kernel/locking/rwsem-xadd.c

   1 /* rwsem.c: R/W semaphores: contention handling functions
   2  *
   3  * Written by David Howells (dhowells@redhat.com).
   4  * Derived from arch/i386/kernel/semaphore.c
   5  *
   6  * Writer lock-stealing by Alex Shi <alex.shi@intel.com>
   7  * and Michel Lespinasse <walken@google.com>
   8  *
   9  * Optimistic spinning by Tim Chen <tim.c.chen@intel.com>
  10  * and Davidlohr Bueso <davidlohr@hp.com>. Based on mutexes.
  11  */
  12 #include <linux/rwsem.h>
  13 #include <linux/init.h>
  14 #include <linux/export.h>
  15 #include <linux/sched/signal.h>
  16 #include <linux/sched/rt.h>
  17 #include <linux/sched/wake_q.h>
  18 #include <linux/sched/debug.h>
  19 #include <linux/osq_lock.h>
  20
  21 #include "rwsem.h"
  22
  23 /*
  24  * Guide to the rw_semaphore's count field for common values.
  25  * (32-bit case illustrated, similar for 64-bit)
  26  *
  27  * 0x0000000X   (1) X readers active or attempting lock, no writer waiting
  28  *                  X = #active_readers + #readers attempting to lock
  29  *                  (X*ACTIVE_BIAS)
  30  *
  31  * 0x00000000   rwsem is unlocked, and no one is waiting for the lock or
  32  *              attempting to read lock or write lock.
  33  *
  34  * 0xffff000X   (1) X readers active or attempting lock, with waiters for lock
  35  *                  X = #active readers + # readers attempting lock
  36  *                  (X*ACTIVE_BIAS + WAITING_BIAS)
  37  *              (2) 1 writer attempting lock, no waiters for lock
  38  *                  X-1 = #active readers + #readers attempting lock
  39  *                  ((X-1)*ACTIVE_BIAS + ACTIVE_WRITE_BIAS)
  40  *              (3) 1 writer active, no waiters for lock
  41  *                  X-1 = #active readers + #readers attempting lock
  42  *                  ((X-1)*ACTIVE_BIAS + ACTIVE_WRITE_BIAS)
  43  *
  44  * 0xffff0001   (1) 1 reader active or attempting lock, waiters for lock
  45  *                  (WAITING_BIAS + ACTIVE_BIAS)
  46  *              (2) 1 writer active or attempting lock, no waiters for lock
  47  *                  (ACTIVE_WRITE_BIAS)
  48  *
  49  * 0xffff0000   (1) There are writers or readers queued but none active
  50  *                  or in the process of attempting lock.
  51  *                  (WAITING_BIAS)
  52  *              Note: writer can attempt to steal lock for this count by adding
  53  *              ACTIVE_WRITE_BIAS in cmpxchg and checking the old count
  54  *
  55  * 0xfffe0001   (1) 1 writer active, or attempting lock. Waiters on queue.
  56  *                  (ACTIVE_WRITE_BIAS + WAITING_BIAS)
  57  *
  58  * Note: Readers attempt to lock by adding ACTIVE_BIAS in down_read and checking
  59  *       the count becomes more than 0 for successful lock acquisition,
  60  *       i.e. the case where there are only readers or nobody has lock.
  61  *       (1st and 2nd case above).
  62  *
  63  *       Writers attempt to lock by adding ACTIVE_WRITE_BIAS in down_write and
  64  *       checking the count becomes ACTIVE_WRITE_BIAS for successful lock
  65  *       acquisition (i.e. nobody else has lock or attempts lock).  If
  66  *       unsuccessful, in rwsem_down_write_failed, we'll check to see if there
  67  *       are only waiters but none active (5th case above), and attempt to
  68  *       steal the lock.
  69  *
  70  */
  71
  72 /*
  73  * Initialize an rwsem:
  74  */
  75 void __init_rwsem(struct rw_semaphore *sem, const char *name,
  76                   struct lock_class_key *key)
  77 {
  78 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  79         /*
  80          * Make sure we are not reinitializing a held semaphore:
  81          */
  82         debug_check_no_locks_freed((void *)sem, sizeof(*sem));
  83         lockdep_init_map(&sem->dep_map, name, key, 0);
  84 #endif
  85         atomic_long_set(&sem->count, RWSEM_UNLOCKED_VALUE);
  86         raw_spin_lock_init(&sem->wait_lock);
  87         INIT_LIST_HEAD(&sem->wait_list);
  88 #ifdef CONFIG_RWSEM_SPIN_ON_OWNER
  89         sem->owner = NULL;
  90         osq_lock_init(&sem->osq);
  91 #endif
  92 }
  93
  94 EXPORT_SYMBOL(__init_rwsem);
  95
  96 enum rwsem_waiter_type {
  97         RWSEM_WAITING_FOR_WRITE,
  98         RWSEM_WAITING_FOR_READ
  99 };
 100
 101 struct rwsem_waiter {
 102         struct list_head list;
 103         struct task_struct *task;
 104         enum rwsem_waiter_type type;
 105 };
 106
 107 enum rwsem_wake_type {
 108         RWSEM_WAKE_ANY,         /* Wake whatever's at head of wait list */
 109         RWSEM_WAKE_READERS,     /* Wake readers only */
 110         RWSEM_WAKE_READ_OWNED   /* Waker thread holds the read lock */
 111 };
 112
 113 /*
 114  * handle the lock release when processes blocked on it that can now run
 115  * - if we come here from up_xxxx(), then:
 116  *   - the 'active part' of count (&0x0000ffff) reached 0 (but may have changed)
 117  *   - the 'waiting part' of count (&0xffff0000) is -ve (and will still be so)
 118  * - there must be someone on the queue
 119  * - the wait_lock must be held by the caller
 120  * - tasks are marked for wakeup, the caller must later invoke wake_up_q()
 121  *   to actually wakeup the blocked task(s) and drop the reference count,
 122  *   preferably when the wait_lock is released
 123  * - woken process blocks are discarded from the list after having task zeroed
 124  * - writers are only marked woken if downgrading is false
 125  */
 126 static void __rwsem_mark_wake(struct rw_semaphore *sem,
 127                               enum rwsem_wake_type wake_type,
 128                               struct wake_q_head *wake_q)
 129 {
 130         struct rwsem_waiter *waiter, *tmp;
 131         long oldcount, woken = 0, adjustment = 0;
 132
 133         /*
 134          * Take a peek at the queue head waiter such that we can determine
 135          * the wakeup(s) to perform.
 136          */
 137         waiter = list_first_entry(&sem->wait_list, struct rwsem_waiter, list);
 138
 139         if (waiter->type == RWSEM_WAITING_FOR_WRITE) {
 140                 if (wake_type == RWSEM_WAKE_ANY) {
 141                         /*
 142                          * Mark writer at the front of the queue for wakeup.
 143                          * Until the task is actually later awoken later by
 144                          * the caller, other writers are able to steal it.
 145                          * Readers, on the other hand, will block as they
 146                          * will notice the queued writer.
 147                          */
 148                         wake_q_add(wake_q, waiter->task);
 149                 }
 150
 151                 return;
 152         }
 153
 154         /*
 155          * Writers might steal the lock before we grant it to the next reader.
 156          * We prefer to do the first reader grant before counting readers
 157          * so we can bail out early if a writer stole the lock.
 158          */
 159         if (wake_type != RWSEM_WAKE_READ_OWNED) {
 160                 adjustment = RWSEM_ACTIVE_READ_BIAS;
 161  try_reader_grant:
 162                 oldcount = atomic_long_fetch_add(adjustment, &sem->count);
 163                 if (unlikely(oldcount < RWSEM_WAITING_BIAS)) {
 164                         /*
 165                          * If the count is still less than RWSEM_WAITING_BIAS
 166                          * after removing the adjustment, it is assumed that
 167                          * a writer has stolen the lock. We have to undo our
 168                          * reader grant.
 169                          */
 170                         if (atomic_long_add_return(-adjustment, &sem->count) <
 171                             RWSEM_WAITING_BIAS)
 172                                 return;
 173
 174                         /* Last active locker left. Retry waking readers. */
 175                         goto try_reader_grant;
 176                 }
 177                 /*
 178                  * It is not really necessary to set it to reader-owned here,
 179                  * but it gives the spinners an early indication that the
 180                  * readers now have the lock.
 181                  */
 182                 rwsem_set_reader_owned(sem);
 183         }
 184
 185         /*
 186          * Grant an infinite number of read locks to the readers at the front
 187          * of the queue. We know that woken will be at least 1 as we accounted
 188          * for above. Note we increment the 'active part' of the count by the
 189          * number of readers before waking any processes up.
 190          */
 191         list_for_each_entry_safe(waiter, tmp, &sem->wait_list, list) {
 192                 struct task_struct *tsk;
 193
 194                 if (waiter->type == RWSEM_WAITING_FOR_WRITE)
 195                         break;
 196
 197                 woken++;
 198                 tsk = waiter->task;
 199
 200                 wake_q_add(wake_q, tsk);
 201                 list_del(&waiter->list);
 202                 /*
 203                  * Ensure that the last operation is setting the reader
 204                  * waiter to nil such that rwsem_down_read_failed() cannot
 205                  * race with do_exit() by always holding a reference count
 206                  * to the task to wakeup.
 207                  */
 208                 smp_store_release(&waiter->task, NULL);
 209         }
 210
 211         adjustment = woken * RWSEM_ACTIVE_READ_BIAS - adjustment;
 212         if (list_empty(&sem->wait_list)) {
 213                 /* hit end of list above */
 214                 adjustment -= RWSEM_WAITING_BIAS;
 215         }
 216
 217         if (adjustment)
 218                 atomic_long_add(adjustment, &sem->count);
 219 }
 220
 221 /*
 222  * Wait for the read lock to be granted
 223  */
 224 __visible
 225 struct rw_semaphore __sched *rwsem_down_read_failed(struct rw_semaphore *sem)
 226 {
 227         long count, adjustment = -RWSEM_ACTIVE_READ_BIAS;
 228         struct rwsem_waiter waiter;
 229         DEFINE_WAKE_Q(wake_q);
 230
 231         waiter.task = current;
 232         waiter.type = RWSEM_WAITING_FOR_READ;
 233
 234         raw_spin_lock_irq(&sem->wait_lock);
 235         if (list_empty(&sem->wait_list))
 236                 adjustment += RWSEM_WAITING_BIAS;
 237         list_add_tail(&waiter.list, &sem->wait_list);
 238
 239         /* we're now waiting on the lock, but no longer actively locking */
 240         count = atomic_long_add_return(adjustment, &sem->count);
 241
 242         /*
 243          * If there are no active locks, wake the front queued process(es).
 244          *
 245          * If there are no writers and we are first in the queue,
 246          * wake our own waiter to join the existing active readers !
 247          */
 248         if (count == RWSEM_WAITING_BIAS ||
 249             (count > RWSEM_WAITING_BIAS &&
 250              adjustment != -RWSEM_ACTIVE_READ_BIAS))
 251                 __rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q);
 252
 253         raw_spin_unlock_irq(&sem->wait_lock);
 254         wake_up_q(&wake_q);
 255
 256         /* wait to be given the lock */
 257         while (true) {
 258                 set_current_state(TASK_UNINTERRUPTIBLE);
 259                 if (!waiter.task)
 260                         break;
 261                 schedule();
 262         }
 263
 264         __set_current_state(TASK_RUNNING);
 265         return sem;
 266 }
 267 EXPORT_SYMBOL(rwsem_down_read_failed);
 268
 269 /*
 270  * This function must be called with the sem->wait_lock held to prevent
 271  * race conditions between checking the rwsem wait list and setting the
 272  * sem->count accordingly.
 273  */
 274 static inline bool rwsem_try_write_lock(long count, struct rw_semaphore *sem)
 275 {
 276         /*
 277          * Avoid trying to acquire write lock if count isn't RWSEM_WAITING_BIAS.
 278          */
 279         if (count != RWSEM_WAITING_BIAS)
 280                 return false;
 281
 282         /*
 283          * Acquire the lock by trying to set it to ACTIVE_WRITE_BIAS. If there
 284          * are other tasks on the wait list, we need to add on WAITING_BIAS.
 285          */
 286         count = list_is_singular(&sem->wait_list) ?
 287                         RWSEM_ACTIVE_WRITE_BIAS :
 288                         RWSEM_ACTIVE_WRITE_BIAS + RWSEM_WAITING_BIAS;
 289
 290         if (atomic_long_cmpxchg_acquire(&sem->count, RWSEM_WAITING_BIAS, count)
 291                                                         == RWSEM_WAITING_BIAS) {
 292                 rwsem_set_owner(sem);
 293                 return true;
 294         }
 295
 296         return false;
 297 }
 298
 299 #ifdef CONFIG_RWSEM_SPIN_ON_OWNER
 300 /*
 301  * Try to acquire write lock before the writer has been put on wait queue.
 302  */
 303 static inline bool rwsem_try_write_lock_unqueued(struct rw_semaphore *sem)
 304 {
 305         long old, count = atomic_long_read(&sem->count);
 306
 307         while (true) {
 308                 if (!(count == 0 || count == RWSEM_WAITING_BIAS))
 309                         return false;
 310
 311                 old = atomic_long_cmpxchg_acquire(&sem->count, count,
 312                                       count + RWSEM_ACTIVE_WRITE_BIAS);
 313                 if (old == count) {
 314                         rwsem_set_owner(sem);
 315                         return true;
 316                 }
 317
 318                 count = old;
 319         }
 320 }
 321
 322 static inline bool rwsem_can_spin_on_owner(struct rw_semaphore *sem)
 323 {
 324         struct task_struct *owner;
 325         bool ret = true;
 326
 327         if (need_resched())
 328                 return false;
 329
 330         rcu_read_lock();
 331         owner = READ_ONCE(sem->owner);
 332         if (!rwsem_owner_is_writer(owner)) {
 333                 /*
 334                  * Don't spin if the rwsem is readers owned.
 335                  */
 336                 ret = !rwsem_owner_is_reader(owner);
 337                 goto done;
 338         }
 339
 340         /*
 341          * As lock holder preemption issue, we both skip spinning if task is not
 342          * on cpu or its cpu is preempted
 343          */
 344         ret = owner->on_cpu && !vcpu_is_preempted(task_cpu(owner));
 345 done:
 346         rcu_read_unlock();
 347         return ret;
 348 }
 349
 350 /*
 351  * Return true only if we can still spin on the owner field of the rwsem.
 352  */
 353 static noinline bool rwsem_spin_on_owner(struct rw_semaphore *sem)
 354 {
 355         struct task_struct *owner = READ_ONCE(sem->owner);
 356
 357         if (!rwsem_owner_is_writer(owner))
 358                 goto out;
 359
 360         rcu_read_lock();
 361         while (sem->owner == owner) {
 362                 /*
 363                  * Ensure we emit the owner->on_cpu, dereference _after_
 364                  * checking sem->owner still matches owner, if that fails,
 365                  * owner might point to free()d memory, if it still matches,
 366                  * the rcu_read_lock() ensures the memory stays valid.
 367                  */
 368                 barrier();
 369
 370                 /*
 371                  * abort spinning when need_resched or owner is not running or
 372                  * owner's cpu is preempted.
 373                  */
 374                 if (!owner->on_cpu || need_resched() ||
 375                                 vcpu_is_preempted(task_cpu(owner))) {
 376                         rcu_read_unlock();
 377                         return false;
 378                 }
 379
 380                 cpu_relax();
 381         }
 382         rcu_read_unlock();
 383 out:
 384         /*
 385          * If there is a new owner or the owner is not set, we continue
 386          * spinning.
 387          */
 388         return !rwsem_owner_is_reader(READ_ONCE(sem->owner));
 389 }
 390
 391 static bool rwsem_optimistic_spin(struct rw_semaphore *sem)
 392 {
 393         bool taken = false;
 394
 395         preempt_disable();
 396
 397         /* sem->wait_lock should not be held when doing optimistic spinning */
 398         if (!rwsem_can_spin_on_owner(sem))
 399                 goto done;
 400
 401         if (!osq_lock(&sem->osq))
 402                 goto done;
 403
 404         /*
 405          * Optimistically spin on the owner field and attempt to acquire the
 406          * lock whenever the owner changes. Spinning will be stopped when:
 407          *  1) the owning writer isn't running; or
 408          *  2) readers own the lock as we can't determine if they are
 409          *     actively running or not.
 410          */
 411         while (rwsem_spin_on_owner(sem)) {
 412                 /*
 413                  * Try to acquire the lock
 414                  */
 415                 if (rwsem_try_write_lock_unqueued(sem)) {
 416                         taken = true;
 417                         break;
 418                 }
 419
 420                 /*
 421                  * When there's no owner, we might have preempted between the
 422                  * owner acquiring the lock and setting the owner field. If
 423                  * we're an RT task that will live-lock because we won't let
 424                  * the owner complete.
 425                  */
 426                 if (!sem->owner && (need_resched() || rt_task(current)))
 427                         break;
 428
 429                 /*
 430                  * The cpu_relax() call is a compiler barrier which forces
 431                  * everything in this loop to be re-loaded. We don't need
 432                  * memory barriers as we'll eventually observe the right
 433                  * values at the cost of a few extra spins.
 434                  */
 435                 cpu_relax();
 436         }
 437         osq_unlock(&sem->osq);
 438 done:
 439         preempt_enable();
 440         return taken;
 441 }
 442
 443 /*
 444  * Return true if the rwsem has active spinner
 445  */
 446 static inline bool rwsem_has_spinner(struct rw_semaphore *sem)
 447 {
 448         return osq_is_locked(&sem->osq);
 449 }
 450
 451 #else
 452 static bool rwsem_optimistic_spin(struct rw_semaphore *sem)
 453 {
 454         return false;
 455 }
 456
 457 static inline bool rwsem_has_spinner(struct rw_semaphore *sem)
 458 {
 459         return false;
 460 }
 461 #endif
 462
 463 /*
 464  * Wait until we successfully acquire the write lock
 465  */
 466 static inline struct rw_semaphore *
 467 __rwsem_down_write_failed_common(struct rw_semaphore *sem, int state)
 468 {
 469         long count;
 470         bool waiting = true; /* any queued threads before us */
 471         struct rwsem_waiter waiter;
 472         struct rw_semaphore *ret = sem;
 473         DEFINE_WAKE_Q(wake_q);
 474
 475         /* undo write bias from down_write operation, stop active locking */
 476         count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count);
 477
 478         /* do optimistic spinning and steal lock if possible */
 479         if (rwsem_optimistic_spin(sem))
 480                 return sem;
 481
 482         /*
 483          * Optimistic spinning failed, proceed to the slowpath
 484          * and block until we can acquire the sem.
 485          */
 486         waiter.task = current;
 487         waiter.type = RWSEM_WAITING_FOR_WRITE;
 488
 489         raw_spin_lock_irq(&sem->wait_lock);
 490
 491         /* account for this before adding a new element to the list */
 492         if (list_empty(&sem->wait_list))
 493                 waiting = false;
 494
 495         list_add_tail(&waiter.list, &sem->wait_list);
 496
 497         /* we're now waiting on the lock, but no longer actively locking */
 498         if (waiting) {
 499                 count = atomic_long_read(&sem->count);
 500
 501                 /*
 502                  * If there were already threads queued before us and there are
 503                  * no active writers, the lock must be read owned; so we try to
 504                  * wake any read locks that were queued ahead of us.
 505                  */
 506                 if (count > RWSEM_WAITING_BIAS) {
 507                         __rwsem_mark_wake(sem, RWSEM_WAKE_READERS, &wake_q);
 508                         /*
 509                          * The wakeup is normally called _after_ the wait_lock
 510                          * is released, but given that we are proactively waking
 511                          * readers we can deal with the wake_q overhead as it is
 512                          * similar to releasing and taking the wait_lock again
 513                          * for attempting rwsem_try_write_lock().
 514                          */
 515                         wake_up_q(&wake_q);
 516
 517                         /*
 518                          * Reinitialize wake_q after use.
 519                          */
 520                         wake_q_init(&wake_q);
 521                 }
 522
 523         } else
 524                 count = atomic_long_add_return(RWSEM_WAITING_BIAS, &sem->count);
 525
 526         /* wait until we successfully acquire the lock */
 527         set_current_state(state);
 528         while (true) {
 529                 if (rwsem_try_write_lock(count, sem))
 530                         break;
 531                 raw_spin_unlock_irq(&sem->wait_lock);
 532
 533                 /* Block until there are no active lockers. */
 534                 do {
 535                         if (signal_pending_state(state, current))
 536                                 goto out_nolock;
 537
 538                         schedule();
 539                         set_current_state(state);
 540                 } while ((count = atomic_long_read(&sem->count)) & RWSEM_ACTIVE_MASK);
 541
 542                 raw_spin_lock_irq(&sem->wait_lock);
 543         }
 544         __set_current_state(TASK_RUNNING);
 545         list_del(&waiter.list);
 546         raw_spin_unlock_irq(&sem->wait_lock);
 547
 548         return ret;
 549
 550 out_nolock:
 551         __set_current_state(TASK_RUNNING);
 552         raw_spin_lock_irq(&sem->wait_lock);
 553         list_del(&waiter.list);
 554         if (list_empty(&sem->wait_list))
 555                 atomic_long_add(-RWSEM_WAITING_BIAS, &sem->count);
 556         else
 557                 __rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q);
 558         raw_spin_unlock_irq(&sem->wait_lock);
 559         wake_up_q(&wake_q);
 560
 561         return ERR_PTR(-EINTR);
 562 }
 563
 564 __visible struct rw_semaphore * __sched
 565 rwsem_down_write_failed(struct rw_semaphore *sem)
 566 {
 567         return __rwsem_down_write_failed_common(sem, TASK_UNINTERRUPTIBLE);
 568 }
 569 EXPORT_SYMBOL(rwsem_down_write_failed);
 570
 571 __visible struct rw_semaphore * __sched
 572 rwsem_down_write_failed_killable(struct rw_semaphore *sem)
 573 {
 574         return __rwsem_down_write_failed_common(sem, TASK_KILLABLE);
 575 }
 576 EXPORT_SYMBOL(rwsem_down_write_failed_killable);
 577
 578 /*
 579  * handle waking up a waiter on the semaphore
 580  * - up_read/up_write has decremented the active part of count if we come here
 581  */
 582 __visible
 583 struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem)
 584 {
 585         unsigned long flags;
 586         DEFINE_WAKE_Q(wake_q);
 587
 588         /*
 589          * If a spinner is present, it is not necessary to do the wakeup.
 590          * Try to do wakeup only if the trylock succeeds to minimize
 591          * spinlock contention which may introduce too much delay in the
 592          * unlock operation.
 593          *
 594          *    spinning writer           up_write/up_read caller
 595          *    ---------------           -----------------------
 596          * [S]   osq_unlock()           [L]   osq
 597          *       MB                           RMB
 598          * [RmW] rwsem_try_write_lock() [RmW] spin_trylock(wait_lock)
 599          *
 600          * Here, it is important to make sure that there won't be a missed
 601          * wakeup while the rwsem is free and the only spinning writer goes
 602          * to sleep without taking the rwsem. Even when the spinning writer
 603          * is just going to break out of the waiting loop, it will still do
 604          * a trylock in rwsem_down_write_failed() before sleeping. IOW, if
 605          * rwsem_has_spinner() is true, it will guarantee at least one
 606          * trylock attempt on the rwsem later on.
 607          */
 608         if (rwsem_has_spinner(sem)) {
 609                 /*
 610                  * The smp_rmb() here is to make sure that the spinner
 611                  * state is consulted before reading the wait_lock.
 612                  */
 613                 smp_rmb();
 614                 if (!raw_spin_trylock_irqsave(&sem->wait_lock, flags))
 615                         return sem;
 616                 goto locked;
 617         }
 618         raw_spin_lock_irqsave(&sem->wait_lock, flags);
 619 locked:
 620
 621         if (!list_empty(&sem->wait_list))
 622                 __rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q);
 623
 624         raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
 625         wake_up_q(&wake_q);
 626
 627         return sem;
 628 }
 629 EXPORT_SYMBOL(rwsem_wake);
 630
 631 /*
 632  * downgrade a write lock into a read lock
 633  * - caller incremented waiting part of count and discovered it still negative
 634  * - just wake up any readers at the front of the queue
 635  */
 636 __visible
 637 struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem)
 638 {
 639         unsigned long flags;
 640         DEFINE_WAKE_Q(wake_q);
 641
 642         raw_spin_lock_irqsave(&sem->wait_lock, flags);
 643
 644         if (!list_empty(&sem->wait_list))
 645                 __rwsem_mark_wake(sem, RWSEM_WAKE_READ_OWNED, &wake_q);
 646
 647         raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
 648         wake_up_q(&wake_q);
 649
 650         return sem;
 651 }
 652 EXPORT_SYMBOL(rwsem_downgrade_wake);