struct mutex {atomic_long_t           owner;     // mutex 获得的owner ID// 若==0, 则mutex未被占用;// 若> 0, 则mutex被此ownerId占用，// 只能由当前owner解mutexspinlock_t              wait_lock; // 自旋锁类型
#ifdef CONFIG_MUTEX_SPIN_ON_OWNERstruct optimistic_spin_queue osq;  /* Spinner MCS lock */
#endifstruct list_head        wait_list; // 等待队列
#ifdef CONFIG_DEBUG_MUTEXESvoid                    *magic;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOCstruct lockdep_map      dep_map;
#endif
};

void
__mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
{atomic_long_set(&lock->owner, 0);   // init atomic 变量 ownerspin_lock_init(&lock->wait_lock);   // init 自旋锁类型变量INIT_LIST_HEAD(&lock->wait_list);   // init 等待队列变量
#ifdef CONFIG_MUTEX_SPIN_ON_OWNERosq_lock_init(&lock->osq);
#endifdebug_mutex_init(lock, name, key);
}

void __sched mutex_lock(struct mutex *lock)
{might_sleep();                       // 打印堆栈 debug sleepif (!__mutex_trylock_fast(lock))     // atomic获得owner, 如果能__mutex_lock_slowpath(lock); //
}
EXPORT_SYMBOL(mutex_lock);
#endif

static __always_inline bool __mutex_trylock_fast(struct mutex *lock)
{ww_acquire_ctxunsigned long curr = (unsigned long)current;unsigned long zero = 0UL;if (atomic_long_try_cmpxchg_acquire(&lock->owner, &zero, curr))  // 获取ownerreturn true;return false;
}

static noinline void __sched
__mutex_lock_slowpath(struct mutex *lock)
{__mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_);  // 调用__mutex_lock
}

static int __sched
__mutex_lock(struct mutex *lock, long state, unsigned int subclass,struct lockdep_map *nest_lock, unsigned long ip)
{// 调用__mutex_lock_commonreturn __mutex_lock_common(lock, state, subclass, nest_lock, ip, NULL, false);
}

static __always_inline int __schedw
__mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,// lock TASK_UNINTERRUPTIBLE 0struct lockdep_map *nest_lock, unsigned long ip,      // NULL _RET_IP_struct ww_acquire_ctx *ww_ctx, const bool use_ww_ctx) // NULL false
{struct mutex_waiter waiter;bool first = false;struct ww_mutex *ww;     // ww = wound/wait mutex 用于死锁检验int ret;might_sleep(); // 一样的去打印context的堆栈ww = container_of(lock, struct ww_mutex, base); // 获得ww_mutexif (use_ww_ctx && ww_ctx) {                     // mutet_lock进不到这个,ww_mutex_lock有可能进if (unlikely(ww_ctx == READ_ONCE(ww->ctx))) // ww_mutex获得的ctx和需要的ctx对比return -EALREADY;/** Reset the wounded flag after a kill. No other process can* race and wound us here since they can't have a valid owner* pointer if we don't have any locks held.*/if (ww_ctx->acquired == 0)   // 如果ww_ctx没有被获得 则重设wounded 位ww_ctx->wounded = 0;}preempt_disable();  // 设置不可抢占mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip); // 检查mutex 需要的条件if (__mutex_trylock(lock) ||                                  // 尝试上lockmutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, NULL)) {  // 尝试上乐观锁/* got the lock, yay! */lock_acquired(&lock->dep_map, ip);                    // 上lockif (use_ww_ctx && ww_ctx)                             // ww_mutex_lock时ww_mutex_set_context_fastpath(ww, ww_ctx);    // 设置上下文pathpreempt_enable();                                     // 解除不可抢占return 0;}spin_lock(&lock->wait_lock); // 对等待队列上自旋锁/** After waiting to acquire the wait_lock, try again.*/if (__mutex_trylock(lock)) {                                 // 那再试试呗 hhhif (use_ww_ctx && ww_ctx)__ww_mutex_check_waiters(lock, ww_ctx);goto skip_wait;}debug_mutex_lock_common(lock, &waiter); // 掉一下debug模式下mutet_lock_commonlock_contended(&lock->dep_map, ip);     // 去等锁if (!use_ww_ctx) {                      // mutex_lock时候/* add waiting tasks to the end of the waitqueue (FIFO): */__mutex_add_waiter(lock, &waiter, &lock->wait_list); // 加到wait_queue#ifdef CONFIG_DEBUG_MUTEXESwaiter.ww_ctx = MUTEX_POISON_WW_CTX;
#endif} else {/** Add in stamp order, waking up waiters that must kill* themselves.*/ret = __ww_mutex_add_waiter(&waiter, lock, ww_ctx); // 加到ww_mutex的wait_queueif (ret)goto err_early_kill;waiter.ww_ctx = ww_ctx;}waiter.task = current;set_current_state(state);  // 设置statefor (;;) {                // 做了一个自旋操作 retry lock/** Once we hold wait_lock, we're serialized against* mutex_unlock() handing the lock off to us, do a trylock* before testing the error conditions to make sure we pick up* the handoff.*/if (__mutex_trylock(lock))  // 等到了goto acquired;/** Check for signals and kill conditions while holding* wait_lock. This ensures the lock cancellation is ordered* against mutex_unlock() and wake-ups do not go missing.*/if (unlikely(signal_pending_state(state, current))) { // if state不对ret = -EINTR;goto err;}if (use_ww_ctx && ww_ctx) {  // 如果是ww_mutex 且 wait_queue 有需要被kill掉的ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx);if (ret)goto err;}spin_unlock(&lock->wait_lock); // 解自旋锁schedule_preempt_disabled();   // 解除不可抢占/** ww_mutex needs to always recheck its position since its waiter* list is not FIFO ordered.*/if ((use_ww_ctx && ww_ctx) || !first) {first = __mutex_waiter_is_first(lock, &waiter);if (first)__mutex_set_flag(lock, MUTEX_FLAG_HANDOFF);}set_current_state(state); // update state/** Here we order against unlock; we must either see it change* state back to RUNNING and fall through the next schedule(),* or we must see its unlock and acquire.*/if (__mutex_trylock(lock) || // 再试一次(first && mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, &waiter)))break;spin_lock(&lock->wait_lock);}spin_lock(&lock->wait_lock);
acquired:__set_current_state(TASK_RUNNING);if (use_ww_ctx && ww_ctx) {/** Wound-Wait; we stole the lock (!first_waiter), check the* waiters as anyone might want to wound us.*/if (!ww_ctx->is_wait_die &&!__mutex_waiter_is_first(lock, &waiter))__ww_mutex_check_waiters(lock, ww_ctx);}mutex_remove_waiter(lock, &waiter, current); // 从等待队列中removeif (likely(list_empty(&lock->wait_list)))__mutex_clear_flag(lock, MUTEX_FLAGS); // 清除flagdebug_mutex_free_waiter(&waiter);skip_wait:/* got the lock - cleanup and rejoice! */lock_acquired(&lock->dep_map, ip);if (use_ww_ctx && ww_ctx)ww_mutex_lock_acquired(ww, ww_ctx);spin_unlock(&lock->wait_lock); // cleanuppreempt_enable();return 0;err:__set_current_state(TASK_RUNNING);mutex_remove_waiter(lock, &waiter, current);
err_early_kill:spin_unlock(&lock->wait_lock);debug_mutex_free_waiter(&waiter);mutex_release(&lock->dep_map, 1, ip);preempt_enable();return ret;
}

static inline int __raw_spin_trylock(raw_spinlock_t *lock)
{preempt_disable(); // 设置不可抢占if (do_raw_spin_trylock(lock)) {  // 尝试获得自旋锁spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); // 获得自旋锁return 1;}preempt_enable(); // 接触不可抢占return 0;
}

#define spin_acquire(l, s, t, i)                lock_acquire_exclusive(l, s, t, NULL, i)
#define lock_acquire_exclusive(l, s, t, n, i)           lock_acquire(l, s, t, 0, 1, n, i)

void lock_acquire(struct lockdep_map *lock, unsigned int subclass,int trylock, int read, int check,struct lockdep_map *nest_lock, unsigned long ip)
{unsigned long flags;if (unlikely(current->lockdep_recursion)) // 如果锁的递归深度标志位!=0return;raw_local_irq_save(flags); // 刷一下flags到diskcheck_flags(flags); // 检查flagcurrent->lockdep_recursion = 1; // 互斥trace_lock_acquire(lock, subclass, trylock, read, check, nest_lock, ip); // 追踪锁获得 打印日志__lock_acquire(lock, subclass, trylock, read, check,irqs_disabled_flags(flags), nest_lock, ip, 0, 0);  // lock acquirecurrent->lockdep_recursion = 0; // 解除互斥raw_local_irq_restore(flags); // 再刷一下flags
}
EXPORT_SYMBOL_GPL(lock_acquire);

static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,int trylock, int read, int check, int hardirqs_off,struct lockdep_map *nest_lock, unsigned long ip,int references, int pin_count)
{struct task_struct *curr = current;struct lock_class *class = NULL;struct held_lock *hlock;unsigned int depth;int chain_head = 0;int class_idx;u64 chain_key;if (subclass < NR_LOCKDEP_CACHING_CLASSES)class = lock->class_cache[subclass]; // 找到cache/** Not cached?*/if (unlikely(!class)) {class = register_lock_class(lock, subclass, 0); // 注册lockif (!class)return 0;}atomic_inc((atomic_t *)&class->ops); // 原子操作获得class 操作符if (very_verbose(class)) {printk("nacquire class [%px] %s", class->key, class->name);if (class->name_version > 1)printk(KERN_CONT "#%d", class->name_version);printk(KERN_CONT "n");dump_stack();}depth = curr->lockdep_depth;  // init depthif (DEBUG_LOCKS_WARN_ON(depth >= MAX_LOCK_DEPTH)) // stack深度溢出return 0;class_idx = class - lock_classes + 1;if (depth) {hlock = curr->held_locks + depth - 1;if (hlock->class_idx == class_idx && nest_lock) {if (hlock->references) {/** Check: unsigned int references:12, overflow.*/if (DEBUG_LOCKS_WARN_ON(hlock->references == (1 << 12)-1)) // 2^12 - 1return 0;hlock->references++;} else {hlock->references = 2;}return 1;}}hlock = curr->held_locks + depth;if (DEBUG_LOCKS_WARN_ON(!class))return 0;hlock->class_idx = class_idx; // 记录hlock信息hlock->acquire_ip = ip;hlock->instance = lock;hlock->nest_lock = nest_lock;hlock->irq_context = task_irq_context(curr);hlock->trylock = trylock;hlock->read = read;hlock->check = check;hlock->hardirqs_off = !!hardirqs_off;hlock->references = references;
#ifdef CONFIG_LOCK_STAThlock->waittime_stamp = 0;hlock->holdtime_stamp = lockstat_clock();
#endifhlock->pin_count = pin_count;if (check && !mark_irqflags(curr, hlock))return 0;/* mark it as used: */if (!mark_lock(curr, hlock, LOCK_USED))return 0;if (DEBUG_LOCKS_WARN_ON(class_idx > MAX_LOCKDEP_KEYS)) // 又溢出了return 0;chain_key = curr->curr_chain_key;if (!depth) {/** How can we have a chain hash when we ain't got no keys?!*/if (DEBUG_LOCKS_WARN_ON(chain_key != 0))return 0;chain_head = 1;}hlock->prev_chain_key = chain_key;if (separate_irq_context(curr, hlock)) {chain_key = 0;chain_head = 1;}chain_key = iterate_chain_key(chain_key, class_idx);curr->curr_chain_key = chain_key;curr->lockdep_depth++;check_chain_key(curr);return 1;
}