LOCKDEP, AN INSIDE OUT PERSPECTIVE. Nahim El

Transcription

1 LOCKDEP, AN INSIDE OUT PERSPECTIVE Nahim El

2 P1 R1 R1 P2 THE BIG PICTURE The need for a proof mechanism

3 PREVIOUSLY ON LINUX SMP Synchronization needed giant-lock (a.k.a big-lock, kernel-lock ) managing lock is challenging

4 ON THIS EPISODE SMP Synchronization needed giant-lock (a.k.a big-lock, kernel-lock ) managing lock is challenging

5 LOCKING IN LINUX «BKL: That's all, folks» (merged rc5-mm1): 4ba8216c Spinlocks Mutex Semaphores RCU...

6 [lockdep is a] complex infrastructure to the kernel which can then be used to prove that none of the locking patterns observed in a running system could ever deadlock the kernel. -- LWN

7 PROVE_LOCKING DEBUG_SPINLOCK DEBUG_MUTEX LOCKDEP DEBUG_LOCK_ALLOC TRACE_IRQFLAGS This feature allows mutex semantics violations to be detected and reported. Checks whether any held lock (spinlock, rwlock, mutex or rwsem) is incorrectly freed by the kernel, whether a live lock is incorrectly reinitialized, or whether there is any lock held during task exit. Catches missing spinlock initialization and certain other kinds of spinlock errors commonly made. Loads all symbols into the kernel image (e.g: functions + variable names ). Create /proc/pid/stack that shows current stack trace used for stack trace generation. Also activate frame pointers. Enables hooks to interrupt enabling and disabling for either tracing or lock debugging.

8 PROOF MECHANISM

9 LOCK STATES Locks can be: 'ever held in STATE context' 'ever held as readlock in STATE context' 'ever held with STATE enabled' 'ever held as readlock with STATE enabled' STATE can be: hardirq (safe, unsafe) softirq (safe, unsafe) reclaim_fs ever used

10 MUTUAL EXCLUSIONS hardirq-safe hardirq-unsafe unused softirq-safe softirq-unsafe

11 IMPLEMENTATION What is the glue to all of this?

12 RUNTIME MAPPING typedef struct raw_spinlock { arch_spinlock_t raw_lock; #ifdef CONFIG_GENERIC_LOCKBREAK unsigned int break_lock; #endif #ifdef CONFIG_DEBUG_SPINLOCK unsigned int magic, owner_cpu; void *owner; #endif #ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map dep_map; #endif } raw_spinlock_t; /* * Map the lock object (the lock instance) to the lock-class object. * This is embedded into specific lock instances: */ struct lockdep_map { struct lock_class_key *key; struct lock_class *class_cache[nr_lockdep_caching_classes]; const char *name; #ifdef CONFIG_LOCK_STAT int cpu; #endif }; unsigned long ip; # define raw_spin_lock_init(lock) \ do { \ static struct lock_class_key key; \ \ raw_spin_lock_init((lock), #lock, & key); \ } while (0) void raw_spin_lock_init(raw_spinlock_t *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, 0); #endif

13 LOCK-CLASSES struct lock_class { struct hlist_node hash_entry; /* class-hash: */ struct list_head lock_entry; /* global list of all lock-classes */ struct lockdep_subclass_key *key; unsigned int subclass; unsigned int dep_gen_id; unsigned long usage_mask; /* IRQ/softirq usage tracking bits */ struct stack_trace usage_traces[xxx_lock_usage_states]; /* * These fields represent a directed graph of lock dependencies, * to every node we attach a list of "forward" and a list of * "backward" graph nodes. */ struct list_head locks_after, locks_before; /* * Generation counter, when doing certain classes of graph walking, * to ensure that we check one node only once: */ unsigned int version; unsigned long ops; /* Statistics counter */ const char *name; int name_version; #ifdef CONFIG_LOCK_STAT unsigned long contention_point[lockstat_points]; #endif }; unsigned long contending_point[lockstat_points]; /* * Lock-class usage-state bits: */ enum lock_usage_bit { #define LOCKDEP_STATE( STATE) \ LOCK_USED_IN_## STATE, \ LOCK_USED_IN_## STATE##_READ, \ LOCK_ENABLED_## STATE, \ LOCK_ENABLED_## STATE##_READ, #include "lockdep_states.h" #undef LOCKDEP_STATE LOCK_USED, LOCK_USAGE_STATES }; LOCKDEP_STATE(HARDIRQ) LOCKDEP_STATE(SOFTIRQ) LOCKDEP_STATE(RECLAIM_FS)

14 lock instance lockdep_map lock_class lock instance lockdep_map... Hash Table access Class / Instance relationship for a lock-type

15 LOCK INSTANCE API Each lock call a generic lock_acquire() check for flags (states) are done in the acquire if wrong state report with full debug info (call stack + symbols + faulty state)

16 OUTPUT modprobe/2287 is trying to acquire lock: (&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 '.' acquired while irqs disabled and not in irq context '-' acquired in irq context '+' acquired with irqs enabled '?' acquired in irq context with irqs enabled.

17 Are we done? We still need to prove the states transition

18 when a process do a lock_acquire() operation a held_lock is added to the stack of current task s held lock this lock is filled using mark_irqflags() which check for locking context using current (get_current()) hash table based transactions

19 CHAIN VALIDATION check that we are holding such a class already, if yes that s a (potential) deadlock. any lock released should be at the top of the maintained lock stack spinlock acquired by Hw interrupt handler can not be held while interrupt are on same for soft interrupt

20 CONCLUSION nothing you can t find in the following references trivial to use but overall design is quite tricky answered the need for a flawless logical proof of work instead of devs intuition and tests

21 RESOURCES Documentation/locking/lockdep-design.txt include/linux/*lock*.h kernel/locking/*lock*.c

22 THANKS! Any questions? You can find me naam{at}lse{dot}epita{dot}fr