From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v4 1/2] drm: Use srcu to protect drm_device.unplugged Date: Wed, 28 Mar 2018 09:47:40 +0300 Message-ID: <1522219661-26827-2-git-send-email-andr2000@gmail.com> References: <1522219661-26827-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1522219661-26827-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, intel-gfx@lists.freedesktop.org, =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= List-Id: dri-devel@lists.freedesktop.org RnJvbTogTm9yYWxmIFRyw7hubmVzIDxub3JhbGZAdHJvbm5lcy5vcmc+CgpVc2Ugc3JjdSB0byBw cm90ZWN0IGRybV9kZXZpY2UudW5wbHVnZ2VkIGluIGEgcmFjZSBmcmVlIG1hbm5lci4KRHJpdmVy cyBjYW4gdXNlIGRybV9kZXZfZW50ZXIoKS9kcm1fZGV2X2V4aXQoKSB0byBwcm90ZWN0IGFuZCBt YXJrCnNlY3Rpb25zIHByZXZlbnRpbmcgYWNjZXNzIHRvIGRldmljZSByZXNvdXJjZXMgdGhhdCBh cmUgbm90IGF2YWlsYWJsZQphZnRlciB0aGUgZGV2aWNlIGlzIGdvbmUuCgpTdWdnZXN0ZWQtYnk6 IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+ClNpZ25lZC1vZmYtYnk6IE5v cmFsZiBUcsO4bm5lcyA8bm9yYWxmQHRyb25uZXMub3JnPgpSZXZpZXdlZC1ieTogT2xla3NhbmRy IEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgpUZXN0ZWQt Ynk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFt LmNvbT4KQ2M6IGludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKLS0tCiBkcml2ZXJzL2dw dS9kcm0vZHJtX2Rydi5jIHwgNTQgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrLS0tLS0KIGluY2x1ZGUvZHJtL2RybV9kZXZpY2UuaCAgfCAgOSArKysrKysrLQogaW5j bHVkZS9kcm0vZHJtX2Rydi5oICAgICB8IDE1ICsrKysrKysrKy0tLS0KIDMgZmlsZXMgY2hhbmdl ZCwgNjggaW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2RybV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZHJ2LmMKaW5kZXggYTFi OTMzODczNmUzLi4zMmE4M2I0MWFiNjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1f ZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcnYuYwpAQCAtMzIsNiArMzIsNyBAQAog I2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CiAjaW5jbHVkZSA8bGludXgvbW91bnQuaD4K ICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc3JjdS5oPgogCiAjaW5j bHVkZSA8ZHJtL2RybV9kcnYuaD4KICNpbmNsdWRlIDxkcm0vZHJtUC5oPgpAQCAtNzUsNiArNzYs OCBAQCBzdGF0aWMgYm9vbCBkcm1fY29yZV9pbml0X2NvbXBsZXRlID0gZmFsc2U7CiAKIHN0YXRp YyBzdHJ1Y3QgZGVudHJ5ICpkcm1fZGVidWdmc19yb290OwogCitERUZJTkVfU1RBVElDX1NSQ1Uo ZHJtX3VucGx1Z19zcmN1KTsKKwogLyoKICAqIERSTSBNaW5vcnMKICAqIEEgRFJNIGRldmljZSBj YW4gcHJvdmlkZSBzZXZlcmFsIGNoYXItZGV2IGludGVyZmFjZXMgb24gdGhlIERSTS1NYWpvci4g RWFjaApAQCAtMzE4LDE4ICszMjEsNTEgQEAgdm9pZCBkcm1fcHV0X2RldihzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2KQogfQogRVhQT1JUX1NZTUJPTChkcm1fcHV0X2Rldik7CiAKLXN0YXRpYyB2b2lk IGRybV9kZXZpY2Vfc2V0X3VucGx1Z2dlZChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQorLyoqCisg KiBkcm1fZGV2X2VudGVyIC0gRW50ZXIgZGV2aWNlIGNyaXRpY2FsIHNlY3Rpb24KKyAqIEBkZXY6 IERSTSBkZXZpY2UKKyAqIEBpZHg6IFBvaW50ZXIgdG8gaW5kZXggdGhhdCB3aWxsIGJlIHBhc3Nl ZCB0byB0aGUgbWF0Y2hpbmcgZHJtX2Rldl9leGl0KCkKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG1h cmtzIGFuZCBwcm90ZWN0cyB0aGUgYmVnaW5uaW5nIG9mIGEgc2VjdGlvbiB0aGF0IHNob3VsZCBu b3QKKyAqIGJlIGVudGVyZWQgYWZ0ZXIgdGhlIGRldmljZSBoYXMgYmVlbiB1bnBsdWdnZWQuIFRo ZSBzZWN0aW9uIGVuZCBpcyBtYXJrZWQKKyAqIHdpdGggZHJtX2Rldl9leGl0KCkuIENhbGxzIHRv IHRoaXMgZnVuY3Rpb24gY2FuIGJlIG5lc3RlZC4KKyAqCisgKiBSZXR1cm5zOgorICogVHJ1ZSBp ZiBpdCBpcyBPSyB0byBlbnRlciB0aGUgc2VjdGlvbiwgZmFsc2Ugb3RoZXJ3aXNlLgorICovCiti b29sIGRybV9kZXZfZW50ZXIoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50ICppZHgpCit7CisJ KmlkeCA9IHNyY3VfcmVhZF9sb2NrKCZkcm1fdW5wbHVnX3NyY3UpOworCisJaWYgKGRldi0+dW5w bHVnZ2VkKSB7CisJCXNyY3VfcmVhZF91bmxvY2soJmRybV91bnBsdWdfc3JjdSwgKmlkeCk7CisJ CXJldHVybiBmYWxzZTsKKwl9CisKKwlyZXR1cm4gdHJ1ZTsKK30KK0VYUE9SVF9TWU1CT0woZHJt X2Rldl9lbnRlcik7CisKKy8qKgorICogZHJtX2Rldl9leGl0IC0gRXhpdCBkZXZpY2UgY3JpdGlj YWwgc2VjdGlvbgorICogQGlkeDogaW5kZXggcmV0dXJuZWQgZnJvbSBkcm1fZGV2X2VudGVyKCkK KyAqCisgKiBUaGlzIGZ1bmN0aW9uIG1hcmtzIHRoZSBlbmQgb2YgYSBzZWN0aW9uIHRoYXQgc2hv dWxkIG5vdCBiZSBlbnRlcmVkIGFmdGVyCisgKiB0aGUgZGV2aWNlIGhhcyBiZWVuIHVucGx1Z2dl ZC4KKyAqLwordm9pZCBkcm1fZGV2X2V4aXQoaW50IGlkeCkKIHsKLQlzbXBfd21iKCk7Ci0JYXRv bWljX3NldCgmZGV2LT51bnBsdWdnZWQsIDEpOworCXNyY3VfcmVhZF91bmxvY2soJmRybV91bnBs dWdfc3JjdSwgaWR4KTsKIH0KK0VYUE9SVF9TWU1CT0woZHJtX2Rldl9leGl0KTsKIAogLyoqCiAg KiBkcm1fZGV2X3VucGx1ZyAtIHVucGx1ZyBhIERSTSBkZXZpY2UKICAqIEBkZXY6IERSTSBkZXZp Y2UKICAqCiAgKiBUaGlzIHVucGx1Z3MgYSBob3RwbHVnZ2FibGUgRFJNIGRldmljZSwgd2hpY2gg bWFrZXMgaXQgaW5hY2Nlc3NpYmxlIHRvCi0gKiB1c2Vyc3BhY2Ugb3BlcmF0aW9ucy4gRW50cnkt cG9pbnRzIGNhbiB1c2UgZHJtX2Rldl9pc191bnBsdWdnZWQoKS4gVGhpcworICogdXNlcnNwYWNl IG9wZXJhdGlvbnMuIEVudHJ5LXBvaW50cyBjYW4gdXNlIGRybV9kZXZfZW50ZXIoKSBhbmQKKyAq IGRybV9kZXZfZXhpdCgpIHRvIHByb3RlY3QgZGV2aWNlIHJlc291cmNlcyBpbiBhIHJhY2UgZnJl ZSBtYW5uZXIuIFRoaXMKICAqIGVzc2VudGlhbGx5IHVucmVnaXN0ZXJzIHRoZSBkZXZpY2UgbGlr ZSBkcm1fZGV2X3VucmVnaXN0ZXIoKSwgYnV0IGNhbiBiZQogICogY2FsbGVkIHdoaWxlIHRoZXJl IGFyZSBzdGlsbCBvcGVuIHVzZXJzIG9mIEBkZXYuCiAgKi8KQEAgLTMzOCwxMCArMzc0LDE4IEBA IHZvaWQgZHJtX2Rldl91bnBsdWcoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAlkcm1fZGV2X3Vu cmVnaXN0ZXIoZGV2KTsKIAogCW11dGV4X2xvY2soJmRybV9nbG9iYWxfbXV0ZXgpOwotCWRybV9k ZXZpY2Vfc2V0X3VucGx1Z2dlZChkZXYpOwogCWlmIChkZXYtPm9wZW5fY291bnQgPT0gMCkKIAkJ ZHJtX2Rldl9wdXQoZGV2KTsKIAltdXRleF91bmxvY2soJmRybV9nbG9iYWxfbXV0ZXgpOworCisJ LyoKKwkgKiBBZnRlciBzeW5jaHJvbml6aW5nIGFueSBjcml0aWNhbCByZWFkIHNlY3Rpb24gaXMg Z3VhcmFudGVlZCB0byBzZWUKKwkgKiB0aGUgbmV3IHZhbHVlIG9mIC0+dW5wbHVnZ2VkLCBhbmQg YW55IGNyaXRpY2FsIHNlY3Rpb24gd2hpY2ggbWlnaHQKKwkgKiBzdGlsbCBoYXZlIHNlZW4gdGhl IG9sZCB2YWx1ZSBvZiAtPnVucGx1Z2dlZCBpcyBndWFyYW50ZWVkIHRvIGhhdmUKKwkgKiBmaW5p c2hlZC4KKwkgKi8KKwlkZXYtPnVucGx1Z2dlZCA9IHRydWU7CisJc3luY2hyb25pemVfc3JjdSgm ZHJtX3VucGx1Z19zcmN1KTsKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2Rldl91bnBsdWcpOwogCmRp ZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fZGV2aWNlLmggYi9pbmNsdWRlL2RybS9kcm1fZGV2 aWNlLmgKaW5kZXggN2M0ZmEzMmYzZmM2Li4zYTBlYWMyODg1YjcgMTAwNjQ0Ci0tLSBhL2luY2x1 ZGUvZHJtL2RybV9kZXZpY2UuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fZGV2aWNlLmgKQEAgLTQ2 LDcgKzQ2LDE0IEBAIHN0cnVjdCBkcm1fZGV2aWNlIHsKIAkvKiBjdXJyZW50bHkgYWN0aXZlIG1h c3RlciBmb3IgdGhpcyBkZXZpY2UuIFByb3RlY3RlZCBieSBtYXN0ZXJfbXV0ZXggKi8KIAlzdHJ1 Y3QgZHJtX21hc3RlciAqbWFzdGVyOwogCi0JYXRvbWljX3QgdW5wbHVnZ2VkOwkJCS8qKjwgRmxh ZyB3aGV0aGVyIGRldiBpcyBkZWFkICovCisJLyoqCisJICogQHVucGx1Z2dlZDoKKwkgKgorCSAq IEZsYWcgdG8gdGVsbCBpZiB0aGUgZGV2aWNlIGhhcyBiZWVuIHVucGx1Z2dlZC4KKwkgKiBTZWUg ZHJtX2Rldl9lbnRlcigpIGFuZCBkcm1fZGV2X2lzX3VucGx1Z2dlZCgpLgorCSAqLworCWJvb2wg dW5wbHVnZ2VkOworCiAJc3RydWN0IGlub2RlICphbm9uX2lub2RlOwkJLyoqPCBpbm9kZSBmb3Ig cHJpdmF0ZSBhZGRyZXNzLXNwYWNlICovCiAJY2hhciAqdW5pcXVlOwkJCQkvKio8IHVuaXF1ZSBu YW1lIG9mIHRoZSBkZXZpY2UgKi8KIAkvKkB9ICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9k cm1fZHJ2LmggYi9pbmNsdWRlL2RybS9kcm1fZHJ2LmgKaW5kZXggZDIzZGNkZDFiZDk1Li43ZTU0 NWY1Zjk0ZDMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9kcnYuaAorKysgYi9pbmNsdWRl L2RybS9kcm1fZHJ2LmgKQEAgLTYyNCw2ICs2MjQsOCBAQCB2b2lkIGRybV9kZXZfZ2V0KHN0cnVj dCBkcm1fZGV2aWNlICpkZXYpOwogdm9pZCBkcm1fZGV2X3B1dChzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2KTsKIHZvaWQgZHJtX2Rldl91bnJlZihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKIHZvaWQg ZHJtX3B1dF9kZXYoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Citib29sIGRybV9kZXZfZW50ZXIo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50ICppZHgpOwordm9pZCBkcm1fZGV2X2V4aXQoaW50 IGlkeCk7CiB2b2lkIGRybV9kZXZfdW5wbHVnKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwogCiAv KioKQEAgLTYzNSwxMSArNjM3LDE2IEBAIHZvaWQgZHJtX2Rldl91bnBsdWcoc3RydWN0IGRybV9k ZXZpY2UgKmRldik7CiAgKiB1bnBsdWdnZWQsIHRoZXNlIHR3byBmdW5jdGlvbnMgZ3VhcmFudGVl IHRoYXQgYW55IHN0b3JlIGJlZm9yZSBjYWxsaW5nCiAgKiBkcm1fZGV2X3VucGx1ZygpIGlzIHZp c2libGUgdG8gY2FsbGVycyBvZiB0aGlzIGZ1bmN0aW9uIGFmdGVyIGl0IGNvbXBsZXRlcwogICov Ci1zdGF0aWMgaW5saW5lIGludCBkcm1fZGV2X2lzX3VucGx1Z2dlZChzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2KQorc3RhdGljIGlubGluZSBib29sIGRybV9kZXZfaXNfdW5wbHVnZ2VkKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYpCiB7Ci0JaW50IHJldCA9IGF0b21pY19yZWFkKCZkZXYtPnVucGx1Z2dl ZCk7Ci0Jc21wX3JtYigpOwotCXJldHVybiByZXQ7CisJaW50IGlkeDsKKworCWlmIChkcm1fZGV2 X2VudGVyKGRldiwgJmlkeCkpIHsKKwkJZHJtX2Rldl9leGl0KGlkeCk7CisJCXJldHVybiBmYWxz ZTsKKwl9CisKKwlyZXR1cm4gdHJ1ZTsKIH0KIAogCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJ bnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752929AbeC1Gr4 (ORCPT ); Wed, 28 Mar 2018 02:47:56 -0400 Received: from mail-lf0-f67.google.com ([209.85.215.67]:33383 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752390AbeC1Grw (ORCPT ); Wed, 28 Mar 2018 02:47:52 -0400 X-Google-Smtp-Source: AIpwx49RhNrT+HHnoBfGZ7GN9MoVqfpuMs3qvhCmM/FTNNMUr0SJuzlOJIhCVfJe/QyZvJ1W9eimAw== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= , intel-gfx@lists.freedesktop.org Subject: [PATCH v4 1/2] drm: Use srcu to protect drm_device.unplugged Date: Wed, 28 Mar 2018 09:47:40 +0300 Message-Id: <1522219661-26827-2-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522219661-26827-1-git-send-email-andr2000@gmail.com> References: <1522219661-26827-1-git-send-email-andr2000@gmail.com> MIME-Version: 1.0 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 From: Noralf Trønnes Use srcu to protect drm_device.unplugged in a race free manner. Drivers can use drm_dev_enter()/drm_dev_exit() to protect and mark sections preventing access to device resources that are not available after the device is gone. Suggested-by: Daniel Vetter Signed-off-by: Noralf Trønnes Reviewed-by: Oleksandr Andrushchenko Tested-by: Oleksandr Andrushchenko Cc: intel-gfx@lists.freedesktop.org --- drivers/gpu/drm/drm_drv.c | 54 ++++++++++++++++++++++++++++++++++++++++++----- include/drm/drm_device.h | 9 +++++++- include/drm/drm_drv.h | 15 +++++++++---- 3 files changed, 68 insertions(+), 10 deletions(-) diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c index a1b9338736e3..32a83b41ab61 100644 --- a/drivers/gpu/drm/drm_drv.c +++ b/drivers/gpu/drm/drm_drv.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -75,6 +76,8 @@ static bool drm_core_init_complete = false; static struct dentry *drm_debugfs_root; +DEFINE_STATIC_SRCU(drm_unplug_srcu); + /* * DRM Minors * A DRM device can provide several char-dev interfaces on the DRM-Major. Each @@ -318,18 +321,51 @@ void drm_put_dev(struct drm_device *dev) } EXPORT_SYMBOL(drm_put_dev); -static void drm_device_set_unplugged(struct drm_device *dev) +/** + * drm_dev_enter - Enter device critical section + * @dev: DRM device + * @idx: Pointer to index that will be passed to the matching drm_dev_exit() + * + * This function marks and protects the beginning of a section that should not + * be entered after the device has been unplugged. The section end is marked + * with drm_dev_exit(). Calls to this function can be nested. + * + * Returns: + * True if it is OK to enter the section, false otherwise. + */ +bool drm_dev_enter(struct drm_device *dev, int *idx) +{ + *idx = srcu_read_lock(&drm_unplug_srcu); + + if (dev->unplugged) { + srcu_read_unlock(&drm_unplug_srcu, *idx); + return false; + } + + return true; +} +EXPORT_SYMBOL(drm_dev_enter); + +/** + * drm_dev_exit - Exit device critical section + * @idx: index returned from drm_dev_enter() + * + * This function marks the end of a section that should not be entered after + * the device has been unplugged. + */ +void drm_dev_exit(int idx) { - smp_wmb(); - atomic_set(&dev->unplugged, 1); + srcu_read_unlock(&drm_unplug_srcu, idx); } +EXPORT_SYMBOL(drm_dev_exit); /** * drm_dev_unplug - unplug a DRM device * @dev: DRM device * * This unplugs a hotpluggable DRM device, which makes it inaccessible to - * userspace operations. Entry-points can use drm_dev_is_unplugged(). This + * userspace operations. Entry-points can use drm_dev_enter() and + * drm_dev_exit() to protect device resources in a race free manner. This * essentially unregisters the device like drm_dev_unregister(), but can be * called while there are still open users of @dev. */ @@ -338,10 +374,18 @@ void drm_dev_unplug(struct drm_device *dev) drm_dev_unregister(dev); mutex_lock(&drm_global_mutex); - drm_device_set_unplugged(dev); if (dev->open_count == 0) drm_dev_put(dev); mutex_unlock(&drm_global_mutex); + + /* + * After synchronizing any critical read section is guaranteed to see + * the new value of ->unplugged, and any critical section which might + * still have seen the old value of ->unplugged is guaranteed to have + * finished. + */ + dev->unplugged = true; + synchronize_srcu(&drm_unplug_srcu); } EXPORT_SYMBOL(drm_dev_unplug); diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h index 7c4fa32f3fc6..3a0eac2885b7 100644 --- a/include/drm/drm_device.h +++ b/include/drm/drm_device.h @@ -46,7 +46,14 @@ struct drm_device { /* currently active master for this device. Protected by master_mutex */ struct drm_master *master; - atomic_t unplugged; /**< Flag whether dev is dead */ + /** + * @unplugged: + * + * Flag to tell if the device has been unplugged. + * See drm_dev_enter() and drm_dev_is_unplugged(). + */ + bool unplugged; + struct inode *anon_inode; /**< inode for private address-space */ char *unique; /**< unique name of the device */ /*@} */ diff --git a/include/drm/drm_drv.h b/include/drm/drm_drv.h index d23dcdd1bd95..7e545f5f94d3 100644 --- a/include/drm/drm_drv.h +++ b/include/drm/drm_drv.h @@ -624,6 +624,8 @@ void drm_dev_get(struct drm_device *dev); void drm_dev_put(struct drm_device *dev); void drm_dev_unref(struct drm_device *dev); void drm_put_dev(struct drm_device *dev); +bool drm_dev_enter(struct drm_device *dev, int *idx); +void drm_dev_exit(int idx); void drm_dev_unplug(struct drm_device *dev); /** @@ -635,11 +637,16 @@ void drm_dev_unplug(struct drm_device *dev); * unplugged, these two functions guarantee that any store before calling * drm_dev_unplug() is visible to callers of this function after it completes */ -static inline int drm_dev_is_unplugged(struct drm_device *dev) +static inline bool drm_dev_is_unplugged(struct drm_device *dev) { - int ret = atomic_read(&dev->unplugged); - smp_rmb(); - return ret; + int idx; + + if (drm_dev_enter(dev, &idx)) { + drm_dev_exit(idx); + return false; + } + + return true; } -- 2.7.4