drivers/dma-buf/reservation.c - kernel/common - Git at Google

 /*
  * Copyright (C) 2012-2014 Canonical Ltd (Maarten Lankhorst)
  *
  * Based on bo.c which bears the following copyright notice,
  * but is dual licensed:
  *
  * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  **************************************************************************/
 /*
  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
  */

 #include <linux/reservation.h>
 #include <linux/export.h>

 /**
  * DOC: Reservation Object Overview
  *
  * The reservation object provides a mechanism to manage shared and
  * exclusive fences associated with a buffer.  A reservation object
  * can have attached one exclusive fence (normally associated with
  * write operations) or N shared fences (read operations).  The RCU
  * mechanism is used to protect read access to fences from locked
  * write-side updates.
  */

 DEFINE_WW_CLASS(reservation_ww_class);
 EXPORT_SYMBOL(reservation_ww_class);

 struct lock_class_key reservation_seqcount_class;
 EXPORT_SYMBOL(reservation_seqcount_class);

 const char reservation_seqcount_string[] = "reservation_seqcount";
 EXPORT_SYMBOL(reservation_seqcount_string);

 /**
  * reservation_object_reserve_shared - Reserve space to add a shared
  * fence to a reservation_object.
  * @obj: reservation object
  *
  * Should be called before reservation_object_add_shared_fence().  Must
  * be called with obj->lock held.
  *
  * RETURNS
  * Zero for success, or -errno
  */
 int reservation_object_reserve_shared(struct reservation_object *obj)
 {
 	struct reservation_object_list *fobj, *old;
 	u32 max;

 	old = reservation_object_get_list(obj);

 	if (old && old->shared_max) {
 		if (old->shared_count < old->shared_max) {
 			/* perform an in-place update */
 			kfree(obj->staged);
 			obj->staged = NULL;
 			return 0;
 		} else
 			max = old->shared_max * 2;
 	} else
 		max = 4;

 	/*
 	 * resize obj->staged or allocate if it doesn't exist,
 	 * noop if already correct size
 	 */
 	fobj = krealloc(obj->staged, offsetof(typeof(*fobj), shared[max]),
 			GFP_KERNEL);
 	if (!fobj)
 		return -ENOMEM;

 	obj->staged = fobj;
 	fobj->shared_max = max;
 	return 0;
 }
 EXPORT_SYMBOL(reservation_object_reserve_shared);

 static void
 reservation_object_add_shared_inplace(struct reservation_object *obj,
 				      struct reservation_object_list *fobj,
 				      struct fence *fence)
 {
 	u32 i;

 	fence_get(fence);

 	preempt_disable();
 	write_seqcount_begin(&obj->seq);

 	for (i = 0; i < fobj->shared_count; ++i) {
 		struct fence *old_fence;

 		old_fence = rcu_dereference_protected(fobj->shared[i],
 						reservation_object_held(obj));

 		if (old_fence->context == fence->context) {
 			/* memory barrier is added by write_seqcount_begin */
 			RCU_INIT_POINTER(fobj->shared[i], fence);
 			write_seqcount_end(&obj->seq);
 			preempt_enable();

 			fence_put(old_fence);
 			return;
 		}
 	}

 	/*
 	 * memory barrier is added by write_seqcount_begin,
 	 * fobj->shared_count is protected by this lock too
 	 */
 	RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
 	fobj->shared_count++;

 	write_seqcount_end(&obj->seq);
 	preempt_enable();
 }

 static void
 reservation_object_add_shared_replace(struct reservation_object *obj,
 				      struct reservation_object_list *old,
 				      struct reservation_object_list *fobj,
 				      struct fence *fence)
 {
 	unsigned i;
 	struct fence *old_fence = NULL;

 	fence_get(fence);

 	if (!old) {
 		RCU_INIT_POINTER(fobj->shared[0], fence);
 		fobj->shared_count = 1;
 		goto done;
 	}

 	/*
 	 * no need to bump fence refcounts, rcu_read access
 	 * requires the use of kref_get_unless_zero, and the
 	 * references from the old struct are carried over to
 	 * the new.
 	 */
 	fobj->shared_count = old->shared_count;

 	for (i = 0; i < old->shared_count; ++i) {
 		struct fence *check;

 		check = rcu_dereference_protected(old->shared[i],
 						reservation_object_held(obj));

 		if (!old_fence && check->context == fence->context) {
 			old_fence = check;
 			RCU_INIT_POINTER(fobj->shared[i], fence);
 		} else
 			RCU_INIT_POINTER(fobj->shared[i], check);
 	}
 	if (!old_fence) {
 		RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
 		fobj->shared_count++;
 	}

 done:
 	preempt_disable();
 	write_seqcount_begin(&obj->seq);
 	/*
 	 * RCU_INIT_POINTER can be used here,
 	 * seqcount provides the necessary barriers
 	 */
 	RCU_INIT_POINTER(obj->fence, fobj);
 	write_seqcount_end(&obj->seq);
 	preempt_enable();

 	if (old)
 		kfree_rcu(old, rcu);

 	if (old_fence)
 		fence_put(old_fence);
 }

 /**
  * reservation_object_add_shared_fence - Add a fence to a shared slot
  * @obj: the reservation object
  * @fence: the shared fence to add
  *
  * Add a fence to a shared slot, obj->lock must be held, and
  * reservation_object_reserve_shared() has been called.
  */
 void reservation_object_add_shared_fence(struct reservation_object *obj,
 					 struct fence *fence)
 {
 	struct reservation_object_list *old, *fobj = obj->staged;

 	old = reservation_object_get_list(obj);
 	obj->staged = NULL;

 	if (!fobj) {
 		BUG_ON(old->shared_count >= old->shared_max);
 		reservation_object_add_shared_inplace(obj, old, fence);
 	} else
 		reservation_object_add_shared_replace(obj, old, fobj, fence);
 }
 EXPORT_SYMBOL(reservation_object_add_shared_fence);

 /**
  * reservation_object_add_excl_fence - Add an exclusive fence.
  * @obj: the reservation object
  * @fence: the shared fence to add
  *
  * Add a fence to the exclusive slot.  The obj->lock must be held.
  */
 void reservation_object_add_excl_fence(struct reservation_object *obj,
 				       struct fence *fence)
 {
 	struct fence *old_fence = reservation_object_get_excl(obj);
 	struct reservation_object_list *old;
 	u32 i = 0;

 	old = reservation_object_get_list(obj);
 	if (old)
 		i = old->shared_count;

 	if (fence)
 		fence_get(fence);

 	preempt_disable();
 	write_seqcount_begin(&obj->seq);
 	/* write_seqcount_begin provides the necessary memory barrier */
 	RCU_INIT_POINTER(obj->fence_excl, fence);
 	if (old)
 		old->shared_count = 0;
 	write_seqcount_end(&obj->seq);
 	preempt_enable();

 	/* inplace update, no shared fences */
 	while (i--)
 		fence_put(rcu_dereference_protected(old->shared[i],
 						reservation_object_held(obj)));

 	if (old_fence)
 		fence_put(old_fence);
 }
 EXPORT_SYMBOL(reservation_object_add_excl_fence);

 /**
  * reservation_object_get_fences_rcu - Get an object's shared and exclusive
  * fences without update side lock held
  * @obj: the reservation object
  * @pfence_excl: the returned exclusive fence (or NULL)
  * @pshared_count: the number of shared fences returned
  * @pshared: the array of shared fence ptrs returned (array is krealloc'd to
  * the required size, and must be freed by caller)
  *
  * RETURNS
  * Zero or -errno
  */
 int reservation_object_get_fences_rcu(struct reservation_object *obj,
 				      struct fence **pfence_excl,
 				      unsigned *pshared_count,
 				      struct fence ***pshared)
 {
 	unsigned shared_count = 0;
 	unsigned retry = 1;
 	struct fence **shared = NULL, *fence_excl = NULL;
 	int ret = 0;

 	while (retry) {
 		struct reservation_object_list *fobj;
 		unsigned seq;

 		seq = read_seqcount_begin(&obj->seq);

 		rcu_read_lock();

 		fobj = rcu_dereference(obj->fence);
 		if (fobj) {
 			struct fence **nshared;
 			size_t sz = sizeof(*shared) * fobj->shared_max;

 			nshared = krealloc(shared, sz,
 					   GFP_NOWAIT | __GFP_NOWARN);
 			if (!nshared) {
 				rcu_read_unlock();
 				nshared = krealloc(shared, sz, GFP_KERNEL);
 				if (nshared) {
 					shared = nshared;
 					continue;
 				}

 				ret = -ENOMEM;
 				shared_count = 0;
 				break;
 			}
 			shared = nshared;
 			memcpy(shared, fobj->shared, sz);
 			shared_count = fobj->shared_count;
 		} else
 			shared_count = 0;
 		fence_excl = rcu_dereference(obj->fence_excl);

 		retry = read_seqcount_retry(&obj->seq, seq);
 		if (retry)
 			goto unlock;

 		if (!fence_excl || fence_get_rcu(fence_excl)) {
 			unsigned i;

 			for (i = 0; i < shared_count; ++i) {
 				if (fence_get_rcu(shared[i]))
 					continue;

 				/* uh oh, refcount failed, abort and retry */
 				while (i--)
 					fence_put(shared[i]);

 				if (fence_excl) {
 					fence_put(fence_excl);
 					fence_excl = NULL;
 				}

 				retry = 1;
 				break;
 			}
 		} else
 			retry = 1;

 unlock:
 		rcu_read_unlock();
 	}
 	*pshared_count = shared_count;
 	if (shared_count)
 		*pshared = shared;
 	else {
 		*pshared = NULL;
 		kfree(shared);
 	}
 	*pfence_excl = fence_excl;

 	return ret;
 }
 EXPORT_SYMBOL_GPL(reservation_object_get_fences_rcu);

 /**
  * reservation_object_wait_timeout_rcu - Wait on reservation's objects
  * shared and/or exclusive fences.
  * @obj: the reservation object
  * @wait_all: if true, wait on all fences, else wait on just exclusive fence
  * @intr: if true, do interruptible wait
  * @timeout: timeout value in jiffies or zero to return immediately
  *
  * RETURNS
  * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or
  * greater than zer on success.
  */
 long reservation_object_wait_timeout_rcu(struct reservation_object *obj,
 					 bool wait_all, bool intr,
 					 unsigned long timeout)
 {
 	struct fence *fence;
 	unsigned seq, shared_count, i = 0;
 	long ret = timeout;

 	if (!timeout)
 		return reservation_object_test_signaled_rcu(obj, wait_all);

 retry:
 	fence = NULL;
 	shared_count = 0;
 	seq = read_seqcount_begin(&obj->seq);
 	rcu_read_lock();

 	if (wait_all) {
 		struct reservation_object_list *fobj =
 						rcu_dereference(obj->fence);

 		if (fobj)
 			shared_count = fobj->shared_count;

 		if (read_seqcount_retry(&obj->seq, seq))
 			goto unlock_retry;

 		for (i = 0; i < shared_count; ++i) {
 			struct fence *lfence = rcu_dereference(fobj->shared[i]);

 			if (test_bit(FENCE_FLAG_SIGNALED_BIT, &lfence->flags))
 				continue;

 			if (!fence_get_rcu(lfence))
 				goto unlock_retry;

 			if (fence_is_signaled(lfence)) {
 				fence_put(lfence);
 				continue;
 			}

 			fence = lfence;
 			break;
 		}
 	}

 	if (!shared_count) {
 		struct fence *fence_excl = rcu_dereference(obj->fence_excl);

 		if (read_seqcount_retry(&obj->seq, seq))
 			goto unlock_retry;

 		if (fence_excl &&
 		    !test_bit(FENCE_FLAG_SIGNALED_BIT, &fence_excl->flags)) {
 			if (!fence_get_rcu(fence_excl))
 				goto unlock_retry;

 			if (fence_is_signaled(fence_excl))
 				fence_put(fence_excl);
 			else
 				fence = fence_excl;
 		}
 	}

 	rcu_read_unlock();
 	if (fence) {
 		ret = fence_wait_timeout(fence, intr, ret);
 		fence_put(fence);
 		if (ret > 0 && wait_all && (i + 1 < shared_count))
 			goto retry;
 	}
 	return ret;

 unlock_retry:
 	rcu_read_unlock();
 	goto retry;
 }
 EXPORT_SYMBOL_GPL(reservation_object_wait_timeout_rcu);


 static inline int
 reservation_object_test_signaled_single(struct fence *passed_fence)
 {
 	struct fence *fence, *lfence = passed_fence;
 	int ret = 1;

 	if (!test_bit(FENCE_FLAG_SIGNALED_BIT, &lfence->flags)) {
 		fence = fence_get_rcu(lfence);
 		if (!fence)
 			return -1;

 		ret = !!fence_is_signaled(fence);
 		fence_put(fence);
 	}
 	return ret;
 }

 /**
  * reservation_object_test_signaled_rcu - Test if a reservation object's
  * fences have been signaled.
  * @obj: the reservation object
  * @test_all: if true, test all fences, otherwise only test the exclusive
  * fence
  *
  * RETURNS
  * true if all fences signaled, else false
  */
 bool reservation_object_test_signaled_rcu(struct reservation_object *obj,
 					  bool test_all)
 {
 	unsigned seq, shared_count;
 	int ret = true;

 retry:
 	shared_count = 0;
 	seq = read_seqcount_begin(&obj->seq);
 	rcu_read_lock();

 	if (test_all) {
 		unsigned i;

 		struct reservation_object_list *fobj =
 						rcu_dereference(obj->fence);

 		if (fobj)
 			shared_count = fobj->shared_count;

 		if (read_seqcount_retry(&obj->seq, seq))
 			goto unlock_retry;

 		for (i = 0; i < shared_count; ++i) {
 			struct fence *fence = rcu_dereference(fobj->shared[i]);

 			ret = reservation_object_test_signaled_single(fence);
 			if (ret < 0)
 				goto unlock_retry;
 			else if (!ret)
 				break;
 		}

 		/*
 		 * There could be a read_seqcount_retry here, but nothing cares
 		 * about whether it's the old or newer fence pointers that are
 		 * signaled. That race could still have happened after checking
 		 * read_seqcount_retry. If you care, use ww_mutex_lock.
 		 */
 	}

 	if (!shared_count) {
 		struct fence *fence_excl = rcu_dereference(obj->fence_excl);

 		if (read_seqcount_retry(&obj->seq, seq))
 			goto unlock_retry;

 		if (fence_excl) {
 			ret = reservation_object_test_signaled_single(
 								fence_excl);
 			if (ret < 0)
 				goto unlock_retry;
 		}
 	}

 	rcu_read_unlock();
 	return ret;

 unlock_retry:
 	rcu_read_unlock();
 	goto retry;
 }
 EXPORT_SYMBOL_GPL(reservation_object_test_signaled_rcu);
	/*
	* Copyright (C) 2012-2014 Canonical Ltd (Maarten Lankhorst)
	*
	* Based on bo.c which bears the following copyright notice,
	* but is dual licensed:
	*
	* Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
	* All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sub license, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice (including the
	* next paragraph) shall be included in all copies or substantial portions
	* of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	* USE OR OTHER DEALINGS IN THE SOFTWARE.
	*
	**************************************************************************/
	/*
	* Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
	*/

	#include <linux/reservation.h>
	#include <linux/export.h>

	/**
	* DOC: Reservation Object Overview
	*
	* The reservation object provides a mechanism to manage shared and
	* exclusive fences associated with a buffer. A reservation object
	* can have attached one exclusive fence (normally associated with
	* write operations) or N shared fences (read operations). The RCU
	* mechanism is used to protect read access to fences from locked
	* write-side updates.
	*/

	DEFINE_WW_CLASS(reservation_ww_class);
	EXPORT_SYMBOL(reservation_ww_class);

	struct lock_class_key reservation_seqcount_class;
	EXPORT_SYMBOL(reservation_seqcount_class);

	const char reservation_seqcount_string[] = "reservation_seqcount";
	EXPORT_SYMBOL(reservation_seqcount_string);

	/**
	* reservation_object_reserve_shared - Reserve space to add a shared
	* fence to a reservation_object.
	* @obj: reservation object
	*
	* Should be called before reservation_object_add_shared_fence(). Must
	* be called with obj->lock held.
	*
	* RETURNS
	* Zero for success, or -errno
	*/
	int reservation_object_reserve_shared(struct reservation_object *obj)
	{
	struct reservation_object_list fobj, old;
	u32 max;

	old = reservation_object_get_list(obj);

	if (old && old->shared_max) {
	if (old->shared_count < old->shared_max) {
	/* perform an in-place update */
	kfree(obj->staged);
	obj->staged = NULL;
	return 0;
	} else
	max = old->shared_max * 2;
	} else
	max = 4;

	/*
	* resize obj->staged or allocate if it doesn't exist,
	* noop if already correct size
	*/
	fobj = krealloc(obj->staged, offsetof(typeof(*fobj), shared[max]),
	GFP_KERNEL);
	if (!fobj)
	return -ENOMEM;

	obj->staged = fobj;
	fobj->shared_max = max;
	return 0;
	}
	EXPORT_SYMBOL(reservation_object_reserve_shared);

	static void
	reservation_object_add_shared_inplace(struct reservation_object *obj,
	struct reservation_object_list *fobj,
	struct fence *fence)
	{
	u32 i;

	fence_get(fence);

	preempt_disable();
	write_seqcount_begin(&obj->seq);

	for (i = 0; i < fobj->shared_count; ++i) {
	struct fence *old_fence;

	old_fence = rcu_dereference_protected(fobj->shared[i],
	reservation_object_held(obj));

	if (old_fence->context == fence->context) {
	/* memory barrier is added by write_seqcount_begin */
	RCU_INIT_POINTER(fobj->shared[i], fence);
	write_seqcount_end(&obj->seq);
	preempt_enable();

	fence_put(old_fence);
	return;
	}
	}

	/*
	* memory barrier is added by write_seqcount_begin,
	* fobj->shared_count is protected by this lock too
	*/
	RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
	fobj->shared_count++;

	write_seqcount_end(&obj->seq);
	preempt_enable();
	}

	static void
	reservation_object_add_shared_replace(struct reservation_object *obj,
	struct reservation_object_list *old,
	struct reservation_object_list *fobj,
	struct fence *fence)
	{
	unsigned i;
	struct fence *old_fence = NULL;

	fence_get(fence);

	if (!old) {
	RCU_INIT_POINTER(fobj->shared[0], fence);
	fobj->shared_count = 1;
	goto done;
	}

	/*
	* no need to bump fence refcounts, rcu_read access
	* requires the use of kref_get_unless_zero, and the
	* references from the old struct are carried over to
	* the new.
	*/
	fobj->shared_count = old->shared_count;

	for (i = 0; i < old->shared_count; ++i) {
	struct fence *check;

	check = rcu_dereference_protected(old->shared[i],
	reservation_object_held(obj));

	if (!old_fence && check->context == fence->context) {
	old_fence = check;
	RCU_INIT_POINTER(fobj->shared[i], fence);
	} else
	RCU_INIT_POINTER(fobj->shared[i], check);
	}
	if (!old_fence) {
	RCU_INIT_POINTER(fobj->shared[fobj->shared_count], fence);
	fobj->shared_count++;
	}

	done:
	preempt_disable();
	write_seqcount_begin(&obj->seq);
	/*
	* RCU_INIT_POINTER can be used here,
	* seqcount provides the necessary barriers
	*/
	RCU_INIT_POINTER(obj->fence, fobj);
	write_seqcount_end(&obj->seq);
	preempt_enable();

	if (old)
	kfree_rcu(old, rcu);

	if (old_fence)
	fence_put(old_fence);
	}

	/**
	* reservation_object_add_shared_fence - Add a fence to a shared slot
	* @obj: the reservation object
	* @fence: the shared fence to add
	*
	* Add a fence to a shared slot, obj->lock must be held, and
	* reservation_object_reserve_shared() has been called.
	*/
	void reservation_object_add_shared_fence(struct reservation_object *obj,
	struct fence *fence)
	{
	struct reservation_object_list old, fobj = obj->staged;

	old = reservation_object_get_list(obj);
	obj->staged = NULL;

	if (!fobj) {
	BUG_ON(old->shared_count >= old->shared_max);
	reservation_object_add_shared_inplace(obj, old, fence);
	} else
	reservation_object_add_shared_replace(obj, old, fobj, fence);
	}
	EXPORT_SYMBOL(reservation_object_add_shared_fence);

	/**
	* reservation_object_add_excl_fence - Add an exclusive fence.
	* @obj: the reservation object
	* @fence: the shared fence to add
	*
	* Add a fence to the exclusive slot. The obj->lock must be held.
	*/
	void reservation_object_add_excl_fence(struct reservation_object *obj,
	struct fence *fence)
	{
	struct fence *old_fence = reservation_object_get_excl(obj);
	struct reservation_object_list *old;
	u32 i = 0;

	old = reservation_object_get_list(obj);
	if (old)
	i = old->shared_count;

	if (fence)
	fence_get(fence);

	preempt_disable();
	write_seqcount_begin(&obj->seq);
	/* write_seqcount_begin provides the necessary memory barrier */
	RCU_INIT_POINTER(obj->fence_excl, fence);
	if (old)
	old->shared_count = 0;
	write_seqcount_end(&obj->seq);
	preempt_enable();

	/* inplace update, no shared fences */
	while (i--)
	fence_put(rcu_dereference_protected(old->shared[i],
	reservation_object_held(obj)));

	if (old_fence)
	fence_put(old_fence);
	}
	EXPORT_SYMBOL(reservation_object_add_excl_fence);

	/**
	* reservation_object_get_fences_rcu - Get an object's shared and exclusive
	* fences without update side lock held
	* @obj: the reservation object
	* @pfence_excl: the returned exclusive fence (or NULL)
	* @pshared_count: the number of shared fences returned
	* @pshared: the array of shared fence ptrs returned (array is krealloc'd to
	* the required size, and must be freed by caller)
	*
	* RETURNS
	* Zero or -errno
	*/
	int reservation_object_get_fences_rcu(struct reservation_object *obj,
	struct fence **pfence_excl,
	unsigned *pshared_count,
	struct fence ***pshared)
	{
	unsigned shared_count = 0;
	unsigned retry = 1;
	struct fence *shared = NULL, fence_excl = NULL;
	int ret = 0;

	while (retry) {
	struct reservation_object_list *fobj;
	unsigned seq;

	seq = read_seqcount_begin(&obj->seq);

	rcu_read_lock();

	fobj = rcu_dereference(obj->fence);
	if (fobj) {
	struct fence **nshared;
	size_t sz = sizeof(shared) fobj->shared_max;

	nshared = krealloc(shared, sz,
	GFP_NOWAIT \| __GFP_NOWARN);
	if (!nshared) {
	rcu_read_unlock();
	nshared = krealloc(shared, sz, GFP_KERNEL);
	if (nshared) {
	shared = nshared;
	continue;
	}

	ret = -ENOMEM;
	shared_count = 0;
	break;
	}
	shared = nshared;
	memcpy(shared, fobj->shared, sz);
	shared_count = fobj->shared_count;
	} else
	shared_count = 0;
	fence_excl = rcu_dereference(obj->fence_excl);

	retry = read_seqcount_retry(&obj->seq, seq);
	if (retry)
	goto unlock;

	if (!fence_excl \|\| fence_get_rcu(fence_excl)) {
	unsigned i;

	for (i = 0; i < shared_count; ++i) {
	if (fence_get_rcu(shared[i]))
	continue;

	/* uh oh, refcount failed, abort and retry */
	while (i--)
	fence_put(shared[i]);

	if (fence_excl) {
	fence_put(fence_excl);
	fence_excl = NULL;
	}

	retry = 1;
	break;
	}
	} else
	retry = 1;

	unlock:
	rcu_read_unlock();
	}
	*pshared_count = shared_count;
	if (shared_count)
	*pshared = shared;
	else {
	*pshared = NULL;
	kfree(shared);
	}
	*pfence_excl = fence_excl;

	return ret;
	}
	EXPORT_SYMBOL_GPL(reservation_object_get_fences_rcu);

	/**
	* reservation_object_wait_timeout_rcu - Wait on reservation's objects
	* shared and/or exclusive fences.
	* @obj: the reservation object
	* @wait_all: if true, wait on all fences, else wait on just exclusive fence
	* @intr: if true, do interruptible wait
	* @timeout: timeout value in jiffies or zero to return immediately
	*
	* RETURNS
	* Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or
	* greater than zer on success.
	*/
	long reservation_object_wait_timeout_rcu(struct reservation_object *obj,
	bool wait_all, bool intr,
	unsigned long timeout)
	{
	struct fence *fence;
	unsigned seq, shared_count, i = 0;
	long ret = timeout;

	if (!timeout)
	return reservation_object_test_signaled_rcu(obj, wait_all);

	retry:
	fence = NULL;
	shared_count = 0;
	seq = read_seqcount_begin(&obj->seq);
	rcu_read_lock();

	if (wait_all) {
	struct reservation_object_list *fobj =
	rcu_dereference(obj->fence);

	if (fobj)
	shared_count = fobj->shared_count;

	if (read_seqcount_retry(&obj->seq, seq))
	goto unlock_retry;

	for (i = 0; i < shared_count; ++i) {
	struct fence *lfence = rcu_dereference(fobj->shared[i]);

	if (test_bit(FENCE_FLAG_SIGNALED_BIT, &lfence->flags))
	continue;

	if (!fence_get_rcu(lfence))
	goto unlock_retry;

	if (fence_is_signaled(lfence)) {
	fence_put(lfence);
	continue;
	}

	fence = lfence;
	break;
	}
	}

	if (!shared_count) {
	struct fence *fence_excl = rcu_dereference(obj->fence_excl);

	if (read_seqcount_retry(&obj->seq, seq))
	goto unlock_retry;

	if (fence_excl &&
	!test_bit(FENCE_FLAG_SIGNALED_BIT, &fence_excl->flags)) {
	if (!fence_get_rcu(fence_excl))
	goto unlock_retry;

	if (fence_is_signaled(fence_excl))
	fence_put(fence_excl);
	else
	fence = fence_excl;
	}
	}

	rcu_read_unlock();
	if (fence) {
	ret = fence_wait_timeout(fence, intr, ret);
	fence_put(fence);
	if (ret > 0 && wait_all && (i + 1 < shared_count))
	goto retry;
	}
	return ret;

	unlock_retry:
	rcu_read_unlock();
	goto retry;
	}
	EXPORT_SYMBOL_GPL(reservation_object_wait_timeout_rcu);


	static inline int
	reservation_object_test_signaled_single(struct fence *passed_fence)
	{
	struct fence fence, lfence = passed_fence;
	int ret = 1;

	if (!test_bit(FENCE_FLAG_SIGNALED_BIT, &lfence->flags)) {
	fence = fence_get_rcu(lfence);
	if (!fence)
	return -1;

	ret = !!fence_is_signaled(fence);
	fence_put(fence);
	}
	return ret;
	}

	/**
	* reservation_object_test_signaled_rcu - Test if a reservation object's
	* fences have been signaled.
	* @obj: the reservation object
	* @test_all: if true, test all fences, otherwise only test the exclusive
	* fence
	*
	* RETURNS
	* true if all fences signaled, else false
	*/
	bool reservation_object_test_signaled_rcu(struct reservation_object *obj,
	bool test_all)
	{
	unsigned seq, shared_count;
	int ret = true;

	retry:
	shared_count = 0;
	seq = read_seqcount_begin(&obj->seq);
	rcu_read_lock();

	if (test_all) {
	unsigned i;

	struct reservation_object_list *fobj =
	rcu_dereference(obj->fence);

	if (fobj)
	shared_count = fobj->shared_count;

	if (read_seqcount_retry(&obj->seq, seq))
	goto unlock_retry;

	for (i = 0; i < shared_count; ++i) {
	struct fence *fence = rcu_dereference(fobj->shared[i]);

	ret = reservation_object_test_signaled_single(fence);
	if (ret < 0)
	goto unlock_retry;
	else if (!ret)
	break;
	}

	/*
	* There could be a read_seqcount_retry here, but nothing cares
	* about whether it's the old or newer fence pointers that are
	* signaled. That race could still have happened after checking
	* read_seqcount_retry. If you care, use ww_mutex_lock.
	*/
	}

	if (!shared_count) {
	struct fence *fence_excl = rcu_dereference(obj->fence_excl);

	if (read_seqcount_retry(&obj->seq, seq))
	goto unlock_retry;

	if (fence_excl) {
	ret = reservation_object_test_signaled_single(
	fence_excl);
	if (ret < 0)
	goto unlock_retry;
	}
	}

	rcu_read_unlock();
	return ret;

	unlock_retry:
	rcu_read_unlock();
	goto retry;
	}
	EXPORT_SYMBOL_GPL(reservation_object_test_signaled_rcu);