From mboxrd@z Thu Jan 1 00:00:00 1970 From: Maarten Lankhorst Subject: Re: [PATCH 09/19] drm/radeon: handle lockup in delayed work, v2 Date: Tue, 05 Aug 2014 11:34:06 +0200 Message-ID: <53E0A50E.6060301@canonical.com> References: <20140731153245.15061.63023.stgit@patser> <20140731153342.15061.54264.stgit@patser> <53DBC1EC.1010001@amd.com> <53DBD269.80807@canonical.com> <53DF462B.2060102@amd.com> <53DF4A7D.3040505@canonical.com> <53DF7516.2010408@amd.com> <53DF8BF2.4000309@canonical.com> <53DF9AC4.3010700@amd.com> <53DF9B58.8000403@canonical.com> <53DF9C88.6060107@amd.com> <53DF9F89.60202@canonical.com> <53DFA0EB.5040302@amd.com> <53DFA210.2020603@canonical.com> <53DFBD2E.5070001@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <53DFBD2E.5070001@amd.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= , airlied@linux.ie Cc: thellstrom@vmware.com, nouveau@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, bskeggs@redhat.com, alexander.deucher@amd.com List-Id: nouveau.vger.kernel.org b3AgMDQtMDgtMTQgMTk6MDQsIENocmlzdGlhbiBLw7ZuaWcgc2NocmVlZjoKPiBBbSAwNC4wOC4y MDE0IHVtIDE3OjA5IHNjaHJpZWIgTWFhcnRlbiBMYW5raG9yc3Q6Cj4+IG9wIDA0LTA4LTE0IDE3 OjA0LCBDaHJpc3RpYW4gS8O2bmlnIHNjaHJlZWY6Cj4+PiBBbSAwNC4wOC4yMDE0IHVtIDE2OjU4 IHNjaHJpZWIgTWFhcnRlbiBMYW5raG9yc3Q6Cj4+Pj4gb3AgMDQtMDgtMTQgMTY6NDUsIENocmlz dGlhbiBLw7ZuaWcgc2NocmVlZjoKPj4+Pj4gQW0gMDQuMDguMjAxNCB1bSAxNjo0MCBzY2hyaWVi IE1hYXJ0ZW4gTGFua2hvcnN0Ogo+Pj4+Pj4gb3AgMDQtMDgtMTQgMTY6MzcsIENocmlzdGlhbiBL w7ZuaWcgc2NocmVlZjoKPj4+Pj4+Pj4gSXQnYSBwYWluIHRvIGRlYWwgd2l0aCBncHUgcmVzZXQu Cj4+Pj4+Pj4gWWVhaCwgd2VsbCB0aGF0J3Mgbm90aGluZyBuZXcuCj4+Pj4+Pj4KPj4+Pj4+Pj4g SSd2ZSBub3cgdHJpZWQgb3RoZXIgc29sdXRpb25zIGJ1dCB0aGF0IHdvdWxkIG1lYW4gcmV2ZXJ0 aW5nIHRvIHRoZSBvbGQgc3R5bGUgZHVyaW5nIGdwdSBsb2NrdXAgcmVjb3ZlcnksIGFuZCBvbmx5 IHJ1bm5pbmcgdGhlIGRlbGF5ZWQgd29yayB3aGVuICFsb2NrdXAuCj4+Pj4+Pj4+IEJ1dCB0aGlz IG1lYW50IHRoYXQgdGhlIHRpbWVvdXQgd2FzIHVzZWxlc3MgdG8gYWRkLiBJIHRoaW5rIHRoZSBj bGVhbmVzdCBpcyBrZWVwaW5nIHRoZSB2MiBwYXRjaCwgYmVjYXVzZSBwb3RlbnRpYWxseSBhbnkg d2FpdGluZyBjb2RlIGNhbiBiZSBjYWxsZWQgZHVyaW5nIGxvY2t1cCByZWNvdmVyeS4KPj4+Pj4+ PiBUaGUgbG9ja3VwIGNvZGUgaXRzZWxmIHNob3VsZCBuZXZlciBjYWxsIGFueSB3YWl0aW5nIGNv ZGUgYW5kIFYyIGRvZXNuJ3Qgc2VlbSB0byBoYW5kbGUgYSBjb3VwbGUgb2YgY2FzZXMgY29ycmVj dGx5IGVpdGhlci4KPj4+Pj4+Pgo+Pj4+Pj4+IEhvdyBhYm91dCBtb3ZpbmcgdGhlIGZlbmNlIHdh aXRpbmcgb3V0IG9mIHRoZSByZXNldCBjb2RlPwo+Pj4+Pj4gV2hhdCBjYXNlcyBkaWQgSSBtaXNz IHRoZW4/Cj4+Pj4+Pgo+Pj4+Pj4gSSdtIGN1cmlvdXMgaG93IHlvdSB3YW50IHRvIG1vdmUgdGhl IGZlbmNlIHdhaXRpbmcgb3V0IG9mIHJlc2V0LCB3aGVuIHRoZXJlIGFyZSBzbyBtYW55IHBsYWNl cyB0aGF0IGNvdWxkIHBvdGVudGlhbGx5IHdhaXQsIGxpa2UgcmFkZW9uX2liX2dldCBjYW4gY2Fs bCByYWRlb25fc2FfYm9fbmV3IHdoaWNoIGNhbiBkbyBhIHdhaXQsIG9yIHJhZGVvbl9yaW5nX2Fs bG9jIHRoYXQgY2FuIHdhaXQgb24gcmFkZW9uX2ZlbmNlX3dhaXRfbmV4dCwgZXRjLgo+Pj4+PiBU aGUgSUIgdGVzdCBpdHNlbGYgZG9lc24ndCBuZWVkcyB0byBiZSBwcm90ZWN0ZWQgYnkgdGhlIGV4 Y2x1c2l2ZSBsb2NrLiBPbmx5IGV2ZXJ5dGhpbmcgYmV0d2VlbiByYWRlb25fc2F2ZV9iaW9zX3Nj cmF0Y2hfcmVncyBhbmQgcmFkZW9uX3JpbmdfcmVzdG9yZS4KPj4+PiBJJ20gbm90IHN1cmUgYWJv dXQgdGhhdCwgd2hhdCBkbyB5b3Ugd2FudCB0byBkbyBpZiB0aGUgcmluZyB0ZXN0cyBmYWlsPyBE byB5b3UgaGF2ZSB0byByZXRha2UgdGhlIGV4Y2x1c2l2ZSBsb2NrPwo+Pj4gSnVzdCBzZXQgbmVl ZF9yZXNldCBhZ2FpbiBhbmQgcmV0dXJuIC1FQUdBSU4sIHRoYXQgc2hvdWxkIGhhdmUgbW9zdGx5 IHRoZSBzYW1lIGVmZmVjdCBhcyB3aGF0IHdlIGFyZSBkb2luZyByaWdodCBub3cuCj4+IFllYWgs IGV4Y2VwdCBmb3IgdGhlIGxvY2tpbmcgdGhlIHR0bSBkZWxheWVkIHdvcmtxdWV1ZSwgYnV0IHRo YXQgYm9vbCBzaG91bGQgYmUgZWFzeSB0byBzYXZlL3Jlc3RvcmUuCj4+IEkgdGhpbmsgdGhpcyBj b3VsZCB3b3JrLgo+Cj4gQWN0dWFsbHkgeW91IGNvdWxkIGFjdGl2YXRlIHRoZSBkZWxheWVkIHdv cmtxdWV1ZSBtdWNoIGVhcmxpZXIgYXMgd2VsbC4KPgo+IFRoaW5raW5nIG1vcmUgYWJvdXQgaXQg dGhhdCBzb3VuZHMgbGlrZSBhIGJ1ZyBpbiB0aGUgY3VycmVudCBjb2RlLCBiZWNhdXNlIHdlIHBy b2JhYmx5IHdhbnQgdGhlIHdvcmtxdWV1ZSBhY3RpdmF0ZWQgYmVmb3JlIHdhaXRpbmcgZm9yIHRo ZSBmZW5jZS4KCk9rLCBob3cgYWJvdXQgdGhpcz8KCkJlY2F1c2Ugb2YgdGhlIGRvd25ncmFkZV93 cml0ZSwgYSBzZWNvbmQgZ3B1IHJlc2V0IGNhbid0IGJlIHN0YXJ0ZWQgdW50aWwgdGhlIGZpcnN0 IGZpbmlzaGVzLgoKSSdtIHVuY2VydGFpbiBhYm91dCBpdCwgSSB0aGluayBJIG1pZ2h0IGVpdGhl ciBoYXZlIHRvIHN0b3AgY2FsbGluZyByYWRlb25fcmVzdG9yZV9iaW9zX3NjcmF0Y2hfcmVncyBh IHNlY29uZCB0aW1lLApvciBJIHNob3VsZCBjYWxsIHNhdmVfYmlvc19zY3JhdGNoX3JlZ3MgdGhl IHNlY29uZCB0aW1lIGFyb3VuZC4KCkFsc28gaXQgZmVlbHMgbGlrZSBkcm1faGVscGVyX3Jlc3Vt ZV9mb3JjZV9tb2RlIHNob3VsZCBiZSBjYWxsZWQgYmVmb3JlIGRvd25ncmFkaW5nIGV4Y2x1c2l2 ZV9sb2NrLCBidXQgaXQgbWlnaHQgZGVwZW5kIG9uIFBNIHJlc3RvcmUuClRvdWdoISBNYXliZSBt b3ZlIGJvdGggY2FsbHMgdG8gYmVmb3JlIGRvd25ncmFkZV93cml0ZT8KIApjb21taXQgMzY0NGFh ZTg1ODFhMTVlM2E5MzUyNzkyODdjMzk3ZjdlYWI0MDBmZgpBdXRob3I6IE1hYXJ0ZW4gTGFua2hv cnN0IDxtYWFydGVuLmxhbmtob3JzdEBjYW5vbmljYWwuY29tPgpEYXRlOiAgIFR1ZSBBdWcgNSAx MDoyOToyMyAyMDE0ICswMjAwCgogICAgZHJtL3JhZGVvbjogdGFrZSBleGNsdXNpdmVfbG9jayBp biByZWFkIG1vZGUgZHVyaW5nIHJpbmcgdGVzdHMKICAgIAogICAgU2lnbmVkLW9mZi1ieTogTWFh cnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGNhbm9uaWNhbC5jb20+CgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9y YWRlb24vcmFkZW9uLmgKaW5kZXggMjlkOWNjMDRjMDRlLi5kZTE0ZTM1ZGEwMDIgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKKysrIGIvZHJpdmVycy9ncHUvZHJt L3JhZGVvbi9yYWRlb24uaApAQCAtMjI4Niw3ICsyMjg2LDcgQEAgc3RydWN0IHJhZGVvbl9kZXZp Y2UgewogCWJvb2wJCQkJbmVlZF9kbWEzMjsKIAlib29sCQkJCWFjY2VsX3dvcmtpbmc7CiAJYm9v bAkJCQlmYXN0ZmJfd29ya2luZzsgLyogSUdQIGZlYXR1cmUqLwotCWJvb2wJCQkJbmVlZHNfcmVz ZXQ7CisJYm9vbAkJCQluZWVkc19yZXNldCwgaW5fcmVzZXQ7CiAJc3RydWN0IHJhZGVvbl9zdXJm YWNlX3JlZyBzdXJmYWNlX3JlZ3NbUkFERU9OX0dFTV9NQVhfU1VSRkFDRVNdOwogCWNvbnN0IHN0 cnVjdCBmaXJtd2FyZSAqbWVfZnc7CS8qIGFsbCBmYW1pbHkgTUUgZmlybXdhcmUgKi8KIAljb25z dCBzdHJ1Y3QgZmlybXdhcmUgKnBmcF9mdzsJLyogcjYvNzAwIFBGUCBmaXJtd2FyZSAqLwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMgYi9kcml2ZXJz L2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kZXZpY2UuYwppbmRleCAwMzY4NmZhYjg0MmQuLjYzMTdi OGEyZWYyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNl LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMKQEAgLTE2MjAs MzcgKzE2MjAsNDQgQEAgaW50IHJhZGVvbl9ncHVfcmVzZXQoc3RydWN0IHJhZGVvbl9kZXZpY2Ug KnJkZXYpCiAJdW5zaWduZWQgcmluZ19zaXplc1tSQURFT05fTlVNX1JJTkdTXTsKIAl1aW50MzJf dCAqcmluZ19kYXRhW1JBREVPTl9OVU1fUklOR1NdOwogCi0JYm9vbCBzYXZlZCA9IGZhbHNlOwor CWJvb2wgc2F2ZWQ7CiAKIAlpbnQgaSwgcjsKIAlpbnQgcmVzY2hlZDsKIAorcmV0cnk6CisJc2F2 ZWQgPSBmYWxzZTsKIAlkb3duX3dyaXRlKCZyZGV2LT5leGNsdXNpdmVfbG9jayk7CiAKIAlpZiAo IXJkZXYtPm5lZWRzX3Jlc2V0KSB7CisJCVdBUk5fT04ocmRldi0+aW5fcmVzZXQpOwogCQl1cF93 cml0ZSgmcmRldi0+ZXhjbHVzaXZlX2xvY2spOwogCQlyZXR1cm4gMDsKIAl9CiAKIAlyZGV2LT5u ZWVkc19yZXNldCA9IGZhbHNlOwotCi0JcmFkZW9uX3NhdmVfYmlvc19zY3JhdGNoX3JlZ3MocmRl dik7Ci0JLyogYmxvY2sgVFRNICovCiAJcmVzY2hlZCA9IHR0bV9ib19sb2NrX2RlbGF5ZWRfd29y a3F1ZXVlKCZyZGV2LT5tbWFuLmJkZXYpOwotCXJhZGVvbl9wbV9zdXNwZW5kKHJkZXYpOwotCXJh ZGVvbl9zdXNwZW5kKHJkZXYpOwogCi0JZm9yIChpID0gMDsgaSA8IFJBREVPTl9OVU1fUklOR1M7 ICsraSkgewotCQlyaW5nX3NpemVzW2ldID0gcmFkZW9uX3JpbmdfYmFja3VwKHJkZXYsICZyZGV2 LT5yaW5nW2ldLAotCQkJCQkJICAgJnJpbmdfZGF0YVtpXSk7Ci0JCWlmIChyaW5nX3NpemVzW2ld KSB7Ci0JCQlzYXZlZCA9IHRydWU7Ci0JCQlkZXZfaW5mbyhyZGV2LT5kZXYsICJTYXZlZCAlZCBk d29yZHMgb2YgY29tbWFuZHMgIgotCQkJCSAib24gcmluZyAlZC5cbiIsIHJpbmdfc2l6ZXNbaV0s IGkpOworCWlmICghcmRldi0+aW5fcmVzZXQpIHsKKwkJcmRldi0+aW5fcmVzZXQgPSB0cnVlOwor CisJCXJhZGVvbl9zYXZlX2Jpb3Nfc2NyYXRjaF9yZWdzKHJkZXYpOworCQkvKiBibG9jayBUVE0g Ki8KKwkJcmFkZW9uX3BtX3N1c3BlbmQocmRldik7CisJCXJhZGVvbl9zdXNwZW5kKHJkZXYpOwor CisJCWZvciAoaSA9IDA7IGkgPCBSQURFT05fTlVNX1JJTkdTOyArK2kpIHsKKwkJCXJpbmdfc2l6 ZXNbaV0gPSByYWRlb25fcmluZ19iYWNrdXAocmRldiwgJnJkZXYtPnJpbmdbaV0sCisJCQkJCQkJ ICAgJnJpbmdfZGF0YVtpXSk7CisJCQlpZiAocmluZ19zaXplc1tpXSkgeworCQkJCXNhdmVkID0g dHJ1ZTsKKwkJCQlkZXZfaW5mbyhyZGV2LT5kZXYsICJTYXZlZCAlZCBkd29yZHMgb2YgY29tbWFu ZHMgIgorCQkJCQkgIm9uIHJpbmcgJWQuXG4iLCByaW5nX3NpemVzW2ldLCBpKTsKKwkJCX0KIAkJ fQotCX0KKwl9IGVsc2UKKwkJbWVtc2V0KHJpbmdfZGF0YSwgMCwgc2l6ZW9mKHJpbmdfZGF0YSkp OwogCi1yZXRyeToKIAlyID0gcmFkZW9uX2FzaWNfcmVzZXQocmRldik7CiAJaWYgKCFyKSB7CiAJ CWRldl9pbmZvKHJkZXYtPmRldiwgIkdQVSByZXNldCBzdWNjZWVkZWQsIHRyeWluZyB0byByZXN1 bWVcbiIpOwpAQCAtMTY1OSw0MCArMTY2Niw0NiBAQCByZXRyeToKIAogCXJhZGVvbl9yZXN0b3Jl X2Jpb3Nfc2NyYXRjaF9yZWdzKHJkZXYpOwogCi0JaWYgKCFyKSB7CisJaWYgKCFyICYmIHNhdmVk KSB7CiAJCWZvciAoaSA9IDA7IGkgPCBSQURFT05fTlVNX1JJTkdTOyArK2kpIHsKIAkJCXJhZGVv bl9yaW5nX3Jlc3RvcmUocmRldiwgJnJkZXYtPnJpbmdbaV0sCiAJCQkJCSAgICByaW5nX3NpemVz W2ldLCByaW5nX2RhdGFbaV0pOwotCQkJcmluZ19zaXplc1tpXSA9IDA7CiAJCQlyaW5nX2RhdGFb aV0gPSBOVUxMOwogCQl9CisJfSBlbHNlIHsKKwkJcmFkZW9uX2ZlbmNlX2RyaXZlcl9mb3JjZV9j b21wbGV0aW9uKHJkZXYpOworCisJCWZvciAoaSA9IDA7IGkgPCBSQURFT05fTlVNX1JJTkdTOyAr K2kpIHsKKwkJCWtmcmVlKHJpbmdfZGF0YVtpXSk7CisJCX0KKwl9CisJZG93bmdyYWRlX3dyaXRl KCZyZGV2LT5leGNsdXNpdmVfbG9jayk7CisJdHRtX2JvX3VubG9ja19kZWxheWVkX3dvcmtxdWV1 ZSgmcmRldi0+bW1hbi5iZGV2LCByZXNjaGVkKTsKIAorCWlmICghcikgewogCQlyID0gcmFkZW9u X2liX3JpbmdfdGVzdHMocmRldik7CiAJCWlmIChyKSB7CiAJCQlkZXZfZXJyKHJkZXYtPmRldiwg ImliIHJpbmcgdGVzdCBmYWlsZWQgKCVkKS5cbiIsIHIpOwogCQkJaWYgKHNhdmVkKSB7Ci0JCQkJ c2F2ZWQgPSBmYWxzZTsKKwkJCQkvKiBpZiByZXNldCBmYWlscywgdHJ5IHdpdGhvdXQgc2F2aW5n IGRhdGEgKi8KKwkJCQlyZGV2LT5uZWVkc19yZXNldCA9IHRydWU7CiAJCQkJcmFkZW9uX3N1c3Bl bmQocmRldik7CisJCQkJdXBfcmVhZCgmcmRldi0+ZXhjbHVzaXZlX2xvY2spOwogCQkJCWdvdG8g cmV0cnk7CiAJCQl9CiAJCX0KLQl9IGVsc2UgewotCQlyYWRlb25fZmVuY2VfZHJpdmVyX2ZvcmNl X2NvbXBsZXRpb24ocmRldik7Ci0JCWZvciAoaSA9IDA7IGkgPCBSQURFT05fTlVNX1JJTkdTOyAr K2kpIHsKLQkJCWtmcmVlKHJpbmdfZGF0YVtpXSk7Ci0JCX0KIAl9CiAKIAlyYWRlb25fcG1fcmVz dW1lKHJkZXYpOwogCWRybV9oZWxwZXJfcmVzdW1lX2ZvcmNlX21vZGUocmRldi0+ZGRldik7CiAK LQl0dG1fYm9fdW5sb2NrX2RlbGF5ZWRfd29ya3F1ZXVlKCZyZGV2LT5tbWFuLmJkZXYsIHJlc2No ZWQpOwogCWlmIChyKSB7CiAJCS8qIGJhZCBuZXdzLCBob3cgdG8gdGVsbCBpdCB0byB1c2Vyc3Bh Y2UgPyAqLwogCQlkZXZfaW5mbyhyZGV2LT5kZXYsICJHUFUgcmVzZXQgZmFpbGVkXG4iKTsKIAl9 CiAKLQl1cF93cml0ZSgmcmRldi0+ZXhjbHVzaXZlX2xvY2spOworCXJkZXYtPmluX3Jlc2V0ID0g ZmFsc2U7CisJdXBfcmVhZCgmcmRldi0+ZXhjbHVzaXZlX2xvY2spOwogCXJldHVybiByOwogfQog CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2 ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cDovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757497AbaHEJeT (ORCPT ); Tue, 5 Aug 2014 05:34:19 -0400 Received: from youngberry.canonical.com ([91.189.89.112]:44040 "EHLO youngberry.canonical.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754689AbaHEJeR (ORCPT ); Tue, 5 Aug 2014 05:34:17 -0400 Message-ID: <53E0A50E.6060301@canonical.com> Date: Tue, 05 Aug 2014 11:34:06 +0200 From: Maarten Lankhorst User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.5.0 MIME-Version: 1.0 To: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= , airlied@linux.ie CC: thellstrom@vmware.com, nouveau@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, bskeggs@redhat.com, alexander.deucher@amd.com Subject: Re: [PATCH 09/19] drm/radeon: handle lockup in delayed work, v2 References: <20140731153245.15061.63023.stgit@patser> <20140731153342.15061.54264.stgit@patser> <53DBC1EC.1010001@amd.com> <53DBD269.80807@canonical.com> <53DF462B.2060102@amd.com> <53DF4A7D.3040505@canonical.com> <53DF7516.2010408@amd.com> <53DF8BF2.4000309@canonical.com> <53DF9AC4.3010700@amd.com> <53DF9B58.8000403@canonical.com> <53DF9C88.6060107@amd.com> <53DF9F89.60202@canonical.com> <53DFA0EB.5040302@amd.com> <53DFA210.2020603@canonical.com> <53DFBD2E.5070001@amd.com> In-Reply-To: <53DFBD2E.5070001@amd.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org op 04-08-14 19:04, Christian König schreef: > Am 04.08.2014 um 17:09 schrieb Maarten Lankhorst: >> op 04-08-14 17:04, Christian König schreef: >>> Am 04.08.2014 um 16:58 schrieb Maarten Lankhorst: >>>> op 04-08-14 16:45, Christian König schreef: >>>>> Am 04.08.2014 um 16:40 schrieb Maarten Lankhorst: >>>>>> op 04-08-14 16:37, Christian König schreef: >>>>>>>> It'a pain to deal with gpu reset. >>>>>>> Yeah, well that's nothing new. >>>>>>> >>>>>>>> I've now tried other solutions but that would mean reverting to the old style during gpu lockup recovery, and only running the delayed work when !lockup. >>>>>>>> But this meant that the timeout was useless to add. I think the cleanest is keeping the v2 patch, because potentially any waiting code can be called during lockup recovery. >>>>>>> The lockup code itself should never call any waiting code and V2 doesn't seem to handle a couple of cases correctly either. >>>>>>> >>>>>>> How about moving the fence waiting out of the reset code? >>>>>> What cases did I miss then? >>>>>> >>>>>> I'm curious how you want to move the fence waiting out of reset, when there are so many places that could potentially wait, like radeon_ib_get can call radeon_sa_bo_new which can do a wait, or radeon_ring_alloc that can wait on radeon_fence_wait_next, etc. >>>>> The IB test itself doesn't needs to be protected by the exclusive lock. Only everything between radeon_save_bios_scratch_regs and radeon_ring_restore. >>>> I'm not sure about that, what do you want to do if the ring tests fail? Do you have to retake the exclusive lock? >>> Just set need_reset again and return -EAGAIN, that should have mostly the same effect as what we are doing right now. >> Yeah, except for the locking the ttm delayed workqueue, but that bool should be easy to save/restore. >> I think this could work. > > Actually you could activate the delayed workqueue much earlier as well. > > Thinking more about it that sounds like a bug in the current code, because we probably want the workqueue activated before waiting for the fence. Ok, how about this? Because of the downgrade_write, a second gpu reset can't be started until the first finishes. I'm uncertain about it, I think I might either have to stop calling radeon_restore_bios_scratch_regs a second time, or I should call save_bios_scratch_regs the second time around. Also it feels like drm_helper_resume_force_mode should be called before downgrading exclusive_lock, but it might depend on PM restore. Tough! Maybe move both calls to before downgrade_write? commit 3644aae8581a15e3a935279287c397f7eab400ff Author: Maarten Lankhorst Date: Tue Aug 5 10:29:23 2014 +0200 drm/radeon: take exclusive_lock in read mode during ring tests Signed-off-by: Maarten Lankhorst diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index 29d9cc04c04e..de14e35da002 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h @@ -2286,7 +2286,7 @@ struct radeon_device { bool need_dma32; bool accel_working; bool fastfb_working; /* IGP feature*/ - bool needs_reset; + bool needs_reset, in_reset; struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES]; const struct firmware *me_fw; /* all family ME firmware */ const struct firmware *pfp_fw; /* r6/700 PFP firmware */ diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c index 03686fab842d..6317b8a2ef20 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c @@ -1620,37 +1620,44 @@ int radeon_gpu_reset(struct radeon_device *rdev) unsigned ring_sizes[RADEON_NUM_RINGS]; uint32_t *ring_data[RADEON_NUM_RINGS]; - bool saved = false; + bool saved; int i, r; int resched; +retry: + saved = false; down_write(&rdev->exclusive_lock); if (!rdev->needs_reset) { + WARN_ON(rdev->in_reset); up_write(&rdev->exclusive_lock); return 0; } rdev->needs_reset = false; - - radeon_save_bios_scratch_regs(rdev); - /* block TTM */ resched = ttm_bo_lock_delayed_workqueue(&rdev->mman.bdev); - radeon_pm_suspend(rdev); - radeon_suspend(rdev); - for (i = 0; i < RADEON_NUM_RINGS; ++i) { - ring_sizes[i] = radeon_ring_backup(rdev, &rdev->ring[i], - &ring_data[i]); - if (ring_sizes[i]) { - saved = true; - dev_info(rdev->dev, "Saved %d dwords of commands " - "on ring %d.\n", ring_sizes[i], i); + if (!rdev->in_reset) { + rdev->in_reset = true; + + radeon_save_bios_scratch_regs(rdev); + /* block TTM */ + radeon_pm_suspend(rdev); + radeon_suspend(rdev); + + for (i = 0; i < RADEON_NUM_RINGS; ++i) { + ring_sizes[i] = radeon_ring_backup(rdev, &rdev->ring[i], + &ring_data[i]); + if (ring_sizes[i]) { + saved = true; + dev_info(rdev->dev, "Saved %d dwords of commands " + "on ring %d.\n", ring_sizes[i], i); + } } - } + } else + memset(ring_data, 0, sizeof(ring_data)); -retry: r = radeon_asic_reset(rdev); if (!r) { dev_info(rdev->dev, "GPU reset succeeded, trying to resume\n"); @@ -1659,40 +1666,46 @@ retry: radeon_restore_bios_scratch_regs(rdev); - if (!r) { + if (!r && saved) { for (i = 0; i < RADEON_NUM_RINGS; ++i) { radeon_ring_restore(rdev, &rdev->ring[i], ring_sizes[i], ring_data[i]); - ring_sizes[i] = 0; ring_data[i] = NULL; } + } else { + radeon_fence_driver_force_completion(rdev); + + for (i = 0; i < RADEON_NUM_RINGS; ++i) { + kfree(ring_data[i]); + } + } + downgrade_write(&rdev->exclusive_lock); + ttm_bo_unlock_delayed_workqueue(&rdev->mman.bdev, resched); + if (!r) { r = radeon_ib_ring_tests(rdev); if (r) { dev_err(rdev->dev, "ib ring test failed (%d).\n", r); if (saved) { - saved = false; + /* if reset fails, try without saving data */ + rdev->needs_reset = true; radeon_suspend(rdev); + up_read(&rdev->exclusive_lock); goto retry; } } - } else { - radeon_fence_driver_force_completion(rdev); - for (i = 0; i < RADEON_NUM_RINGS; ++i) { - kfree(ring_data[i]); - } } radeon_pm_resume(rdev); drm_helper_resume_force_mode(rdev->ddev); - ttm_bo_unlock_delayed_workqueue(&rdev->mman.bdev, resched); if (r) { /* bad news, how to tell it to userspace ? */ dev_info(rdev->dev, "GPU reset failed\n"); } - up_write(&rdev->exclusive_lock); + rdev->in_reset = false; + up_read(&rdev->exclusive_lock); return r; }