Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5b43f97f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'locking-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull locking fixes from Ingo Molnar:
 "Two rtmutex race fixes (which miraculously never triggered, that we
  know of), plus two lockdep printk formatting regression fixes"

* 'locking-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  lockdep: Fix report formatting
  locking/rtmutex: Use READ_ONCE() in rt_mutex_owner()
  locking/rtmutex: Prevent dequeue vs. unlock race
  locking/selftest: Fix output since KERN_CONT changes
parents 407cf05d f943fe0f

kernel/locking/lockdep.c

+57 −54
Original line number Diff line number Diff line
@@ -506,13 +506,13 @@ static void __print_lock_name(struct lock_class *class) 
	name = class->name;

	if (!name) {

		name = __get_key_name(class->key, str);

		printk("%s", name);

		printk(KERN_CONT "%s", name);

	} else {

		printk("%s", name);

		printk(KERN_CONT "%s", name);

		if (class->name_version > 1)

			printk("#%d", class->name_version);

			printk(KERN_CONT "#%d", class->name_version);

		if (class->subclass)

			printk("/%d", class->subclass);

			printk(KERN_CONT "/%d", class->subclass);

	}

}
@@ -522,9 +522,9 @@ static void print_lock_name(struct lock_class *class) 


	get_usage_chars(class, usage);



	printk(" (");

	printk(KERN_CONT " (");

	__print_lock_name(class);

	printk("){%s}", usage);

	printk(KERN_CONT "){%s}", usage);

}



static void print_lockdep_cache(struct lockdep_map *lock)
@@ -536,7 +536,7 @@ static void print_lockdep_cache(struct lockdep_map *lock) 
	if (!name)

		name = __get_key_name(lock->key->subkeys, str);



	printk("%s", name);

	printk(KERN_CONT "%s", name);

}



static void print_lock(struct held_lock *hlock)
@@ -551,13 +551,13 @@ static void print_lock(struct held_lock *hlock) 
	barrier();



	if (!class_idx || (class_idx - 1) >= MAX_LOCKDEP_KEYS) {

		printk("<RELEASED>\n");

		printk(KERN_CONT "<RELEASED>\n");

		return;

	}



	print_lock_name(lock_classes + class_idx - 1);

	printk(", at: ");

	print_ip_sym(hlock->acquire_ip);

	printk(KERN_CONT ", at: [<%p>] %pS\n",

		(void *)hlock->acquire_ip, (void *)hlock->acquire_ip);

}



static void lockdep_print_held_locks(struct task_struct *curr)
@@ -792,8 +792,8 @@ register_lock_class(struct lockdep_map *lock, unsigned int subclass, int force) 


		printk("\nnew class %p: %s", class->key, class->name);

		if (class->name_version > 1)

			printk("#%d", class->name_version);

		printk("\n");

			printk(KERN_CONT "#%d", class->name_version);

		printk(KERN_CONT "\n");

		dump_stack();



		if (!graph_lock()) {
@@ -1071,7 +1071,7 @@ print_circular_bug_entry(struct lock_list *target, int depth) 
		return 0;

	printk("\n-> #%u", depth);

	print_lock_name(target->class);

	printk(":\n");

	printk(KERN_CONT ":\n");

	print_stack_trace(&target->trace, 6);



	return 0;
@@ -1102,11 +1102,11 @@ print_circular_lock_scenario(struct held_lock *src, 
	if (parent != source) {

		printk("Chain exists of:\n  ");

		__print_lock_name(source);

		printk(" --> ");

		printk(KERN_CONT " --> ");

		__print_lock_name(parent);

		printk(" --> ");

		printk(KERN_CONT " --> ");

		__print_lock_name(target);

		printk("\n\n");

		printk(KERN_CONT "\n\n");

	}



	printk(" Possible unsafe locking scenario:\n\n");
@@ -1114,16 +1114,16 @@ print_circular_lock_scenario(struct held_lock *src, 
	printk("       ----                    ----\n");

	printk("  lock(");

	__print_lock_name(target);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("                               lock(");

	__print_lock_name(parent);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("                               lock(");

	__print_lock_name(target);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("  lock(");

	__print_lock_name(source);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("\n *** DEADLOCK ***\n\n");

}
@@ -1359,22 +1359,22 @@ static void print_lock_class_header(struct lock_class *class, int depth) 


	printk("%*s->", depth, "");

	print_lock_name(class);

	printk(" ops: %lu", class->ops);

	printk(" {\n");

	printk(KERN_CONT " ops: %lu", class->ops);

	printk(KERN_CONT " {\n");



	for (bit = 0; bit < LOCK_USAGE_STATES; bit++) {

		if (class->usage_mask & (1 << bit)) {

			int len = depth;



			len += printk("%*s   %s", depth, "", usage_str[bit]);

			len += printk(" at:\n");

			len += printk(KERN_CONT " at:\n");

			print_stack_trace(class->usage_traces + bit, len);

		}

	}

	printk("%*s }\n", depth, "");



	printk("%*s ... key      at: ",depth,"");

	print_ip_sym((unsigned long)class->key);

	printk("%*s ... key      at: [<%p>] %pS\n",

		depth, "", class->key, class->key);

}



/*
@@ -1437,11 +1437,11 @@ print_irq_lock_scenario(struct lock_list *safe_entry, 
	if (middle_class != unsafe_class) {

		printk("Chain exists of:\n  ");

		__print_lock_name(safe_class);

		printk(" --> ");

		printk(KERN_CONT " --> ");

		__print_lock_name(middle_class);

		printk(" --> ");

		printk(KERN_CONT " --> ");

		__print_lock_name(unsafe_class);

		printk("\n\n");

		printk(KERN_CONT "\n\n");

	}



	printk(" Possible interrupt unsafe locking scenario:\n\n");
@@ -1449,18 +1449,18 @@ print_irq_lock_scenario(struct lock_list *safe_entry, 
	printk("       ----                    ----\n");

	printk("  lock(");

	__print_lock_name(unsafe_class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("                               local_irq_disable();\n");

	printk("                               lock(");

	__print_lock_name(safe_class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("                               lock(");

	__print_lock_name(middle_class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("  <Interrupt>\n");

	printk("    lock(");

	__print_lock_name(safe_class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("\n *** DEADLOCK ***\n\n");

}
@@ -1497,9 +1497,9 @@ print_bad_irq_dependency(struct task_struct *curr, 
	print_lock(prev);

	printk("which would create a new lock dependency:\n");

	print_lock_name(hlock_class(prev));

	printk(" ->");

	printk(KERN_CONT " ->");

	print_lock_name(hlock_class(next));

	printk("\n");

	printk(KERN_CONT "\n");



	printk("\nbut this new dependency connects a %s-irq-safe lock:\n",

		irqclass);
@@ -1521,8 +1521,7 @@ print_bad_irq_dependency(struct task_struct *curr, 


	lockdep_print_held_locks(curr);



	printk("\nthe dependencies between %s-irq-safe lock", irqclass);

	printk(" and the holding lock:\n");

	printk("\nthe dependencies between %s-irq-safe lock and the holding lock:\n", irqclass);

	if (!save_trace(&prev_root->trace))

		return 0;

	print_shortest_lock_dependencies(backwards_entry, prev_root);
@@ -1694,10 +1693,10 @@ print_deadlock_scenario(struct held_lock *nxt, 
	printk("       ----\n");

	printk("  lock(");

	__print_lock_name(prev);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("  lock(");

	__print_lock_name(next);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("\n *** DEADLOCK ***\n\n");

	printk(" May be due to missing lock nesting notation\n\n");

}
@@ -1891,9 +1890,9 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, 
		graph_unlock();

		printk("\n new dependency: ");

		print_lock_name(hlock_class(prev));

		printk(" => ");

		printk(KERN_CONT " => ");

		print_lock_name(hlock_class(next));

		printk("\n");

		printk(KERN_CONT "\n");

		dump_stack();

		return graph_lock();

	}
@@ -2343,11 +2342,11 @@ print_usage_bug_scenario(struct held_lock *lock) 
	printk("       ----\n");

	printk("  lock(");

	__print_lock_name(class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("  <Interrupt>\n");

	printk("    lock(");

	__print_lock_name(class);

	printk(");\n");

	printk(KERN_CONT ");\n");

	printk("\n *** DEADLOCK ***\n\n");

}
@@ -2522,14 +2521,18 @@ check_usage_backwards(struct task_struct *curr, struct held_lock *this, 
void print_irqtrace_events(struct task_struct *curr)

{

	printk("irq event stamp: %u\n", curr->irq_events);

	printk("hardirqs last  enabled at (%u): ", curr->hardirq_enable_event);

	print_ip_sym(curr->hardirq_enable_ip);

	printk("hardirqs last disabled at (%u): ", curr->hardirq_disable_event);

	print_ip_sym(curr->hardirq_disable_ip);

	printk("softirqs last  enabled at (%u): ", curr->softirq_enable_event);

	print_ip_sym(curr->softirq_enable_ip);

	printk("softirqs last disabled at (%u): ", curr->softirq_disable_event);

	print_ip_sym(curr->softirq_disable_ip);

	printk("hardirqs last  enabled at (%u): [<%p>] %pS\n",

		curr->hardirq_enable_event, (void *)curr->hardirq_enable_ip,

		(void *)curr->hardirq_enable_ip);

	printk("hardirqs last disabled at (%u): [<%p>] %pS\n",

		curr->hardirq_disable_event, (void *)curr->hardirq_disable_ip,

		(void *)curr->hardirq_disable_ip);

	printk("softirqs last  enabled at (%u): [<%p>] %pS\n",

		curr->softirq_enable_event, (void *)curr->softirq_enable_ip,

		(void *)curr->softirq_enable_ip);

	printk("softirqs last disabled at (%u): [<%p>] %pS\n",

		curr->softirq_disable_event, (void *)curr->softirq_disable_ip,

		(void *)curr->softirq_disable_ip);

}



static int HARDIRQ_verbose(struct lock_class *class)
@@ -3235,8 +3238,8 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass, 
	if (very_verbose(class)) {

		printk("\nacquire class [%p] %s", class->key, class->name);

		if (class->name_version > 1)

			printk("#%d", class->name_version);

		printk("\n");

			printk(KERN_CONT "#%d", class->name_version);

		printk(KERN_CONT "\n");

		dump_stack();

	}
@@ -3378,7 +3381,7 @@ print_unlock_imbalance_bug(struct task_struct *curr, struct lockdep_map *lock, 
	printk("%s/%d is trying to release lock (",

		curr->comm, task_pid_nr(curr));

	print_lockdep_cache(lock);

	printk(") at:\n");

	printk(KERN_CONT ") at:\n");

	print_ip_sym(ip);

	printk("but there are no more locks to release!\n");

	printk("\nother info that might help us debug this:\n");
@@ -3871,7 +3874,7 @@ print_lock_contention_bug(struct task_struct *curr, struct lockdep_map *lock, 
	printk("%s/%d is trying to contend lock (",

		curr->comm, task_pid_nr(curr));

	print_lockdep_cache(lock);

	printk(") at:\n");

	printk(KERN_CONT ") at:\n");

	print_ip_sym(ip);

	printk("but there are no locks held!\n");

	printk("\nother info that might help us debug this:\n");

kernel/locking/rtmutex.c

+66 −2
Original line number Diff line number Diff line
@@ -65,8 +65,72 @@ static inline void clear_rt_mutex_waiters(struct rt_mutex *lock) 


static void fixup_rt_mutex_waiters(struct rt_mutex *lock)

{

	if (!rt_mutex_has_waiters(lock))

		clear_rt_mutex_waiters(lock);

	unsigned long owner, *p = (unsigned long *) &lock->owner;



	if (rt_mutex_has_waiters(lock))

		return;



	/*

	 * The rbtree has no waiters enqueued, now make sure that the

	 * lock->owner still has the waiters bit set, otherwise the

	 * following can happen:

	 *

	 * CPU 0	CPU 1		CPU2

	 * l->owner=T1

	 *		rt_mutex_lock(l)

	 *		lock(l->lock)

	 *		l->owner = T1 | HAS_WAITERS;

	 *		enqueue(T2)

	 *		boost()

	 *		  unlock(l->lock)

	 *		block()

	 *

	 *				rt_mutex_lock(l)

	 *				lock(l->lock)

	 *				l->owner = T1 | HAS_WAITERS;

	 *				enqueue(T3)

	 *				boost()

	 *				  unlock(l->lock)

	 *				block()

	 *		signal(->T2)	signal(->T3)

	 *		lock(l->lock)

	 *		dequeue(T2)

	 *		deboost()

	 *		  unlock(l->lock)

	 *				lock(l->lock)

	 *				dequeue(T3)

	 *				 ==> wait list is empty

	 *				deboost()

	 *				 unlock(l->lock)

	 *		lock(l->lock)

	 *		fixup_rt_mutex_waiters()

	 *		  if (wait_list_empty(l) {

	 *		    l->owner = owner

	 *		    owner = l->owner & ~HAS_WAITERS;

	 *		      ==> l->owner = T1

	 *		  }

	 *				lock(l->lock)

	 * rt_mutex_unlock(l)		fixup_rt_mutex_waiters()

	 *				  if (wait_list_empty(l) {

	 *				    owner = l->owner & ~HAS_WAITERS;

	 * cmpxchg(l->owner, T1, NULL)

	 *  ===> Success (l->owner = NULL)

	 *

	 *				    l->owner = owner

	 *				      ==> l->owner = T1

	 *				  }

	 *

	 * With the check for the waiter bit in place T3 on CPU2 will not

	 * overwrite. All tasks fiddling with the waiters bit are

	 * serialized by l->lock, so nothing else can modify the waiters

	 * bit. If the bit is set then nothing can change l->owner either

	 * so the simple RMW is safe. The cmpxchg() will simply fail if it

	 * happens in the middle of the RMW because the waiters bit is

	 * still set.

	 */

	owner = READ_ONCE(*p);

	if (owner & RT_MUTEX_HAS_WAITERS)

		WRITE_ONCE(*p, owner & ~RT_MUTEX_HAS_WAITERS);

}



/*

kernel/locking/rtmutex_common.h

+3 −2
Original line number Diff line number Diff line
@@ -75,8 +75,9 @@ task_top_pi_waiter(struct task_struct *p) 


static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)

{

	return (struct task_struct *)

		((unsigned long)lock->owner & ~RT_MUTEX_OWNER_MASKALL);

	unsigned long owner = (unsigned long) READ_ONCE(lock->owner);



	return (struct task_struct *) (owner & ~RT_MUTEX_OWNER_MASKALL);

}



/*

lib/locking-selftest.c

+33 −33
Original line number Diff line number Diff line
@@ -980,23 +980,23 @@ static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask) 
#ifndef CONFIG_PROVE_LOCKING

	if (expected == FAILURE && debug_locks) {

		expected_testcase_failures++;

		printk("failed|");

		pr_cont("failed|");

	}

	else

#endif

	if (debug_locks != expected) {

		unexpected_testcase_failures++;

		printk("FAILED|");

		pr_cont("FAILED|");



		dump_stack();

	} else {

		testcase_successes++;

		printk("  ok  |");

		pr_cont("  ok  |");

	}

	testcase_total++;



	if (debug_locks_verbose)

		printk(" lockclass mask: %x, debug_locks: %d, expected: %d\n",

		pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",

			lockclass_mask, debug_locks, expected);

	/*

	 * Some tests (e.g. double-unlock) might corrupt the preemption
@@ -1021,26 +1021,26 @@ static inline void print_testname(const char *testname) 
#define DO_TESTCASE_1(desc, name, nr)				\

	print_testname(desc"/"#nr);				\

	dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK);		\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_1B(desc, name, nr)				\

	print_testname(desc"/"#nr);				\

	dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);		\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_3(desc, name, nr)				\

	print_testname(desc"/"#nr);				\

	dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN);	\

	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\

	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_3RW(desc, name, nr)				\

	print_testname(desc"/"#nr);				\

	dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\

	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\

	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_6(desc, name)				\

	print_testname(desc);					\
@@ -1050,7 +1050,7 @@ static inline void print_testname(const char *testname) 
	dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);		\

	dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);		\

	dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);		\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_6_SUCCESS(desc, name)			\

	print_testname(desc);					\
@@ -1060,7 +1060,7 @@ static inline void print_testname(const char *testname) 
	dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX);		\

	dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM);		\

	dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM);		\

	printk("\n");

	pr_cont("\n");



/*

 * 'read' variant: rlocks must not trigger.
@@ -1073,7 +1073,7 @@ static inline void print_testname(const char *testname) 
	dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);		\

	dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);		\

	dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);		\

	printk("\n");

	pr_cont("\n");



#define DO_TESTCASE_2I(desc, name, nr)				\

	DO_TESTCASE_1("hard-"desc, name##_hard, nr);		\
@@ -1726,25 +1726,25 @@ static void ww_tests(void) 
	dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("ww contexts mixing");

	dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("finishing ww context");

	dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("locking mismatches");

	dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("EDEADLK handling");

	dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
@@ -1757,11 +1757,11 @@ static void ww_tests(void) 
	dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("spinlock nest unlocked");

	dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	printk("  -----------------------------------------------------\n");

	printk("                                 |block | try  |context|\n");
@@ -1771,25 +1771,25 @@ static void ww_tests(void) 
	dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("try");

	dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("block");

	dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");



	print_testname("spinlock");

	dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);

	dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);

	dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);

	printk("\n");

	pr_cont("\n");

}



void locking_selftest(void)
@@ -1829,32 +1829,32 @@ void locking_selftest(void) 


	printk("  --------------------------------------------------------------------------\n");

	print_testname("recursive read-lock");

	printk("             |");

	pr_cont("             |");

	dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);

	printk("             |");

	pr_cont("             |");

	dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);

	printk("\n");

	pr_cont("\n");



	print_testname("recursive read-lock #2");

	printk("             |");

	pr_cont("             |");

	dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);

	printk("             |");

	pr_cont("             |");

	dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);

	printk("\n");

	pr_cont("\n");



	print_testname("mixed read-write-lock");

	printk("             |");

	pr_cont("             |");

	dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);

	printk("             |");

	pr_cont("             |");

	dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);

	printk("\n");

	pr_cont("\n");



	print_testname("mixed write-read-lock");

	printk("             |");

	pr_cont("             |");

	dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);

	printk("             |");

	pr_cont("             |");

	dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);

	printk("\n");

	pr_cont("\n");



	printk("  --------------------------------------------------------------------------\n");