Glance at the code of pretty much any kernel component or driver, and, when you're new to them, the various locking APIs they routinely employ can simply overwhelm. From the famous spinlock to the newly fashionable guard locks and everything in-between: sleeping locks (the mutex and yes, even the semaphore), to spinning locks (different spinlock variations and the reader-writer locks), specialized atomic / refcount integer and bit-op RMW locking, and the subtle-yet-oh-so-powerful lock-free technologies - the per-cpu and RCU primitives. It can indeed leave one's head spinning (like a cold lock :-))!

Obviously, only when your kernel / driver code uses tight, proven and efficient locking can it be considered production-ready. Learning how to use the lock APIs isn't too difficult; more importantly, we need to understand the _why and when_ of using different lock types, and their performance characteristics, given the circumstances. This talk attempts to throw some perhaps much-needed light on this key area.

Time permitting, can also delves into how exactly we identify whether a code path requires locking, whether it is or isn't a critical section; it's important we get it right!