Commit c4e1aa67 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

* 'locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (33 commits)
  lockdep: fix deadlock in lockdep_trace_alloc
  lockdep: annotate reclaim context (__GFP_NOFS), fix SLOB
  lockdep: annotate reclaim context (__GFP_NOFS), fix
  lockdep: build fix for !PROVE_LOCKING
  lockstat: warn about disabled lock debugging
  lockdep: use stringify.h
  lockdep: simplify check_prev_add_irq()
  lockdep: get_user_chars() redo
  lockdep: simplify get_user_chars()
  lockdep: add comments to mark_lock_irq()
  lockdep: remove macro usage from mark_held_locks()
  lockdep: fully reduce mark_lock_irq()
  lockdep: merge the !_READ mark_lock_irq() helpers
  lockdep: merge the _READ mark_lock_irq() helpers
  lockdep: simplify mark_lock_irq() helpers #3
  lockdep: further simplify mark_lock_irq() helpers
  lockdep: simplify the mark_lock_irq() helpers
  lockdep: split up mark_lock_irq()
  lockdep: generate usage strings
  lockdep: generate the state bit definitions
  ...
parents cf2f7d7c 2f850181

Documentation/lockdep-design.txt

+17 −13
Original line number Diff line number Diff line
@@ -27,33 +27,37 @@ lock-class. 
State

-----



The validator tracks lock-class usage history into 5 separate state bits:

The validator tracks lock-class usage history into 4n + 1 separate state bits:



- 'ever held in hardirq context'                    [ == hardirq-safe   ]

- 'ever held in softirq context'                    [ == softirq-safe   ]

- 'ever held with hardirqs enabled'                 [ == hardirq-unsafe ]

- 'ever held with softirqs and hardirqs enabled'    [ == softirq-unsafe ]

- 'ever held in STATE context'

- 'ever head as readlock in STATE context'

- 'ever head with STATE enabled'

- 'ever head as readlock with STATE enabled'



Where STATE can be either one of (kernel/lockdep_states.h)

 - hardirq

 - softirq

 - reclaim_fs



- 'ever used'                                       [ == !unused        ]



When locking rules are violated, these 4 state bits are presented in the

When locking rules are violated, these state bits are presented in the

locking error messages, inside curlies. A contrived example:



   modprobe/2287 is trying to acquire lock:

    (&sio_locks[i].lock){--..}, at: [<c02867fd>] mutex_lock+0x21/0x24

    (&sio_locks[i].lock){-.-...}, at: [<c02867fd>] mutex_lock+0x21/0x24



   but task is already holding lock:

    (&sio_locks[i].lock){--..}, at: [<c02867fd>] mutex_lock+0x21/0x24

    (&sio_locks[i].lock){-.-...}, at: [<c02867fd>] mutex_lock+0x21/0x24





The bit position indicates hardirq, softirq, hardirq-read,

softirq-read respectively, and the character displayed in each

indicates:

The bit position indicates STATE, STATE-read, for each of the states listed

above, and the character displayed in each indicates:



   '.'  acquired while irqs disabled

   '+'  acquired in irq context

   '-'  acquired with irqs enabled

   '?' read acquired in irq context with irqs enabled.

   '?'  acquired in irq context with irqs enabled.



Unused mutexes cannot be part of the cause of an error.

include/linux/lockdep.h

+12 −38
Original line number Diff line number Diff line
@@ -20,43 +20,10 @@ struct lockdep_map; 
#include <linux/stacktrace.h>



/*

 * Lock-class usage-state bits:

 * We'd rather not expose kernel/lockdep_states.h this wide, but we do need

 * the total number of states... :-(

 */

enum lock_usage_bit

{

	LOCK_USED = 0,

	LOCK_USED_IN_HARDIRQ,

	LOCK_USED_IN_SOFTIRQ,

	LOCK_ENABLED_SOFTIRQS,

	LOCK_ENABLED_HARDIRQS,

	LOCK_USED_IN_HARDIRQ_READ,

	LOCK_USED_IN_SOFTIRQ_READ,

	LOCK_ENABLED_SOFTIRQS_READ,

	LOCK_ENABLED_HARDIRQS_READ,

	LOCK_USAGE_STATES

};



/*

 * Usage-state bitmasks:

 */

#define LOCKF_USED			(1 << LOCK_USED)

#define LOCKF_USED_IN_HARDIRQ		(1 << LOCK_USED_IN_HARDIRQ)

#define LOCKF_USED_IN_SOFTIRQ		(1 << LOCK_USED_IN_SOFTIRQ)

#define LOCKF_ENABLED_HARDIRQS		(1 << LOCK_ENABLED_HARDIRQS)

#define LOCKF_ENABLED_SOFTIRQS		(1 << LOCK_ENABLED_SOFTIRQS)



#define LOCKF_ENABLED_IRQS (LOCKF_ENABLED_HARDIRQS | LOCKF_ENABLED_SOFTIRQS)

#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)



#define LOCKF_USED_IN_HARDIRQ_READ	(1 << LOCK_USED_IN_HARDIRQ_READ)

#define LOCKF_USED_IN_SOFTIRQ_READ	(1 << LOCK_USED_IN_SOFTIRQ_READ)

#define LOCKF_ENABLED_HARDIRQS_READ	(1 << LOCK_ENABLED_HARDIRQS_READ)

#define LOCKF_ENABLED_SOFTIRQS_READ	(1 << LOCK_ENABLED_SOFTIRQS_READ)



#define LOCKF_ENABLED_IRQS_READ \

		(LOCKF_ENABLED_HARDIRQS_READ | LOCKF_ENABLED_SOFTIRQS_READ)

#define LOCKF_USED_IN_IRQ_READ \

		(LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)

#define XXX_LOCK_USAGE_STATES		(1+3*4)



#define MAX_LOCKDEP_SUBCLASSES		8UL
@@ -97,7 +64,7 @@ struct lock_class { 
	 * IRQ/softirq usage tracking bits:

	 */

	unsigned long			usage_mask;

	struct stack_trace		usage_traces[LOCK_USAGE_STATES];

	struct stack_trace		usage_traces[XXX_LOCK_USAGE_STATES];



	/*

	 * These fields represent a directed graph of lock dependencies,
@@ -324,7 +291,11 @@ static inline void lock_set_subclass(struct lockdep_map *lock, 
	lock_set_class(lock, lock->name, lock->key, subclass, ip);

}



# define INIT_LOCKDEP				.lockdep_recursion = 0,

extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);

extern void lockdep_clear_current_reclaim_state(void);

extern void lockdep_trace_alloc(gfp_t mask);



# define INIT_LOCKDEP				.lockdep_recursion = 0, .lockdep_reclaim_gfp = 0,



#define lockdep_depth(tsk)	(debug_locks ? (tsk)->lockdep_depth : 0)
@@ -342,6 +313,9 @@ static inline void lockdep_on(void) 
# define lock_release(l, n, i)			do { } while (0)

# define lock_set_class(l, n, k, s, i)		do { } while (0)

# define lock_set_subclass(l, s, i)		do { } while (0)

# define lockdep_set_current_reclaim_state(g)	do { } while (0)

# define lockdep_clear_current_reclaim_state()	do { } while (0)

# define lockdep_trace_alloc(g)			do { } while (0)

# define lockdep_init()				do { } while (0)

# define lockdep_info()				do { } while (0)

# define lockdep_init_map(lock, name, key, sub) \

include/linux/mutex.h

+3 −2
Original line number Diff line number Diff line
@@ -50,8 +50,10 @@ struct mutex { 
	atomic_t		count;

	spinlock_t		wait_lock;

	struct list_head	wait_list;

#ifdef CONFIG_DEBUG_MUTEXES

#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)

	struct thread_info	*owner;

#endif

#ifdef CONFIG_DEBUG_MUTEXES

	const char 		*name;

	void			*magic;

#endif
@@ -68,7 +70,6 @@ struct mutex_waiter { 
	struct list_head	list;

	struct task_struct	*task;

#ifdef CONFIG_DEBUG_MUTEXES

	struct mutex		*lock;

	void			*magic;

#endif

};

include/linux/sched.h

+3 −0
Original line number Diff line number Diff line
@@ -331,7 +331,9 @@ extern signed long schedule_timeout(signed long timeout); 
extern signed long schedule_timeout_interruptible(signed long timeout);

extern signed long schedule_timeout_killable(signed long timeout);

extern signed long schedule_timeout_uninterruptible(signed long timeout);

asmlinkage void __schedule(void);

asmlinkage void schedule(void);

extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);



struct nsproxy;

struct user_namespace;
@@ -1334,6 +1336,7 @@ struct task_struct { 
	int lockdep_depth;

	unsigned int lockdep_recursion;

	struct held_lock held_locks[MAX_LOCK_DEPTH];

	gfp_t lockdep_reclaim_gfp;

#endif



/* journalling filesystem info */

include/linux/timer.h

+84 −9
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#include <linux/ktime.h>

#include <linux/stddef.h>

#include <linux/debugobjects.h>

#include <linux/stringify.h>



struct tvec_base;
@@ -21,52 +22,126 @@ struct timer_list { 
	char start_comm[16];

	int start_pid;

#endif

#ifdef CONFIG_LOCKDEP

	struct lockdep_map lockdep_map;

#endif

};



extern struct tvec_base boot_tvec_bases;



#ifdef CONFIG_LOCKDEP

/*

 * NB: because we have to copy the lockdep_map, setting the lockdep_map key

 * (second argument) here is required, otherwise it could be initialised to

 * the copy of the lockdep_map later! We use the pointer to and the string

 * "<file>:<line>" as the key resp. the name of the lockdep_map.

 */

#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)				\

	.lockdep_map = STATIC_LOCKDEP_MAP_INIT(_kn, &_kn),

#else

#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)

#endif



#define TIMER_INITIALIZER(_function, _expires, _data) {		\

		.entry = { .prev = TIMER_ENTRY_STATIC },	\

		.function = (_function),			\

		.expires = (_expires),				\

		.data = (_data),				\

		.base = &boot_tvec_bases,			\

		__TIMER_LOCKDEP_MAP_INITIALIZER(		\

			__FILE__ ":" __stringify(__LINE__))	\

	}



#define DEFINE_TIMER(_name, _function, _expires, _data)		\

	struct timer_list _name =				\

		TIMER_INITIALIZER(_function, _expires, _data)



void init_timer(struct timer_list *timer);

void init_timer_deferrable(struct timer_list *timer);

void init_timer_key(struct timer_list *timer,

		    const char *name,

		    struct lock_class_key *key);

void init_timer_deferrable_key(struct timer_list *timer,

			       const char *name,

			       struct lock_class_key *key);



#ifdef CONFIG_LOCKDEP

#define init_timer(timer)						\

	do {								\

		static struct lock_class_key __key;			\

		init_timer_key((timer), #timer, &__key);		\

	} while (0)



#define init_timer_deferrable(timer)					\

	do {								\

		static struct lock_class_key __key;			\

		init_timer_deferrable_key((timer), #timer, &__key);	\

	} while (0)



#define init_timer_on_stack(timer)					\

	do {								\

		static struct lock_class_key __key;			\

		init_timer_on_stack_key((timer), #timer, &__key);	\

	} while (0)



#define setup_timer(timer, fn, data)					\

	do {								\

		static struct lock_class_key __key;			\

		setup_timer_key((timer), #timer, &__key, (fn), (data));\

	} while (0)



#define setup_timer_on_stack(timer, fn, data)				\

	do {								\

		static struct lock_class_key __key;			\

		setup_timer_on_stack_key((timer), #timer, &__key,	\

					 (fn), (data));			\

	} while (0)

#else

#define init_timer(timer)\

	init_timer_key((timer), NULL, NULL)

#define init_timer_deferrable(timer)\

	init_timer_deferrable_key((timer), NULL, NULL)

#define init_timer_on_stack(timer)\

	init_timer_on_stack_key((timer), NULL, NULL)

#define setup_timer(timer, fn, data)\

	setup_timer_key((timer), NULL, NULL, (fn), (data))

#define setup_timer_on_stack(timer, fn, data)\

	setup_timer_on_stack_key((timer), NULL, NULL, (fn), (data))

#endif



#ifdef CONFIG_DEBUG_OBJECTS_TIMERS

extern void init_timer_on_stack(struct timer_list *timer);

extern void init_timer_on_stack_key(struct timer_list *timer,

				    const char *name,

				    struct lock_class_key *key);

extern void destroy_timer_on_stack(struct timer_list *timer);

#else

static inline void destroy_timer_on_stack(struct timer_list *timer) { }

static inline void init_timer_on_stack(struct timer_list *timer)

static inline void init_timer_on_stack_key(struct timer_list *timer,

					   const char *name,

					   struct lock_class_key *key)

{

	init_timer(timer);

	init_timer_key(timer, name, key);

}

#endif



static inline void setup_timer(struct timer_list * timer,

static inline void setup_timer_key(struct timer_list * timer,

				const char *name,

				struct lock_class_key *key,

				void (*function)(unsigned long),

				unsigned long data)

{

	timer->function = function;

	timer->data = data;

	init_timer(timer);

	init_timer_key(timer, name, key);

}



static inline void setup_timer_on_stack(struct timer_list *timer,

static inline void setup_timer_on_stack_key(struct timer_list *timer,

					const char *name,

					struct lock_class_key *key,

					void (*function)(unsigned long),

					unsigned long data)

{

	timer->function = function;

	timer->data = data;

	init_timer_on_stack(timer);

	init_timer_on_stack_key(timer, name, key);

}



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE