|
|
# 42 | IPC(下):不同项目组之间抢资源,如何协调?
|
|
|
|
|
|
IPC这块的内容比较多,为了让你能够更好地理解,我分成了三节来讲。前面我们解析完了共享内存的内核机制后,今天我们来看最后一部分,信号量的内核机制。
|
|
|
|
|
|
首先,我们需要创建一个信号量,调用的是系统调用semget。代码如下:
|
|
|
|
|
|
```
|
|
|
SYSCALL_DEFINE3(semget, key_t, key, int, nsems, int, semflg)
|
|
|
{
|
|
|
struct ipc_namespace *ns;
|
|
|
static const struct ipc_ops sem_ops = {
|
|
|
.getnew = newary,
|
|
|
.associate = sem_security,
|
|
|
.more_checks = sem_more_checks,
|
|
|
};
|
|
|
struct ipc_params sem_params;
|
|
|
ns = current->nsproxy->ipc_ns;
|
|
|
sem_params.key = key;
|
|
|
sem_params.flg = semflg;
|
|
|
sem_params.u.nsems = nsems;
|
|
|
return ipcget(ns, &sem_ids(ns), &sem_ops, &sem_params);
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
我们解析过了共享内存,再看信号量,就顺畅很多了。这里同样调用了抽象的ipcget,参数分别为信号量对应的sem\_ids、对应的操作sem\_ops以及对应的参数sem\_params。
|
|
|
|
|
|
ipcget的代码我们已经解析过了。如果key设置为IPC\_PRIVATE则永远创建新的;如果不是的话,就会调用ipcget\_public。
|
|
|
|
|
|
在ipcget\_public中,我们能会按照key,去查找struct kern\_ipc\_perm。如果没有找到,那就看看是否设置了IPC\_CREAT。如果设置了,就创建一个新的。如果找到了,就将对应的id返回。
|
|
|
|
|
|
我们这里重点看,如何按照参数sem\_ops,创建新的信号量会调用newary。
|
|
|
|
|
|
```
|
|
|
static int newary(struct ipc_namespace *ns, struct ipc_params *params)
|
|
|
{
|
|
|
int retval;
|
|
|
struct sem_array *sma;
|
|
|
key_t key = params->key;
|
|
|
int nsems = params->u.nsems;
|
|
|
int semflg = params->flg;
|
|
|
int i;
|
|
|
......
|
|
|
sma = sem_alloc(nsems);
|
|
|
......
|
|
|
sma->sem_perm.mode = (semflg & S_IRWXUGO);
|
|
|
sma->sem_perm.key = key;
|
|
|
sma->sem_perm.security = NULL;
|
|
|
......
|
|
|
for (i = 0; i < nsems; i++) {
|
|
|
INIT_LIST_HEAD(&sma->sems[i].pending_alter);
|
|
|
INIT_LIST_HEAD(&sma->sems[i].pending_const);
|
|
|
spin_lock_init(&sma->sems[i].lock);
|
|
|
}
|
|
|
sma->complex_count = 0;
|
|
|
sma->use_global_lock = USE_GLOBAL_LOCK_HYSTERESIS;
|
|
|
INIT_LIST_HEAD(&sma->pending_alter);
|
|
|
INIT_LIST_HEAD(&sma->pending_const);
|
|
|
INIT_LIST_HEAD(&sma->list_id);
|
|
|
sma->sem_nsems = nsems;
|
|
|
sma->sem_ctime = get_seconds();
|
|
|
retval = ipc_addid(&sem_ids(ns), &sma->sem_perm, ns->sc_semmni);
|
|
|
......
|
|
|
ns->used_sems += nsems;
|
|
|
......
|
|
|
return sma->sem_perm.id;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
newary函数的第一步,通过kvmalloc在直接映射区分配一个struct sem\_array结构。这个结构是用来描述信号量的,这个结构最开始就是上面说的struct kern\_ipc\_perm结构。接下来就是填充这个struct sem\_array结构,例如key、权限等。
|
|
|
|
|
|
struct sem\_array里有多个信号量,放在struct sem sems\[\]数组里面,在struct sem里面有当前的信号量的数值semval。
|
|
|
|
|
|
```
|
|
|
struct sem {
|
|
|
int semval; /* current value */
|
|
|
/*
|
|
|
* PID of the process that last modified the semaphore. For
|
|
|
* Linux, specifically these are:
|
|
|
* - semop
|
|
|
* - semctl, via SETVAL and SETALL.
|
|
|
* - at task exit when performing undo adjustments (see exit_sem).
|
|
|
*/
|
|
|
int sempid;
|
|
|
spinlock_t lock; /* spinlock for fine-grained semtimedop */
|
|
|
struct list_head pending_alter; /* pending single-sop operations that alter the semaphore */
|
|
|
struct list_head pending_const; /* pending single-sop operations that do not alter the semaphore*/
|
|
|
time_t sem_otime; /* candidate for sem_otime */
|
|
|
} ____cacheline_aligned_in_smp;
|
|
|
|
|
|
```
|
|
|
|
|
|
struct sem\_array和struct sem各有一个链表struct list\_head pending\_alter,分别表示对于整个信号量数组的修改和对于某个信号量的修改。
|
|
|
|
|
|
newary函数的第二步,就是初始化这些链表。
|
|
|
|
|
|
newary函数的第三步,通过ipc\_addid将新创建的struct sem\_array结构,挂到sem\_ids里面的基数树上,并返回相应的id。
|
|
|
|
|
|
信号量创建的过程到此结束,接下来我们来看,如何通过semctl对信号量数组进行初始化。
|
|
|
|
|
|
```
|
|
|
SYSCALL_DEFINE4(semctl, int, semid, int, semnum, int, cmd, unsigned long, arg)
|
|
|
{
|
|
|
int version;
|
|
|
struct ipc_namespace *ns;
|
|
|
void __user *p = (void __user *)arg;
|
|
|
ns = current->nsproxy->ipc_ns;
|
|
|
switch (cmd) {
|
|
|
case IPC_INFO:
|
|
|
case SEM_INFO:
|
|
|
case IPC_STAT:
|
|
|
case SEM_STAT:
|
|
|
return semctl_nolock(ns, semid, cmd, version, p);
|
|
|
case GETALL:
|
|
|
case GETVAL:
|
|
|
case GETPID:
|
|
|
case GETNCNT:
|
|
|
case GETZCNT:
|
|
|
case SETALL:
|
|
|
return semctl_main(ns, semid, semnum, cmd, p);
|
|
|
case SETVAL:
|
|
|
return semctl_setval(ns, semid, semnum, arg);
|
|
|
case IPC_RMID:
|
|
|
case IPC_SET:
|
|
|
return semctl_down(ns, semid, cmd, version, p);
|
|
|
default:
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
这里我们重点看,SETALL操作调用的semctl\_main函数,以及SETVAL操作调用的semctl\_setval函数。
|
|
|
|
|
|
对于SETALL操作来讲,传进来的参数为union semun里面的unsigned short \*array,会设置整个信号量集合。
|
|
|
|
|
|
```
|
|
|
static int semctl_main(struct ipc_namespace *ns, int semid, int semnum,
|
|
|
int cmd, void __user *p)
|
|
|
{
|
|
|
struct sem_array *sma;
|
|
|
struct sem *curr;
|
|
|
int err, nsems;
|
|
|
ushort fast_sem_io[SEMMSL_FAST];
|
|
|
ushort *sem_io = fast_sem_io;
|
|
|
DEFINE_WAKE_Q(wake_q);
|
|
|
sma = sem_obtain_object_check(ns, semid);
|
|
|
nsems = sma->sem_nsems;
|
|
|
......
|
|
|
switch (cmd) {
|
|
|
......
|
|
|
case SETALL:
|
|
|
{
|
|
|
int i;
|
|
|
struct sem_undo *un;
|
|
|
......
|
|
|
if (copy_from_user(sem_io, p, nsems*sizeof(ushort))) {
|
|
|
......
|
|
|
}
|
|
|
......
|
|
|
for (i = 0; i < nsems; i++) {
|
|
|
sma->sems[i].semval = sem_io[i];
|
|
|
sma->sems[i].sempid = task_tgid_vnr(current);
|
|
|
}
|
|
|
......
|
|
|
sma->sem_ctime = get_seconds();
|
|
|
/* maybe some queued-up processes were waiting for this */
|
|
|
do_smart_update(sma, NULL, 0, 0, &wake_q);
|
|
|
err = 0;
|
|
|
goto out_unlock;
|
|
|
}
|
|
|
}
|
|
|
......
|
|
|
wake_up_q(&wake_q);
|
|
|
......
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在semctl\_main函数中,先是通过sem\_obtain\_object\_check,根据信号量集合的id在基数树里面找到struct sem\_array对象,发现如果是SETALL操作,就将用户的参数中的unsigned short \*array通过copy\_from\_user拷贝到内核里面的sem\_io数组,然后是一个循环,对于信号量集合里面的每一个信号量,设置semval,以及修改这个信号量值的pid。
|
|
|
|
|
|
对于SETVAL操作来讲,传进来的参数union semun里面的int val,仅仅会设置某个信号量。
|
|
|
|
|
|
```
|
|
|
static int semctl_setval(struct ipc_namespace *ns, int semid, int semnum,
|
|
|
unsigned long arg)
|
|
|
{
|
|
|
struct sem_undo *un;
|
|
|
struct sem_array *sma;
|
|
|
struct sem *curr;
|
|
|
int err, val;
|
|
|
DEFINE_WAKE_Q(wake_q);
|
|
|
......
|
|
|
sma = sem_obtain_object_check(ns, semid);
|
|
|
......
|
|
|
curr = &sma->sems[semnum];
|
|
|
......
|
|
|
curr->semval = val;
|
|
|
curr->sempid = task_tgid_vnr(current);
|
|
|
sma->sem_ctime = get_seconds();
|
|
|
/* maybe some queued-up processes were waiting for this */
|
|
|
do_smart_update(sma, NULL, 0, 0, &wake_q);
|
|
|
......
|
|
|
wake_up_q(&wake_q);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在semctl\_setval函数中,我们先是通过sem\_obtain\_object\_check,根据信号量集合的id在基数树里面找到struct sem\_array对象,对于SETVAL操作,直接根据参数中的val设置semval,以及修改这个信号量值的pid。
|
|
|
|
|
|
至此,信号量数组初始化完毕。接下来我们来看P操作和V操作。无论是P操作,还是V操作都是调用semop系统调用。
|
|
|
|
|
|
```
|
|
|
SYSCALL_DEFINE3(semop, int, semid, struct sembuf __user *, tsops,
|
|
|
unsigned, nsops)
|
|
|
{
|
|
|
return sys_semtimedop(semid, tsops, nsops, NULL);
|
|
|
}
|
|
|
|
|
|
SYSCALL_DEFINE4(semtimedop, int, semid, struct sembuf __user *, tsops,
|
|
|
unsigned, nsops, const struct timespec __user *, timeout)
|
|
|
{
|
|
|
int error = -EINVAL;
|
|
|
struct sem_array *sma;
|
|
|
struct sembuf fast_sops[SEMOPM_FAST];
|
|
|
struct sembuf *sops = fast_sops, *sop;
|
|
|
struct sem_undo *un;
|
|
|
int max, locknum;
|
|
|
bool undos = false, alter = false, dupsop = false;
|
|
|
struct sem_queue queue;
|
|
|
unsigned long dup = 0, jiffies_left = 0;
|
|
|
struct ipc_namespace *ns;
|
|
|
|
|
|
ns = current->nsproxy->ipc_ns;
|
|
|
......
|
|
|
if (copy_from_user(sops, tsops, nsops * sizeof(*tsops))) {
|
|
|
error = -EFAULT;
|
|
|
goto out_free;
|
|
|
}
|
|
|
|
|
|
if (timeout) {
|
|
|
struct timespec _timeout;
|
|
|
if (copy_from_user(&_timeout, timeout, sizeof(*timeout))) {
|
|
|
}
|
|
|
jiffies_left = timespec_to_jiffies(&_timeout);
|
|
|
}
|
|
|
......
|
|
|
/* On success, find_alloc_undo takes the rcu_read_lock */
|
|
|
un = find_alloc_undo(ns, semid);
|
|
|
......
|
|
|
sma = sem_obtain_object_check(ns, semid);
|
|
|
......
|
|
|
queue.sops = sops;
|
|
|
queue.nsops = nsops;
|
|
|
queue.undo = un;
|
|
|
queue.pid = task_tgid_vnr(current);
|
|
|
queue.alter = alter;
|
|
|
queue.dupsop = dupsop;
|
|
|
|
|
|
error = perform_atomic_semop(sma, &queue);
|
|
|
if (error == 0) { /* non-blocking succesfull path */
|
|
|
DEFINE_WAKE_Q(wake_q);
|
|
|
......
|
|
|
do_smart_update(sma, sops, nsops, 1, &wake_q);
|
|
|
......
|
|
|
wake_up_q(&wake_q);
|
|
|
goto out_free;
|
|
|
}
|
|
|
/*
|
|
|
* We need to sleep on this operation, so we put the current
|
|
|
* task into the pending queue and go to sleep.
|
|
|
*/
|
|
|
if (nsops == 1) {
|
|
|
struct sem *curr;
|
|
|
curr = &sma->sems[sops->sem_num];
|
|
|
......
|
|
|
list_add_tail(&queue.list,
|
|
|
&curr->pending_alter);
|
|
|
......
|
|
|
} else {
|
|
|
......
|
|
|
list_add_tail(&queue.list, &sma->pending_alter);
|
|
|
......
|
|
|
}
|
|
|
|
|
|
do {
|
|
|
queue.status = -EINTR;
|
|
|
queue.sleeper = current;
|
|
|
|
|
|
__set_current_state(TASK_INTERRUPTIBLE);
|
|
|
if (timeout)
|
|
|
jiffies_left = schedule_timeout(jiffies_left);
|
|
|
else
|
|
|
schedule();
|
|
|
......
|
|
|
/*
|
|
|
* If an interrupt occurred we have to clean up the queue.
|
|
|
*/
|
|
|
if (timeout && jiffies_left == 0)
|
|
|
error = -EAGAIN;
|
|
|
} while (error == -EINTR && !signal_pending(current)); /* spurious */
|
|
|
......
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
semop会调用semtimedop,这是一个非常复杂的函数。
|
|
|
|
|
|
semtimedop做的第一件事情,就是将用户的参数,例如,对于信号量的操作struct sembuf,拷贝到内核里面来。另外,如果是P操作,很可能让进程进入等待状态,是否要为这个等待状态设置一个超时,timeout也是一个参数,会把它变成时钟的滴答数目。
|
|
|
|
|
|
semtimedop做的第二件事情,是通过sem\_obtain\_object\_check,根据信号量集合的id,获得struct sem\_array,然后,创建一个struct sem\_queue表示当前的信号量操作。为什么叫queue呢?因为这个操作可能马上就能完成,也可能因为无法获取信号量不能完成,不能完成的话就只好排列到队列上,等待信号量满足条件的时候。semtimedop会调用perform\_atomic\_semop在实施信号量操作。
|
|
|
|
|
|
```
|
|
|
static int perform_atomic_semop(struct sem_array *sma, struct sem_queue *q)
|
|
|
{
|
|
|
int result, sem_op, nsops;
|
|
|
struct sembuf *sop;
|
|
|
struct sem *curr;
|
|
|
struct sembuf *sops;
|
|
|
struct sem_undo *un;
|
|
|
|
|
|
sops = q->sops;
|
|
|
nsops = q->nsops;
|
|
|
un = q->undo;
|
|
|
|
|
|
for (sop = sops; sop < sops + nsops; sop++) {
|
|
|
curr = &sma->sems[sop->sem_num];
|
|
|
sem_op = sop->sem_op;
|
|
|
result = curr->semval;
|
|
|
......
|
|
|
result += sem_op;
|
|
|
if (result < 0)
|
|
|
goto would_block;
|
|
|
......
|
|
|
if (sop->sem_flg & SEM_UNDO) {
|
|
|
int undo = un->semadj[sop->sem_num] - sem_op;
|
|
|
.....
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (sop = sops; sop < sops + nsops; sop++) {
|
|
|
curr = &sma->sems[sop->sem_num];
|
|
|
sem_op = sop->sem_op;
|
|
|
result = curr->semval;
|
|
|
|
|
|
if (sop->sem_flg & SEM_UNDO) {
|
|
|
int undo = un->semadj[sop->sem_num] - sem_op;
|
|
|
un->semadj[sop->sem_num] = undo;
|
|
|
}
|
|
|
curr->semval += sem_op;
|
|
|
curr->sempid = q->pid;
|
|
|
}
|
|
|
return 0;
|
|
|
would_block:
|
|
|
q->blocking = sop;
|
|
|
return sop->sem_flg & IPC_NOWAIT ? -EAGAIN : 1;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在perform\_atomic\_semop函数中,对于所有信号量操作都进行两次循环。在第一次循环中,如果发现计算出的result小于0,则说明必须等待,于是跳到would\_block中,设置q->blocking = sop表示这个queue是block在这个操作上,然后如果需要等待,则返回1。如果第一次循环中发现无需等待,则第二个循环实施所有的信号量操作,将信号量的值设置为新的值,并且返回0。
|
|
|
|
|
|
接下来,我们回到semtimedop,来看它干的第三件事情,就是如果需要等待,应该怎么办?
|
|
|
|
|
|
如果需要等待,则要区分刚才的对于信号量的操作,是对一个信号量的,还是对于整个信号量集合的。如果是对于一个信号量的,那我们就将queue挂到这个信号量的pending\_alter中;如果是对于整个信号量集合的,那我们就将queue挂到整个信号量集合的pending\_alter中。
|
|
|
|
|
|
接下来的do-while循环,就是要开始等待了。如果等待没有时间限制,则调用schedule让出CPU;如果等待有时间限制,则调用schedule\_timeout让出CPU,过一段时间还回来。当回来的时候,判断是否等待超时,如果没有等待超时则进入下一轮循环,再次等待,如果超时则退出循环,返回错误。在让出CPU的时候,设置进程的状态为TASK\_INTERRUPTIBLE,并且循环的结束会通过signal\_pending查看是否收到过信号,这说明这个等待信号量的进程是可以被信号中断的,也即一个等待信号量的进程是可以通过kill杀掉的。
|
|
|
|
|
|
我们再来看,semtimedop要做的第四件事情,如果不需要等待,应该怎么办?
|
|
|
|
|
|
如果不需要等待,就说明对于信号量的操作完成了,也改变了信号量的值。接下来,就是一个标准流程。我们通过DEFINE\_WAKE\_Q(wake\_q)声明一个wake\_q,调用do\_smart\_update,看这次对于信号量的值的改变,可以影响并可以激活等待队列中的哪些struct sem\_queue,然后把它们都放在wake\_q里面,调用wake\_up\_q唤醒这些进程。其实,所有的对于信号量的值的修改都会涉及这三个操作,如果你回过头去仔细看SETALL和SETVAL操作,在设置完毕信号量之后,也是这三个操作。
|
|
|
|
|
|
我们来看do\_smart\_update是如何实现的。do\_smart\_update会调用update\_queue。
|
|
|
|
|
|
```
|
|
|
static int update_queue(struct sem_array *sma, int semnum, struct wake_q_head *wake_q)
|
|
|
{
|
|
|
struct sem_queue *q, *tmp;
|
|
|
struct list_head *pending_list;
|
|
|
int semop_completed = 0;
|
|
|
|
|
|
if (semnum == -1)
|
|
|
pending_list = &sma->pending_alter;
|
|
|
else
|
|
|
pending_list = &sma->sems[semnum].pending_alter;
|
|
|
|
|
|
again:
|
|
|
list_for_each_entry_safe(q, tmp, pending_list, list) {
|
|
|
int error, restart;
|
|
|
......
|
|
|
error = perform_atomic_semop(sma, q);
|
|
|
|
|
|
/* Does q->sleeper still need to sleep? */
|
|
|
if (error > 0)
|
|
|
continue;
|
|
|
|
|
|
unlink_queue(sma, q);
|
|
|
......
|
|
|
wake_up_sem_queue_prepare(q, error, wake_q);
|
|
|
......
|
|
|
}
|
|
|
return semop_completed;
|
|
|
}
|
|
|
|
|
|
static inline void wake_up_sem_queue_prepare(struct sem_queue *q, int error,
|
|
|
struct wake_q_head *wake_q)
|
|
|
{
|
|
|
wake_q_add(wake_q, q->sleeper);
|
|
|
......
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
update\_queue会依次循环整个信号量集合的等待队列pending\_alter,或者某个信号量的等待队列。试图在信号量的值变了的情况下,再次尝试perform\_atomic\_semop进行信号量操作。如果不成功,则尝试队列中的下一个;如果尝试成功,则调用unlink\_queue从队列上取下来,然后调用wake\_up\_sem\_queue\_prepare,将q->sleeper加到wake\_q上去。q->sleeper是一个task\_struct,是等待在这个信号量操作上的进程。
|
|
|
|
|
|
接下来,wake\_up\_q就依次唤醒wake\_q上的所有task\_struct,调用的是我们在进程调度那一节学过的wake\_up\_process方法。
|
|
|
|
|
|
```
|
|
|
void wake_up_q(struct wake_q_head *head)
|
|
|
{
|
|
|
struct wake_q_node *node = head->first;
|
|
|
|
|
|
while (node != WAKE_Q_TAIL) {
|
|
|
struct task_struct *task;
|
|
|
|
|
|
task = container_of(node, struct task_struct, wake_q);
|
|
|
|
|
|
node = node->next;
|
|
|
task->wake_q.next = NULL;
|
|
|
|
|
|
wake_up_process(task);
|
|
|
put_task_struct(task);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
至此,对于信号量的主流操作都解析完毕了。
|
|
|
|
|
|
其实还有一点需要强调一下,信号量是一个整个Linux可见的全局资源,而不像咱们在线程同步那一节讲过的都是某个进程独占的资源,好处是可以跨进程通信,坏处就是如果一个进程通过P操作拿到了一个信号量,但是不幸异常退出了,如果没有来得及归还这个信号量,可能所有其他的进程都阻塞了。
|
|
|
|
|
|
那怎么办呢?Linux有一种机制叫SEM\_UNDO,也即每一个semop操作都会保存一个反向struct sem\_undo操作,当因为某个进程异常退出的时候,这个进程做的所有的操作都会回退,从而保证其他进程可以正常工作。
|
|
|
|
|
|
如果你回头看,我们写的程序里面的semaphore\_p函数和semaphore\_v函数,都把sem\_flg设置为SEM\_UNDO,就是这个作用。
|
|
|
|
|
|
等待队列上的每一个struct sem\_queue,都有一个struct sem\_undo,以此来表示这次操作的反向操作。
|
|
|
|
|
|
```
|
|
|
struct sem_queue {
|
|
|
struct list_head list; /* queue of pending operations */
|
|
|
struct task_struct *sleeper; /* this process */
|
|
|
struct sem_undo *undo; /* undo structure */
|
|
|
int pid; /* process id of requesting process */
|
|
|
int status; /* completion status of operation */
|
|
|
struct sembuf *sops; /* array of pending operations */
|
|
|
struct sembuf *blocking; /* the operation that blocked */
|
|
|
int nsops; /* number of operations */
|
|
|
bool alter; /* does *sops alter the array? */
|
|
|
bool dupsop; /* sops on more than one sem_num */
|
|
|
};
|
|
|
|
|
|
```
|
|
|
|
|
|
在进程的task\_struct里面对于信号量有一个成员struct sysv\_sem,里面是一个struct sem\_undo\_list,将这个进程所有的semop所带来的undo操作都串起来。
|
|
|
|
|
|
```
|
|
|
struct task_struct {
|
|
|
......
|
|
|
struct sysv_sem sysvsem;
|
|
|
......
|
|
|
}
|
|
|
|
|
|
struct sysv_sem {
|
|
|
struct sem_undo_list *undo_list;
|
|
|
};
|
|
|
|
|
|
struct sem_undo {
|
|
|
struct list_head list_proc; /* per-process list: *
|
|
|
* all undos from one process
|
|
|
* rcu protected */
|
|
|
struct rcu_head rcu; /* rcu struct for sem_undo */
|
|
|
struct sem_undo_list *ulp; /* back ptr to sem_undo_list */
|
|
|
struct list_head list_id; /* per semaphore array list:
|
|
|
* all undos for one array */
|
|
|
int semid; /* semaphore set identifier */
|
|
|
short *semadj; /* array of adjustments */
|
|
|
/* one per semaphore */
|
|
|
};
|
|
|
|
|
|
struct sem_undo_list {
|
|
|
atomic_t refcnt;
|
|
|
spinlock_t lock;
|
|
|
struct list_head list_proc;
|
|
|
};
|
|
|
|
|
|
```
|
|
|
|
|
|
为了让你更清楚地理解struct sem\_undo的原理,我们这里举一个例子。
|
|
|
|
|
|
假设我们创建了两个信号量集合。一个叫semaphore1,它包含三个信号量,初始化值为3,另一个叫semaphore2,它包含4个信号量,初始化值都为4。初始化时候的信号量以及undo结构里面的值如图中(1)标号所示。
|
|
|
|
|
|
![](https://static001.geekbang.org/resource/image/03/d6/0352227c5f49d194b6094f229220cdd6.png)
|
|
|
|
|
|
首先,我们来看进程1。我们调用semop,将semaphore1的三个信号量的值,分别加1、加2和减3,从而信号量的值变为4,5,0。于是在semaphore1和进程1链表交汇的undo结构里面,填写-1,-2,+3,是semop操作的反向操作,如图中(2)标号所示。
|
|
|
|
|
|
然后,我们来看进程2。我们调用semop,将semaphore1的三个信号量的值,分别减3、加2和加1,从而信号量的值变为1、7、1。于是在semaphore1和进程2链表交汇的undo结构里面,填写+3、-2、-1,是semop操作的反向操作,如图中(3)标号所示。
|
|
|
|
|
|
然后,我们接着看进程2。我们调用semop,将semaphore2的四个信号量的值,分别减3、加1、加4和减1,从而信号量的值变为1、5、8、3。于是,在semaphore2和进程2链表交汇的undo结构里面,填写+3、-1、-4、+1,是semop操作的反向操作,如图中(4)标号所示。
|
|
|
|
|
|
然后,我们再来看进程1。我们调用semop,将semaphore2的四个信号量的值,分别减1、减4、减5和加2,从而信号量的值变为0、1、3、5。于是在semaphore2和进程1链表交汇的undo结构里面,填写+1、+4、+5、-2,是semop操作的反向操作,如图中(5)标号所示。
|
|
|
|
|
|
从这个例子可以看出,无论哪个进程异常退出,只要将undo结构里面的值加回当前信号量的值,就能够得到正确的信号量的值,不会因为一个进程退出,导致信号量的值处于不一致的状态。
|
|
|
|
|
|
## 总结时刻
|
|
|
|
|
|
信号量的机制也很复杂,我们对着下面这个图总结一下。
|
|
|
|
|
|
![](https://static001.geekbang.org/resource/image/60/7c/6028c83b0aa00e65916988911aa01b7c.png)
|
|
|
|
|
|
1. 调用semget创建信号量集合。
|
|
|
2. ipc\_findkey会在基数树中,根据key查找信号量集合sem\_array对象。如果已经被创建,就会被查询出来。例如producer被创建过,在consumer中就会查询出来。
|
|
|
3. 如果信号量集合没有被创建过,则调用sem\_ops的newary方法,创建一个信号量集合对象sem\_array。例如,在producer中就会新建。
|
|
|
4. 调用semctl(SETALL)初始化信号量。
|
|
|
5. sem\_obtain\_object\_check先从基数树里面找到sem\_array对象。
|
|
|
6. 根据用户指定的信号量数组,初始化信号量集合,也即初始化sem\_array对象的struct sem sems\[\]成员。
|
|
|
7. 调用semop操作信号量。
|
|
|
8. 创建信号量操作结构sem\_queue,放入队列。
|
|
|
9. 创建undo结构,放入链表。
|
|
|
|
|
|
## 课堂练习
|
|
|
|
|
|
现在,我们的共享内存、信号量、消息队列都讲完了,你是不是觉得,它们的API非常相似。为了方便记忆,你可以自己整理一个表格,列一下这三种进程间通信机制、行为创建xxxget、使用、控制xxxctl、对应的API和系统调用。
|
|
|
|
|
|
欢迎留言和我分享你的疑惑和见解 ,也欢迎可以收藏本节内容,反复研读。你也可以把今天的内容分享给你的朋友,和他一起学习和进步。
|
|
|
|