cls_can: Fixed protocol restriction + minor changes.

[lisovros/linux_canprio.git] / lib / rwsem.c

diff --git a/lib/rwsem.c b/lib/rwsem.c
index 94f2d7a9dc4f67d04374688cf572a969c8e51b0f..f236d7cd5cf3e34bab6955613a773aeda8914039 100644 (file)
--- a/lib/rwsem.c
+++ b/lib/rwsem.c
@@ -60,22 +60,28 @@ __rwsem_do_wake(struct rw_semaphore *sem, int wake_type)
        struct rwsem_waiter *waiter;
        struct task_struct *tsk;
        struct list_head *next;
-       signed long oldcount, woken, loop;
+       signed long oldcount, woken, loop, adjustment;
 
        waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
        if (!(waiter->flags & RWSEM_WAITING_FOR_WRITE))
                goto readers_only;
 
        if (wake_type == RWSEM_WAKE_READ_OWNED)
+               /* Another active reader was observed, so wakeup is not
+                * likely to succeed. Save the atomic op.
+                */
                goto out;
 
        /* There's a writer at the front of the queue - try to grant it the
         * write lock.  However, we only wake this writer if we can transition
         * the active part of the count from 0 -> 1
         */
+       adjustment = RWSEM_ACTIVE_WRITE_BIAS;
+       if (waiter->list.next == &sem->wait_list)
+               adjustment -= RWSEM_WAITING_BIAS;
+
  try_again_write:
-       oldcount = rwsem_atomic_update(RWSEM_ACTIVE_BIAS, sem)
-                                               - RWSEM_ACTIVE_BIAS;
+       oldcount = rwsem_atomic_update(adjustment, sem) - adjustment;
        if (oldcount & RWSEM_ACTIVE_MASK)
                /* Someone grabbed the sem already */
                goto undo_write;
@@ -108,8 +114,8 @@ __rwsem_do_wake(struct rw_semaphore *sem, int wake_type)
         * count adjustment pretty soon.
         */
        if (wake_type == RWSEM_WAKE_ANY &&
-           (rwsem_atomic_update(0, sem) & RWSEM_ACTIVE_MASK))
-               /* Someone grabbed the sem already */
+           rwsem_atomic_update(0, sem) < RWSEM_WAITING_BIAS)
+               /* Someone grabbed the sem for write already */
                goto out;
 
        /* Grant an infinite number of read locks to the readers at the front
@@ -128,13 +134,15 @@ __rwsem_do_wake(struct rw_semaphore *sem, int wake_type)
 
        } while (waiter->flags & RWSEM_WAITING_FOR_READ);
 
-       loop = woken;
-       woken *= RWSEM_ACTIVE_BIAS - RWSEM_WAITING_BIAS;
+       adjustment = woken * RWSEM_ACTIVE_READ_BIAS;
+       if (waiter->flags & RWSEM_WAITING_FOR_READ)
+               /* hit end of list above */
+               adjustment -= RWSEM_WAITING_BIAS;
 
-       rwsem_atomic_add(woken, sem);
+       rwsem_atomic_add(adjustment, sem);
 
        next = sem->wait_list.next;
-       for (; loop > 0; loop--) {
+       for (loop = woken; loop > 0; loop--) {
                waiter = list_entry(next, struct rwsem_waiter, list);
                next = waiter->list.next;
                tsk = waiter->task;
@@ -153,7 +161,7 @@ __rwsem_do_wake(struct rw_semaphore *sem, int wake_type)
        /* undo the change to the active count, but check for a transition
         * 1->0 */
  undo_write:
-       if (rwsem_atomic_update(-RWSEM_ACTIVE_BIAS, sem) & RWSEM_ACTIVE_MASK)
+       if (rwsem_atomic_update(-adjustment, sem) & RWSEM_ACTIVE_MASK)
                goto out;
        goto try_again_write;
 }
@@ -163,8 +171,9 @@ __rwsem_do_wake(struct rw_semaphore *sem, int wake_type)
  */
 static struct rw_semaphore __sched *
 rwsem_down_failed_common(struct rw_semaphore *sem,
-                       struct rwsem_waiter *waiter, signed long adjustment)
+                        unsigned int flags, signed long adjustment)
 {
+       struct rwsem_waiter waiter;
        struct task_struct *tsk = current;
        signed long count;
 
@@ -172,23 +181,34 @@ rwsem_down_failed_common(struct rw_semaphore *sem,
 
        /* set up my own style of waitqueue */
        spin_lock_irq(&sem->wait_lock);
-       waiter->task = tsk;
+       waiter.task = tsk;
+       waiter.flags = flags;
        get_task_struct(tsk);
 
-       list_add_tail(&waiter->list, &sem->wait_list);
+       if (list_empty(&sem->wait_list))
+               adjustment += RWSEM_WAITING_BIAS;
+       list_add_tail(&waiter.list, &sem->wait_list);
 
        /* we're now waiting on the lock, but no longer actively locking */
        count = rwsem_atomic_update(adjustment, sem);
 
-       /* if there are no active locks, wake the front queued process(es) up */
-       if (!(count & RWSEM_ACTIVE_MASK))
+       /* If there are no active locks, wake the front queued process(es) up.
+        *
+        * Alternatively, if we're called from a failed down_write(), there
+        * were already threads queued before us and there are no active
+        * writers, the lock must be read owned; so we try to wake any read
+        * locks that were queued ahead of us. */
+       if (count == RWSEM_WAITING_BIAS)
                sem = __rwsem_do_wake(sem, RWSEM_WAKE_NO_ACTIVE);
+       else if (count > RWSEM_WAITING_BIAS &&
+                adjustment == -RWSEM_ACTIVE_WRITE_BIAS)
+               sem = __rwsem_do_wake(sem, RWSEM_WAKE_READ_OWNED);
 
        spin_unlock_irq(&sem->wait_lock);
 
        /* wait to be given the lock */
        for (;;) {
-               if (!waiter->task)
+               if (!waiter.task)
                        break;
                schedule();
                set_task_state(tsk, TASK_UNINTERRUPTIBLE);
@@ -205,12 +225,8 @@ rwsem_down_failed_common(struct rw_semaphore *sem,
 asmregparm struct rw_semaphore __sched *
 rwsem_down_read_failed(struct rw_semaphore *sem)
 {
-       struct rwsem_waiter waiter;
-
-       waiter.flags = RWSEM_WAITING_FOR_READ;
-       rwsem_down_failed_common(sem, &waiter,
-                               RWSEM_WAITING_BIAS - RWSEM_ACTIVE_BIAS);
-       return sem;
+       return rwsem_down_failed_common(sem, RWSEM_WAITING_FOR_READ,
+                                       -RWSEM_ACTIVE_READ_BIAS);
 }
 
 /*
@@ -219,12 +235,8 @@ rwsem_down_read_failed(struct rw_semaphore *sem)
 asmregparm struct rw_semaphore __sched *
 rwsem_down_write_failed(struct rw_semaphore *sem)
 {
-       struct rwsem_waiter waiter;
-
-       waiter.flags = RWSEM_WAITING_FOR_WRITE;
-       rwsem_down_failed_common(sem, &waiter, -RWSEM_ACTIVE_BIAS);
-
-       return sem;
+       return rwsem_down_failed_common(sem, RWSEM_WAITING_FOR_WRITE,
+                                       -RWSEM_ACTIVE_WRITE_BIAS);
 }
 
 /*