drm/i915/guc: Fix a fw content lost issue after it is evicted
Subsystems (2)
PATCH 1/1 drm/i915/guc: Fix a fw content lost issue after it is evicted
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is evicted (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail.
Now we keep the copy in a memory block rather than a GEM objet. During fw loading, we will wrap up a GEM obj with fw data for DMA copy. The GEM obj will be freed DMA is done.
--- drivers/gpu/drm/i915/intel_guc.h | 2 +- drivers/gpu/drm/i915/intel_guc_loader.c | 84 +++++++++++++++------------------ 2 files changed, 39 insertions(+), 47 deletions(-)
drivers/gpu/drm/i915/intel_guc.h +1 -1
@@ -68,7 +68,7 @@ struct intel_guc_fw {struct drm_device * guc_dev;const char * guc_fw_path;size_t guc_fw_size; -struct drm_i915_gem_object * guc_fw_obj; +uint32_t *guc_fw_data;enum intel_guc_fw_status guc_fw_fetch_status;enum intel_guc_fw_status guc_fw_load_status;
drivers/gpu/drm/i915/intel_guc_loader.c +38 -46
156 lines not on this page · raw message
Signature · 6 lines
2.5.0 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 5 lines · On Fri, Nov 06, 2015 at 01:55:27PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is evicted (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail.
No, it's not. The bug is in sg_copy_buffer called by i915_gem_object_create_from_data introduced by yourselves. -Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 10 lines · Chris Wilson
Quoted 5 lines · On Fri, Nov 06, 2015 at 01:55:27PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is evicted (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail.
No, it's not. The bug is in
sg_copy_buffercalled byi915_gem_object_create_from_dataintroduced by yourselves.
My understanding is that sg_copy_from_buffer is used to copy data. Can you clarify why using this will cause such issue? I also did another experiment that always leaving the GEM obj pinned, then it's content never changed.
Alex
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 10 lines · Yu Dai
Quoted 7 lines · Chris Wilson
Quoted 5 lines · On Fri, Nov 06, 2015 at 01:55:27PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is evicted (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail.
Quoted 6 lines
Quoted 3 lines
No, it's not. The bug is in
sg_copy_buffercalled byi915_gem_object_create_from_dataintroduced by yourselves.My understanding is that
sg_copy_from_bufferis used to copy data. Can you clarify why using this will cause such issue?
"However its content is lost if the GEM obj is evicted (igt/gem_evict_*)."
is not strictly true. The content is lost if the object is swapped because the page is never marked as dirty. sg_copy_buffer() is copying into the page but never marks said page as dirty.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 1/1 drm/i915/guc: Fix a fw content lost issue after it is evicted
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)
drivers/gpu/drm/i915/i915_gem.c +1 -0
@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;i915_gem_object_unpin_pages (obj);if (WARN_ON (bytes != size)) {
Signature · 6 lines
2.5.0 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 18 lines · On Tue, Nov 10, 2015 at 03:27:36PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0
drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5202
Quoted 4 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;
That's one way of doing it, but atypical for our CPU access to the pages. The root cause is still that sg_copy_from_buffer() isn't calling set_page_dirty() and so there will be other places in the kernel that fall foul of it. Also, not that we could have written this to not require the whole object to be pinned at once as well.
I would prefer this to be fixed in sg_copy_from_buffer() for the reason that all callers are susceptible to this bug.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 30 lines · Chris Wilson
Quoted 18 lines · On Tue, Nov 10, 2015 at 03:27:36PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5202
Quoted 4 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;That's one way of doing it, but atypical for our CPU access to the pages. The root cause is still that
sg_copy_from_buffer()isn't callingset_page_dirty()and so there will be other places in the kernel that fall foul of it. Also, not that we could have written this to not require the whole object to be pinned at once as well.
Quoted 4 lines
I would prefer this to be fixed in
sg_copy_from_buffer()for the reason that all callers are susceptible to this bug.
-Chris
Makes sense. I will keep this as it for now. We want to set this GEM obj dirty too in addition of marking each page dirty. A change in sg_copy_buffer will have big impact on kernel though.
Thanks,
Alex
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 30 lines · Chris Wilson
Quoted 18 lines · On Tue, Nov 10, 2015 at 03:27:36PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5202
Quoted 4 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;That's one way of doing it, but atypical for our CPU access to the pages. The root cause is still that
sg_copy_from_buffer()isn't callingset_page_dirty()and so there will be other places in the kernel that fall foul of it. Also, not that we could have written this to not require the whole object to be pinned at once as well.
Quoted 3 lines
I would prefer this to be fixed in
sg_copy_from_buffer()for the reason that all callers are susceptible to this bug.
-Chris
Probably the sg_copy_from_buffer is written with an assumption that the pages it is supposed to write to,
would always be the kernel pages (GFP_KERNEL), which will always be resident in RAM. Thus no real need to mark the pages as dirty. Or the Clients/Users of sg_copy_from_buffer function are expected to explicitly mark the pages as dirty.
Best regards
Akash
Quoted 7 lines
--
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 31 lines · akash goel
Quoted 30 lines · Chris Wilson
Quoted 18 lines · On Tue, Nov 10, 2015 at 03:27:36PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5202
Quoted 4 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;That's one way of doing it, but atypical for our CPU access to the pages. The root cause is still that
sg_copy_from_buffer()isn't callingset_page_dirty()and so there will be other places in the kernel that fall foul of it. Also, not that we could have written this to not require the whole object to be pinned at once as well.
Quoted 6 lines
Quoted 3 lines
I would prefer this to be fixed in
sg_copy_from_buffer()for the reason that all callers are susceptible to this bug.
-ChrisProbably the
sg_copy_from_bufferis written with an assumption that the pages it is supposed to write to,
Seems unlikely considering it is supposed to be a generic library helper.
Quoted 4 lines
would always be the kernel pages (
GFP_KERNEL), which will always be resident in RAM. Thus no real need to mark the pages as dirty. Or the Clients/Users ofsg_copy_from_bufferfunction are expected to explicitly mark the pages as dirty.
In which case, we shouldn't be using it. So back to making the library function correct, or using a better interface to write the shmemfs pages directly (which would avoid the extra clears, or for more points an internal object which we can write and avoid even the kmalloc through the generic firmware loader).
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 18 lines · On 10/11/15 23:27, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0
drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5205
Quoted 7 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;i915_gem_object_unpin_pages (obj);if (WARN_ON (bytes != size)) {
Hi,
although I liked this at first, on further checking I've found that there are other cases where the CPU writes on a GEM object without marking it dirty, so in theory all of those could also be subject to the same issue.
Functions that may suffer from this problem include copy_batch(),relocate_entry_cpu(), and render_state_setup(); hence, the objects that might be affected (CPU updates discarded) would in general be batch buffers.
Obviously also i915_gem_object_create_from_data() currently used only for firmware objects; and populate_lr_context() also modifies a GEM object using the CPU, but it already explicitly marks the object dirty and so avoid any problems.
At present, setting an object into the GTT domain with intent-to-write causes the object to be marked as dirty, whereas setting it into the CPU domain with intent-to-write doesn't. Since the obj->dirty flag doesn't mean "CPU and GPU views differ" but rather "In-memory version is newer than backing store", setting it should depend only on the intent-to-write flag, not on which domain it's being put into.
So my preferred solution would be to set the obj->dirty flag inside i915_gem_object_set_to_cpu_domain(obj, true). Then objects that have been written by the CPU would be swapped out to backing store rather than discarded if the shrinker decides to reclaim the memory.
To make this work properly, we also need to audit all the callers of i915_gem_object_set_to_cpu_domain(), because I think in several places the callers pass the second argument as true where it should be false; this would cause objects to unnecessarily be marked dirty, increasing swap requirements and impacting performance.
I'll follow up with an actual patch once people have had an opportunity to check that the above analysis is accurate.
.Dave.
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 54 lines · Dave Gordon
Quoted 18 lines · On 10/11/15 23:27, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5205
Quoted 7 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;i915_gem_object_unpin_pages (obj);if (WARN_ON (bytes != size)) {Hi,
although I liked this at first, on further checking I've found that there are other cases where the CPU writes on a GEM object without marking it dirty, so in theory all of those could also be subject to the same issue.
Functions that may suffer from this problem include
copy_batch(),relocate_entry_cpu(), andrender_state_setup(); hence, the objects that might be affected (CPU updates discarded) would in general be batch buffers.Obviously also
i915_gem_object_create_from_data()currently used only for firmware objects; andpopulate_lr_context()also modifies a GEM object using the CPU, but it already explicitly marks the object dirty and so avoid any problems.At present, setting an object into the GTT domain with intent-to-write causes the object to be marked as dirty, whereas setting it into the CPU domain with intent-to-write doesn't. Since the
obj->dirtyflag doesn't mean "CPU and GPU views differ" but rather "In-memory version is newer than backing store", setting it should depend only on the intent-to-write flag, not on which domain it's being put into.So my preferred solution would be to set the
obj->dirtyflag insidei915_gem_object_set_to_cpu_domain(obj, true). Then objects that have been written by the CPU would be swapped out to backing store rather than discarded if the shrinker decides to reclaim the memory.
Quoted 8 lines
To make this work properly, we also need to audit all the callers of
i915_gem_object_set_to_cpu_domain(), because I think in several places the callers pass the second argument as true where it should be false; this would cause objects to unnecessarily be marked dirty, increasing swap requirements and impacting performance.I'll follow up with an actual patch once people have had an opportunity to check that the above analysis is accurate.
set_to_cpu_domain won't cover everyone, since some callers like shmem_pwrite/pread do clever tricks with inline flushing.
Also there's a fundamental difference between writing through GTT (where we always pin all the pages, even though now we do have partial views), and CPU writes, which in most places access the bo page-by-page.
Given that I'm still slightly leaning towards a "cpu writes need to mark pages dirty themselves" world-view. At least teaching this to set_to_cpu_domain won't be a fully effective magic bullet. -Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 67 lines · Daniel Vetter
Quoted 54 lines · Dave Gordon
Quoted 18 lines · On 10/11/15 23:27, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5205
Quoted 7 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;i915_gem_object_unpin_pages (obj);if (WARN_ON (bytes != size)) {Hi,
although I liked this at first, on further checking I've found that there are other cases where the CPU writes on a GEM object without marking it dirty, so in theory all of those could also be subject to the same issue.
Functions that may suffer from this problem include
copy_batch(),relocate_entry_cpu(), andrender_state_setup(); hence, the objects that might be affected (CPU updates discarded) would in general be batch buffers.Obviously also
i915_gem_object_create_from_data()currently used only for firmware objects; andpopulate_lr_context()also modifies a GEM object using the CPU, but it already explicitly marks the object dirty and so avoid any problems.At present, setting an object into the GTT domain with intent-to-write causes the object to be marked as dirty, whereas setting it into the CPU domain with intent-to-write doesn't. Since the
obj->dirtyflag doesn't mean "CPU and GPU views differ" but rather "In-memory version is newer than backing store", setting it should depend only on the intent-to-write flag, not on which domain it's being put into.So my preferred solution would be to set the
obj->dirtyflag insidei915_gem_object_set_to_cpu_domain(obj, true). Then objects that have been written by the CPU would be swapped out to backing store rather than discarded if the shrinker decides to reclaim the memory.Quoted 8 lines
To make this work properly, we also need to audit all the callers of
i915_gem_object_set_to_cpu_domain(), because I think in several places the callers pass the second argument as true where it should be false; this would cause objects to unnecessarily be marked dirty, increasing swap requirements and impacting performance.I'll follow up with an actual patch once people have had an opportunity to check that the above analysis is accurate.
set_to_cpu_domainwon't cover everyone, since some callers like shmem_pwrite/pread do clever tricks with inline flushing.
Quoted 8 lines
Also there's a fundamental difference between writing through GTT (where we always pin all the pages, even though now we do have partial views), and CPU writes, which in most places access the bo page-by-page.
Given that I'm still slightly leaning towards a "cpu writes need to mark pages dirty themselves" world-view. At least teaching this to
set_to_cpu_domainwon't be a fully effective magic bullet. -Daniel
shmem_pwrite doesn't call set_to_cpu_domain, and it already explicitly marks the GEM object as dirty; shmem_pread obviously doesn't need to as it's a read operation and doesn't change the object contents.
There's no difference (as far as backing store is concerned) whether the object is written via a CPU mapping, a GTT mapping, or by the GPU; the end result is that the object in memory is different from the version on backing store, and the object should be marked dirty if we want the changes to persist across eviction.
There may indeed be additional functions that modify GEM objects in some way without first setting them into the CPU domain, in which case they will also be responsible for marking the objects dirty. But all the (correct) callers of i915_gem_object_set_to_cpu_domain(obj, true) follow it by writing on the object, and only one marks the object as dirty, so all others are potential victims of having the shrinker discard their uncommitted changes.
Fixing it here (i.e when mapping whole objects for CPU write access) means that object-level operations then don't have to worry about page-level details. Functions that want to be smarter about tracking updates at the level of individual pages could still do so, but I don't want to impose that requirement on code that just wants to manipulate objects.
BTW, I note that the different implementations of put_pages() are not consistent about how they treat dirty pages within objects not marked as dirty. Does this matter?
.Dave.
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 94 lines · Dave Gordon
Quoted 67 lines · Daniel Vetter
Quoted 54 lines · Dave Gordon
Quoted 18 lines · On 10/11/15 23:27, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is swapped (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail. Mark the obj dirty after copying data into the pages. So its content will be kept during swapped out.
Signed-off-by Alex Dai <[email protected]>--- drivers/gpu/drm/i915/i915_gem.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/drm/i915/i915_gem.c +0
-0drivers/gpu/drm/i915/i915_gem.c i915_gem_object_create_from_data(struct drm_device *dev, · line 5205
Quoted 7 lines
drivers/gpu/drm/i915/i915_gem.c +1
-0@@ -5199,6 +5199,7 @@ i915_gem_object_create_from_data(struct drm_device *dev,i915_gem_object_pin_pages (obj); sg = obj->pages; bytes =sg_copy_from_buffer (sg->sgl, sg->nents, (void *)data, size); + obj->dirty =1 ;i915_gem_object_unpin_pages (obj);if (WARN_ON (bytes != size)) {Hi,
although I liked this at first, on further checking I've found that there are other cases where the CPU writes on a GEM object without marking it dirty, so in theory all of those could also be subject to the same issue.
Functions that may suffer from this problem include
copy_batch(),relocate_entry_cpu(), andrender_state_setup(); hence, the objects that might be affected (CPU updates discarded) would in general be batch buffers.Obviously also
i915_gem_object_create_from_data()currently used only for firmware objects; andpopulate_lr_context()also modifies a GEM object using the CPU, but it already explicitly marks the object dirty and so avoid any problems.At present, setting an object into the GTT domain with intent-to-write causes the object to be marked as dirty, whereas setting it into the CPU domain with intent-to-write doesn't. Since the
obj->dirtyflag doesn't mean "CPU and GPU views differ" but rather "In-memory version is newer than backing store", setting it should depend only on the intent-to-write flag, not on which domain it's being put into.So my preferred solution would be to set the
obj->dirtyflag insidei915_gem_object_set_to_cpu_domain(obj, true). Then objects that have been written by the CPU would be swapped out to backing store rather than discarded if the shrinker decides to reclaim the memory.Quoted 8 lines
To make this work properly, we also need to audit all the callers of
i915_gem_object_set_to_cpu_domain(), because I think in several places the callers pass the second argument as true where it should be false; this would cause objects to unnecessarily be marked dirty, increasing swap requirements and impacting performance.I'll follow up with an actual patch once people have had an opportunity to check that the above analysis is accurate.
set_to_cpu_domainwon't cover everyone, since some callers like shmem_pwrite/pread do clever tricks with inline flushing.Quoted 8 lines
Also there's a fundamental difference between writing through GTT (where we always pin all the pages, even though now we do have partial views), and CPU writes, which in most places access the bo page-by-page.
Given that I'm still slightly leaning towards a "cpu writes need to mark pages dirty themselves" world-view. At least teaching this to
set_to_cpu_domainwon't be a fully effective magic bullet. -Daniel
shmem_pwritedoesn't callset_to_cpu_domain, and it already explicitly marks the GEM object as dirty;shmem_preadobviously doesn't need to as it's a read operation and doesn't change the object contents.There's no difference (as far as backing store is concerned) whether the object is written via a CPU mapping, a GTT mapping, or by the GPU; the end result is that the object in memory is different from the version on backing store, and the object should be marked dirty if we want the changes to persist across eviction.
There may indeed be additional functions that modify GEM objects in some way without first setting them into the CPU domain, in which case they will also be responsible for marking the objects dirty. But all the (correct) callers of
i915_gem_object_set_to_cpu_domain(obj, true)follow it by writing on the object, and only one marks the object as dirty, so all others are potential victims of having the shrinker discard their uncommitted changes.
Quoted 5 lines
Fixing it here (i.e when mapping whole objects for CPU write access) means that object-level operations then don't have to worry about page-level details. Functions that want to be smarter about tracking updates at the level of individual pages could still do so, but I don't want to impose that requirement on code that just wants to manipulate objects.
It's still not entirely equivalent: With GTT writes it's impossible to write through the GTT with get_pages having been called, which means someone eventually will do the put_pages. But with CPU writes you can do a set_to_cpu_domain just for flushing, and then write through some completely different path. Just setting obj->dirty only works if you also have the pages.
Which means moving the obj->dirty = true into set_to_cpu_domain won't be a solution that works everywhere, but it will work mostly. That's a bit fragile. For create_from_data it will work perfectly, and if we put the set_to_cpu_domain after get_pages it's even obvious that this is so. But since it's fundamentally fragile I don't like it that much.
But it's also not awesome that set_to_gtt_domain does this for callers.
For lack of clear solutions I'd go with sprinkling obj->dirty or page_set_dirty over callers. Aside: relocate_entry_cpu probably gets away because of the unconditional obj->dirty we do later on, and that we redo all relocs if a fault happens. Still would be good to fix it, just for safety.
Quoted 3 lines
BTW, I note that the different implementations of
put_pages()are not consistent about how they treat dirty pages within objects not marked as dirty. Does this matter?
Just checked them. All the struct page backed ones handle it (shmem+userptr) all the others (dma-buf+stolen) don't. Seems consistent. -Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 1 line · Daniel Vetter
Just setting
obj->dirtyonly works if you also have the pages.
Exactly. The CPU access has historically always been page-by-page. The style here more or less to emulate the CPU mmap.
Quoted 1 line
But it's also not awesome that
set_to_gtt_domaindoes this for callers.
Hmm, do you have an example where we want set-to-gtt(write), but not actually write through the backing storage? Internal use of set-to-gtt has never been ideal (e.g. context) but we haven't yet come up with a better semantic.
Quoted 5 lines
For lack of clear solutions I'd go with sprinkling
obj->dirtyorpage_set_dirtyover callers. Aside:relocate_entry_cpuprobably gets away because of the unconditionalobj->dirtywe do later on, and that we redo all relocs if a fault happens. Still would be good to fix it, just for safety.
[copy_batch() isn't a bug as the contents are invalidated after use anyway]
relocate_entry_cpu() is a bug we never caught. Indeed we've papered over it to mask some over userspace issues, but just adding the set_page_dirty() as required isn't going to be a big hardship.
We have tons of swapthrash tests to check persistency of GPU buffers, but we never tried to thrash the batches themselves out to swap and then reuse them.
I guess that it is because userspace doesn't reuse batches that we never had report of the issue. Hibernating would be a good exercise of such. -Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 6 lines · Chris Wilson
Quoted 1 line · Daniel Vetter
Just setting
obj->dirtyonly works if you also have the pages.Exactly. The CPU access has historically always been page-by-page. The style here more or less to emulate the CPU mmap.
Quoted 6 lines
Quoted 1 line
But it's also not awesome that
set_to_gtt_domaindoes this for callers.Hmm, do you have an example where we want set-to-gtt(write), but not actually write through the backing storage? Internal use of set-to-gtt has never been ideal (e.g. context) but we haven't yet come up with a better semantic.
Just the inconsistency that Dave pointed out is a bit worrisome. At most we can fix this with docs (which atm we have), which gives us a rather low score on API design (still a positive one still it's possible to get right). I agree that I don't have better semantics either.
Quoted 8 lines
Quoted 5 lines
For lack of clear solutions I'd go with sprinkling
obj->dirtyorpage_set_dirtyover callers. Aside:relocate_entry_cpuprobably gets away because of the unconditionalobj->dirtywe do later on, and that we redo all relocs if a fault happens. Still would be good to fix it, just for safety.[
copy_batch()isn't a bug as the contents are invalidated after use anyway]
Just for consistency adding the obj->dirty after get_pages won't hurt though.
Quoted 3 lines
relocate_entry_cpu()is a bug we never caught. Indeed we've papered over it to mask some over userspace issues, but just adding theset_page_dirty()as required isn't going to be a big hardship.
Yeah.
Quoted 6 lines
We have tons of swapthrash tests to check persistency of GPU buffers, but we never tried to thrash the batches themselves out to swap and then reuse them.
I guess that it is because userspace doesn't reuse batches that we never had report of the issue. Hibernating would be a good exercise of such.
Hm it's not just batches but any object with relocs. Could this explain the oddball libva/uxa hang? Stuff like "after playing $game for hours my desktop looked funny", but not for tiling issues.
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 3 lines · Daniel Vetter
Hm it's not just batches but any object with relocs. Could this explain the oddball libva/uxa hang? Stuff like "after playing $game for hours my desktop looked funny", but not for tiling issues.
Possible, but with libva having its own issues with not marking GPU writes, only time will tell. I say batches because in modern code, only the batch has the reloc. In UXA and mesa, even the auxiliary buffers with the relocs are reallocated with each batch.
There's only one swap related corruption issue on gen4, for which we also know the machine had bad swizzle detection, and there is another swap related bug on gen2, but neither are actually susceptible to this bug. I don't have any strong candidates for an eureka moment. -Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 9 lines · Chris Wilson
Quoted 3 lines · Daniel Vetter
Hm it's not just batches but any object with relocs. Could this explain the oddball libva/uxa hang? Stuff like "after playing $game for hours my desktop looked funny", but not for tiling issues.
Possible, but with libva having its own issues with not marking GPU writes, only time will tell. I say batches because in modern code, only the batch has the reloc. In UXA and mesa, even the auxiliary buffers with the relocs are reallocated with each batch.
Ah, I didn't realize/forgot that UXA doesn't reuse the indirect state.
Quoted 4 lines
There's only one swap related corruption issue on gen4, for which we also know the machine had bad swizzle detection, and there is another swap related bug on gen2, but neither are actually susceptible to this bug. I don't have any strong candidates for an eureka moment.
Was just a thought really.
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 18 lines · Chris Wilson
Quoted 10 lines · Yu Dai
Quoted 7 lines · Chris Wilson
Quoted 5 lines · On Fri, Nov 06, 2015 at 01:55:27PM -0800, [email protected] wrote:
From: Alex Dai <[email protected]>
We keep a copy of GuC fw in a GEM obj. However its content is lost if the GEM obj is evicted (igt/gem_evict_*). Therefore, the later fw loading during GPU reset will fail.
Quoted 6 lines
Quoted 3 lines
No, it's not. The bug is in
sg_copy_buffercalled byi915_gem_object_create_from_dataintroduced by yourselves.My understanding is that
sg_copy_from_bufferis used to copy data. Can you clarify why using this will cause such issue?
Quoted 7 lines
"However its content is lost if the GEM obj is evicted (igt/gem_evict_*)."
is not strictly true. The content is lost if the object is swapped because the page is never marked as dirty.
sg_copy_buffer()is copying into the page but never marks said page as dirty.
-Chris
Thanks Chris. Now the patch is one line change. :)
Alex
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx