From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [RFC] driver core: don't hold dev's parent lock when using async probe From: martin_liu Message-Id: <20180522141227.GA118442@google.com> Date: Tue, 22 May 2018 22:12:27 +0800 To: gregkh@linuxfoundation.org, stern@rowland.harvard.edu, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org List-ID: U09DIGhhdmUgaW50ZXJuYWwgSS9PIGJ1c2VzIHRoYXQgY2FuJ3QgYmUgcHJvYmVkIGZvciBkZXZp Y2VzLiBUaGUKZGV2aWNlcyBvbiB0aGUgYnVzZXMgY2FuIGJlIGFjY2Vzc2VkIGRpcmVjdGx5IHdp dGhvdXQgYWRkaXRpbmFsCmNvbmZpZ3VyYXRpb24gcmVxdWlyZWQuIFRoaXMgdHlwZSBvZiBidXMg aXMgcmVwcmVzZW50ZWQgYXMKInNpbXBsZS1idXMiLiBJbiBzb21lIHBsYXRmb3Jtcywgd2UgbmFt ZSAic29jIiB3aXRoICJzaW1wbGUtYnVzIgphdHRyaWJ1dGUgYW5kIG1hbnkgZGV2aWNlcyBhcmUg aG9va2VkIHVuZGVyIGFuZCBkZXNyaWJlIHRoZW0gaW4gRFQKKGRldmljZSB0cmVlKS4KCkluIGNv bW1pdCAnYmY3NGFkNWJjNDE3IGludHJvZHVjZSAoIltQQVRDSF0gSG9sZCB0aGUgZGV2aWNlJ3MK cGFyZW50J3MgbG9jayBkdXJpbmcgcHJvYmUgYW5kIHJlbW92ZSIpJyB0byBzb2x2ZSBVU0Igc3Vi c3lzdGVtCmxvY2sgc2VxdWVuY2Ugc2luY2UgdXNiIGRldmljZSdzIGNoYXJhY3RlcmlzdGljLiBU aHVzICJzb2MiCm5lZWRzIHRvIGJlIGxvY2tlZCB3aGVuZXZlciBhIGRldmljZSBhbmQgZHJpdmVy J3MgcHJvYmluZwpoYXBwZW4gdW5kZXIgInNvYyIgYnVzLiBEdXJpbmcgdGhpcyBwZXJpb2QsIGFu IGFzeW5jIGRyaXZlcgp0cmllcyB0byBwcm9iZSBhIGRldmljZSB3aGljaCBpcyB1bmRlciB0aGUg InNvYyIgYnVzIHdvdWxkIGJlCmJsb2NrZWQgdW50aWwgcHJldmlvdXMgZHJpdmVyIGZpbmlzaCB0 aGUgcHJvYmluZyBhbmQgcmVsZWFzZSAic29jIgpsb2NrLiBBbmQgdGhlIG5leHQgcHJvYmluZyB1 bmRlciB0aGUgInNvYyIgYnVzIG5lZWQgdG8gd2FpdCBmb3IKYXN5bmMgZmluaXNoLiBCZWNhdXNl IG9mIHRoYXQsIGRyaXZlcidzIGFzeW5jIHByb2JlIGZvciBpbml0CnRpbWUgaW1wcm92ZW1lbnQg d2lsbCBiZSBzaGFkb3dlZC4KClNpbmNlIG1hbnkgZGV2aWNlcyBkb24ndCBoYXZlIFVTQiBkZXZp Y2VzJyBjaGFyYWN0ZXJpc3RpYywgdGhleQphY3R1YWxseSBkb24ndCBuZWVkIHBhcmVudCdzIGxv Y2suIEhvd2V2ZXIsIGluIG9yZGVyIHRvIGNvbnRyb2wKdGhlIHJpc2sgYW5kIG1pbmltaXplIHRo ZSBpbXBhY3QsIHdlIGRvbid0IHJlcXVlc3QgcGFyZW50J3MgbG9jawpvbmx5IHdoZW4gYSBkcml2 ZXIgcmVxdWVzdHMgYXN5bmMgcHJvYmUuCgpBc3luYyBwcm9iZSBjb3VsZCBoYXZlIG1vcmUgYmVu ZWZpdCBhZnRlciB3ZSBoYXZlIHRoaXMgcGF0Y2guCgpTaWduZWQtb2ZmLWJ5OiBtYXJ0aW5fbGl1 IDxsaXVtYXJ0aW5AZ29vZ2xlLmNvbT4KLS0tClRoaXMgUkZDIGlzIGFza2VkIHRvIGdldCBzb21l IGZlZWRiYWNrIHNpbmNlIGl0IGludm9sZWQgZHJpdmVyCmNvcmUgYW5kIFVTQiBzdWJzeXN0ZW0u IEknbSBub3QgZmFtaWxpYXIgd2l0aCBVU0Igc3Vic3lzdGVtIGFuZApub3Qgc3VyZSBpZiB3ZSBz dGlsbCBuZWVkICdiZjc0YWQ1YmM0MTcgKCJbUEFUQ0hdIEhvbGQgdGhlCmRldmljZSdzIHBhcmVu dCdzIGxvY2sgZHVyaW5nIHByb2JlIGFuZCByZW1vdmUiKScgc2luY2UgaXQgaGFzCmJlZW4gdGhl cmUgb3ZlciAxMCB5ZWFycy4gSWYgd2Ugc3RpbGwgbmVlZCBpdCBhbmQgaGFyZCB0byBmaXggaXQK LCB0aGUgc2ltcGxlIHdheSBpcyB0byBmaW5kIGEgcGxhY2Ugbm90IHRvIGFsbG93IFVTQiBzdWJz eXN0ZW0KZHJpdmVycyB0byBoYXZlIGFzeW5jIHByb2JlIGNhcGFiaWxpdHkuIEFueSBzdWdnZXN0 aW9uIGlzIHdlbGNvbWUuCgogZHJpdmVycy9iYXNlL2J1cy5jIHwgMTkgKysrKysrKysrKysrKy0t LS0tLQogZHJpdmVycy9iYXNlL2RkLmMgIHwgMjMgKysrKysrKysrKysrKysrKy0tLS0tLS0KIDIg ZmlsZXMgY2hhbmdlZCwgMjkgaW5zZXJ0aW9ucygrKSwgMTMgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9iYXNlL2J1cy5jIGIvZHJpdmVycy9iYXNlL2J1cy5jCmluZGV4IGVmNjE4 MzMwNmI0MC4uNjQzNDMzMzk5NWQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2UvYnVzLmMKKysr IGIvZHJpdmVycy9iYXNlL2J1cy5jCkBAIC0xODEsMTMgKzE4MSwxNSBAQCBzdGF0aWMgc3NpemVf dCB1bmJpbmRfc3RvcmUoc3RydWN0IGRldmljZV9kcml2ZXIgKmRydiwgY29uc3QgY2hhciAqYnVm LAogCXN0cnVjdCBidXNfdHlwZSAqYnVzID0gYnVzX2dldChkcnYtPmJ1cyk7CiAJc3RydWN0IGRl dmljZSAqZGV2OwogCWludCBlcnIgPSAtRU5PREVWOworCWJvb2wgYWxsb3dfYXN5bmM7CiAKKwlh bGxvd19hc3luYyA9IGRyaXZlcl9hbGxvd3NfYXN5bmNfcHJvYmluZyhkcnYpOwogCWRldiA9IGJ1 c19maW5kX2RldmljZV9ieV9uYW1lKGJ1cywgTlVMTCwgYnVmKTsKIAlpZiAoZGV2ICYmIGRldi0+ ZHJpdmVyID09IGRydikgewotCQlpZiAoZGV2LT5wYXJlbnQpCS8qIE5lZWRlZCBmb3IgVVNCICov CisJCWlmIChkZXYtPnBhcmVudCAmJiAhYWxsb3dfYXN5bmMpLyogTmVlZGVkIGZvciBVU0IgKi8K IAkJCWRldmljZV9sb2NrKGRldi0+cGFyZW50KTsKIAkJZGV2aWNlX3JlbGVhc2VfZHJpdmVyKGRl dik7Ci0JCWlmIChkZXYtPnBhcmVudCkKKwkJaWYgKGRldi0+cGFyZW50ICYmICFhbGxvd19hc3lu YykKIAkJCWRldmljZV91bmxvY2soZGV2LT5wYXJlbnQpOwogCQllcnIgPSBjb3VudDsKIAl9CkBA IC0yMDgsMTUgKzIxMCwxNyBAQCBzdGF0aWMgc3NpemVfdCBiaW5kX3N0b3JlKHN0cnVjdCBkZXZp Y2VfZHJpdmVyICpkcnYsIGNvbnN0IGNoYXIgKmJ1ZiwKIAlzdHJ1Y3QgYnVzX3R5cGUgKmJ1cyA9 IGJ1c19nZXQoZHJ2LT5idXMpOwogCXN0cnVjdCBkZXZpY2UgKmRldjsKIAlpbnQgZXJyID0gLUVO T0RFVjsKKwlib29sIGFsbG93X2FzeW5jOwogCisJYWxsb3dfYXN5bmMgPSBkcml2ZXJfYWxsb3dz X2FzeW5jX3Byb2JpbmcoZHJ2KTsKIAlkZXYgPSBidXNfZmluZF9kZXZpY2VfYnlfbmFtZShidXMs IE5VTEwsIGJ1Zik7CiAJaWYgKGRldiAmJiBkZXYtPmRyaXZlciA9PSBOVUxMICYmIGRyaXZlcl9t YXRjaF9kZXZpY2UoZHJ2LCBkZXYpKSB7Ci0JCWlmIChkZXYtPnBhcmVudCkJLyogTmVlZGVkIGZv ciBVU0IgKi8KKwkJaWYgKGRldi0+cGFyZW50ICYmICFhbGxvd19hc3luYykvKiBOZWVkZWQgZm9y IFVTQiAqLwogCQkJZGV2aWNlX2xvY2soZGV2LT5wYXJlbnQpOwogCQlkZXZpY2VfbG9jayhkZXYp OwogCQllcnIgPSBkcml2ZXJfcHJvYmVfZGV2aWNlKGRydiwgZGV2KTsKIAkJZGV2aWNlX3VubG9j ayhkZXYpOwotCQlpZiAoZGV2LT5wYXJlbnQpCisJCWlmIChkZXYtPnBhcmVudCAmJiAhYWxsb3df YXN5bmMpCiAJCQlkZXZpY2VfdW5sb2NrKGRldi0+cGFyZW50KTsKIAogCQlpZiAoZXJyID4gMCkg ewpAQCAtNzY5LDExICs3NzMsMTQgQEAgRVhQT1JUX1NZTUJPTF9HUEwoYnVzX3Jlc2Nhbl9kZXZp Y2VzKTsKICAqLwogaW50IGRldmljZV9yZXByb2JlKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKKwli b29sIGFsbG93X2FzeW5jOworCiAJaWYgKGRldi0+ZHJpdmVyKSB7Ci0JCWlmIChkZXYtPnBhcmVu dCkgICAgICAgIC8qIE5lZWRlZCBmb3IgVVNCICovCisJCWFsbG93X2FzeW5jID0gZHJpdmVyX2Fs bG93c19hc3luY19wcm9iaW5nKGRldi0+ZHJpdmVyKTsKKwkJaWYgKGRldi0+cGFyZW50ICYmICFh bGxvd19hc3luYykvKiBOZWVkZWQgZm9yIFVTQiAqLwogCQkJZGV2aWNlX2xvY2soZGV2LT5wYXJl bnQpOwogCQlkZXZpY2VfcmVsZWFzZV9kcml2ZXIoZGV2KTsKLQkJaWYgKGRldi0+cGFyZW50KQor CQlpZiAoZGV2LT5wYXJlbnQgJiYgIWFsbG93X2FzeW5jKQogCQkJZGV2aWNlX3VubG9jayhkZXYt PnBhcmVudCk7CiAJfQogCXJldHVybiBidXNfcmVzY2FuX2RldmljZXNfaGVscGVyKGRldiwgTlVM TCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvZGQuYyBiL2RyaXZlcnMvYmFzZS9kZC5jCmlu ZGV4IGM5ZjU0MDg5NDI5Yi4uMzZhZWQxNTc2YzU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2Uv ZGQuYworKysgYi9kcml2ZXJzL2Jhc2UvZGQuYwpAQCAtNzk0LDYgKzc5NCw3IEBAIHN0YXRpYyBp bnQgX19kcml2ZXJfYXR0YWNoKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkKIHsKIAlz dHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2ID0gZGF0YTsKIAlpbnQgcmV0OworCWJvb2wgYWxsb3df YXN5bmM7CiAKIAkvKgogCSAqIExvY2sgZGV2aWNlIGFuZCB0cnkgdG8gYmluZCB0byBpdC4gV2Ug ZHJvcCB0aGUgZXJyb3IKQEAgLTgxNywxMyArODE4LDE0IEBAIHN0YXRpYyBpbnQgX19kcml2ZXJf YXR0YWNoKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkKIAkJcmV0dXJuIHJldDsKIAl9 IC8qIHJldCA+IDAgbWVhbnMgcG9zaXRpdmUgbWF0Y2ggKi8KIAotCWlmIChkZXYtPnBhcmVudCkJ LyogTmVlZGVkIGZvciBVU0IgKi8KKwlhbGxvd19hc3luYyA9IGRyaXZlcl9hbGxvd3NfYXN5bmNf cHJvYmluZyhkcnYpOworCWlmIChkZXYtPnBhcmVudCAmJiAhYWxsb3dfYXN5bmMpLyogTmVlZGVk IGZvciBVU0IgKi8KIAkJZGV2aWNlX2xvY2soZGV2LT5wYXJlbnQpOwogCWRldmljZV9sb2NrKGRl dik7CiAJaWYgKCFkZXYtPmRyaXZlcikKIAkJZHJpdmVyX3Byb2JlX2RldmljZShkcnYsIGRldik7 CiAJZGV2aWNlX3VubG9jayhkZXYpOwotCWlmIChkZXYtPnBhcmVudCkKKwlpZiAoZGV2LT5wYXJl bnQgJiYgIWFsbG93X2FzeW5jKQogCQlkZXZpY2VfdW5sb2NrKGRldi0+cGFyZW50KTsKIAogCXJl dHVybiAwOwpAQCAtODUxLDE5ICs4NTMsMjEgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZHJpdmVyX2F0 dGFjaCk7CiBzdGF0aWMgdm9pZCBfX2RldmljZV9yZWxlYXNlX2RyaXZlcihzdHJ1Y3QgZGV2aWNl ICpkZXYsIHN0cnVjdCBkZXZpY2UgKnBhcmVudCkKIHsKIAlzdHJ1Y3QgZGV2aWNlX2RyaXZlciAq ZHJ2OworCWJvb2wgYWxsb3dfYXN5bmM7CiAKIAlkcnYgPSBkZXYtPmRyaXZlcjsKIAlpZiAoZHJ2 KSB7Ci0JCWlmIChkcml2ZXJfYWxsb3dzX2FzeW5jX3Byb2JpbmcoZHJ2KSkKKwkJYWxsb3dfYXN5 bmMgPSBkcml2ZXJfYWxsb3dzX2FzeW5jX3Byb2JpbmcoZHJ2KTsKKwkJaWYgKGFsbG93X2FzeW5j KQogCQkJYXN5bmNfc3luY2hyb25pemVfZnVsbCgpOwogCiAJCXdoaWxlIChkZXZpY2VfbGlua3Nf YnVzeShkZXYpKSB7CiAJCQlkZXZpY2VfdW5sb2NrKGRldik7Ci0JCQlpZiAocGFyZW50KQorCQkJ aWYgKHBhcmVudCAmJiAhYWxsb3dfYXN5bmMpCiAJCQkJZGV2aWNlX3VubG9jayhwYXJlbnQpOwog CiAJCQlkZXZpY2VfbGlua3NfdW5iaW5kX2NvbnN1bWVycyhkZXYpOwotCQkJaWYgKHBhcmVudCkK KwkJCWlmIChwYXJlbnQgJiYgIWFsbG93X2FzeW5jKQogCQkJCWRldmljZV9sb2NrKHBhcmVudCk7 CiAKIAkJCWRldmljZV9sb2NrKGRldik7CkBAIC05MTksNyArOTIzLDEyIEBAIHZvaWQgZGV2aWNl X3JlbGVhc2VfZHJpdmVyX2ludGVybmFsKHN0cnVjdCBkZXZpY2UgKmRldiwKIAkJCQkgICAgc3Ry dWN0IGRldmljZV9kcml2ZXIgKmRydiwKIAkJCQkgICAgc3RydWN0IGRldmljZSAqcGFyZW50KQog ewotCWlmIChwYXJlbnQpCisJYm9vbCBhbGxvd19hc3luYyA9IGZhbHNlOworCisJaWYgKGRydikK KwkJYWxsb3dfYXN5bmMgPSBkcml2ZXJfYWxsb3dzX2FzeW5jX3Byb2JpbmcoZHJ2KTsKKworCWlm IChwYXJlbnQgJiYgIWFsbG93X2FzeW5jKQogCQlkZXZpY2VfbG9jayhwYXJlbnQpOwogCiAJZGV2 aWNlX2xvY2soZGV2KTsKQEAgLTkyNyw3ICs5MzYsNyBAQCB2b2lkIGRldmljZV9yZWxlYXNlX2Ry aXZlcl9pbnRlcm5hbChzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJCV9fZGV2aWNlX3JlbGVhc2VfZHJp dmVyKGRldiwgcGFyZW50KTsKIAogCWRldmljZV91bmxvY2soZGV2KTsKLQlpZiAocGFyZW50KQor CWlmIChwYXJlbnQgJiYgIWFsbG93X2FzeW5jKQogCQlkZXZpY2VfdW5sb2NrKHBhcmVudCk7CiB9 CiAK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752062AbeEVOMi (ORCPT ); Tue, 22 May 2018 10:12:38 -0400 Received: from mail-pl0-f67.google.com ([209.85.160.67]:42045 "EHLO mail-pl0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751199AbeEVOMd (ORCPT ); Tue, 22 May 2018 10:12:33 -0400 X-Google-Smtp-Source: AB8JxZoYMx57Gs+df6EnnJj7LYN2vmp7AvVU67Ps/9KF+zNGMCYepWN37q9EPBHHGzuNtkReeqxiUA== Date: Tue, 22 May 2018 22:12:27 +0800 From: martin_liu To: gregkh@linuxfoundation.org, stern@rowland.harvard.edu, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC] driver core: don't hold dev's parent lock when using async probe Message-ID: <20180522141227.GA118442@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.9.2 (2017-12-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org SOC have internal I/O buses that can't be probed for devices. The devices on the buses can be accessed directly without additinal configuration required. This type of bus is represented as "simple-bus". In some platforms, we name "soc" with "simple-bus" attribute and many devices are hooked under and desribe them in DT (device tree). In commit 'bf74ad5bc417 introduce ("[PATCH] Hold the device's parent's lock during probe and remove")' to solve USB subsystem lock sequence since usb device's characteristic. Thus "soc" needs to be locked whenever a device and driver's probing happen under "soc" bus. During this period, an async driver tries to probe a device which is under the "soc" bus would be blocked until previous driver finish the probing and release "soc" lock. And the next probing under the "soc" bus need to wait for async finish. Because of that, driver's async probe for init time improvement will be shadowed. Since many devices don't have USB devices' characteristic, they actually don't need parent's lock. However, in order to control the risk and minimize the impact, we don't request parent's lock only when a driver requests async probe. Async probe could have more benefit after we have this patch. Signed-off-by: martin_liu --- This RFC is asked to get some feedback since it involed driver core and USB subsystem. I'm not familiar with USB subsystem and not sure if we still need 'bf74ad5bc417 ("[PATCH] Hold the device's parent's lock during probe and remove")' since it has been there over 10 years. If we still need it and hard to fix it , the simple way is to find a place not to allow USB subsystem drivers to have async probe capability. Any suggestion is welcome. drivers/base/bus.c | 19 +++++++++++++------ drivers/base/dd.c | 23 ++++++++++++++++------- 2 files changed, 29 insertions(+), 13 deletions(-) diff --git a/drivers/base/bus.c b/drivers/base/bus.c index ef6183306b40..6434333995d4 100644 --- a/drivers/base/bus.c +++ b/drivers/base/bus.c @@ -181,13 +181,15 @@ static ssize_t unbind_store(struct device_driver *drv, const char *buf, struct bus_type *bus = bus_get(drv->bus); struct device *dev; int err = -ENODEV; + bool allow_async; + allow_async = driver_allows_async_probing(drv); dev = bus_find_device_by_name(bus, NULL, buf); if (dev && dev->driver == drv) { - if (dev->parent) /* Needed for USB */ + if (dev->parent && !allow_async)/* Needed for USB */ device_lock(dev->parent); device_release_driver(dev); - if (dev->parent) + if (dev->parent && !allow_async) device_unlock(dev->parent); err = count; } @@ -208,15 +210,17 @@ static ssize_t bind_store(struct device_driver *drv, const char *buf, struct bus_type *bus = bus_get(drv->bus); struct device *dev; int err = -ENODEV; + bool allow_async; + allow_async = driver_allows_async_probing(drv); dev = bus_find_device_by_name(bus, NULL, buf); if (dev && dev->driver == NULL && driver_match_device(drv, dev)) { - if (dev->parent) /* Needed for USB */ + if (dev->parent && !allow_async)/* Needed for USB */ device_lock(dev->parent); device_lock(dev); err = driver_probe_device(drv, dev); device_unlock(dev); - if (dev->parent) + if (dev->parent && !allow_async) device_unlock(dev->parent); if (err > 0) { @@ -769,11 +773,14 @@ EXPORT_SYMBOL_GPL(bus_rescan_devices); */ int device_reprobe(struct device *dev) { + bool allow_async; + if (dev->driver) { - if (dev->parent) /* Needed for USB */ + allow_async = driver_allows_async_probing(dev->driver); + if (dev->parent && !allow_async)/* Needed for USB */ device_lock(dev->parent); device_release_driver(dev); - if (dev->parent) + if (dev->parent && !allow_async) device_unlock(dev->parent); } return bus_rescan_devices_helper(dev, NULL); diff --git a/drivers/base/dd.c b/drivers/base/dd.c index c9f54089429b..36aed1576c58 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -794,6 +794,7 @@ static int __driver_attach(struct device *dev, void *data) { struct device_driver *drv = data; int ret; + bool allow_async; /* * Lock device and try to bind to it. We drop the error @@ -817,13 +818,14 @@ static int __driver_attach(struct device *dev, void *data) return ret; } /* ret > 0 means positive match */ - if (dev->parent) /* Needed for USB */ + allow_async = driver_allows_async_probing(drv); + if (dev->parent && !allow_async)/* Needed for USB */ device_lock(dev->parent); device_lock(dev); if (!dev->driver) driver_probe_device(drv, dev); device_unlock(dev); - if (dev->parent) + if (dev->parent && !allow_async) device_unlock(dev->parent); return 0; @@ -851,19 +853,21 @@ EXPORT_SYMBOL_GPL(driver_attach); static void __device_release_driver(struct device *dev, struct device *parent) { struct device_driver *drv; + bool allow_async; drv = dev->driver; if (drv) { - if (driver_allows_async_probing(drv)) + allow_async = driver_allows_async_probing(drv); + if (allow_async) async_synchronize_full(); while (device_links_busy(dev)) { device_unlock(dev); - if (parent) + if (parent && !allow_async) device_unlock(parent); device_links_unbind_consumers(dev); - if (parent) + if (parent && !allow_async) device_lock(parent); device_lock(dev); @@ -919,7 +923,12 @@ void device_release_driver_internal(struct device *dev, struct device_driver *drv, struct device *parent) { - if (parent) + bool allow_async = false; + + if (drv) + allow_async = driver_allows_async_probing(drv); + + if (parent && !allow_async) device_lock(parent); device_lock(dev); @@ -927,7 +936,7 @@ void device_release_driver_internal(struct device *dev, __device_release_driver(dev, parent); device_unlock(dev); - if (parent) + if (parent && !allow_async) device_unlock(parent); } -- 2.17.0.441.gb46fe60e1d-goog