leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Linus Torvalds 2016-12-07 11:27:33 -08:00
commit 5b43f97f3f
4 changed files with 159 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
kernel/locking/lockdep.c
View File

@ -506,13 +506,13 @@ static void __print_lock_name(struct lock_class *class)
name = class->name; name = class->name;
if (!name) { if (!name) {
name = __get_key_name(class->key, str); name = __get_key_name(class->key, str);
printk("%s", name); printk(KERN_CONT "%s", name);
} else { } else {
printk("%s", name); printk(KERN_CONT "%s", name);
if (class->name_version > 1) if (class->name_version > 1)
printk("#%d", class->name_version); printk(KERN_CONT "#%d", class->name_version);
if (class->subclass) 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); get_usage_chars(class, usage);
printk(" ("); printk(KERN_CONT " (");
__print_lock_name(class); __print_lock_name(class);
printk("){%s}", usage); printk(KERN_CONT "){%s}", usage);
} }
static void print_lockdep_cache(struct lockdep_map *lock) static void print_lockdep_cache(struct lockdep_map *lock)
@ -536,7 +536,7 @@ static void print_lockdep_cache(struct lockdep_map *lock)
if (!name) if (!name)
name = __get_key_name(lock->key->subkeys, str); name = __get_key_name(lock->key->subkeys, str);
printk("%s", name); printk(KERN_CONT "%s", name);
} }
static void print_lock(struct held_lock *hlock) static void print_lock(struct held_lock *hlock)
@ -551,13 +551,13 @@ static void print_lock(struct held_lock *hlock)
barrier(); barrier();
if (!class_idx || (class_idx - 1) >= MAX_LOCKDEP_KEYS) { if (!class_idx || (class_idx - 1) >= MAX_LOCKDEP_KEYS) {
printk("<RELEASED>\n"); printk(KERN_CONT "<RELEASED>\n");
return; return;
} }
print_lock_name(lock_classes + class_idx - 1); print_lock_name(lock_classes + class_idx - 1);
printk(", at: "); printk(KERN_CONT ", at: [<%p>] %pS\n",
print_ip_sym(hlock->acquire_ip); (void *)hlock->acquire_ip, (void *)hlock->acquire_ip);
} }
static void lockdep_print_held_locks(struct task_struct *curr) 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); printk("\nnew class %p: %s", class->key, class->name);
if (class->name_version > 1) if (class->name_version > 1)
printk("#%d", class->name_version); printk(KERN_CONT "#%d", class->name_version);
printk("\n"); printk(KERN_CONT "\n");
dump_stack(); dump_stack();
if (!graph_lock()) { if (!graph_lock()) {
@ -1071,7 +1071,7 @@ print_circular_bug_entry(struct lock_list *target, int depth)
return 0; return 0;
printk("\n-> #%u", depth); printk("\n-> #%u", depth);
print_lock_name(target->class); print_lock_name(target->class);
printk(":\n"); printk(KERN_CONT ":\n");
print_stack_trace(&target->trace, 6); print_stack_trace(&target->trace, 6);
return 0; return 0;
@ -1102,11 +1102,11 @@ print_circular_lock_scenario(struct held_lock *src,
if (parent != source) { if (parent != source) {
printk("Chain exists of:\n "); printk("Chain exists of:\n ");
__print_lock_name(source); __print_lock_name(source);
printk(" --> "); printk(KERN_CONT " --> ");
__print_lock_name(parent); __print_lock_name(parent);
printk(" --> "); printk(KERN_CONT " --> ");
__print_lock_name(target); __print_lock_name(target);
printk("\n\n"); printk(KERN_CONT "\n\n");
} }
printk(" Possible unsafe locking scenario:\n\n"); printk(" Possible unsafe locking scenario:\n\n");
@ -1114,16 +1114,16 @@ print_circular_lock_scenario(struct held_lock *src,
printk(" ---- ----\n"); printk(" ---- ----\n");
printk(" lock("); printk(" lock(");
__print_lock_name(target); __print_lock_name(target);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" lock("); printk(" lock(");
__print_lock_name(parent); __print_lock_name(parent);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" lock("); printk(" lock(");
__print_lock_name(target); __print_lock_name(target);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" lock("); printk(" lock(");
__print_lock_name(source); __print_lock_name(source);
printk(");\n"); printk(KERN_CONT ");\n");
printk("\n *** DEADLOCK ***\n\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, ""); printk("%*s->", depth, "");
print_lock_name(class); print_lock_name(class);
printk(" ops: %lu", class->ops); printk(KERN_CONT " ops: %lu", class->ops);
printk(" {\n"); printk(KERN_CONT " {\n");
for (bit = 0; bit < LOCK_USAGE_STATES; bit++) { for (bit = 0; bit < LOCK_USAGE_STATES; bit++) {
if (class->usage_mask & (1 << bit)) { if (class->usage_mask & (1 << bit)) {
int len = depth; int len = depth;
len += printk("%*s %s", depth, "", usage_str[bit]); 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); print_stack_trace(class->usage_traces + bit, len);
} }
} }
printk("%*s }\n", depth, ""); printk("%*s }\n", depth, "");
printk("%*s ... key at: ",depth,""); printk("%*s ... key at: [<%p>] %pS\n",
print_ip_sym((unsigned long)class->key); depth, "", class->key, class->key);
} }
/* /*
@ -1437,11 +1437,11 @@ print_irq_lock_scenario(struct lock_list *safe_entry,
if (middle_class != unsafe_class) { if (middle_class != unsafe_class) {
printk("Chain exists of:\n "); printk("Chain exists of:\n ");
__print_lock_name(safe_class); __print_lock_name(safe_class);
printk(" --> "); printk(KERN_CONT " --> ");
__print_lock_name(middle_class); __print_lock_name(middle_class);
printk(" --> "); printk(KERN_CONT " --> ");
__print_lock_name(unsafe_class); __print_lock_name(unsafe_class);
printk("\n\n"); printk(KERN_CONT "\n\n");
} }
printk(" Possible interrupt unsafe locking scenario:\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(" ---- ----\n");
printk(" lock("); printk(" lock(");
__print_lock_name(unsafe_class); __print_lock_name(unsafe_class);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" local_irq_disable();\n"); printk(" local_irq_disable();\n");
printk(" lock("); printk(" lock(");
__print_lock_name(safe_class); __print_lock_name(safe_class);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" lock("); printk(" lock(");
__print_lock_name(middle_class); __print_lock_name(middle_class);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" <Interrupt>\n"); printk(" <Interrupt>\n");
printk(" lock("); printk(" lock(");
__print_lock_name(safe_class); __print_lock_name(safe_class);
printk(");\n"); printk(KERN_CONT ");\n");
printk("\n *** DEADLOCK ***\n\n"); printk("\n *** DEADLOCK ***\n\n");
} }
@ -1497,9 +1497,9 @@ print_bad_irq_dependency(struct task_struct *curr,
print_lock(prev); print_lock(prev);
printk("which would create a new lock dependency:\n"); printk("which would create a new lock dependency:\n");
print_lock_name(hlock_class(prev)); print_lock_name(hlock_class(prev));
printk(" ->"); printk(KERN_CONT " ->");
print_lock_name(hlock_class(next)); print_lock_name(hlock_class(next));
printk("\n"); printk(KERN_CONT "\n");
printk("\nbut this new dependency connects a %s-irq-safe lock:\n", printk("\nbut this new dependency connects a %s-irq-safe lock:\n",
irqclass); irqclass);
@ -1521,8 +1521,7 @@ print_bad_irq_dependency(struct task_struct *curr,
lockdep_print_held_locks(curr); lockdep_print_held_locks(curr);
printk("\nthe dependencies between %s-irq-safe lock", irqclass); printk("\nthe dependencies between %s-irq-safe lock and the holding lock:\n", irqclass);
printk(" and the holding lock:\n");
if (!save_trace(&prev_root->trace)) if (!save_trace(&prev_root->trace))
return 0; return 0;
print_shortest_lock_dependencies(backwards_entry, prev_root); print_shortest_lock_dependencies(backwards_entry, prev_root);
@ -1694,10 +1693,10 @@ print_deadlock_scenario(struct held_lock *nxt,
printk(" ----\n"); printk(" ----\n");
printk(" lock("); printk(" lock(");
__print_lock_name(prev); __print_lock_name(prev);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" lock("); printk(" lock(");
__print_lock_name(next); __print_lock_name(next);
printk(");\n"); printk(KERN_CONT ");\n");
printk("\n *** DEADLOCK ***\n\n"); printk("\n *** DEADLOCK ***\n\n");
printk(" May be due to missing lock nesting notation\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(); graph_unlock();
printk("\n new dependency: "); printk("\n new dependency: ");
print_lock_name(hlock_class(prev)); print_lock_name(hlock_class(prev));
printk(" => "); printk(KERN_CONT " => ");
print_lock_name(hlock_class(next)); print_lock_name(hlock_class(next));
printk("\n"); printk(KERN_CONT "\n");
dump_stack(); dump_stack();
return graph_lock(); return graph_lock();
} }
@ -2343,11 +2342,11 @@ print_usage_bug_scenario(struct held_lock *lock)
printk(" ----\n"); printk(" ----\n");
printk(" lock("); printk(" lock(");
__print_lock_name(class); __print_lock_name(class);
printk(");\n"); printk(KERN_CONT ");\n");
printk(" <Interrupt>\n"); printk(" <Interrupt>\n");
printk(" lock("); printk(" lock(");
__print_lock_name(class); __print_lock_name(class);
printk(");\n"); printk(KERN_CONT ");\n");
printk("\n *** DEADLOCK ***\n\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) void print_irqtrace_events(struct task_struct *curr)
{ {
printk("irq event stamp: %u\n", curr->irq_events); printk("irq event stamp: %u\n", curr->irq_events);
printk("hardirqs last enabled at (%u): ", curr->hardirq_enable_event); printk("hardirqs last enabled at (%u): [<%p>] %pS\n",
print_ip_sym(curr->hardirq_enable_ip); curr->hardirq_enable_event, (void *)curr->hardirq_enable_ip,
printk("hardirqs last disabled at (%u): ", curr->hardirq_disable_event); (void *)curr->hardirq_enable_ip);
print_ip_sym(curr->hardirq_disable_ip); printk("hardirqs last disabled at (%u): [<%p>] %pS\n",
printk("softirqs last enabled at (%u): ", curr->softirq_enable_event); curr->hardirq_disable_event, (void *)curr->hardirq_disable_ip,
print_ip_sym(curr->softirq_enable_ip); (void *)curr->hardirq_disable_ip);
printk("softirqs last disabled at (%u): ", curr->softirq_disable_event); printk("softirqs last enabled at (%u): [<%p>] %pS\n",
print_ip_sym(curr->softirq_disable_ip); 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) 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)) { if (very_verbose(class)) {
printk("\nacquire class [%p] %s", class->key, class->name); printk("\nacquire class [%p] %s", class->key, class->name);
if (class->name_version > 1) if (class->name_version > 1)
printk("#%d", class->name_version); printk(KERN_CONT "#%d", class->name_version);
printk("\n"); printk(KERN_CONT "\n");
dump_stack(); 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 (", printk("%s/%d is trying to release lock (",
curr->comm, task_pid_nr(curr)); curr->comm, task_pid_nr(curr));
print_lockdep_cache(lock); print_lockdep_cache(lock);
printk(") at:\n"); printk(KERN_CONT ") at:\n");
print_ip_sym(ip); print_ip_sym(ip);
printk("but there are no more locks to release!\n"); printk("but there are no more locks to release!\n");
printk("\nother info that might help us debug this:\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 (", printk("%s/%d is trying to contend lock (",
curr->comm, task_pid_nr(curr)); curr->comm, task_pid_nr(curr));
print_lockdep_cache(lock); print_lockdep_cache(lock);
printk(") at:\n"); printk(KERN_CONT ") at:\n");
print_ip_sym(ip); print_ip_sym(ip);
printk("but there are no locks held!\n"); printk("but there are no locks held!\n");
printk("\nother info that might help us debug this:\n"); printk("\nother info that might help us debug this:\n");

68
kernel/locking/rtmutex.c
View File

@ -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) static void fixup_rt_mutex_waiters(struct rt_mutex *lock)
{ {
if (!rt_mutex_has_waiters(lock)) unsigned long owner, *p = (unsigned long *) &lock->owner;
clear_rt_mutex_waiters(lock);
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);
} }
/* /*

5
kernel/locking/rtmutex_common.h
View File

@ -75,8 +75,9 @@ task_top_pi_waiter(struct task_struct *p)
static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock) static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)
{ {
return (struct task_struct *) unsigned long owner = (unsigned long) READ_ONCE(lock->owner);
((unsigned long)lock->owner & ~RT_MUTEX_OWNER_MASKALL);
return (struct task_struct *) (owner & ~RT_MUTEX_OWNER_MASKALL);
} }
/* /*

66
lib/locking-selftest.c
View File

@ -980,23 +980,23 @@ static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
#ifndef CONFIG_PROVE_LOCKING #ifndef CONFIG_PROVE_LOCKING
if (expected == FAILURE && debug_locks) { if (expected == FAILURE && debug_locks) {
expected_testcase_failures++; expected_testcase_failures++;
printk("failed|"); pr_cont("failed|");
} }
else else
#endif #endif
if (debug_locks != expected) { if (debug_locks != expected) {
unexpected_testcase_failures++; unexpected_testcase_failures++;
printk("FAILED|"); pr_cont("FAILED|");
dump_stack(); dump_stack();
} else { } else {
testcase_successes++; testcase_successes++;
printk(" ok |"); pr_cont(" ok |");
} }
testcase_total++; testcase_total++;
if (debug_locks_verbose) 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); lockclass_mask, debug_locks, expected);
/* /*
* Some tests (e.g. double-unlock) might corrupt the preemption * 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) \ #define DO_TESTCASE_1(desc, name, nr) \
print_testname(desc"/"#nr); \ print_testname(desc"/"#nr); \
dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_1B(desc, name, nr) \ #define DO_TESTCASE_1B(desc, name, nr) \
print_testname(desc"/"#nr); \ print_testname(desc"/"#nr); \
dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \ dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_3(desc, name, nr) \ #define DO_TESTCASE_3(desc, name, nr) \
print_testname(desc"/"#nr); \ print_testname(desc"/"#nr); \
dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \ dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \ dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_3RW(desc, name, nr) \ #define DO_TESTCASE_3RW(desc, name, nr) \
print_testname(desc"/"#nr); \ print_testname(desc"/"#nr); \
dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\ dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \ dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \ dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_6(desc, name) \ #define DO_TESTCASE_6(desc, name) \
print_testname(desc); \ print_testname(desc); \
@ -1050,7 +1050,7 @@ static inline void print_testname(const char *testname)
dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \ dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \ dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \ dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_6_SUCCESS(desc, name) \ #define DO_TESTCASE_6_SUCCESS(desc, name) \
print_testname(desc); \ print_testname(desc); \
@ -1060,7 +1060,7 @@ static inline void print_testname(const char *testname)
dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \ dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \
dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \ dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \
dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \ dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \
printk("\n"); pr_cont("\n");
/* /*
* 'read' variant: rlocks must not trigger. * '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##_mutex, FAILURE, LOCKTYPE_MUTEX); \
dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \ dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \ dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
printk("\n"); pr_cont("\n");
#define DO_TESTCASE_2I(desc, name, nr) \ #define DO_TESTCASE_2I(desc, name, nr) \
DO_TESTCASE_1("hard-"desc, name##_hard, 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_fail_acquire, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW); dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW); dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("ww contexts mixing"); print_testname("ww contexts mixing");
dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW); dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW); dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("finishing ww context"); print_testname("finishing ww context");
dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW); dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
dotest(ww_test_context_unlock_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_fini_early, FAILURE, LOCKTYPE_WW);
dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW); dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("locking mismatches"); print_testname("locking mismatches");
dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW); dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW); dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW); dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("EDEADLK handling"); print_testname("EDEADLK handling");
dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW); 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_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW); dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW); dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("spinlock nest unlocked"); print_testname("spinlock nest unlocked");
dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW); dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
printk(" -----------------------------------------------------\n"); printk(" -----------------------------------------------------\n");
printk(" |block | try |context|\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_block, FAILURE, LOCKTYPE_WW);
dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW); dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW); dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("try"); print_testname("try");
dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW); dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW); dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW); dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("block"); print_testname("block");
dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW); dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW); dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW); dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
print_testname("spinlock"); print_testname("spinlock");
dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW); dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW); dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW); dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
printk("\n"); pr_cont("\n");
} }
void locking_selftest(void) void locking_selftest(void)
@ -1829,32 +1829,32 @@ void locking_selftest(void)
printk(" --------------------------------------------------------------------------\n"); printk(" --------------------------------------------------------------------------\n");
print_testname("recursive read-lock"); print_testname("recursive read-lock");
printk(" |"); pr_cont(" |");
dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK); dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
printk(" |"); pr_cont(" |");
dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM); dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
printk("\n"); pr_cont("\n");
print_testname("recursive read-lock #2"); print_testname("recursive read-lock #2");
printk(" |"); pr_cont(" |");
dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK); dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
printk(" |"); pr_cont(" |");
dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM); dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
printk("\n"); pr_cont("\n");
print_testname("mixed read-write-lock"); print_testname("mixed read-write-lock");
printk(" |"); pr_cont(" |");
dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK); dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
printk(" |"); pr_cont(" |");
dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM); dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
printk("\n"); pr_cont("\n");
print_testname("mixed write-read-lock"); print_testname("mixed write-read-lock");
printk(" |"); pr_cont(" |");
dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK); dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
printk(" |"); pr_cont(" |");
dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM); dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
printk("\n"); pr_cont("\n");
printk(" --------------------------------------------------------------------------\n"); printk(" --------------------------------------------------------------------------\n");