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

Commit 39e2e173 authored by Alfredo Alvarez Fernandez's avatar Alfredo Alvarez Fernandez Committed by Ingo Molnar
Browse files

locking/lockdep: Print chain_key collision information 



A sequence of pairs [class_idx -> corresponding chain_key iteration]
is printed for both the current held_lock chain and the cached chain.

That exposes the two different class_idx sequences that led to that
particular hash value.

This helps with debugging hash chain collision reports.

Signed-off-by: default avatarAlfredo Alvarez Fernandez <alfredoalvarezfernandez@gmail.com>
Acked-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-fsdevel@vger.kernel.org
Cc: sedat.dilek@gmail.com
Cc: tytso@mit.edu
Link: http://lkml.kernel.org/r/1459357416-19190-1-git-send-email-alfredoalvarezernandez@gmail.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 283d7573

kernel/locking/lockdep.c

+77 −2
Original line number Diff line number Diff line
@@ -1999,6 +1999,77 @@ static inline int get_first_held_lock(struct task_struct *curr, 
	return ++i;

}



/*

 * Returns the next chain_key iteration

 */

static u64 print_chain_key_iteration(int class_idx, u64 chain_key)

{

	u64 new_chain_key = iterate_chain_key(chain_key, class_idx);



	printk(" class_idx:%d -> chain_key:%016Lx",

		class_idx,

		(unsigned long long)new_chain_key);

	return new_chain_key;

}



static void

print_chain_keys_held_locks(struct task_struct *curr, struct held_lock *hlock_next)

{

	struct held_lock *hlock;

	u64 chain_key = 0;

	int depth = curr->lockdep_depth;

	int i;



	printk("depth: %u\n", depth + 1);

	for (i = get_first_held_lock(curr, hlock_next); i < depth; i++) {

		hlock = curr->held_locks + i;

		chain_key = print_chain_key_iteration(hlock->class_idx, chain_key);



		print_lock(hlock);

	}



	print_chain_key_iteration(hlock_next->class_idx, chain_key);

	print_lock(hlock_next);

}



static void print_chain_keys_chain(struct lock_chain *chain)

{

	int i;

	u64 chain_key = 0;

	int class_id;



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

	for (i = 0; i < chain->depth; i++) {

		class_id = chain_hlocks[chain->base + i];

		chain_key = print_chain_key_iteration(class_id + 1, chain_key);



		print_lock_name(lock_classes + class_id);

		printk("\n");

	}

}



static void print_collision(struct task_struct *curr,

			struct held_lock *hlock_next,

			struct lock_chain *chain)

{

	printk("\n");

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

	printk("[chain_key collision ]\n");

	print_kernel_ident();

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

	printk("%s/%d: ", current->comm, task_pid_nr(current));

	printk("Hash chain already cached but the contents don't match!\n");



	printk("Held locks:");

	print_chain_keys_held_locks(curr, hlock_next);



	printk("Locks in cached chain:");

	print_chain_keys_chain(chain);



	printk("\nstack backtrace:\n");

	dump_stack();

}



/*

 * Checks whether the chain and the current held locks are consistent

 * in depth and also in content. If they are not it most likely means
@@ -2014,15 +2085,19 @@ static int check_no_collision(struct task_struct *curr, 


	i = get_first_held_lock(curr, hlock);



	if (DEBUG_LOCKS_WARN_ON(chain->depth != curr->lockdep_depth - (i - 1)))

	if (DEBUG_LOCKS_WARN_ON(chain->depth != curr->lockdep_depth - (i - 1))) {

		print_collision(curr, hlock, chain);

		return 0;

	}



	for (j = 0; j < chain->depth - 1; j++, i++) {

		id = curr->held_locks[i].class_idx - 1;



		if (DEBUG_LOCKS_WARN_ON(chain_hlocks[chain->base + j] != id))

		if (DEBUG_LOCKS_WARN_ON(chain_hlocks[chain->base + j] != id)) {

			print_collision(curr, hlock, chain);

			return 0;

		}

	}

#endif

	return 1;

}