From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tvrtko Ursulin Subject: Re: [PATCH 4/4] drm/i915: Late request cancellations are harmful Date: Mon, 11 Apr 2016 14:50:17 +0100 Message-ID: <570BAB99.5050402@linux.intel.com> References: <1460194059-12447-1-git-send-email-chris@chris-wilson.co.uk> <1460194059-12447-5-git-send-email-chris@chris-wilson.co.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTP id 0E1336E436 for ; Mon, 11 Apr 2016 13:50:20 +0000 (UTC) In-Reply-To: <1460194059-12447-5-git-send-email-chris@chris-wilson.co.uk> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Chris Wilson , intel-gfx@lists.freedesktop.org Cc: Daniel Vetter , stable@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org Ck9uIDA5LzA0LzE2IDEwOjI3LCBDaHJpcyBXaWxzb24gd3JvdGU6Cj4gQ29uY2VwdHVhbGx5LCBl YWNoIHJlcXVlc3QgaXMgYSByZWNvcmQgb2YgYSBoYXJkd2FyZSB0cmFuc2FjdGlvbiAtIHdlCj4g YnVpbGQgdXAgYSBsaXN0IG9mIHBlbmRpbmcgY29tbWFuZHMgYW5kIHRoZW4gZWl0aGVyIGNvbW1p dCB0aGVtIHRvCj4gaGFyZHdhcmUsIG9yIGNhbmNlbCB0aGVtLiBIb3dldmVyLCB3aGlsc3QgYnVp bGRpbmcgdXAgdGhlIGxpc3Qgb2YKPiBwZW5kaW5nIGNvbW1hbmRzLCB3ZSBtYXkgbW9kaWZ5IHN0 YXRlIG91dHNpZGUgb2YgdGhlIHJlcXVlc3QgYW5kIG1ha2UKPiByZWZlcmVuY2VzIHRvIHRoZSBw ZW5kaW5nIHJlcXVlc3QuIElmIHdlIGRvIHNvIGFuZCB0aGVuIGNhbmNlbCB0aGF0Cj4gcmVxdWVz dCwgZXh0ZXJuYWwgb2JqZWN0cyB0aGVuIHBvaW50IHRvIHRoZSBkZWxldGVkIHJlcXVlc3QgbGVh ZGluZyB0bwo+IGJvdGggZ3JhcGhpY2FsIGFuZCBtZW1vcnkgY29ycnVwdGlvbi4KPgo+IFRoZSBl YXNpZXN0IGV4YW1wbGUgaXMgdG8gY29uc2lkZXIgb2JqZWN0L1ZNQSB0cmFja2luZy4gV2hlbiB3 ZSBtYXJrIGFuCj4gb2JqZWN0IGFzIGFjdGl2ZSBpbiBhIHJlcXVlc3QsIHdlIHN0b3JlIGEgcG9p bnRlciB0byB0aGlzLCB0aGUgbW9zdAo+IHJlY2VudCByZXF1ZXN0LCBpbiB0aGUgb2JqZWN0LiBU aGVuIHdlIHdhbnQgdG8gZnJlZSB0aGF0IG9iamVjdCwgd2Ugd2FpdAo+IGZvciB0aGUgbW9zdCBy ZWNlbnQgcmVxdWVzdCB0byBiZSBpZGxlIGJlZm9yZSBwcm9jZWVkaW5nIChvdGhlcndpc2UgdGhl Cj4gaGFyZHdhcmUgd2lsbCB3cml0ZSB0byBwYWdlcyBub3cgb3duZWQgYnkgdGhlIHN5c3RlbSwg b3Igd2Ugd2lsbCBhdHRlbXB0Cj4gdG8gcmVhZCBmcm9tIHRob3NlIHBhZ2VzIGJlZm9yZSB0aGUg aGFyZHdhcmUgaXMgZmluaXNoZWQgd3JpdGluZykuIElmCj4gdGhlIHJlcXVlc3Qgd2FzIGNhbmNl bGxlZCBpbnN0ZWFkLCB0aGF0IHdhaXQgY29tcGxldGVzIGltbWVkaWF0ZWx5LiBBcyBhCj4gcmVz dWx0LCBhbGwgcmVxdWVzdHMgbXVzdCBiZSBjb21taXR0ZWQgYW5kIG5vdCBjYW5jZWxsZWQgaWYg dGhlIGV4dGVybmFsCj4gc3RhdGUgaXMgdW5rbm93bi4KClRoaXMgd2FzIGEgYml0IGhhcmQgdG8g ZmlndXJlIG91dC4KClNvIHdlIGNhbm5vdCB1bndpbmQgYmVjYXVzZSBvbmNlIHdlIHNldCBsYXN0 X3JlYWRfcmVxIHdlIGxvc2UgdGhlIGRhdGEgCm9uIHdoYXQgd2FzIHRoZSBwcmV2aW91cyBvbmUs IGJlZm9yZSB0aGlzIHRyYW5zYWN0aW9uIHN0YXJ0ZWQ/CgpJbnR1aXRpdmVseSBJIGRvbid0IGxp a2UgdGhlIGlkZWEgb2Ygc2VuZGluZyB1bmZpbmlzaGVkIHN0dWZmIHRvIHRoZQpHUFUsIHdoZW4g aXQgZmFpbGVkIGF0IHNvbWUgcmFuZG9tIHBvaW50IGluIHJpbmcgYnVmZmVyIHByZXBhcmF0aW9u LgoKU28gSSBhbSBzdHJ1Z2dsaW5nIHdpdGggcmV2aWV3aW5nIHRoaXMgYXMgSSBoYXZlIGluIHRo ZSBwcmV2aW91cyByb3VuZC4KCj4gQWxsIHRoYXQgcmVtYWlucyBvZiBpOTE1X2dlbV9yZXF1ZXN0 X2NhbmNlbCgpIHVzZXJzIGFyZSBqdXN0IGEgY291cGxlIG9mCj4gZXh0cmVtZWx5IHVubGlrZWx5 IGFsbG9jYXRpb24gZmFpbHVyZXMsIHNvIHJlbW92ZSB0aGUgQVBJIGVudGlyZWx5LgoKVGhpcyBw YXJ0cyBmZWVscyBleHRyYSB3ZWlyZCBiZWNhdXNlIGluIHRoZSBub24tZXhlY2J1ZiBjYXNlcyB3 ZSAKYWN0dWFsbHkgY2FuIGNhbmNlbCB0aGUgdHJhbnNhY3Rpb24gd2l0aG91dCBhbnkgaXNzdWVz LCBjb3JyZWN0PwoKV291bGQgbWlkZGxlLWdyb3VuZCBiZSB0byBrZWVwIHRoZSBjYW5jZWxsYXRp b25zIGZvciBpbi1rZXJuZWwgc3VibWl0cywgCmFuZCBmb3IgZXhlY2J1ZiByZXdpbmQgdGhlIHJp bmdidWYgc28gb25seSByZXF1ZXN0IHBvc3QtYW1ibGUgaXMgc2VudCB0byAKdGhlIEdQVT8KCj4g QSBjb25zZXF1ZW5jZSBvZiBjb21taXR0aW5nIGFsbCBpbmNvbXBsZXRlIHJlcXVlc3RzIGlzIHRo YXQgd2UgZ2VuZXJhdGUKPiBleGNlc3MgYnJlYWRjcnVtYnMgYW5kIGZpbGwgdGhlIHJpbmcgbXVj aCBtb3JlIG9mdGVuIHdpdGggZHVtbXkgd29yay4gV2UKPiBoYXZlIGNvbXBsZXRlbHkgdW5kb25l IHRoZSBvdXRzdGFuZGluZ19sYXN0X3NlcW5vIG9wdGltaXNhdGlvbi4KPgo+IEJ1Z3ppbGxhOiBo dHRwczovL2J1Z3MuZnJlZWRlc2t0b3Aub3JnL3Nob3dfYnVnLmNnaT9pZD05MzkwNwo+IFNpZ25l ZC1vZmYtYnk6IENocmlzIFdpbHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNvLnVrPgo+IENjOiBE YW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgo+IENjOiBUdnJ0a28gVXJzdWxp biA8dHZydGtvLnVyc3VsaW5AbGludXguaW50ZWwuY29tPgo+IENjOiBzdGFibGVAdmdlci5rZXJu ZWwub3JnCj4gLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgICAg ICAgfCAgMiAtLQo+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyAgICAgICAgICAg IHwgNTAgKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2dlbV9jb250ZXh0LmMgICAgfCAyMSArKysrKystLS0tLS0tCj4gICBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9leGVjYnVmZmVyLmMgfCAxNSArKystLS0tLS0KPiAgIGRy aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyAgICAgICB8ICAyICstCj4gICBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9scmMuYyAgICAgICAgICAgfCAgNCArLS0KPiAgIGRyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX292ZXJsYXkuYyAgICAgICB8ICA4ICsrLS0tCj4gICA3IGZp bGVzIGNoYW5nZWQsIDM5IGluc2VydGlvbnMoKyksIDYzIGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5oCj4gaW5kZXggYTkzZTVkZDRmYTlhLi5mMzc0ZGI4ZGU2NzMgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBAQCAtMjMyMCw3ICsyMzIwLDYgQEAgc3RydWN0IGRy bV9pOTE1X2dlbV9yZXF1ZXN0IHsKPiAgIHN0cnVjdCBkcm1faTkxNV9nZW1fcmVxdWVzdCAqIF9f bXVzdF9jaGVjawo+ICAgaTkxNV9nZW1fcmVxdWVzdF9hbGxvYyhzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmUsCj4gICAJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY3R4KTsKPiAt dm9pZCBpOTE1X2dlbV9yZXF1ZXN0X2NhbmNlbChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3JlcXVlc3Qg KnJlcSk7Cj4gICB2b2lkIGk5MTVfZ2VtX3JlcXVlc3RfZnJlZShzdHJ1Y3Qga3JlZiAqcmVxX3Jl Zik7Cj4gICBpbnQgaTkxNV9nZW1fcmVxdWVzdF9hZGRfdG9fY2xpZW50KHN0cnVjdCBkcm1faTkx NV9nZW1fcmVxdWVzdCAqcmVxLAo+ICAgCQkJCSAgIHN0cnVjdCBkcm1fZmlsZSAqZmlsZSk7Cj4g QEAgLTI4NzIsNyArMjg3MSw2IEBAIGludCBpOTE1X2dlbV9zd19maW5pc2hfaW9jdGwoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKPiAgIAkJCSAgICAgc3RydWN0IGRybV9maWxl ICpmaWxlX3ByaXYpOwo+ICAgdm9pZCBpOTE1X2dlbV9leGVjYnVmZmVyX21vdmVfdG9fYWN0aXZl KHN0cnVjdCBsaXN0X2hlYWQgKnZtYXMsCj4gICAJCQkJCXN0cnVjdCBkcm1faTkxNV9nZW1fcmVx dWVzdCAqcmVxKTsKPiAtdm9pZCBpOTE1X2dlbV9leGVjYnVmZmVyX3JldGlyZV9jb21tYW5kcyhz dHJ1Y3QgaTkxNV9leGVjYnVmZmVyX3BhcmFtcyAqcGFyYW1zKTsKPiAgIGludCBpOTE1X2dlbV9y aW5nYnVmZmVyX3N1Ym1pc3Npb24oc3RydWN0IGk5MTVfZXhlY2J1ZmZlcl9wYXJhbXMgKnBhcmFt cywKPiAgIAkJCQkgICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2V4ZWNidWZmZXIyICphcmdzLAo+ICAg CQkJCSAgIHN0cnVjdCBsaXN0X2hlYWQgKnZtYXMpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwo+ IGluZGV4IDFjM2ZmNTY1OTRkNi4uNDIyMjc0OTU4MDNmIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2dlbS5jCj4gQEAgLTI3NTMsNyArMjc1Myw4IEBAIF9faTkxNV9nZW1fcmVxdWVzdF9hbGxvYyhz dHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCj4gICAJCSAqIGZ1bGx5IHByZXBhcmVkLiBU aHVzIGl0IGNhbiBiZSBjbGVhbmVkIHVwIHVzaW5nIHRoZSBwcm9wZXIKPiAgIAkJICogZnJlZSBj b2RlLgo+ICAgCQkgKi8KPiAtCQlpOTE1X2dlbV9yZXF1ZXN0X2NhbmNlbChyZXEpOwo+ICsJCWlu dGVsX3JpbmdfcmVzZXJ2ZWRfc3BhY2VfY2FuY2VsKHJlcS0+cmluZ2J1Zik7Cj4gKwkJaTkxNV9n ZW1fcmVxdWVzdF91bnJlZmVyZW5jZShyZXEpOwo+ICAgCQlyZXR1cm4gcmV0Owo+ICAgCX0KPgo+ IEBAIC0yNzkwLDEzICsyNzkxLDYgQEAgaTkxNV9nZW1fcmVxdWVzdF9hbGxvYyhzdHJ1Y3QgaW50 ZWxfZW5naW5lX2NzICplbmdpbmUsCj4gICAJcmV0dXJuIGVyciA/IEVSUl9QVFIoZXJyKSA6IHJl cTsKPiAgIH0KPgo+IC12b2lkIGk5MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHN0cnVjdCBkcm1faTkx NV9nZW1fcmVxdWVzdCAqcmVxKQo+IC17Cj4gLQlpbnRlbF9yaW5nX3Jlc2VydmVkX3NwYWNlX2Nh bmNlbChyZXEtPnJpbmdidWYpOwo+IC0KPiAtCWk5MTVfZ2VtX3JlcXVlc3RfdW5yZWZlcmVuY2Uo cmVxKTsKPiAtfQo+IC0KPiAgIHN0cnVjdCBkcm1faTkxNV9nZW1fcmVxdWVzdCAqCj4gICBpOTE1 X2dlbV9maW5kX2FjdGl2ZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkK PiAgIHsKPiBAQCAtMzQxMCwxMiArMzQwNCw5IEBAIGludCBpOTE1X2dwdV9pZGxlKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpCj4gICAJCQkJcmV0dXJuIFBUUl9FUlIocmVxKTsKPgo+ICAgCQkJcmV0 ID0gaTkxNV9zd2l0Y2hfY29udGV4dChyZXEpOwo+IC0JCQlpZiAocmV0KSB7Cj4gLQkJCQlpOTE1 X2dlbV9yZXF1ZXN0X2NhbmNlbChyZXEpOwo+IC0JCQkJcmV0dXJuIHJldDsKPiAtCQkJfQo+IC0K PiAgIAkJCWk5MTVfYWRkX3JlcXVlc3Rfbm9fZmx1c2gocmVxKTsKPiArCQkJaWYgKHJldCkKPiAr CQkJCXJldHVybiByZXQ7CgpMb29rcyBsaWtlIHdpdGggdGhpcyBpdCBjb3VsZCBleGVjdXRlIHRo ZSBjb250ZXh0IHN3aXRjaCBvbiB0aGUgR1BVIGJ1dCAKbm90IHVwZGF0ZSB0aGUgZW5naW5lLT5s YXN0X2NvbnRleHQgaW4gZG9fc3dpdGNoKCkuCgpSZWdhcmRzLAoKVHZydGtvCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxp c3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNr dG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com ([134.134.136.24]:2246 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933080AbcDKNu0 (ORCPT ); Mon, 11 Apr 2016 09:50:26 -0400 Subject: Re: [PATCH 4/4] drm/i915: Late request cancellations are harmful To: Chris Wilson , intel-gfx@lists.freedesktop.org References: <1460194059-12447-1-git-send-email-chris@chris-wilson.co.uk> <1460194059-12447-5-git-send-email-chris@chris-wilson.co.uk> Cc: Daniel Vetter , stable@vger.kernel.org From: Tvrtko Ursulin Message-ID: <570BAB99.5050402@linux.intel.com> Date: Mon, 11 Apr 2016 14:50:17 +0100 MIME-Version: 1.0 In-Reply-To: <1460194059-12447-5-git-send-email-chris@chris-wilson.co.uk> Content-Type: text/plain; charset=windows-1252; format=flowed Content-Transfer-Encoding: 7bit Sender: stable-owner@vger.kernel.org List-ID: On 09/04/16 10:27, Chris Wilson wrote: > Conceptually, each request is a record of a hardware transaction - we > build up a list of pending commands and then either commit them to > hardware, or cancel them. However, whilst building up the list of > pending commands, we may modify state outside of the request and make > references to the pending request. If we do so and then cancel that > request, external objects then point to the deleted request leading to > both graphical and memory corruption. > > The easiest example is to consider object/VMA tracking. When we mark an > object as active in a request, we store a pointer to this, the most > recent request, in the object. Then we want to free that object, we wait > for the most recent request to be idle before proceeding (otherwise the > hardware will write to pages now owned by the system, or we will attempt > to read from those pages before the hardware is finished writing). If > the request was cancelled instead, that wait completes immediately. As a > result, all requests must be committed and not cancelled if the external > state is unknown. This was a bit hard to figure out. So we cannot unwind because once we set last_read_req we lose the data on what was the previous one, before this transaction started? Intuitively I don't like the idea of sending unfinished stuff to the GPU, when it failed at some random point in ring buffer preparation. So I am struggling with reviewing this as I have in the previous round. > All that remains of i915_gem_request_cancel() users are just a couple of > extremely unlikely allocation failures, so remove the API entirely. This parts feels extra weird because in the non-execbuf cases we actually can cancel the transaction without any issues, correct? Would middle-ground be to keep the cancellations for in-kernel submits, and for execbuf rewind the ringbuf so only request post-amble is sent to the GPU? > A consequence of committing all incomplete requests is that we generate > excess breadcrumbs and fill the ring much more often with dummy work. We > have completely undone the outstanding_last_seqno optimisation. > > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=93907 > Signed-off-by: Chris Wilson > Cc: Daniel Vetter > Cc: Tvrtko Ursulin > Cc: stable@vger.kernel.org > --- > drivers/gpu/drm/i915/i915_drv.h | 2 -- > drivers/gpu/drm/i915/i915_gem.c | 50 ++++++++++++------------------ > drivers/gpu/drm/i915/i915_gem_context.c | 21 ++++++------- > drivers/gpu/drm/i915/i915_gem_execbuffer.c | 15 +++------ > drivers/gpu/drm/i915/intel_display.c | 2 +- > drivers/gpu/drm/i915/intel_lrc.c | 4 +-- > drivers/gpu/drm/i915/intel_overlay.c | 8 ++--- > 7 files changed, 39 insertions(+), 63 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index a93e5dd4fa9a..f374db8de673 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -2320,7 +2320,6 @@ struct drm_i915_gem_request { > struct drm_i915_gem_request * __must_check > i915_gem_request_alloc(struct intel_engine_cs *engine, > struct intel_context *ctx); > -void i915_gem_request_cancel(struct drm_i915_gem_request *req); > void i915_gem_request_free(struct kref *req_ref); > int i915_gem_request_add_to_client(struct drm_i915_gem_request *req, > struct drm_file *file); > @@ -2872,7 +2871,6 @@ int i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data, > struct drm_file *file_priv); > void i915_gem_execbuffer_move_to_active(struct list_head *vmas, > struct drm_i915_gem_request *req); > -void i915_gem_execbuffer_retire_commands(struct i915_execbuffer_params *params); > int i915_gem_ringbuffer_submission(struct i915_execbuffer_params *params, > struct drm_i915_gem_execbuffer2 *args, > struct list_head *vmas); > diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c > index 1c3ff56594d6..42227495803f 100644 > --- a/drivers/gpu/drm/i915/i915_gem.c > +++ b/drivers/gpu/drm/i915/i915_gem.c > @@ -2753,7 +2753,8 @@ __i915_gem_request_alloc(struct intel_engine_cs *engine, > * fully prepared. Thus it can be cleaned up using the proper > * free code. > */ > - i915_gem_request_cancel(req); > + intel_ring_reserved_space_cancel(req->ringbuf); > + i915_gem_request_unreference(req); > return ret; > } > > @@ -2790,13 +2791,6 @@ i915_gem_request_alloc(struct intel_engine_cs *engine, > return err ? ERR_PTR(err) : req; > } > > -void i915_gem_request_cancel(struct drm_i915_gem_request *req) > -{ > - intel_ring_reserved_space_cancel(req->ringbuf); > - > - i915_gem_request_unreference(req); > -} > - > struct drm_i915_gem_request * > i915_gem_find_active_request(struct intel_engine_cs *engine) > { > @@ -3410,12 +3404,9 @@ int i915_gpu_idle(struct drm_device *dev) > return PTR_ERR(req); > > ret = i915_switch_context(req); > - if (ret) { > - i915_gem_request_cancel(req); > - return ret; > - } > - > i915_add_request_no_flush(req); > + if (ret) > + return ret; Looks like with this it could execute the context switch on the GPU but not update the engine->last_context in do_switch(). Regards, Tvrtko