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

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

[PATCH] lockdep: prove mutex locking correctness 



Use the lock validator framework to prove mutex locking correctness.

Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarArjan van de Ven <arjan@linux.intel.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 8a25d5de

include/linux/mutex-debug.h

+7 −1
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
#define __LINUX_MUTEX_DEBUG_H



#include <linux/linkage.h>

#include <linux/lockdep.h>



/*

 * Mutexes - debugging helpers:
@@ -10,7 +11,12 @@ 
#define __DEBUG_MUTEX_INITIALIZER(lockname)				\

	, .magic = &lockname



#define mutex_init(sem)		__mutex_init(sem, __FILE__":"#sem)

#define mutex_init(mutex)						\

do {									\

	static struct lock_class_key __key;				\

									\

	__mutex_init((mutex), #mutex, &__key);				\

} while (0)



extern void FASTCALL(mutex_destroy(struct mutex *lock));

include/linux/mutex.h

+28 −3
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/list.h>

#include <linux/spinlock_types.h>

#include <linux/linkage.h>

#include <linux/lockdep.h>



#include <asm/atomic.h>
@@ -53,6 +54,9 @@ struct mutex { 
	const char 		*name;

	void			*magic;

#endif

#ifdef CONFIG_DEBUG_LOCK_ALLOC

	struct lockdep_map	dep_map;

#endif

};



/*
@@ -72,20 +76,34 @@ struct mutex_waiter { 
# include <linux/mutex-debug.h>

#else

# define __DEBUG_MUTEX_INITIALIZER(lockname)

# define mutex_init(mutex)			__mutex_init(mutex, NULL)

# define mutex_init(mutex) \

do {							\

	static struct lock_class_key __key;		\

							\

	__mutex_init((mutex), #mutex, &__key);		\

} while (0)

# define mutex_destroy(mutex)				do { } while (0)

#endif



#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define __DEP_MAP_MUTEX_INITIALIZER(lockname) \

		, .dep_map = { .name = #lockname }

#else

# define __DEP_MAP_MUTEX_INITIALIZER(lockname)

#endif



#define __MUTEX_INITIALIZER(lockname) \

		{ .count = ATOMIC_INIT(1) \

		, .wait_lock = SPIN_LOCK_UNLOCKED \

		, .wait_list = LIST_HEAD_INIT(lockname.wait_list) \

		__DEBUG_MUTEX_INITIALIZER(lockname) }

		__DEBUG_MUTEX_INITIALIZER(lockname) \

		__DEP_MAP_MUTEX_INITIALIZER(lockname) }



#define DEFINE_MUTEX(mutexname) \

	struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)



extern void fastcall __mutex_init(struct mutex *lock, const char *name);

extern void __mutex_init(struct mutex *lock, const char *name,

			 struct lock_class_key *key);



/***

 * mutex_is_locked - is the mutex locked
@@ -104,6 +122,13 @@ static inline int fastcall mutex_is_locked(struct mutex *lock) 
 */

extern void fastcall mutex_lock(struct mutex *lock);

extern int fastcall mutex_lock_interruptible(struct mutex *lock);



#ifdef CONFIG_DEBUG_LOCK_ALLOC

extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);

#else

# define mutex_lock_nested(lock, subclass) mutex_lock(lock)

#endif



/*

 * NOTE: mutex_trylock() follows the spin_trylock() convention,

 *       not the down_trylock() convention!

kernel/mutex-debug.c

+5 −1
Original line number Diff line number Diff line
@@ -83,12 +83,16 @@ void debug_mutex_unlock(struct mutex *lock) 
	DEBUG_LOCKS_WARN_ON(lock->owner != current_thread_info());

}



void debug_mutex_init(struct mutex *lock, const char *name)

void debug_mutex_init(struct mutex *lock, const char *name,

		      struct lock_class_key *key)

{

#ifdef CONFIG_DEBUG_LOCK_ALLOC

	/*

	 * Make sure we are not reinitializing a held lock:

	 */

	debug_check_no_locks_freed((void *)lock, sizeof(*lock));

	lockdep_init_map(&lock->dep_map, name, key);

#endif

	lock->owner = NULL;

	lock->magic = lock;

}

kernel/mutex.c

+22 −6
Original line number Diff line number Diff line
@@ -39,13 +39,14 @@ 
 *

 * It is not allowed to initialize an already locked mutex.

 */

__always_inline void fastcall __mutex_init(struct mutex *lock, const char *name)

void

__mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)

{

	atomic_set(&lock->count, 1);

	spin_lock_init(&lock->wait_lock);

	INIT_LIST_HEAD(&lock->wait_list);



	debug_mutex_init(lock, name);

	debug_mutex_init(lock, name, key);

}



EXPORT_SYMBOL(__mutex_init);
@@ -131,6 +132,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass) 
	spin_lock_mutex(&lock->wait_lock, flags);



	debug_mutex_lock_common(lock, &waiter);

	mutex_acquire(&lock->dep_map, subclass, 0, _RET_IP_);

	debug_mutex_add_waiter(lock, &waiter, task->thread_info);



	/* add waiting tasks to the end of the waitqueue (FIFO): */
@@ -158,6 +160,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass) 
		if (unlikely(state == TASK_INTERRUPTIBLE &&

						signal_pending(task))) {

			mutex_remove_waiter(lock, &waiter, task->thread_info);

			mutex_release(&lock->dep_map, 1, _RET_IP_);

			spin_unlock_mutex(&lock->wait_lock, flags);



			debug_mutex_free_waiter(&waiter);
@@ -194,16 +197,28 @@ __mutex_lock_slowpath(atomic_t *lock_count) 
	__mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, 0);

}



#ifdef CONFIG_DEBUG_LOCK_ALLOC

void __sched

mutex_lock_nested(struct mutex *lock, unsigned int subclass)

{

	might_sleep();

	__mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, subclass);

}



EXPORT_SYMBOL_GPL(mutex_lock_nested);

#endif



/*

 * Release the lock, slowpath:

 */

static fastcall inline void

__mutex_unlock_common_slowpath(atomic_t *lock_count)

__mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)

{

	struct mutex *lock = container_of(lock_count, struct mutex, count);

	unsigned long flags;



	spin_lock_mutex(&lock->wait_lock, flags);

	mutex_release(&lock->dep_map, nested, _RET_IP_);

	debug_mutex_unlock(lock);



	/*
@@ -236,7 +251,7 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count) 
static fastcall noinline void

__mutex_unlock_slowpath(atomic_t *lock_count)

{

	__mutex_unlock_common_slowpath(lock_count);

	__mutex_unlock_common_slowpath(lock_count, 1);

}



/*
@@ -287,9 +302,10 @@ static inline int __mutex_trylock_slowpath(atomic_t *lock_count) 
	spin_lock_mutex(&lock->wait_lock, flags);



	prev = atomic_xchg(&lock->count, -1);

	if (likely(prev == 1))

	if (likely(prev == 1)) {

		debug_mutex_set_owner(lock, current_thread_info());



		mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);

	}

	/* Set it back to 0 if there are no waiters: */

	if (likely(list_empty(&lock->wait_list)))

		atomic_set(&lock->count, 0);

kernel/mutex.h

+1 −1
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ 
#define debug_mutex_free_waiter(waiter)			do { } while (0)

#define debug_mutex_add_waiter(lock, waiter, ti)	do { } while (0)

#define debug_mutex_unlock(lock)			do { } while (0)

#define debug_mutex_init(lock, name)			do { } while (0)

#define debug_mutex_init(lock, name, key)		do { } while (0)



static inline void

debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)