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

Commit fb7e4241 authored by Ingo Molnar's avatar Ingo Molnar Committed by Linus Torvalds
Browse files

[PATCH] lockdep: remove mutex deadlock checking code 



With the lock validator we detect mutex deadlocks (and more), the mutex
deadlock checking code is both redundant and slower.  So remove it.

Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 36596243

kernel/mutex-debug.c

+0 −316
Original line number Diff line number Diff line
@@ -51,321 +51,6 @@ LIST_HEAD(debug_mutex_held_locks); 
 */

int debug_mutex_on = 1;



static void printk_task(struct task_struct *p)

{

	if (p)

		printk("%16s:%5d [%p, %3d]", p->comm, p->pid, p, p->prio);

	else

		printk("<none>");

}



static void printk_ti(struct thread_info *ti)

{

	if (ti)

		printk_task(ti->task);

	else

		printk("<none>");

}



static void printk_task_short(struct task_struct *p)

{

	if (p)

		printk("%s/%d [%p, %3d]", p->comm, p->pid, p, p->prio);

	else

		printk("<none>");

}



static void printk_lock(struct mutex *lock, int print_owner)

{

	printk(" [%p] {%s}\n", lock, lock->name);



	if (print_owner && lock->owner) {

		printk(".. held by:  ");

		printk_ti(lock->owner);

		printk("\n");

	}

	if (lock->owner) {

		printk("... acquired at:               ");

		print_symbol("%s\n", lock->acquire_ip);

	}

}



/*

 * printk locks held by a task:

 */

static void show_task_locks(struct task_struct *p)

{

	switch (p->state) {

	case TASK_RUNNING:		printk("R"); break;

	case TASK_INTERRUPTIBLE:	printk("S"); break;

	case TASK_UNINTERRUPTIBLE:	printk("D"); break;

	case TASK_STOPPED:		printk("T"); break;

	case EXIT_ZOMBIE:		printk("Z"); break;

	case EXIT_DEAD:			printk("X"); break;

	default:			printk("?"); break;

	}

	printk_task(p);

	if (p->blocked_on) {

		struct mutex *lock = p->blocked_on->lock;



		printk(" blocked on mutex:");

		printk_lock(lock, 1);

	} else

		printk(" (not blocked on mutex)\n");

}



/*

 * printk all locks held in the system (if filter == NULL),

 * or all locks belonging to a single task (if filter != NULL):

 */

void show_held_locks(struct task_struct *filter)

{

	struct list_head *curr, *cursor = NULL;

	struct mutex *lock;

	struct thread_info *t;

	unsigned long flags;

	int count = 0;



	if (filter) {

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

		printk("| showing all locks held by: |  (");

		printk_task_short(filter);

		printk("):\n");

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

	} else {

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

		printk("| showing all locks held: |\n");

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

	}



	/*

	 * Play safe and acquire the global trace lock. We

	 * cannot printk with that lock held so we iterate

	 * very carefully:

	 */

next:

	debug_spin_lock_save(&debug_mutex_lock, flags);

	list_for_each(curr, &debug_mutex_held_locks) {

		if (cursor && curr != cursor)

			continue;

		lock = list_entry(curr, struct mutex, held_list);

		t = lock->owner;

		if (filter && (t != filter->thread_info))

			continue;

		count++;

		cursor = curr->next;

		debug_spin_unlock_restore(&debug_mutex_lock, flags);



		printk("\n#%03d:            ", count);

		printk_lock(lock, filter ? 0 : 1);

		goto next;

	}

	debug_spin_unlock_restore(&debug_mutex_lock, flags);

	printk("\n");

}



void mutex_debug_show_all_locks(void)

{

	struct task_struct *g, *p;

	int count = 10;

	int unlock = 1;



	printk("\nShowing all blocking locks in the system:\n");



	/*

	 * Here we try to get the tasklist_lock as hard as possible,

	 * if not successful after 2 seconds we ignore it (but keep

	 * trying). This is to enable a debug printout even if a

	 * tasklist_lock-holding task deadlocks or crashes.

	 */

retry:

	if (!read_trylock(&tasklist_lock)) {

		if (count == 10)

			printk("hm, tasklist_lock locked, retrying... ");

		if (count) {

			count--;

			printk(" #%d", 10-count);

			mdelay(200);

			goto retry;

		}

		printk(" ignoring it.\n");

		unlock = 0;

	}

	if (count != 10)

		printk(" locked it.\n");



	do_each_thread(g, p) {

		show_task_locks(p);

		if (!unlock)

			if (read_trylock(&tasklist_lock))

				unlock = 1;

	} while_each_thread(g, p);



	printk("\n");

	show_held_locks(NULL);

	printk("=============================================\n\n");



	if (unlock)

		read_unlock(&tasklist_lock);

}



static void report_deadlock(struct task_struct *task, struct mutex *lock,

			    struct mutex *lockblk, unsigned long ip)

{

	printk("\n%s/%d is trying to acquire this lock:\n",

		current->comm, current->pid);

	printk_lock(lock, 1);

	printk("... trying at:                 ");

	print_symbol("%s\n", ip);

	show_held_locks(current);



	if (lockblk) {

		printk("but %s/%d is deadlocking current task %s/%d!\n\n",

			task->comm, task->pid, current->comm, current->pid);

		printk("\n%s/%d is blocked on this lock:\n",

			task->comm, task->pid);

		printk_lock(lockblk, 1);



		show_held_locks(task);



		printk("\n%s/%d's [blocked] stackdump:\n\n",

			task->comm, task->pid);

		show_stack(task, NULL);

	}



	printk("\n%s/%d's [current] stackdump:\n\n",

		current->comm, current->pid);

	dump_stack();

	mutex_debug_show_all_locks();

	printk("[ turning off deadlock detection. Please report this. ]\n\n");

	local_irq_disable();

}



/*

 * Recursively check for mutex deadlocks:

 */

static int check_deadlock(struct mutex *lock, int depth,

			  struct thread_info *ti, unsigned long ip)

{

	struct mutex *lockblk;

	struct task_struct *task;



	if (!debug_mutex_on)

		return 0;



	ti = lock->owner;

	if (!ti)

		return 0;



	task = ti->task;

	lockblk = NULL;

	if (task->blocked_on)

		lockblk = task->blocked_on->lock;



	/* Self-deadlock: */

	if (current == task) {

		DEBUG_OFF();

		if (depth)

			return 1;

		printk("\n==========================================\n");

		printk(  "[ BUG: lock recursion deadlock detected! |\n");

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

		report_deadlock(task, lock, NULL, ip);

		return 0;

	}



	/* Ugh, something corrupted the lock data structure? */

	if (depth > 20) {

		DEBUG_OFF();

		printk("\n===========================================\n");

		printk(  "[ BUG: infinite lock dependency detected!? |\n");

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

		report_deadlock(task, lock, lockblk, ip);

		return 0;

	}



	/* Recursively check for dependencies: */

	if (lockblk && check_deadlock(lockblk, depth+1, ti, ip)) {

		printk("\n============================================\n");

		printk(  "[ BUG: circular locking deadlock detected! ]\n");

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

		report_deadlock(task, lock, lockblk, ip);

		return 0;

	}

	return 0;

}



/*

 * Called when a task exits, this function checks whether the

 * task is holding any locks, and reports the first one if so:

 */

void mutex_debug_check_no_locks_held(struct task_struct *task)

{

	struct list_head *curr, *next;

	struct thread_info *t;

	unsigned long flags;

	struct mutex *lock;



	if (!debug_mutex_on)

		return;



	debug_spin_lock_save(&debug_mutex_lock, flags);

	list_for_each_safe(curr, next, &debug_mutex_held_locks) {

		lock = list_entry(curr, struct mutex, held_list);

		t = lock->owner;

		if (t != task->thread_info)

			continue;

		list_del_init(curr);

		DEBUG_OFF();

		debug_spin_unlock_restore(&debug_mutex_lock, flags);



		printk("BUG: %s/%d, lock held at task exit time!\n",

			task->comm, task->pid);

		printk_lock(lock, 1);

		if (lock->owner != task->thread_info)

			printk("exiting task is not even the owner??\n");

		return;

	}

	debug_spin_unlock_restore(&debug_mutex_lock, flags);

}



/*

 * Called when kernel memory is freed (or unmapped), or if a mutex

 * is destroyed or reinitialized - this code checks whether there is

 * any held lock in the memory range of <from> to <to>:

 */

void mutex_debug_check_no_locks_freed(const void *from, unsigned long len)

{

	struct list_head *curr, *next;

	const void *to = from + len;

	unsigned long flags;

	struct mutex *lock;

	void *lock_addr;



	if (!debug_mutex_on)

		return;



	debug_spin_lock_save(&debug_mutex_lock, flags);

	list_for_each_safe(curr, next, &debug_mutex_held_locks) {

		lock = list_entry(curr, struct mutex, held_list);

		lock_addr = lock;

		if (lock_addr < from || lock_addr >= to)

			continue;

		list_del_init(curr);

		DEBUG_OFF();

		debug_spin_unlock_restore(&debug_mutex_lock, flags);



		printk("BUG: %s/%d, active lock [%p(%p-%p)] freed!\n",

			current->comm, current->pid, lock, from, to);

		dump_stack();

		printk_lock(lock, 1);

		if (lock->owner != current_thread_info())

			printk("freeing task is not even the owner??\n");

		return;

	}

	debug_spin_unlock_restore(&debug_mutex_lock, flags);

}



/*

 * Must be called with lock->wait_lock held.

 */
@@ -405,7 +90,6 @@ void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter, 
			    struct thread_info *ti __IP_DECL__)

{

	SMP_DEBUG_LOCKS_WARN_ON(!spin_is_locked(&lock->wait_lock));

	check_deadlock(lock, 0, ti, ip);

	/* Mark the current thread as blocked on the lock: */

	ti->task->blocked_on = waiter;

	waiter->lock = lock;

lib/Kconfig.debug

+0 −8
Original line number Diff line number Diff line
@@ -115,14 +115,6 @@ config DEBUG_PREEMPT 
	  if kernel code uses it in a preemption-unsafe way. Also, the kernel

	  will detect preemption count underflows.



config DEBUG_MUTEXES

	bool "Mutex debugging, deadlock detection"

	default n

	depends on DEBUG_KERNEL

	help

	 This allows mutex semantics violations and mutex related deadlocks

	 (lockups) to be detected and reported automatically.



config DEBUG_RT_MUTEXES

	bool "RT Mutex debugging, deadlock detection"

	depends on DEBUG_KERNEL && RT_MUTEXES