基于linux-5.10.66
一、相关结构
1. rwsem 表示结构体 struct rw_semaphore
/* * 对于无竞争的 rwsem，count 和 owner 是任务在获取 rwsem 时需要触及的唯一字段。 * 因此，它们彼此相邻放置，以增加它们共享相同cacheline的机会。 * * 在竞争 rwsem 中，owner 可能是此结构中最常访问的字段，因为持有 osq 锁的乐观 * 等待者将在 owner 上自旋。 对于嵌入的 rwsem，上层结构中的其它热字段应远离rwsem， * 以减少它们共享相同cacheline导致cacheline弹跳问题的机会。 */ struct rw_semaphore { /* 计数和位掩码组成 */ atomic_long_t count; /* task_struct指针值和位掩码组成 */ atomic_long_t owner; #ifdef CONFIG_RWSEM_SPIN_ON_OWNER //默认不使能 struct optimistic_spin_queue osq; /* spinner MCS lock */ #endif /* wait_lock 用于保护wait_list成员 */ raw_spinlock_t wait_lock; struct list_head wait_list; #ifdef CONFIG_DEBUG_RWSEMS //默认不使能 void *magic; #endif #ifdef CONFIG_DEBUG_LOCK_ALLOC //默认不使能 struct lockdep_map dep_map; #endif ANDROID_VENDOR_DATA(1); //u64 android_vendor_data1; ANDROID_OEM_DATA_ARRAY(1, 2); //u64 android_oem_data1[2]; };
成员介绍：
(1) count
/* * Bit 0 - writer locked bit * Bit 1 - waiters present bit * Bit 2 - lock handoff bit * Bits 3-7 - reserved * Bits 8-62 - 55-bit reader count * Bit 63 - read fail bit */ #define RWSEM_WRITER_LOCKED (1UL << 0) //标记有writer在临界区 #define RWSEM_FLAG_WAITERS (1UL << 1) //标记是否有waiter在等待队列上等待 #define RWSEM_FLAG_HANDOFF (1UL << 2) #define RWSEM_FLAG_READFAIL (1UL << (BITS_PER_LONG - 1)) //1<<63 最高bit位为1。表示在临界区的reader太多，计数溢出 #define RWSEM_READER_SHIFT 8 #define RWSEM_READER_BIAS (1UL << RWSEM_READER_SHIFT) //1<<8，在临界区的reader从此bit开始加1计数 #define RWSEM_READER_MASK (~(RWSEM_READER_BIAS - 1)) //低8bit清0，其它bit全为1 #define RWSEM_WRITER_MASK RWSEM_WRITER_LOCKED //1<<0 #define RWSEM_LOCK_MASK (RWSEM_WRITER_MASK|RWSEM_READER_MASK) //(1<<0)|(低8bit清0，其它bit全为1) 表示是否有writer或reader在临界区中 //只要sem->count 和其与不为0，reader就不能走快速路径持锁 #define RWSEM_READ_FAILED_MASK (RWSEM_WRITER_MASK|RWSEM_FLAG_WAITERS|RWSEM_FLAG_HANDOFF|RWSEM_FLAG_READFAIL) //(1<<0)|(1<<1)|(1<<2)|(1<<63)
RWSEM_FLAG_READFAIL: 最高有效位（读取失败位）不太可能被设置。 无论如何，在 down_read() 快速路径中仍会检查此保护位，以防我们将来需要将更多reader位用于其他目的。
RWSEM_READ_FAILED_MASK: reader获取锁时若sem->count中包含其内的任意一个掩码，就无法走快速获取获取读锁。
RWSEM_FLAG_HANDOFF: 可以设置或清除handoff标志位的三个位置。
1) rwsem_mark_wake() 读者使用的此函数。
2) rwsem_try_write_lock() 写者使用的此函数。
3) rwsem_down_write_slowpath() 中的错误路径。
对于上述所有情况，wait_lock 都会被持有。writer还必须是 wait_list 中第一个waiter以便可以设置handoff bit位。 因此无法同时设置/清除handoff bit位。
(2) owner
由于至少是8字节对齐，owner的低3bit可以另做它用，如下。其它bit位保存的是持有此rwsem的task_struct结构。
#define RWSEM_READER_OWNED (1UL << 0) // The rwsem is owned by readers #define RWSEM_RD_NONSPINNABLE (1UL << 1) // Readers cannot spin on this lock #define RWSEM_WR_NONSPINNABLE (1UL << 2) // Writers cannot spin on this locks #define RWSEM_NONSPINNABLE (RWSEM_RD_NONSPINNABLE | RWSEM_WR_NONSPINNABLE) //(1<<1)|(1<<2) #define RWSEM_OWNER_FLAGS_MASK (RWSEM_READER_OWNED | RWSEM_NONSPINNABLE) //(1<<0)|(1<<1)|(1<<2)
只有 reader_owned 宏，没有 writer_owned 宏。有设置这个 reader_owned 的逻辑，设置位置为reader持锁进入临界区的位置，但是没有直接清
理这个 reader_owned 的逻辑，但是不需要做额外的清理动作，因为writer持锁时rwsem_set_owner() 中直接 sem->owner = current 进行赋值，
会清理掉reader_owner标志位。
对于多个reader持锁进入临界区，owner保存的是最后一个进入临界区的reader的task_struct结构指针。
(3) wait_list
等待队列，当reader或writer获取不到rwsem而阻塞时，会挂载此链表上。默认是尾插法，从头部唤醒，当做一个队列来使用了。
2. rwsem 等待者结构 rwsem_waiter
struct rwsem_waiter { /* 通过此成员挂载 rwsem->wait_list 链表上 */ struct list_head list; /* waiter的 task_struct 结构 */ struct task_struct *task; /* 标记是reader还是writer，分别取值为 RWSEM_WAITING_FOR_READ/RWSEM_WAITING_FOR_WRITE */ enum rwsem_waiter_type type; /* 挂入等待链表之前设置，通常是4ms */ unsigned long timeout; /* 上一个reader owner */ unsigned long last_rowner; };
二、相关函数
1. 初始化函数
/* 初始化宏，将 sem->count 设置为 RWSEM_UNLOCKED_VALUE(8), 将 sem->owner 设置为0 */ init_rwsem(sem)
2. 获取读sem
/* 阻塞时是 TASK_UNINTERRUPTIBLE 状态 */ void __sched down_read(struct rw_semaphore *sem); /* 阻塞时是 TASK_INTERRUPTIBLE 状态，writer没有类似接口 */ int __sched down_read_interruptible(struct rw_semaphore *sem) /* 阻塞时是 TASK_KILLABLE 状态 */ int __sched down_read_killable(struct rw_semaphore *sem) /* 尝试获取读锁，不会阻塞，成功获取返回1，失败返回0 */ int down_read_trylock(struct rw_semaphore *sem)
3. 获取写sem
/* 阻塞时是 TASK_UNINTERRUPTIBLE 状态 */ void __sched down_write(struct rw_semaphore *sem) /* 阻塞时是 TASK_KILLABLE 状态 */ int __sched down_write_killable(struct rw_semaphore *sem) /* 尝试获取写锁，不会阻塞，成功获取返回1，失败返回0 */ int down_write_trylock(struct rw_semaphore *sem)
4. 释放读sem
void up_read(struct rw_semaphore *sem)
5. 释放写sem
void up_write(struct rw_semaphore *sem)
可见rwsem只是一个二值信号量，不支持递归获取，获取不到要进入休眠。
三、获取读信号流程
1. down_read
void __sched down_read(struct rw_semaphore *sem) { might_sleep(); /* 若没有使能 CONFIG_LOCKDEP 就是空函数，默认不使能的 */ rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_); /* 若没有使能 CONFIG_LOCK_STAT 就等于 __down_read(sem) */ LOCK_CONTENDED(sem, __down_read_trylock, __down_read); } static inline void __down_read(struct rw_semaphore *sem) { /* * 先执行尝试获取信号量，若获取不到再进入慢速路径，若获取 * 到了就将sem->owner设置为当前线程。 */ if (!rwsem_read_trylock(sem)) { rwsem_down_read_slowpath(sem, TASK_UNINTERRUPTIBLE); /*若不使能 CONFIG_DEBUG_RWSEMS 就是空函数，默认不使能 */ DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); } else { rwsem_set_reader_owned(sem); } }
走慢速路径之前会调用一次 rwsem_read_trylock() 尝试获取锁，若获取不到就会走慢速路径，获取到后走快速路径。
(1) rwsem_read_trylock(sem) 判断是否能持有读取锁
/* 这个函数只是一个判断，能成功持锁返回1，否则返回0 */ static inline bool rwsem_read_trylock(struct rw_semaphore *sem) { /* 作用：sem->count += RWSEM_READER_BIAS */ long cnt = atomic_long_add_return_acquire(RWSEM_READER_BIAS, &sem->count); /* * 最高bit位为1才会小于0, RWSEM_FLAG_READFAIL 是bit63,但是没有使用过， * 这里应该只是表示reader持锁个数已经导致bit位溢出，应该不会发生这种情况。 */ if (WARN_ON_ONCE(cnt < 0)) rwsem_set_nonspinnable(sem); /* 只要这些标志中sem->count中有1个，reader就不能在快速路径中获取到锁 */ return !(cnt & RWSEM_READ_FAILED_MASK); }
若此时已经有 writer 在临界区了，也就是说 cnt 中包含了 RWSEM_READ_FAILED_MASK 中的 RWSEM_WRITER_MASK，reader 就无法走快速路径获取到锁了，而是要挂到等待链表中等待。
可以再看下面 RWSEM_READ_FAILED_MASK 的定义，只要有writer在临界区、有waiter在等待、写者持锁慢速路径中对wait状态的写者标记了handoff、写者标记了handoff、reader等待的太多(bit63==1)，读者都不能走快速路径持锁。
(2) rwsem_set_reader_owned(sem) 持锁快速路径
reader持锁，在sem->owner上或上 RWSEM_READER_OWNED 并保留owner中原来的 RWSEM_RD_NONSPINNABLE 位的值。最后一个持锁的reader才会将其task_struct结构指针设置到sem->owner中。
static inline void rwsem_set_reader_owned(struct rw_semaphore *sem) { __rwsem_set_reader_owned(sem, current); } /* * 最后拥有的 reader 的 task_struct 指针将留在 owner 字段中。 * * 请注意，owner 的值仅表示该任务之前拥有了该 rwsem，当检查该字段时，它可能不 * 再是真正的所有者或真正的所有者之一，因此请谨慎对待。 * * reader的non-spinnable bit位被保留下来。 * * 传参：owner = current * 作用：sem->owner = owner | RWSEM_READER_OWNED | (sem->owner & RWSEM_RD_NONSPINNABLE) */ static inline void __rwsem_set_reader_owned(struct rw_semaphore *sem, struct task_struct *owner) { unsigned long val = (unsigned long)owner | RWSEM_READER_OWNED | (atomic_long_read(&sem->owner) & RWSEM_RD_NONSPINNABLE); atomic_long_set(&sem->owner, val); }
(3) rwsem_down_read_slowpath(sem, TASK_UNINTERRUPTIBLE) 持读取锁的慢速路径
/* * Wait for the read lock to be granted. * __down_read()传参：(sem, TASK_UNINTERRUPTIBLE) */ static struct rw_semaphore __sched * rwsem_down_read_slowpath(struct rw_semaphore *sem, int state) { /* 每增加一个等待的reader就从bit8的reader计算bit位开始增加1 */ long count, adjustment = -RWSEM_READER_BIAS; struct rwsem_waiter waiter; DEFINE_WAKE_Q(wake_q); bool wake = false; bool already_on_list = false; /* * Save the current read-owner of rwsem, if available, and the * reader nonspinnable bit. * 先将 sem->owner 保存到 waiter.last_rowner。在reader的持锁快速路径中 * sem->owner 保存的是最后一个持读取锁的reader. */ waiter.last_rowner = atomic_long_read(&sem->owner); /* * 在reader快速路径持锁时，都会 sem->owner 都会或上 RWSEM_READER_OWNED * 标志。若没有此标志说明上次reader已经不是走快速路径持锁的了。此时 * waiter.last_rowner 中只保留 RWSEM_RD_NONSPINNABLE bit位的值【为啥？ * 此bit在默认deconfig下是否有使用 ？】。 */ if (!(waiter.last_rowner & RWSEM_READER_OWNED)) waiter.last_rowner &= RWSEM_RD_NONSPINNABLE; /* 默认没有使能 CONFIG_RWSEM_SPIN_ON_OWNER，此函数恒返回0 */ if (!rwsem_can_spin_on_owner(sem, RWSEM_RD_NONSPINNABLE)) goto queue; .... queue: /* 标记waiter的线程、类型、超时时间【超时时间怎么使用？】 */ waiter.task = current; waiter.type = RWSEM_WAITING_FOR_READ; waiter.timeout = jiffies + RWSEM_WAIT_TIMEOUT; //jiffies+1, 即是4ms raw_spin_lock_irq(&sem->wait_lock); if (list_empty(&sem->wait_list)) { /* * 翻译：如果等待队列为空，并且锁没有被writer持有或handoff位未被设置， * 则此reader可以退出慢速路径并立即返回，因为其 RWSEM_READER_BIAS * 位已被设置到count成员中【什么时候设置进去的？】。 * * 默认配置下 adjustment = -RWSEM_READER_BIAS 恒成立。 * 没有 writer 持锁，且没有指定 handoff。 */ if (adjustment && !(atomic_long_read(&sem->count) & (RWSEM_WRITER_MASK | RWSEM_FLAG_HANDOFF))) { /* Provide lock ACQUIRE */ smp_acquire__after_ctrl_dep(); //只是smp_rmb() raw_spin_unlock_irq(&sem->wait_lock); /* * 将current线程当做reader设置进sem->owner中，然后就返回了。 * 这体现了多个reader可以同时获取锁。 */ rwsem_set_reader_owned(sem); /* CONFIG_LOCK_EVENT_COUNTS 默认没有使能，是空函数 */ lockevent_inc(rwsem_rlock_fast); return sem; } /* 等待链表为空，但是有writer持锁或指定了handoff bit位，准备好有waiter等待bit位 */ adjustment += RWSEM_FLAG_WAITERS; } /*----下面就是等待链表不为空(有writer持锁或指定了handoff标志)的处理情况了----*/ trace_android_vh_alter_rwsem_list_add(&waiter, sem, &already_on_list); if (!already_on_list) /* 默认逻辑是添加到等待队列的尾部 */ list_add_tail(&waiter.list, &sem->wait_list); /* we're now waiting on the lock, but no longer actively locking */ if (adjustment) /* * 相当于 sem->count = sem->count - RWSEM_READER_BIAS + RWSEM_FLAG_WAITERS * 减去 RWSEM_READER_BIAS 应该是因为在前面的trey_lock中加了。多了一个waiter。 */ count = atomic_long_add_return(adjustment, &sem->count); else count = atomic_long_read(&sem->count); //不会执行到 /* * 翻译： * 如果没有处于active状态的锁，唤醒排队前面的任务。 * 如果没有writers并且我们排在队列的首位，唤醒我们自己的waiter加入现有的活跃readers！ * active 锁应该表示获取不到sem而挂在等待链表上的reader和writer. */ if (!(count & RWSEM_LOCK_MASK)) { /* 没有使能 CONFIG_RWSEM_SPIN_ON_OWNER, 是个空函数 */ clear_wr_nonspinnable(sem); wake = true; } /* * 若没有writer持锁，并且sem->wait_list链表为空(adjustment中有RWSEM_FLAG_WAITERS * bit位表示), 那么就标记要唤醒的任务。 */ if (wake || (!(count & RWSEM_WRITER_MASK) && (adjustment & RWSEM_FLAG_WAITERS))) rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q); /*-又重新看了-*/ trace_android_vh_rwsem_wake(sem); raw_spin_unlock_irq(&sem->wait_lock); /* 唤醒queue入等待队列中的任务 */ wake_up_q(&wake_q); /* 这不是睡眠吗，，为啥执行起了唤醒逻辑？*/ /* ----下面就是有writer持有信号量，reader要进入休眠的情况了---- */ /* wait to be given the lock */ trace_android_vh_rwsem_read_wait_start(sem); for (;;) { /* __down_read()传参：state == TASK_UNINTERRUPTIBLE) */ set_current_state(state); /* 如果 waiter.task 为空，退出死循环 */ if (!smp_load_acquire(&waiter.task)) { /* Matches rwsem_mark_wake()'s smp_store_release(). */ break; } /* 若传参state==TASK_UNINTERRUPTIBLE，这里不可能为真 */ if (signal_pending_state(state, current)) { raw_spin_lock_irq(&sem->wait_lock); if (waiter.task) goto out_nolock; raw_spin_unlock_irq(&sem->wait_lock); /* Ordered by sem->wait_lock against rwsem_mark_wake(). */ break; } schedule(); lockevent_inc(rwsem_sleep_reader); } __set_current_state(TASK_RUNNING); trace_android_vh_rwsem_read_wait_finish(sem); lockevent_inc(rwsem_rlock); /* 获得到信号量之后的返回值 */ return sem; out_nolock: //被信号唤醒走这里 list_del(&waiter.list); if (list_empty(&sem->wait_list)) { atomic_long_andnot(RWSEM_FLAG_WAITERS|RWSEM_FLAG_HANDOFF, &sem->count); } raw_spin_unlock_irq(&sem->wait_lock); __set_current_state(TASK_RUNNING); trace_android_vh_rwsem_read_wait_finish(sem); lockevent_inc(rwsem_rlock_fail); /* 被信号唤醒时的返回值 */ return ERR_PTR(-EINTR); }
在获取不到信号量，进入休眠之前，还尝试标记唤醒。
rwsem_mark_wake() 函数：
/* * 翻译： * 当被阻塞的线程可以运行时处理释放锁的逻辑： * - 如果我们从 up_xxxx() 来到这里，那么 RWSEM_FLAG_WAITERS 位必须已被设置。 * - 队列中必须有排队的任务 * - wait_lock 必须被调用者持有 * - 任务标记唤醒，调用者必须稍后调用 wake_up_q() 来唤醒阻塞的任务，并降低引用计数，最好是在释放 wait_lock 时做。 * - 任务归零后被唤醒的任务从链表中删除 * - 只有当降级为假时，writers才会被标记为唤醒 */ /* rwsem_down_read_slowpath()传参：(sem, RWSEM_WAKE_ANY, &wake_q) */ static void rwsem_mark_wake(struct rw_semaphore *sem, enum rwsem_wake_type wake_type, struct wake_q_head *wake_q) { struct rwsem_waiter *waiter, *tmp; long oldcount, woken = 0, adjustment = 0; struct list_head wlist; lockdep_assert_held(&sem->wait_lock); /* * 翻译：获取队列头部的waiter，以便我们确定要执行的唤醒。 * 是从 sem->wait_list 链表首，取一个任务来唤醒的。 */ waiter = rwsem_first_waiter(sem); /* * 若等待链表头部排队的是一个writer, 而且唤醒类型是ANY, 那么直接 * 将这个writer放到待唤醒链表上。 */ if (waiter->type == RWSEM_WAITING_FOR_WRITE) { if (wake_type == RWSEM_WAKE_ANY) { /* * 翻译：在队列前面标记 writer 以唤醒。直到调用者稍后真正唤醒了任务， * 其他writer才能窃取它。另一方面，读者会阻塞，因为他们会注意到排队的writer。 */ wake_q_add(wake_q, waiter->task); /* 没使能CONFIG_LOCK_EVENT_COUNTS，是个空函数 */ lockevent_inc(rwsem_wake_writer); } return; } /*---- 下面就是sem的等待链表首不是writer或唤醒类型不是ANY的情况 ----*/ /* * 翻译：如果有太多读者等待了，则不会唤醒读者。最高bit为1才是小于0，实际情况下 * 应该不大会出现。 */ if (unlikely(atomic_long_read(&sem->count) < 0)) return; /* * 翻译：在我们将锁授予下一个读者之前，写者可能会偷走它。 * 我们更喜欢在计算读者数之前进行第一读者授权，这样如果写者偷了锁， * 我们可以提前退出。 */ if (wake_type != RWSEM_WAKE_READ_OWNED) { struct task_struct *owner; adjustment = RWSEM_READER_BIAS; /* 应该是先将sem->count的值返回，再加上adjustment的值 (1)*/ oldcount = atomic_long_fetch_add(adjustment, &sem->count); /* 若此刻有写者持有锁 */ if (unlikely(oldcount & RWSEM_WRITER_MASK)) { /* * 翻译：当我们已经等待“太”长时间(等待写者释放锁)时，请求 HANDOFF 以强制 * 解决该问题。 */ if (!(oldcount & RWSEM_FLAG_HANDOFF) && time_after(jiffies, waiter->timeout)) { /* 这里是减，减减就是加【handoff是专门针对写者吗？】 */ adjustment -= RWSEM_FLAG_HANDOFF; lockevent_inc(rwsem_rlock_handoff); } /* 对 RWSEM_READER_BIAS 加减相互抵消，相当于 sem->count += RWSEM_FLAG_HANDOFF */ atomic_long_add(-adjustment, &sem->count); return; } /*---- 下面就是当前没有writer在等待sem的情况了 ----*/ /* * 翻译：将其设置为 reader-owned 可以让 spinners 及早感知到现在是读者拥有锁。 * 在读者的慢速路径入口处看到的读者不可spin位被复制。 */ owner = waiter->task; /* 若上个被阻塞的reader的nom-spin位被设置，则继承，仍然被设置 */ if (waiter->last_rowner & RWSEM_RD_NONSPINNABLE) { owner = (void *)((unsigned long)owner | RWSEM_RD_NONSPINNABLE); lockevent_inc(rwsem_opt_norspin); } /* 设置等待链表上的首个reader持有锁 */ __rwsem_set_reader_owned(sem, owner); } /* * 翻译： * 向队列中的所有读者授予最多 MAX_READERS_WAKEUP 读取锁。 我们知道被唤醒任 * 务至少是1个，正如我们上面所解释的。请注意，在唤醒任何进程之前，我们将计 * 数的“active part”增加读者的数量。 * * 这是对相位公平 R/W 锁的改编，其中在读者阶段（第一个等待者是读者），所有 * 读者都有资格同时获取锁，而不管他们在队列中的顺序如何。 写者根据他们在队 * 列中的顺序获取锁。 * * 我们必须在 2 遍中进行唤醒，以防止读者计数可能在增加之前减少。 因为将被唤 * 醒的写者可能还没睡。所以它可能会看到 waiter->task 被清除，执行完它的临界 * 区部分并在读者计数增加之前进行解锁。 * * 1) 在单独的链表中收集读取等待者，对它们进行计数并在 rwsem 中增加读者计数。 * 2) 对于新链表中的每一个waiter，清空waiter->task 并放入wake_q 以便稍后唤醒。 */ INIT_LIST_HEAD(&wlist); list_for_each_entry_safe(waiter, tmp, &sem->wait_list, list) { /* 跳过等待链表上的writer */ if (waiter->type == RWSEM_WAITING_FOR_WRITE) continue; woken++; /* 将等待链表上的reader摘取下来挂在临时链表wlist的尾部 */ list_move_tail(&waiter->list, &wlist); /* 翻译：限制每次调用可以唤醒的读者数量，256个, 应该很难达到。*/ if (woken >= MAX_READERS_WAKEUP) break; } /* 减去应该是去除 (1) 位置的影响*/ adjustment = woken * RWSEM_READER_BIAS - adjustment; lockevent_cond_inc(rwsem_wake_reader, woken); /* * 等待链表已经为空了说明等待链表上没有writer(因为没有往下摘writer)， * 也没有reader了，这里减去有waiter的标志 */ if (list_empty(&sem->wait_list)) { /* hit end of list above */ adjustment -= RWSEM_FLAG_WAITERS; } /* * 翻译：当我们唤醒读者后，就不再需要强制写者放弃锁，可以清除 HANDOFF 标志了。【？】 */ if (woken && (atomic_long_read(&sem->count) & RWSEM_FLAG_HANDOFF)) adjustment -= RWSEM_FLAG_HANDOFF; /* * 相当于进来时 sem->count 的状态加上 woken * RWSEM_READER_BIAS，并且没有handoff * 标志。 * 可见(要)唤醒状态的reader才会出记录在sem->count中，已经被阻塞的不会。 */ if (adjustment) atomic_long_add(adjustment, &sem->count); /* 2nd pass */ /* 临时链表 wlist 上只挂入了reader */ list_for_each_entry_safe(waiter, tmp, &wlist, list) { struct task_struct *tsk; tsk = waiter->task; /* 增加计数，防止使用过程中 task_struct 结构被释放 */ get_task_struct(tsk); /* * 翻译：确保在将 reader waiter 设置为 NULL 之前调用 get_task_struct()， * 这样 rwsem_down_read_slowpath() 在整个唤醒任务的过程中始终保持引用 * 计数而不会和 do_exit() 存在竞争。 */ /* waiter->task == NULL 【waiter->task 设置为NULL是什么意思？】*/ smp_store_release(&waiter->task, NULL); /* 翻译：确保在将 reader waiter 设置为 NULL 后开始唤醒（由我们或其他人） */ wake_q_add_safe(wake_q, tsk); } }
主要逻辑：若链表首是个writer，且唤醒类型是ANY，只唤醒此writer就返回。若链表首不是writer，就唤醒等待队列中的所有reader。唤醒所有的reader能获得更高的并发效果，因为所有的reader能同时进入临界区。queue在等待队列中的writer是还没有进入临界区的。
sem->count 中对于 writer 只有一个标记，唤醒 writer 没有像唤醒 reader 那样从 sem->count 中减去对 reader 的计数。
四、获取写信号量流程
1. down_write()
/* * lock for writing */ void __sched down_write(struct rw_semaphore *sem) { might_sleep(); rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_); /* 没有使能CONFIG_LOCK_STAT，等效于__down_write(sem) */ LOCK_CONTENDED(sem, __down_write_trylock, __down_write); } EXPORT_SYMBOL(down_write); /* * lock for writing */ static inline void __down_write(struct rw_semaphore *sem) { long tmp = RWSEM_UNLOCKED_VALUE; /* * atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new) * 若*v==*old, *v=new, return true * 若*v!=*old, *old=*v, return false * * 作用是原子的执行： * if (sem->count == RWSEM_UNLOCKED_VALUE) { * sem->count = RWSEM_WRITER_LOCKED; * } */ if (unlikely(!atomic_long_try_cmpxchg_acquire(&sem->count, &tmp, RWSEM_WRITER_LOCKED))) { rwsem_down_write_slowpath(sem, TASK_UNINTERRUPTIBLE); } else { /* 当前sem还没被持有，writer快速持有路径。直接 sem->owner = current */ rwsem_set_owner(sem); } }
(1) 尝试获取写锁
判断 sem->count 是否为0，若是，就将起赋值为 RWSEM_WRITER_LOCKED，表示 writer 持有锁了，返回真。
(2) 持写锁的快速路径
上面尝试获取锁成功后，直接 sem->owner = current，表示持锁的是当前任务。
(3) 持写锁的慢速路径
若前面尝试持写锁失败，将进入持写锁慢速路径。执行 rwsem_down_write_slowpath() 函数
/* * Wait until we successfully acquire the write lock. * * __down_write 传参：(sem, TASK_UNINTERRUPTIBLE) */ static struct rw_semaphore *rwsem_down_write_slowpath(struct rw_semaphore *sem, int state) { long count; bool disable_rspin; enum writer_wait_state wstate; struct rwsem_waiter waiter; struct rw_semaphore *ret = sem; DEFINE_WAKE_Q(wake_q); bool already_on_list = false; /* do optimistic spinning and steal lock if possible */ /* CONFIG_RWSEM_SPIN_ON_OWNER 默认不使能，恒返回false，不执行 */ if (rwsem_can_spin_on_owner(sem, RWSEM_WR_NONSPINNABLE) && rwsem_optimistic_spin(sem, true)) { /* rwsem_optimistic_spin() implies ACQUIRE on success */ return sem; } /* * 翻译：当观察到不可spin bit位被设置时，在获取写锁后关闭此rwsem的reader的乐观自旋。 * 检索此标志没有被赋值过，disable_rspin 应该恒为假 */ disable_rspin = atomic_long_read(&sem->owner) & RWSEM_NONSPINNABLE; /* 翻译：乐观自旋失败，继续慢速路径并阻塞，直到可以获取sem。*/ waiter.task = current; waiter.type = RWSEM_WAITING_FOR_WRITE; waiter.timeout = jiffies + RWSEM_WAIT_TIMEOUT; //jiffies + 4ms raw_spin_lock_irq(&sem->wait_lock); /* account for this before adding a new element to the list */ wstate = list_empty(&sem->wait_list) ? WRITER_FIRST : WRITER_NOT_FIRST; trace_android_vh_alter_rwsem_list_add(&waiter, sem, &already_on_list); if (!already_on_list) /* 默认是插入等待队列的尾部 */ list_add_tail(&waiter.list, &sem->wait_list); /* we're now waiting on the lock */ /* * 插入时等待队列不为空就是NOT_FIRST。此时可能是只有一个writer在临界区，等待链表上 * 都是reader，也可能已经有writer在等待链表上了，reader和writer都有。 */ if (wstate == WRITER_NOT_FIRST) { count = atomic_long_read(&sem->count); /* * 翻译：如果在我们之前已经有排队等待的任务了，并且： * 1) 没有active状态的锁，唤醒前面排队的进程，因为可能设置了handoff bit位。 * 2) 没有active状态的写者和一些读者，锁必须是读拥有的；所以我们尝试唤醒任 * 何排在我们前面的读锁等待者(由于是尾插法，等待链表上已有的所有读者都在我们前面)。 */ /* * 之前持锁的writer是不是已经释放锁了，若是还没有释放，那么当前等待持锁的writer * 直接去休眠等待。 */ if (count & RWSEM_WRITER_MASK) goto wait; /* 若之前持锁的writer已经释放锁了，那么接下来就把等待的reader都唤醒吧 */ rwsem_mark_wake(sem, (count & RWSEM_READEMASK) ? RWSEM_WAKE_READERS : RWSEM_WAKE_ANY, &wake_q); if (!wake_q_empty(&wake_q)) { /* 翻译：我们希望最小化 wait_lock 保持时间，尤其是在要唤醒大量读者时。*/ raw_spin_unlock_irq(&sem->wait_lock); /* 唤醒等待队列上的所有任务 */ wake_up_q(&wake_q); /* Used again, reinit */ wake_q_init(&wake_q); raw_spin_lock_irq(&sem->wait_lock); } } else { /* * 若插入时writer是等待链表上为空, 也就是此时只有reader持有锁， * 只或上这个标志位，表示有writer在等待锁。 */ atomic_long_or(RWSEM_FLAG_WAITERS, &sem->count); } wait: trace_android_vh_rwsem_wake(sem); /* wait until we successfully acquire the lock */ trace_android_vh_rwsem_write_wait_start(sem); /* __down_write 传参：state == TASK_UNINTERRUPTIBLE */ set_current_state(state); /* 第一层循环 */ for (;;) { /* * 成功获取sem返回true, 失败返回false。这里若传 wstate = WRITER_HANDOFF, * 会赋值到 sem->count 中。 */ if (rwsem_try_write_lock(sem, wstate)) { /* * 外层for循环唯一退出位置。唯一退出条件是成功持有sem。退出时 * sem->wait_lock 是锁定状态的。 */ break; } raw_spin_unlock_irq(&sem->wait_lock); /* * 翻译： * 在未能获取锁和设置了handoff bit位后，尝试在sem的owner上自 * 旋以加速锁的传递。如果前一个owner是一个on-cpu(正在运行)的writer * 并且它刚刚释放了锁，则将返回 OWNER_NULL。在这种情况下，我们尝试 * 在不休眠的情况下再次获取锁。 * * CONFIG_RWSEM_SPIN_ON_OWNER 默认不使能，此if恒不成立。 */ if (wstate == WRITER_HANDOFF && rwsem_spin_on_owner(sem, RWSEM_NONSPINNABLE) == OWNER_NULL) goto trylock_again; //恒不执行 /* Block until there are no active lockers. */ /* active lockers：位于临界区的入任务。睡眠等待，直到自己是 WRITER_FIRST 才能退出 */ /* 第二层循环 */ for (;;) { /* __down_write 传参 state==TASK_UNINTERRUPTABLE, 恒不成立*/ if (signal_pending_state(state, current)) goto out_nolock; /* 将当前任务切走 */ schedule(); lockevent_inc(rwsem_sleep_writer); set_current_state(state); /* If HANDOFF bit is set, unconditionally do a trylock */ if (wstate == WRITER_HANDOFF) break; /* * 若之前writer不是等待链表中的第一个waiter, 而现在是一个waiter了，更新wstate。 * 这里是一级循环退出的唯一条件：WRITER_FIRST --> WRITER_HANDOFF --> break */ if (wstate == WRITER_NOT_FIRST && rwsem_first_waiter(sem) == &waiter) wstate = WRITER_FIRST; /* 若此时writer和reader都没有再持有sem */ count = atomic_long_read(&sem->count); if (!(count & RWSEM_LOCK_MASK)) break; /* * 翻译：handoff 位的设置被推迟到 rwsem_try_write_lock() 被调用时。 * * 此 writer 必须是等待链表上的首个waiter了，并且已经在这里是spin大于4ms了 */ if (wstate == WRITER_FIRST && (rt_task(current) || time_after(jiffies, waiter.timeout))) { wstate = WRITER_HANDOFF; lockevent_inc(rwsem_wlock_handoff); break; } } trylock_again: raw_spin_lock_irq(&sem->wait_lock); } __set_current_state(TASK_RUNNING); trace_android_vh_rwsem_write_wait_finish(sem); /* 将此waiter从等待链表中移除 */ list_del(&waiter.list); /* 若之前是no-spin，退出时还是设置为no-spin */ rwsem_disable_reader_optspin(sem, disable_rspin); raw_spin_unlock_irq(&sem->wait_lock); lockevent_inc(rwsem_wlock); return ret; out_nolock: //被信号唤醒，此Case这里恒不会被执行 __set_current_state(TASK_RUNNING); trace_android_vh_rwsem_write_wait_finish(sem); raw_spin_lock_irq(&sem->wait_lock); list_del(&waiter.list); if (unlikely(wstate == WRITER_HANDOFF)) atomic_long_add(-RWSEM_FLAG_HANDOFF, &sem->count); if (list_empty(&sem->wait_list)) atomic_long_andnot(RWSEM_FLAG_WAITERS, &sem->count); else rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q); raw_spin_unlock_irq(&sem->wait_lock); wake_up_q(&wake_q); lockevent_inc(rwsem_wlock_fail); return ERR_PTR(-EINTR); }
a. reader 获取sem锁时，若是没有 writer 持有，只是在 sem->count 上增加读者计数。之后在 writer 持锁时，发现 sem->count 不为0就会
进入慢速持锁路径，放在等待链表上休眠。若之前持锁的reader在休眠，这里什么也没有做，只是静静的等待reader释放锁。只有在 writer
持锁进入慢速路径时，发现等待链表上已经有任务了，并且之前持锁的writer已经释放锁了，才会尝试将之前阻塞的reader一下子都唤醒。
b. 进入慢速路径的writer若发现 sem->wait_list 等待链表不为空，这说明之前已经有一个writer和若干个reader在等待链表上了。
c. 虽然 sem->count 上 writer 只有一个bit的标志，标识同一时间只能有一个writer进入临界区。但是 sem->wait_list 链表上等待的 writer 却可以同时有多个，它们都不在临界区中。
d. 一直等待，直到此writer成功等待链表上首个waiter了。若它是rt线程或等待时间已经超过了4ms, 就会启用 WRITER_HANDOFF 进行锁交接。
(2) rwsem_try_write_lock() 函数
/* * 翻译： * 必须在持有 sem->wait_lock 的情况下调用此函数，以防止检查 rwsem 等待链表和 * 相应地设置 sem->count 之间的竞争条件。 * * 如果 wstate 为 WRITER_HANDOFF，它将确保设置了切换位或在清除切换位的情况下 * 获取锁。 * * rwsem_down_write_slowpath 传参 wstate 为 WRITER_FIRST 或 WRITER_NOT_FIRST, * 第二轮也可能传参为 WRITER_HANDOFF. * * 成功获取sem返回true, 失败返回false并设置handoff bit位 */ static inline bool rwsem_try_write_lock(struct rw_semaphore *sem, enum writer_wait_state wstate) { long count, new; lockdep_assert_held(&sem->wait_lock); count = atomic_long_read(&sem->count); do { bool has_handoff = !!(count & RWSEM_FLAG_HANDOFF); /* 看来handoff主要是针对等待队列中首个waiter是writer的情况 */ if (has_handoff && wstate == WRITER_NOT_FIRST) return false; new = count; /* 是否有writer或reader在等待sem */ if (count & RWSEM_LOCK_MASK) { /* * 虽然还有持锁，但是传参handoff标志，也不返回false退出了， * 后面这个handoff标志会设置到sem->count中。 */ if (has_handoff || wstate != WRITER_HANDOFF) return false; new |= RWSEM_FLAG_HANDOFF; } else { /* * 既没有writer又没有reader在等待sem，此writer就可以持锁了， * 或上writer标志，清除掉handoff标志。 */ new |= RWSEM_WRITER_LOCKED; new &= ~RWSEM_FLAG_HANDOFF; /* 若等待链表中只有一个元素(本writer自己)，标记等待链表上没有waiters */ if (list_is_singular(&sem->wait_list)) new &= ~RWSEM_FLAG_WAITERS; } /* * 若 sem->count==count, sem->count=new, return true; * 若 sem->count!=count, count=sem->count, return false; */ } while (!atomic_long_try_cmpxchg_acquire(&sem->count, &count, new)); /* * We have either acquired the lock with handoff bit cleared or * set the handoff bit. * 翻译：走到这里了还没退出，说明我们要么获得了锁并清除了handoff bit位，就返回true; * 要么设置了handoff bit位, 返回false. */ if (new & RWSEM_FLAG_HANDOFF) return false; /* 直接单纯是sem->owner=current */ rwsem_set_owner(sem); return true; }
五、释放读信号流程
1. up_read() 函数
/* release a read lock */ void up_read(struct rw_semaphore *sem) { rwsem_release(&sem->dep_map, _RET_IP_); __up_read(sem); } EXPORT_SYMBOL(up_read); /* unlock after reading */ static inline void __up_read(struct rw_semaphore *sem) { long tmp; /* CONFIG_DEBUG_RWSEMS 默认不使能，是空函数 */ DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); /* CONFIG_DEBUG_RWSEMS 默认不使能，是个空函数 */ rwsem_clear_reader_owned(sem); /* sem->count 中的 reader 计数减去1 */ tmp = atomic_long_add_return_release(-RWSEM_READER_BIAS, &sem->count); /* CONFIG_DEBUG_RWSEMS 默认不使能，是个空函数 */ DEBUG_RWSEMS_WARN_ON(tmp < 0, sem); /* 若是有waiter, 才执行唤醒流程。[或上 RWSEM_LOCK_MASK 有什么意义呢，作者笔误？] */ if (unlikely((tmp & (RWSEM_LOCK_MASK|RWSEM_FLAG_WAITERS)) == RWSEM_FLAG_WAITERS)) { clear_wr_nonspinnable(sem); rwsem_wake(sem, tmp); } }
(1) rwsem_wake() 函数
/* * 翻译： * 处理唤醒信号量上的waiter * - 如果我们来到这里，up_read/up_write 会减少 count 的活动部分 */ static struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem, long count) { unsigned long flags; DEFINE_WAKE_Q(wake_q); raw_spin_lock_irqsave(&sem->wait_lock, flags); /* 若等待链表不为空，就执行唤醒动作 */ if (!list_empty(&sem->wait_list)) /* 标记待唤醒的waiter */ rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q); trace_android_vh_rwsem_wake_finish(sem); raw_spin_unlock_irqrestore(&sem->wait_lock, flags); /* 执行唤醒操作 */ wake_up_q(&wake_q); return sem; }
六、释放写信号量流程
1. up_write() 函数
/* release a write lock */ void up_write(struct rw_semaphore *sem) { rwsem_release(&sem->dep_map, _RET_IP_); trace_android_vh_rwsem_write_finished(sem); __up_write(sem); } EXPORT_SYMBOL(up_write); /* unlock after writing */ static inline void __up_write(struct rw_semaphore *sem) { long tmp; /* CONFIG_DEBUG_RWSEMS 默认不使能，是个空函数 */ DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); /* * 翻译：如果通过设置 RWSEM_NONSPINNABLE 位将所有权转移给匿名写入者，则 * sem->owner 可能与当前不同。 * * CONFIG_DEBUG_RWSEMS 默认不使能，是个空函数 */ DEBUG_RWSEMS_WARN_ON((rwsem_owner(sem) != current) && !rwsem_test_oflags(sem, RWSEM_NONSPINNABLE), sem); /* 直接 sem->owner=0 */ rwsem_clear_owner(sem); /* 原子的读取-修改-写入，等效于 return sem->count; sem->count += -RWSEM_WRITER_LOCKED; */ tmp = atomic_long_fetch_add_release(-RWSEM_WRITER_LOCKED, &sem->count); /* 有等待的waiter才执行唤醒操作 */ if (unlikely(tmp & RWSEM_FLAG_WAITERS)) rwsem_wake(sem, tmp); }
七、总结
1. rwsem可以有多个读者同时进入临界区，但是读者和写者，写者和写者之间只能有一个进入临界区。
2. 有写者在临界区，对应成功获取写锁，从 down_write() 到 up_write() 之间，前者会在 sem->count 上或上 RWSEM_WRITER_LOCKED 标志，i后者会清除此标志。RWSEM_WRITER_LOCKED 标志标识的是写者在临界区中，慢速路径中写者被挂在等待链表上时是不会或上这个标志的。在读者持锁时会因为 sem->count 中有这个标志而被迫进入慢速路径在等待链表上进行等待。
八、补充
1. CONFIG_RWSEM_SPIN_ON_OWNER 默认是使能的，上面是默认其不使能分析的，TODO：