Merge tag 'hsi-for-3.16-fixes1' of git://git.kernel.org/pub/scm/linux/kernel/git...

[firefly-linux-kernel-4.4.55.git] / ipc / sem.c

diff --git a/ipc/sem.c b/ipc/sem.c
index b93b561842cdf86a1ed52ba575151980b9d13d5f..454f6c6020a8d98dccb167e46d3a5225d5f4ce2d 100644 (file)
--- a/ipc/sem.c
+++ b/ipc/sem.c
@@ -109,6 +109,7 @@ struct sem_queue {
        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 */
        int                     alter;   /* does *sops alter the array? */
 };
@@ -642,6 +643,8 @@ out_of_range:
        goto undo;
 
 would_block:
+       q->blocking = sop;
+
        if (sop->sem_flg & IPC_NOWAIT)
                result = -EAGAIN;
        else
@@ -990,38 +993,41 @@ static void do_smart_update(struct sem_array *sma, struct sembuf *sops, int nsop
 }
 
 /*
- * check_qop: Test how often a queued operation sleeps on the semaphore semnum
+ * check_qop: Test if a queued operation sleeps on the semaphore semnum
  */
 static int check_qop(struct sem_array *sma, int semnum, struct sem_queue *q,
                        bool count_zero)
 {
-       struct sembuf *sops = q->sops;
-       int nsops = q->nsops;
-       int i, semcnt;
+       struct sembuf *sop = q->blocking;
 
-       semcnt = 0;
+       /*
+        * Linux always (since 0.99.10) reported a task as sleeping on all
+        * semaphores. This violates SUS, therefore it was changed to the
+        * standard compliant behavior.
+        * Give the administrators a chance to notice that an application
+        * might misbehave because it relies on the Linux behavior.
+        */
+       pr_info_once("semctl(GETNCNT/GETZCNT) is since 3.16 Single Unix Specification compliant.\n"
+                       "The task %s (%d) triggered the difference, watch for misbehavior.\n",
+                       current->comm, task_pid_nr(current));
 
-       for (i = 0; i < nsops; i++) {
-               if (sops[i].sem_num != semnum)
-                       continue;
-               if (sops[i].sem_flg & IPC_NOWAIT)
-                       continue;
-               if (count_zero && sops[i].sem_op == 0)
-                       semcnt++;
-               if (!count_zero && sops[i].sem_op < 0)
-                       semcnt++;
-       }
-       return semcnt;
+       if (sop->sem_num != semnum)
+               return 0;
+
+       if (count_zero && sop->sem_op == 0)
+               return 1;
+       if (!count_zero && sop->sem_op < 0)
+               return 1;
+
+       return 0;
 }
 
 /* The following counts are associated to each semaphore:
  *   semncnt        number of tasks waiting on semval being nonzero
  *   semzcnt        number of tasks waiting on semval being zero
- * This model assumes that a task waits on exactly one semaphore.
- * Since semaphore operations are to be performed atomically, tasks actually
- * wait on a whole sequence of semaphores simultaneously.
- * The counts we return here are a rough approximation, but still
- * warrant that semncnt+semzcnt>0 if the task is on the pending queue.
+ *
+ * Per definition, a task waits only on the semaphore of the first semop
+ * that cannot proceed, even if additional operation would block, too.
  */
 static int count_semcnt(struct sem_array *sma, ushort semnum,
                        bool count_zero)