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 chris@chris-wilson.co.uk Cc: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org 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 daniel.vetter@ffwll.ch

*/ -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