From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f68.google.com ([209.85.215.68]:34243 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755454AbcIWM7i (ORCPT ); Fri, 23 Sep 2016 08:59:38 -0400 Received: by mail-lf0-f68.google.com with SMTP id b71so4860297lfg.1 for ; Fri, 23 Sep 2016 05:59:37 -0700 (PDT) Date: Fri, 23 Sep 2016 14:59:32 +0200 From: Daniel Vetter To: Chris Wilson Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, Daniel Vetter , Sumit Semwal , linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org Subject: Re: [PATCH 06/11] dma-buf: Introduce fence_get_rcu_safe() Message-ID: <20160923125932.GG3988@dvetter-linux.ger.corp.intel.com> References: <20160829070834.22296-1-chris@chris-wilson.co.uk> <20160829070834.22296-6-chris@chris-wilson.co.uk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20160829070834.22296-6-chris@chris-wilson.co.uk> Sender: linux-media-owner@vger.kernel.org List-ID: On Mon, Aug 29, 2016 at 08:08:29AM +0100, Chris Wilson wrote: > 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. Would be good to cross reference the various fence_get functions a bit better in the docs. But since the docs aren't yet pulled into the rst/html output, that doesn't matter that much. Hence as-is: Reviewed-by: Daniel Vetter > */ > -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 > -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 06/11] dma-buf: Introduce fence_get_rcu_safe() Date: Fri, 23 Sep 2016 14:59:32 +0200 Message-ID: <20160923125932.GG3988@dvetter-linux.ger.corp.intel.com> References: <20160829070834.22296-1-chris@chris-wilson.co.uk> <20160829070834.22296-6-chris@chris-wilson.co.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20160829070834.22296-6-chris@chris-wilson.co.uk> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Chris Wilson Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-media@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org T24gTW9uLCBBdWcgMjksIDIwMTYgYXQgMDg6MDg6MjlBTSArMDEwMCwgQ2hyaXMgV2lsc29uIHdy b3RlOgo+IFRoaXMgdmFyaWFudCBvZiBmZW5jZV9nZXRfcmN1KCkgdGFrZXMgYW4gUkNVIHByb3Rl Y3RlZCBwb2ludGVyIHRvIGEKPiBmZW5jZSBhbmQgY2FyZWZ1bGx5IHJldHVybnMgYSByZWZlcmVu Y2UgdG8gdGhlIGZlbmNlIGVuc3VyaW5nIHRoYXQgaXQgaXMKPiBub3QgcmVhbGxvY2F0ZWQgYXMg aXQgZG9lcy4gVGhpcyBpcyByZXF1aXJlZCB3aGVuIG1peGluZyBmZW5jZXMgYW5kCj4gU0xBQl9E RVNUUk9ZX0JZX1JDVSAtIGFsdGhvdWdoIGl0IHNlcnZlcyBhIG1vcmUgcGVkYWdvZ2ljYWwgZnVu Y3Rpb24gYXRtCj4gCj4gU2lnbmVkLW9mZi1ieTogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13 aWxzb24uY28udWs+Cj4gQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+ Cj4gQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+Cj4gQ2M6IGxpbnV4 LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IENjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCj4gQ2M6IGxpbmFyby1tbS1zaWdAbGlzdHMubGluYXJvLm9yZwo+IC0tLQo+ICBpbmNsdWRl L2xpbnV4L2ZlbmNlLmggfCA1NiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0tLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDUxIGluc2VydGlvbnMoKyksIDUgZGVs ZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZmVuY2UuaCBiL2luY2x1 ZGUvbGludXgvZmVuY2UuaAo+IGluZGV4IDBkNzYzMDUzZjk3YS4uYzljNWJhOThjMzAyIDEwMDY0 NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZmVuY2UuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvZmVu Y2UuaAo+IEBAIC0xODMsNiArMTgzLDE2IEBAIHZvaWQgZmVuY2VfcmVsZWFzZShzdHJ1Y3Qga3Jl ZiAqa3JlZik7Cj4gIHZvaWQgZmVuY2VfZnJlZShzdHJ1Y3QgZmVuY2UgKmZlbmNlKTsKPiAgCj4g IC8qKgo+ICsgKiBmZW5jZV9wdXQgLSBkZWNyZWFzZXMgcmVmY291bnQgb2YgdGhlIGZlbmNlCj4g KyAqIEBmZW5jZToJW2luXQlmZW5jZSB0byByZWR1Y2UgcmVmY291bnQgb2YKPiArICovCj4gK3N0 YXRpYyBpbmxpbmUgdm9pZCBmZW5jZV9wdXQoc3RydWN0IGZlbmNlICpmZW5jZSkKPiArewo+ICsJ aWYgKGZlbmNlKQo+ICsJCWtyZWZfcHV0KCZmZW5jZS0+cmVmY291bnQsIGZlbmNlX3JlbGVhc2Up Owo+ICt9Cj4gKwo+ICsvKioKPiAgICogZmVuY2VfZ2V0IC0gaW5jcmVhc2VzIHJlZmNvdW50IG9m IHRoZSBmZW5jZQo+ICAgKiBAZmVuY2U6CVtpbl0JZmVuY2UgdG8gaW5jcmVhc2UgcmVmY291bnQg b2YKPiAgICoKPiBAQCAtMjEwLDEzICsyMjAsNDkgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZmVu Y2UgKmZlbmNlX2dldF9yY3Uoc3RydWN0IGZlbmNlICpmZW5jZSkKPiAgfQo+ICAKPiAgLyoqCj4g LSAqIGZlbmNlX3B1dCAtIGRlY3JlYXNlcyByZWZjb3VudCBvZiB0aGUgZmVuY2UKPiAtICogQGZl bmNlOglbaW5dCWZlbmNlIHRvIHJlZHVjZSByZWZjb3VudCBvZgo+ICsgKiBmZW5jZV9nZXRfcmN1 X3NhZmUgIC0gYWNxdWlyZSBhIHJlZmVyZW5jZSB0byBhbiBSQ1UgdHJhY2tlZCBmZW5jZQo+ICsg KiBAZmVuY2U6CVtpbl0JcG9pbnRlciB0byBmZW5jZSB0byBpbmNyZWFzZSByZWZjb3VudCBvZgo+ ICsgKgo+ICsgKiBGdW5jdGlvbiByZXR1cm5zIE5VTEwgaWYgbm8gcmVmY291bnQgY291bGQgYmUg b2J0YWluZWQsIG9yIHRoZSBmZW5jZS4KPiArICogVGhpcyBmdW5jdGlvbiBoYW5kbGVzIGFjcXVp cmluZyBhIHJlZmVyZW5jZSB0byBhIGZlbmNlIHRoYXQgbWF5IGJlCj4gKyAqIHJlYWxsb2NhdGVk IHdpdGhpbiB0aGUgUkNVIGdyYWNlIHBlcmlvZCAoc3VjaCBhcyB3aXRoIFNMQUJfREVTVFJPWV9C WV9SQ1UpLAo+ICsgKiBzbyBsb25nIGFzIHRoZSBjYWxsZXIgaXMgdXNpbmcgUkNVIG9uIHRoZSBw b2ludGVyIHRvIHRoZSBmZW5jZS4KPiArICoKPiArICogQW4gYWx0ZXJuYXRpdmUgbWVjaGFuaXNt IGlzIHRvIGVtcGxveSBhIHNlcWxvY2sgdG8gcHJvdGVjdCBhIGJ1bmNoIG9mCj4gKyAqIGZlbmNl cywgc3VjaCBhcyB1c2VkIGJ5IHN0cnVjdCByZXNlcnZhdGlvbl9vYmplY3QuIFdoZW4gdXNpbmcg YSBzZXFsb2NrLAo+ICsgKiB0aGUgc2VxbG9jayBtdXN0IGJlIHRha2VuIGJlZm9yZSBhbmQgY2hl Y2tlZCBhZnRlciBhIHJlZmVyZW5jZSB0byB0aGUKPiArICogZmVuY2UgaXMgYWNxdWlyZWQgKGFz IHNob3duIGhlcmUpLgo+ICsgKgo+ICsgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIGhvbGQg dGhlIFJDVSByZWFkIGxvY2suCgpXb3VsZCBiZSBnb29kIHRvIGNyb3NzIHJlZmVyZW5jZSB0aGUg dmFyaW91cyBmZW5jZV9nZXQgZnVuY3Rpb25zIGEgYml0CmJldHRlciBpbiB0aGUgZG9jcy4gQnV0 IHNpbmNlIHRoZSBkb2NzIGFyZW4ndCB5ZXQgcHVsbGVkIGludG8gdGhlIHJzdC9odG1sCm91dHB1 dCwgdGhhdCBkb2Vzbid0IG1hdHRlciB0aGF0IG11Y2guIEhlbmNlIGFzLWlzOgoKUmV2aWV3ZWQt Ynk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+Cgo+ICAgKi8KPiAtc3Rh dGljIGlubGluZSB2b2lkIGZlbmNlX3B1dChzdHJ1Y3QgZmVuY2UgKmZlbmNlKQo+ICtzdGF0aWMg aW5saW5lIHN0cnVjdCBmZW5jZSAqZmVuY2VfZ2V0X3JjdV9zYWZlKHN0cnVjdCBmZW5jZSAqIF9f cmN1ICpmZW5jZXApCj4gIHsKPiAtCWlmIChmZW5jZSkKPiAtCQlrcmVmX3B1dCgmZmVuY2UtPnJl ZmNvdW50LCBmZW5jZV9yZWxlYXNlKTsKPiArCWRvIHsKPiArCQlzdHJ1Y3QgZmVuY2UgKmZlbmNl Owo+ICsKPiArCQlmZW5jZSA9IHJjdV9kZXJlZmVyZW5jZSgqZmVuY2VwKTsKPiArCQlpZiAoIWZl bmNlIHx8ICFmZW5jZV9nZXRfcmN1KGZlbmNlKSkKPiArCQkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJ CS8qIFRoZSBhdG9taWNfaW5jX25vdF96ZXJvKCkgaW5zaWRlIGZlbmNlX2dldF9yY3UoKQo+ICsJ CSAqIHByb3ZpZGVzIGEgZnVsbCBtZW1vcnkgYmFycmllciB1cG9uIHN1Y2Nlc3MgKHN1Y2ggYXMg bm93KS4KPiArCQkgKiBUaGlzIGlzIHBhaXJlZCB3aXRoIHRoZSB3cml0ZSBiYXJyaWVyIGZyb20g YXNzaWduaW5nCj4gKwkJICogdG8gdGhlIF9fcmN1IHByb3RlY3RlZCBmZW5jZSBwb2ludGVyIHNv IHRoYXQgaWYgdGhhdAo+ICsJCSAqIHBvaW50ZXIgc3RpbGwgbWF0Y2hlcyB0aGUgY3VycmVudCBm ZW5jZSwgd2Uga25vdyB3ZQo+ICsJCSAqIGhhdmUgc3VjY2Vzc2Z1bGx5IGFjcXVpcmUgYSByZWZl cmVuY2UgdG8gaXQuIElmIGl0IG5vCj4gKwkJICogbG9uZ2VyIG1hdGNoZXMsIHdlIGFyZSBob2xk aW5nIGEgcmVmZXJlbmNlIHRvIHNvbWUgb3RoZXIKPiArCQkgKiByZWFsbG9jYXRlZCBwb2ludGVy LiBUaGlzIGlzIHBvc3NpYmxlIGlmIHRoZSBhbGxvY2F0b3IKPiArCQkgKiBpcyB1c2luZyBhIGZy ZWVsaXN0IGxpa2UgU0xBQl9ERVNUUk9ZX0JZX1JDVSB3aGVyZSB0aGUKPiArCQkgKiBmZW5jZSBy ZW1haW5zIHZhbGlkIGZvciB0aGUgUkNVIGdyYWNlIHBlcmlvZCwgYnV0IGl0Cj4gKwkJICogbWF5 IGJlIHJlYWxsb2NhdGVkLiBXaGVuIHVzaW5nIHN1Y2ggYWxsb2NhdG9ycywgd2UgYXJlCj4gKwkJ ICogcmVzcG9uc2libGUgZm9yIGVuc3VyaW5nIHRoZSByZWZlcmVuY2Ugd2UgZ2V0IGlzIHRvCj4g KwkJICogdGhlIHJpZ2h0IGZlbmNlLCBhcyBiZWxvdy4KPiArCQkgKi8KPiArCQlpZiAoZmVuY2Ug PT0gcmN1X2FjY2Vzc19wb2ludGVyKCpmZW5jZXApKQo+ICsJCQlyZXR1cm4gcmN1X3BvaW50ZXJf aGFuZG9mZihmZW5jZSk7Cj4gKwo+ICsJCWZlbmNlX3B1dChmZW5jZSk7Cj4gKwl9IHdoaWxlICgx KTsKPiAgfQo+ICAKPiAgaW50IGZlbmNlX3NpZ25hbChzdHJ1Y3QgZmVuY2UgKmZlbmNlKTsKPiAt LSAKPiAyLjkuMwo+IAoKLS0gCkRhbmllbCBWZXR0ZXIKU29mdHdhcmUgRW5naW5lZXIsIEludGVs IENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xsLmNoCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVs QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=