2008-07-30 19:06:12 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2008 Intel Corporation
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS 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:
|
|
|
|
* Eric Anholt <eric@anholt.net>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "drmP.h"
|
|
|
|
#include "drm.h"
|
|
|
|
#include "i915_drm.h"
|
|
|
|
#include "i915_drv.h"
|
2009-08-25 10:15:50 +00:00
|
|
|
#include "i915_trace.h"
|
2009-08-17 20:31:43 +00:00
|
|
|
#include "intel_drv.h"
|
2011-06-27 23:18:18 +00:00
|
|
|
#include <linux/shmem_fs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-07-30 19:06:12 +00:00
|
|
|
#include <linux/swap.h>
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
#include <linux/pci.h>
|
2012-05-10 13:25:09 +00:00
|
|
|
#include <linux/dma-buf.h>
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
static void i915_gem_object_flush_gtt_write_domain(struct drm_i915_gem_object *obj);
|
|
|
|
static void i915_gem_object_flush_cpu_write_domain(struct drm_i915_gem_object *obj);
|
2011-01-07 17:09:48 +00:00
|
|
|
static __must_check int i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
|
|
|
|
unsigned alignment,
|
2012-08-11 14:41:04 +00:00
|
|
|
bool map_and_fenceable,
|
|
|
|
bool nonblocking);
|
2010-11-08 19:18:58 +00:00
|
|
|
static int i915_gem_phys_pwrite(struct drm_device *dev,
|
|
|
|
struct drm_i915_gem_object *obj,
|
2008-12-30 10:31:46 +00:00
|
|
|
struct drm_i915_gem_pwrite *args,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-04-17 14:31:31 +00:00
|
|
|
static void i915_gem_write_fence(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj);
|
|
|
|
static void i915_gem_object_update_fence(struct drm_i915_gem_object *obj,
|
|
|
|
struct drm_i915_fence_reg *fence,
|
|
|
|
bool enable);
|
|
|
|
|
2010-10-28 11:51:39 +00:00
|
|
|
static int i915_gem_inactive_shrink(struct shrinker *shrinker,
|
2011-05-25 00:12:27 +00:00
|
|
|
struct shrink_control *sc);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
static long i915_gem_purge(struct drm_i915_private *dev_priv, long target);
|
|
|
|
static void i915_gem_shrink_all(struct drm_i915_private *dev_priv);
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
static void i915_gem_object_truncate(struct drm_i915_gem_object *obj);
|
2009-09-14 15:50:28 +00:00
|
|
|
|
2012-04-17 14:31:31 +00:00
|
|
|
static inline void i915_gem_object_fence_lost(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
if (obj->tiling_mode)
|
|
|
|
i915_gem_release_mmap(obj);
|
|
|
|
|
|
|
|
/* As we do not have an associated fence register, we will force
|
|
|
|
* a tiling change if we ever need to acquire one.
|
|
|
|
*/
|
2012-04-21 15:23:23 +00:00
|
|
|
obj->fence_dirty = false;
|
2012-04-17 14:31:31 +00:00
|
|
|
obj->fence_reg = I915_FENCE_REG_NONE;
|
|
|
|
}
|
|
|
|
|
2010-09-30 10:46:12 +00:00
|
|
|
/* some bookkeeping */
|
|
|
|
static void i915_gem_info_add_obj(struct drm_i915_private *dev_priv,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
dev_priv->mm.object_count++;
|
|
|
|
dev_priv->mm.object_memory += size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_gem_info_remove_obj(struct drm_i915_private *dev_priv,
|
|
|
|
size_t size)
|
|
|
|
{
|
|
|
|
dev_priv->mm.object_count--;
|
|
|
|
dev_priv->mm.object_memory -= size;
|
|
|
|
}
|
|
|
|
|
2011-01-26 15:55:56 +00:00
|
|
|
static int
|
|
|
|
i915_gem_wait_for_error(struct drm_device *dev)
|
2010-09-25 09:19:17 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct completion *x = &dev_priv->error_completion;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!atomic_read(&dev_priv->mm.wedged))
|
|
|
|
return 0;
|
|
|
|
|
2012-07-04 20:18:41 +00:00
|
|
|
/*
|
|
|
|
* Only wait 10 seconds for the gpu reset to complete to avoid hanging
|
|
|
|
* userspace. If it takes that long something really bad is going on and
|
|
|
|
* we should simply try to bail out and fail as gracefully as possible.
|
|
|
|
*/
|
|
|
|
ret = wait_for_completion_interruptible_timeout(x, 10*HZ);
|
|
|
|
if (ret == 0) {
|
|
|
|
DRM_ERROR("Timed out waiting for the gpu reset to complete\n");
|
|
|
|
return -EIO;
|
|
|
|
} else if (ret < 0) {
|
2010-09-25 09:19:17 +00:00
|
|
|
return ret;
|
2012-07-04 20:18:41 +00:00
|
|
|
}
|
2010-09-25 09:19:17 +00:00
|
|
|
|
2011-01-26 15:55:56 +00:00
|
|
|
if (atomic_read(&dev_priv->mm.wedged)) {
|
|
|
|
/* GPU is hung, bump the completion count to account for
|
|
|
|
* the token we just consumed so that we never hit zero and
|
|
|
|
* end up waiting upon a subsequent completion event that
|
|
|
|
* will never happen.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
|
|
|
x->done++;
|
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
|
|
|
}
|
|
|
|
return 0;
|
2010-09-25 09:19:17 +00:00
|
|
|
}
|
|
|
|
|
2010-11-25 18:00:26 +00:00
|
|
|
int i915_mutex_lock_interruptible(struct drm_device *dev)
|
2010-09-25 10:22:51 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2011-01-26 15:55:56 +00:00
|
|
|
ret = i915_gem_wait_for_error(dev);
|
2010-09-25 10:22:51 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&dev->struct_mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2010-09-29 15:10:57 +00:00
|
|
|
WARN_ON(i915_verify_lists(dev));
|
2010-09-25 10:22:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-09-25 09:19:17 +00:00
|
|
|
|
2010-08-07 20:45:03 +00:00
|
|
|
static inline bool
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_is_inactive(struct drm_i915_gem_object *obj)
|
2010-08-07 20:45:03 +00:00
|
|
|
{
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
return obj->gtt_space && !obj->active;
|
2010-08-07 20:45:03 +00:00
|
|
|
}
|
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
int
|
|
|
|
i915_gem_init_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_init *args = data;
|
2010-11-23 15:26:33 +00:00
|
|
|
|
2012-04-24 06:22:52 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-11-23 15:26:33 +00:00
|
|
|
if (args->gtt_start >= args->gtt_end ||
|
|
|
|
(args->gtt_end | args->gtt_start) & (PAGE_SIZE - 1))
|
|
|
|
return -EINVAL;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
|
2012-03-26 20:37:04 +00:00
|
|
|
/* GEM with user mode setting was never supported on ilk and later. */
|
|
|
|
if (INTEL_INFO(dev)->gen >= 5)
|
|
|
|
return -ENODEV;
|
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2012-03-26 07:45:40 +00:00
|
|
|
i915_gem_init_global_gtt(dev, args->gtt_start,
|
|
|
|
args->gtt_end, args->gtt_end);
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2010-11-23 15:26:33 +00:00
|
|
|
return 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2008-10-23 04:40:13 +00:00
|
|
|
int
|
|
|
|
i915_gem_get_aperture_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-10-23 04:40:13 +00:00
|
|
|
{
|
2010-09-30 10:46:12 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2008-10-23 04:40:13 +00:00
|
|
|
struct drm_i915_gem_get_aperture *args = data;
|
2010-11-24 12:23:44 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
size_t pinned;
|
2008-10-23 04:40:13 +00:00
|
|
|
|
2010-11-24 12:23:44 +00:00
|
|
|
pinned = 0;
|
2010-09-30 10:46:12 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, gtt_list)
|
2012-04-24 14:47:30 +00:00
|
|
|
if (obj->pin_count)
|
|
|
|
pinned += obj->gtt_space->size;
|
2010-09-30 10:46:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2008-10-23 04:40:13 +00:00
|
|
|
|
2010-11-24 12:23:44 +00:00
|
|
|
args->aper_size = dev_priv->mm.gtt_total;
|
2011-08-16 19:34:10 +00:00
|
|
|
args->aper_available_size = args->aper_size - pinned;
|
2010-11-24 12:23:44 +00:00
|
|
|
|
2008-10-23 04:40:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
static int
|
|
|
|
i915_gem_create(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint64_t size,
|
|
|
|
uint32_t *handle_p)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2009-08-23 09:40:55 +00:00
|
|
|
int ret;
|
|
|
|
u32 handle;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
size = roundup(size, PAGE_SIZE);
|
2011-09-14 12:14:28 +00:00
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
/* Allocate the new object */
|
2011-02-07 02:16:14 +00:00
|
|
|
obj = i915_gem_alloc_object(dev, size);
|
2008-07-30 19:06:12 +00:00
|
|
|
if (obj == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
ret = drm_gem_handle_create(file, &obj->base, &handle);
|
2010-09-06 13:44:14 +00:00
|
|
|
if (ret) {
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_release(&obj->base);
|
|
|
|
i915_gem_info_remove_obj(dev->dev_private, obj->base.size);
|
2010-10-14 12:20:40 +00:00
|
|
|
kfree(obj);
|
2008-07-30 19:06:12 +00:00
|
|
|
return ret;
|
2010-09-06 13:44:14 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-10-14 12:20:40 +00:00
|
|
|
/* drop reference from allocate - handle holds it now */
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-14 12:20:40 +00:00
|
|
|
trace_i915_gem_object_create(obj);
|
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
*handle_p = handle;
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
int
|
|
|
|
i915_gem_dumb_create(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args)
|
|
|
|
{
|
|
|
|
/* have to work out size/pitch and return them */
|
2011-03-19 08:21:45 +00:00
|
|
|
args->pitch = ALIGN(args->width * ((args->bpp + 7) / 8), 64);
|
2011-02-07 02:16:14 +00:00
|
|
|
args->size = args->pitch * args->height;
|
|
|
|
return i915_gem_create(file, dev,
|
|
|
|
args->size, &args->handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
int i915_gem_dumb_destroy(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle)
|
|
|
|
{
|
|
|
|
return drm_gem_handle_delete(file, handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new mm object and returns a handle to it.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_create_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_create *args = data;
|
2012-04-23 14:50:50 +00:00
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
return i915_gem_create(file, dev,
|
|
|
|
args->size, &args->handle);
|
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
static int i915_gem_object_needs_bit17_swizzle(struct drm_i915_gem_object *obj)
|
2009-03-12 23:56:27 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_i915_private_t *dev_priv = obj->base.dev->dev_private;
|
2009-03-12 23:56:27 +00:00
|
|
|
|
|
|
|
return dev_priv->mm.bit_6_swizzle_x == I915_BIT_6_SWIZZLE_9_10_17 &&
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->tiling_mode != I915_TILING_NONE;
|
2009-03-12 23:56:27 +00:00
|
|
|
}
|
|
|
|
|
2011-12-14 12:57:32 +00:00
|
|
|
static inline int
|
|
|
|
__copy_to_user_swizzled(char __user *cpu_vaddr,
|
|
|
|
const char *gpu_vaddr, int gpu_offset,
|
|
|
|
int length)
|
|
|
|
{
|
|
|
|
int ret, cpu_offset = 0;
|
|
|
|
|
|
|
|
while (length > 0) {
|
|
|
|
int cacheline_end = ALIGN(gpu_offset + 1, 64);
|
|
|
|
int this_length = min(cacheline_end - gpu_offset, length);
|
|
|
|
int swizzled_gpu_offset = gpu_offset ^ 64;
|
|
|
|
|
|
|
|
ret = __copy_to_user(cpu_vaddr + cpu_offset,
|
|
|
|
gpu_vaddr + swizzled_gpu_offset,
|
|
|
|
this_length);
|
|
|
|
if (ret)
|
|
|
|
return ret + length;
|
|
|
|
|
|
|
|
cpu_offset += this_length;
|
|
|
|
gpu_offset += this_length;
|
|
|
|
length -= this_length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
static inline int
|
2012-04-16 21:07:47 +00:00
|
|
|
__copy_from_user_swizzled(char *gpu_vaddr, int gpu_offset,
|
|
|
|
const char __user *cpu_vaddr,
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
int length)
|
|
|
|
{
|
|
|
|
int ret, cpu_offset = 0;
|
|
|
|
|
|
|
|
while (length > 0) {
|
|
|
|
int cacheline_end = ALIGN(gpu_offset + 1, 64);
|
|
|
|
int this_length = min(cacheline_end - gpu_offset, length);
|
|
|
|
int swizzled_gpu_offset = gpu_offset ^ 64;
|
|
|
|
|
|
|
|
ret = __copy_from_user(gpu_vaddr + swizzled_gpu_offset,
|
|
|
|
cpu_vaddr + cpu_offset,
|
|
|
|
this_length);
|
|
|
|
if (ret)
|
|
|
|
return ret + length;
|
|
|
|
|
|
|
|
cpu_offset += this_length;
|
|
|
|
gpu_offset += this_length;
|
|
|
|
length -= this_length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
/* Per-page copy function for the shmem pread fastpath.
|
|
|
|
* Flushes invalid cachelines before reading the target if
|
|
|
|
* needs_clflush is set. */
|
2009-03-10 18:44:52 +00:00
|
|
|
static int
|
2012-03-25 17:47:40 +00:00
|
|
|
shmem_pread_fast(struct page *page, int shmem_page_offset, int page_length,
|
|
|
|
char __user *user_data,
|
|
|
|
bool page_do_bit17_swizzling, bool needs_clflush)
|
|
|
|
{
|
|
|
|
char *vaddr;
|
|
|
|
int ret;
|
|
|
|
|
2012-03-25 17:47:43 +00:00
|
|
|
if (unlikely(page_do_bit17_swizzling))
|
2012-03-25 17:47:40 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
vaddr = kmap_atomic(page);
|
|
|
|
if (needs_clflush)
|
|
|
|
drm_clflush_virt_range(vaddr + shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
ret = __copy_to_user_inatomic(user_data,
|
|
|
|
vaddr + shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
kunmap_atomic(vaddr);
|
|
|
|
|
2012-09-04 20:02:56 +00:00
|
|
|
return ret ? -EFAULT : 0;
|
2012-03-25 17:47:40 +00:00
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:42 +00:00
|
|
|
static void
|
|
|
|
shmem_clflush_swizzled_range(char *addr, unsigned long length,
|
|
|
|
bool swizzled)
|
|
|
|
{
|
2012-03-25 17:47:43 +00:00
|
|
|
if (unlikely(swizzled)) {
|
2012-03-25 17:47:42 +00:00
|
|
|
unsigned long start = (unsigned long) addr;
|
|
|
|
unsigned long end = (unsigned long) addr + length;
|
|
|
|
|
|
|
|
/* For swizzling simply ensure that we always flush both
|
|
|
|
* channels. Lame, but simple and it works. Swizzled
|
|
|
|
* pwrite/pread is far from a hotpath - current userspace
|
|
|
|
* doesn't use it at all. */
|
|
|
|
start = round_down(start, 128);
|
|
|
|
end = round_up(end, 128);
|
|
|
|
|
|
|
|
drm_clflush_virt_range((void *)start, end - start);
|
|
|
|
} else {
|
|
|
|
drm_clflush_virt_range(addr, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
/* Only difference to the fast-path function is that this can handle bit17
|
|
|
|
* and uses non-atomic copy and kmap functions. */
|
|
|
|
static int
|
|
|
|
shmem_pread_slow(struct page *page, int shmem_page_offset, int page_length,
|
|
|
|
char __user *user_data,
|
|
|
|
bool page_do_bit17_swizzling, bool needs_clflush)
|
|
|
|
{
|
|
|
|
char *vaddr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
vaddr = kmap(page);
|
|
|
|
if (needs_clflush)
|
2012-03-25 17:47:42 +00:00
|
|
|
shmem_clflush_swizzled_range(vaddr + shmem_page_offset,
|
|
|
|
page_length,
|
|
|
|
page_do_bit17_swizzling);
|
2012-03-25 17:47:40 +00:00
|
|
|
|
|
|
|
if (page_do_bit17_swizzling)
|
|
|
|
ret = __copy_to_user_swizzled(user_data,
|
|
|
|
vaddr, shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
else
|
|
|
|
ret = __copy_to_user(user_data,
|
|
|
|
vaddr + shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
kunmap(page);
|
|
|
|
|
2012-09-04 20:02:56 +00:00
|
|
|
return ret ? - EFAULT : 0;
|
2012-03-25 17:47:40 +00:00
|
|
|
}
|
|
|
|
|
2009-03-10 18:44:52 +00:00
|
|
|
static int
|
2012-03-25 17:47:29 +00:00
|
|
|
i915_gem_shmem_pread(struct drm_device *dev,
|
|
|
|
struct drm_i915_gem_object *obj,
|
|
|
|
struct drm_i915_gem_pread *args,
|
|
|
|
struct drm_file *file)
|
2009-03-10 18:44:52 +00:00
|
|
|
{
|
2011-12-14 12:57:32 +00:00
|
|
|
char __user *user_data;
|
2009-03-10 18:44:52 +00:00
|
|
|
ssize_t remain;
|
2011-12-14 12:57:32 +00:00
|
|
|
loff_t offset;
|
2012-02-15 13:42:43 +00:00
|
|
|
int shmem_page_offset, page_length, ret = 0;
|
2011-12-14 12:57:32 +00:00
|
|
|
int obj_do_bit17_swizzling, page_do_bit17_swizzling;
|
2012-03-25 17:47:29 +00:00
|
|
|
int hit_slowpath = 0;
|
2012-03-25 17:47:36 +00:00
|
|
|
int prefaulted = 0;
|
2012-03-25 17:47:31 +00:00
|
|
|
int needs_clflush = 0;
|
2012-06-01 14:20:22 +00:00
|
|
|
struct scatterlist *sg;
|
|
|
|
int i;
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2011-12-14 12:57:32 +00:00
|
|
|
user_data = (char __user *) (uintptr_t) args->data_ptr;
|
2009-03-10 18:44:52 +00:00
|
|
|
remain = args->size;
|
|
|
|
|
2011-12-14 12:57:32 +00:00
|
|
|
obj_do_bit17_swizzling = i915_gem_object_needs_bit17_swizzle(obj);
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2012-03-25 17:47:31 +00:00
|
|
|
if (!(obj->base.read_domains & I915_GEM_DOMAIN_CPU)) {
|
|
|
|
/* If we're not in the cpu read domain, set ourself into the gtt
|
|
|
|
* read domain and manually flush cachelines (if required). This
|
|
|
|
* optimizes for the case when the gpu will dirty the data
|
|
|
|
* anyway again before the next pread happens. */
|
|
|
|
if (obj->cache_level == I915_CACHE_NONE)
|
|
|
|
needs_clflush = 1;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
if (obj->gtt_space) {
|
|
|
|
ret = i915_gem_object_set_to_gtt_domain(obj, false);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-03-25 17:47:31 +00:00
|
|
|
}
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2012-09-04 20:02:56 +00:00
|
|
|
ret = i915_gem_object_get_pages(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
i915_gem_object_pin_pages(obj);
|
|
|
|
|
2011-12-14 12:57:32 +00:00
|
|
|
offset = args->offset;
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
for_each_sg(obj->pages->sgl, sg, obj->pages->nents, i) {
|
2010-10-28 12:45:36 +00:00
|
|
|
struct page *page;
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
if (i < offset >> PAGE_SHIFT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (remain <= 0)
|
|
|
|
break;
|
|
|
|
|
2009-03-10 18:44:52 +00:00
|
|
|
/* Operation in this page
|
|
|
|
*
|
|
|
|
* shmem_page_offset = offset within page in shmem file
|
|
|
|
* page_length = bytes to copy for this page
|
|
|
|
*/
|
2011-05-12 21:17:11 +00:00
|
|
|
shmem_page_offset = offset_in_page(offset);
|
2009-03-10 18:44:52 +00:00
|
|
|
page_length = remain;
|
|
|
|
if ((shmem_page_offset + page_length) > PAGE_SIZE)
|
|
|
|
page_length = PAGE_SIZE - shmem_page_offset;
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
page = sg_page(sg);
|
2011-12-14 12:57:32 +00:00
|
|
|
page_do_bit17_swizzling = obj_do_bit17_swizzling &&
|
|
|
|
(page_to_phys(page) & (1 << 17)) != 0;
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
ret = shmem_pread_fast(page, shmem_page_offset, page_length,
|
|
|
|
user_data, page_do_bit17_swizzling,
|
|
|
|
needs_clflush);
|
|
|
|
if (ret == 0)
|
|
|
|
goto next_page;
|
2012-03-25 17:47:29 +00:00
|
|
|
|
|
|
|
hit_slowpath = 1;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2012-03-25 17:47:36 +00:00
|
|
|
if (!prefaulted) {
|
2012-03-25 17:47:41 +00:00
|
|
|
ret = fault_in_multipages_writeable(user_data, remain);
|
2012-03-25 17:47:36 +00:00
|
|
|
/* Userspace is tricking us, but we've already clobbered
|
|
|
|
* its pages with the prefault and promised to write the
|
|
|
|
* data up to the first fault. Hence ignore any errors
|
|
|
|
* and just continue. */
|
|
|
|
(void)ret;
|
|
|
|
prefaulted = 1;
|
|
|
|
}
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
ret = shmem_pread_slow(page, shmem_page_offset, page_length,
|
|
|
|
user_data, page_do_bit17_swizzling,
|
|
|
|
needs_clflush);
|
2009-03-10 18:44:52 +00:00
|
|
|
|
2012-03-25 17:47:29 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2012-09-04 20:02:56 +00:00
|
|
|
|
2012-03-25 17:47:29 +00:00
|
|
|
next_page:
|
2010-10-28 12:45:36 +00:00
|
|
|
mark_page_accessed(page);
|
|
|
|
|
2012-09-04 20:02:56 +00:00
|
|
|
if (ret)
|
2011-12-14 12:57:32 +00:00
|
|
|
goto out;
|
|
|
|
|
2009-03-10 18:44:52 +00:00
|
|
|
remain -= page_length;
|
2011-12-14 12:57:32 +00:00
|
|
|
user_data += page_length;
|
2009-03-10 18:44:52 +00:00
|
|
|
offset += page_length;
|
|
|
|
}
|
|
|
|
|
2010-10-14 14:26:45 +00:00
|
|
|
out:
|
2012-09-04 20:02:56 +00:00
|
|
|
i915_gem_object_unpin_pages(obj);
|
|
|
|
|
2012-03-25 17:47:29 +00:00
|
|
|
if (hit_slowpath) {
|
|
|
|
/* Fixup: Kill any reinstated backing storage pages */
|
|
|
|
if (obj->madv == __I915_MADV_PURGED)
|
|
|
|
i915_gem_object_truncate(obj);
|
|
|
|
}
|
2009-03-10 18:44:52 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/**
|
|
|
|
* Reads data from the object referenced by handle.
|
|
|
|
*
|
|
|
|
* On error, the contents of *data are undefined.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_pread_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_pread *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-09-26 19:23:38 +00:00
|
|
|
int ret = 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-17 09:10:42 +00:00
|
|
|
if (args->size == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_WRITE,
|
|
|
|
(char __user *)(uintptr_t)args->data_ptr,
|
|
|
|
args->size))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2010-10-14 14:26:45 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-10-14 14:26:45 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2010-10-14 14:26:45 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-26 19:21:44 +00:00
|
|
|
/* Bounds check source. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (args->offset > obj->base.size ||
|
|
|
|
args->size > obj->base.size - args->offset) {
|
2010-09-26 19:50:05 +00:00
|
|
|
ret = -EINVAL;
|
2010-09-26 19:23:38 +00:00
|
|
|
goto out;
|
2010-09-26 19:50:05 +00:00
|
|
|
}
|
|
|
|
|
2012-05-10 13:25:09 +00:00
|
|
|
/* prime objects have no backing filp to GEM pread/pwrite
|
|
|
|
* pages from.
|
|
|
|
*/
|
|
|
|
if (!obj->base.filp) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_object_pread(obj, args->offset, args->size);
|
|
|
|
|
2012-03-25 17:47:29 +00:00
|
|
|
ret = i915_gem_shmem_pread(dev, obj, args, file);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-26 19:23:38 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2010-10-14 14:26:45 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2009-03-10 18:44:52 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2008-10-31 02:38:48 +00:00
|
|
|
/* This is the fast write path which cannot handle
|
|
|
|
* page faults in the source data
|
2008-10-20 21:16:43 +00:00
|
|
|
*/
|
2008-10-31 02:38:48 +00:00
|
|
|
|
|
|
|
static inline int
|
|
|
|
fast_user_write(struct io_mapping *mapping,
|
|
|
|
loff_t page_base, int page_offset,
|
|
|
|
char __user *user_data,
|
|
|
|
int length)
|
2008-10-20 21:16:43 +00:00
|
|
|
{
|
2012-04-16 21:07:47 +00:00
|
|
|
void __iomem *vaddr_atomic;
|
|
|
|
void *vaddr;
|
2008-10-31 02:38:48 +00:00
|
|
|
unsigned long unwritten;
|
2008-10-20 21:16:43 +00:00
|
|
|
|
2010-10-26 21:21:51 +00:00
|
|
|
vaddr_atomic = io_mapping_map_atomic_wc(mapping, page_base);
|
2012-04-16 21:07:47 +00:00
|
|
|
/* We can use the cpu mem copy function because this is X86. */
|
|
|
|
vaddr = (void __force*)vaddr_atomic + page_offset;
|
|
|
|
unwritten = __copy_from_user_inatomic_nocache(vaddr,
|
2008-10-31 02:38:48 +00:00
|
|
|
user_data, length);
|
2010-10-26 21:21:51 +00:00
|
|
|
io_mapping_unmap_atomic(vaddr_atomic);
|
2010-10-14 14:03:58 +00:00
|
|
|
return unwritten;
|
2008-10-31 02:38:48 +00:00
|
|
|
}
|
|
|
|
|
2009-03-09 16:42:23 +00:00
|
|
|
/**
|
|
|
|
* This is the fast pwrite path, where we copy the data directly from the
|
|
|
|
* user into the GTT, uncached.
|
|
|
|
*/
|
2008-07-30 19:06:12 +00:00
|
|
|
static int
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_gtt_pwrite_fast(struct drm_device *dev,
|
|
|
|
struct drm_i915_gem_object *obj,
|
2009-03-09 16:42:23 +00:00
|
|
|
struct drm_i915_gem_pwrite *args,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2008-10-31 02:38:48 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2008-07-30 19:06:12 +00:00
|
|
|
ssize_t remain;
|
2008-10-31 02:38:48 +00:00
|
|
|
loff_t offset, page_base;
|
2008-07-30 19:06:12 +00:00
|
|
|
char __user *user_data;
|
2012-03-25 17:47:35 +00:00
|
|
|
int page_offset, page_length, ret;
|
|
|
|
|
2012-08-11 14:41:04 +00:00
|
|
|
ret = i915_gem_object_pin(obj, 0, true, true);
|
2012-03-25 17:47:35 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = i915_gem_object_set_to_gtt_domain(obj, true);
|
|
|
|
if (ret)
|
|
|
|
goto out_unpin;
|
|
|
|
|
|
|
|
ret = i915_gem_object_put_fence(obj);
|
|
|
|
if (ret)
|
|
|
|
goto out_unpin;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
user_data = (char __user *) (uintptr_t) args->data_ptr;
|
|
|
|
remain = args->size;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
offset = obj->gtt_offset + args->offset;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
while (remain > 0) {
|
|
|
|
/* Operation in this page
|
|
|
|
*
|
2008-10-31 02:38:48 +00:00
|
|
|
* page_base = page offset within aperture
|
|
|
|
* page_offset = offset within page
|
|
|
|
* page_length = bytes to copy for this page
|
2008-07-30 19:06:12 +00:00
|
|
|
*/
|
2011-05-12 21:17:11 +00:00
|
|
|
page_base = offset & PAGE_MASK;
|
|
|
|
page_offset = offset_in_page(offset);
|
2008-10-31 02:38:48 +00:00
|
|
|
page_length = remain;
|
|
|
|
if ((page_offset + remain) > PAGE_SIZE)
|
|
|
|
page_length = PAGE_SIZE - page_offset;
|
|
|
|
|
|
|
|
/* If we get a fault while copying data, then (presumably) our
|
2009-03-09 16:42:23 +00:00
|
|
|
* source page isn't available. Return the error and we'll
|
|
|
|
* retry in the slow path.
|
2008-10-31 02:38:48 +00:00
|
|
|
*/
|
2010-10-14 14:03:58 +00:00
|
|
|
if (fast_user_write(dev_priv->mm.gtt_mapping, page_base,
|
2012-03-25 17:47:35 +00:00
|
|
|
page_offset, user_data, page_length)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out_unpin;
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2008-10-31 02:38:48 +00:00
|
|
|
remain -= page_length;
|
|
|
|
user_data += page_length;
|
|
|
|
offset += page_length;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:35 +00:00
|
|
|
out_unpin:
|
|
|
|
i915_gem_object_unpin(obj);
|
|
|
|
out:
|
2009-03-09 16:42:23 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
/* Per-page copy function for the shmem pwrite fastpath.
|
|
|
|
* Flushes invalid cachelines before writing to the target if
|
|
|
|
* needs_clflush_before is set and flushes out any written cachelines after
|
|
|
|
* writing if needs_clflush is set. */
|
2008-10-02 19:24:47 +00:00
|
|
|
static int
|
2012-03-25 17:47:40 +00:00
|
|
|
shmem_pwrite_fast(struct page *page, int shmem_page_offset, int page_length,
|
|
|
|
char __user *user_data,
|
|
|
|
bool page_do_bit17_swizzling,
|
|
|
|
bool needs_clflush_before,
|
|
|
|
bool needs_clflush_after)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2012-03-25 17:47:40 +00:00
|
|
|
char *vaddr;
|
2008-07-30 19:06:12 +00:00
|
|
|
int ret;
|
2009-03-09 16:42:23 +00:00
|
|
|
|
2012-03-25 17:47:43 +00:00
|
|
|
if (unlikely(page_do_bit17_swizzling))
|
2012-03-25 17:47:40 +00:00
|
|
|
return -EINVAL;
|
2009-03-09 16:42:23 +00:00
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
vaddr = kmap_atomic(page);
|
|
|
|
if (needs_clflush_before)
|
|
|
|
drm_clflush_virt_range(vaddr + shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
ret = __copy_from_user_inatomic_nocache(vaddr + shmem_page_offset,
|
|
|
|
user_data,
|
|
|
|
page_length);
|
|
|
|
if (needs_clflush_after)
|
|
|
|
drm_clflush_virt_range(vaddr + shmem_page_offset,
|
|
|
|
page_length);
|
|
|
|
kunmap_atomic(vaddr);
|
2009-03-09 16:42:23 +00:00
|
|
|
|
2012-09-04 20:02:55 +00:00
|
|
|
return ret ? -EFAULT : 0;
|
2009-03-09 16:42:23 +00:00
|
|
|
}
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
/* Only difference to the fast-path function is that this can handle bit17
|
|
|
|
* and uses non-atomic copy and kmap functions. */
|
2008-10-02 19:24:47 +00:00
|
|
|
static int
|
2012-03-25 17:47:40 +00:00
|
|
|
shmem_pwrite_slow(struct page *page, int shmem_page_offset, int page_length,
|
|
|
|
char __user *user_data,
|
|
|
|
bool page_do_bit17_swizzling,
|
|
|
|
bool needs_clflush_before,
|
|
|
|
bool needs_clflush_after)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2012-03-25 17:47:40 +00:00
|
|
|
char *vaddr;
|
|
|
|
int ret;
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
vaddr = kmap(page);
|
2012-03-25 17:47:43 +00:00
|
|
|
if (unlikely(needs_clflush_before || page_do_bit17_swizzling))
|
2012-03-25 17:47:42 +00:00
|
|
|
shmem_clflush_swizzled_range(vaddr + shmem_page_offset,
|
|
|
|
page_length,
|
|
|
|
page_do_bit17_swizzling);
|
2012-03-25 17:47:40 +00:00
|
|
|
if (page_do_bit17_swizzling)
|
|
|
|
ret = __copy_from_user_swizzled(vaddr, shmem_page_offset,
|
2010-10-28 12:45:36 +00:00
|
|
|
user_data,
|
|
|
|
page_length);
|
2012-03-25 17:47:40 +00:00
|
|
|
else
|
|
|
|
ret = __copy_from_user(vaddr + shmem_page_offset,
|
|
|
|
user_data,
|
|
|
|
page_length);
|
|
|
|
if (needs_clflush_after)
|
2012-03-25 17:47:42 +00:00
|
|
|
shmem_clflush_swizzled_range(vaddr + shmem_page_offset,
|
|
|
|
page_length,
|
|
|
|
page_do_bit17_swizzling);
|
2012-03-25 17:47:40 +00:00
|
|
|
kunmap(page);
|
2009-03-09 20:42:30 +00:00
|
|
|
|
2012-09-04 20:02:55 +00:00
|
|
|
return ret ? -EFAULT : 0;
|
2009-03-09 20:42:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2012-03-25 17:47:28 +00:00
|
|
|
i915_gem_shmem_pwrite(struct drm_device *dev,
|
|
|
|
struct drm_i915_gem_object *obj,
|
|
|
|
struct drm_i915_gem_pwrite *args,
|
|
|
|
struct drm_file *file)
|
2009-03-09 20:42:30 +00:00
|
|
|
{
|
|
|
|
ssize_t remain;
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
loff_t offset;
|
|
|
|
char __user *user_data;
|
2012-02-15 13:42:43 +00:00
|
|
|
int shmem_page_offset, page_length, ret = 0;
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
int obj_do_bit17_swizzling, page_do_bit17_swizzling;
|
2012-03-25 17:47:28 +00:00
|
|
|
int hit_slowpath = 0;
|
2012-03-25 17:47:37 +00:00
|
|
|
int needs_clflush_after = 0;
|
|
|
|
int needs_clflush_before = 0;
|
2012-06-01 14:20:22 +00:00
|
|
|
int i;
|
|
|
|
struct scatterlist *sg;
|
2009-03-09 20:42:30 +00:00
|
|
|
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
user_data = (char __user *) (uintptr_t) args->data_ptr;
|
2009-03-09 20:42:30 +00:00
|
|
|
remain = args->size;
|
|
|
|
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
obj_do_bit17_swizzling = i915_gem_object_needs_bit17_swizzle(obj);
|
2009-03-09 20:42:30 +00:00
|
|
|
|
2012-03-25 17:47:37 +00:00
|
|
|
if (obj->base.write_domain != I915_GEM_DOMAIN_CPU) {
|
|
|
|
/* If we're not in the cpu write domain, set ourself into the gtt
|
|
|
|
* write domain and manually flush cachelines (if required). This
|
|
|
|
* optimizes for the case when the gpu will use the data
|
|
|
|
* right away and we therefore have to clflush anyway. */
|
|
|
|
if (obj->cache_level == I915_CACHE_NONE)
|
|
|
|
needs_clflush_after = 1;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
if (obj->gtt_space) {
|
|
|
|
ret = i915_gem_object_set_to_gtt_domain(obj, true);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-03-25 17:47:37 +00:00
|
|
|
}
|
|
|
|
/* Same trick applies for invalidate partially written cachelines before
|
|
|
|
* writing. */
|
|
|
|
if (!(obj->base.read_domains & I915_GEM_DOMAIN_CPU)
|
|
|
|
&& obj->cache_level == I915_CACHE_NONE)
|
|
|
|
needs_clflush_before = 1;
|
|
|
|
|
2012-09-04 20:02:55 +00:00
|
|
|
ret = i915_gem_object_get_pages(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
i915_gem_object_pin_pages(obj);
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
offset = args->offset;
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->dirty = 1;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
for_each_sg(obj->pages->sgl, sg, obj->pages->nents, i) {
|
2010-10-28 12:45:36 +00:00
|
|
|
struct page *page;
|
2012-03-25 17:47:37 +00:00
|
|
|
int partial_cacheline_write;
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
if (i < offset >> PAGE_SHIFT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (remain <= 0)
|
|
|
|
break;
|
|
|
|
|
2009-03-09 20:42:30 +00:00
|
|
|
/* Operation in this page
|
|
|
|
*
|
|
|
|
* shmem_page_offset = offset within page in shmem file
|
|
|
|
* page_length = bytes to copy for this page
|
|
|
|
*/
|
2011-05-12 21:17:11 +00:00
|
|
|
shmem_page_offset = offset_in_page(offset);
|
2009-03-09 20:42:30 +00:00
|
|
|
|
|
|
|
page_length = remain;
|
|
|
|
if ((shmem_page_offset + page_length) > PAGE_SIZE)
|
|
|
|
page_length = PAGE_SIZE - shmem_page_offset;
|
|
|
|
|
2012-03-25 17:47:37 +00:00
|
|
|
/* If we don't overwrite a cacheline completely we need to be
|
|
|
|
* careful to have up-to-date data by first clflushing. Don't
|
|
|
|
* overcomplicate things and flush the entire patch. */
|
|
|
|
partial_cacheline_write = needs_clflush_before &&
|
|
|
|
((shmem_page_offset | page_length)
|
|
|
|
& (boot_cpu_data.x86_clflush_size - 1));
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
page = sg_page(sg);
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
page_do_bit17_swizzling = obj_do_bit17_swizzling &&
|
|
|
|
(page_to_phys(page) & (1 << 17)) != 0;
|
|
|
|
|
2012-03-25 17:47:40 +00:00
|
|
|
ret = shmem_pwrite_fast(page, shmem_page_offset, page_length,
|
|
|
|
user_data, page_do_bit17_swizzling,
|
|
|
|
partial_cacheline_write,
|
|
|
|
needs_clflush_after);
|
|
|
|
if (ret == 0)
|
|
|
|
goto next_page;
|
2012-03-25 17:47:28 +00:00
|
|
|
|
|
|
|
hit_slowpath = 1;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2012-03-25 17:47:40 +00:00
|
|
|
ret = shmem_pwrite_slow(page, shmem_page_offset, page_length,
|
|
|
|
user_data, page_do_bit17_swizzling,
|
|
|
|
partial_cacheline_write,
|
|
|
|
needs_clflush_after);
|
2009-03-09 20:42:30 +00:00
|
|
|
|
2012-03-25 17:47:28 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2012-09-04 20:02:55 +00:00
|
|
|
|
2012-03-25 17:47:28 +00:00
|
|
|
next_page:
|
2010-10-28 12:45:36 +00:00
|
|
|
set_page_dirty(page);
|
|
|
|
mark_page_accessed(page);
|
|
|
|
|
2012-09-04 20:02:55 +00:00
|
|
|
if (ret)
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
goto out;
|
|
|
|
|
2009-03-09 20:42:30 +00:00
|
|
|
remain -= page_length;
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
user_data += page_length;
|
2009-03-09 20:42:30 +00:00
|
|
|
offset += page_length;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-10-14 14:03:58 +00:00
|
|
|
out:
|
2012-09-04 20:02:55 +00:00
|
|
|
i915_gem_object_unpin_pages(obj);
|
|
|
|
|
2012-03-25 17:47:28 +00:00
|
|
|
if (hit_slowpath) {
|
|
|
|
/* Fixup: Kill any reinstated backing storage pages */
|
|
|
|
if (obj->madv == __I915_MADV_PURGED)
|
|
|
|
i915_gem_object_truncate(obj);
|
|
|
|
/* and flush dirty cachelines in case the object isn't in the cpu write
|
|
|
|
* domain anymore. */
|
|
|
|
if (obj->base.write_domain != I915_GEM_DOMAIN_CPU) {
|
|
|
|
i915_gem_clflush_object(obj);
|
|
|
|
intel_gtt_chipset_flush();
|
|
|
|
}
|
drm/i915: rewrite shmem_pwrite_slow to use copy_from_user
... instead of get_user_pages, because that fails on non page-backed
user addresses like e.g. a gtt mapping of a bo.
To get there essentially copy the vfs read path into pagecache. We
can't call that right away because we have to take care of bit17
swizzling. To not deadlock with our own pagefault handler we need
to completely drop struct_mutex, reducing the atomicty-guarantees
of our userspace abi. Implications for racing with other gem ioctl:
- execbuf, pwrite, pread: Due to -EFAULT fallback to slow paths there's
already the risk of the pwrite call not being atomic, no degration.
- read/write access to mmaps: already fully racy, no degration.
- set_tiling: Calling set_tiling while reading/writing is already
pretty much undefined, now it just got a bit worse. set_tiling is
only called by libdrm on unused/new bos, so no problem.
- set_domain: When changing to the gtt domain while copying (without any
read/write access, e.g. for synchronization), we might leave unflushed
data in the cpu caches. The clflush_object at the end of pwrite_slow
takes care of this problem.
- truncating of purgeable objects: the shmem_read_mapping_page call could
reinstate backing storage for truncated objects. The check at the end
of pwrite_slow takes care of this.
v2:
- add missing intel_gtt_chipset_flush
- add __ to copy_from_user_swizzled as suggest by Chris Wilson.
v3: Fixup bit17 swizzling, it swizzled the wrong pages.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2011-12-14 12:57:31 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-03-25 17:47:37 +00:00
|
|
|
if (needs_clflush_after)
|
|
|
|
intel_gtt_chipset_flush();
|
|
|
|
|
2009-03-09 20:42:30 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes data to the object referenced by handle.
|
|
|
|
*
|
|
|
|
* On error, the contents of the buffer that were to be modified are undefined.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
|
2010-10-14 14:03:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_pwrite *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-11-17 09:10:42 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (args->size == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ,
|
|
|
|
(char __user *)(uintptr_t)args->data_ptr,
|
|
|
|
args->size))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2012-03-25 17:47:41 +00:00
|
|
|
ret = fault_in_multipages_readable((char __user *)(uintptr_t)args->data_ptr,
|
|
|
|
args->size);
|
2010-11-17 09:10:42 +00:00
|
|
|
if (ret)
|
|
|
|
return -EFAULT;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-10-14 14:03:58 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-10-14 14:03:58 +00:00
|
|
|
return ret;
|
2010-10-17 08:45:41 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2010-10-14 14:03:58 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-26 19:21:44 +00:00
|
|
|
/* Bounds check destination. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (args->offset > obj->base.size ||
|
|
|
|
args->size > obj->base.size - args->offset) {
|
2010-09-26 19:50:05 +00:00
|
|
|
ret = -EINVAL;
|
2010-09-26 19:23:38 +00:00
|
|
|
goto out;
|
2010-09-26 19:50:05 +00:00
|
|
|
}
|
|
|
|
|
2012-05-10 13:25:09 +00:00
|
|
|
/* prime objects have no backing filp to GEM pread/pwrite
|
|
|
|
* pages from.
|
|
|
|
*/
|
|
|
|
if (!obj->base.filp) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_object_pwrite(obj, args->offset, args->size);
|
|
|
|
|
2012-03-25 17:47:35 +00:00
|
|
|
ret = -EFAULT;
|
2008-07-30 19:06:12 +00:00
|
|
|
/* We can only do the GTT pwrite on untiled buffers, as otherwise
|
|
|
|
* it would end up going through the fenced access, and we'll get
|
|
|
|
* different detiling behavior between reading and writing.
|
|
|
|
* pread/pwrite currently are reading and writing from the CPU
|
|
|
|
* perspective, requiring manual detiling by the client.
|
|
|
|
*/
|
2011-12-14 12:57:30 +00:00
|
|
|
if (obj->phys_obj) {
|
2010-10-14 14:03:58 +00:00
|
|
|
ret = i915_gem_phys_pwrite(dev, obj, args, file);
|
2011-12-14 12:57:30 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-08-11 14:41:04 +00:00
|
|
|
if (obj->cache_level == I915_CACHE_NONE &&
|
2012-04-13 13:51:51 +00:00
|
|
|
obj->tiling_mode == I915_TILING_NONE &&
|
2011-12-14 12:57:30 +00:00
|
|
|
obj->base.write_domain != I915_GEM_DOMAIN_CPU) {
|
2010-10-14 14:03:58 +00:00
|
|
|
ret = i915_gem_gtt_pwrite_fast(dev, obj, args, file);
|
2012-03-25 17:47:35 +00:00
|
|
|
/* Note that the gtt paths might fail with non-page-backed user
|
|
|
|
* pointers (e.g. gtt mappings when moving data between
|
|
|
|
* textures). Fallback to the shmem path in that case. */
|
2010-10-14 14:03:58 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-08-11 14:41:04 +00:00
|
|
|
if (ret == -EFAULT || ret == -ENOSPC)
|
2012-03-25 17:47:35 +00:00
|
|
|
ret = i915_gem_shmem_pwrite(dev, obj, args, file);
|
2011-12-14 12:57:30 +00:00
|
|
|
|
2010-09-26 19:23:38 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2010-10-14 14:03:58 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2008-07-30 19:06:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-24 08:35:08 +00:00
|
|
|
int
|
|
|
|
i915_gem_check_wedge(struct drm_i915_private *dev_priv,
|
|
|
|
bool interruptible)
|
|
|
|
{
|
|
|
|
if (atomic_read(&dev_priv->mm.wedged)) {
|
|
|
|
struct completion *x = &dev_priv->error_completion;
|
|
|
|
bool recovery_complete;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* Give the error handler a chance to run. */
|
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
|
|
|
recovery_complete = x->done > 0;
|
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
|
|
|
|
|
|
|
/* Non-interruptible callers can't handle -EAGAIN, hence return
|
|
|
|
* -EIO unconditionally for these. */
|
|
|
|
if (!interruptible)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* Recovery complete, but still wedged means reset failure. */
|
|
|
|
if (recovery_complete)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare seqno against outstanding lazy request. Emit a request if they are
|
|
|
|
* equal.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
i915_gem_check_olr(struct intel_ring_buffer *ring, u32 seqno)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(!mutex_is_locked(&ring->dev->struct_mutex));
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
if (seqno == ring->outstanding_lazy_request)
|
|
|
|
ret = i915_add_request(ring, NULL, NULL);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __wait_seqno - wait until execution of seqno has finished
|
|
|
|
* @ring: the ring expected to report seqno
|
|
|
|
* @seqno: duh!
|
|
|
|
* @interruptible: do an interruptible wait (normally yes)
|
|
|
|
* @timeout: in - how long to wait (NULL forever); out - how much time remaining
|
|
|
|
*
|
|
|
|
* Returns 0 if the seqno was found within the alloted time. Else returns the
|
|
|
|
* errno with remaining time filled in timeout argument.
|
|
|
|
*/
|
|
|
|
static int __wait_seqno(struct intel_ring_buffer *ring, u32 seqno,
|
|
|
|
bool interruptible, struct timespec *timeout)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = ring->dev->dev_private;
|
|
|
|
struct timespec before, now, wait_time={1,0};
|
|
|
|
unsigned long timeout_jiffies;
|
|
|
|
long end;
|
|
|
|
bool wait_forever = true;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (i915_seqno_passed(ring->get_seqno(ring, true), seqno))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
trace_i915_gem_request_wait_begin(ring, seqno);
|
|
|
|
|
|
|
|
if (timeout != NULL) {
|
|
|
|
wait_time = *timeout;
|
|
|
|
wait_forever = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
timeout_jiffies = timespec_to_jiffies(&wait_time);
|
|
|
|
|
|
|
|
if (WARN_ON(!ring->irq_get(ring)))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* Record current time in case interrupted by signal, or wedged * */
|
|
|
|
getrawmonotonic(&before);
|
|
|
|
|
|
|
|
#define EXIT_COND \
|
|
|
|
(i915_seqno_passed(ring->get_seqno(ring, false), seqno) || \
|
|
|
|
atomic_read(&dev_priv->mm.wedged))
|
|
|
|
do {
|
|
|
|
if (interruptible)
|
|
|
|
end = wait_event_interruptible_timeout(ring->irq_queue,
|
|
|
|
EXIT_COND,
|
|
|
|
timeout_jiffies);
|
|
|
|
else
|
|
|
|
end = wait_event_timeout(ring->irq_queue, EXIT_COND,
|
|
|
|
timeout_jiffies);
|
|
|
|
|
|
|
|
ret = i915_gem_check_wedge(dev_priv, interruptible);
|
|
|
|
if (ret)
|
|
|
|
end = ret;
|
|
|
|
} while (end == 0 && wait_forever);
|
|
|
|
|
|
|
|
getrawmonotonic(&now);
|
|
|
|
|
|
|
|
ring->irq_put(ring);
|
|
|
|
trace_i915_gem_request_wait_end(ring, seqno);
|
|
|
|
#undef EXIT_COND
|
|
|
|
|
|
|
|
if (timeout) {
|
|
|
|
struct timespec sleep_time = timespec_sub(now, before);
|
|
|
|
*timeout = timespec_sub(*timeout, sleep_time);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (end) {
|
|
|
|
case -EIO:
|
|
|
|
case -EAGAIN: /* Wedged */
|
|
|
|
case -ERESTARTSYS: /* Signal */
|
|
|
|
return (int)end;
|
|
|
|
case 0: /* Timeout */
|
|
|
|
if (timeout)
|
|
|
|
set_normalized_timespec(timeout, 0, 0);
|
|
|
|
return -ETIME;
|
|
|
|
default: /* Completed */
|
|
|
|
WARN_ON(end < 0); /* We're not aware of other errors */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Waits for a sequence number to be signaled, and cleans up the
|
|
|
|
* request and object lists appropriately for that event.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_wait_seqno(struct intel_ring_buffer *ring, uint32_t seqno)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = ring->dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
bool interruptible = dev_priv->mm.interruptible;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(!mutex_is_locked(&dev->struct_mutex));
|
|
|
|
BUG_ON(seqno == 0);
|
|
|
|
|
|
|
|
ret = i915_gem_check_wedge(dev_priv, interruptible);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = i915_gem_check_olr(ring, seqno);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return __wait_seqno(ring, seqno, interruptible, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ensures that all rendering to the object has completed and the object is
|
|
|
|
* safe to unbind from the GTT or access from the CPU.
|
|
|
|
*/
|
|
|
|
static __must_check int
|
|
|
|
i915_gem_object_wait_rendering(struct drm_i915_gem_object *obj,
|
|
|
|
bool readonly)
|
|
|
|
{
|
|
|
|
struct intel_ring_buffer *ring = obj->ring;
|
|
|
|
u32 seqno;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
seqno = readonly ? obj->last_write_seqno : obj->last_read_seqno;
|
|
|
|
if (seqno == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = i915_wait_seqno(ring, seqno);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
i915_gem_retire_requests_ring(ring);
|
|
|
|
|
|
|
|
/* Manually manage the write flush as we may have not yet
|
|
|
|
* retired the buffer.
|
|
|
|
*/
|
|
|
|
if (obj->last_write_seqno &&
|
|
|
|
i915_seqno_passed(seqno, obj->last_write_seqno)) {
|
|
|
|
obj->last_write_seqno = 0;
|
|
|
|
obj->base.write_domain &= ~I915_GEM_GPU_DOMAINS;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-24 08:35:09 +00:00
|
|
|
/* A nonblocking variant of the above wait. This is a highly dangerous routine
|
|
|
|
* as the object state may change during this call.
|
|
|
|
*/
|
|
|
|
static __must_check int
|
|
|
|
i915_gem_object_wait_rendering__nonblocking(struct drm_i915_gem_object *obj,
|
|
|
|
bool readonly)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct intel_ring_buffer *ring = obj->ring;
|
|
|
|
u32 seqno;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(!mutex_is_locked(&dev->struct_mutex));
|
|
|
|
BUG_ON(!dev_priv->mm.interruptible);
|
|
|
|
|
|
|
|
seqno = readonly ? obj->last_write_seqno : obj->last_read_seqno;
|
|
|
|
if (seqno == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = i915_gem_check_wedge(dev_priv, true);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = i915_gem_check_olr(ring, seqno);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
ret = __wait_seqno(ring, seqno, true, NULL);
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
i915_gem_retire_requests_ring(ring);
|
|
|
|
|
|
|
|
/* Manually manage the write flush as we may have not yet
|
|
|
|
* retired the buffer.
|
|
|
|
*/
|
|
|
|
if (obj->last_write_seqno &&
|
|
|
|
i915_seqno_passed(seqno, obj->last_write_seqno)) {
|
|
|
|
obj->last_write_seqno = 0;
|
|
|
|
obj->base.write_domain &= ~I915_GEM_GPU_DOMAINS;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/**
|
2008-11-10 18:53:25 +00:00
|
|
|
* Called when user space prepares to use an object with the CPU, either
|
|
|
|
* through the mmap ioctl's mapping or a GTT mapping.
|
2008-07-30 19:06:12 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_set_domain *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2008-11-10 18:53:25 +00:00
|
|
|
uint32_t read_domains = args->read_domains;
|
|
|
|
uint32_t write_domain = args->write_domain;
|
2008-07-30 19:06:12 +00:00
|
|
|
int ret;
|
|
|
|
|
2008-11-10 18:53:25 +00:00
|
|
|
/* Only handle setting domains to types used by the CPU. */
|
2009-06-06 08:46:02 +00:00
|
|
|
if (write_domain & I915_GEM_GPU_DOMAINS)
|
2008-11-10 18:53:25 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-06-06 08:46:02 +00:00
|
|
|
if (read_domains & I915_GEM_GPU_DOMAINS)
|
2008-11-10 18:53:25 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Having something in the write domain implies it's in the read
|
|
|
|
* domain, and only that read domain. Enforce that in the request.
|
|
|
|
*/
|
|
|
|
if (write_domain != 0 && read_domains != write_domain)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-25 10:22:51 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-09-25 10:22:51 +00:00
|
|
|
return ret;
|
2010-10-17 08:45:41 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2010-09-25 10:22:51 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-08-24 08:35:09 +00:00
|
|
|
/* Try to flush the object off the GPU without holding the lock.
|
|
|
|
* We will repeat the flush holding the lock in the normal manner
|
|
|
|
* to catch cases where we are gazumped.
|
|
|
|
*/
|
|
|
|
ret = i915_gem_object_wait_rendering__nonblocking(obj, !write_domain);
|
|
|
|
if (ret)
|
|
|
|
goto unref;
|
|
|
|
|
2008-11-10 18:53:25 +00:00
|
|
|
if (read_domains & I915_GEM_DOMAIN_GTT) {
|
|
|
|
ret = i915_gem_object_set_to_gtt_domain(obj, write_domain != 0);
|
2008-11-26 21:58:13 +00:00
|
|
|
|
|
|
|
/* Silently promote "you're not bound, there was nothing to do"
|
|
|
|
* to success, since the client was just asking us to
|
|
|
|
* make sure everything was done.
|
|
|
|
*/
|
|
|
|
if (ret == -EINVAL)
|
|
|
|
ret = 0;
|
2008-11-10 18:53:25 +00:00
|
|
|
} else {
|
2008-11-14 21:35:19 +00:00
|
|
|
ret = i915_gem_object_set_to_cpu_domain(obj, write_domain != 0);
|
2008-11-10 18:53:25 +00:00
|
|
|
}
|
|
|
|
|
2012-08-24 08:35:09 +00:00
|
|
|
unref:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called when user space has done writes to this buffer
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_sw_finish *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2008-07-30 19:06:12 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2010-09-25 10:22:51 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-09-25 10:22:51 +00:00
|
|
|
return ret;
|
2010-10-17 08:45:41 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Pinned buffers may be scanout, so flush the cache */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->pin_count)
|
2008-11-14 21:35:19 +00:00
|
|
|
i915_gem_object_flush_cpu_write_domain(obj);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Maps the contents of an object, returning the address it is mapped
|
|
|
|
* into.
|
|
|
|
*
|
|
|
|
* While the mapping holds a reference on the contents of the object, it doesn't
|
|
|
|
* imply a ref on the object itself.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_mmap_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_mmap *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
unsigned long addr;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = drm_gem_object_lookup(dev, file, args->handle);
|
2008-07-30 19:06:12 +00:00
|
|
|
if (obj == NULL)
|
2010-08-04 13:19:46 +00:00
|
|
|
return -ENOENT;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-05-10 13:25:09 +00:00
|
|
|
/* prime objects have no backing filp to GEM mmap
|
|
|
|
* pages from.
|
|
|
|
*/
|
|
|
|
if (!obj->filp) {
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-04-21 00:13:58 +00:00
|
|
|
addr = vm_mmap(obj->filp, 0, args->size,
|
2008-07-30 19:06:12 +00:00
|
|
|
PROT_READ | PROT_WRITE, MAP_SHARED,
|
|
|
|
args->offset);
|
2010-02-09 05:49:12 +00:00
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2008-07-30 19:06:12 +00:00
|
|
|
if (IS_ERR((void *)addr))
|
|
|
|
return addr;
|
|
|
|
|
|
|
|
args->addr_ptr = (uint64_t) addr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-12 18:03:55 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_fault - fault a page into the GTT
|
|
|
|
* vma: VMA in question
|
|
|
|
* vmf: fault info
|
|
|
|
*
|
|
|
|
* The fault handler is set up by drm_gem_mmap() when a object is GTT mapped
|
|
|
|
* from userspace. The fault handler takes care of binding the object to
|
|
|
|
* the GTT (if needed), allocating and programming a fence register (again,
|
|
|
|
* only if needed based on whether the old reg is still valid or the object
|
|
|
|
* is tiled) and inserting a new PTE into the faulting process.
|
|
|
|
*
|
|
|
|
* Note that the faulting process may involve evicting existing objects
|
|
|
|
* from the GTT and/or fence registers to make room. So performance may
|
|
|
|
* suffer if the GTT working set is large or there are few fence registers
|
|
|
|
* left.
|
|
|
|
*/
|
|
|
|
int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj = to_intel_bo(vma->vm_private_data);
|
|
|
|
struct drm_device *dev = obj->base.dev;
|
2010-08-07 20:45:03 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2008-11-12 18:03:55 +00:00
|
|
|
pgoff_t page_offset;
|
|
|
|
unsigned long pfn;
|
|
|
|
int ret = 0;
|
2009-01-27 01:10:45 +00:00
|
|
|
bool write = !!(vmf->flags & FAULT_FLAG_WRITE);
|
2008-11-12 18:03:55 +00:00
|
|
|
|
|
|
|
/* We don't use vmf->pgoff since that has the fake offset */
|
|
|
|
page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >>
|
|
|
|
PAGE_SHIFT;
|
|
|
|
|
2011-02-07 13:09:31 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2010-09-24 20:15:47 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_object_fault(obj, page_offset, true, write);
|
|
|
|
|
2011-02-07 13:09:31 +00:00
|
|
|
/* Now bind it into the GTT if needed */
|
2010-11-12 13:42:53 +00:00
|
|
|
if (!obj->map_and_fenceable) {
|
|
|
|
ret = i915_gem_object_unbind(obj);
|
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
2010-09-24 20:15:47 +00:00
|
|
|
}
|
2010-11-08 19:18:58 +00:00
|
|
|
if (!obj->gtt_space) {
|
2012-08-11 14:41:04 +00:00
|
|
|
ret = i915_gem_object_bind_to_gtt(obj, 0, true, false);
|
2009-09-22 23:43:56 +00:00
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2011-06-14 23:43:09 +00:00
|
|
|
ret = i915_gem_object_set_to_gtt_domain(obj, write);
|
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
|
|
|
}
|
2010-10-28 13:44:08 +00:00
|
|
|
|
2012-02-15 22:50:22 +00:00
|
|
|
if (!obj->has_global_gtt_mapping)
|
|
|
|
i915_gem_gtt_bind_object(obj, obj->cache_level);
|
|
|
|
|
2012-04-17 14:31:24 +00:00
|
|
|
ret = i915_gem_object_get_fence(obj);
|
2010-11-10 16:40:20 +00:00
|
|
|
if (ret)
|
|
|
|
goto unlock;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (i915_gem_object_is_inactive(obj))
|
|
|
|
list_move_tail(&obj->mm_list, &dev_priv->mm.inactive_list);
|
2010-08-07 20:45:03 +00:00
|
|
|
|
2010-11-24 12:23:44 +00:00
|
|
|
obj->fault_mappable = true;
|
|
|
|
|
2012-06-07 13:55:57 +00:00
|
|
|
pfn = ((dev_priv->mm.gtt_base_addr + obj->gtt_offset) >> PAGE_SHIFT) +
|
2008-11-12 18:03:55 +00:00
|
|
|
page_offset;
|
|
|
|
|
|
|
|
/* Finally, remap it using the new GTT offset */
|
|
|
|
ret = vm_insert_pfn(vma, (unsigned long)vmf->virtual_address, pfn);
|
2009-09-22 23:43:56 +00:00
|
|
|
unlock:
|
2008-11-12 18:03:55 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2011-02-07 13:09:31 +00:00
|
|
|
out:
|
2008-11-12 18:03:55 +00:00
|
|
|
switch (ret) {
|
2011-02-07 13:09:31 +00:00
|
|
|
case -EIO:
|
2012-07-04 20:18:42 +00:00
|
|
|
/* If this -EIO is due to a gpu hang, give the reset code a
|
|
|
|
* chance to clean up the mess. Otherwise return the proper
|
|
|
|
* SIGBUS. */
|
|
|
|
if (!atomic_read(&dev_priv->mm.wedged))
|
|
|
|
return VM_FAULT_SIGBUS;
|
2010-11-07 09:18:22 +00:00
|
|
|
case -EAGAIN:
|
2011-02-07 13:09:31 +00:00
|
|
|
/* Give the error handler a chance to run and move the
|
|
|
|
* objects off the GPU active list. Next time we service the
|
|
|
|
* fault, we should be able to transition the page into the
|
|
|
|
* GTT without touching the GPU (and so avoid further
|
|
|
|
* EIO/EGAIN). If the GPU is wedged, then there is no issue
|
|
|
|
* with coherency, just lost writes.
|
|
|
|
*/
|
2010-11-07 09:18:22 +00:00
|
|
|
set_need_resched();
|
2009-09-22 23:43:56 +00:00
|
|
|
case 0:
|
|
|
|
case -ERESTARTSYS:
|
2011-02-11 20:31:19 +00:00
|
|
|
case -EINTR:
|
2009-09-22 23:43:56 +00:00
|
|
|
return VM_FAULT_NOPAGE;
|
2008-11-12 18:03:55 +00:00
|
|
|
case -ENOMEM:
|
|
|
|
return VM_FAULT_OOM;
|
|
|
|
default:
|
2009-09-22 23:43:56 +00:00
|
|
|
return VM_FAULT_SIGBUS;
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-10 07:18:50 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_release_mmap - remove physical page mappings
|
|
|
|
* @obj: obj in question
|
|
|
|
*
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 15:09:05 +00:00
|
|
|
* Preserve the reservation of the mmapping with the DRM core code, but
|
2009-07-10 07:18:50 +00:00
|
|
|
* relinquish ownership of the pages back to the system.
|
|
|
|
*
|
|
|
|
* It is vital that we remove the page mapping if we have mapped a tiled
|
|
|
|
* object through the GTT and then lose the fence register due to
|
|
|
|
* resource pressure. Similarly if the object has been moved out of the
|
|
|
|
* aperture, than pages mapped into userspace must be revoked. Removing the
|
|
|
|
* mapping will then trigger a page fault on the next user access, allowing
|
|
|
|
* fixup by i915_gem_fault().
|
|
|
|
*/
|
2009-07-10 20:02:26 +00:00
|
|
|
void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_release_mmap(struct drm_i915_gem_object *obj)
|
2009-07-10 07:18:50 +00:00
|
|
|
{
|
2010-11-24 12:23:44 +00:00
|
|
|
if (!obj->fault_mappable)
|
|
|
|
return;
|
2009-07-10 07:18:50 +00:00
|
|
|
|
2011-03-20 21:09:12 +00:00
|
|
|
if (obj->base.dev->dev_mapping)
|
|
|
|
unmap_mapping_range(obj->base.dev->dev_mapping,
|
|
|
|
(loff_t)obj->base.map_list.hash.key<<PAGE_SHIFT,
|
|
|
|
obj->base.size, 1);
|
2010-10-01 20:05:20 +00:00
|
|
|
|
2010-11-24 12:23:44 +00:00
|
|
|
obj->fault_mappable = false;
|
2009-07-10 07:18:50 +00:00
|
|
|
}
|
|
|
|
|
2010-11-09 11:47:32 +00:00
|
|
|
static uint32_t
|
2011-07-18 20:11:49 +00:00
|
|
|
i915_gem_get_gtt_size(struct drm_device *dev, uint32_t size, int tiling_mode)
|
2010-11-09 11:47:32 +00:00
|
|
|
{
|
2011-07-18 20:11:49 +00:00
|
|
|
uint32_t gtt_size;
|
2010-11-09 11:47:32 +00:00
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen >= 4 ||
|
2011-07-18 20:11:49 +00:00
|
|
|
tiling_mode == I915_TILING_NONE)
|
|
|
|
return size;
|
2010-11-09 11:47:32 +00:00
|
|
|
|
|
|
|
/* Previous chips need a power-of-two fence region when tiling */
|
|
|
|
if (INTEL_INFO(dev)->gen == 3)
|
2011-07-18 20:11:49 +00:00
|
|
|
gtt_size = 1024*1024;
|
2010-11-09 11:47:32 +00:00
|
|
|
else
|
2011-07-18 20:11:49 +00:00
|
|
|
gtt_size = 512*1024;
|
2010-11-09 11:47:32 +00:00
|
|
|
|
2011-07-18 20:11:49 +00:00
|
|
|
while (gtt_size < size)
|
|
|
|
gtt_size <<= 1;
|
2010-11-09 11:47:32 +00:00
|
|
|
|
2011-07-18 20:11:49 +00:00
|
|
|
return gtt_size;
|
2010-11-09 11:47:32 +00:00
|
|
|
}
|
|
|
|
|
2008-11-12 18:03:55 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_get_gtt_alignment - return required GTT alignment for an object
|
|
|
|
* @obj: object to check
|
|
|
|
*
|
|
|
|
* Return the required GTT alignment for an object, taking into account
|
2010-11-14 21:32:36 +00:00
|
|
|
* potential fence register mapping.
|
2008-11-12 18:03:55 +00:00
|
|
|
*/
|
|
|
|
static uint32_t
|
2011-07-18 20:11:49 +00:00
|
|
|
i915_gem_get_gtt_alignment(struct drm_device *dev,
|
|
|
|
uint32_t size,
|
|
|
|
int tiling_mode)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Minimum alignment is 4k (GTT page size), but might be greater
|
|
|
|
* if a fence register is needed for the object.
|
|
|
|
*/
|
2010-09-24 20:15:47 +00:00
|
|
|
if (INTEL_INFO(dev)->gen >= 4 ||
|
2011-07-18 20:11:49 +00:00
|
|
|
tiling_mode == I915_TILING_NONE)
|
2008-11-12 18:03:55 +00:00
|
|
|
return 4096;
|
|
|
|
|
2010-09-24 20:15:47 +00:00
|
|
|
/*
|
|
|
|
* Previous chips need to be aligned to the size of the smallest
|
|
|
|
* fence register that can contain the object.
|
|
|
|
*/
|
2011-07-18 20:11:49 +00:00
|
|
|
return i915_gem_get_gtt_size(dev, size, tiling_mode);
|
2010-09-24 20:15:47 +00:00
|
|
|
}
|
|
|
|
|
2010-11-14 21:32:36 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_get_unfenced_gtt_alignment - return required GTT alignment for an
|
|
|
|
* unfenced object
|
2011-07-18 20:11:49 +00:00
|
|
|
* @dev: the device
|
|
|
|
* @size: size of the object
|
|
|
|
* @tiling_mode: tiling mode of the object
|
2010-11-14 21:32:36 +00:00
|
|
|
*
|
|
|
|
* Return the required GTT alignment for an object, only taking into account
|
|
|
|
* unfenced tiled surface requirements.
|
|
|
|
*/
|
2011-03-07 10:42:03 +00:00
|
|
|
uint32_t
|
2011-07-18 20:11:49 +00:00
|
|
|
i915_gem_get_unfenced_gtt_alignment(struct drm_device *dev,
|
|
|
|
uint32_t size,
|
|
|
|
int tiling_mode)
|
2010-11-14 21:32:36 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Minimum alignment is 4k (GTT page size) for sane hw.
|
|
|
|
*/
|
|
|
|
if (INTEL_INFO(dev)->gen >= 4 || IS_G33(dev) ||
|
2011-07-18 20:11:49 +00:00
|
|
|
tiling_mode == I915_TILING_NONE)
|
2010-11-14 21:32:36 +00:00
|
|
|
return 4096;
|
|
|
|
|
2011-07-18 20:11:49 +00:00
|
|
|
/* Previous hardware however needs to be aligned to a power-of-two
|
|
|
|
* tile height. The simplest method for determining this is to reuse
|
|
|
|
* the power-of-tile object size.
|
2010-11-14 21:32:36 +00:00
|
|
|
*/
|
2011-07-18 20:11:49 +00:00
|
|
|
return i915_gem_get_gtt_size(dev, size, tiling_mode);
|
2010-11-14 21:32:36 +00:00
|
|
|
}
|
|
|
|
|
2012-08-11 14:41:03 +00:00
|
|
|
static int i915_gem_object_create_mmap_offset(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (obj->base.map_list.map)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = drm_gem_create_mmap_offset(&obj->base);
|
|
|
|
if (ret != -ENOSPC)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Badly fragmented mmap space? The only way we can recover
|
|
|
|
* space is by destroying unwanted objects. We can't randomly release
|
|
|
|
* mmap_offsets as userspace expects them to be persistent for the
|
|
|
|
* lifetime of the objects. The closest we can is to release the
|
|
|
|
* offsets on purgeable objects by truncating it and marking it purged,
|
|
|
|
* which prevents userspace from ever using that object again.
|
|
|
|
*/
|
|
|
|
i915_gem_purge(dev_priv, obj->base.size >> PAGE_SHIFT);
|
|
|
|
ret = drm_gem_create_mmap_offset(&obj->base);
|
|
|
|
if (ret != -ENOSPC)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
i915_gem_shrink_all(dev_priv);
|
|
|
|
return drm_gem_create_mmap_offset(&obj->base);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_gem_object_free_mmap_offset(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
if (!obj->base.map_list.map)
|
|
|
|
return;
|
|
|
|
|
|
|
|
drm_gem_free_mmap_offset(&obj->base);
|
|
|
|
}
|
|
|
|
|
2008-11-12 18:03:55 +00:00
|
|
|
int
|
2011-02-07 02:16:14 +00:00
|
|
|
i915_gem_mmap_gtt(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle,
|
|
|
|
uint64_t *offset)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
2010-10-27 16:37:08 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2008-11-12 18:03:55 +00:00
|
|
|
int ret;
|
|
|
|
|
2010-09-25 10:22:51 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-09-25 10:22:51 +00:00
|
|
|
return ret;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->base.size > dev_priv->mm.gtt_mappable_end) {
|
2010-10-27 16:37:08 +00:00
|
|
|
ret = -E2BIG;
|
2011-11-01 06:16:21 +00:00
|
|
|
goto out;
|
2010-10-27 16:37:08 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv != I915_MADV_WILLNEED) {
|
2009-09-22 17:46:17 +00:00
|
|
|
DRM_ERROR("Attempting to mmap a purgeable buffer\n");
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2009-09-22 17:46:17 +00:00
|
|
|
}
|
|
|
|
|
2012-08-11 14:41:03 +00:00
|
|
|
ret = i915_gem_object_create_mmap_offset(obj);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
*offset = (u64)obj->base.map_list.hash.key << PAGE_SHIFT;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-11-12 18:03:55 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-10-17 08:45:41 +00:00
|
|
|
return ret;
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_mmap_gtt_ioctl - prepare an object for GTT mmap'ing
|
|
|
|
* @dev: DRM device
|
|
|
|
* @data: GTT mapping ioctl data
|
|
|
|
* @file: GEM object info
|
|
|
|
*
|
|
|
|
* Simply returns the fake offset to userspace so it can mmap it.
|
|
|
|
* The mmap call will end up in drm_gem_mmap(), which will set things
|
|
|
|
* up so we can get faults in the handler above.
|
|
|
|
*
|
|
|
|
* The fault handler will take care of binding the object into the GTT
|
|
|
|
* (since it may have been evicted to make room for something), allocating
|
|
|
|
* a fence register, and mapping the appropriate aperture address into
|
|
|
|
* userspace.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_mmap_gtt_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_mmap_gtt *args = data;
|
|
|
|
|
|
|
|
return i915_gem_mmap_gtt(file, dev, args->handle, &args->offset);
|
|
|
|
}
|
|
|
|
|
2012-08-20 08:23:20 +00:00
|
|
|
/* Immediately discard the backing storage */
|
|
|
|
static void
|
|
|
|
i915_gem_object_truncate(struct drm_i915_gem_object *obj)
|
2010-10-28 12:45:36 +00:00
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
|
2012-08-11 14:41:05 +00:00
|
|
|
i915_gem_object_free_mmap_offset(obj);
|
2012-05-10 13:25:09 +00:00
|
|
|
|
2012-08-11 14:41:05 +00:00
|
|
|
if (obj->base.filp == NULL)
|
|
|
|
return;
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-08-20 08:23:20 +00:00
|
|
|
/* Our goal here is to return as much of the memory as
|
|
|
|
* is possible back to the system as we are called from OOM.
|
|
|
|
* To do this we must instruct the shmfs to drop all of its
|
|
|
|
* backing pages, *now*.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
inode = obj->base.filp->f_path.dentry->d_inode;
|
2012-08-20 08:23:20 +00:00
|
|
|
shmem_truncate_range(inode, 0, (loff_t)-1);
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-08-20 08:23:20 +00:00
|
|
|
obj->madv = __I915_MADV_PURGED;
|
|
|
|
}
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-08-20 08:23:20 +00:00
|
|
|
static inline int
|
|
|
|
i915_gem_object_is_purgeable(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
return obj->madv == I915_MADV_DONTNEED;
|
2010-10-28 12:45:36 +00:00
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
static void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_put_pages_gtt(struct drm_i915_gem_object *obj)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
int page_count = obj->base.size / PAGE_SIZE;
|
2012-06-01 14:20:22 +00:00
|
|
|
struct scatterlist *sg;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
int ret, i;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
BUG_ON(obj->madv == __I915_MADV_PURGED);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
ret = i915_gem_object_set_to_cpu_domain(obj, true);
|
|
|
|
if (ret) {
|
|
|
|
/* In the event of a disaster, abandon all caches and
|
|
|
|
* hope for the best.
|
|
|
|
*/
|
|
|
|
WARN_ON(ret != -EIO);
|
|
|
|
i915_gem_clflush_object(obj);
|
|
|
|
obj->base.read_domains = obj->base.write_domain = I915_GEM_DOMAIN_CPU;
|
|
|
|
}
|
|
|
|
|
2011-09-12 19:30:02 +00:00
|
|
|
if (i915_gem_object_needs_bit17_swizzle(obj))
|
2009-03-12 23:56:27 +00:00
|
|
|
i915_gem_object_save_bit_17_swizzle(obj);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv == I915_MADV_DONTNEED)
|
|
|
|
obj->dirty = 0;
|
2009-09-14 15:50:29 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
for_each_sg(obj->pages->sgl, sg, page_count, i) {
|
|
|
|
struct page *page = sg_page(sg);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->dirty)
|
2012-06-01 14:20:22 +00:00
|
|
|
set_page_dirty(page);
|
2009-09-14 15:50:29 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv == I915_MADV_WILLNEED)
|
2012-06-01 14:20:22 +00:00
|
|
|
mark_page_accessed(page);
|
2009-09-14 15:50:29 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
page_cache_release(page);
|
2009-09-14 15:50:29 +00:00
|
|
|
}
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->dirty = 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
sg_free_table(obj->pages);
|
|
|
|
kfree(obj->pages);
|
2012-06-07 14:38:42 +00:00
|
|
|
}
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
static int
|
|
|
|
i915_gem_object_put_pages(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
const struct drm_i915_gem_object_ops *ops = obj->ops;
|
|
|
|
|
|
|
|
if (obj->sg_table || obj->pages == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
BUG_ON(obj->gtt_space);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
|
2012-09-04 20:02:54 +00:00
|
|
|
if (obj->pages_pin_count)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
ops->put_pages(obj);
|
2012-06-01 14:20:22 +00:00
|
|
|
obj->pages = NULL;
|
2012-06-07 14:38:42 +00:00
|
|
|
|
|
|
|
list_del(&obj->gtt_list);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
if (i915_gem_object_is_purgeable(obj))
|
|
|
|
i915_gem_object_truncate(obj);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long
|
|
|
|
i915_gem_purge(struct drm_i915_private *dev_priv, long target)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_object *obj, *next;
|
|
|
|
long count = 0;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(obj, next,
|
|
|
|
&dev_priv->mm.unbound_list,
|
|
|
|
gtt_list) {
|
|
|
|
if (i915_gem_object_is_purgeable(obj) &&
|
2012-06-07 14:38:42 +00:00
|
|
|
i915_gem_object_put_pages(obj) == 0) {
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
count += obj->base.size >> PAGE_SHIFT;
|
|
|
|
if (count >= target)
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(obj, next,
|
|
|
|
&dev_priv->mm.inactive_list,
|
|
|
|
mm_list) {
|
|
|
|
if (i915_gem_object_is_purgeable(obj) &&
|
|
|
|
i915_gem_object_unbind(obj) == 0 &&
|
2012-06-07 14:38:42 +00:00
|
|
|
i915_gem_object_put_pages(obj) == 0) {
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
count += obj->base.size >> PAGE_SHIFT;
|
|
|
|
if (count >= target)
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
i915_gem_shrink_all(struct drm_i915_private *dev_priv)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_object *obj, *next;
|
|
|
|
|
|
|
|
i915_gem_evict_everything(dev_priv->dev);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(obj, next, &dev_priv->mm.unbound_list, gtt_list)
|
2012-06-07 14:38:42 +00:00
|
|
|
i915_gem_object_put_pages(obj);
|
2012-08-20 08:23:20 +00:00
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
static int
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
i915_gem_object_get_pages_gtt(struct drm_i915_gem_object *obj)
|
2010-10-28 12:45:36 +00:00
|
|
|
{
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
|
2010-10-28 12:45:36 +00:00
|
|
|
int page_count, i;
|
|
|
|
struct address_space *mapping;
|
2012-06-01 14:20:22 +00:00
|
|
|
struct sg_table *st;
|
|
|
|
struct scatterlist *sg;
|
2010-10-28 12:45:36 +00:00
|
|
|
struct page *page;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
gfp_t gfp;
|
2010-10-28 12:45:36 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
/* Assert that the object is not currently in any GPU domain. As it
|
|
|
|
* wasn't in the GTT, there shouldn't be any way it could have been in
|
|
|
|
* a GPU cache
|
|
|
|
*/
|
|
|
|
BUG_ON(obj->base.read_domains & I915_GEM_GPU_DOMAINS);
|
|
|
|
BUG_ON(obj->base.write_domain & I915_GEM_GPU_DOMAINS);
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
st = kmalloc(sizeof(*st), GFP_KERNEL);
|
|
|
|
if (st == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
page_count = obj->base.size / PAGE_SIZE;
|
2012-06-01 14:20:22 +00:00
|
|
|
if (sg_alloc_table(st, page_count, GFP_KERNEL)) {
|
|
|
|
sg_free_table(st);
|
|
|
|
kfree(st);
|
2010-10-28 12:45:36 +00:00
|
|
|
return -ENOMEM;
|
2012-06-01 14:20:22 +00:00
|
|
|
}
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
/* Get the list of pages out of our struct file. They'll be pinned
|
|
|
|
* at this point until we release them.
|
|
|
|
*
|
|
|
|
* Fail silently without starting the shrinker
|
|
|
|
*/
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
mapping = obj->base.filp->f_path.dentry->d_inode->i_mapping;
|
|
|
|
gfp = mapping_gfp_mask(mapping);
|
2012-08-27 12:02:37 +00:00
|
|
|
gfp |= __GFP_NORETRY | __GFP_NOWARN;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
gfp &= ~(__GFP_IO | __GFP_WAIT);
|
2012-06-01 14:20:22 +00:00
|
|
|
for_each_sg(st->sgl, sg, page_count, i) {
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
page = shmem_read_mapping_page_gfp(mapping, i, gfp);
|
|
|
|
if (IS_ERR(page)) {
|
|
|
|
i915_gem_purge(dev_priv, page_count);
|
|
|
|
page = shmem_read_mapping_page_gfp(mapping, i, gfp);
|
|
|
|
}
|
|
|
|
if (IS_ERR(page)) {
|
|
|
|
/* We've tried hard to allocate the memory by reaping
|
|
|
|
* our own buffer, now let the real VM do its job and
|
|
|
|
* go down in flames if truly OOM.
|
|
|
|
*/
|
2012-08-27 12:02:37 +00:00
|
|
|
gfp &= ~(__GFP_NORETRY | __GFP_NOWARN);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
gfp |= __GFP_IO | __GFP_WAIT;
|
|
|
|
|
|
|
|
i915_gem_shrink_all(dev_priv);
|
|
|
|
page = shmem_read_mapping_page_gfp(mapping, i, gfp);
|
|
|
|
if (IS_ERR(page))
|
|
|
|
goto err_pages;
|
|
|
|
|
2012-08-27 12:02:37 +00:00
|
|
|
gfp |= __GFP_NORETRY | __GFP_NOWARN;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
gfp &= ~(__GFP_IO | __GFP_WAIT);
|
|
|
|
}
|
2010-10-28 12:45:36 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
sg_set_page(sg, page, PAGE_SIZE, 0);
|
2010-10-28 12:45:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-12 19:30:02 +00:00
|
|
|
if (i915_gem_object_needs_bit17_swizzle(obj))
|
2010-10-28 12:45:36 +00:00
|
|
|
i915_gem_object_do_bit_17_swizzle(obj);
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
obj->pages = st;
|
2010-10-28 12:45:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_pages:
|
2012-06-01 14:20:22 +00:00
|
|
|
for_each_sg(st->sgl, sg, i, page_count)
|
|
|
|
page_cache_release(sg_page(sg));
|
|
|
|
sg_free_table(st);
|
|
|
|
kfree(st);
|
2010-10-28 12:45:36 +00:00
|
|
|
return PTR_ERR(page);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
/* Ensure that the associated pages are gathered from the backing storage
|
|
|
|
* and pinned into our object. i915_gem_object_get_pages() may be called
|
|
|
|
* multiple times before they are released by a single call to
|
|
|
|
* i915_gem_object_put_pages() - once the pages are no longer referenced
|
|
|
|
* either as a result of memory pressure (reaping pages under the shrinker)
|
|
|
|
* or as the object is itself released.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_object_get_pages(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
|
|
|
|
const struct drm_i915_gem_object_ops *ops = obj->ops;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (obj->sg_table || obj->pages)
|
|
|
|
return 0;
|
|
|
|
|
2012-09-04 20:02:54 +00:00
|
|
|
BUG_ON(obj->pages_pin_count);
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
ret = ops->get_pages(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
list_add_tail(&obj->gtt_list, &dev_priv->mm.unbound_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-25 18:00:26 +00:00
|
|
|
void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_move_to_active(struct drm_i915_gem_object *obj,
|
2010-12-04 11:30:53 +00:00
|
|
|
struct intel_ring_buffer *ring,
|
|
|
|
u32 seqno)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
2010-10-19 09:36:51 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-02-11 21:16:02 +00:00
|
|
|
|
2010-05-21 01:08:56 +00:00
|
|
|
BUG_ON(ring == NULL);
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->ring = ring;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
/* Add a reference if we're newly entering the active list. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (!obj->active) {
|
|
|
|
drm_gem_object_reference(&obj->base);
|
|
|
|
obj->active = 1;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
drm/i915: allow lazy emitting of requests
Sometimes (like when flushing in preparation of batchbuffer execution)
we know that we'll emit a request but haven't yet done so. Allow this
case by simply taking the next seqno by default. Ensure that a request
is eventually emitted before waiting for an request by issuing it
in i915_wait_request iff this is not yet done.
Also replace one open-coded version of i915_gem_object_wait_rendering,
to prevent future code-diversion.
Chris Wilson asked me to explain and clarify what this patch does and why.
Here it goes:
Old way of moving objects onto the active list and associating them with a
reques:
1. i915_add_request + store the returned seqno somewhere
2. i915_gem_object_move_to_active (with the stored seqno as parameter)
For the current users, this is all fine. But I'd like to associate objects
(and fence regs) with the batchbuffer request deep down in the execbuf
call-chain. I thought about three ways of implementing this.
a) Don't care, just emit request when we need a new seqno. When heavily
pipelining fence reg changes, this would have caused tons of superflous
request (and corresponding irqs).
b) Thread all changed fences, objects, whatever through the execbuf-maze,
so that when we emit a request, we can store the new seqno at all the right
places.
c) Kill that seqno-threading-around business by simply storing the next
seqno, i.e. allow 2. to be done before 1. in the above sequence.
I've decided to implement c) (in this patch). The following patches are
just fall-out that resulted from this small conceptual change.
* We can handle the flushing list processing where we actually emit a flush
(i915_gem_flush and i915_retire_commands) instead of in i915_add_request.
The code makes IMHO more sense this way (and i915_add_request looses the
flush_domains parameter, obviously).
* We can avoid emitting unnecessary requests. IMHO there's no point in
emitting more than one request per batchbuffer (with or without an
corresponding irq).
* By enforcing 2. before 1. ordering in the above sequence the seqno
argument of i915_gem_object_move_to_active is redundant and can be
dropped.
v2: Now i915_wait_request issues request if it is not yet emitted.
Also introduce i915_gem_next_request_seqno(dev) just in case we ever
need to do some prep work before using a new seqno.
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
[ickle: Keep i915_gem_object_set_to_display_plane() uninterruptible.]
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2010-02-11 21:13:59 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/* Move from whatever list we were on to the tail of execution. */
|
2010-11-08 19:18:58 +00:00
|
|
|
list_move_tail(&obj->mm_list, &dev_priv->mm.active_list);
|
|
|
|
list_move_tail(&obj->ring_list, &ring->active_list);
|
2010-11-12 13:53:37 +00:00
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
obj->last_read_seqno = seqno;
|
2010-11-12 13:53:37 +00:00
|
|
|
|
2012-03-21 10:48:18 +00:00
|
|
|
if (obj->fenced_gpu_access) {
|
2010-11-12 13:53:37 +00:00
|
|
|
obj->last_fenced_seqno = seqno;
|
|
|
|
|
2012-03-21 10:48:18 +00:00
|
|
|
/* Bump MRU to take account of the delayed flush */
|
|
|
|
if (obj->fence_reg != I915_FENCE_REG_NONE) {
|
|
|
|
struct drm_i915_fence_reg *reg;
|
|
|
|
|
|
|
|
reg = &dev_priv->fence_regs[obj->fence_reg];
|
|
|
|
list_move_tail(®->lru_list,
|
|
|
|
&dev_priv->mm.fence_list);
|
|
|
|
}
|
2010-11-12 13:53:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
i915_gem_object_move_to_inactive(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
|
2012-07-20 11:41:02 +00:00
|
|
|
BUG_ON(obj->base.write_domain & ~I915_GEM_GPU_DOMAINS);
|
2010-11-12 13:53:37 +00:00
|
|
|
BUG_ON(!obj->active);
|
2012-07-20 11:41:02 +00:00
|
|
|
|
2012-07-21 11:31:41 +00:00
|
|
|
if (obj->pin_count) /* are we a framebuffer? */
|
|
|
|
intel_mark_fb_idle(obj);
|
|
|
|
|
|
|
|
list_move_tail(&obj->mm_list, &dev_priv->mm.inactive_list);
|
|
|
|
|
2012-07-20 11:41:02 +00:00
|
|
|
list_del_init(&obj->ring_list);
|
2010-11-12 13:53:37 +00:00
|
|
|
obj->ring = NULL;
|
|
|
|
|
2012-07-20 11:41:02 +00:00
|
|
|
obj->last_read_seqno = 0;
|
|
|
|
obj->last_write_seqno = 0;
|
|
|
|
obj->base.write_domain = 0;
|
|
|
|
|
|
|
|
obj->last_fenced_seqno = 0;
|
2010-11-12 13:53:37 +00:00
|
|
|
obj->fenced_gpu_access = false;
|
|
|
|
|
|
|
|
obj->active = 0;
|
|
|
|
drm_gem_object_unreference(&obj->base);
|
|
|
|
|
|
|
|
WARN_ON(i915_verify_lists(dev));
|
2008-11-07 00:00:31 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-01-25 15:32:49 +00:00
|
|
|
static u32
|
|
|
|
i915_gem_get_seqno(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
u32 seqno = dev_priv->next_seqno;
|
|
|
|
|
|
|
|
/* reserve 0 for non-seqno */
|
|
|
|
if (++dev_priv->next_seqno == 0)
|
|
|
|
dev_priv->next_seqno = 1;
|
|
|
|
|
|
|
|
return seqno;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32
|
|
|
|
i915_gem_next_request_seqno(struct intel_ring_buffer *ring)
|
|
|
|
{
|
|
|
|
if (ring->outstanding_lazy_request == 0)
|
|
|
|
ring->outstanding_lazy_request = i915_gem_get_seqno(ring->dev);
|
|
|
|
|
|
|
|
return ring->outstanding_lazy_request;
|
|
|
|
}
|
|
|
|
|
2010-10-27 15:11:02 +00:00
|
|
|
int
|
2011-02-03 11:57:46 +00:00
|
|
|
i915_add_request(struct intel_ring_buffer *ring,
|
2010-09-24 15:02:42 +00:00
|
|
|
struct drm_file *file,
|
2011-02-03 11:57:46 +00:00
|
|
|
struct drm_i915_gem_request *request)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2011-02-03 11:57:46 +00:00
|
|
|
drm_i915_private_t *dev_priv = ring->dev->dev_private;
|
2008-07-30 19:06:12 +00:00
|
|
|
uint32_t seqno;
|
2012-02-15 11:25:36 +00:00
|
|
|
u32 request_ring_position;
|
2008-07-30 19:06:12 +00:00
|
|
|
int was_empty;
|
2010-10-27 15:11:02 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-06-13 18:45:19 +00:00
|
|
|
/*
|
|
|
|
* Emit any outstanding flushes - execbuf can fail to emit the flush
|
|
|
|
* after having emitted the batchbuffer command. Hence we need to fix
|
|
|
|
* things up similar to emitting the lazy request. The difference here
|
|
|
|
* is that the flush _must_ happen before the next request, no matter
|
|
|
|
* what.
|
|
|
|
*/
|
2012-07-20 11:41:08 +00:00
|
|
|
ret = intel_ring_flush_all_caches(ring);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-06-13 18:45:19 +00:00
|
|
|
|
2012-07-20 11:40:59 +00:00
|
|
|
if (request == NULL) {
|
|
|
|
request = kmalloc(sizeof(*request), GFP_KERNEL);
|
|
|
|
if (request == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-01-25 15:32:49 +00:00
|
|
|
seqno = i915_gem_next_request_seqno(ring);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-02-15 11:25:36 +00:00
|
|
|
/* Record the position of the start of the request so that
|
|
|
|
* should we detect the updated seqno part-way through the
|
|
|
|
* GPU processing the request, we never over-estimate the
|
|
|
|
* position of the head.
|
|
|
|
*/
|
|
|
|
request_ring_position = intel_ring_get_tail(ring);
|
|
|
|
|
2010-10-27 15:11:02 +00:00
|
|
|
ret = ring->add_request(ring, &seqno);
|
2012-07-20 11:40:59 +00:00
|
|
|
if (ret) {
|
|
|
|
kfree(request);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_request_add(ring, seqno);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
request->seqno = seqno;
|
2010-05-21 01:08:56 +00:00
|
|
|
request->ring = ring;
|
2012-02-15 11:25:36 +00:00
|
|
|
request->tail = request_ring_position;
|
2008-07-30 19:06:12 +00:00
|
|
|
request->emitted_jiffies = jiffies;
|
2010-05-21 01:08:56 +00:00
|
|
|
was_empty = list_empty(&ring->request_list);
|
|
|
|
list_add_tail(&request->list, &ring->request_list);
|
2012-07-20 11:40:59 +00:00
|
|
|
request->file_priv = NULL;
|
2010-05-21 01:08:56 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
if (file) {
|
|
|
|
struct drm_i915_file_private *file_priv = file->driver_priv;
|
|
|
|
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_lock(&file_priv->mm.lock);
|
2010-09-24 15:02:42 +00:00
|
|
|
request->file_priv = file_priv;
|
2009-06-03 07:27:35 +00:00
|
|
|
list_add_tail(&request->client_list,
|
2010-09-24 15:02:42 +00:00
|
|
|
&file_priv->mm.request_list);
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_unlock(&file_priv->mm.lock);
|
2009-06-03 07:27:35 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-01-25 13:03:57 +00:00
|
|
|
ring->outstanding_lazy_request = 0;
|
2011-02-03 11:57:46 +00:00
|
|
|
|
2009-09-14 21:48:44 +00:00
|
|
|
if (!dev_priv->mm.suspended) {
|
2011-06-29 17:26:42 +00:00
|
|
|
if (i915_enable_hangcheck) {
|
|
|
|
mod_timer(&dev_priv->hangcheck_timer,
|
|
|
|
jiffies +
|
|
|
|
msecs_to_jiffies(DRM_I915_HANGCHECK_PERIOD));
|
|
|
|
}
|
2012-07-21 11:31:41 +00:00
|
|
|
if (was_empty) {
|
2010-09-13 22:44:34 +00:00
|
|
|
queue_delayed_work(dev_priv->wq,
|
|
|
|
&dev_priv->mm.retire_work, HZ);
|
2012-07-21 11:31:41 +00:00
|
|
|
intel_mark_busy(dev_priv->dev);
|
|
|
|
}
|
2009-09-14 21:48:44 +00:00
|
|
|
}
|
2012-06-13 18:45:19 +00:00
|
|
|
|
2010-10-27 15:11:02 +00:00
|
|
|
return 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-09-24 15:02:42 +00:00
|
|
|
static inline void
|
|
|
|
i915_gem_request_remove_from_client(struct drm_i915_gem_request *request)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-09-26 10:03:27 +00:00
|
|
|
struct drm_i915_file_private *file_priv = request->file_priv;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-26 10:03:27 +00:00
|
|
|
if (!file_priv)
|
|
|
|
return;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_lock(&file_priv->mm.lock);
|
drm/i915: Prevent racy removal of request from client list
When i915_gem_retire_requests_ring calls i915_gem_request_remove_from_client,
the client_list for that request may already be removed in i915_gem_release.
So we may call twice list_del(&request->client_list), resulting in an
oops like this report:
[126167.230394] BUG: unable to handle kernel paging request at 00100104
[126167.230699] IP: [<f8c2ce44>] i915_gem_retire_requests_ring+0xd4/0x240 [i915]
[126167.231042] *pdpt = 00000000314c1001 *pde = 0000000000000000
[126167.231314] Oops: 0002 [#1] SMP
[126167.231471] last sysfs file: /sys/devices/LNXSYSTM:00/device:00/PNP0C0A:00/power_supply/BAT1/current_now
[126167.231901] Modules linked in: snd_seq_dummy nls_utf8 isofs btrfs zlib_deflate libcrc32c ufs qnx4 hfsplus hfs minix ntfs vfat msdos fat jfs xfs exportfs reiserfs cryptd aes_i586 aes_generic binfmt_misc vboxnetadp vboxnetflt vboxdrv parport_pc ppdev snd_hda_codec_hdmi snd_hda_codec_conexant snd_hda_intel snd_hda_codec snd_hwdep arc4 snd_pcm snd_seq_midi snd_rawmidi snd_seq_midi_event snd_seq uvcvideo videodev snd_timer snd_seq_device joydev iwlagn iwlcore mac80211 snd cfg80211 soundcore i915 drm_kms_helper snd_page_alloc psmouse drm serio_raw i2c_algo_bit video lp parport usbhid hid sky2 sdhci_pci ahci sdhci libahci
[126167.232018]
[126167.232018] Pid: 1101, comm: Xorg Not tainted 2.6.38-6-generic-pae #34-Ubuntu Gateway MC7833U /
[126167.232018] EIP: 0060:[<f8c2ce44>] EFLAGS: 00213246 CPU: 0
[126167.232018] EIP is at i915_gem_retire_requests_ring+0xd4/0x240 [i915]
[126167.232018] EAX: 00200200 EBX: f1ac25b0 ECX: 00000040 EDX: 00100100
[126167.232018] ESI: f1a2801c EDI: e87fc060 EBP: ef4d7dd8 ESP: ef4d7db0
[126167.232018] DS: 007b ES: 007b FS: 00d8 GS: 00e0 SS: 0068
[126167.232018] Process Xorg (pid: 1101, ti=ef4d6000 task=f1ba6500 task.ti=ef4d6000)
[126167.232018] Stack:
[126167.232018] f1a28000 f1a2809c f1a28094 0058bd97 f1aa2400 f1a2801c 0058bd7b 0058bd85
[126167.232018] f1a2801c f1a28000 ef4d7e38 f8c2e995 ef4d7e30 ef4d7e60 c14d1ebc f6b3a040
[126167.232018] f1522cc0 000000db 00000000 f1ba6500 ffffffa1 00000000 00000001 f1a29214
[126167.232018] Call Trace:
Unfortunately the call trace reported was cut, but looking at debug
symbols the crash is at __list_del, when probably list_del is called
twice on the same request->client_list, as the dereferenced value is
LIST_POISON1 + 4, and by looking more at the debug symbols before
list_del call it should have being called by
i915_gem_request_remove_from_client
And as I can see in the code, it seems we indeed have the possibility
to remove a request->client_list twice, which would cause the above,
because we do list_del(&request->client_list) on both
i915_gem_request_remove_from_client and i915_gem_release
As Chris Wilson pointed out, it's indeed the case:
"(...) I had thought that the actual insertion/deletion was serialised
under the struct mutex and the intention of the spinlock was to protect
the unlocked list traversal during throttling. However, I missed that
i915_gem_release() is also called without struct mutex and so we do need
the double check for i915_gem_request_remove_from_client()."
This change does the required check to avoid the duplicate remove of
request->client_list.
Bugzilla: http://bugs.launchpad.net/bugs/733780
Cc: stable@kernel.org # 2.6.38
Signed-off-by: Herton Ronaldo Krzesinski <herton.krzesinski@canonical.com>
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-03-17 13:45:12 +00:00
|
|
|
if (request->file_priv) {
|
|
|
|
list_del(&request->client_list);
|
|
|
|
request->file_priv = NULL;
|
|
|
|
}
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_unlock(&file_priv->mm.lock);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-09-22 09:31:52 +00:00
|
|
|
static void i915_gem_reset_ring_lists(struct drm_i915_private *dev_priv,
|
|
|
|
struct intel_ring_buffer *ring)
|
2010-09-19 11:21:28 +00:00
|
|
|
{
|
2010-09-22 09:31:52 +00:00
|
|
|
while (!list_empty(&ring->request_list)) {
|
|
|
|
struct drm_i915_gem_request *request;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-22 09:31:52 +00:00
|
|
|
request = list_first_entry(&ring->request_list,
|
|
|
|
struct drm_i915_gem_request,
|
|
|
|
list);
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2010-09-22 09:31:52 +00:00
|
|
|
list_del(&request->list);
|
2010-09-24 15:02:42 +00:00
|
|
|
i915_gem_request_remove_from_client(request);
|
2010-09-22 09:31:52 +00:00
|
|
|
kfree(request);
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-09-22 09:31:52 +00:00
|
|
|
while (!list_empty(&ring->active_list)) {
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-09-19 11:21:28 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = list_first_entry(&ring->active_list,
|
|
|
|
struct drm_i915_gem_object,
|
|
|
|
ring_list);
|
2010-09-19 11:21:28 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_move_to_inactive(obj);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-22 11:50:11 +00:00
|
|
|
static void i915_gem_reset_fences(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
int i;
|
|
|
|
|
2011-10-09 19:52:02 +00:00
|
|
|
for (i = 0; i < dev_priv->num_fence_regs; i++) {
|
2010-11-22 11:50:11 +00:00
|
|
|
struct drm_i915_fence_reg *reg = &dev_priv->fence_regs[i];
|
2010-11-27 17:38:29 +00:00
|
|
|
|
2012-04-17 14:31:32 +00:00
|
|
|
i915_gem_write_fence(dev, i, NULL);
|
2010-11-27 17:38:29 +00:00
|
|
|
|
2012-04-17 14:31:32 +00:00
|
|
|
if (reg->obj)
|
|
|
|
i915_gem_object_fence_lost(reg->obj);
|
2010-11-27 17:38:29 +00:00
|
|
|
|
2012-04-17 14:31:32 +00:00
|
|
|
reg->pin_count = 0;
|
|
|
|
reg->obj = NULL;
|
|
|
|
INIT_LIST_HEAD(®->lru_list);
|
2010-11-22 11:50:11 +00:00
|
|
|
}
|
2012-04-17 14:31:32 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.fence_list);
|
2010-11-22 11:50:11 +00:00
|
|
|
}
|
|
|
|
|
2010-09-30 15:53:18 +00:00
|
|
|
void i915_gem_reset(struct drm_device *dev)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-09-19 11:31:36 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2012-05-11 13:29:30 +00:00
|
|
|
struct intel_ring_buffer *ring;
|
2010-12-04 11:30:53 +00:00
|
|
|
int i;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i)
|
|
|
|
i915_gem_reset_ring_lists(dev_priv, ring);
|
2010-09-22 09:31:52 +00:00
|
|
|
|
|
|
|
/* Move everything out of the GPU domains to ensure we do any
|
|
|
|
* necessary invalidation upon reuse.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
list_for_each_entry(obj,
|
2010-09-19 11:31:36 +00:00
|
|
|
&dev_priv->mm.inactive_list,
|
2010-10-19 09:36:51 +00:00
|
|
|
mm_list)
|
2010-09-19 11:31:36 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains &= ~I915_GEM_GPU_DOMAINS;
|
2010-09-19 11:31:36 +00:00
|
|
|
}
|
2010-09-30 15:53:18 +00:00
|
|
|
|
|
|
|
/* The fence registers are invalidated so clear them out */
|
2010-11-22 11:50:11 +00:00
|
|
|
i915_gem_reset_fences(dev);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function clears the request list as sequence numbers are passed.
|
|
|
|
*/
|
2012-02-15 11:25:36 +00:00
|
|
|
void
|
2011-02-03 11:57:46 +00:00
|
|
|
i915_gem_retire_requests_ring(struct intel_ring_buffer *ring)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
uint32_t seqno;
|
2010-12-04 11:30:53 +00:00
|
|
|
int i;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
if (list_empty(&ring->request_list))
|
2009-02-23 14:07:57 +00:00
|
|
|
return;
|
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
WARN_ON(i915_verify_lists(ring->dev));
|
2012-05-24 22:03:08 +00:00
|
|
|
|
2012-08-09 09:58:30 +00:00
|
|
|
seqno = ring->get_seqno(ring, true);
|
2012-04-26 23:03:03 +00:00
|
|
|
|
2011-01-21 10:07:18 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ring->sync_seqno); i++)
|
2010-12-04 11:30:53 +00:00
|
|
|
if (seqno >= ring->sync_seqno[i])
|
|
|
|
ring->sync_seqno[i] = 0;
|
2012-05-24 22:03:08 +00:00
|
|
|
|
2010-05-21 01:08:56 +00:00
|
|
|
while (!list_empty(&ring->request_list)) {
|
2008-07-30 19:06:12 +00:00
|
|
|
struct drm_i915_gem_request *request;
|
2012-04-26 23:03:03 +00:00
|
|
|
|
2010-05-21 01:08:56 +00:00
|
|
|
request = list_first_entry(&ring->request_list,
|
2008-07-30 19:06:12 +00:00
|
|
|
struct drm_i915_gem_request,
|
|
|
|
list);
|
2012-05-24 22:03:08 +00:00
|
|
|
|
2010-09-22 09:31:52 +00:00
|
|
|
if (!i915_seqno_passed(seqno, request->seqno))
|
2010-09-18 00:38:04 +00:00
|
|
|
break;
|
2012-04-26 23:03:03 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_request_retire(ring, request->seqno);
|
2012-02-15 11:25:36 +00:00
|
|
|
/* We know the GPU must have read the request to have
|
|
|
|
* sent us the seqno + interrupt, so use the position
|
|
|
|
* of tail of the request to update the last known position
|
|
|
|
* of the GPU head.
|
|
|
|
*/
|
|
|
|
ring->last_retired_head = request->tail;
|
2012-04-26 23:03:03 +00:00
|
|
|
|
2010-09-18 00:38:04 +00:00
|
|
|
list_del(&request->list);
|
2010-09-24 15:02:42 +00:00
|
|
|
i915_gem_request_remove_from_client(request);
|
2010-09-18 00:38:04 +00:00
|
|
|
kfree(request);
|
2012-05-24 22:03:08 +00:00
|
|
|
}
|
|
|
|
|
2010-09-18 00:38:04 +00:00
|
|
|
/* Move any buffers on the active list that are no longer referenced
|
|
|
|
* by the ringbuffer to the flushing/inactive lists as appropriate.
|
|
|
|
*/
|
|
|
|
while (!list_empty(&ring->active_list)) {
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2012-04-26 23:03:03 +00:00
|
|
|
|
2011-08-16 19:34:10 +00:00
|
|
|
obj = list_first_entry(&ring->active_list,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object,
|
|
|
|
ring_list);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
if (!i915_seqno_passed(seqno, obj->last_read_seqno))
|
2008-07-30 19:06:12 +00:00
|
|
|
break;
|
|
|
|
|
2012-07-20 11:41:02 +00:00
|
|
|
i915_gem_object_move_to_inactive(obj);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
2010-10-27 15:11:02 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
if (unlikely(ring->trace_irq_seqno &&
|
|
|
|
i915_seqno_passed(seqno, ring->trace_irq_seqno))) {
|
2010-12-04 11:30:53 +00:00
|
|
|
ring->irq_put(ring);
|
2011-02-03 11:57:46 +00:00
|
|
|
ring->trace_irq_seqno = 0;
|
2009-09-24 04:26:06 +00:00
|
|
|
}
|
2010-09-29 15:10:57 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
WARN_ON(i915_verify_lists(ring->dev));
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
2009-09-14 21:48:41 +00:00
|
|
|
|
2010-07-23 22:18:49 +00:00
|
|
|
void
|
|
|
|
i915_gem_retire_requests(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2012-05-11 13:29:30 +00:00
|
|
|
struct intel_ring_buffer *ring;
|
2010-12-04 11:30:53 +00:00
|
|
|
int i;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i)
|
|
|
|
i915_gem_retire_requests_ring(ring);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-08-20 22:25:16 +00:00
|
|
|
static void
|
2008-07-30 19:06:12 +00:00
|
|
|
i915_gem_retire_work_handler(struct work_struct *work)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv;
|
|
|
|
struct drm_device *dev;
|
2012-05-11 13:29:30 +00:00
|
|
|
struct intel_ring_buffer *ring;
|
2011-01-09 21:05:44 +00:00
|
|
|
bool idle;
|
|
|
|
int i;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
dev_priv = container_of(work, drm_i915_private_t,
|
|
|
|
mm.retire_work.work);
|
|
|
|
dev = dev_priv->dev;
|
2012-07-20 11:41:01 +00:00
|
|
|
|
2010-09-29 11:26:37 +00:00
|
|
|
/* Come back later if the device is busy... */
|
|
|
|
if (!mutex_trylock(&dev->struct_mutex)) {
|
|
|
|
queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, HZ);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-07-23 22:18:49 +00:00
|
|
|
i915_gem_retire_requests(dev);
|
2012-07-20 11:41:01 +00:00
|
|
|
|
2011-01-09 21:05:44 +00:00
|
|
|
/* Send a periodic flush down the ring so we don't hold onto GEM
|
|
|
|
* objects indefinitely.
|
2012-07-20 11:41:01 +00:00
|
|
|
*/
|
2011-01-09 21:05:44 +00:00
|
|
|
idle = true;
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2012-07-20 11:40:59 +00:00
|
|
|
if (ring->gpu_caches_dirty)
|
|
|
|
i915_add_request(ring, NULL, NULL);
|
2011-01-09 21:05:44 +00:00
|
|
|
|
|
|
|
idle &= list_empty(&ring->request_list);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2011-01-09 21:05:44 +00:00
|
|
|
if (!dev_priv->mm.suspended && !idle)
|
2009-08-03 23:09:16 +00:00
|
|
|
queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, HZ);
|
2012-07-21 11:31:41 +00:00
|
|
|
if (idle)
|
|
|
|
intel_mark_idle(dev);
|
2011-01-09 21:05:44 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
}
|
|
|
|
|
2012-06-01 13:21:23 +00:00
|
|
|
/**
|
|
|
|
* Ensures that an object will eventually get non-busy by flushing any required
|
|
|
|
* write domains, emitting any outstanding lazy request and retiring and
|
|
|
|
* completed requests.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
i915_gem_object_flush_active(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (obj->active) {
|
2012-07-20 11:41:01 +00:00
|
|
|
ret = i915_gem_check_olr(obj->ring, obj->last_read_seqno);
|
2012-06-01 13:21:23 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-07-20 11:41:01 +00:00
|
|
|
|
2012-06-01 13:21:23 +00:00
|
|
|
i915_gem_retire_requests_ring(obj->ring);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-24 22:03:10 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_wait_ioctl - implements DRM_IOCTL_I915_GEM_WAIT
|
|
|
|
* @DRM_IOCTL_ARGS: standard ioctl arguments
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, else an error is returned with the remaining time in
|
|
|
|
* the timeout parameter.
|
|
|
|
* -ETIME: object is still busy after timeout
|
|
|
|
* -ERESTARTSYS: signal interrupted the wait
|
|
|
|
* -ENONENT: object doesn't exist
|
|
|
|
* Also possible, but rare:
|
|
|
|
* -EAGAIN: GPU wedged
|
|
|
|
* -ENOMEM: damn
|
|
|
|
* -ENODEV: Internal IRQ fail
|
|
|
|
* -E?: The add request failed
|
|
|
|
*
|
|
|
|
* The wait ioctl with a timeout of 0 reimplements the busy ioctl. With any
|
|
|
|
* non-zero timeout parameter the wait ioctl will wait for the given number of
|
|
|
|
* nanoseconds on an object becoming unbusy. Since the wait itself does so
|
|
|
|
* without holding struct_mutex the object may become re-busied before this
|
|
|
|
* function completes. A similar but shorter * race condition exists in the busy
|
|
|
|
* ioctl
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
i915_gem_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_wait *args = data;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
struct intel_ring_buffer *ring = NULL;
|
2012-06-05 22:24:24 +00:00
|
|
|
struct timespec timeout_stack, *timeout = NULL;
|
2012-05-24 22:03:10 +00:00
|
|
|
u32 seqno = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
2012-06-05 22:24:24 +00:00
|
|
|
if (args->timeout_ns >= 0) {
|
|
|
|
timeout_stack = ns_to_timespec(args->timeout_ns);
|
|
|
|
timeout = &timeout_stack;
|
|
|
|
}
|
2012-05-24 22:03:10 +00:00
|
|
|
|
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->bo_handle));
|
|
|
|
if (&obj->base == NULL) {
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2012-06-01 13:21:23 +00:00
|
|
|
/* Need to make sure the object gets inactive eventually. */
|
|
|
|
ret = i915_gem_object_flush_active(obj);
|
2012-05-24 22:03:10 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (obj->active) {
|
2012-07-20 11:41:01 +00:00
|
|
|
seqno = obj->last_read_seqno;
|
2012-05-24 22:03:10 +00:00
|
|
|
ring = obj->ring;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (seqno == 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Do this after OLR check to make sure we make forward progress polling
|
|
|
|
* on this IOCTL with a 0 timeout (like busy ioctl)
|
|
|
|
*/
|
|
|
|
if (!args->timeout_ns) {
|
|
|
|
ret = -ETIME;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_gem_object_unreference(&obj->base);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2012-06-05 22:24:24 +00:00
|
|
|
ret = __wait_seqno(ring, seqno, true, timeout);
|
|
|
|
if (timeout) {
|
|
|
|
WARN_ON(!timespec_valid(timeout));
|
|
|
|
args->timeout_ns = timespec_to_ns(timeout);
|
|
|
|
}
|
2012-05-24 22:03:10 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
out:
|
|
|
|
drm_gem_object_unreference(&obj->base);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-11 18:18:19 +00:00
|
|
|
/**
|
|
|
|
* i915_gem_object_sync - sync an object to a ring.
|
|
|
|
*
|
|
|
|
* @obj: object which may be in use on another ring.
|
|
|
|
* @to: ring we wish to use the object on. May be NULL.
|
|
|
|
*
|
|
|
|
* This code is meant to abstract object synchronization with the GPU.
|
|
|
|
* Calling with NULL implies synchronizing the object with the CPU
|
|
|
|
* rather than a particular GPU ring.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, else propagates up the lower layer error.
|
|
|
|
*/
|
2012-04-05 21:47:36 +00:00
|
|
|
int
|
|
|
|
i915_gem_object_sync(struct drm_i915_gem_object *obj,
|
|
|
|
struct intel_ring_buffer *to)
|
|
|
|
{
|
|
|
|
struct intel_ring_buffer *from = obj->ring;
|
|
|
|
u32 seqno;
|
|
|
|
int ret, idx;
|
|
|
|
|
|
|
|
if (from == NULL || to == from)
|
|
|
|
return 0;
|
|
|
|
|
2012-04-11 18:18:19 +00:00
|
|
|
if (to == NULL || !i915_semaphore_is_enabled(obj->base.dev))
|
2012-07-20 11:41:01 +00:00
|
|
|
return i915_gem_object_wait_rendering(obj, false);
|
2012-04-05 21:47:36 +00:00
|
|
|
|
|
|
|
idx = intel_ring_sync_index(from, to);
|
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
seqno = obj->last_read_seqno;
|
2012-04-05 21:47:36 +00:00
|
|
|
if (seqno <= from->sync_seqno[idx])
|
|
|
|
return 0;
|
|
|
|
|
2012-04-26 03:50:12 +00:00
|
|
|
ret = i915_gem_check_olr(obj->ring, seqno);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-04-05 21:47:36 +00:00
|
|
|
|
2012-04-11 18:18:21 +00:00
|
|
|
ret = to->sync_to(to, from, seqno);
|
2012-04-11 18:18:20 +00:00
|
|
|
if (!ret)
|
|
|
|
from->sync_seqno[idx] = seqno;
|
2012-04-05 21:47:36 +00:00
|
|
|
|
2012-04-11 18:18:20 +00:00
|
|
|
return ret;
|
2012-04-05 21:47:36 +00:00
|
|
|
}
|
|
|
|
|
2011-04-13 21:06:03 +00:00
|
|
|
static void i915_gem_object_finish_gtt(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
u32 old_write_domain, old_read_domains;
|
|
|
|
|
|
|
|
/* Act a barrier for all accesses through the GTT */
|
|
|
|
mb();
|
|
|
|
|
|
|
|
/* Force a pagefault for domain tracking on next user access */
|
|
|
|
i915_gem_release_mmap(obj);
|
|
|
|
|
2011-06-25 04:02:59 +00:00
|
|
|
if ((obj->base.read_domains & I915_GEM_DOMAIN_GTT) == 0)
|
|
|
|
return;
|
|
|
|
|
2011-04-13 21:06:03 +00:00
|
|
|
old_read_domains = obj->base.read_domains;
|
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
|
|
|
|
obj->base.read_domains &= ~I915_GEM_DOMAIN_GTT;
|
|
|
|
obj->base.write_domain &= ~I915_GEM_DOMAIN_GTT;
|
|
|
|
|
|
|
|
trace_i915_gem_object_change_domain(obj,
|
|
|
|
old_read_domains,
|
|
|
|
old_write_domain);
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/**
|
|
|
|
* Unbinds an object from the GTT aperture.
|
|
|
|
*/
|
2009-01-27 01:10:45 +00:00
|
|
|
int
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_unbind(struct drm_i915_gem_object *obj)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2012-02-09 16:15:47 +00:00
|
|
|
drm_i915_private_t *dev_priv = obj->base.dev->dev_private;
|
2008-07-30 19:06:12 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->gtt_space == NULL)
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-05-24 18:11:20 +00:00
|
|
|
if (obj->pin_count)
|
|
|
|
return -EBUSY;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-08-20 09:23:27 +00:00
|
|
|
BUG_ON(obj->pages == NULL);
|
|
|
|
|
2011-04-13 21:04:09 +00:00
|
|
|
ret = i915_gem_object_finish_gpu(obj);
|
2012-04-24 14:47:31 +00:00
|
|
|
if (ret)
|
2011-04-13 21:04:09 +00:00
|
|
|
return ret;
|
|
|
|
/* Continue on if we fail due to EIO, the GPU is hung so we
|
|
|
|
* should be safe and we need to cleanup or else we might
|
|
|
|
* cause memory corruption through use-after-free.
|
|
|
|
*/
|
|
|
|
|
2011-04-13 21:06:03 +00:00
|
|
|
i915_gem_object_finish_gtt(obj);
|
2009-09-09 18:50:45 +00:00
|
|
|
|
2009-12-15 16:50:00 +00:00
|
|
|
/* release the fence reg _after_ flushing */
|
2010-11-10 16:40:20 +00:00
|
|
|
ret = i915_gem_object_put_fence(obj);
|
2012-04-24 14:47:31 +00:00
|
|
|
if (ret)
|
2010-11-10 16:40:20 +00:00
|
|
|
return ret;
|
2009-12-15 16:50:00 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_object_unbind(obj);
|
|
|
|
|
2012-02-15 22:50:22 +00:00
|
|
|
if (obj->has_global_gtt_mapping)
|
|
|
|
i915_gem_gtt_unbind_object(obj);
|
2012-02-09 16:15:47 +00:00
|
|
|
if (obj->has_aliasing_ppgtt_mapping) {
|
|
|
|
i915_ppgtt_unbind_object(dev_priv->mm.aliasing_ppgtt, obj);
|
|
|
|
obj->has_aliasing_ppgtt_mapping = 0;
|
|
|
|
}
|
2012-02-15 22:50:21 +00:00
|
|
|
i915_gem_gtt_finish_object(obj);
|
2012-02-09 16:15:47 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_del(&obj->mm_list);
|
|
|
|
list_move_tail(&obj->gtt_list, &dev_priv->mm.unbound_list);
|
2010-11-04 16:11:09 +00:00
|
|
|
/* Avoid an unnecessary call to unbind on rebind. */
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->map_and_fenceable = true;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_mm_put_block(obj->gtt_space);
|
|
|
|
obj->gtt_space = NULL;
|
|
|
|
obj->gtt_offset = 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
return 0;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 23:02:58 +00:00
|
|
|
static int i915_ring_idle(struct intel_ring_buffer *ring)
|
2010-09-28 09:07:56 +00:00
|
|
|
{
|
2012-07-20 11:41:03 +00:00
|
|
|
if (list_empty(&ring->active_list))
|
2010-10-24 11:38:05 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-05-24 22:03:11 +00:00
|
|
|
return i915_wait_seqno(ring, i915_gem_next_request_seqno(ring));
|
2010-09-28 09:07:56 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 23:02:58 +00:00
|
|
|
int i915_gpu_idle(struct drm_device *dev)
|
2010-02-19 10:52:00 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2012-05-11 13:29:30 +00:00
|
|
|
struct intel_ring_buffer *ring;
|
2010-12-04 11:30:53 +00:00
|
|
|
int ret, i;
|
2010-02-19 10:52:00 +00:00
|
|
|
|
|
|
|
/* Flush everything onto the inactive list. */
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2012-08-14 21:35:14 +00:00
|
|
|
ret = i915_switch_context(ring, NULL, DEFAULT_CONTEXT_ID);
|
2010-12-04 11:30:53 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-05-11 13:29:30 +00:00
|
|
|
|
|
|
|
ret = i915_ring_idle(ring);
|
2012-06-04 21:42:53 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-12-04 11:30:53 +00:00
|
|
|
}
|
2010-02-19 10:52:00 +00:00
|
|
|
|
2010-02-11 21:29:04 +00:00
|
|
|
return 0;
|
2010-02-19 10:52:00 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
static void sandybridge_write_fence_reg(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj)
|
2009-10-26 23:44:17 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
uint64_t val;
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj) {
|
|
|
|
u32 size = obj->gtt_space->size;
|
2009-10-26 23:44:17 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
val = (uint64_t)((obj->gtt_offset + size - 4096) &
|
|
|
|
0xfffff000) << 32;
|
|
|
|
val |= obj->gtt_offset & 0xfffff000;
|
|
|
|
val |= (uint64_t)((obj->stride / 128) - 1) <<
|
|
|
|
SANDYBRIDGE_FENCE_PITCH_SHIFT;
|
2009-10-26 23:44:17 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj->tiling_mode == I915_TILING_Y)
|
|
|
|
val |= 1 << I965_FENCE_TILING_Y_SHIFT;
|
|
|
|
val |= I965_FENCE_REG_VALID;
|
|
|
|
} else
|
|
|
|
val = 0;
|
2010-11-12 13:46:18 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
I915_WRITE64(FENCE_REG_SANDYBRIDGE_0 + reg * 8, val);
|
|
|
|
POSTING_READ(FENCE_REG_SANDYBRIDGE_0 + reg * 8);
|
2009-10-26 23:44:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
static void i965_write_fence_reg(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
uint64_t val;
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj) {
|
|
|
|
u32 size = obj->gtt_space->size;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
val = (uint64_t)((obj->gtt_offset + size - 4096) &
|
|
|
|
0xfffff000) << 32;
|
|
|
|
val |= obj->gtt_offset & 0xfffff000;
|
|
|
|
val |= ((obj->stride / 128) - 1) << I965_FENCE_PITCH_SHIFT;
|
|
|
|
if (obj->tiling_mode == I915_TILING_Y)
|
|
|
|
val |= 1 << I965_FENCE_TILING_Y_SHIFT;
|
|
|
|
val |= I965_FENCE_REG_VALID;
|
|
|
|
} else
|
|
|
|
val = 0;
|
2010-11-12 13:46:18 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
I915_WRITE64(FENCE_REG_965_0 + reg * 8, val);
|
|
|
|
POSTING_READ(FENCE_REG_965_0 + reg * 8);
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
static void i915_write_fence_reg(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2012-04-17 14:31:30 +00:00
|
|
|
u32 val;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj) {
|
|
|
|
u32 size = obj->gtt_space->size;
|
|
|
|
int pitch_val;
|
|
|
|
int tile_width;
|
2010-11-12 13:46:18 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
WARN((obj->gtt_offset & ~I915_FENCE_START_MASK) ||
|
|
|
|
(size & -size) != size ||
|
|
|
|
(obj->gtt_offset & (size - 1)),
|
|
|
|
"object 0x%08x [fenceable? %d] not 1M or pot-size (0x%08x) aligned\n",
|
|
|
|
obj->gtt_offset, obj->map_and_fenceable, size);
|
2010-11-12 13:46:18 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj->tiling_mode == I915_TILING_Y && HAS_128_BYTE_Y_TILING(dev))
|
|
|
|
tile_width = 128;
|
|
|
|
else
|
|
|
|
tile_width = 512;
|
|
|
|
|
|
|
|
/* Note: pitch better be a power of two tile widths */
|
|
|
|
pitch_val = obj->stride / tile_width;
|
|
|
|
pitch_val = ffs(pitch_val) - 1;
|
|
|
|
|
|
|
|
val = obj->gtt_offset;
|
|
|
|
if (obj->tiling_mode == I915_TILING_Y)
|
|
|
|
val |= 1 << I830_FENCE_TILING_Y_SHIFT;
|
|
|
|
val |= I915_FENCE_SIZE_BITS(size);
|
|
|
|
val |= pitch_val << I830_FENCE_PITCH_SHIFT;
|
|
|
|
val |= I830_FENCE_REG_VALID;
|
|
|
|
} else
|
|
|
|
val = 0;
|
|
|
|
|
|
|
|
if (reg < 8)
|
|
|
|
reg = FENCE_REG_830_0 + reg * 4;
|
|
|
|
else
|
|
|
|
reg = FENCE_REG_945_8 + (reg - 8) * 4;
|
|
|
|
|
|
|
|
I915_WRITE(reg, val);
|
|
|
|
POSTING_READ(reg);
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
static void i830_write_fence_reg(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
uint32_t val;
|
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
if (obj) {
|
|
|
|
u32 size = obj->gtt_space->size;
|
|
|
|
uint32_t pitch_val;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
WARN((obj->gtt_offset & ~I830_FENCE_START_MASK) ||
|
|
|
|
(size & -size) != size ||
|
|
|
|
(obj->gtt_offset & (size - 1)),
|
|
|
|
"object 0x%08x not 512K or pot-size 0x%08x aligned\n",
|
|
|
|
obj->gtt_offset, size);
|
2009-05-27 00:44:56 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
pitch_val = obj->stride / 128;
|
|
|
|
pitch_val = ffs(pitch_val) - 1;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
val = obj->gtt_offset;
|
|
|
|
if (obj->tiling_mode == I915_TILING_Y)
|
|
|
|
val |= 1 << I830_FENCE_TILING_Y_SHIFT;
|
|
|
|
val |= I830_FENCE_SIZE_BITS(size);
|
|
|
|
val |= pitch_val << I830_FENCE_PITCH_SHIFT;
|
|
|
|
val |= I830_FENCE_REG_VALID;
|
|
|
|
} else
|
|
|
|
val = 0;
|
2010-11-12 13:46:18 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
I915_WRITE(FENCE_REG_830_0 + reg * 4, val);
|
|
|
|
POSTING_READ(FENCE_REG_830_0 + reg * 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_gem_write_fence(struct drm_device *dev, int reg,
|
|
|
|
struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
switch (INTEL_INFO(dev)->gen) {
|
|
|
|
case 7:
|
|
|
|
case 6: sandybridge_write_fence_reg(dev, reg, obj); break;
|
|
|
|
case 5:
|
|
|
|
case 4: i965_write_fence_reg(dev, reg, obj); break;
|
|
|
|
case 3: i915_write_fence_reg(dev, reg, obj); break;
|
|
|
|
case 2: i830_write_fence_reg(dev, reg, obj); break;
|
|
|
|
default: break;
|
|
|
|
}
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:31 +00:00
|
|
|
static inline int fence_number(struct drm_i915_private *dev_priv,
|
|
|
|
struct drm_i915_fence_reg *fence)
|
|
|
|
{
|
|
|
|
return fence - dev_priv->fence_regs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_gem_object_update_fence(struct drm_i915_gem_object *obj,
|
|
|
|
struct drm_i915_fence_reg *fence,
|
|
|
|
bool enable)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
|
|
|
|
int reg = fence_number(dev_priv, fence);
|
|
|
|
|
|
|
|
i915_gem_write_fence(obj->base.dev, reg, enable ? obj : NULL);
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
obj->fence_reg = reg;
|
|
|
|
fence->obj = obj;
|
|
|
|
list_move_tail(&fence->lru_list, &dev_priv->mm.fence_list);
|
|
|
|
} else {
|
|
|
|
obj->fence_reg = I915_FENCE_REG_NONE;
|
|
|
|
fence->obj = NULL;
|
|
|
|
list_del_init(&fence->lru_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-10 16:40:20 +00:00
|
|
|
static int
|
2012-04-17 14:31:25 +00:00
|
|
|
i915_gem_object_flush_fence(struct drm_i915_gem_object *obj)
|
2010-11-10 16:40:20 +00:00
|
|
|
{
|
2012-04-17 14:31:27 +00:00
|
|
|
if (obj->last_fenced_seqno) {
|
2012-07-20 11:41:04 +00:00
|
|
|
int ret = i915_wait_seqno(obj->ring, obj->last_fenced_seqno);
|
2012-04-17 14:31:29 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-11-10 16:40:20 +00:00
|
|
|
|
|
|
|
obj->last_fenced_seqno = 0;
|
|
|
|
}
|
|
|
|
|
2011-01-04 18:42:07 +00:00
|
|
|
/* Ensure that all CPU reads are completed before installing a fence
|
|
|
|
* and all writes before removing the fence.
|
|
|
|
*/
|
|
|
|
if (obj->base.read_domains & I915_GEM_DOMAIN_GTT)
|
|
|
|
mb();
|
|
|
|
|
2012-07-20 11:41:04 +00:00
|
|
|
obj->fenced_gpu_access = false;
|
2010-11-10 16:40:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_object_put_fence(struct drm_i915_gem_object *obj)
|
|
|
|
{
|
2012-04-17 14:31:31 +00:00
|
|
|
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
|
2010-11-10 16:40:20 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-04-17 14:31:25 +00:00
|
|
|
ret = i915_gem_object_flush_fence(obj);
|
2010-11-10 16:40:20 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-04-17 14:31:31 +00:00
|
|
|
if (obj->fence_reg == I915_FENCE_REG_NONE)
|
|
|
|
return 0;
|
2010-11-10 16:40:20 +00:00
|
|
|
|
2012-04-17 14:31:31 +00:00
|
|
|
i915_gem_object_update_fence(obj,
|
|
|
|
&dev_priv->fence_regs[obj->fence_reg],
|
|
|
|
false);
|
|
|
|
i915_gem_object_fence_lost(obj);
|
2010-11-10 16:40:20 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct drm_i915_fence_reg *
|
2012-04-17 14:31:25 +00:00
|
|
|
i915_find_fence_reg(struct drm_device *dev)
|
2010-02-19 10:51:58 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-04-17 14:31:28 +00:00
|
|
|
struct drm_i915_fence_reg *reg, *avail;
|
2010-11-10 16:40:20 +00:00
|
|
|
int i;
|
2010-02-19 10:51:58 +00:00
|
|
|
|
|
|
|
/* First try to find a free reg */
|
2010-11-10 16:40:20 +00:00
|
|
|
avail = NULL;
|
2010-02-19 10:51:58 +00:00
|
|
|
for (i = dev_priv->fence_reg_start; i < dev_priv->num_fence_regs; i++) {
|
|
|
|
reg = &dev_priv->fence_regs[i];
|
|
|
|
if (!reg->obj)
|
2010-11-10 16:40:20 +00:00
|
|
|
return reg;
|
2010-02-19 10:51:58 +00:00
|
|
|
|
2011-12-14 12:57:08 +00:00
|
|
|
if (!reg->pin_count)
|
2010-11-10 16:40:20 +00:00
|
|
|
avail = reg;
|
2010-02-19 10:51:58 +00:00
|
|
|
}
|
|
|
|
|
2010-11-10 16:40:20 +00:00
|
|
|
if (avail == NULL)
|
|
|
|
return NULL;
|
2010-02-19 10:51:58 +00:00
|
|
|
|
|
|
|
/* None available, try to steal one or wait for a user to finish */
|
2010-11-10 16:40:20 +00:00
|
|
|
list_for_each_entry(reg, &dev_priv->mm.fence_list, lru_list) {
|
2011-12-14 12:57:08 +00:00
|
|
|
if (reg->pin_count)
|
2010-02-19 10:51:58 +00:00
|
|
|
continue;
|
|
|
|
|
2012-04-17 14:31:28 +00:00
|
|
|
return reg;
|
2010-02-19 10:51:58 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 14:31:28 +00:00
|
|
|
return NULL;
|
2010-02-19 10:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-11-12 18:03:55 +00:00
|
|
|
/**
|
2012-03-22 15:10:00 +00:00
|
|
|
* i915_gem_object_get_fence - set up fencing for an object
|
2008-11-12 18:03:55 +00:00
|
|
|
* @obj: object to map through a fence reg
|
|
|
|
*
|
|
|
|
* When mapping objects through the GTT, userspace wants to be able to write
|
|
|
|
* to them without having to worry about swizzling if the object is tiled.
|
|
|
|
* This function walks the fence regs looking for a free one for @obj,
|
|
|
|
* stealing one if it can't find any.
|
|
|
|
*
|
|
|
|
* It then sets up the reg based on the object's properties: address, pitch
|
|
|
|
* and tiling format.
|
2012-03-22 15:10:00 +00:00
|
|
|
*
|
|
|
|
* For an untiled surface, this removes any existing fence.
|
2008-11-12 18:03:55 +00:00
|
|
|
*/
|
2009-06-17 21:08:52 +00:00
|
|
|
int
|
2012-04-17 14:31:24 +00:00
|
|
|
i915_gem_object_get_fence(struct drm_i915_gem_object *obj)
|
2008-11-12 18:03:55 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2012-04-17 14:31:33 +00:00
|
|
|
bool enable = obj->tiling_mode != I915_TILING_NONE;
|
2010-11-10 16:40:20 +00:00
|
|
|
struct drm_i915_fence_reg *reg;
|
2010-02-19 10:51:58 +00:00
|
|
|
int ret;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-04-17 14:31:33 +00:00
|
|
|
/* Have we updated the tiling parameters upon the object and so
|
|
|
|
* will need to serialise the write to the associated fence register?
|
|
|
|
*/
|
2012-04-21 15:23:23 +00:00
|
|
|
if (obj->fence_dirty) {
|
2012-04-17 14:31:33 +00:00
|
|
|
ret = i915_gem_object_flush_fence(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-03-22 15:10:00 +00:00
|
|
|
|
2010-11-10 16:40:20 +00:00
|
|
|
/* Just update our place in the LRU if our fence is getting reused. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->fence_reg != I915_FENCE_REG_NONE) {
|
|
|
|
reg = &dev_priv->fence_regs[obj->fence_reg];
|
2012-04-21 15:23:23 +00:00
|
|
|
if (!obj->fence_dirty) {
|
2012-04-17 14:31:33 +00:00
|
|
|
list_move_tail(®->lru_list,
|
|
|
|
&dev_priv->mm.fence_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else if (enable) {
|
|
|
|
reg = i915_find_fence_reg(dev);
|
|
|
|
if (reg == NULL)
|
|
|
|
return -EDEADLK;
|
2010-11-10 16:40:20 +00:00
|
|
|
|
2012-04-17 14:31:33 +00:00
|
|
|
if (reg->obj) {
|
|
|
|
struct drm_i915_gem_object *old = reg->obj;
|
|
|
|
|
|
|
|
ret = i915_gem_object_flush_fence(old);
|
2011-03-17 15:23:22 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2012-04-17 14:31:33 +00:00
|
|
|
i915_gem_object_fence_lost(old);
|
2011-03-17 15:23:22 +00:00
|
|
|
}
|
2012-04-17 14:31:33 +00:00
|
|
|
} else
|
2009-08-29 19:49:51 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-04-17 14:31:33 +00:00
|
|
|
i915_gem_object_update_fence(obj, reg, enable);
|
2012-04-21 15:23:23 +00:00
|
|
|
obj->fence_dirty = false;
|
2012-04-17 14:31:33 +00:00
|
|
|
|
2012-04-17 14:31:30 +00:00
|
|
|
return 0;
|
2008-11-12 18:03:55 +00:00
|
|
|
}
|
|
|
|
|
2012-07-26 10:49:32 +00:00
|
|
|
static bool i915_gem_valid_gtt_space(struct drm_device *dev,
|
|
|
|
struct drm_mm_node *gtt_space,
|
|
|
|
unsigned long cache_level)
|
|
|
|
{
|
|
|
|
struct drm_mm_node *other;
|
|
|
|
|
|
|
|
/* On non-LLC machines we have to be careful when putting differing
|
|
|
|
* types of snoopable memory together to avoid the prefetcher
|
|
|
|
* crossing memory domains and dieing.
|
|
|
|
*/
|
|
|
|
if (HAS_LLC(dev))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (gtt_space == NULL)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (list_empty(>t_space->node_list))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
other = list_entry(gtt_space->node_list.prev, struct drm_mm_node, node_list);
|
|
|
|
if (other->allocated && !other->hole_follows && other->color != cache_level)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
other = list_entry(gtt_space->node_list.next, struct drm_mm_node, node_list);
|
|
|
|
if (other->allocated && !gtt_space->hole_follows && other->color != cache_level)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void i915_gem_verify_gtt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
#if WATCH_GTT
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(obj, &dev_priv->mm.gtt_list, gtt_list) {
|
|
|
|
if (obj->gtt_space == NULL) {
|
|
|
|
printk(KERN_ERR "object found on GTT list with no space reserved\n");
|
|
|
|
err++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj->cache_level != obj->gtt_space->color) {
|
|
|
|
printk(KERN_ERR "object reserved space [%08lx, %08lx] with wrong color, cache_level=%x, color=%lx\n",
|
|
|
|
obj->gtt_space->start,
|
|
|
|
obj->gtt_space->start + obj->gtt_space->size,
|
|
|
|
obj->cache_level,
|
|
|
|
obj->gtt_space->color);
|
|
|
|
err++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!i915_gem_valid_gtt_space(dev,
|
|
|
|
obj->gtt_space,
|
|
|
|
obj->cache_level)) {
|
|
|
|
printk(KERN_ERR "invalid GTT space found at [%08lx, %08lx] - color=%x\n",
|
|
|
|
obj->gtt_space->start,
|
|
|
|
obj->gtt_space->start + obj->gtt_space->size,
|
|
|
|
obj->cache_level);
|
|
|
|
err++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(err);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/**
|
|
|
|
* Finds free space in the GTT aperture and binds the object there.
|
|
|
|
*/
|
|
|
|
static int
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
|
2010-09-16 15:54:23 +00:00
|
|
|
unsigned alignment,
|
2012-08-11 14:41:04 +00:00
|
|
|
bool map_and_fenceable,
|
|
|
|
bool nonblocking)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
2008-07-30 19:06:12 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
struct drm_mm_node *free_space;
|
2010-11-14 21:32:36 +00:00
|
|
|
u32 size, fence_size, fence_alignment, unfenced_alignment;
|
2010-11-04 16:11:09 +00:00
|
|
|
bool mappable, fenceable;
|
2009-09-14 15:50:30 +00:00
|
|
|
int ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv != I915_MADV_WILLNEED) {
|
2009-09-14 15:50:29 +00:00
|
|
|
DRM_ERROR("Attempting to bind a purgeable object\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-07-18 20:11:49 +00:00
|
|
|
fence_size = i915_gem_get_gtt_size(dev,
|
|
|
|
obj->base.size,
|
|
|
|
obj->tiling_mode);
|
|
|
|
fence_alignment = i915_gem_get_gtt_alignment(dev,
|
|
|
|
obj->base.size,
|
|
|
|
obj->tiling_mode);
|
|
|
|
unfenced_alignment =
|
|
|
|
i915_gem_get_unfenced_gtt_alignment(dev,
|
|
|
|
obj->base.size,
|
|
|
|
obj->tiling_mode);
|
2010-09-24 20:15:47 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
if (alignment == 0)
|
2010-11-14 21:32:36 +00:00
|
|
|
alignment = map_and_fenceable ? fence_alignment :
|
|
|
|
unfenced_alignment;
|
2010-11-04 16:11:09 +00:00
|
|
|
if (map_and_fenceable && alignment & (fence_alignment - 1)) {
|
2008-07-30 19:06:12 +00:00
|
|
|
DRM_ERROR("Invalid object alignment requested %u\n", alignment);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
size = map_and_fenceable ? fence_size : obj->base.size;
|
2010-09-24 20:15:47 +00:00
|
|
|
|
2010-05-27 12:18:21 +00:00
|
|
|
/* If the object is bigger than the entire aperture, reject it early
|
|
|
|
* before evicting everything in a vain attempt to find space.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->base.size >
|
2010-11-04 16:11:09 +00:00
|
|
|
(map_and_fenceable ? dev_priv->mm.gtt_mappable_end : dev_priv->mm.gtt_total)) {
|
2010-05-27 12:18:21 +00:00
|
|
|
DRM_ERROR("Attempting to bind an object larger than the aperture\n");
|
|
|
|
return -E2BIG;
|
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
ret = i915_gem_object_get_pages(obj);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
search_free:
|
2010-11-04 16:11:09 +00:00
|
|
|
if (map_and_fenceable)
|
2010-09-16 15:54:23 +00:00
|
|
|
free_space =
|
2012-07-26 10:49:32 +00:00
|
|
|
drm_mm_search_free_in_range_color(&dev_priv->mm.gtt_space,
|
|
|
|
size, alignment, obj->cache_level,
|
|
|
|
0, dev_priv->mm.gtt_mappable_end,
|
|
|
|
false);
|
2010-09-16 15:54:23 +00:00
|
|
|
else
|
2012-07-26 10:49:32 +00:00
|
|
|
free_space = drm_mm_search_free_color(&dev_priv->mm.gtt_space,
|
|
|
|
size, alignment, obj->cache_level,
|
|
|
|
false);
|
2010-09-16 15:54:23 +00:00
|
|
|
|
|
|
|
if (free_space != NULL) {
|
2010-11-04 16:11:09 +00:00
|
|
|
if (map_and_fenceable)
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->gtt_space =
|
2010-09-16 15:54:23 +00:00
|
|
|
drm_mm_get_block_range_generic(free_space,
|
2012-07-26 10:49:32 +00:00
|
|
|
size, alignment, obj->cache_level,
|
2012-07-10 10:15:23 +00:00
|
|
|
0, dev_priv->mm.gtt_mappable_end,
|
2012-07-26 10:49:32 +00:00
|
|
|
false);
|
2010-09-16 15:54:23 +00:00
|
|
|
else
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->gtt_space =
|
2012-07-26 10:49:32 +00:00
|
|
|
drm_mm_get_block_generic(free_space,
|
|
|
|
size, alignment, obj->cache_level,
|
|
|
|
false);
|
2010-09-16 15:54:23 +00:00
|
|
|
}
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->gtt_space == NULL) {
|
2010-11-04 16:11:09 +00:00
|
|
|
ret = i915_gem_evict_something(dev, size, alignment,
|
2012-07-26 10:49:32 +00:00
|
|
|
obj->cache_level,
|
2012-08-11 14:41:04 +00:00
|
|
|
map_and_fenceable,
|
|
|
|
nonblocking);
|
2009-09-20 23:22:34 +00:00
|
|
|
if (ret)
|
2008-07-30 19:06:12 +00:00
|
|
|
return ret;
|
2009-09-20 23:22:34 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
goto search_free;
|
|
|
|
}
|
2012-07-26 10:49:32 +00:00
|
|
|
if (WARN_ON(!i915_gem_valid_gtt_space(dev,
|
|
|
|
obj->gtt_space,
|
|
|
|
obj->cache_level))) {
|
|
|
|
drm_mm_put_block(obj->gtt_space);
|
|
|
|
obj->gtt_space = NULL;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
|
2012-02-15 22:50:21 +00:00
|
|
|
ret = i915_gem_gtt_prepare_object(obj);
|
2010-11-06 09:10:47 +00:00
|
|
|
if (ret) {
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_mm_put_block(obj->gtt_space);
|
|
|
|
obj->gtt_space = NULL;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2012-02-15 22:50:24 +00:00
|
|
|
if (!dev_priv->mm.aliasing_ppgtt)
|
|
|
|
i915_gem_gtt_bind_object(obj, obj->cache_level);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_move_tail(&obj->gtt_list, &dev_priv->mm.bound_list);
|
2010-11-08 19:18:58 +00:00
|
|
|
list_add_tail(&obj->mm_list, &dev_priv->mm.inactive_list);
|
2010-08-07 10:01:20 +00:00
|
|
|
|
2010-11-24 12:23:44 +00:00
|
|
|
obj->gtt_offset = obj->gtt_space->start;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2010-11-04 16:11:09 +00:00
|
|
|
fenceable =
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->gtt_space->size == fence_size &&
|
2011-08-16 19:34:10 +00:00
|
|
|
(obj->gtt_space->start & (fence_alignment - 1)) == 0;
|
2010-09-24 20:15:47 +00:00
|
|
|
|
2010-11-04 16:11:09 +00:00
|
|
|
mappable =
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->gtt_offset + obj->base.size <= dev_priv->mm.gtt_mappable_end;
|
2010-09-24 20:15:47 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->map_and_fenceable = mappable && fenceable;
|
2010-11-04 16:11:09 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
trace_i915_gem_object_bind(obj, map_and_fenceable);
|
2012-07-26 10:49:32 +00:00
|
|
|
i915_gem_verify_gtt(dev);
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_clflush_object(struct drm_i915_gem_object *obj)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
/* If we don't have a page list set up, then we're not pinned
|
|
|
|
* to GPU, and we can ignore the cache flush because it'll happen
|
|
|
|
* again at bind time.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->pages == NULL)
|
2008-07-30 19:06:12 +00:00
|
|
|
return;
|
|
|
|
|
2011-03-29 23:59:52 +00:00
|
|
|
/* If the GPU is snooping the contents of the CPU cache,
|
|
|
|
* we do not need to manually clear the CPU cache lines. However,
|
|
|
|
* the caches are only snooped when the render cache is
|
|
|
|
* flushed/invalidated. As we always have to emit invalidations
|
|
|
|
* and flushes when moving into and out of the RENDER domain, correct
|
|
|
|
* snooping behaviour occurs naturally as the result of our domain
|
|
|
|
* tracking.
|
|
|
|
*/
|
|
|
|
if (obj->cache_level != I915_CACHE_NONE)
|
|
|
|
return;
|
|
|
|
|
2009-08-25 10:15:50 +00:00
|
|
|
trace_i915_gem_object_clflush(obj);
|
2009-05-27 01:46:16 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
drm_clflush_sg(obj->pages);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
/** Flushes the GTT write domain for the object if it's dirty. */
|
|
|
|
static void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_flush_gtt_write_domain(struct drm_i915_gem_object *obj)
|
2008-11-14 21:35:19 +00:00
|
|
|
{
|
2009-08-25 10:15:50 +00:00
|
|
|
uint32_t old_write_domain;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->base.write_domain != I915_GEM_DOMAIN_GTT)
|
2008-11-14 21:35:19 +00:00
|
|
|
return;
|
|
|
|
|
2011-01-04 18:42:07 +00:00
|
|
|
/* No actual flushing is required for the GTT write domain. Writes
|
2008-11-14 21:35:19 +00:00
|
|
|
* to it immediately go to main memory as far as we know, so there's
|
|
|
|
* no chipset flush. It also doesn't land in render cache.
|
2011-01-04 18:42:07 +00:00
|
|
|
*
|
|
|
|
* However, we do have to enforce the order so that all writes through
|
|
|
|
* the GTT land before any writes to the device, such as updates to
|
|
|
|
* the GATT itself.
|
2008-11-14 21:35:19 +00:00
|
|
|
*/
|
2011-01-04 18:42:07 +00:00
|
|
|
wmb();
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
obj->base.write_domain = 0;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
trace_i915_gem_object_change_domain(obj,
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains,
|
2009-08-25 10:15:50 +00:00
|
|
|
old_write_domain);
|
2008-11-14 21:35:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Flushes the CPU write domain for the object if it's dirty. */
|
|
|
|
static void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_flush_cpu_write_domain(struct drm_i915_gem_object *obj)
|
2008-11-14 21:35:19 +00:00
|
|
|
{
|
2009-08-25 10:15:50 +00:00
|
|
|
uint32_t old_write_domain;
|
2008-11-14 21:35:19 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->base.write_domain != I915_GEM_DOMAIN_CPU)
|
2008-11-14 21:35:19 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
i915_gem_clflush_object(obj);
|
2010-11-05 17:12:18 +00:00
|
|
|
intel_gtt_chipset_flush();
|
2010-11-08 19:18:58 +00:00
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
obj->base.write_domain = 0;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
trace_i915_gem_object_change_domain(obj,
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains,
|
2009-08-25 10:15:50 +00:00
|
|
|
old_write_domain);
|
2008-11-14 21:35:19 +00:00
|
|
|
}
|
|
|
|
|
2008-11-10 18:53:25 +00:00
|
|
|
/**
|
|
|
|
* Moves a single object to the GTT read, and possibly write domain.
|
|
|
|
*
|
|
|
|
* This function returns when the move is complete, including waiting on
|
|
|
|
* flushes to occur.
|
|
|
|
*/
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
int
|
2010-11-23 15:26:33 +00:00
|
|
|
i915_gem_object_set_to_gtt_domain(struct drm_i915_gem_object *obj, bool write)
|
2008-11-10 18:53:25 +00:00
|
|
|
{
|
2012-04-24 14:52:35 +00:00
|
|
|
drm_i915_private_t *dev_priv = obj->base.dev->dev_private;
|
2009-08-25 10:15:50 +00:00
|
|
|
uint32_t old_write_domain, old_read_domains;
|
2008-11-14 21:35:19 +00:00
|
|
|
int ret;
|
2008-11-10 18:53:25 +00:00
|
|
|
|
2008-11-26 21:58:13 +00:00
|
|
|
/* Not valid to be called on unbound objects. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->gtt_space == NULL)
|
2008-11-26 21:58:13 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-02-07 15:23:02 +00:00
|
|
|
if (obj->base.write_domain == I915_GEM_DOMAIN_GTT)
|
|
|
|
return 0;
|
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
ret = i915_gem_object_wait_rendering(obj, !write);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-06-07 13:03:05 +00:00
|
|
|
|
2010-09-13 22:56:38 +00:00
|
|
|
i915_gem_object_flush_cpu_write_domain(obj);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
old_read_domains = obj->base.read_domains;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
/* It should now be out of any other write domains, and we can update
|
|
|
|
* the domain values for our changes.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
BUG_ON((obj->base.write_domain & ~I915_GEM_DOMAIN_GTT) != 0);
|
|
|
|
obj->base.read_domains |= I915_GEM_DOMAIN_GTT;
|
2008-11-14 21:35:19 +00:00
|
|
|
if (write) {
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains = I915_GEM_DOMAIN_GTT;
|
|
|
|
obj->base.write_domain = I915_GEM_DOMAIN_GTT;
|
|
|
|
obj->dirty = 1;
|
2008-11-10 18:53:25 +00:00
|
|
|
}
|
|
|
|
|
2009-08-25 10:15:50 +00:00
|
|
|
trace_i915_gem_object_change_domain(obj,
|
|
|
|
old_read_domains,
|
|
|
|
old_write_domain);
|
|
|
|
|
2012-04-24 14:52:35 +00:00
|
|
|
/* And bump the LRU for this access */
|
|
|
|
if (i915_gem_object_is_inactive(obj))
|
|
|
|
list_move_tail(&obj->mm_list, &dev_priv->mm.inactive_list);
|
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-04 08:44:39 +00:00
|
|
|
int i915_gem_object_set_cache_level(struct drm_i915_gem_object *obj,
|
|
|
|
enum i915_cache_level cache_level)
|
|
|
|
{
|
2012-02-09 16:15:47 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2011-04-04 08:44:39 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (obj->cache_level == cache_level)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (obj->pin_count) {
|
|
|
|
DRM_DEBUG("can not change the cache level of pinned objects\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2012-07-26 10:49:32 +00:00
|
|
|
if (!i915_gem_valid_gtt_space(dev, obj->gtt_space, cache_level)) {
|
|
|
|
ret = i915_gem_object_unbind(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-04 08:44:39 +00:00
|
|
|
if (obj->gtt_space) {
|
|
|
|
ret = i915_gem_object_finish_gpu(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
i915_gem_object_finish_gtt(obj);
|
|
|
|
|
|
|
|
/* Before SandyBridge, you could not use tiling or fence
|
|
|
|
* registers with snooped memory, so relinquish any fences
|
|
|
|
* currently pointing to our region in the aperture.
|
|
|
|
*/
|
2012-07-26 10:49:32 +00:00
|
|
|
if (INTEL_INFO(dev)->gen < 6) {
|
2011-04-04 08:44:39 +00:00
|
|
|
ret = i915_gem_object_put_fence(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-02-15 22:50:22 +00:00
|
|
|
if (obj->has_global_gtt_mapping)
|
|
|
|
i915_gem_gtt_bind_object(obj, cache_level);
|
2012-02-09 16:15:47 +00:00
|
|
|
if (obj->has_aliasing_ppgtt_mapping)
|
|
|
|
i915_ppgtt_bind_object(dev_priv->mm.aliasing_ppgtt,
|
|
|
|
obj, cache_level);
|
2012-07-26 10:49:32 +00:00
|
|
|
|
|
|
|
obj->gtt_space->color = cache_level;
|
2011-04-04 08:44:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cache_level == I915_CACHE_NONE) {
|
|
|
|
u32 old_read_domains, old_write_domain;
|
|
|
|
|
|
|
|
/* If we're coming from LLC cached, then we haven't
|
|
|
|
* actually been tracking whether the data is in the
|
|
|
|
* CPU cache or not, since we only allow one bit set
|
|
|
|
* in obj->write_domain and have been skipping the clflushes.
|
|
|
|
* Just set it to the CPU cache for now.
|
|
|
|
*/
|
|
|
|
WARN_ON(obj->base.write_domain & ~I915_GEM_DOMAIN_CPU);
|
|
|
|
WARN_ON(obj->base.read_domains & ~I915_GEM_DOMAIN_CPU);
|
|
|
|
|
|
|
|
old_read_domains = obj->base.read_domains;
|
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
|
|
|
|
obj->base.read_domains = I915_GEM_DOMAIN_CPU;
|
|
|
|
obj->base.write_domain = I915_GEM_DOMAIN_CPU;
|
|
|
|
|
|
|
|
trace_i915_gem_object_change_domain(obj,
|
|
|
|
old_read_domains,
|
|
|
|
old_write_domain);
|
|
|
|
}
|
|
|
|
|
|
|
|
obj->cache_level = cache_level;
|
2012-07-26 10:49:32 +00:00
|
|
|
i915_gem_verify_gtt(dev);
|
2011-04-04 08:44:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-10 09:27:08 +00:00
|
|
|
int i915_gem_get_cacheing_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_cacheing *args = data;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
|
|
|
if (&obj->base == NULL) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
args->cacheing = obj->cache_level != I915_CACHE_NONE;
|
|
|
|
|
|
|
|
drm_gem_object_unreference(&obj->base);
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int i915_gem_set_cacheing_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_cacheing *args = data;
|
|
|
|
struct drm_i915_gem_object *obj;
|
|
|
|
enum i915_cache_level level;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
switch (args->cacheing) {
|
|
|
|
case I915_CACHEING_NONE:
|
|
|
|
level = I915_CACHE_NONE;
|
|
|
|
break;
|
|
|
|
case I915_CACHEING_CACHED:
|
|
|
|
level = I915_CACHE_LLC;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
|
|
|
if (&obj->base == NULL) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = i915_gem_object_set_cache_level(obj, level);
|
|
|
|
|
|
|
|
drm_gem_object_unreference(&obj->base);
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-25 05:09:39 +00:00
|
|
|
/*
|
2011-04-14 08:41:17 +00:00
|
|
|
* Prepare buffer for display plane (scanout, cursors, etc).
|
|
|
|
* Can be called from an uninterruptible phase (modesetting) and allows
|
|
|
|
* any flushes to be pipelined (for pageflips).
|
2009-11-25 05:09:39 +00:00
|
|
|
*/
|
|
|
|
int
|
2011-04-14 08:41:17 +00:00
|
|
|
i915_gem_object_pin_to_display_plane(struct drm_i915_gem_object *obj,
|
|
|
|
u32 alignment,
|
2010-11-12 13:42:53 +00:00
|
|
|
struct intel_ring_buffer *pipelined)
|
2009-11-25 05:09:39 +00:00
|
|
|
{
|
2011-04-14 08:41:17 +00:00
|
|
|
u32 old_read_domains, old_write_domain;
|
2009-11-25 05:09:39 +00:00
|
|
|
int ret;
|
|
|
|
|
2010-12-06 14:36:27 +00:00
|
|
|
if (pipelined != obj->ring) {
|
2012-04-05 21:47:36 +00:00
|
|
|
ret = i915_gem_object_sync(obj, pipelined);
|
|
|
|
if (ret)
|
2009-11-25 05:09:39 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-29 23:59:54 +00:00
|
|
|
/* The display engine is not coherent with the LLC cache on gen6. As
|
|
|
|
* a result, we make sure that the pinning that is about to occur is
|
|
|
|
* done with uncached PTEs. This is lowest common denominator for all
|
|
|
|
* chipsets.
|
|
|
|
*
|
|
|
|
* However for gen6+, we could do better by using the GFDT bit instead
|
|
|
|
* of uncaching, which would allow us to flush all the LLC-cached data
|
|
|
|
* with that bit in the PTE to main memory with just one PIPE_CONTROL.
|
|
|
|
*/
|
|
|
|
ret = i915_gem_object_set_cache_level(obj, I915_CACHE_NONE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-04-14 08:41:17 +00:00
|
|
|
/* As the user may map the buffer once pinned in the display plane
|
|
|
|
* (e.g. libkms for the bootup splash), we have to ensure that we
|
|
|
|
* always use map_and_fenceable for all scanout buffers.
|
|
|
|
*/
|
2012-08-11 14:41:04 +00:00
|
|
|
ret = i915_gem_object_pin(obj, alignment, true, false);
|
2011-04-14 08:41:17 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2010-05-27 12:18:14 +00:00
|
|
|
i915_gem_object_flush_cpu_write_domain(obj);
|
|
|
|
|
2011-04-14 08:41:17 +00:00
|
|
|
old_write_domain = obj->base.write_domain;
|
2010-11-08 19:18:58 +00:00
|
|
|
old_read_domains = obj->base.read_domains;
|
2011-04-14 08:41:17 +00:00
|
|
|
|
|
|
|
/* It should now be out of any other write domains, and we can update
|
|
|
|
* the domain values for our changes.
|
|
|
|
*/
|
2012-07-20 11:41:00 +00:00
|
|
|
obj->base.write_domain = 0;
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains |= I915_GEM_DOMAIN_GTT;
|
2009-11-25 05:09:39 +00:00
|
|
|
|
|
|
|
trace_i915_gem_object_change_domain(obj,
|
|
|
|
old_read_domains,
|
2011-04-14 08:41:17 +00:00
|
|
|
old_write_domain);
|
2009-11-25 05:09:39 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-13 09:49:11 +00:00
|
|
|
int
|
2011-04-13 21:04:09 +00:00
|
|
|
i915_gem_object_finish_gpu(struct drm_i915_gem_object *obj)
|
2010-11-13 09:49:11 +00:00
|
|
|
{
|
2011-01-07 17:09:48 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-04-13 21:04:09 +00:00
|
|
|
if ((obj->base.read_domains & I915_GEM_GPU_DOMAINS) == 0)
|
2010-11-13 09:49:11 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
ret = i915_gem_object_wait_rendering(obj, false);
|
2011-12-14 12:57:23 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-04-13 21:04:09 +00:00
|
|
|
/* Ensure that we invalidate the GPU's caches and TLBs. */
|
|
|
|
obj->base.read_domains &= ~I915_GEM_GPU_DOMAINS;
|
2011-12-14 12:57:23 +00:00
|
|
|
return 0;
|
2010-11-13 09:49:11 +00:00
|
|
|
}
|
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
/**
|
|
|
|
* Moves a single object to the CPU read, and possibly write domain.
|
|
|
|
*
|
|
|
|
* This function returns when the move is complete, including waiting on
|
|
|
|
* flushes to occur.
|
|
|
|
*/
|
2012-03-26 08:10:27 +00:00
|
|
|
int
|
2010-11-12 13:42:53 +00:00
|
|
|
i915_gem_object_set_to_cpu_domain(struct drm_i915_gem_object *obj, bool write)
|
2008-11-14 21:35:19 +00:00
|
|
|
{
|
2009-08-25 10:15:50 +00:00
|
|
|
uint32_t old_write_domain, old_read_domains;
|
2008-11-14 21:35:19 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-02-07 15:23:02 +00:00
|
|
|
if (obj->base.write_domain == I915_GEM_DOMAIN_CPU)
|
|
|
|
return 0;
|
|
|
|
|
2012-07-20 11:41:01 +00:00
|
|
|
ret = i915_gem_object_wait_rendering(obj, !write);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-11-10 18:53:25 +00:00
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
i915_gem_object_flush_gtt_write_domain(obj);
|
2008-11-10 18:53:25 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
old_write_domain = obj->base.write_domain;
|
|
|
|
old_read_domains = obj->base.read_domains;
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2008-11-14 21:35:19 +00:00
|
|
|
/* Flush the CPU cache if it's still invalid. */
|
2010-11-08 19:18:58 +00:00
|
|
|
if ((obj->base.read_domains & I915_GEM_DOMAIN_CPU) == 0) {
|
2008-11-10 18:53:25 +00:00
|
|
|
i915_gem_clflush_object(obj);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains |= I915_GEM_DOMAIN_CPU;
|
2008-11-10 18:53:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* It should now be out of any other write domains, and we can update
|
|
|
|
* the domain values for our changes.
|
|
|
|
*/
|
2010-11-08 19:18:58 +00:00
|
|
|
BUG_ON((obj->base.write_domain & ~I915_GEM_DOMAIN_CPU) != 0);
|
2008-11-14 21:35:19 +00:00
|
|
|
|
|
|
|
/* If we're writing through the CPU, then the GPU read domains will
|
|
|
|
* need to be invalidated at next use.
|
|
|
|
*/
|
|
|
|
if (write) {
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.read_domains = I915_GEM_DOMAIN_CPU;
|
|
|
|
obj->base.write_domain = I915_GEM_DOMAIN_CPU;
|
2008-11-14 21:35:19 +00:00
|
|
|
}
|
2008-11-10 18:53:25 +00:00
|
|
|
|
2009-08-25 10:15:50 +00:00
|
|
|
trace_i915_gem_object_change_domain(obj,
|
|
|
|
old_read_domains,
|
|
|
|
old_write_domain);
|
|
|
|
|
2008-11-10 18:53:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
/* Throttle our rendering by waiting until the ring has completed our requests
|
|
|
|
* emitted over 20 msec ago.
|
|
|
|
*
|
2009-06-03 07:27:35 +00:00
|
|
|
* Note that if we were to use the current jiffies each time around the loop,
|
|
|
|
* we wouldn't escape the function with any frames outstanding if the time to
|
|
|
|
* render a frame was over 20ms.
|
|
|
|
*
|
2008-07-30 19:06:12 +00:00
|
|
|
* This should get us reasonable parallelism between CPU and GPU but also
|
|
|
|
* relatively low latency when blocking on a particular request to finish.
|
|
|
|
*/
|
2009-03-12 18:23:52 +00:00
|
|
|
static int
|
2010-09-24 15:02:42 +00:00
|
|
|
i915_gem_ring_throttle(struct drm_device *dev, struct drm_file *file)
|
2009-03-12 18:23:52 +00:00
|
|
|
{
|
2010-09-24 15:02:42 +00:00
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_file_private *file_priv = file->driver_priv;
|
2009-06-03 07:27:35 +00:00
|
|
|
unsigned long recent_enough = jiffies - msecs_to_jiffies(20);
|
2010-09-24 15:02:42 +00:00
|
|
|
struct drm_i915_gem_request *request;
|
|
|
|
struct intel_ring_buffer *ring = NULL;
|
|
|
|
u32 seqno = 0;
|
|
|
|
int ret;
|
2010-01-31 10:40:48 +00:00
|
|
|
|
2011-01-26 15:39:14 +00:00
|
|
|
if (atomic_read(&dev_priv->mm.wedged))
|
|
|
|
return -EIO;
|
|
|
|
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_lock(&file_priv->mm.lock);
|
2010-09-24 15:02:42 +00:00
|
|
|
list_for_each_entry(request, &file_priv->mm.request_list, client_list) {
|
2009-06-03 07:27:35 +00:00
|
|
|
if (time_after_eq(request->emitted_jiffies, recent_enough))
|
|
|
|
break;
|
2009-03-12 18:23:52 +00:00
|
|
|
|
2010-09-24 15:02:42 +00:00
|
|
|
ring = request->ring;
|
|
|
|
seqno = request->seqno;
|
2009-06-03 07:27:35 +00:00
|
|
|
}
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_unlock(&file_priv->mm.lock);
|
2009-03-12 18:23:52 +00:00
|
|
|
|
2010-09-24 15:02:42 +00:00
|
|
|
if (seqno == 0)
|
|
|
|
return 0;
|
2009-04-06 20:55:41 +00:00
|
|
|
|
2012-05-24 22:03:08 +00:00
|
|
|
ret = __wait_seqno(ring, seqno, true, NULL);
|
2010-09-24 15:02:42 +00:00
|
|
|
if (ret == 0)
|
|
|
|
queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, 0);
|
2009-03-12 18:23:52 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
int
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_pin(struct drm_i915_gem_object *obj,
|
|
|
|
uint32_t alignment,
|
2012-08-11 14:41:04 +00:00
|
|
|
bool map_and_fenceable,
|
|
|
|
bool nonblocking)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
BUG_ON(obj->pin_count == DRM_I915_GEM_OBJECT_MAX_PIN_COUNT);
|
2010-05-27 12:18:18 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->gtt_space != NULL) {
|
|
|
|
if ((alignment && obj->gtt_offset & (alignment - 1)) ||
|
|
|
|
(map_and_fenceable && !obj->map_and_fenceable)) {
|
|
|
|
WARN(obj->pin_count,
|
2010-08-04 11:37:41 +00:00
|
|
|
"bo is already pinned with incorrect alignment:"
|
2010-11-04 16:11:09 +00:00
|
|
|
" offset=%x, req.alignment=%x, req.map_and_fenceable=%d,"
|
|
|
|
" obj->map_and_fenceable=%d\n",
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->gtt_offset, alignment,
|
2010-11-04 16:11:09 +00:00
|
|
|
map_and_fenceable,
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->map_and_fenceable);
|
2010-05-27 12:18:18 +00:00
|
|
|
ret = i915_gem_object_unbind(obj);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->gtt_space == NULL) {
|
2010-09-24 20:15:47 +00:00
|
|
|
ret = i915_gem_object_bind_to_gtt(obj, alignment,
|
2012-08-11 14:41:04 +00:00
|
|
|
map_and_fenceable,
|
|
|
|
nonblocking);
|
2009-09-20 23:22:34 +00:00
|
|
|
if (ret)
|
2008-07-30 19:06:12 +00:00
|
|
|
return ret;
|
2009-02-11 14:26:45 +00:00
|
|
|
}
|
2009-12-18 03:05:42 +00:00
|
|
|
|
2012-02-15 22:50:22 +00:00
|
|
|
if (!obj->has_global_gtt_mapping && map_and_fenceable)
|
|
|
|
i915_gem_gtt_bind_object(obj, obj->cache_level);
|
|
|
|
|
2012-04-24 14:47:30 +00:00
|
|
|
obj->pin_count++;
|
2010-11-24 12:23:44 +00:00
|
|
|
obj->pin_mappable |= map_and_fenceable;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_object_unpin(struct drm_i915_gem_object *obj)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
BUG_ON(obj->pin_count == 0);
|
|
|
|
BUG_ON(obj->gtt_space == NULL);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-04-24 14:47:30 +00:00
|
|
|
if (--obj->pin_count == 0)
|
2010-11-24 12:23:44 +00:00
|
|
|
obj->pin_mappable = false;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_pin_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_pin *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2008-07-30 19:06:12 +00:00
|
|
|
int ret;
|
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv != I915_MADV_WILLNEED) {
|
2009-09-22 13:24:13 +00:00
|
|
|
DRM_ERROR("Attempting to pin a purgeable buffer\n");
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2009-09-14 15:50:29 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->pin_filp != NULL && obj->pin_filp != file) {
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
DRM_ERROR("Already pinned in i915_gem_pin_ioctl(): %d\n",
|
|
|
|
args->handle);
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->user_pin_count++;
|
|
|
|
obj->pin_filp = file;
|
|
|
|
if (obj->user_pin_count == 1) {
|
2012-08-11 14:41:04 +00:00
|
|
|
ret = i915_gem_object_pin(obj, args->alignment, true, false);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX - flush the CPU caches for pinned objects
|
|
|
|
* as the X server doesn't manage domains yet
|
|
|
|
*/
|
2008-11-14 21:35:19 +00:00
|
|
|
i915_gem_object_flush_cpu_write_domain(obj);
|
2010-11-08 19:18:58 +00:00
|
|
|
args->offset = obj->gtt_offset;
|
2010-10-17 08:45:41 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-10-17 08:45:41 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_unpin_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_pin *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-09-25 10:22:51 +00:00
|
|
|
int ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
2010-09-25 10:22:51 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->pin_filp != file) {
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
DRM_ERROR("Not pinned by caller in i915_gem_pin_ioctl(): %d\n",
|
|
|
|
args->handle);
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
}
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->user_pin_count--;
|
|
|
|
if (obj->user_pin_count == 0) {
|
|
|
|
obj->pin_filp = NULL;
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
i915_gem_object_unpin(obj);
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-10-17 08:45:41 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_busy_ioctl(struct drm_device *dev, void *data,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_file *file)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
|
|
|
struct drm_i915_gem_busy *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-09-25 09:19:17 +00:00
|
|
|
int ret;
|
|
|
|
|
2010-09-25 10:22:51 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
2010-10-17 08:45:41 +00:00
|
|
|
if (ret)
|
2010-09-25 10:22:51 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
2010-05-21 01:08:57 +00:00
|
|
|
|
2010-08-04 14:36:30 +00:00
|
|
|
/* Count all active objects as busy, even if they are currently not used
|
|
|
|
* by the gpu. Users of this interface expect objects to eventually
|
|
|
|
* become non-busy without any further actions, therefore emit any
|
|
|
|
* necessary flushes here.
|
2008-12-15 03:05:04 +00:00
|
|
|
*/
|
2012-06-01 13:21:23 +00:00
|
|
|
ret = i915_gem_object_flush_active(obj);
|
2010-08-04 14:36:30 +00:00
|
|
|
|
2012-06-01 13:21:23 +00:00
|
|
|
args->busy = obj->active;
|
2012-07-04 11:25:08 +00:00
|
|
|
if (obj->ring) {
|
|
|
|
BUILD_BUG_ON(I915_NUM_RINGS > 16);
|
|
|
|
args->busy |= intel_ring_flag(obj->ring) << 16;
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2008-07-30 19:06:12 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-10-17 08:45:41 +00:00
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_throttle_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
2011-08-16 19:34:10 +00:00
|
|
|
return i915_gem_ring_throttle(dev, file_priv);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2009-09-14 15:50:29 +00:00
|
|
|
int
|
|
|
|
i915_gem_madvise_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_i915_gem_madvise *args = data;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-09-25 10:22:51 +00:00
|
|
|
int ret;
|
2009-09-14 15:50:29 +00:00
|
|
|
|
|
|
|
switch (args->madv) {
|
|
|
|
case I915_MADV_DONTNEED:
|
|
|
|
case I915_MADV_WILLNEED:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = i915_mutex_lock_interruptible(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj = to_intel_bo(drm_gem_object_lookup(dev, file_priv, args->handle));
|
2011-02-19 11:31:06 +00:00
|
|
|
if (&obj->base == NULL) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto unlock;
|
2009-09-14 15:50:29 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->pin_count) {
|
2010-10-17 08:45:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2009-09-14 15:50:29 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->madv != __I915_MADV_PURGED)
|
|
|
|
obj->madv = args->madv;
|
2009-09-14 15:50:29 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
/* if the object is no longer attached, discard its backing storage */
|
|
|
|
if (i915_gem_object_is_purgeable(obj) && obj->pages == NULL)
|
2009-09-20 22:13:10 +00:00
|
|
|
i915_gem_object_truncate(obj);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
args->retained = obj->madv != __I915_MADV_PURGED;
|
2009-09-22 13:24:13 +00:00
|
|
|
|
2010-10-17 08:45:41 +00:00
|
|
|
out:
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_unreference(&obj->base);
|
2010-10-17 08:45:41 +00:00
|
|
|
unlock:
|
2009-09-14 15:50:29 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2010-10-17 08:45:41 +00:00
|
|
|
return ret;
|
2009-09-14 15:50:29 +00:00
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
void i915_gem_object_init(struct drm_i915_gem_object *obj,
|
|
|
|
const struct drm_i915_gem_object_ops *ops)
|
2012-08-11 14:41:06 +00:00
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&obj->mm_list);
|
|
|
|
INIT_LIST_HEAD(&obj->gtt_list);
|
|
|
|
INIT_LIST_HEAD(&obj->ring_list);
|
|
|
|
INIT_LIST_HEAD(&obj->exec_list);
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
obj->ops = ops;
|
|
|
|
|
2012-08-11 14:41:06 +00:00
|
|
|
obj->fence_reg = I915_FENCE_REG_NONE;
|
|
|
|
obj->madv = I915_MADV_WILLNEED;
|
|
|
|
/* Avoid an unnecessary call to unbind on the first bind. */
|
|
|
|
obj->map_and_fenceable = true;
|
|
|
|
|
|
|
|
i915_gem_info_add_obj(obj->base.dev->dev_private, obj->base.size);
|
|
|
|
}
|
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
static const struct drm_i915_gem_object_ops i915_gem_object_ops = {
|
|
|
|
.get_pages = i915_gem_object_get_pages_gtt,
|
|
|
|
.put_pages = i915_gem_object_put_pages_gtt,
|
|
|
|
};
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *i915_gem_alloc_object(struct drm_device *dev,
|
|
|
|
size_t size)
|
2010-04-09 19:05:06 +00:00
|
|
|
{
|
2010-04-09 19:05:07 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2011-06-27 23:18:18 +00:00
|
|
|
struct address_space *mapping;
|
2012-05-24 19:48:12 +00:00
|
|
|
u32 mask;
|
2010-04-09 19:05:06 +00:00
|
|
|
|
2010-04-09 19:05:07 +00:00
|
|
|
obj = kzalloc(sizeof(*obj), GFP_KERNEL);
|
|
|
|
if (obj == NULL)
|
|
|
|
return NULL;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-04-09 19:05:07 +00:00
|
|
|
if (drm_gem_object_init(dev, &obj->base, size) != 0) {
|
|
|
|
kfree(obj);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-05-24 19:48:12 +00:00
|
|
|
mask = GFP_HIGHUSER | __GFP_RECLAIMABLE;
|
|
|
|
if (IS_CRESTLINE(dev) || IS_BROADWATER(dev)) {
|
|
|
|
/* 965gm cannot relocate objects above 4GiB. */
|
|
|
|
mask &= ~__GFP_HIGHMEM;
|
|
|
|
mask |= __GFP_DMA32;
|
|
|
|
}
|
|
|
|
|
2011-06-27 23:18:18 +00:00
|
|
|
mapping = obj->base.filp->f_path.dentry->d_inode->i_mapping;
|
2012-05-24 19:48:12 +00:00
|
|
|
mapping_set_gfp_mask(mapping, mask);
|
2011-06-27 23:18:18 +00:00
|
|
|
|
2012-06-07 14:38:42 +00:00
|
|
|
i915_gem_object_init(obj, &i915_gem_object_ops);
|
2010-09-30 10:46:12 +00:00
|
|
|
|
2010-04-09 19:05:07 +00:00
|
|
|
obj->base.write_domain = I915_GEM_DOMAIN_CPU;
|
|
|
|
obj->base.read_domains = I915_GEM_DOMAIN_CPU;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2012-01-17 16:43:53 +00:00
|
|
|
if (HAS_LLC(dev)) {
|
|
|
|
/* On some devices, we can have the GPU use the LLC (the CPU
|
2011-03-29 23:59:55 +00:00
|
|
|
* cache) for about a 10% performance improvement
|
|
|
|
* compared to uncached. Graphics requests other than
|
|
|
|
* display scanout are coherent with the CPU in
|
|
|
|
* accessing this cache. This means in this mode we
|
|
|
|
* don't need to clflush on the CPU side, and on the
|
|
|
|
* GPU side we only need to flush internal caches to
|
|
|
|
* get data visible to the CPU.
|
|
|
|
*
|
|
|
|
* However, we maintain the display planes as UC, and so
|
|
|
|
* need to rebind when first used as such.
|
|
|
|
*/
|
|
|
|
obj->cache_level = I915_CACHE_LLC;
|
|
|
|
} else
|
|
|
|
obj->cache_level = I915_CACHE_NONE;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
return obj;
|
2010-04-09 19:05:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int i915_gem_init_object(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
BUG();
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-24 14:47:31 +00:00
|
|
|
void i915_gem_free_object(struct drm_gem_object *gem_obj)
|
2008-07-30 19:06:12 +00:00
|
|
|
{
|
2012-04-24 14:47:31 +00:00
|
|
|
struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
2010-07-23 22:18:50 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2011-03-20 11:20:19 +00:00
|
|
|
trace_i915_gem_object_destroy(obj);
|
|
|
|
|
2012-05-10 13:25:09 +00:00
|
|
|
if (gem_obj->import_attach)
|
|
|
|
drm_prime_gem_destroy(gem_obj, obj->sg_table);
|
|
|
|
|
2012-04-24 14:47:31 +00:00
|
|
|
if (obj->phys_obj)
|
|
|
|
i915_gem_detach_phys_object(dev, obj);
|
|
|
|
|
|
|
|
obj->pin_count = 0;
|
|
|
|
if (WARN_ON(i915_gem_object_unbind(obj) == -ERESTARTSYS)) {
|
|
|
|
bool was_interruptible;
|
|
|
|
|
|
|
|
was_interruptible = dev_priv->mm.interruptible;
|
|
|
|
dev_priv->mm.interruptible = false;
|
|
|
|
|
|
|
|
WARN_ON(i915_gem_object_unbind(obj));
|
|
|
|
|
|
|
|
dev_priv->mm.interruptible = was_interruptible;
|
|
|
|
}
|
|
|
|
|
2012-09-04 20:02:54 +00:00
|
|
|
obj->pages_pin_count = 0;
|
2012-06-07 14:38:42 +00:00
|
|
|
i915_gem_object_put_pages(obj);
|
2012-08-11 14:41:03 +00:00
|
|
|
i915_gem_object_free_mmap_offset(obj);
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
BUG_ON(obj->pages);
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
drm_gem_object_release(&obj->base);
|
|
|
|
i915_gem_info_remove_obj(dev_priv, obj->base.size);
|
2010-04-09 19:05:07 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
kfree(obj->bit_17);
|
|
|
|
kfree(obj);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-01-07 10:39:13 +00:00
|
|
|
int
|
|
|
|
i915_gem_idle(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
int ret;
|
2008-11-13 23:00:55 +00:00
|
|
|
|
2010-01-07 10:39:13 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2010-10-19 09:13:00 +00:00
|
|
|
if (dev_priv->mm.suspended) {
|
2010-01-07 10:39:13 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return 0;
|
2008-11-13 23:00:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 23:02:58 +00:00
|
|
|
ret = i915_gpu_idle(dev);
|
2008-10-15 04:41:13 +00:00
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2008-07-30 19:06:12 +00:00
|
|
|
return ret;
|
2008-10-15 04:41:13 +00:00
|
|
|
}
|
2012-04-26 23:02:58 +00:00
|
|
|
i915_gem_retire_requests(dev);
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2010-01-07 10:39:13 +00:00
|
|
|
/* Under UMS, be paranoid and evict. */
|
2012-04-24 17:22:52 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
i915_gem_evict_everything(dev);
|
2010-01-07 10:39:13 +00:00
|
|
|
|
2010-11-22 11:50:11 +00:00
|
|
|
i915_gem_reset_fences(dev);
|
|
|
|
|
2010-01-07 10:39:13 +00:00
|
|
|
/* Hack! Don't let anybody do execbuf while we don't control the chip.
|
|
|
|
* We need to replace this with a semaphore, or something.
|
|
|
|
* And not confound mm.suspended!
|
|
|
|
*/
|
|
|
|
dev_priv->mm.suspended = 1;
|
2010-08-20 16:18:48 +00:00
|
|
|
del_timer_sync(&dev_priv->hangcheck_timer);
|
2010-01-07 10:39:13 +00:00
|
|
|
|
|
|
|
i915_kernel_lost_context(dev);
|
2008-10-15 04:41:13 +00:00
|
|
|
i915_gem_cleanup_ringbuffer(dev);
|
2010-01-07 10:39:13 +00:00
|
|
|
|
2008-10-15 04:41:13 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
2010-01-07 10:39:13 +00:00
|
|
|
/* Cancel the retire work handler, which should be idle now. */
|
|
|
|
cancel_delayed_work_sync(&dev_priv->mm.retire_work);
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-25 23:56:24 +00:00
|
|
|
void i915_gem_l3_remap(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
u32 misccpctl;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!IS_IVYBRIDGE(dev))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!dev_priv->mm.l3_remap_info)
|
|
|
|
return;
|
|
|
|
|
|
|
|
misccpctl = I915_READ(GEN7_MISCCPCTL);
|
|
|
|
I915_WRITE(GEN7_MISCCPCTL, misccpctl & ~GEN7_DOP_CLOCK_GATE_ENABLE);
|
|
|
|
POSTING_READ(GEN7_MISCCPCTL);
|
|
|
|
|
|
|
|
for (i = 0; i < GEN7_L3LOG_SIZE; i += 4) {
|
|
|
|
u32 remap = I915_READ(GEN7_L3LOG_BASE + i);
|
|
|
|
if (remap && remap != dev_priv->mm.l3_remap_info[i/4])
|
|
|
|
DRM_DEBUG("0x%x was already programmed to %x\n",
|
|
|
|
GEN7_L3LOG_BASE + i, remap);
|
|
|
|
if (remap && !dev_priv->mm.l3_remap_info[i/4])
|
|
|
|
DRM_DEBUG_DRIVER("Clearing remapped register\n");
|
|
|
|
I915_WRITE(GEN7_L3LOG_BASE + i, dev_priv->mm.l3_remap_info[i/4]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure all the writes land before disabling dop clock gating */
|
|
|
|
POSTING_READ(GEN7_L3LOG_BASE);
|
|
|
|
|
|
|
|
I915_WRITE(GEN7_MISCCPCTL, misccpctl);
|
|
|
|
}
|
|
|
|
|
2012-02-02 08:58:12 +00:00
|
|
|
void i915_gem_init_swizzling(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
|
2012-01-31 15:47:55 +00:00
|
|
|
if (INTEL_INFO(dev)->gen < 5 ||
|
2012-02-02 08:58:12 +00:00
|
|
|
dev_priv->mm.bit_6_swizzle_x == I915_BIT_6_SWIZZLE_NONE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
I915_WRITE(DISP_ARB_CTL, I915_READ(DISP_ARB_CTL) |
|
|
|
|
DISP_TILE_SURFACE_SWIZZLING);
|
|
|
|
|
2012-01-31 15:47:55 +00:00
|
|
|
if (IS_GEN5(dev))
|
|
|
|
return;
|
|
|
|
|
2012-02-02 08:58:12 +00:00
|
|
|
I915_WRITE(TILECTL, I915_READ(TILECTL) | TILECTL_SWZCTL);
|
|
|
|
if (IS_GEN6(dev))
|
2012-04-24 12:04:12 +00:00
|
|
|
I915_WRITE(ARB_MODE, _MASKED_BIT_ENABLE(ARB_MODE_SWIZZLE_SNB));
|
2012-02-02 08:58:12 +00:00
|
|
|
else
|
2012-04-24 12:04:12 +00:00
|
|
|
I915_WRITE(ARB_MODE, _MASKED_BIT_ENABLE(ARB_MODE_SWIZZLE_IVB));
|
2012-02-02 08:58:12 +00:00
|
|
|
}
|
2012-02-09 19:53:27 +00:00
|
|
|
|
|
|
|
void i915_gem_init_ppgtt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
uint32_t pd_offset;
|
|
|
|
struct intel_ring_buffer *ring;
|
2012-03-21 23:14:43 +00:00
|
|
|
struct i915_hw_ppgtt *ppgtt = dev_priv->mm.aliasing_ppgtt;
|
|
|
|
uint32_t __iomem *pd_addr;
|
|
|
|
uint32_t pd_entry;
|
2012-02-09 19:53:27 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!dev_priv->mm.aliasing_ppgtt)
|
|
|
|
return;
|
|
|
|
|
2012-03-21 23:14:43 +00:00
|
|
|
|
|
|
|
pd_addr = dev_priv->mm.gtt->gtt + ppgtt->pd_offset/sizeof(uint32_t);
|
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++) {
|
|
|
|
dma_addr_t pt_addr;
|
|
|
|
|
|
|
|
if (dev_priv->mm.gtt->needs_dmar)
|
|
|
|
pt_addr = ppgtt->pt_dma_addr[i];
|
|
|
|
else
|
|
|
|
pt_addr = page_to_phys(ppgtt->pt_pages[i]);
|
|
|
|
|
|
|
|
pd_entry = GEN6_PDE_ADDR_ENCODE(pt_addr);
|
|
|
|
pd_entry |= GEN6_PDE_VALID;
|
|
|
|
|
|
|
|
writel(pd_entry, pd_addr + i);
|
|
|
|
}
|
|
|
|
readl(pd_addr);
|
|
|
|
|
|
|
|
pd_offset = ppgtt->pd_offset;
|
2012-02-09 19:53:27 +00:00
|
|
|
pd_offset /= 64; /* in cachelines, */
|
|
|
|
pd_offset <<= 16;
|
|
|
|
|
|
|
|
if (INTEL_INFO(dev)->gen == 6) {
|
2012-04-11 18:42:40 +00:00
|
|
|
uint32_t ecochk, gab_ctl, ecobits;
|
|
|
|
|
|
|
|
ecobits = I915_READ(GAC_ECO_BITS);
|
|
|
|
I915_WRITE(GAC_ECO_BITS, ecobits | ECOBITS_PPGTT_CACHE64B);
|
2012-04-11 18:42:39 +00:00
|
|
|
|
|
|
|
gab_ctl = I915_READ(GAB_CTL);
|
|
|
|
I915_WRITE(GAB_CTL, gab_ctl | GAB_CTL_CONT_AFTER_PAGEFAULT);
|
|
|
|
|
|
|
|
ecochk = I915_READ(GAM_ECOCHK);
|
2012-02-09 19:53:27 +00:00
|
|
|
I915_WRITE(GAM_ECOCHK, ecochk | ECOCHK_SNB_BIT |
|
|
|
|
ECOCHK_PPGTT_CACHE64B);
|
2012-04-24 12:04:12 +00:00
|
|
|
I915_WRITE(GFX_MODE, _MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
|
2012-02-09 19:53:27 +00:00
|
|
|
} else if (INTEL_INFO(dev)->gen >= 7) {
|
|
|
|
I915_WRITE(GAM_ECOCHK, ECOCHK_PPGTT_CACHE64B);
|
|
|
|
/* GFX_MODE is per-ring on gen7+ */
|
|
|
|
}
|
|
|
|
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i) {
|
2012-02-09 19:53:27 +00:00
|
|
|
if (INTEL_INFO(dev)->gen >= 7)
|
|
|
|
I915_WRITE(RING_MODE_GEN7(ring),
|
2012-04-24 12:04:12 +00:00
|
|
|
_MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
|
2012-02-09 19:53:27 +00:00
|
|
|
|
|
|
|
I915_WRITE(RING_PP_DIR_DCLV(ring), PP_DIR_DCLV_2G);
|
|
|
|
I915_WRITE(RING_PP_DIR_BASE(ring), pd_offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-05 22:49:40 +00:00
|
|
|
static bool
|
|
|
|
intel_enable_blt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (!HAS_BLT(dev))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* The blitter was dysfunctional on early prototypes */
|
|
|
|
if (IS_GEN6(dev) && dev->pdev->revision < 8) {
|
|
|
|
DRM_INFO("BLT not supported on this pre-production hardware;"
|
|
|
|
" graphics performance will be degraded.\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-05-21 01:08:55 +00:00
|
|
|
int
|
2012-02-02 08:58:12 +00:00
|
|
|
i915_gem_init_hw(struct drm_device *dev)
|
2010-05-21 01:08:55 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
int ret;
|
2010-05-27 12:18:22 +00:00
|
|
|
|
2012-06-07 13:56:03 +00:00
|
|
|
if (!intel_enable_gtt())
|
|
|
|
return -EIO;
|
|
|
|
|
2012-05-25 23:56:24 +00:00
|
|
|
i915_gem_l3_remap(dev);
|
|
|
|
|
2012-02-02 08:58:12 +00:00
|
|
|
i915_gem_init_swizzling(dev);
|
|
|
|
|
2010-09-16 02:43:11 +00:00
|
|
|
ret = intel_init_render_ring_buffer(dev);
|
2010-05-27 12:18:22 +00:00
|
|
|
if (ret)
|
2010-11-12 10:46:37 +00:00
|
|
|
return ret;
|
2010-05-27 12:18:22 +00:00
|
|
|
|
|
|
|
if (HAS_BSD(dev)) {
|
2010-09-16 02:43:11 +00:00
|
|
|
ret = intel_init_bsd_ring_buffer(dev);
|
2010-05-27 12:18:22 +00:00
|
|
|
if (ret)
|
|
|
|
goto cleanup_render_ring;
|
2010-05-21 01:08:57 +00:00
|
|
|
}
|
2010-05-27 12:18:22 +00:00
|
|
|
|
2012-07-05 22:49:40 +00:00
|
|
|
if (intel_enable_blt(dev)) {
|
2010-10-19 10:19:32 +00:00
|
|
|
ret = intel_init_blt_ring_buffer(dev);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup_bsd_ring;
|
|
|
|
}
|
|
|
|
|
2010-08-07 10:01:22 +00:00
|
|
|
dev_priv->next_seqno = 1;
|
|
|
|
|
drm/i915: preliminary context support
Very basic code for context setup/destruction in the driver.
Adds the file i915_gem_context.c This file implements HW context
support. On gen5+ a HW context consists of an opaque GPU object which is
referenced at times of context saves and restores. With RC6 enabled,
the context is also referenced as the GPU enters and exists from RC6
(GPU has it's own internal power context, except on gen5). Though
something like a context does exist for the media ring, the code only
supports contexts for the render ring.
In software, there is a distinction between contexts created by the
user, and the default HW context. The default HW context is used by GPU
clients that do not request setup of their own hardware context. The
default context's state is never restored to help prevent programming
errors. This would happen if a client ran and piggy-backed off another
clients GPU state. The default context only exists to give the GPU some
offset to load as the current to invoke a save of the context we
actually care about. In fact, the code could likely be constructed,
albeit in a more complicated fashion, to never use the default context,
though that limits the driver's ability to swap out, and/or destroy
other contexts.
All other contexts are created as a request by the GPU client. These
contexts store GPU state, and thus allow GPU clients to not re-emit
state (and potentially query certain state) at any time. The kernel
driver makes certain that the appropriate commands are inserted.
There are 4 entry points into the contexts, init, fini, open, close.
The names are self-explanatory except that init can be called during
reset, and also during pm thaw/resume. As we expect our context to be
preserved across these events, we do not reinitialize in this case.
As Adam Jackson pointed out, The cutoff of 1MB where a HW context is
considered too big is arbitrary. The reason for this is even though
context sizes are increasing with every generation, they have yet to
eclipse even 32k. If we somehow read back way more than that, it
probably means BIOS has done something strange, or we're running on a
platform that wasn't designed for this.
v2: rename load/unload to init/fini (daniel)
remove ILK support for get_size() (indirectly daniel)
add HAS_HW_CONTEXTS macro to clarify supported platforms (daniel)
added comments (Ben)
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
2012-06-04 21:42:42 +00:00
|
|
|
/*
|
|
|
|
* XXX: There was some w/a described somewhere suggesting loading
|
|
|
|
* contexts before PPGTT.
|
|
|
|
*/
|
|
|
|
i915_gem_context_init(dev);
|
2012-02-09 19:53:27 +00:00
|
|
|
i915_gem_init_ppgtt(dev);
|
|
|
|
|
2010-05-27 12:18:22 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-10-19 10:19:32 +00:00
|
|
|
cleanup_bsd_ring:
|
2010-12-04 11:30:53 +00:00
|
|
|
intel_cleanup_ring_buffer(&dev_priv->ring[VCS]);
|
2010-05-27 12:18:22 +00:00
|
|
|
cleanup_render_ring:
|
2010-12-04 11:30:53 +00:00
|
|
|
intel_cleanup_ring_buffer(&dev_priv->ring[RCS]);
|
2010-05-21 01:08:55 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-24 14:47:41 +00:00
|
|
|
static bool
|
|
|
|
intel_enable_ppgtt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (i915_enable_ppgtt >= 0)
|
|
|
|
return i915_enable_ppgtt;
|
|
|
|
|
|
|
|
#ifdef CONFIG_INTEL_IOMMU
|
|
|
|
/* Disable ppgtt on SNB if VT-d is on. */
|
|
|
|
if (INTEL_INFO(dev)->gen == 6 && intel_iommu_gfx_mapped)
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int i915_gem_init(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
unsigned long gtt_size, mappable_size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
gtt_size = dev_priv->mm.gtt->gtt_total_entries << PAGE_SHIFT;
|
|
|
|
mappable_size = dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
if (intel_enable_ppgtt(dev) && HAS_ALIASING_PPGTT(dev)) {
|
|
|
|
/* PPGTT pdes are stolen from global gtt ptes, so shrink the
|
|
|
|
* aperture accordingly when using aliasing ppgtt. */
|
|
|
|
gtt_size -= I915_PPGTT_PD_ENTRIES*PAGE_SIZE;
|
|
|
|
|
|
|
|
i915_gem_init_global_gtt(dev, 0, mappable_size, gtt_size);
|
|
|
|
|
|
|
|
ret = i915_gem_init_aliasing_ppgtt(dev);
|
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Let GEM Manage all of the aperture.
|
|
|
|
*
|
|
|
|
* However, leave one page at the end still bound to the scratch
|
|
|
|
* page. There are a number of places where the hardware
|
|
|
|
* apparently prefetches past the end of the object, and we've
|
|
|
|
* seen multiple hangs with the GPU head pointer stuck in a
|
|
|
|
* batchbuffer bound at the last page of the aperture. One page
|
|
|
|
* should be enough to keep any prefetching inside of the
|
|
|
|
* aperture.
|
|
|
|
*/
|
|
|
|
i915_gem_init_global_gtt(dev, 0, mappable_size,
|
|
|
|
gtt_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = i915_gem_init_hw(dev);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
if (ret) {
|
|
|
|
i915_gem_cleanup_aliasing_ppgtt(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-26 21:28:03 +00:00
|
|
|
/* Allow hardware batchbuffers unless told otherwise, but not for KMS. */
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
dev_priv->dri1.allow_batchbuffer = 1;
|
2012-04-24 14:47:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-21 01:08:55 +00:00
|
|
|
void
|
|
|
|
i915_gem_cleanup_ringbuffer(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2012-05-11 13:29:30 +00:00
|
|
|
struct intel_ring_buffer *ring;
|
2010-12-04 11:30:53 +00:00
|
|
|
int i;
|
2010-05-21 01:08:55 +00:00
|
|
|
|
2012-05-11 13:29:30 +00:00
|
|
|
for_each_ring(ring, dev_priv, i)
|
|
|
|
intel_cleanup_ring_buffer(ring);
|
2010-05-21 01:08:55 +00:00
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
int
|
|
|
|
i915_gem_entervt_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
2012-05-11 13:29:30 +00:00
|
|
|
int ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return 0;
|
|
|
|
|
2009-09-14 21:48:47 +00:00
|
|
|
if (atomic_read(&dev_priv->mm.wedged)) {
|
2008-07-30 19:06:12 +00:00
|
|
|
DRM_ERROR("Reenabling wedged hardware, good luck\n");
|
2009-09-14 21:48:47 +00:00
|
|
|
atomic_set(&dev_priv->mm.wedged, 0);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
2008-12-24 02:42:32 +00:00
|
|
|
dev_priv->mm.suspended = 0;
|
|
|
|
|
2012-02-02 08:58:12 +00:00
|
|
|
ret = i915_gem_init_hw(dev);
|
2009-04-18 02:43:32 +00:00
|
|
|
if (ret != 0) {
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2008-12-24 02:42:32 +00:00
|
|
|
return ret;
|
2009-04-18 02:43:32 +00:00
|
|
|
}
|
2008-12-24 02:42:32 +00:00
|
|
|
|
2010-10-19 09:36:51 +00:00
|
|
|
BUG_ON(!list_empty(&dev_priv->mm.active_list));
|
2008-07-30 19:06:12 +00:00
|
|
|
BUG_ON(!list_empty(&dev_priv->mm.inactive_list));
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2008-08-20 15:04:27 +00:00
|
|
|
|
2010-06-07 13:03:03 +00:00
|
|
|
ret = drm_irq_install(dev);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup_ringbuffer;
|
2008-08-20 15:04:27 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
return 0;
|
2010-06-07 13:03:03 +00:00
|
|
|
|
|
|
|
cleanup_ringbuffer:
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
i915_gem_cleanup_ringbuffer(dev);
|
|
|
|
dev_priv->mm.suspended = 1;
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return ret;
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_leavevt_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
DRM: i915: add mode setting support
This commit adds i915 driver support for the DRM mode setting APIs.
Currently, VGA, LVDS, SDVO DVI & VGA, TV and DVO LVDS outputs are
supported. HDMI, DisplayPort and additional SDVO output support will
follow.
Support for the mode setting code is controlled by the new 'modeset'
module option. A new config option, CONFIG_DRM_I915_KMS controls the
default behavior, and whether a PCI ID list is built into the module for
use by user level module utilities.
Note that if mode setting is enabled, user level drivers that access
display registers directly or that don't use the kernel graphics memory
manager will likely corrupt kernel graphics memory, disrupt output
configuration (possibly leading to hangs and/or blank displays), and
prevent panic/oops messages from appearing. So use caution when
enabling this code; be sure your user level code supports the new
interfaces.
A new SysRq key, 'g', provides emergency support for switching back to
the kernel's framebuffer console; which is useful for testing.
Co-authors: Dave Airlie <airlied@linux.ie>, Hong Liu <hong.liu@intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2008-11-07 22:24:08 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return 0;
|
|
|
|
|
2008-08-20 15:04:27 +00:00
|
|
|
drm_irq_uninstall(dev);
|
2009-09-09 00:09:24 +00:00
|
|
|
return i915_gem_idle(dev);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i915_gem_lastclose(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2009-01-22 17:56:58 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return;
|
|
|
|
|
2008-10-15 04:41:13 +00:00
|
|
|
ret = i915_gem_idle(dev);
|
|
|
|
if (ret)
|
|
|
|
DRM_ERROR("failed to idle hardware: %d\n", ret);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
|
|
|
|
2010-10-24 11:38:05 +00:00
|
|
|
static void
|
|
|
|
init_ring_lists(struct intel_ring_buffer *ring)
|
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&ring->active_list);
|
|
|
|
INIT_LIST_HEAD(&ring->request_list);
|
|
|
|
}
|
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
void
|
|
|
|
i915_gem_load(struct drm_device *dev)
|
|
|
|
{
|
2009-06-23 13:41:02 +00:00
|
|
|
int i;
|
2008-07-30 19:06:12 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
|
2010-10-19 09:36:51 +00:00
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.active_list);
|
2008-07-30 19:06:12 +00:00
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.inactive_list);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.unbound_list);
|
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.bound_list);
|
2009-08-29 19:49:51 +00:00
|
|
|
INIT_LIST_HEAD(&dev_priv->mm.fence_list);
|
2010-12-04 11:30:53 +00:00
|
|
|
for (i = 0; i < I915_NUM_RINGS; i++)
|
|
|
|
init_ring_lists(&dev_priv->ring[i]);
|
2011-10-09 19:52:02 +00:00
|
|
|
for (i = 0; i < I915_MAX_NUM_FENCES; i++)
|
2010-04-28 09:02:31 +00:00
|
|
|
INIT_LIST_HEAD(&dev_priv->fence_regs[i].lru_list);
|
2008-07-30 19:06:12 +00:00
|
|
|
INIT_DELAYED_WORK(&dev_priv->mm.retire_work,
|
|
|
|
i915_gem_retire_work_handler);
|
2010-09-25 09:19:17 +00:00
|
|
|
init_completion(&dev_priv->error_completion);
|
2009-09-14 15:50:28 +00:00
|
|
|
|
2010-07-20 03:15:31 +00:00
|
|
|
/* On GEN3 we really need to make sure the ARB C3 LP bit is set */
|
|
|
|
if (IS_GEN3(dev)) {
|
2012-04-26 20:02:54 +00:00
|
|
|
I915_WRITE(MI_ARB_STATE,
|
|
|
|
_MASKED_BIT_ENABLE(MI_ARB_C3_LP_WRITE_ENABLE));
|
2010-07-20 03:15:31 +00:00
|
|
|
}
|
|
|
|
|
2010-12-19 11:42:05 +00:00
|
|
|
dev_priv->relative_constants_mode = I915_EXEC_CONSTANTS_REL_GENERAL;
|
|
|
|
|
2008-11-12 18:03:55 +00:00
|
|
|
/* Old X drivers will take 0-2 for front, back, depth buffers */
|
2010-01-26 17:43:10 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
dev_priv->fence_reg_start = 3;
|
2008-11-12 18:03:55 +00:00
|
|
|
|
2010-09-16 23:32:17 +00:00
|
|
|
if (INTEL_INFO(dev)->gen >= 4 || IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev))
|
2008-11-12 18:03:55 +00:00
|
|
|
dev_priv->num_fence_regs = 16;
|
|
|
|
else
|
|
|
|
dev_priv->num_fence_regs = 8;
|
|
|
|
|
2009-06-23 13:41:02 +00:00
|
|
|
/* Initialize fence registers to zero */
|
2012-04-17 14:31:32 +00:00
|
|
|
i915_gem_reset_fences(dev);
|
2011-05-06 20:53:49 +00:00
|
|
|
|
2008-07-30 19:06:12 +00:00
|
|
|
i915_gem_detect_bit_6_swizzle(dev);
|
2009-11-18 16:25:18 +00:00
|
|
|
init_waitqueue_head(&dev_priv->pending_flip_queue);
|
2010-10-28 11:51:39 +00:00
|
|
|
|
2011-02-21 14:43:56 +00:00
|
|
|
dev_priv->mm.interruptible = true;
|
|
|
|
|
2010-10-28 11:51:39 +00:00
|
|
|
dev_priv->mm.inactive_shrinker.shrink = i915_gem_inactive_shrink;
|
|
|
|
dev_priv->mm.inactive_shrinker.seeks = DEFAULT_SEEKS;
|
|
|
|
register_shrinker(&dev_priv->mm.inactive_shrinker);
|
2008-07-30 19:06:12 +00:00
|
|
|
}
|
2008-12-30 10:31:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a physically contiguous memory object for this object
|
|
|
|
* e.g. for cursor + overlay regs
|
|
|
|
*/
|
2010-08-20 12:23:26 +00:00
|
|
|
static int i915_gem_init_phys_object(struct drm_device *dev,
|
|
|
|
int id, int size, int align)
|
2008-12-30 10:31:46 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_phys_object *phys_obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (dev_priv->mm.phys_objs[id - 1] || !size)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-24 19:23:04 +00:00
|
|
|
phys_obj = kzalloc(sizeof(struct drm_i915_gem_phys_object), GFP_KERNEL);
|
2008-12-30 10:31:46 +00:00
|
|
|
if (!phys_obj)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
phys_obj->id = id;
|
|
|
|
|
2010-08-07 10:01:39 +00:00
|
|
|
phys_obj->handle = drm_pci_alloc(dev, size, align);
|
2008-12-30 10:31:46 +00:00
|
|
|
if (!phys_obj->handle) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto kfree_obj;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
set_memory_wc((unsigned long)phys_obj->handle->vaddr, phys_obj->handle->size / PAGE_SIZE);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
dev_priv->mm.phys_objs[id - 1] = phys_obj;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
kfree_obj:
|
2009-03-24 19:23:04 +00:00
|
|
|
kfree(phys_obj);
|
2008-12-30 10:31:46 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-08-20 12:23:26 +00:00
|
|
|
static void i915_gem_free_phys_object(struct drm_device *dev, int id)
|
2008-12-30 10:31:46 +00:00
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
struct drm_i915_gem_phys_object *phys_obj;
|
|
|
|
|
|
|
|
if (!dev_priv->mm.phys_objs[id - 1])
|
|
|
|
return;
|
|
|
|
|
|
|
|
phys_obj = dev_priv->mm.phys_objs[id - 1];
|
|
|
|
if (phys_obj->cur_obj) {
|
|
|
|
i915_gem_detach_phys_object(dev, phys_obj->cur_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
set_memory_wb((unsigned long)phys_obj->handle->vaddr, phys_obj->handle->size / PAGE_SIZE);
|
|
|
|
#endif
|
|
|
|
drm_pci_free(dev, phys_obj->handle);
|
|
|
|
kfree(phys_obj);
|
|
|
|
dev_priv->mm.phys_objs[id - 1] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void i915_gem_free_all_phys_object(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2009-01-22 07:58:49 +00:00
|
|
|
for (i = I915_GEM_PHYS_CURSOR_0; i <= I915_MAX_PHYS_OBJECT; i++)
|
2008-12-30 10:31:46 +00:00
|
|
|
i915_gem_free_phys_object(dev, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
void i915_gem_detach_phys_object(struct drm_device *dev,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj)
|
2008-12-30 10:31:46 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct address_space *mapping = obj->base.filp->f_path.dentry->d_inode->i_mapping;
|
2010-10-28 12:45:36 +00:00
|
|
|
char *vaddr;
|
2008-12-30 10:31:46 +00:00
|
|
|
int i;
|
|
|
|
int page_count;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (!obj->phys_obj)
|
2008-12-30 10:31:46 +00:00
|
|
|
return;
|
2010-11-08 19:18:58 +00:00
|
|
|
vaddr = obj->phys_obj->handle->vaddr;
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
page_count = obj->base.size / PAGE_SIZE;
|
2008-12-30 10:31:46 +00:00
|
|
|
for (i = 0; i < page_count; i++) {
|
2011-06-27 23:18:18 +00:00
|
|
|
struct page *page = shmem_read_mapping_page(mapping, i);
|
2010-10-28 12:45:36 +00:00
|
|
|
if (!IS_ERR(page)) {
|
|
|
|
char *dst = kmap_atomic(page);
|
|
|
|
memcpy(dst, vaddr + i*PAGE_SIZE, PAGE_SIZE);
|
|
|
|
kunmap_atomic(dst);
|
|
|
|
|
|
|
|
drm_clflush_pages(&page, 1);
|
|
|
|
|
|
|
|
set_page_dirty(page);
|
|
|
|
mark_page_accessed(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
2008-12-30 10:31:46 +00:00
|
|
|
}
|
2010-11-05 17:12:18 +00:00
|
|
|
intel_gtt_chipset_flush();
|
2009-06-17 20:52:49 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->phys_obj->cur_obj = NULL;
|
|
|
|
obj->phys_obj = NULL;
|
2008-12-30 10:31:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
i915_gem_attach_phys_object(struct drm_device *dev,
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj,
|
2010-08-07 10:01:39 +00:00
|
|
|
int id,
|
|
|
|
int align)
|
2008-12-30 10:31:46 +00:00
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
struct address_space *mapping = obj->base.filp->f_path.dentry->d_inode->i_mapping;
|
2008-12-30 10:31:46 +00:00
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
int ret = 0;
|
|
|
|
int page_count;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (id > I915_MAX_PHYS_OBJECT)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
if (obj->phys_obj) {
|
|
|
|
if (obj->phys_obj->id == id)
|
2008-12-30 10:31:46 +00:00
|
|
|
return 0;
|
|
|
|
i915_gem_detach_phys_object(dev, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create a new object */
|
|
|
|
if (!dev_priv->mm.phys_objs[id - 1]) {
|
|
|
|
ret = i915_gem_init_phys_object(dev, id,
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->base.size, align);
|
2008-12-30 10:31:46 +00:00
|
|
|
if (ret) {
|
2010-11-08 19:18:58 +00:00
|
|
|
DRM_ERROR("failed to init phys object %d size: %zu\n",
|
|
|
|
id, obj->base.size);
|
2010-10-28 12:45:36 +00:00
|
|
|
return ret;
|
2008-12-30 10:31:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bind to the object */
|
2010-11-08 19:18:58 +00:00
|
|
|
obj->phys_obj = dev_priv->mm.phys_objs[id - 1];
|
|
|
|
obj->phys_obj->cur_obj = obj;
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
page_count = obj->base.size / PAGE_SIZE;
|
2008-12-30 10:31:46 +00:00
|
|
|
|
|
|
|
for (i = 0; i < page_count; i++) {
|
2010-10-28 12:45:36 +00:00
|
|
|
struct page *page;
|
|
|
|
char *dst, *src;
|
|
|
|
|
2011-06-27 23:18:18 +00:00
|
|
|
page = shmem_read_mapping_page(mapping, i);
|
2010-10-28 12:45:36 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return PTR_ERR(page);
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-10-30 21:52:31 +00:00
|
|
|
src = kmap_atomic(page);
|
2010-11-08 19:18:58 +00:00
|
|
|
dst = obj->phys_obj->handle->vaddr + (i * PAGE_SIZE);
|
2008-12-30 10:31:46 +00:00
|
|
|
memcpy(dst, src, PAGE_SIZE);
|
2010-10-26 21:21:51 +00:00
|
|
|
kunmap_atomic(src);
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-10-28 12:45:36 +00:00
|
|
|
mark_page_accessed(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
2009-06-17 20:52:49 +00:00
|
|
|
|
2008-12-30 10:31:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2010-11-08 19:18:58 +00:00
|
|
|
i915_gem_phys_pwrite(struct drm_device *dev,
|
|
|
|
struct drm_i915_gem_object *obj,
|
2008-12-30 10:31:46 +00:00
|
|
|
struct drm_i915_gem_pwrite *args,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
2010-11-08 19:18:58 +00:00
|
|
|
void *vaddr = obj->phys_obj->handle->vaddr + args->offset;
|
2010-11-08 01:12:29 +00:00
|
|
|
char __user *user_data = (char __user *) (uintptr_t) args->data_ptr;
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-11-08 01:12:29 +00:00
|
|
|
if (__copy_from_user_inatomic_nocache(vaddr, user_data, args->size)) {
|
|
|
|
unsigned long unwritten;
|
|
|
|
|
|
|
|
/* The physical object once assigned is fixed for the lifetime
|
|
|
|
* of the obj, so we can safely drop the lock and continue
|
|
|
|
* to access vaddr.
|
|
|
|
*/
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
unwritten = copy_from_user(vaddr, user_data, args->size);
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
if (unwritten)
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2008-12-30 10:31:46 +00:00
|
|
|
|
2010-11-05 17:12:18 +00:00
|
|
|
intel_gtt_chipset_flush();
|
2008-12-30 10:31:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-06-03 07:27:35 +00:00
|
|
|
|
2010-09-24 15:02:42 +00:00
|
|
|
void i915_gem_release(struct drm_device *dev, struct drm_file *file)
|
2009-06-03 07:27:35 +00:00
|
|
|
{
|
2010-09-24 15:02:42 +00:00
|
|
|
struct drm_i915_file_private *file_priv = file->driver_priv;
|
2009-06-03 07:27:35 +00:00
|
|
|
|
|
|
|
/* Clean up our request list when the client is going away, so that
|
|
|
|
* later retire_requests won't dereference our soon-to-be-gone
|
|
|
|
* file_priv.
|
|
|
|
*/
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_lock(&file_priv->mm.lock);
|
2010-09-24 15:02:42 +00:00
|
|
|
while (!list_empty(&file_priv->mm.request_list)) {
|
|
|
|
struct drm_i915_gem_request *request;
|
|
|
|
|
|
|
|
request = list_first_entry(&file_priv->mm.request_list,
|
|
|
|
struct drm_i915_gem_request,
|
|
|
|
client_list);
|
|
|
|
list_del(&request->client_list);
|
|
|
|
request->file_priv = NULL;
|
|
|
|
}
|
2010-09-26 10:03:27 +00:00
|
|
|
spin_unlock(&file_priv->mm.lock);
|
2009-06-03 07:27:35 +00:00
|
|
|
}
|
2009-09-14 15:50:28 +00:00
|
|
|
|
|
|
|
static int
|
2011-05-25 00:12:27 +00:00
|
|
|
i915_gem_inactive_shrink(struct shrinker *shrinker, struct shrink_control *sc)
|
2009-09-14 15:50:28 +00:00
|
|
|
{
|
2010-10-28 11:51:39 +00:00
|
|
|
struct drm_i915_private *dev_priv =
|
|
|
|
container_of(shrinker,
|
|
|
|
struct drm_i915_private,
|
|
|
|
mm.inactive_shrinker);
|
|
|
|
struct drm_device *dev = dev_priv->dev;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2011-05-25 00:12:27 +00:00
|
|
|
int nr_to_scan = sc->nr_to_scan;
|
2010-10-28 11:51:39 +00:00
|
|
|
int cnt;
|
|
|
|
|
|
|
|
if (!mutex_trylock(&dev->struct_mutex))
|
2010-10-28 21:35:07 +00:00
|
|
|
return 0;
|
2009-09-14 15:50:28 +00:00
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
if (nr_to_scan) {
|
|
|
|
nr_to_scan -= i915_gem_purge(dev_priv, nr_to_scan);
|
|
|
|
if (nr_to_scan > 0)
|
|
|
|
i915_gem_shrink_all(dev_priv);
|
2009-09-14 15:50:28 +00:00
|
|
|
}
|
|
|
|
|
2010-10-28 11:51:39 +00:00
|
|
|
cnt = 0;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.unbound_list, gtt_list)
|
2012-09-04 20:02:54 +00:00
|
|
|
if (obj->pages_pin_count == 0)
|
|
|
|
cnt += obj->base.size >> PAGE_SHIFT;
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, gtt_list)
|
2012-09-04 20:02:54 +00:00
|
|
|
if (obj->pin_count == 0 && obj->pages_pin_count == 0)
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
cnt += obj->base.size >> PAGE_SHIFT;
|
2010-10-28 11:51:39 +00:00
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
return cnt;
|
2009-09-14 15:50:28 +00:00
|
|
|
}
|