From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f68.google.com ([74.125.82.68]:35202 "EHLO mail-wm0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750828AbcH2HZg (ORCPT ); Mon, 29 Aug 2016 03:25:36 -0400 Received: by mail-wm0-f68.google.com with SMTP id i5so8260679wmg.2 for ; Mon, 29 Aug 2016 00:25:36 -0700 (PDT) From: Chris Wilson To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Chris Wilson , Daniel Vetter , Sumit Semwal , linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org Subject: [PATCH 06/11] dma-buf: Introduce fence_get_rcu_safe() Date: Mon, 29 Aug 2016 08:08:29 +0100 Message-Id: <20160829070834.22296-6-chris@chris-wilson.co.uk> In-Reply-To: <20160829070834.22296-1-chris@chris-wilson.co.uk> References: <20160829070834.22296-1-chris@chris-wilson.co.uk> Sender: linux-media-owner@vger.kernel.org List-ID: This variant of fence_get_rcu() takes an RCU protected pointer to a fence and carefully returns a reference to the fence ensuring that it is not reallocated as it does. This is required when mixing fences and SLAB_DESTROY_BY_RCU - although it serves a more pedagogical function atm Signed-off-by: Chris Wilson Cc: Daniel Vetter Cc: Sumit Semwal Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Cc: linaro-mm-sig@lists.linaro.org --- include/linux/fence.h | 56 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 51 insertions(+), 5 deletions(-) diff --git a/include/linux/fence.h b/include/linux/fence.h index 0d763053f97a..c9c5ba98c302 100644 --- a/include/linux/fence.h +++ b/include/linux/fence.h @@ -183,6 +183,16 @@ void fence_release(struct kref *kref); void fence_free(struct fence *fence); /** + * fence_put - decreases refcount of the fence + * @fence: [in] fence to reduce refcount of + */ +static inline void fence_put(struct fence *fence) +{ + if (fence) + kref_put(&fence->refcount, fence_release); +} + +/** * fence_get - increases refcount of the fence * @fence: [in] fence to increase refcount of * @@ -210,13 +220,49 @@ static inline struct fence *fence_get_rcu(struct fence *fence) } /** - * fence_put - decreases refcount of the fence - * @fence: [in] fence to reduce refcount of + * fence_get_rcu_safe - acquire a reference to an RCU tracked fence + * @fence: [in] pointer to fence to increase refcount of + * + * Function returns NULL if no refcount could be obtained, or the fence. + * This function handles acquiring a reference to a fence that may be + * reallocated within the RCU grace period (such as with SLAB_DESTROY_BY_RCU), + * so long as the caller is using RCU on the pointer to the fence. + * + * An alternative mechanism is to employ a seqlock to protect a bunch of + * fences, such as used by struct reservation_object. When using a seqlock, + * the seqlock must be taken before and checked after a reference to the + * fence is acquired (as shown here). + * + * The caller is required to hold the RCU read lock. */ -static inline void fence_put(struct fence *fence) +static inline struct fence *fence_get_rcu_safe(struct fence * __rcu *fencep) { - if (fence) - kref_put(&fence->refcount, fence_release); + do { + struct fence *fence; + + fence = rcu_dereference(*fencep); + if (!fence || !fence_get_rcu(fence)) + return NULL; + + /* The atomic_inc_not_zero() inside fence_get_rcu() + * provides a full memory barrier upon success (such as now). + * This is paired with the write barrier from assigning + * to the __rcu protected fence pointer so that if that + * pointer still matches the current fence, we know we + * have successfully acquire a reference to it. If it no + * longer matches, we are holding a reference to some other + * reallocated pointer. This is possible if the allocator + * is using a freelist like SLAB_DESTROY_BY_RCU where the + * fence remains valid for the RCU grace period, but it + * may be reallocated. When using such allocators, we are + * responsible for ensuring the reference we get is to + * the right fence, as below. + */ + if (fence == rcu_access_pointer(*fencep)) + return rcu_pointer_handoff(fence); + + fence_put(fence); + } while (1); } int fence_signal(struct fence *fence); -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Chris Wilson Subject: [PATCH 06/11] dma-buf: Introduce fence_get_rcu_safe() Date: Mon, 29 Aug 2016 08:08:29 +0100 Message-ID: <20160829070834.22296-6-chris@chris-wilson.co.uk> References: <20160829070834.22296-1-chris@chris-wilson.co.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20160829070834.22296-1-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: dri-devel@lists.freedesktop.org Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, Sumit Semwal , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org VGhpcyB2YXJpYW50IG9mIGZlbmNlX2dldF9yY3UoKSB0YWtlcyBhbiBSQ1UgcHJvdGVjdGVkIHBv aW50ZXIgdG8gYQpmZW5jZSBhbmQgY2FyZWZ1bGx5IHJldHVybnMgYSByZWZlcmVuY2UgdG8gdGhl IGZlbmNlIGVuc3VyaW5nIHRoYXQgaXQgaXMKbm90IHJlYWxsb2NhdGVkIGFzIGl0IGRvZXMuIFRo aXMgaXMgcmVxdWlyZWQgd2hlbiBtaXhpbmcgZmVuY2VzIGFuZApTTEFCX0RFU1RST1lfQllfUkNV IC0gYWx0aG91Z2ggaXQgc2VydmVzIGEgbW9yZSBwZWRhZ29naWNhbCBmdW5jdGlvbiBhdG0KClNp Z25lZC1vZmYtYnk6IENocmlzIFdpbHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNvLnVrPgpDYzog RGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KQ2M6IFN1bWl0IFNlbXdhbCA8 c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+CkNjOiBsaW51eC1tZWRpYUB2Z2VyLmtlcm5lbC5vcmcK Q2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKQ2M6IGxpbmFyby1tbS1zaWdAbGlz dHMubGluYXJvLm9yZwotLS0KIGluY2x1ZGUvbGludXgvZmVuY2UuaCB8IDU2ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLQogMSBmaWxlIGNoYW5nZWQs IDUxIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9mZW5jZS5oIGIvaW5jbHVkZS9saW51eC9mZW5jZS5oCmluZGV4IDBkNzYzMDUzZjk3YS4u YzljNWJhOThjMzAyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2ZlbmNlLmgKKysrIGIvaW5j bHVkZS9saW51eC9mZW5jZS5oCkBAIC0xODMsNiArMTgzLDE2IEBAIHZvaWQgZmVuY2VfcmVsZWFz ZShzdHJ1Y3Qga3JlZiAqa3JlZik7CiB2b2lkIGZlbmNlX2ZyZWUoc3RydWN0IGZlbmNlICpmZW5j ZSk7CiAKIC8qKgorICogZmVuY2VfcHV0IC0gZGVjcmVhc2VzIHJlZmNvdW50IG9mIHRoZSBmZW5j ZQorICogQGZlbmNlOglbaW5dCWZlbmNlIHRvIHJlZHVjZSByZWZjb3VudCBvZgorICovCitzdGF0 aWMgaW5saW5lIHZvaWQgZmVuY2VfcHV0KHN0cnVjdCBmZW5jZSAqZmVuY2UpCit7CisJaWYgKGZl bmNlKQorCQlrcmVmX3B1dCgmZmVuY2UtPnJlZmNvdW50LCBmZW5jZV9yZWxlYXNlKTsKK30KKwor LyoqCiAgKiBmZW5jZV9nZXQgLSBpbmNyZWFzZXMgcmVmY291bnQgb2YgdGhlIGZlbmNlCiAgKiBA ZmVuY2U6CVtpbl0JZmVuY2UgdG8gaW5jcmVhc2UgcmVmY291bnQgb2YKICAqCkBAIC0yMTAsMTMg KzIyMCw0OSBAQCBzdGF0aWMgaW5saW5lIHN0cnVjdCBmZW5jZSAqZmVuY2VfZ2V0X3JjdShzdHJ1 Y3QgZmVuY2UgKmZlbmNlKQogfQogCiAvKioKLSAqIGZlbmNlX3B1dCAtIGRlY3JlYXNlcyByZWZj b3VudCBvZiB0aGUgZmVuY2UKLSAqIEBmZW5jZToJW2luXQlmZW5jZSB0byByZWR1Y2UgcmVmY291 bnQgb2YKKyAqIGZlbmNlX2dldF9yY3Vfc2FmZSAgLSBhY3F1aXJlIGEgcmVmZXJlbmNlIHRvIGFu IFJDVSB0cmFja2VkIGZlbmNlCisgKiBAZmVuY2U6CVtpbl0JcG9pbnRlciB0byBmZW5jZSB0byBp bmNyZWFzZSByZWZjb3VudCBvZgorICoKKyAqIEZ1bmN0aW9uIHJldHVybnMgTlVMTCBpZiBubyBy ZWZjb3VudCBjb3VsZCBiZSBvYnRhaW5lZCwgb3IgdGhlIGZlbmNlLgorICogVGhpcyBmdW5jdGlv biBoYW5kbGVzIGFjcXVpcmluZyBhIHJlZmVyZW5jZSB0byBhIGZlbmNlIHRoYXQgbWF5IGJlCisg KiByZWFsbG9jYXRlZCB3aXRoaW4gdGhlIFJDVSBncmFjZSBwZXJpb2QgKHN1Y2ggYXMgd2l0aCBT TEFCX0RFU1RST1lfQllfUkNVKSwKKyAqIHNvIGxvbmcgYXMgdGhlIGNhbGxlciBpcyB1c2luZyBS Q1Ugb24gdGhlIHBvaW50ZXIgdG8gdGhlIGZlbmNlLgorICoKKyAqIEFuIGFsdGVybmF0aXZlIG1l Y2hhbmlzbSBpcyB0byBlbXBsb3kgYSBzZXFsb2NrIHRvIHByb3RlY3QgYSBidW5jaCBvZgorICog ZmVuY2VzLCBzdWNoIGFzIHVzZWQgYnkgc3RydWN0IHJlc2VydmF0aW9uX29iamVjdC4gV2hlbiB1 c2luZyBhIHNlcWxvY2ssCisgKiB0aGUgc2VxbG9jayBtdXN0IGJlIHRha2VuIGJlZm9yZSBhbmQg Y2hlY2tlZCBhZnRlciBhIHJlZmVyZW5jZSB0byB0aGUKKyAqIGZlbmNlIGlzIGFjcXVpcmVkIChh cyBzaG93biBoZXJlKS4KKyAqCisgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIGhvbGQgdGhl IFJDVSByZWFkIGxvY2suCiAgKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBmZW5jZV9wdXQoc3RydWN0 IGZlbmNlICpmZW5jZSkKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGZlbmNlICpmZW5jZV9nZXRfcmN1 X3NhZmUoc3RydWN0IGZlbmNlICogX19yY3UgKmZlbmNlcCkKIHsKLQlpZiAoZmVuY2UpCi0JCWty ZWZfcHV0KCZmZW5jZS0+cmVmY291bnQsIGZlbmNlX3JlbGVhc2UpOworCWRvIHsKKwkJc3RydWN0 IGZlbmNlICpmZW5jZTsKKworCQlmZW5jZSA9IHJjdV9kZXJlZmVyZW5jZSgqZmVuY2VwKTsKKwkJ aWYgKCFmZW5jZSB8fCAhZmVuY2VfZ2V0X3JjdShmZW5jZSkpCisJCQlyZXR1cm4gTlVMTDsKKwor CQkvKiBUaGUgYXRvbWljX2luY19ub3RfemVybygpIGluc2lkZSBmZW5jZV9nZXRfcmN1KCkKKwkJ ICogcHJvdmlkZXMgYSBmdWxsIG1lbW9yeSBiYXJyaWVyIHVwb24gc3VjY2VzcyAoc3VjaCBhcyBu b3cpLgorCQkgKiBUaGlzIGlzIHBhaXJlZCB3aXRoIHRoZSB3cml0ZSBiYXJyaWVyIGZyb20gYXNz aWduaW5nCisJCSAqIHRvIHRoZSBfX3JjdSBwcm90ZWN0ZWQgZmVuY2UgcG9pbnRlciBzbyB0aGF0 IGlmIHRoYXQKKwkJICogcG9pbnRlciBzdGlsbCBtYXRjaGVzIHRoZSBjdXJyZW50IGZlbmNlLCB3 ZSBrbm93IHdlCisJCSAqIGhhdmUgc3VjY2Vzc2Z1bGx5IGFjcXVpcmUgYSByZWZlcmVuY2UgdG8g aXQuIElmIGl0IG5vCisJCSAqIGxvbmdlciBtYXRjaGVzLCB3ZSBhcmUgaG9sZGluZyBhIHJlZmVy ZW5jZSB0byBzb21lIG90aGVyCisJCSAqIHJlYWxsb2NhdGVkIHBvaW50ZXIuIFRoaXMgaXMgcG9z c2libGUgaWYgdGhlIGFsbG9jYXRvcgorCQkgKiBpcyB1c2luZyBhIGZyZWVsaXN0IGxpa2UgU0xB Ql9ERVNUUk9ZX0JZX1JDVSB3aGVyZSB0aGUKKwkJICogZmVuY2UgcmVtYWlucyB2YWxpZCBmb3Ig dGhlIFJDVSBncmFjZSBwZXJpb2QsIGJ1dCBpdAorCQkgKiBtYXkgYmUgcmVhbGxvY2F0ZWQuIFdo ZW4gdXNpbmcgc3VjaCBhbGxvY2F0b3JzLCB3ZSBhcmUKKwkJICogcmVzcG9uc2libGUgZm9yIGVu c3VyaW5nIHRoZSByZWZlcmVuY2Ugd2UgZ2V0IGlzIHRvCisJCSAqIHRoZSByaWdodCBmZW5jZSwg YXMgYmVsb3cuCisJCSAqLworCQlpZiAoZmVuY2UgPT0gcmN1X2FjY2Vzc19wb2ludGVyKCpmZW5j ZXApKQorCQkJcmV0dXJuIHJjdV9wb2ludGVyX2hhbmRvZmYoZmVuY2UpOworCisJCWZlbmNlX3B1 dChmZW5jZSk7CisJfSB3aGlsZSAoMSk7CiB9CiAKIGludCBmZW5jZV9zaWduYWwoc3RydWN0IGZl bmNlICpmZW5jZSk7Ci0tIAoyLjkuMwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vaW50ZWwtZ2Z4Cg==