[linux.git] / lib / lockref.c

#include <linux/export.h>
#include <linux/lockref.h>
#include <linux/mutex.h>

#if USE_CMPXCHG_LOCKREF

/*
 * Allow weakly-ordered memory architectures to provide barrier-less
 * cmpxchg semantics for lockref updates.
 */
#ifndef cmpxchg64_relaxed
# define cmpxchg64_relaxed cmpxchg64
#endif

/*
 * Note that the "cmpxchg()" reloads the "old" value for the
 * failure case.
 */
#define CMPXCHG_LOOP(CODE, SUCCESS) do {					\
	struct lockref old;							\
	BUILD_BUG_ON(sizeof(old) != 8);						\
	old.lock_count = ACCESS_ONCE(lockref->lock_count);			\
	while (likely(arch_spin_value_unlocked(old.lock.rlock.raw_lock))) {  	\
		struct lockref new = old, prev = old;				\
		CODE								\
		old.lock_count = cmpxchg64_relaxed(&lockref->lock_count,	\
						   old.lock_count,		\
						   new.lock_count);		\
		if (likely(old.lock_count == prev.lock_count)) {		\
			SUCCESS;						\
		}								\
		arch_mutex_cpu_relax();						\
	}									\
} while (0)

#else

#define CMPXCHG_LOOP(CODE, SUCCESS) do { } while (0)

#endif

/**
 * lockref_get - Increments reference count unconditionally
 * @lockref: pointer to lockref structure
 *
 * This operation is only valid if you already hold a reference
 * to the object, so you know the count cannot be zero.
 */
void lockref_get(struct lockref *lockref)
{
	CMPXCHG_LOOP(
		new.count++;
	,
		return;
	);

	spin_lock(&lockref->lock);
	lockref->count++;
	spin_unlock(&lockref->lock);
}
EXPORT_SYMBOL(lockref_get);

/**
 * lockref_get_not_zero - Increments count unless the count is 0
 * @lockref: pointer to lockref structure
 * Return: 1 if count updated successfully or 0 if count was zero
 */
int lockref_get_not_zero(struct lockref *lockref)
{
	int retval;

	CMPXCHG_LOOP(
		new.count++;
		if (!old.count)
			return 0;
	,
		return 1;
	);

	spin_lock(&lockref->lock);
	retval = 0;
	if (lockref->count) {
		lockref->count++;
		retval = 1;
	}
	spin_unlock(&lockref->lock);
	return retval;
}
EXPORT_SYMBOL(lockref_get_not_zero);

/**
 * lockref_get_or_lock - Increments count unless the count is 0
 * @lockref: pointer to lockref structure
 * Return: 1 if count updated successfully or 0 if count was zero
 * and we got the lock instead.
 */
int lockref_get_or_lock(struct lockref *lockref)
{
	CMPXCHG_LOOP(
		new.count++;
		if (!old.count)
			break;
	,
		return 1;
	);

	spin_lock(&lockref->lock);
	if (!lockref->count)
		return 0;
	lockref->count++;
	spin_unlock(&lockref->lock);
	return 1;
}
EXPORT_SYMBOL(lockref_get_or_lock);

/**
 * lockref_put_or_lock - decrements count unless count <= 1 before decrement
 * @lockref: pointer to lockref structure
 * Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
 */
int lockref_put_or_lock(struct lockref *lockref)
{
	CMPXCHG_LOOP(
		new.count--;
		if (old.count <= 1)
			break;
	,
		return 1;
	);

	spin_lock(&lockref->lock);
	if (lockref->count <= 1)
		return 0;
	lockref->count--;
	spin_unlock(&lockref->lock);
	return 1;
}
EXPORT_SYMBOL(lockref_put_or_lock);

/**
 * lockref_mark_dead - mark lockref dead
 * @lockref: pointer to lockref structure
 */
void lockref_mark_dead(struct lockref *lockref)
{
	assert_spin_locked(&lockref->lock);
	lockref->count = -128;
}
EXPORT_SYMBOL(lockref_mark_dead);

/**
 * lockref_get_not_dead - Increments count unless the ref is dead
 * @lockref: pointer to lockref structure
 * Return: 1 if count updated successfully or 0 if lockref was dead
 */
int lockref_get_not_dead(struct lockref *lockref)
{
	int retval;

	CMPXCHG_LOOP(
		new.count++;
		if ((int)old.count < 0)
			return 0;
	,
		return 1;
	);

	spin_lock(&lockref->lock);
	retval = 0;
	if ((int) lockref->count >= 0) {
		lockref->count++;
		retval = 1;
	}
	spin_unlock(&lockref->lock);
	return retval;
}
EXPORT_SYMBOL(lockref_get_not_dead);
Commit	Line	Data
2f4f12e5 LT	1	#include <linux/export.h>
2f4f12e5 LT	2	#include <linux/lockref.h>
14058d20	3	#include <linux/mutex.h>
2f4f12e5	4
57f4257e	5	#if USE_CMPXCHG_LOCKREF
bc08b449	6
d2212b4d WD	7	/*
	8	* Allow weakly-ordered memory architectures to provide barrier-less
	9	* cmpxchg semantics for lockref updates.
	10	*/
	11	#ifndef cmpxchg64_relaxed
	12	# define cmpxchg64_relaxed cmpxchg64
	13	#endif
	14
bc08b449 LT	15	/*
	16	* Note that the "cmpxchg()" reloads the "old" value for the
	17	* failure case.
	18	*/
	19	#define CMPXCHG_LOOP(CODE, SUCCESS) do { \
	20	struct lockref old; \
	21	BUILD_BUG_ON(sizeof(old) != 8); \
	22	old.lock_count = ACCESS_ONCE(lockref->lock_count); \
	23	while (likely(arch_spin_value_unlocked(old.lock.rlock.raw_lock))) { \
	24	struct lockref new = old, prev = old; \
	25	CODE \
d2212b4d WD	26	old.lock_count = cmpxchg64_relaxed(&lockref->lock_count, \
	27	old.lock_count, \
	28	new.lock_count); \
bc08b449 LT	29	if (likely(old.lock_count == prev.lock_count)) { \
	30	SUCCESS; \
	31	} \
491f6f8e	32	arch_mutex_cpu_relax(); \
bc08b449 LT	33	} \
	34	} while (0)
	35
	36	#else
	37
	38	#define CMPXCHG_LOOP(CODE, SUCCESS) do { } while (0)
	39
	40	#endif
	41
2f4f12e5 LT	42	/**
2f4f12e5 LT	43	* lockref_get - Increments reference count unconditionally
44a0cf92	44	* @lockref: pointer to lockref structure
2f4f12e5 LT	45	*
	46	* This operation is only valid if you already hold a reference
	47	* to the object, so you know the count cannot be zero.
	48	*/
	49	void lockref_get(struct lockref *lockref)
	50	{
bc08b449 LT	51	CMPXCHG_LOOP(
	52	new.count++;
	53	,
	54	return;
	55	);
	56
2f4f12e5 LT	57	spin_lock(&lockref->lock);
	58	lockref->count++;
	59	spin_unlock(&lockref->lock);
	60	}
	61	EXPORT_SYMBOL(lockref_get);
	62
	63	/**
	64	* lockref_get_not_zero - Increments count unless the count is 0
44a0cf92	65	* @lockref: pointer to lockref structure
2f4f12e5 LT	66	* Return: 1 if count updated successfully or 0 if count was zero
	67	*/
	68	int lockref_get_not_zero(struct lockref *lockref)
	69	{
bc08b449 LT	70	int retval;
	71
	72	CMPXCHG_LOOP(
	73	new.count++;
	74	if (!old.count)
	75	return 0;
	76	,
	77	return 1;
	78	);
2f4f12e5 LT	79
2f4f12e5 LT	80	spin_lock(&lockref->lock);
bc08b449	81	retval = 0;
2f4f12e5 LT	82	if (lockref->count) {
	83	lockref->count++;
	84	retval = 1;
	85	}
	86	spin_unlock(&lockref->lock);
	87	return retval;
	88	}
	89	EXPORT_SYMBOL(lockref_get_not_zero);
	90
	91	/**
	92	* lockref_get_or_lock - Increments count unless the count is 0
44a0cf92	93	* @lockref: pointer to lockref structure
2f4f12e5 LT	94	* Return: 1 if count updated successfully or 0 if count was zero
	95	* and we got the lock instead.
	96	*/
	97	int lockref_get_or_lock(struct lockref *lockref)
	98	{
bc08b449 LT	99	CMPXCHG_LOOP(
	100	new.count++;
	101	if (!old.count)
	102	break;
	103	,
	104	return 1;
	105	);
	106
2f4f12e5 LT	107	spin_lock(&lockref->lock);
	108	if (!lockref->count)
	109	return 0;
	110	lockref->count++;
	111	spin_unlock(&lockref->lock);
	112	return 1;
	113	}
	114	EXPORT_SYMBOL(lockref_get_or_lock);
	115
	116	/**
	117	* lockref_put_or_lock - decrements count unless count <= 1 before decrement
44a0cf92	118	* @lockref: pointer to lockref structure
2f4f12e5 LT	119	* Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
	120	*/
	121	int lockref_put_or_lock(struct lockref *lockref)
	122	{
bc08b449 LT	123	CMPXCHG_LOOP(
	124	new.count--;
	125	if (old.count <= 1)
	126	break;
	127	,
	128	return 1;
	129	);
	130
2f4f12e5 LT	131	spin_lock(&lockref->lock);
	132	if (lockref->count <= 1)
	133	return 0;
	134	lockref->count--;
	135	spin_unlock(&lockref->lock);
	136	return 1;
	137	}
	138	EXPORT_SYMBOL(lockref_put_or_lock);
e7d33bb5 LT	139
	140	/**
	141	* lockref_mark_dead - mark lockref dead
	142	* @lockref: pointer to lockref structure
	143	*/
	144	void lockref_mark_dead(struct lockref *lockref)
	145	{
	146	assert_spin_locked(&lockref->lock);
	147	lockref->count = -128;
	148	}
e66cf161	149	EXPORT_SYMBOL(lockref_mark_dead);
e7d33bb5 LT	150
	151	/**
	152	* lockref_get_not_dead - Increments count unless the ref is dead
	153	* @lockref: pointer to lockref structure
	154	* Return: 1 if count updated successfully or 0 if lockref was dead
	155	*/
	156	int lockref_get_not_dead(struct lockref *lockref)
	157	{
	158	int retval;
	159
	160	CMPXCHG_LOOP(
	161	new.count++;
	162	if ((int)old.count < 0)
	163	return 0;
	164	,
	165	return 1;
	166	);
	167
	168	spin_lock(&lockref->lock);
	169	retval = 0;
	170	if ((int) lockref->count >= 0) {
	171	lockref->count++;
	172	retval = 1;
	173	}
	174	spin_unlock(&lockref->lock);
	175	return retval;
	176	}
	177	EXPORT_SYMBOL(lockref_get_not_dead);