diff --git a/sys/dev/drm2/drm_fops.c b/sys/dev/drm2/drm_fops.c index 5d040e92ed12..316d21a8e731 100644 --- a/sys/dev/drm2/drm_fops.c +++ b/sys/dev/drm2/drm_fops.c @@ -1,595 +1,595 @@ /** * \file drm_fops.c * File operations for DRM * * \author Rickard E. (Rik) Faith * \author Daryll Strauss * \author Gareth Hughes */ /* * Created: Mon Jan 4 08:58:31 1999 by faith@valinux.com * * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include #include static int drm_open_helper(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p, struct drm_device *dev); static int drm_setup(struct drm_device * dev) { int i; int ret; if (dev->driver->firstopen) { ret = dev->driver->firstopen(dev); if (ret != 0) return ret; } atomic_set(&dev->ioctl_count, 0); atomic_set(&dev->vma_count, 0); if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) && !drm_core_check_feature(dev, DRIVER_MODESET)) { dev->buf_use = 0; atomic_set(&dev->buf_alloc, 0); i = drm_dma_setup(dev); if (i < 0) return i; } /* * FIXME Linux<->FreeBSD: counter incremented in drm_open() and * reset to 0 here. */ #if 0 for (i = 0; i < ARRAY_SIZE(dev->counts); i++) atomic_set(&dev->counts[i], 0); #endif dev->sigdata.lock = NULL; dev->context_flag = 0; dev->interrupt_flag = 0; dev->dma_flag = 0; dev->last_context = 0; dev->last_switch = 0; dev->last_checked = 0; DRM_INIT_WAITQUEUE(&dev->context_wait); dev->if_version = 0; #ifdef FREEBSD_NOTYET dev->ctx_start = 0; dev->lck_start = 0; dev->buf_async = NULL; DRM_INIT_WAITQUEUE(&dev->buf_readers); DRM_INIT_WAITQUEUE(&dev->buf_writers); #endif /* FREEBSD_NOTYET */ DRM_DEBUG("\n"); /* * The kernel's context could be created here, but is now created * in drm_dma_enqueue. This is more resource-efficient for * hardware that does not do DMA, but may mean that * drm_select_queue fails between the time the interrupt is * initialized and the time the queues are initialized. */ return 0; } /** * Open file. * * \param inode device inode * \param filp file pointer. * \return zero on success or a negative number on failure. * * Searches the DRM device with the same minor number, calls open_helper(), and * increments the device open count. If the open count was previous at zero, * i.e., it's the first that the device is open, then calls setup(). */ int drm_open(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p) { struct drm_device *dev = NULL; struct drm_minor *minor; int retcode = 0; int need_setup = 0; minor = kdev->si_drv1; if (!minor) return ENODEV; if (!(dev = minor->dev)) return ENODEV; sx_xlock(&drm_global_mutex); /* * FIXME Linux<->FreeBSD: On Linux, counter updated outside * global mutex. */ if (!dev->open_count++) need_setup = 1; retcode = drm_open_helper(kdev, flags, fmt, p, dev); if (retcode) { sx_xunlock(&drm_global_mutex); return (-retcode); } atomic_inc(&dev->counts[_DRM_STAT_OPENS]); if (need_setup) { retcode = drm_setup(dev); if (retcode) goto err_undo; } sx_xunlock(&drm_global_mutex); return 0; err_undo: device_unbusy(dev->dev); dev->open_count--; sx_xunlock(&drm_global_mutex); return -retcode; } EXPORT_SYMBOL(drm_open); /** * Called whenever a process opens /dev/drm. * * \param inode device inode. * \param filp file pointer. * \param dev device. * \return zero on success or a negative number on failure. * * Creates and initializes a drm_file structure for the file private data in \p * filp and add it into the double linked list in \p dev. */ static int drm_open_helper(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p, struct drm_device *dev) { struct drm_file *priv; int ret; if (flags & O_EXCL) return -EBUSY; /* No exclusive opens */ if (dev->switch_power_state != DRM_SWITCH_POWER_ON) return -EINVAL; DRM_DEBUG("pid = %d, device = %s\n", DRM_CURRENTPID, devtoname(kdev)); priv = malloc(sizeof(*priv), DRM_MEM_FILES, M_NOWAIT | M_ZERO); if (!priv) return -ENOMEM; priv->uid = p->td_ucred->cr_svuid; priv->pid = p->td_proc->p_pid; priv->minor = kdev->si_drv1; priv->ioctl_count = 0; /* for compatibility root is always authenticated */ priv->authenticated = DRM_SUSER(p); priv->lock_count = 0; INIT_LIST_HEAD(&priv->lhead); INIT_LIST_HEAD(&priv->fbs); INIT_LIST_HEAD(&priv->event_list); priv->event_space = 4096; /* set aside 4k for event buffer */ if (dev->driver->driver_features & DRIVER_GEM) drm_gem_open(dev, priv); #ifdef FREEBSD_NOTYET if (drm_core_check_feature(dev, DRIVER_PRIME)) drm_prime_init_file_private(&priv->prime); #endif /* FREEBSD_NOTYET */ if (dev->driver->open) { ret = dev->driver->open(dev, priv); if (ret < 0) goto out_free; } /* if there is no current master make this fd it */ DRM_LOCK(dev); if (!priv->minor->master) { /* create a new master */ priv->minor->master = drm_master_create(priv->minor); if (!priv->minor->master) { DRM_UNLOCK(dev); ret = -ENOMEM; goto out_free; } priv->is_master = 1; /* take another reference for the copy in the local file priv */ priv->master = drm_master_get(priv->minor->master); priv->authenticated = 1; DRM_UNLOCK(dev); if (dev->driver->master_create) { ret = dev->driver->master_create(dev, priv->master); if (ret) { DRM_LOCK(dev); /* drop both references if this fails */ drm_master_put(&priv->minor->master); drm_master_put(&priv->master); DRM_UNLOCK(dev); goto out_free; } } DRM_LOCK(dev); if (dev->driver->master_set) { ret = dev->driver->master_set(dev, priv, true); if (ret) { /* drop both references if this fails */ drm_master_put(&priv->minor->master); drm_master_put(&priv->master); DRM_UNLOCK(dev); goto out_free; } } DRM_UNLOCK(dev); } else { /* get a reference to the master */ priv->master = drm_master_get(priv->minor->master); DRM_UNLOCK(dev); } DRM_LOCK(dev); list_add(&priv->lhead, &dev->filelist); DRM_UNLOCK(dev); device_busy(dev->dev); ret = devfs_set_cdevpriv(priv, drm_release); if (ret != 0) drm_release(priv); return ret; out_free: free(priv, DRM_MEM_FILES); return ret; } static void drm_master_release(struct drm_device *dev, struct drm_file *file_priv) { if (drm_i_have_hw_lock(dev, file_priv)) { DRM_DEBUG("File %p released, freeing lock for context %d\n", file_priv, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock)); drm_lock_free(&file_priv->master->lock, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock)); } } static void drm_events_release(struct drm_file *file_priv) { struct drm_device *dev = file_priv->minor->dev; struct drm_pending_event *e, *et; struct drm_pending_vblank_event *v, *vt; unsigned long flags; DRM_SPINLOCK_IRQSAVE(&dev->event_lock, flags); /* Remove pending flips */ list_for_each_entry_safe(v, vt, &dev->vblank_event_list, base.link) if (v->base.file_priv == file_priv) { list_del(&v->base.link); drm_vblank_put(dev, v->pipe); v->base.destroy(&v->base); } /* Remove unconsumed events */ list_for_each_entry_safe(e, et, &file_priv->event_list, link) e->destroy(e); DRM_SPINUNLOCK_IRQRESTORE(&dev->event_lock, flags); } /** * Release file. * * \param inode device inode * \param file_priv DRM file private. * \return zero on success or a negative number on failure. * * If the hardware lock is held then free it, and take it again for the kernel * context since it's necessary to reclaim buffers. Unlink the file private * data from its list and free it. Decreases the open count and if it reaches * zero calls drm_lastclose(). */ void drm_release(void *data) { struct drm_file *file_priv = data; struct drm_device *dev = file_priv->minor->dev; sx_xlock(&drm_global_mutex); DRM_DEBUG("open_count = %d\n", dev->open_count); if (dev->driver->preclose) dev->driver->preclose(dev, file_priv); /* ======================================================== * Begin inline drm_release */ DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n", DRM_CURRENTPID, (long)file_priv->minor->device, dev->open_count); /* Release any auth tokens that might point to this file_priv, (do that under the drm_global_mutex) */ if (file_priv->magic) (void) drm_remove_magic(file_priv->master, file_priv->magic); /* if the master has gone away we can't do anything with the lock */ if (file_priv->minor->master) drm_master_release(dev, file_priv); if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) drm_core_reclaim_buffers(dev, file_priv); drm_events_release(file_priv); seldrain(&file_priv->event_poll); if (dev->driver->driver_features & DRIVER_MODESET) drm_fb_release(file_priv); if (dev->driver->driver_features & DRIVER_GEM) drm_gem_release(dev, file_priv); #ifdef FREEBSD_NOTYET mutex_lock(&dev->ctxlist_mutex); if (!list_empty(&dev->ctxlist)) { struct drm_ctx_list *pos, *n; list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { if (pos->tag == file_priv && pos->handle != DRM_KERNEL_CONTEXT) { if (dev->driver->context_dtor) dev->driver->context_dtor(dev, pos->handle); drm_ctxbitmap_free(dev, pos->handle); list_del(&pos->head); kfree(pos); --dev->ctx_count; } } } mutex_unlock(&dev->ctxlist_mutex); #endif /* FREEBSD_NOTYET */ DRM_LOCK(dev); if (file_priv->is_master) { struct drm_master *master = file_priv->master; struct drm_file *temp; list_for_each_entry(temp, &dev->filelist, lhead) { if ((temp->master == file_priv->master) && (temp != file_priv)) temp->authenticated = 0; } /** * Since the master is disappearing, so is the * possibility to lock. */ if (master->lock.hw_lock) { if (dev->sigdata.lock == master->lock.hw_lock) dev->sigdata.lock = NULL; master->lock.hw_lock = NULL; master->lock.file_priv = NULL; DRM_WAKEUP_INT(&master->lock.lock_queue); } if (file_priv->minor->master == file_priv->master) { /* drop the reference held my the minor */ if (dev->driver->master_drop) dev->driver->master_drop(dev, file_priv, true); drm_master_put(&file_priv->minor->master); } } /* drop the reference held my the file priv */ drm_master_put(&file_priv->master); file_priv->is_master = 0; list_del(&file_priv->lhead); DRM_UNLOCK(dev); if (dev->driver->postclose) dev->driver->postclose(dev, file_priv); #ifdef FREEBSD_NOTYET if (drm_core_check_feature(dev, DRIVER_PRIME)) drm_prime_destroy_file_private(&file_priv->prime); #endif /* FREEBSD_NOTYET */ free(file_priv, DRM_MEM_FILES); /* ======================================================== * End inline drm_release */ atomic_inc(&dev->counts[_DRM_STAT_CLOSES]); device_unbusy(dev->dev); if (!--dev->open_count) { if (atomic_read(&dev->ioctl_count)) { DRM_ERROR("Device busy: %d\n", atomic_read(&dev->ioctl_count)); } else drm_lastclose(dev); } sx_xunlock(&drm_global_mutex); } EXPORT_SYMBOL(drm_release); static bool drm_dequeue_event(struct drm_file *file_priv, struct uio *uio, struct drm_pending_event **out) { struct drm_pending_event *e; bool ret = false; /* Already locked in drm_read(). */ /* DRM_SPINLOCK_IRQSAVE(&dev->event_lock, flags); */ *out = NULL; if (list_empty(&file_priv->event_list)) goto out; e = list_first_entry(&file_priv->event_list, struct drm_pending_event, link); if (e->event->length > uio->uio_resid) goto out; file_priv->event_space += e->event->length; list_del(&e->link); *out = e; ret = true; out: /* DRM_SPINUNLOCK_IRQRESTORE(&dev->event_lock, flags); */ return ret; } int drm_read(struct cdev *kdev, struct uio *uio, int ioflag) { struct drm_file *file_priv; struct drm_device *dev; struct drm_pending_event *e; ssize_t error; error = devfs_get_cdevpriv((void **)&file_priv); if (error != 0) { DRM_ERROR("can't find authenticator\n"); return (EINVAL); } dev = drm_get_device_from_kdev(kdev); mtx_lock(&dev->event_lock); while (list_empty(&file_priv->event_list)) { if ((ioflag & O_NONBLOCK) != 0) { error = EAGAIN; goto out; } error = msleep(&file_priv->event_space, &dev->event_lock, PCATCH, "drmrea", 0); if (error != 0) goto out; } while (drm_dequeue_event(file_priv, uio, &e)) { mtx_unlock(&dev->event_lock); error = uiomove(e->event, e->event->length, uio); CTR3(KTR_DRM, "drm_event_dequeued %d %d %d", curproc->p_pid, e->event->type, e->event->length); e->destroy(e); if (error != 0) return (error); mtx_lock(&dev->event_lock); } out: mtx_unlock(&dev->event_lock); return (error); } EXPORT_SYMBOL(drm_read); void drm_event_wakeup(struct drm_pending_event *e) { struct drm_file *file_priv; - struct drm_device *dev; + struct drm_device *dev __diagused; file_priv = e->file_priv; dev = file_priv->minor->dev; mtx_assert(&dev->event_lock, MA_OWNED); wakeup(&file_priv->event_space); selwakeup(&file_priv->event_poll); } int drm_poll(struct cdev *kdev, int events, struct thread *td) { struct drm_file *file_priv; struct drm_device *dev; int error, revents; error = devfs_get_cdevpriv((void **)&file_priv); if (error != 0) { DRM_ERROR("can't find authenticator\n"); return (EINVAL); } dev = drm_get_device_from_kdev(kdev); revents = 0; mtx_lock(&dev->event_lock); if ((events & (POLLIN | POLLRDNORM)) != 0) { if (list_empty(&file_priv->event_list)) { CTR0(KTR_DRM, "drm_poll empty list"); selrecord(td, &file_priv->event_poll); } else { revents |= events & (POLLIN | POLLRDNORM); CTR1(KTR_DRM, "drm_poll revents %x", revents); } } mtx_unlock(&dev->event_lock); return (revents); } EXPORT_SYMBOL(drm_poll); int drm_mmap_single(struct cdev *kdev, vm_ooffset_t *offset, vm_size_t size, struct vm_object **obj_res, int nprot) { struct drm_device *dev; dev = drm_get_device_from_kdev(kdev); if (dev->drm_ttm_bdev != NULL) { return (-ttm_bo_mmap_single(dev->drm_ttm_bdev, offset, size, obj_res, nprot)); } else if ((dev->driver->driver_features & DRIVER_GEM) != 0) { return (-drm_gem_mmap_single(dev, offset, size, obj_res, nprot)); } else { return (ENODEV); } } diff --git a/sys/dev/drm2/ttm/ttm_lock.c b/sys/dev/drm2/ttm/ttm_lock.c index 9a8cafbf2abc..1884acb12118 100644 --- a/sys/dev/drm2/ttm/ttm_lock.c +++ b/sys/dev/drm2/ttm/ttm_lock.c @@ -1,346 +1,346 @@ /************************************************************************** * * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE * USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ /* * Authors: Thomas Hellstrom */ /* * Copyright (c) 2013 The FreeBSD Foundation * All rights reserved. * * Portions of this software were developed by Konstantin Belousov * under sponsorship from the FreeBSD Foundation. */ #include #include #include #define TTM_WRITE_LOCK_PENDING (1 << 0) #define TTM_VT_LOCK_PENDING (1 << 1) #define TTM_SUSPEND_LOCK_PENDING (1 << 2) #define TTM_VT_LOCK (1 << 3) #define TTM_SUSPEND_LOCK (1 << 4) void ttm_lock_init(struct ttm_lock *lock) { mtx_init(&lock->lock, "ttmlk", NULL, MTX_DEF); lock->rw = 0; lock->flags = 0; lock->kill_takers = false; lock->signal = SIGKILL; } static void ttm_lock_send_sig(int signo) { struct proc *p; p = curproc; /* XXXKIB curthread ? */ PROC_LOCK(p); kern_psignal(p, signo); PROC_UNLOCK(p); } void ttm_read_unlock(struct ttm_lock *lock) { mtx_lock(&lock->lock); if (--lock->rw == 0) wakeup(lock); mtx_unlock(&lock->lock); } static bool __ttm_read_lock(struct ttm_lock *lock) { bool locked = false; if (unlikely(lock->kill_takers)) { ttm_lock_send_sig(lock->signal); return false; } if (lock->rw >= 0 && lock->flags == 0) { ++lock->rw; locked = true; } return locked; } int ttm_read_lock(struct ttm_lock *lock, bool interruptible) { const char *wmsg; int flags, ret; ret = 0; if (interruptible) { flags = PCATCH; wmsg = "ttmri"; } else { flags = 0; wmsg = "ttmr"; } mtx_lock(&lock->lock); while (!__ttm_read_lock(lock)) { ret = -msleep(lock, &lock->lock, flags, wmsg, 0); if (ret == -EINTR || ret == -ERESTART) ret = -ERESTARTSYS; if (ret != 0) break; } return (ret); } static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked) { bool block = true; *locked = false; if (unlikely(lock->kill_takers)) { ttm_lock_send_sig(lock->signal); return false; } if (lock->rw >= 0 && lock->flags == 0) { ++lock->rw; block = false; *locked = true; } else if (lock->flags == 0) { block = false; } return !block; } int ttm_read_trylock(struct ttm_lock *lock, bool interruptible) { const char *wmsg; int flags, ret; bool locked; ret = 0; if (interruptible) { flags = PCATCH; wmsg = "ttmrti"; } else { flags = 0; wmsg = "ttmrt"; } mtx_lock(&lock->lock); while (!__ttm_read_trylock(lock, &locked)) { ret = -msleep(lock, &lock->lock, flags, wmsg, 0); if (ret == -EINTR || ret == -ERESTART) ret = -ERESTARTSYS; if (ret != 0) break; } MPASS(!locked || ret == 0); mtx_unlock(&lock->lock); return (locked) ? 0 : -EBUSY; } void ttm_write_unlock(struct ttm_lock *lock) { mtx_lock(&lock->lock); lock->rw = 0; wakeup(lock); mtx_unlock(&lock->lock); } static bool __ttm_write_lock(struct ttm_lock *lock) { bool locked = false; if (unlikely(lock->kill_takers)) { ttm_lock_send_sig(lock->signal); return false; } if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) == 0)) { lock->rw = -1; lock->flags &= ~TTM_WRITE_LOCK_PENDING; locked = true; } else { lock->flags |= TTM_WRITE_LOCK_PENDING; } return locked; } int ttm_write_lock(struct ttm_lock *lock, bool interruptible) { const char *wmsg; int flags, ret; ret = 0; if (interruptible) { flags = PCATCH; wmsg = "ttmwi"; } else { flags = 0; wmsg = "ttmw"; } mtx_lock(&lock->lock); /* XXXKIB: linux uses __ttm_read_lock for uninterruptible sleeps */ while (!__ttm_write_lock(lock)) { ret = -msleep(lock, &lock->lock, flags, wmsg, 0); if (ret == -EINTR || ret == -ERESTART) ret = -ERESTARTSYS; if (interruptible && ret != 0) { lock->flags &= ~TTM_WRITE_LOCK_PENDING; wakeup(lock); break; } } mtx_unlock(&lock->lock); return (ret); } void ttm_write_lock_downgrade(struct ttm_lock *lock) { mtx_lock(&lock->lock); lock->rw = 1; wakeup(lock); mtx_unlock(&lock->lock); } static int __ttm_vt_unlock(struct ttm_lock *lock) { int ret = 0; mtx_lock(&lock->lock); if (unlikely(!(lock->flags & TTM_VT_LOCK))) ret = -EINVAL; lock->flags &= ~TTM_VT_LOCK; wakeup(lock); mtx_unlock(&lock->lock); return ret; } static void ttm_vt_lock_remove(struct ttm_base_object **p_base) { struct ttm_base_object *base = *p_base; struct ttm_lock *lock = container_of(base, struct ttm_lock, base); - int ret; + int ret __diagused; *p_base = NULL; ret = __ttm_vt_unlock(lock); MPASS(ret == 0); } static bool __ttm_vt_lock(struct ttm_lock *lock) { bool locked = false; if (lock->rw == 0) { lock->flags &= ~TTM_VT_LOCK_PENDING; lock->flags |= TTM_VT_LOCK; locked = true; } else { lock->flags |= TTM_VT_LOCK_PENDING; } return locked; } int ttm_vt_lock(struct ttm_lock *lock, bool interruptible, struct ttm_object_file *tfile) { const char *wmsg; int flags, ret; ret = 0; if (interruptible) { flags = PCATCH; wmsg = "ttmwi"; } else { flags = 0; wmsg = "ttmw"; } mtx_lock(&lock->lock); while (!__ttm_vt_lock(lock)) { ret = -msleep(lock, &lock->lock, flags, wmsg, 0); if (ret == -EINTR || ret == -ERESTART) ret = -ERESTARTSYS; if (interruptible && ret != 0) { lock->flags &= ~TTM_VT_LOCK_PENDING; wakeup(lock); break; } } /* * Add a base-object, the destructor of which will * make sure the lock is released if the client dies * while holding it. */ ret = ttm_base_object_init(tfile, &lock->base, false, ttm_lock_type, &ttm_vt_lock_remove, NULL); if (ret) (void)__ttm_vt_unlock(lock); else lock->vt_holder = tfile; return (ret); } int ttm_vt_unlock(struct ttm_lock *lock) { return ttm_ref_object_base_unref(lock->vt_holder, lock->base.hash.key, TTM_REF_USAGE); } void ttm_suspend_unlock(struct ttm_lock *lock) { mtx_lock(&lock->lock); lock->flags &= ~TTM_SUSPEND_LOCK; wakeup(lock); mtx_unlock(&lock->lock); } static bool __ttm_suspend_lock(struct ttm_lock *lock) { bool locked = false; if (lock->rw == 0) { lock->flags &= ~TTM_SUSPEND_LOCK_PENDING; lock->flags |= TTM_SUSPEND_LOCK; locked = true; } else { lock->flags |= TTM_SUSPEND_LOCK_PENDING; } return locked; } void ttm_suspend_lock(struct ttm_lock *lock) { mtx_lock(&lock->lock); while (!__ttm_suspend_lock(lock)) msleep(lock, &lock->lock, 0, "ttms", 0); mtx_unlock(&lock->lock); } diff --git a/sys/dev/drm2/ttm/ttm_tt.c b/sys/dev/drm2/ttm/ttm_tt.c index 55131c73bdc3..d52df50adeb3 100644 --- a/sys/dev/drm2/ttm/ttm_tt.c +++ b/sys/dev/drm2/ttm/ttm_tt.c @@ -1,357 +1,357 @@ /************************************************************************** * * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE * USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ /* * Authors: Thomas Hellstrom */ /* * Copyright (c) 2013 The FreeBSD Foundation * All rights reserved. * * Portions of this software were developed by Konstantin Belousov * under sponsorship from the FreeBSD Foundation. */ #include #include #include #include #include #include MALLOC_DEFINE(M_TTM_PD, "ttm_pd", "TTM Page Directories"); /** * Allocates storage for pointers to the pages that back the ttm. */ static void ttm_tt_alloc_page_directory(struct ttm_tt *ttm) { ttm->pages = malloc(ttm->num_pages * sizeof(void *), M_TTM_PD, M_WAITOK | M_ZERO); } static void ttm_dma_tt_alloc_page_directory(struct ttm_dma_tt *ttm) { ttm->ttm.pages = malloc(ttm->ttm.num_pages * sizeof(void *), M_TTM_PD, M_WAITOK | M_ZERO); ttm->dma_address = malloc(ttm->ttm.num_pages * sizeof(*ttm->dma_address), M_TTM_PD, M_WAITOK); } #if defined(__i386__) || defined(__amd64__) static inline int ttm_tt_set_page_caching(vm_page_t p, enum ttm_caching_state c_old, enum ttm_caching_state c_new) { /* XXXKIB our VM does not need this. */ #if 0 if (c_old != tt_cached) { /* p isn't in the default caching state, set it to * writeback first to free its current memtype. */ pmap_page_set_memattr(p, VM_MEMATTR_WRITE_BACK); } #endif if (c_new == tt_wc) pmap_page_set_memattr(p, VM_MEMATTR_WRITE_COMBINING); else if (c_new == tt_uncached) pmap_page_set_memattr(p, VM_MEMATTR_UNCACHEABLE); return (0); } #else static inline int ttm_tt_set_page_caching(vm_page_t p, enum ttm_caching_state c_old, enum ttm_caching_state c_new) { return 0; } #endif /* * Change caching policy for the linear kernel map * for range of pages in a ttm. */ static int ttm_tt_set_caching(struct ttm_tt *ttm, enum ttm_caching_state c_state) { int i, j; vm_page_t cur_page; int ret; if (ttm->caching_state == c_state) return 0; if (ttm->state == tt_unpopulated) { /* Change caching but don't populate */ ttm->caching_state = c_state; return 0; } if (ttm->caching_state == tt_cached) drm_clflush_pages(ttm->pages, ttm->num_pages); for (i = 0; i < ttm->num_pages; ++i) { cur_page = ttm->pages[i]; if (likely(cur_page != NULL)) { ret = ttm_tt_set_page_caching(cur_page, ttm->caching_state, c_state); if (unlikely(ret != 0)) goto out_err; } } ttm->caching_state = c_state; return 0; out_err: for (j = 0; j < i; ++j) { cur_page = ttm->pages[j]; if (cur_page != NULL) { (void)ttm_tt_set_page_caching(cur_page, c_state, ttm->caching_state); } } return ret; } int ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement) { enum ttm_caching_state state; if (placement & TTM_PL_FLAG_WC) state = tt_wc; else if (placement & TTM_PL_FLAG_UNCACHED) state = tt_uncached; else state = tt_cached; return ttm_tt_set_caching(ttm, state); } void ttm_tt_destroy(struct ttm_tt *ttm) { if (unlikely(ttm == NULL)) return; if (ttm->state == tt_bound) { ttm_tt_unbind(ttm); } if (likely(ttm->pages != NULL)) { ttm->bdev->driver->ttm_tt_unpopulate(ttm); } if (!(ttm->page_flags & TTM_PAGE_FLAG_PERSISTENT_SWAP) && ttm->swap_storage) vm_object_deallocate(ttm->swap_storage); ttm->swap_storage = NULL; ttm->func->destroy(ttm); } int ttm_tt_init(struct ttm_tt *ttm, struct ttm_bo_device *bdev, unsigned long size, uint32_t page_flags, vm_page_t dummy_read_page) { ttm->bdev = bdev; ttm->glob = bdev->glob; ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; ttm->caching_state = tt_cached; ttm->page_flags = page_flags; ttm->dummy_read_page = dummy_read_page; ttm->state = tt_unpopulated; ttm->swap_storage = NULL; ttm_tt_alloc_page_directory(ttm); if (!ttm->pages) { ttm_tt_destroy(ttm); printf("Failed allocating page table\n"); return -ENOMEM; } return 0; } void ttm_tt_fini(struct ttm_tt *ttm) { free(ttm->pages, M_TTM_PD); ttm->pages = NULL; } int ttm_dma_tt_init(struct ttm_dma_tt *ttm_dma, struct ttm_bo_device *bdev, unsigned long size, uint32_t page_flags, vm_page_t dummy_read_page) { struct ttm_tt *ttm = &ttm_dma->ttm; ttm->bdev = bdev; ttm->glob = bdev->glob; ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; ttm->caching_state = tt_cached; ttm->page_flags = page_flags; ttm->dummy_read_page = dummy_read_page; ttm->state = tt_unpopulated; ttm->swap_storage = NULL; INIT_LIST_HEAD(&ttm_dma->pages_list); ttm_dma_tt_alloc_page_directory(ttm_dma); if (!ttm->pages || !ttm_dma->dma_address) { ttm_tt_destroy(ttm); printf("Failed allocating page table\n"); return -ENOMEM; } return 0; } void ttm_dma_tt_fini(struct ttm_dma_tt *ttm_dma) { struct ttm_tt *ttm = &ttm_dma->ttm; free(ttm->pages, M_TTM_PD); ttm->pages = NULL; free(ttm_dma->dma_address, M_TTM_PD); ttm_dma->dma_address = NULL; } void ttm_tt_unbind(struct ttm_tt *ttm) { - int ret; + int ret __diagused; if (ttm->state == tt_bound) { ret = ttm->func->unbind(ttm); MPASS(ret == 0); ttm->state = tt_unbound; } } int ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem) { int ret = 0; if (!ttm) return -EINVAL; if (ttm->state == tt_bound) return 0; ret = ttm->bdev->driver->ttm_tt_populate(ttm); if (ret) return ret; ret = ttm->func->bind(ttm, bo_mem); if (unlikely(ret != 0)) return ret; ttm->state = tt_bound; return 0; } int ttm_tt_swapin(struct ttm_tt *ttm) { vm_object_t obj; vm_page_t from_page, to_page; int i, ret, rv; obj = ttm->swap_storage; vm_object_pip_add(obj, 1); for (i = 0; i < ttm->num_pages; ++i) { rv = vm_page_grab_valid_unlocked(&from_page, obj, i, VM_ALLOC_NORMAL | VM_ALLOC_SBUSY | VM_ALLOC_IGN_SBUSY); if (rv != VM_PAGER_OK) { ret = -EIO; goto err_ret; } to_page = ttm->pages[i]; if (unlikely(to_page == NULL)) { vm_page_sunbusy(from_page); ret = -ENOMEM; goto err_ret; } pmap_copy_page(from_page, to_page); vm_page_sunbusy(from_page); } vm_object_pip_wakeup(obj); if (!(ttm->page_flags & TTM_PAGE_FLAG_PERSISTENT_SWAP)) vm_object_deallocate(obj); ttm->swap_storage = NULL; ttm->page_flags &= ~TTM_PAGE_FLAG_SWAPPED; return (0); err_ret: vm_object_pip_wakeup(obj); return (ret); } int ttm_tt_swapout(struct ttm_tt *ttm, vm_object_t persistent_swap_storage) { vm_object_t obj; vm_page_t from_page, to_page; int i; MPASS(ttm->state == tt_unbound || ttm->state == tt_unpopulated); MPASS(ttm->caching_state == tt_cached); if (persistent_swap_storage == NULL) { obj = vm_pager_allocate(OBJT_SWAP, NULL, IDX_TO_OFF(ttm->num_pages), VM_PROT_DEFAULT, 0, curthread->td_ucred); if (obj == NULL) { printf("[TTM] Failed allocating swap storage\n"); return (-ENOMEM); } } else obj = persistent_swap_storage; VM_OBJECT_WLOCK(obj); vm_object_pip_add(obj, 1); for (i = 0; i < ttm->num_pages; ++i) { from_page = ttm->pages[i]; if (unlikely(from_page == NULL)) continue; to_page = vm_page_grab(obj, i, VM_ALLOC_NORMAL); pmap_copy_page(from_page, to_page); vm_page_valid(to_page); vm_page_dirty(to_page); vm_page_xunbusy(to_page); } vm_object_pip_wakeup(obj); VM_OBJECT_WUNLOCK(obj); ttm->bdev->driver->ttm_tt_unpopulate(ttm); ttm->swap_storage = obj; ttm->page_flags |= TTM_PAGE_FLAG_SWAPPED; if (persistent_swap_storage != NULL) ttm->page_flags |= TTM_PAGE_FLAG_PERSISTENT_SWAP; return (0); }