ALSA: usb-audio: add support for Akai MPD16

[safe/jmp/linux-2.6] / ipc / sem.c

diff --git a/ipc/sem.c b/ipc/sem.c
index 4252a8e..dbef95b 100644 (file)
--- a/ipc/sem.c
+++ b/ipc/sem.c
@@ -434,17 +434,56 @@ static void unlink_queue(struct sem_array *sma, struct sem_queue *q)
                sma->complex_count--;
 }
 
                sma->complex_count--;
 }
 

-/* Go through the pending queue for the indicated semaphore
- * looking for tasks that can be completed.
+
+/**
+ * update_queue(sma, semnum): Look for tasks that can be completed.
+ * @sma: semaphore array.
+ * @semnum: semaphore that was modified.
+ *
+ * update_queue must be called after a semaphore in a semaphore array
+ * was modified. If multiple semaphore were modified, then @semnum
+ * must be set to -1.

  */
  */

-static void update_queue (struct sem_array * sma)
+static void update_queue(struct sem_array *sma, int semnum)

 {
 {

-       struct sem_queue *q, *tq;
+       struct sem_queue *q;
+       struct list_head *walk;
+       struct list_head *pending_list;
+       int offset;
+
+       /* if there are complex operations around, then knowing the semaphore
+        * that was modified doesn't help us. Assume that multiple semaphores
+        * were modified.
+        */
+       if (sma->complex_count)
+               semnum = -1;
+
+       if (semnum == -1) {
+               pending_list = &sma->sem_pending;
+               offset = offsetof(struct sem_queue, list);
+       } else {
+               pending_list = &sma->sem_base[semnum].sem_pending;
+               offset = offsetof(struct sem_queue, simple_list);
+       }

 
 again:
 
 again:

-       list_for_each_entry_safe(q, tq, &sma->sem_pending, list) {
-               int error;
-               int alter;
+       walk = pending_list->next;
+       while (walk != pending_list) {
+               int error, alter;
+
+               q = (struct sem_queue *)((char *)walk - offset);
+               walk = walk->next;
+
+               /* If we are scanning the single sop, per-semaphore list of
+                * one semaphore and that semaphore is 0, then it is not
+                * necessary to scan the "alter" entries: simple increments
+                * that affect only one entry succeed immediately and cannot
+                * be in the  per semaphore pending queue, and decrements
+                * cannot be successful if the value is already 0.
+                */
+               if (semnum != -1 && sma->sem_base[semnum].semval == 0 &&
+                               q->alter)
+                       break;

 
                error = try_atomic_semop(sma, q->sops, q->nsops,
                                         q->undo, q->pid);
 
                error = try_atomic_semop(sma, q->sops, q->nsops,
                                         q->undo, q->pid);


@@ -585,7 +624,7 @@ static unsigned long copy_semid_to_user(void __user *buf, struct semid64_ds *in,
 static int semctl_nolock(struct ipc_namespace *ns, int semid,
                         int cmd, int version, union semun arg)
 {
 static int semctl_nolock(struct ipc_namespace *ns, int semid,
                         int cmd, int version, union semun arg)
 {

-       int err = -EINVAL;
+       int err;

        struct sem_array *sma;
 
        switch(cmd) {
        struct sem_array *sma;
 
        switch(cmd) {


@@ -662,7 +701,6 @@ static int semctl_nolock(struct ipc_namespace *ns, int semid,
        default:
                return -EINVAL;
        }
        default:
                return -EINVAL;
        }

-       return err;

 out_unlock:
        sem_unlock(sma);
        return err;
 out_unlock:
        sem_unlock(sma);
        return err;


@@ -769,7 +807,7 @@ static int semctl_main(struct ipc_namespace *ns, int semid, int semnum,
                }
                sma->sem_ctime = get_seconds();
                /* maybe some queued-up processes were waiting for this */
                }
                sma->sem_ctime = get_seconds();
                /* maybe some queued-up processes were waiting for this */

-               update_queue(sma);
+               update_queue(sma, -1);

                err = 0;
                goto out_unlock;
        }
                err = 0;
                goto out_unlock;
        }


@@ -811,7 +849,7 @@ static int semctl_main(struct ipc_namespace *ns, int semid, int semnum,
                curr->sempid = task_tgid_vnr(current);
                sma->sem_ctime = get_seconds();
                /* maybe some queued-up processes were waiting for this */
                curr->sempid = task_tgid_vnr(current);
                sma->sem_ctime = get_seconds();
                /* maybe some queued-up processes were waiting for this */

-               update_queue(sma);
+               update_queue(sma, semnum);

                err = 0;
                goto out_unlock;
        }
                err = 0;
                goto out_unlock;
        }


@@ -1187,7 +1225,8 @@ SYSCALL_DEFINE4(semtimedop, int, semid, struct sembuf __user *, tsops,
        error = try_atomic_semop (sma, sops, nsops, un, task_tgid_vnr(current));
        if (error <= 0) {
                if (alter && error == 0)
        error = try_atomic_semop (sma, sops, nsops, un, task_tgid_vnr(current));
        if (error <= 0) {
                if (alter && error == 0)

-                       update_queue (sma);
+                       update_queue(sma, (nsops == 1) ? sops[0].sem_num : -1);
+

                goto out_unlock_free;
        }
 
                goto out_unlock_free;
        }
 


@@ -1388,7 +1427,7 @@ void exit_sem(struct task_struct *tsk)
                }
                sma->sem_otime = get_seconds();
                /* maybe some queued-up processes were waiting for this */
                }
                sma->sem_otime = get_seconds();
                /* maybe some queued-up processes were waiting for this */

-               update_queue(sma);
+               update_queue(sma, -1);

                sem_unlock(sma);
 
                call_rcu(&un->rcu, free_un);
                sem_unlock(sma);
 
                call_rcu(&un->rcu, free_un);