Back to home page

LXR

 
 

    


0001 /*
0002  *  Fast Userspace Mutexes (which I call "Futexes!").
0003  *  (C) Rusty Russell, IBM 2002
0004  *
0005  *  Generalized futexes, futex requeueing, misc fixes by Ingo Molnar
0006  *  (C) Copyright 2003 Red Hat Inc, All Rights Reserved
0007  *
0008  *  Removed page pinning, fix privately mapped COW pages and other cleanups
0009  *  (C) Copyright 2003, 2004 Jamie Lokier
0010  *
0011  *  Robust futex support started by Ingo Molnar
0012  *  (C) Copyright 2006 Red Hat Inc, All Rights Reserved
0013  *  Thanks to Thomas Gleixner for suggestions, analysis and fixes.
0014  *
0015  *  PI-futex support started by Ingo Molnar and Thomas Gleixner
0016  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
0017  *  Copyright (C) 2006 Timesys Corp., Thomas Gleixner <tglx@timesys.com>
0018  *
0019  *  PRIVATE futexes by Eric Dumazet
0020  *  Copyright (C) 2007 Eric Dumazet <dada1@cosmosbay.com>
0021  *
0022  *  Requeue-PI support by Darren Hart <dvhltc@us.ibm.com>
0023  *  Copyright (C) IBM Corporation, 2009
0024  *  Thanks to Thomas Gleixner for conceptual design and careful reviews.
0025  *
0026  *  Thanks to Ben LaHaise for yelling "hashed waitqueues" loudly
0027  *  enough at me, Linus for the original (flawed) idea, Matthew
0028  *  Kirkwood for proof-of-concept implementation.
0029  *
0030  *  "The futexes are also cursed."
0031  *  "But they come in a choice of three flavours!"
0032  *
0033  *  This program is free software; you can redistribute it and/or modify
0034  *  it under the terms of the GNU General Public License as published by
0035  *  the Free Software Foundation; either version 2 of the License, or
0036  *  (at your option) any later version.
0037  *
0038  *  This program is distributed in the hope that it will be useful,
0039  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
0040  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0041  *  GNU General Public License for more details.
0042  *
0043  *  You should have received a copy of the GNU General Public License
0044  *  along with this program; if not, write to the Free Software
0045  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
0046  */
0047 #include <linux/slab.h>
0048 #include <linux/poll.h>
0049 #include <linux/fs.h>
0050 #include <linux/file.h>
0051 #include <linux/jhash.h>
0052 #include <linux/init.h>
0053 #include <linux/futex.h>
0054 #include <linux/mount.h>
0055 #include <linux/pagemap.h>
0056 #include <linux/syscalls.h>
0057 #include <linux/signal.h>
0058 #include <linux/export.h>
0059 #include <linux/magic.h>
0060 #include <linux/pid.h>
0061 #include <linux/nsproxy.h>
0062 #include <linux/ptrace.h>
0063 #include <linux/sched/rt.h>
0064 #include <linux/hugetlb.h>
0065 #include <linux/freezer.h>
0066 #include <linux/bootmem.h>
0067 #include <linux/fault-inject.h>
0068 
0069 #include <asm/futex.h>
0070 
0071 #include "locking/rtmutex_common.h"
0072 
0073 /*
0074  * READ this before attempting to hack on futexes!
0075  *
0076  * Basic futex operation and ordering guarantees
0077  * =============================================
0078  *
0079  * The waiter reads the futex value in user space and calls
0080  * futex_wait(). This function computes the hash bucket and acquires
0081  * the hash bucket lock. After that it reads the futex user space value
0082  * again and verifies that the data has not changed. If it has not changed
0083  * it enqueues itself into the hash bucket, releases the hash bucket lock
0084  * and schedules.
0085  *
0086  * The waker side modifies the user space value of the futex and calls
0087  * futex_wake(). This function computes the hash bucket and acquires the
0088  * hash bucket lock. Then it looks for waiters on that futex in the hash
0089  * bucket and wakes them.
0090  *
0091  * In futex wake up scenarios where no tasks are blocked on a futex, taking
0092  * the hb spinlock can be avoided and simply return. In order for this
0093  * optimization to work, ordering guarantees must exist so that the waiter
0094  * being added to the list is acknowledged when the list is concurrently being
0095  * checked by the waker, avoiding scenarios like the following:
0096  *
0097  * CPU 0                               CPU 1
0098  * val = *futex;
0099  * sys_futex(WAIT, futex, val);
0100  *   futex_wait(futex, val);
0101  *   uval = *futex;
0102  *                                     *futex = newval;
0103  *                                     sys_futex(WAKE, futex);
0104  *                                       futex_wake(futex);
0105  *                                       if (queue_empty())
0106  *                                         return;
0107  *   if (uval == val)
0108  *      lock(hash_bucket(futex));
0109  *      queue();
0110  *     unlock(hash_bucket(futex));
0111  *     schedule();
0112  *
0113  * This would cause the waiter on CPU 0 to wait forever because it
0114  * missed the transition of the user space value from val to newval
0115  * and the waker did not find the waiter in the hash bucket queue.
0116  *
0117  * The correct serialization ensures that a waiter either observes
0118  * the changed user space value before blocking or is woken by a
0119  * concurrent waker:
0120  *
0121  * CPU 0                                 CPU 1
0122  * val = *futex;
0123  * sys_futex(WAIT, futex, val);
0124  *   futex_wait(futex, val);
0125  *
0126  *   waiters++; (a)
0127  *   smp_mb(); (A) <-- paired with -.
0128  *                                  |
0129  *   lock(hash_bucket(futex));      |
0130  *                                  |
0131  *   uval = *futex;                 |
0132  *                                  |        *futex = newval;
0133  *                                  |        sys_futex(WAKE, futex);
0134  *                                  |          futex_wake(futex);
0135  *                                  |
0136  *                                  `--------> smp_mb(); (B)
0137  *   if (uval == val)
0138  *     queue();
0139  *     unlock(hash_bucket(futex));
0140  *     schedule();                         if (waiters)
0141  *                                           lock(hash_bucket(futex));
0142  *   else                                    wake_waiters(futex);
0143  *     waiters--; (b)                        unlock(hash_bucket(futex));
0144  *
0145  * Where (A) orders the waiters increment and the futex value read through
0146  * atomic operations (see hb_waiters_inc) and where (B) orders the write
0147  * to futex and the waiters read -- this is done by the barriers for both
0148  * shared and private futexes in get_futex_key_refs().
0149  *
0150  * This yields the following case (where X:=waiters, Y:=futex):
0151  *
0152  *  X = Y = 0
0153  *
0154  *  w[X]=1      w[Y]=1
0155  *  MB      MB
0156  *  r[Y]=y      r[X]=x
0157  *
0158  * Which guarantees that x==0 && y==0 is impossible; which translates back into
0159  * the guarantee that we cannot both miss the futex variable change and the
0160  * enqueue.
0161  *
0162  * Note that a new waiter is accounted for in (a) even when it is possible that
0163  * the wait call can return error, in which case we backtrack from it in (b).
0164  * Refer to the comment in queue_lock().
0165  *
0166  * Similarly, in order to account for waiters being requeued on another
0167  * address we always increment the waiters for the destination bucket before
0168  * acquiring the lock. It then decrements them again  after releasing it -
0169  * the code that actually moves the futex(es) between hash buckets (requeue_futex)
0170  * will do the additional required waiter count housekeeping. This is done for
0171  * double_lock_hb() and double_unlock_hb(), respectively.
0172  */
0173 
0174 #ifndef CONFIG_HAVE_FUTEX_CMPXCHG
0175 int __read_mostly futex_cmpxchg_enabled;
0176 #endif
0177 
0178 /*
0179  * Futex flags used to encode options to functions and preserve them across
0180  * restarts.
0181  */
0182 #ifdef CONFIG_MMU
0183 # define FLAGS_SHARED       0x01
0184 #else
0185 /*
0186  * NOMMU does not have per process address space. Let the compiler optimize
0187  * code away.
0188  */
0189 # define FLAGS_SHARED       0x00
0190 #endif
0191 #define FLAGS_CLOCKRT       0x02
0192 #define FLAGS_HAS_TIMEOUT   0x04
0193 
0194 /*
0195  * Priority Inheritance state:
0196  */
0197 struct futex_pi_state {
0198     /*
0199      * list of 'owned' pi_state instances - these have to be
0200      * cleaned up in do_exit() if the task exits prematurely:
0201      */
0202     struct list_head list;
0203 
0204     /*
0205      * The PI object:
0206      */
0207     struct rt_mutex pi_mutex;
0208 
0209     struct task_struct *owner;
0210     atomic_t refcount;
0211 
0212     union futex_key key;
0213 };
0214 
0215 /**
0216  * struct futex_q - The hashed futex queue entry, one per waiting task
0217  * @list:       priority-sorted list of tasks waiting on this futex
0218  * @task:       the task waiting on the futex
0219  * @lock_ptr:       the hash bucket lock
0220  * @key:        the key the futex is hashed on
0221  * @pi_state:       optional priority inheritance state
0222  * @rt_waiter:      rt_waiter storage for use with requeue_pi
0223  * @requeue_pi_key: the requeue_pi target futex key
0224  * @bitset:     bitset for the optional bitmasked wakeup
0225  *
0226  * We use this hashed waitqueue, instead of a normal wait_queue_t, so
0227  * we can wake only the relevant ones (hashed queues may be shared).
0228  *
0229  * A futex_q has a woken state, just like tasks have TASK_RUNNING.
0230  * It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
0231  * The order of wakeup is always to make the first condition true, then
0232  * the second.
0233  *
0234  * PI futexes are typically woken before they are removed from the hash list via
0235  * the rt_mutex code. See unqueue_me_pi().
0236  */
0237 struct futex_q {
0238     struct plist_node list;
0239 
0240     struct task_struct *task;
0241     spinlock_t *lock_ptr;
0242     union futex_key key;
0243     struct futex_pi_state *pi_state;
0244     struct rt_mutex_waiter *rt_waiter;
0245     union futex_key *requeue_pi_key;
0246     u32 bitset;
0247 };
0248 
0249 static const struct futex_q futex_q_init = {
0250     /* list gets initialized in queue_me()*/
0251     .key = FUTEX_KEY_INIT,
0252     .bitset = FUTEX_BITSET_MATCH_ANY
0253 };
0254 
0255 /*
0256  * Hash buckets are shared by all the futex_keys that hash to the same
0257  * location.  Each key may have multiple futex_q structures, one for each task
0258  * waiting on a futex.
0259  */
0260 struct futex_hash_bucket {
0261     atomic_t waiters;
0262     spinlock_t lock;
0263     struct plist_head chain;
0264 } ____cacheline_aligned_in_smp;
0265 
0266 /*
0267  * The base of the bucket array and its size are always used together
0268  * (after initialization only in hash_futex()), so ensure that they
0269  * reside in the same cacheline.
0270  */
0271 static struct {
0272     struct futex_hash_bucket *queues;
0273     unsigned long            hashsize;
0274 } __futex_data __read_mostly __aligned(2*sizeof(long));
0275 #define futex_queues   (__futex_data.queues)
0276 #define futex_hashsize (__futex_data.hashsize)
0277 
0278 
0279 /*
0280  * Fault injections for futexes.
0281  */
0282 #ifdef CONFIG_FAIL_FUTEX
0283 
0284 static struct {
0285     struct fault_attr attr;
0286 
0287     bool ignore_private;
0288 } fail_futex = {
0289     .attr = FAULT_ATTR_INITIALIZER,
0290     .ignore_private = false,
0291 };
0292 
0293 static int __init setup_fail_futex(char *str)
0294 {
0295     return setup_fault_attr(&fail_futex.attr, str);
0296 }
0297 __setup("fail_futex=", setup_fail_futex);
0298 
0299 static bool should_fail_futex(bool fshared)
0300 {
0301     if (fail_futex.ignore_private && !fshared)
0302         return false;
0303 
0304     return should_fail(&fail_futex.attr, 1);
0305 }
0306 
0307 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
0308 
0309 static int __init fail_futex_debugfs(void)
0310 {
0311     umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
0312     struct dentry *dir;
0313 
0314     dir = fault_create_debugfs_attr("fail_futex", NULL,
0315                     &fail_futex.attr);
0316     if (IS_ERR(dir))
0317         return PTR_ERR(dir);
0318 
0319     if (!debugfs_create_bool("ignore-private", mode, dir,
0320                  &fail_futex.ignore_private)) {
0321         debugfs_remove_recursive(dir);
0322         return -ENOMEM;
0323     }
0324 
0325     return 0;
0326 }
0327 
0328 late_initcall(fail_futex_debugfs);
0329 
0330 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
0331 
0332 #else
0333 static inline bool should_fail_futex(bool fshared)
0334 {
0335     return false;
0336 }
0337 #endif /* CONFIG_FAIL_FUTEX */
0338 
0339 static inline void futex_get_mm(union futex_key *key)
0340 {
0341     atomic_inc(&key->private.mm->mm_count);
0342     /*
0343      * Ensure futex_get_mm() implies a full barrier such that
0344      * get_futex_key() implies a full barrier. This is relied upon
0345      * as smp_mb(); (B), see the ordering comment above.
0346      */
0347     smp_mb__after_atomic();
0348 }
0349 
0350 /*
0351  * Reflects a new waiter being added to the waitqueue.
0352  */
0353 static inline void hb_waiters_inc(struct futex_hash_bucket *hb)
0354 {
0355 #ifdef CONFIG_SMP
0356     atomic_inc(&hb->waiters);
0357     /*
0358      * Full barrier (A), see the ordering comment above.
0359      */
0360     smp_mb__after_atomic();
0361 #endif
0362 }
0363 
0364 /*
0365  * Reflects a waiter being removed from the waitqueue by wakeup
0366  * paths.
0367  */
0368 static inline void hb_waiters_dec(struct futex_hash_bucket *hb)
0369 {
0370 #ifdef CONFIG_SMP
0371     atomic_dec(&hb->waiters);
0372 #endif
0373 }
0374 
0375 static inline int hb_waiters_pending(struct futex_hash_bucket *hb)
0376 {
0377 #ifdef CONFIG_SMP
0378     return atomic_read(&hb->waiters);
0379 #else
0380     return 1;
0381 #endif
0382 }
0383 
0384 /**
0385  * hash_futex - Return the hash bucket in the global hash
0386  * @key:    Pointer to the futex key for which the hash is calculated
0387  *
0388  * We hash on the keys returned from get_futex_key (see below) and return the
0389  * corresponding hash bucket in the global hash.
0390  */
0391 static struct futex_hash_bucket *hash_futex(union futex_key *key)
0392 {
0393     u32 hash = jhash2((u32*)&key->both.word,
0394               (sizeof(key->both.word)+sizeof(key->both.ptr))/4,
0395               key->both.offset);
0396     return &futex_queues[hash & (futex_hashsize - 1)];
0397 }
0398 
0399 
0400 /**
0401  * match_futex - Check whether two futex keys are equal
0402  * @key1:   Pointer to key1
0403  * @key2:   Pointer to key2
0404  *
0405  * Return 1 if two futex_keys are equal, 0 otherwise.
0406  */
0407 static inline int match_futex(union futex_key *key1, union futex_key *key2)
0408 {
0409     return (key1 && key2
0410         && key1->both.word == key2->both.word
0411         && key1->both.ptr == key2->both.ptr
0412         && key1->both.offset == key2->both.offset);
0413 }
0414 
0415 /*
0416  * Take a reference to the resource addressed by a key.
0417  * Can be called while holding spinlocks.
0418  *
0419  */
0420 static void get_futex_key_refs(union futex_key *key)
0421 {
0422     if (!key->both.ptr)
0423         return;
0424 
0425     /*
0426      * On MMU less systems futexes are always "private" as there is no per
0427      * process address space. We need the smp wmb nevertheless - yes,
0428      * arch/blackfin has MMU less SMP ...
0429      */
0430     if (!IS_ENABLED(CONFIG_MMU)) {
0431         smp_mb(); /* explicit smp_mb(); (B) */
0432         return;
0433     }
0434 
0435     switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
0436     case FUT_OFF_INODE:
0437         ihold(key->shared.inode); /* implies smp_mb(); (B) */
0438         break;
0439     case FUT_OFF_MMSHARED:
0440         futex_get_mm(key); /* implies smp_mb(); (B) */
0441         break;
0442     default:
0443         /*
0444          * Private futexes do not hold reference on an inode or
0445          * mm, therefore the only purpose of calling get_futex_key_refs
0446          * is because we need the barrier for the lockless waiter check.
0447          */
0448         smp_mb(); /* explicit smp_mb(); (B) */
0449     }
0450 }
0451 
0452 /*
0453  * Drop a reference to the resource addressed by a key.
0454  * The hash bucket spinlock must not be held. This is
0455  * a no-op for private futexes, see comment in the get
0456  * counterpart.
0457  */
0458 static void drop_futex_key_refs(union futex_key *key)
0459 {
0460     if (!key->both.ptr) {
0461         /* If we're here then we tried to put a key we failed to get */
0462         WARN_ON_ONCE(1);
0463         return;
0464     }
0465 
0466     if (!IS_ENABLED(CONFIG_MMU))
0467         return;
0468 
0469     switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
0470     case FUT_OFF_INODE:
0471         iput(key->shared.inode);
0472         break;
0473     case FUT_OFF_MMSHARED:
0474         mmdrop(key->private.mm);
0475         break;
0476     }
0477 }
0478 
0479 /**
0480  * get_futex_key() - Get parameters which are the keys for a futex
0481  * @uaddr:  virtual address of the futex
0482  * @fshared:    0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
0483  * @key:    address where result is stored.
0484  * @rw:     mapping needs to be read/write (values: VERIFY_READ,
0485  *              VERIFY_WRITE)
0486  *
0487  * Return: a negative error code or 0
0488  *
0489  * The key words are stored in *key on success.
0490  *
0491  * For shared mappings, it's (page->index, file_inode(vma->vm_file),
0492  * offset_within_page).  For private mappings, it's (uaddr, current->mm).
0493  * We can usually work out the index without swapping in the page.
0494  *
0495  * lock_page() might sleep, the caller should not hold a spinlock.
0496  */
0497 static int
0498 get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
0499 {
0500     unsigned long address = (unsigned long)uaddr;
0501     struct mm_struct *mm = current->mm;
0502     struct page *page, *tail;
0503     struct address_space *mapping;
0504     int err, ro = 0;
0505 
0506     /*
0507      * The futex address must be "naturally" aligned.
0508      */
0509     key->both.offset = address % PAGE_SIZE;
0510     if (unlikely((address % sizeof(u32)) != 0))
0511         return -EINVAL;
0512     address -= key->both.offset;
0513 
0514     if (unlikely(!access_ok(rw, uaddr, sizeof(u32))))
0515         return -EFAULT;
0516 
0517     if (unlikely(should_fail_futex(fshared)))
0518         return -EFAULT;
0519 
0520     /*
0521      * PROCESS_PRIVATE futexes are fast.
0522      * As the mm cannot disappear under us and the 'key' only needs
0523      * virtual address, we dont even have to find the underlying vma.
0524      * Note : We do have to check 'uaddr' is a valid user address,
0525      *        but access_ok() should be faster than find_vma()
0526      */
0527     if (!fshared) {
0528         key->private.mm = mm;
0529         key->private.address = address;
0530         get_futex_key_refs(key);  /* implies smp_mb(); (B) */
0531         return 0;
0532     }
0533 
0534 again:
0535     /* Ignore any VERIFY_READ mapping (futex common case) */
0536     if (unlikely(should_fail_futex(fshared)))
0537         return -EFAULT;
0538 
0539     err = get_user_pages_fast(address, 1, 1, &page);
0540     /*
0541      * If write access is not required (eg. FUTEX_WAIT), try
0542      * and get read-only access.
0543      */
0544     if (err == -EFAULT && rw == VERIFY_READ) {
0545         err = get_user_pages_fast(address, 1, 0, &page);
0546         ro = 1;
0547     }
0548     if (err < 0)
0549         return err;
0550     else
0551         err = 0;
0552 
0553     /*
0554      * The treatment of mapping from this point on is critical. The page
0555      * lock protects many things but in this context the page lock
0556      * stabilizes mapping, prevents inode freeing in the shared
0557      * file-backed region case and guards against movement to swap cache.
0558      *
0559      * Strictly speaking the page lock is not needed in all cases being
0560      * considered here and page lock forces unnecessarily serialization
0561      * From this point on, mapping will be re-verified if necessary and
0562      * page lock will be acquired only if it is unavoidable
0563      *
0564      * Mapping checks require the head page for any compound page so the
0565      * head page and mapping is looked up now. For anonymous pages, it
0566      * does not matter if the page splits in the future as the key is
0567      * based on the address. For filesystem-backed pages, the tail is
0568      * required as the index of the page determines the key. For
0569      * base pages, there is no tail page and tail == page.
0570      */
0571     tail = page;
0572     page = compound_head(page);
0573     mapping = READ_ONCE(page->mapping);
0574 
0575     /*
0576      * If page->mapping is NULL, then it cannot be a PageAnon
0577      * page; but it might be the ZERO_PAGE or in the gate area or
0578      * in a special mapping (all cases which we are happy to fail);
0579      * or it may have been a good file page when get_user_pages_fast
0580      * found it, but truncated or holepunched or subjected to
0581      * invalidate_complete_page2 before we got the page lock (also
0582      * cases which we are happy to fail).  And we hold a reference,
0583      * so refcount care in invalidate_complete_page's remove_mapping
0584      * prevents drop_caches from setting mapping to NULL beneath us.
0585      *
0586      * The case we do have to guard against is when memory pressure made
0587      * shmem_writepage move it from filecache to swapcache beneath us:
0588      * an unlikely race, but we do need to retry for page->mapping.
0589      */
0590     if (unlikely(!mapping)) {
0591         int shmem_swizzled;
0592 
0593         /*
0594          * Page lock is required to identify which special case above
0595          * applies. If this is really a shmem page then the page lock
0596          * will prevent unexpected transitions.
0597          */
0598         lock_page(page);
0599         shmem_swizzled = PageSwapCache(page) || page->mapping;
0600         unlock_page(page);
0601         put_page(page);
0602 
0603         if (shmem_swizzled)
0604             goto again;
0605 
0606         return -EFAULT;
0607     }
0608 
0609     /*
0610      * Private mappings are handled in a simple way.
0611      *
0612      * If the futex key is stored on an anonymous page, then the associated
0613      * object is the mm which is implicitly pinned by the calling process.
0614      *
0615      * NOTE: When userspace waits on a MAP_SHARED mapping, even if
0616      * it's a read-only handle, it's expected that futexes attach to
0617      * the object not the particular process.
0618      */
0619     if (PageAnon(page)) {
0620         /*
0621          * A RO anonymous page will never change and thus doesn't make
0622          * sense for futex operations.
0623          */
0624         if (unlikely(should_fail_futex(fshared)) || ro) {
0625             err = -EFAULT;
0626             goto out;
0627         }
0628 
0629         key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
0630         key->private.mm = mm;
0631         key->private.address = address;
0632 
0633         get_futex_key_refs(key); /* implies smp_mb(); (B) */
0634 
0635     } else {
0636         struct inode *inode;
0637 
0638         /*
0639          * The associated futex object in this case is the inode and
0640          * the page->mapping must be traversed. Ordinarily this should
0641          * be stabilised under page lock but it's not strictly
0642          * necessary in this case as we just want to pin the inode, not
0643          * update the radix tree or anything like that.
0644          *
0645          * The RCU read lock is taken as the inode is finally freed
0646          * under RCU. If the mapping still matches expectations then the
0647          * mapping->host can be safely accessed as being a valid inode.
0648          */
0649         rcu_read_lock();
0650 
0651         if (READ_ONCE(page->mapping) != mapping) {
0652             rcu_read_unlock();
0653             put_page(page);
0654 
0655             goto again;
0656         }
0657 
0658         inode = READ_ONCE(mapping->host);
0659         if (!inode) {
0660             rcu_read_unlock();
0661             put_page(page);
0662 
0663             goto again;
0664         }
0665 
0666         /*
0667          * Take a reference unless it is about to be freed. Previously
0668          * this reference was taken by ihold under the page lock
0669          * pinning the inode in place so i_lock was unnecessary. The
0670          * only way for this check to fail is if the inode was
0671          * truncated in parallel so warn for now if this happens.
0672          *
0673          * We are not calling into get_futex_key_refs() in file-backed
0674          * cases, therefore a successful atomic_inc return below will
0675          * guarantee that get_futex_key() will still imply smp_mb(); (B).
0676          */
0677         if (WARN_ON_ONCE(!atomic_inc_not_zero(&inode->i_count))) {
0678             rcu_read_unlock();
0679             put_page(page);
0680 
0681             goto again;
0682         }
0683 
0684         /* Should be impossible but lets be paranoid for now */
0685         if (WARN_ON_ONCE(inode->i_mapping != mapping)) {
0686             err = -EFAULT;
0687             rcu_read_unlock();
0688             iput(inode);
0689 
0690             goto out;
0691         }
0692 
0693         key->both.offset |= FUT_OFF_INODE; /* inode-based key */
0694         key->shared.inode = inode;
0695         key->shared.pgoff = basepage_index(tail);
0696         rcu_read_unlock();
0697     }
0698 
0699 out:
0700     put_page(page);
0701     return err;
0702 }
0703 
0704 static inline void put_futex_key(union futex_key *key)
0705 {
0706     drop_futex_key_refs(key);
0707 }
0708 
0709 /**
0710  * fault_in_user_writeable() - Fault in user address and verify RW access
0711  * @uaddr:  pointer to faulting user space address
0712  *
0713  * Slow path to fixup the fault we just took in the atomic write
0714  * access to @uaddr.
0715  *
0716  * We have no generic implementation of a non-destructive write to the
0717  * user address. We know that we faulted in the atomic pagefault
0718  * disabled section so we can as well avoid the #PF overhead by
0719  * calling get_user_pages() right away.
0720  */
0721 static int fault_in_user_writeable(u32 __user *uaddr)
0722 {
0723     struct mm_struct *mm = current->mm;
0724     int ret;
0725 
0726     down_read(&mm->mmap_sem);
0727     ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
0728                    FAULT_FLAG_WRITE, NULL);
0729     up_read(&mm->mmap_sem);
0730 
0731     return ret < 0 ? ret : 0;
0732 }
0733 
0734 /**
0735  * futex_top_waiter() - Return the highest priority waiter on a futex
0736  * @hb:     the hash bucket the futex_q's reside in
0737  * @key:    the futex key (to distinguish it from other futex futex_q's)
0738  *
0739  * Must be called with the hb lock held.
0740  */
0741 static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
0742                     union futex_key *key)
0743 {
0744     struct futex_q *this;
0745 
0746     plist_for_each_entry(this, &hb->chain, list) {
0747         if (match_futex(&this->key, key))
0748             return this;
0749     }
0750     return NULL;
0751 }
0752 
0753 static int cmpxchg_futex_value_locked(u32 *curval, u32 __user *uaddr,
0754                       u32 uval, u32 newval)
0755 {
0756     int ret;
0757 
0758     pagefault_disable();
0759     ret = futex_atomic_cmpxchg_inatomic(curval, uaddr, uval, newval);
0760     pagefault_enable();
0761 
0762     return ret;
0763 }
0764 
0765 static int get_futex_value_locked(u32 *dest, u32 __user *from)
0766 {
0767     int ret;
0768 
0769     pagefault_disable();
0770     ret = __get_user(*dest, from);
0771     pagefault_enable();
0772 
0773     return ret ? -EFAULT : 0;
0774 }
0775 
0776 
0777 /*
0778  * PI code:
0779  */
0780 static int refill_pi_state_cache(void)
0781 {
0782     struct futex_pi_state *pi_state;
0783 
0784     if (likely(current->pi_state_cache))
0785         return 0;
0786 
0787     pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
0788 
0789     if (!pi_state)
0790         return -ENOMEM;
0791 
0792     INIT_LIST_HEAD(&pi_state->list);
0793     /* pi_mutex gets initialized later */
0794     pi_state->owner = NULL;
0795     atomic_set(&pi_state->refcount, 1);
0796     pi_state->key = FUTEX_KEY_INIT;
0797 
0798     current->pi_state_cache = pi_state;
0799 
0800     return 0;
0801 }
0802 
0803 static struct futex_pi_state * alloc_pi_state(void)
0804 {
0805     struct futex_pi_state *pi_state = current->pi_state_cache;
0806 
0807     WARN_ON(!pi_state);
0808     current->pi_state_cache = NULL;
0809 
0810     return pi_state;
0811 }
0812 
0813 /*
0814  * Drops a reference to the pi_state object and frees or caches it
0815  * when the last reference is gone.
0816  *
0817  * Must be called with the hb lock held.
0818  */
0819 static void put_pi_state(struct futex_pi_state *pi_state)
0820 {
0821     if (!pi_state)
0822         return;
0823 
0824     if (!atomic_dec_and_test(&pi_state->refcount))
0825         return;
0826 
0827     /*
0828      * If pi_state->owner is NULL, the owner is most probably dying
0829      * and has cleaned up the pi_state already
0830      */
0831     if (pi_state->owner) {
0832         raw_spin_lock_irq(&pi_state->owner->pi_lock);
0833         list_del_init(&pi_state->list);
0834         raw_spin_unlock_irq(&pi_state->owner->pi_lock);
0835 
0836         rt_mutex_proxy_unlock(&pi_state->pi_mutex, pi_state->owner);
0837     }
0838 
0839     if (current->pi_state_cache)
0840         kfree(pi_state);
0841     else {
0842         /*
0843          * pi_state->list is already empty.
0844          * clear pi_state->owner.
0845          * refcount is at 0 - put it back to 1.
0846          */
0847         pi_state->owner = NULL;
0848         atomic_set(&pi_state->refcount, 1);
0849         current->pi_state_cache = pi_state;
0850     }
0851 }
0852 
0853 /*
0854  * Look up the task based on what TID userspace gave us.
0855  * We dont trust it.
0856  */
0857 static struct task_struct * futex_find_get_task(pid_t pid)
0858 {
0859     struct task_struct *p;
0860 
0861     rcu_read_lock();
0862     p = find_task_by_vpid(pid);
0863     if (p)
0864         get_task_struct(p);
0865 
0866     rcu_read_unlock();
0867 
0868     return p;
0869 }
0870 
0871 /*
0872  * This task is holding PI mutexes at exit time => bad.
0873  * Kernel cleans up PI-state, but userspace is likely hosed.
0874  * (Robust-futex cleanup is separate and might save the day for userspace.)
0875  */
0876 void exit_pi_state_list(struct task_struct *curr)
0877 {
0878     struct list_head *next, *head = &curr->pi_state_list;
0879     struct futex_pi_state *pi_state;
0880     struct futex_hash_bucket *hb;
0881     union futex_key key = FUTEX_KEY_INIT;
0882 
0883     if (!futex_cmpxchg_enabled)
0884         return;
0885     /*
0886      * We are a ZOMBIE and nobody can enqueue itself on
0887      * pi_state_list anymore, but we have to be careful
0888      * versus waiters unqueueing themselves:
0889      */
0890     raw_spin_lock_irq(&curr->pi_lock);
0891     while (!list_empty(head)) {
0892 
0893         next = head->next;
0894         pi_state = list_entry(next, struct futex_pi_state, list);
0895         key = pi_state->key;
0896         hb = hash_futex(&key);
0897         raw_spin_unlock_irq(&curr->pi_lock);
0898 
0899         spin_lock(&hb->lock);
0900 
0901         raw_spin_lock_irq(&curr->pi_lock);
0902         /*
0903          * We dropped the pi-lock, so re-check whether this
0904          * task still owns the PI-state:
0905          */
0906         if (head->next != next) {
0907             spin_unlock(&hb->lock);
0908             continue;
0909         }
0910 
0911         WARN_ON(pi_state->owner != curr);
0912         WARN_ON(list_empty(&pi_state->list));
0913         list_del_init(&pi_state->list);
0914         pi_state->owner = NULL;
0915         raw_spin_unlock_irq(&curr->pi_lock);
0916 
0917         rt_mutex_unlock(&pi_state->pi_mutex);
0918 
0919         spin_unlock(&hb->lock);
0920 
0921         raw_spin_lock_irq(&curr->pi_lock);
0922     }
0923     raw_spin_unlock_irq(&curr->pi_lock);
0924 }
0925 
0926 /*
0927  * We need to check the following states:
0928  *
0929  *      Waiter | pi_state | pi->owner | uTID      | uODIED | ?
0930  *
0931  * [1]  NULL   | ---      | ---       | 0         | 0/1    | Valid
0932  * [2]  NULL   | ---      | ---       | >0        | 0/1    | Valid
0933  *
0934  * [3]  Found  | NULL     | --        | Any       | 0/1    | Invalid
0935  *
0936  * [4]  Found  | Found    | NULL      | 0         | 1      | Valid
0937  * [5]  Found  | Found    | NULL      | >0        | 1      | Invalid
0938  *
0939  * [6]  Found  | Found    | task      | 0         | 1      | Valid
0940  *
0941  * [7]  Found  | Found    | NULL      | Any       | 0      | Invalid
0942  *
0943  * [8]  Found  | Found    | task      | ==taskTID | 0/1    | Valid
0944  * [9]  Found  | Found    | task      | 0         | 0      | Invalid
0945  * [10] Found  | Found    | task      | !=taskTID | 0/1    | Invalid
0946  *
0947  * [1]  Indicates that the kernel can acquire the futex atomically. We
0948  *  came came here due to a stale FUTEX_WAITERS/FUTEX_OWNER_DIED bit.
0949  *
0950  * [2]  Valid, if TID does not belong to a kernel thread. If no matching
0951  *      thread is found then it indicates that the owner TID has died.
0952  *
0953  * [3]  Invalid. The waiter is queued on a non PI futex
0954  *
0955  * [4]  Valid state after exit_robust_list(), which sets the user space
0956  *  value to FUTEX_WAITERS | FUTEX_OWNER_DIED.
0957  *
0958  * [5]  The user space value got manipulated between exit_robust_list()
0959  *  and exit_pi_state_list()
0960  *
0961  * [6]  Valid state after exit_pi_state_list() which sets the new owner in
0962  *  the pi_state but cannot access the user space value.
0963  *
0964  * [7]  pi_state->owner can only be NULL when the OWNER_DIED bit is set.
0965  *
0966  * [8]  Owner and user space value match
0967  *
0968  * [9]  There is no transient state which sets the user space TID to 0
0969  *  except exit_robust_list(), but this is indicated by the
0970  *  FUTEX_OWNER_DIED bit. See [4]
0971  *
0972  * [10] There is no transient state which leaves owner and user space
0973  *  TID out of sync.
0974  */
0975 
0976 /*
0977  * Validate that the existing waiter has a pi_state and sanity check
0978  * the pi_state against the user space value. If correct, attach to
0979  * it.
0980  */
0981 static int attach_to_pi_state(u32 uval, struct futex_pi_state *pi_state,
0982                   struct futex_pi_state **ps)
0983 {
0984     pid_t pid = uval & FUTEX_TID_MASK;
0985 
0986     /*
0987      * Userspace might have messed up non-PI and PI futexes [3]
0988      */
0989     if (unlikely(!pi_state))
0990         return -EINVAL;
0991 
0992     WARN_ON(!atomic_read(&pi_state->refcount));
0993 
0994     /*
0995      * Handle the owner died case:
0996      */
0997     if (uval & FUTEX_OWNER_DIED) {
0998         /*
0999          * exit_pi_state_list sets owner to NULL and wakes the
1000          * topmost waiter. The task which acquires the
1001          * pi_state->rt_mutex will fixup owner.
1002          */
1003         if (!pi_state->owner) {
1004             /*
1005              * No pi state owner, but the user space TID
1006              * is not 0. Inconsistent state. [5]
1007              */
1008             if (pid)
1009                 return -EINVAL;
1010             /*
1011              * Take a ref on the state and return success. [4]
1012              */
1013             goto out_state;
1014         }
1015 
1016         /*
1017          * If TID is 0, then either the dying owner has not
1018          * yet executed exit_pi_state_list() or some waiter
1019          * acquired the rtmutex in the pi state, but did not
1020          * yet fixup the TID in user space.
1021          *
1022          * Take a ref on the state and return success. [6]
1023          */
1024         if (!pid)
1025             goto out_state;
1026     } else {
1027         /*
1028          * If the owner died bit is not set, then the pi_state
1029          * must have an owner. [7]
1030          */
1031         if (!pi_state->owner)
1032             return -EINVAL;
1033     }
1034 
1035     /*
1036      * Bail out if user space manipulated the futex value. If pi
1037      * state exists then the owner TID must be the same as the
1038      * user space TID. [9/10]
1039      */
1040     if (pid != task_pid_vnr(pi_state->owner))
1041         return -EINVAL;
1042 out_state:
1043     atomic_inc(&pi_state->refcount);
1044     *ps = pi_state;
1045     return 0;
1046 }
1047 
1048 /*
1049  * Lookup the task for the TID provided from user space and attach to
1050  * it after doing proper sanity checks.
1051  */
1052 static int attach_to_pi_owner(u32 uval, union futex_key *key,
1053                   struct futex_pi_state **ps)
1054 {
1055     pid_t pid = uval & FUTEX_TID_MASK;
1056     struct futex_pi_state *pi_state;
1057     struct task_struct *p;
1058 
1059     /*
1060      * We are the first waiter - try to look up the real owner and attach
1061      * the new pi_state to it, but bail out when TID = 0 [1]
1062      */
1063     if (!pid)
1064         return -ESRCH;
1065     p = futex_find_get_task(pid);
1066     if (!p)
1067         return -ESRCH;
1068 
1069     if (unlikely(p->flags & PF_KTHREAD)) {
1070         put_task_struct(p);
1071         return -EPERM;
1072     }
1073 
1074     /*
1075      * We need to look at the task state flags to figure out,
1076      * whether the task is exiting. To protect against the do_exit
1077      * change of the task flags, we do this protected by
1078      * p->pi_lock:
1079      */
1080     raw_spin_lock_irq(&p->pi_lock);
1081     if (unlikely(p->flags & PF_EXITING)) {
1082         /*
1083          * The task is on the way out. When PF_EXITPIDONE is
1084          * set, we know that the task has finished the
1085          * cleanup:
1086          */
1087         int ret = (p->flags & PF_EXITPIDONE) ? -ESRCH : -EAGAIN;
1088 
1089         raw_spin_unlock_irq(&p->pi_lock);
1090         put_task_struct(p);
1091         return ret;
1092     }
1093 
1094     /*
1095      * No existing pi state. First waiter. [2]
1096      */
1097     pi_state = alloc_pi_state();
1098 
1099     /*
1100      * Initialize the pi_mutex in locked state and make @p
1101      * the owner of it:
1102      */
1103     rt_mutex_init_proxy_locked(&pi_state->pi_mutex, p);
1104 
1105     /* Store the key for possible exit cleanups: */
1106     pi_state->key = *key;
1107 
1108     WARN_ON(!list_empty(&pi_state->list));
1109     list_add(&pi_state->list, &p->pi_state_list);
1110     pi_state->owner = p;
1111     raw_spin_unlock_irq(&p->pi_lock);
1112 
1113     put_task_struct(p);
1114 
1115     *ps = pi_state;
1116 
1117     return 0;
1118 }
1119 
1120 static int lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
1121                union futex_key *key, struct futex_pi_state **ps)
1122 {
1123     struct futex_q *match = futex_top_waiter(hb, key);
1124 
1125     /*
1126      * If there is a waiter on that futex, validate it and
1127      * attach to the pi_state when the validation succeeds.
1128      */
1129     if (match)
1130         return attach_to_pi_state(uval, match->pi_state, ps);
1131 
1132     /*
1133      * We are the first waiter - try to look up the owner based on
1134      * @uval and attach to it.
1135      */
1136     return attach_to_pi_owner(uval, key, ps);
1137 }
1138 
1139 static int lock_pi_update_atomic(u32 __user *uaddr, u32 uval, u32 newval)
1140 {
1141     u32 uninitialized_var(curval);
1142 
1143     if (unlikely(should_fail_futex(true)))
1144         return -EFAULT;
1145 
1146     if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)))
1147         return -EFAULT;
1148 
1149     /*If user space value changed, let the caller retry */
1150     return curval != uval ? -EAGAIN : 0;
1151 }
1152 
1153 /**
1154  * futex_lock_pi_atomic() - Atomic work required to acquire a pi aware futex
1155  * @uaddr:      the pi futex user address
1156  * @hb:         the pi futex hash bucket
1157  * @key:        the futex key associated with uaddr and hb
1158  * @ps:         the pi_state pointer where we store the result of the
1159  *          lookup
1160  * @task:       the task to perform the atomic lock work for.  This will
1161  *          be "current" except in the case of requeue pi.
1162  * @set_waiters:    force setting the FUTEX_WAITERS bit (1) or not (0)
1163  *
1164  * Return:
1165  *  0 - ready to wait;
1166  *  1 - acquired the lock;
1167  * <0 - error
1168  *
1169  * The hb->lock and futex_key refs shall be held by the caller.
1170  */
1171 static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
1172                 union futex_key *key,
1173                 struct futex_pi_state **ps,
1174                 struct task_struct *task, int set_waiters)
1175 {
1176     u32 uval, newval, vpid = task_pid_vnr(task);
1177     struct futex_q *match;
1178     int ret;
1179 
1180     /*
1181      * Read the user space value first so we can validate a few
1182      * things before proceeding further.
1183      */
1184     if (get_futex_value_locked(&uval, uaddr))
1185         return -EFAULT;
1186 
1187     if (unlikely(should_fail_futex(true)))
1188         return -EFAULT;
1189 
1190     /*
1191      * Detect deadlocks.
1192      */
1193     if ((unlikely((uval & FUTEX_TID_MASK) == vpid)))
1194         return -EDEADLK;
1195 
1196     if ((unlikely(should_fail_futex(true))))
1197         return -EDEADLK;
1198 
1199     /*
1200      * Lookup existing state first. If it exists, try to attach to
1201      * its pi_state.
1202      */
1203     match = futex_top_waiter(hb, key);
1204     if (match)
1205         return attach_to_pi_state(uval, match->pi_state, ps);
1206 
1207     /*
1208      * No waiter and user TID is 0. We are here because the
1209      * waiters or the owner died bit is set or called from
1210      * requeue_cmp_pi or for whatever reason something took the
1211      * syscall.
1212      */
1213     if (!(uval & FUTEX_TID_MASK)) {
1214         /*
1215          * We take over the futex. No other waiters and the user space
1216          * TID is 0. We preserve the owner died bit.
1217          */
1218         newval = uval & FUTEX_OWNER_DIED;
1219         newval |= vpid;
1220 
1221         /* The futex requeue_pi code can enforce the waiters bit */
1222         if (set_waiters)
1223             newval |= FUTEX_WAITERS;
1224 
1225         ret = lock_pi_update_atomic(uaddr, uval, newval);
1226         /* If the take over worked, return 1 */
1227         return ret < 0 ? ret : 1;
1228     }
1229 
1230     /*
1231      * First waiter. Set the waiters bit before attaching ourself to
1232      * the owner. If owner tries to unlock, it will be forced into
1233      * the kernel and blocked on hb->lock.
1234      */
1235     newval = uval | FUTEX_WAITERS;
1236     ret = lock_pi_update_atomic(uaddr, uval, newval);
1237     if (ret)
1238         return ret;
1239     /*
1240      * If the update of the user space value succeeded, we try to
1241      * attach to the owner. If that fails, no harm done, we only
1242      * set the FUTEX_WAITERS bit in the user space variable.
1243      */
1244     return attach_to_pi_owner(uval, key, ps);
1245 }
1246 
1247 /**
1248  * __unqueue_futex() - Remove the futex_q from its futex_hash_bucket
1249  * @q:  The futex_q to unqueue
1250  *
1251  * The q->lock_ptr must not be NULL and must be held by the caller.
1252  */
1253 static void __unqueue_futex(struct futex_q *q)
1254 {
1255     struct futex_hash_bucket *hb;
1256 
1257     if (WARN_ON_SMP(!q->lock_ptr || !spin_is_locked(q->lock_ptr))
1258         || WARN_ON(plist_node_empty(&q->list)))
1259         return;
1260 
1261     hb = container_of(q->lock_ptr, struct futex_hash_bucket, lock);
1262     plist_del(&q->list, &hb->chain);
1263     hb_waiters_dec(hb);
1264 }
1265 
1266 /*
1267  * The hash bucket lock must be held when this is called.
1268  * Afterwards, the futex_q must not be accessed. Callers
1269  * must ensure to later call wake_up_q() for the actual
1270  * wakeups to occur.
1271  */
1272 static void mark_wake_futex(struct wake_q_head *wake_q, struct futex_q *q)
1273 {
1274     struct task_struct *p = q->task;
1275 
1276     if (WARN(q->pi_state || q->rt_waiter, "refusing to wake PI futex\n"))
1277         return;
1278 
1279     /*
1280      * Queue the task for later wakeup for after we've released
1281      * the hb->lock. wake_q_add() grabs reference to p.
1282      */
1283     wake_q_add(wake_q, p);
1284     __unqueue_futex(q);
1285     /*
1286      * The waiting task can free the futex_q as soon as
1287      * q->lock_ptr = NULL is written, without taking any locks. A
1288      * memory barrier is required here to prevent the following
1289      * store to lock_ptr from getting ahead of the plist_del.
1290      */
1291     smp_wmb();
1292     q->lock_ptr = NULL;
1293 }
1294 
1295 static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this,
1296              struct futex_hash_bucket *hb)
1297 {
1298     struct task_struct *new_owner;
1299     struct futex_pi_state *pi_state = this->pi_state;
1300     u32 uninitialized_var(curval), newval;
1301     DEFINE_WAKE_Q(wake_q);
1302     bool deboost;
1303     int ret = 0;
1304 
1305     if (!pi_state)
1306         return -EINVAL;
1307 
1308     /*
1309      * If current does not own the pi_state then the futex is
1310      * inconsistent and user space fiddled with the futex value.
1311      */
1312     if (pi_state->owner != current)
1313         return -EINVAL;
1314 
1315     raw_spin_lock_irq(&pi_state->pi_mutex.wait_lock);
1316     new_owner = rt_mutex_next_owner(&pi_state->pi_mutex);
1317 
1318     /*
1319      * It is possible that the next waiter (the one that brought
1320      * this owner to the kernel) timed out and is no longer
1321      * waiting on the lock.
1322      */
1323     if (!new_owner)
1324         new_owner = this->task;
1325 
1326     /*
1327      * We pass it to the next owner. The WAITERS bit is always
1328      * kept enabled while there is PI state around. We cleanup the
1329      * owner died bit, because we are the owner.
1330      */
1331     newval = FUTEX_WAITERS | task_pid_vnr(new_owner);
1332 
1333     if (unlikely(should_fail_futex(true)))
1334         ret = -EFAULT;
1335 
1336     if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)) {
1337         ret = -EFAULT;
1338     } else if (curval != uval) {
1339         /*
1340          * If a unconditional UNLOCK_PI operation (user space did not
1341          * try the TID->0 transition) raced with a waiter setting the
1342          * FUTEX_WAITERS flag between get_user() and locking the hash
1343          * bucket lock, retry the operation.
1344          */
1345         if ((FUTEX_TID_MASK & curval) == uval)
1346             ret = -EAGAIN;
1347         else
1348             ret = -EINVAL;
1349     }
1350     if (ret) {
1351         raw_spin_unlock_irq(&pi_state->pi_mutex.wait_lock);
1352         return ret;
1353     }
1354 
1355     raw_spin_lock(&pi_state->owner->pi_lock);
1356     WARN_ON(list_empty(&pi_state->list));
1357     list_del_init(&pi_state->list);
1358     raw_spin_unlock(&pi_state->owner->pi_lock);
1359 
1360     raw_spin_lock(&new_owner->pi_lock);
1361     WARN_ON(!list_empty(&pi_state->list));
1362     list_add(&pi_state->list, &new_owner->pi_state_list);
1363     pi_state->owner = new_owner;
1364     raw_spin_unlock(&new_owner->pi_lock);
1365 
1366     raw_spin_unlock_irq(&pi_state->pi_mutex.wait_lock);
1367 
1368     deboost = rt_mutex_futex_unlock(&pi_state->pi_mutex, &wake_q);
1369 
1370     /*
1371      * First unlock HB so the waiter does not spin on it once he got woken
1372      * up. Second wake up the waiter before the priority is adjusted. If we
1373      * deboost first (and lose our higher priority), then the task might get
1374      * scheduled away before the wake up can take place.
1375      */
1376     spin_unlock(&hb->lock);
1377     wake_up_q(&wake_q);
1378     if (deboost)
1379         rt_mutex_adjust_prio(current);
1380 
1381     return 0;
1382 }
1383 
1384 /*
1385  * Express the locking dependencies for lockdep:
1386  */
1387 static inline void
1388 double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
1389 {
1390     if (hb1 <= hb2) {
1391         spin_lock(&hb1->lock);
1392         if (hb1 < hb2)
1393             spin_lock_nested(&hb2->lock, SINGLE_DEPTH_NESTING);
1394     } else { /* hb1 > hb2 */
1395         spin_lock(&hb2->lock);
1396         spin_lock_nested(&hb1->lock, SINGLE_DEPTH_NESTING);
1397     }
1398 }
1399 
1400 static inline void
1401 double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
1402 {
1403     spin_unlock(&hb1->lock);
1404     if (hb1 != hb2)
1405         spin_unlock(&hb2->lock);
1406 }
1407 
1408 /*
1409  * Wake up waiters matching bitset queued on this futex (uaddr).
1410  */
1411 static int
1412 futex_wake(u32 __user *uaddr, unsigned int flags, int nr_wake, u32 bitset)
1413 {
1414     struct futex_hash_bucket *hb;
1415     struct futex_q *this, *next;
1416     union futex_key key = FUTEX_KEY_INIT;
1417     int ret;
1418     DEFINE_WAKE_Q(wake_q);
1419 
1420     if (!bitset)
1421         return -EINVAL;
1422 
1423     ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_READ);
1424     if (unlikely(ret != 0))
1425         goto out;
1426 
1427     hb = hash_futex(&key);
1428 
1429     /* Make sure we really have tasks to wakeup */
1430     if (!hb_waiters_pending(hb))
1431         goto out_put_key;
1432 
1433     spin_lock(&hb->lock);
1434 
1435     plist_for_each_entry_safe(this, next, &hb->chain, list) {
1436         if (match_futex (&this->key, &key)) {
1437             if (this->pi_state || this->rt_waiter) {
1438                 ret = -EINVAL;
1439                 break;
1440             }
1441 
1442             /* Check if one of the bits is set in both bitsets */
1443             if (!(this->bitset & bitset))
1444                 continue;
1445 
1446             mark_wake_futex(&wake_q, this);
1447             if (++ret >= nr_wake)
1448                 break;
1449         }
1450     }
1451 
1452     spin_unlock(&hb->lock);
1453     wake_up_q(&wake_q);
1454 out_put_key:
1455     put_futex_key(&key);
1456 out:
1457     return ret;
1458 }
1459 
1460 /*
1461  * Wake up all waiters hashed on the physical page that is mapped
1462  * to this virtual address:
1463  */
1464 static int
1465 futex_wake_op(u32 __user *uaddr1, unsigned int flags, u32 __user *uaddr2,
1466           int nr_wake, int nr_wake2, int op)
1467 {
1468     union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
1469     struct futex_hash_bucket *hb1, *hb2;
1470     struct futex_q *this, *next;
1471     int ret, op_ret;
1472     DEFINE_WAKE_Q(wake_q);
1473 
1474 retry:
1475     ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
1476     if (unlikely(ret != 0))
1477         goto out;
1478     ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
1479     if (unlikely(ret != 0))
1480         goto out_put_key1;
1481 
1482     hb1 = hash_futex(&key1);
1483     hb2 = hash_futex(&key2);
1484 
1485 retry_private:
1486     double_lock_hb(hb1, hb2);
1487     op_ret = futex_atomic_op_inuser(op, uaddr2);
1488     if (unlikely(op_ret < 0)) {
1489 
1490         double_unlock_hb(hb1, hb2);
1491 
1492 #ifndef CONFIG_MMU
1493         /*
1494          * we don't get EFAULT from MMU faults if we don't have an MMU,
1495          * but we might get them from range checking
1496          */
1497         ret = op_ret;
1498         goto out_put_keys;
1499 #endif
1500 
1501         if (unlikely(op_ret != -EFAULT)) {
1502             ret = op_ret;
1503             goto out_put_keys;
1504         }
1505 
1506         ret = fault_in_user_writeable(uaddr2);
1507         if (ret)
1508             goto out_put_keys;
1509 
1510         if (!(flags & FLAGS_SHARED))
1511             goto retry_private;
1512 
1513         put_futex_key(&key2);
1514         put_futex_key(&key1);
1515         goto retry;
1516     }
1517 
1518     plist_for_each_entry_safe(this, next, &hb1->chain, list) {
1519         if (match_futex (&this->key, &key1)) {
1520             if (this->pi_state || this->rt_waiter) {
1521                 ret = -EINVAL;
1522                 goto out_unlock;
1523             }
1524             mark_wake_futex(&wake_q, this);
1525             if (++ret >= nr_wake)
1526                 break;
1527         }
1528     }
1529 
1530     if (op_ret > 0) {
1531         op_ret = 0;
1532         plist_for_each_entry_safe(this, next, &hb2->chain, list) {
1533             if (match_futex (&this->key, &key2)) {
1534                 if (this->pi_state || this->rt_waiter) {
1535                     ret = -EINVAL;
1536                     goto out_unlock;
1537                 }
1538                 mark_wake_futex(&wake_q, this);
1539                 if (++op_ret >= nr_wake2)
1540                     break;
1541             }
1542         }
1543         ret += op_ret;
1544     }
1545 
1546 out_unlock:
1547     double_unlock_hb(hb1, hb2);
1548     wake_up_q(&wake_q);
1549 out_put_keys:
1550     put_futex_key(&key2);
1551 out_put_key1:
1552     put_futex_key(&key1);
1553 out:
1554     return ret;
1555 }
1556 
1557 /**
1558  * requeue_futex() - Requeue a futex_q from one hb to another
1559  * @q:      the futex_q to requeue
1560  * @hb1:    the source hash_bucket
1561  * @hb2:    the target hash_bucket
1562  * @key2:   the new key for the requeued futex_q
1563  */
1564 static inline
1565 void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
1566            struct futex_hash_bucket *hb2, union futex_key *key2)
1567 {
1568 
1569     /*
1570      * If key1 and key2 hash to the same bucket, no need to
1571      * requeue.
1572      */
1573     if (likely(&hb1->chain != &hb2->chain)) {
1574         plist_del(&q->list, &hb1->chain);
1575         hb_waiters_dec(hb1);
1576         hb_waiters_inc(hb2);
1577         plist_add(&q->list, &hb2->chain);
1578         q->lock_ptr = &hb2->lock;
1579     }
1580     get_futex_key_refs(key2);
1581     q->key = *key2;
1582 }
1583 
1584 /**
1585  * requeue_pi_wake_futex() - Wake a task that acquired the lock during requeue
1586  * @q:      the futex_q
1587  * @key:    the key of the requeue target futex
1588  * @hb:     the hash_bucket of the requeue target futex
1589  *
1590  * During futex_requeue, with requeue_pi=1, it is possible to acquire the
1591  * target futex if it is uncontended or via a lock steal.  Set the futex_q key
1592  * to the requeue target futex so the waiter can detect the wakeup on the right
1593  * futex, but remove it from the hb and NULL the rt_waiter so it can detect
1594  * atomic lock acquisition.  Set the q->lock_ptr to the requeue target hb->lock
1595  * to protect access to the pi_state to fixup the owner later.  Must be called
1596  * with both q->lock_ptr and hb->lock held.
1597  */
1598 static inline
1599 void requeue_pi_wake_futex(struct futex_q *q, union futex_key *key,
1600                struct futex_hash_bucket *hb)
1601 {
1602     get_futex_key_refs(key);
1603     q->key = *key;
1604 
1605     __unqueue_futex(q);
1606 
1607     WARN_ON(!q->rt_waiter);
1608     q->rt_waiter = NULL;
1609 
1610     q->lock_ptr = &hb->lock;
1611 
1612     wake_up_state(q->task, TASK_NORMAL);
1613 }
1614 
1615 /**
1616  * futex_proxy_trylock_atomic() - Attempt an atomic lock for the top waiter
1617  * @pifutex:        the user address of the to futex
1618  * @hb1:        the from futex hash bucket, must be locked by the caller
1619  * @hb2:        the to futex hash bucket, must be locked by the caller
1620  * @key1:       the from futex key
1621  * @key2:       the to futex key
1622  * @ps:         address to store the pi_state pointer
1623  * @set_waiters:    force setting the FUTEX_WAITERS bit (1) or not (0)
1624  *
1625  * Try and get the lock on behalf of the top waiter if we can do it atomically.
1626  * Wake the top waiter if we succeed.  If the caller specified set_waiters,
1627  * then direct futex_lock_pi_atomic() to force setting the FUTEX_WAITERS bit.
1628  * hb1 and hb2 must be held by the caller.
1629  *
1630  * Return:
1631  *  0 - failed to acquire the lock atomically;
1632  * >0 - acquired the lock, return value is vpid of the top_waiter
1633  * <0 - error
1634  */
1635 static int futex_proxy_trylock_atomic(u32 __user *pifutex,
1636                  struct futex_hash_bucket *hb1,
1637                  struct futex_hash_bucket *hb2,
1638                  union futex_key *key1, union futex_key *key2,
1639                  struct futex_pi_state **ps, int set_waiters)
1640 {
1641     struct futex_q *top_waiter = NULL;
1642     u32 curval;
1643     int ret, vpid;
1644 
1645     if (get_futex_value_locked(&curval, pifutex))
1646         return -EFAULT;
1647 
1648     if (unlikely(should_fail_futex(true)))
1649         return -EFAULT;
1650 
1651     /*
1652      * Find the top_waiter and determine if there are additional waiters.
1653      * If the caller intends to requeue more than 1 waiter to pifutex,
1654      * force futex_lock_pi_atomic() to set the FUTEX_WAITERS bit now,
1655      * as we have means to handle the possible fault.  If not, don't set
1656      * the bit unecessarily as it will force the subsequent unlock to enter
1657      * the kernel.
1658      */
1659     top_waiter = futex_top_waiter(hb1, key1);
1660 
1661     /* There are no waiters, nothing for us to do. */
1662     if (!top_waiter)
1663         return 0;
1664 
1665     /* Ensure we requeue to the expected futex. */
1666     if (!match_futex(top_waiter->requeue_pi_key, key2))
1667         return -EINVAL;
1668 
1669     /*
1670      * Try to take the lock for top_waiter.  Set the FUTEX_WAITERS bit in
1671      * the contended case or if set_waiters is 1.  The pi_state is returned
1672      * in ps in contended cases.
1673      */
1674     vpid = task_pid_vnr(top_waiter->task);
1675     ret = futex_lock_pi_atomic(pifutex, hb2, key2, ps, top_waiter->task,
1676                    set_waiters);
1677     if (ret == 1) {
1678         requeue_pi_wake_futex(top_waiter, key2, hb2);
1679         return vpid;
1680     }
1681     return ret;
1682 }
1683 
1684 /**
1685  * futex_requeue() - Requeue waiters from uaddr1 to uaddr2
1686  * @uaddr1: source futex user address
1687  * @flags:  futex flags (FLAGS_SHARED, etc.)
1688  * @uaddr2: target futex user address
1689  * @nr_wake:    number of waiters to wake (must be 1 for requeue_pi)
1690  * @nr_requeue: number of waiters to requeue (0-INT_MAX)
1691  * @cmpval: @uaddr1 expected value (or %NULL)
1692  * @requeue_pi: if we are attempting to requeue from a non-pi futex to a
1693  *      pi futex (pi to pi requeue is not supported)
1694  *
1695  * Requeue waiters on uaddr1 to uaddr2. In the requeue_pi case, try to acquire
1696  * uaddr2 atomically on behalf of the top waiter.
1697  *
1698  * Return:
1699  * >=0 - on success, the number of tasks requeued or woken;
1700  *  <0 - on error
1701  */
1702 static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
1703              u32 __user *uaddr2, int nr_wake, int nr_requeue,
1704              u32 *cmpval, int requeue_pi)
1705 {
1706     union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
1707     int drop_count = 0, task_count = 0, ret;
1708     struct futex_pi_state *pi_state = NULL;
1709     struct futex_hash_bucket *hb1, *hb2;
1710     struct futex_q *this, *next;
1711     DEFINE_WAKE_Q(wake_q);
1712 
1713     if (requeue_pi) {
1714         /*
1715          * Requeue PI only works on two distinct uaddrs. This
1716          * check is only valid for private futexes. See below.
1717          */
1718         if (uaddr1 == uaddr2)
1719             return -EINVAL;
1720 
1721         /*
1722          * requeue_pi requires a pi_state, try to allocate it now
1723          * without any locks in case it fails.
1724          */
1725         if (refill_pi_state_cache())
1726             return -ENOMEM;
1727         /*
1728          * requeue_pi must wake as many tasks as it can, up to nr_wake
1729          * + nr_requeue, since it acquires the rt_mutex prior to
1730          * returning to userspace, so as to not leave the rt_mutex with
1731          * waiters and no owner.  However, second and third wake-ups
1732          * cannot be predicted as they involve race conditions with the
1733          * first wake and a fault while looking up the pi_state.  Both
1734          * pthread_cond_signal() and pthread_cond_broadcast() should
1735          * use nr_wake=1.
1736          */
1737         if (nr_wake != 1)
1738             return -EINVAL;
1739     }
1740 
1741 retry:
1742     ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
1743     if (unlikely(ret != 0))
1744         goto out;
1745     ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2,
1746                 requeue_pi ? VERIFY_WRITE : VERIFY_READ);
1747     if (unlikely(ret != 0))
1748         goto out_put_key1;
1749 
1750     /*
1751      * The check above which compares uaddrs is not sufficient for
1752      * shared futexes. We need to compare the keys:
1753      */
1754     if (requeue_pi && match_futex(&key1, &key2)) {
1755         ret = -EINVAL;
1756         goto out_put_keys;
1757     }
1758 
1759     hb1 = hash_futex(&key1);
1760     hb2 = hash_futex(&key2);
1761 
1762 retry_private:
1763     hb_waiters_inc(hb2);
1764     double_lock_hb(hb1, hb2);
1765 
1766     if (likely(cmpval != NULL)) {
1767         u32 curval;
1768 
1769         ret = get_futex_value_locked(&curval, uaddr1);
1770 
1771         if (unlikely(ret)) {
1772             double_unlock_hb(hb1, hb2);
1773             hb_waiters_dec(hb2);
1774 
1775             ret = get_user(curval, uaddr1);
1776             if (ret)
1777                 goto out_put_keys;
1778 
1779             if (!(flags & FLAGS_SHARED))
1780                 goto retry_private;
1781 
1782             put_futex_key(&key2);
1783             put_futex_key(&key1);
1784             goto retry;
1785         }
1786         if (curval != *cmpval) {
1787             ret = -EAGAIN;
1788             goto out_unlock;
1789         }
1790     }
1791 
1792     if (requeue_pi && (task_count - nr_wake < nr_requeue)) {
1793         /*
1794          * Attempt to acquire uaddr2 and wake the top waiter. If we
1795          * intend to requeue waiters, force setting the FUTEX_WAITERS
1796          * bit.  We force this here where we are able to easily handle
1797          * faults rather in the requeue loop below.
1798          */
1799         ret = futex_proxy_trylock_atomic(uaddr2, hb1, hb2, &key1,
1800                          &key2, &pi_state, nr_requeue);
1801 
1802         /*
1803          * At this point the top_waiter has either taken uaddr2 or is
1804          * waiting on it.  If the former, then the pi_state will not
1805          * exist yet, look it up one more time to ensure we have a
1806          * reference to it. If the lock was taken, ret contains the
1807          * vpid of the top waiter task.
1808          * If the lock was not taken, we have pi_state and an initial
1809          * refcount on it. In case of an error we have nothing.
1810          */
1811         if (ret > 0) {
1812             WARN_ON(pi_state);
1813             drop_count++;
1814             task_count++;
1815             /*
1816              * If we acquired the lock, then the user space value
1817              * of uaddr2 should be vpid. It cannot be changed by
1818              * the top waiter as it is blocked on hb2 lock if it
1819              * tries to do so. If something fiddled with it behind
1820              * our back the pi state lookup might unearth it. So
1821              * we rather use the known value than rereading and
1822              * handing potential crap to lookup_pi_state.
1823              *
1824              * If that call succeeds then we have pi_state and an
1825              * initial refcount on it.
1826              */
1827             ret = lookup_pi_state(ret, hb2, &key2, &pi_state);
1828         }
1829 
1830         switch (ret) {
1831         case 0:
1832             /* We hold a reference on the pi state. */
1833             break;
1834 
1835             /* If the above failed, then pi_state is NULL */
1836         case -EFAULT:
1837             double_unlock_hb(hb1, hb2);
1838             hb_waiters_dec(hb2);
1839             put_futex_key(&key2);
1840             put_futex_key(&key1);
1841             ret = fault_in_user_writeable(uaddr2);
1842             if (!ret)
1843                 goto retry;
1844             goto out;
1845         case -EAGAIN:
1846             /*
1847              * Two reasons for this:
1848              * - Owner is exiting and we just wait for the
1849              *   exit to complete.
1850              * - The user space value changed.
1851              */
1852             double_unlock_hb(hb1, hb2);
1853             hb_waiters_dec(hb2);
1854             put_futex_key(&key2);
1855             put_futex_key(&key1);
1856             cond_resched();
1857             goto retry;
1858         default:
1859             goto out_unlock;
1860         }
1861     }
1862 
1863     plist_for_each_entry_safe(this, next, &hb1->chain, list) {
1864         if (task_count - nr_wake >= nr_requeue)
1865             break;
1866 
1867         if (!match_futex(&this->key, &key1))
1868             continue;
1869 
1870         /*
1871          * FUTEX_WAIT_REQEUE_PI and FUTEX_CMP_REQUEUE_PI should always
1872          * be paired with each other and no other futex ops.
1873          *
1874          * We should never be requeueing a futex_q with a pi_state,
1875          * which is awaiting a futex_unlock_pi().
1876          */
1877         if ((requeue_pi && !this->rt_waiter) ||
1878             (!requeue_pi && this->rt_waiter) ||
1879             this->pi_state) {
1880             ret = -EINVAL;
1881             break;
1882         }
1883 
1884         /*
1885          * Wake nr_wake waiters.  For requeue_pi, if we acquired the
1886          * lock, we already woke the top_waiter.  If not, it will be
1887          * woken by futex_unlock_pi().
1888          */
1889         if (++task_count <= nr_wake && !requeue_pi) {
1890             mark_wake_futex(&wake_q, this);
1891             continue;
1892         }
1893 
1894         /* Ensure we requeue to the expected futex for requeue_pi. */
1895         if (requeue_pi && !match_futex(this->requeue_pi_key, &key2)) {
1896             ret = -EINVAL;
1897             break;
1898         }
1899 
1900         /*
1901          * Requeue nr_requeue waiters and possibly one more in the case
1902          * of requeue_pi if we couldn't acquire the lock atomically.
1903          */
1904         if (requeue_pi) {
1905             /*
1906              * Prepare the waiter to take the rt_mutex. Take a
1907              * refcount on the pi_state and store the pointer in
1908              * the futex_q object of the waiter.
1909              */
1910             atomic_inc(&pi_state->refcount);
1911             this->pi_state = pi_state;
1912             ret = rt_mutex_start_proxy_lock(&pi_state->pi_mutex,
1913                             this->rt_waiter,
1914                             this->task);
1915             if (ret == 1) {
1916                 /*
1917                  * We got the lock. We do neither drop the
1918                  * refcount on pi_state nor clear
1919                  * this->pi_state because the waiter needs the
1920                  * pi_state for cleaning up the user space
1921                  * value. It will drop the refcount after
1922                  * doing so.
1923                  */
1924                 requeue_pi_wake_futex(this, &key2, hb2);
1925                 drop_count++;
1926                 continue;
1927             } else if (ret) {
1928                 /*
1929                  * rt_mutex_start_proxy_lock() detected a
1930                  * potential deadlock when we tried to queue
1931                  * that waiter. Drop the pi_state reference
1932                  * which we took above and remove the pointer
1933                  * to the state from the waiters futex_q
1934                  * object.
1935                  */
1936                 this->pi_state = NULL;
1937                 put_pi_state(pi_state);
1938                 /*
1939                  * We stop queueing more waiters and let user
1940                  * space deal with the mess.
1941                  */
1942                 break;
1943             }
1944         }
1945         requeue_futex(this, hb1, hb2, &key2);
1946         drop_count++;
1947     }
1948 
1949     /*
1950      * We took an extra initial reference to the pi_state either
1951      * in futex_proxy_trylock_atomic() or in lookup_pi_state(). We
1952      * need to drop it here again.
1953      */
1954     put_pi_state(pi_state);
1955 
1956 out_unlock:
1957     double_unlock_hb(hb1, hb2);
1958     wake_up_q(&wake_q);
1959     hb_waiters_dec(hb2);
1960 
1961     /*
1962      * drop_futex_key_refs() must be called outside the spinlocks. During
1963      * the requeue we moved futex_q's from the hash bucket at key1 to the
1964      * one at key2 and updated their key pointer.  We no longer need to
1965      * hold the references to key1.
1966      */
1967     while (--drop_count >= 0)
1968         drop_futex_key_refs(&key1);
1969 
1970 out_put_keys:
1971     put_futex_key(&key2);
1972 out_put_key1:
1973     put_futex_key(&key1);
1974 out:
1975     return ret ? ret : task_count;
1976 }
1977 
1978 /* The key must be already stored in q->key. */
1979 static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
1980     __acquires(&hb->lock)
1981 {
1982     struct futex_hash_bucket *hb;
1983 
1984     hb = hash_futex(&q->key);
1985 
1986     /*
1987      * Increment the counter before taking the lock so that
1988      * a potential waker won't miss a to-be-slept task that is
1989      * waiting for the spinlock. This is safe as all queue_lock()
1990      * users end up calling queue_me(). Similarly, for housekeeping,
1991      * decrement the counter at queue_unlock() when some error has
1992      * occurred and we don't end up adding the task to the list.
1993      */
1994     hb_waiters_inc(hb);
1995 
1996     q->lock_ptr = &hb->lock;
1997 
1998     spin_lock(&hb->lock); /* implies smp_mb(); (A) */
1999     return hb;
2000 }
2001 
2002 static inline void
2003 queue_unlock(struct futex_hash_bucket *hb)
2004     __releases(&hb->lock)
2005 {
2006     spin_unlock(&hb->lock);
2007     hb_waiters_dec(hb);
2008 }
2009 
2010 /**
2011  * queue_me() - Enqueue the futex_q on the futex_hash_bucket
2012  * @q:  The futex_q to enqueue
2013  * @hb: The destination hash bucket
2014  *
2015  * The hb->lock must be held by the caller, and is released here. A call to
2016  * queue_me() is typically paired with exactly one call to unqueue_me().  The
2017  * exceptions involve the PI related operations, which may use unqueue_me_pi()
2018  * or nothing if the unqueue is done as part of the wake process and the unqueue
2019  * state is implicit in the state of woken task (see futex_wait_requeue_pi() for
2020  * an example).
2021  */
2022 static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
2023     __releases(&hb->lock)
2024 {
2025     int prio;
2026 
2027     /*
2028      * The priority used to register this element is
2029      * - either the real thread-priority for the real-time threads
2030      * (i.e. threads with a priority lower than MAX_RT_PRIO)
2031      * - or MAX_RT_PRIO for non-RT threads.
2032      * Thus, all RT-threads are woken first in priority order, and
2033      * the others are woken last, in FIFO order.
2034      */
2035     prio = min(current->normal_prio, MAX_RT_PRIO);
2036 
2037     plist_node_init(&q->list, prio);
2038     plist_add(&q->list, &hb->chain);
2039     q->task = current;
2040     spin_unlock(&hb->lock);
2041 }
2042 
2043 /**
2044  * unqueue_me() - Remove the futex_q from its futex_hash_bucket
2045  * @q:  The futex_q to unqueue
2046  *
2047  * The q->lock_ptr must not be held by the caller. A call to unqueue_me() must
2048  * be paired with exactly one earlier call to queue_me().
2049  *
2050  * Return:
2051  *   1 - if the futex_q was still queued (and we removed unqueued it);
2052  *   0 - if the futex_q was already removed by the waking thread
2053  */
2054 static int unqueue_me(struct futex_q *q)
2055 {
2056     spinlock_t *lock_ptr;
2057     int ret = 0;
2058 
2059     /* In the common case we don't take the spinlock, which is nice. */
2060 retry:
2061     /*
2062      * q->lock_ptr can change between this read and the following spin_lock.
2063      * Use READ_ONCE to forbid the compiler from reloading q->lock_ptr and
2064      * optimizing lock_ptr out of the logic below.
2065      */
2066     lock_ptr = READ_ONCE(q->lock_ptr);
2067     if (lock_ptr != NULL) {
2068         spin_lock(lock_ptr);
2069         /*
2070          * q->lock_ptr can change between reading it and
2071          * spin_lock(), causing us to take the wrong lock.  This
2072          * corrects the race condition.
2073          *
2074          * Reasoning goes like this: if we have the wrong lock,
2075          * q->lock_ptr must have changed (maybe several times)
2076          * between reading it and the spin_lock().  It can
2077          * change again after the spin_lock() but only if it was
2078          * already changed before the spin_lock().  It cannot,
2079          * however, change back to the original value.  Therefore
2080          * we can detect whether we acquired the correct lock.
2081          */
2082         if (unlikely(lock_ptr != q->lock_ptr)) {
2083             spin_unlock(lock_ptr);
2084             goto retry;
2085         }
2086         __unqueue_futex(q);
2087 
2088         BUG_ON(q->pi_state);
2089 
2090         spin_unlock(lock_ptr);
2091         ret = 1;
2092     }
2093 
2094     drop_futex_key_refs(&q->key);
2095     return ret;
2096 }
2097 
2098 /*
2099  * PI futexes can not be requeued and must remove themself from the
2100  * hash bucket. The hash bucket lock (i.e. lock_ptr) is held on entry
2101  * and dropped here.
2102  */
2103 static void unqueue_me_pi(struct futex_q *q)
2104     __releases(q->lock_ptr)
2105 {
2106     __unqueue_futex(q);
2107 
2108     BUG_ON(!q->pi_state);
2109     put_pi_state(q->pi_state);
2110     q->pi_state = NULL;
2111 
2112     spin_unlock(q->lock_ptr);
2113 }
2114 
2115 /*
2116  * Fixup the pi_state owner with the new owner.
2117  *
2118  * Must be called with hash bucket lock held and mm->sem held for non
2119  * private futexes.
2120  */
2121 static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
2122                 struct task_struct *newowner)
2123 {
2124     u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
2125     struct futex_pi_state *pi_state = q->pi_state;
2126     struct task_struct *oldowner = pi_state->owner;
2127     u32 uval, uninitialized_var(curval), newval;
2128     int ret;
2129 
2130     /* Owner died? */
2131     if (!pi_state->owner)
2132         newtid |= FUTEX_OWNER_DIED;
2133 
2134     /*
2135      * We are here either because we stole the rtmutex from the
2136      * previous highest priority waiter or we are the highest priority
2137      * waiter but failed to get the rtmutex the first time.
2138      * We have to replace the newowner TID in the user space variable.
2139      * This must be atomic as we have to preserve the owner died bit here.
2140      *
2141      * Note: We write the user space value _before_ changing the pi_state
2142      * because we can fault here. Imagine swapped out pages or a fork
2143      * that marked all the anonymous memory readonly for cow.
2144      *
2145      * Modifying pi_state _before_ the user space value would
2146      * leave the pi_state in an inconsistent state when we fault
2147      * here, because we need to drop the hash bucket lock to
2148      * handle the fault. This might be observed in the PID check
2149      * in lookup_pi_state.
2150      */
2151 retry:
2152     if (get_futex_value_locked(&uval, uaddr))
2153         goto handle_fault;
2154 
2155     while (1) {
2156         newval = (uval & FUTEX_OWNER_DIED) | newtid;
2157 
2158         if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
2159             goto handle_fault;
2160         if (curval == uval)
2161             break;
2162         uval = curval;
2163     }
2164 
2165     /*
2166      * We fixed up user space. Now we need to fix the pi_state
2167      * itself.
2168      */
2169     if (pi_state->owner != NULL) {
2170         raw_spin_lock_irq(&pi_state->owner->pi_lock);
2171         WARN_ON(list_empty(&pi_state->list));
2172         list_del_init(&pi_state->list);
2173         raw_spin_unlock_irq(&pi_state->owner->pi_lock);
2174     }
2175 
2176     pi_state->owner = newowner;
2177 
2178     raw_spin_lock_irq(&newowner->pi_lock);
2179     WARN_ON(!list_empty(&pi_state->list));
2180     list_add(&pi_state->list, &newowner->pi_state_list);
2181     raw_spin_unlock_irq(&newowner->pi_lock);
2182     return 0;
2183 
2184     /*
2185      * To handle the page fault we need to drop the hash bucket
2186      * lock here. That gives the other task (either the highest priority
2187      * waiter itself or the task which stole the rtmutex) the
2188      * chance to try the fixup of the pi_state. So once we are
2189      * back from handling the fault we need to check the pi_state
2190      * after reacquiring the hash bucket lock and before trying to
2191      * do another fixup. When the fixup has been done already we
2192      * simply return.
2193      */
2194 handle_fault:
2195     spin_unlock(q->lock_ptr);
2196 
2197     ret = fault_in_user_writeable(uaddr);
2198 
2199     spin_lock(q->lock_ptr);
2200 
2201     /*
2202      * Check if someone else fixed it for us:
2203      */
2204     if (pi_state->owner != oldowner)
2205         return 0;
2206 
2207     if (ret)
2208         return ret;
2209 
2210     goto retry;
2211 }
2212 
2213 static long futex_wait_restart(struct restart_block *restart);
2214 
2215 /**
2216  * fixup_owner() - Post lock pi_state and corner case management
2217  * @uaddr:  user address of the futex
2218  * @q:      futex_q (contains pi_state and access to the rt_mutex)
2219  * @locked: if the attempt to take the rt_mutex succeeded (1) or not (0)
2220  *
2221  * After attempting to lock an rt_mutex, this function is called to cleanup
2222  * the pi_state owner as well as handle race conditions that may allow us to
2223  * acquire the lock. Must be called with the hb lock held.
2224  *
2225  * Return:
2226  *  1 - success, lock taken;
2227  *  0 - success, lock not taken;
2228  * <0 - on error (-EFAULT)
2229  */
2230 static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
2231 {
2232     struct task_struct *owner;
2233     int ret = 0;
2234 
2235     if (locked) {
2236         /*
2237          * Got the lock. We might not be the anticipated owner if we
2238          * did a lock-steal - fix up the PI-state in that case:
2239          */
2240         if (q->pi_state->owner != current)
2241             ret = fixup_pi_state_owner(uaddr, q, current);
2242         goto out;
2243     }
2244 
2245     /*
2246      * Catch the rare case, where the lock was released when we were on the
2247      * way back before we locked the hash bucket.
2248      */
2249     if (q->pi_state->owner == current) {
2250         /*
2251          * Try to get the rt_mutex now. This might fail as some other
2252          * task acquired the rt_mutex after we removed ourself from the
2253          * rt_mutex waiters list.
2254          */
2255         if (rt_mutex_trylock(&q->pi_state->pi_mutex)) {
2256             locked = 1;
2257             goto out;
2258         }
2259 
2260         /*
2261          * pi_state is incorrect, some other task did a lock steal and
2262          * we returned due to timeout or signal without taking the
2263          * rt_mutex. Too late.
2264          */
2265         raw_spin_lock_irq(&q->pi_state->pi_mutex.wait_lock);
2266         owner = rt_mutex_owner(&q->pi_state->pi_mutex);
2267         if (!owner)
2268             owner = rt_mutex_next_owner(&q->pi_state->pi_mutex);
2269         raw_spin_unlock_irq(&q->pi_state->pi_mutex.wait_lock);
2270         ret = fixup_pi_state_owner(uaddr, q, owner);
2271         goto out;
2272     }
2273 
2274     /*
2275      * Paranoia check. If we did not take the lock, then we should not be
2276      * the owner of the rt_mutex.
2277      */
2278     if (rt_mutex_owner(&q->pi_state->pi_mutex) == current)
2279         printk(KERN_ERR "fixup_owner: ret = %d pi-mutex: %p "
2280                 "pi-state %p\n", ret,
2281                 q->pi_state->pi_mutex.owner,
2282                 q->pi_state->owner);
2283 
2284 out:
2285     return ret ? ret : locked;
2286 }
2287 
2288 /**
2289  * futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal
2290  * @hb:     the futex hash bucket, must be locked by the caller
2291  * @q:      the futex_q to queue up on
2292  * @timeout:    the prepared hrtimer_sleeper, or null for no timeout
2293  */
2294 static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
2295                 struct hrtimer_sleeper *timeout)
2296 {
2297     /*
2298      * The task state is guaranteed to be set before another task can
2299      * wake it. set_current_state() is implemented using smp_store_mb() and
2300      * queue_me() calls spin_unlock() upon completion, both serializing
2301      * access to the hash list and forcing another memory barrier.
2302      */
2303     set_current_state(TASK_INTERRUPTIBLE);
2304     queue_me(q, hb);
2305 
2306     /* Arm the timer */
2307     if (timeout)
2308         hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
2309 
2310     /*
2311      * If we have been removed from the hash list, then another task
2312      * has tried to wake us, and we can skip the call to schedule().
2313      */
2314     if (likely(!plist_node_empty(&q->list))) {
2315         /*
2316          * If the timer has already expired, current will already be
2317          * flagged for rescheduling. Only call schedule if there
2318          * is no timeout, or if it has yet to expire.
2319          */
2320         if (!timeout || timeout->task)
2321             freezable_schedule();
2322     }
2323     __set_current_state(TASK_RUNNING);
2324 }
2325 
2326 /**
2327  * futex_wait_setup() - Prepare to wait on a futex
2328  * @uaddr:  the futex userspace address
2329  * @val:    the expected value
2330  * @flags:  futex flags (FLAGS_SHARED, etc.)
2331  * @q:      the associated futex_q
2332  * @hb:     storage for hash_bucket pointer to be returned to caller
2333  *
2334  * Setup the futex_q and locate the hash_bucket.  Get the futex value and
2335  * compare it with the expected value.  Handle atomic faults internally.
2336  * Return with the hb lock held and a q.key reference on success, and unlocked
2337  * with no q.key reference on failure.
2338  *
2339  * Return:
2340  *  0 - uaddr contains val and hb has been locked;
2341  * <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
2342  */
2343 static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
2344                struct futex_q *q, struct futex_hash_bucket **hb)
2345 {
2346     u32 uval;
2347     int ret;
2348 
2349     /*
2350      * Access the page AFTER the hash-bucket is locked.
2351      * Order is important:
2352      *
2353      *   Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
2354      *   Userspace waker:  if (cond(var)) { var = new; futex_wake(&var); }
2355      *
2356      * The basic logical guarantee of a futex is that it blocks ONLY
2357      * if cond(var) is known to be true at the time of blocking, for
2358      * any cond.  If we locked the hash-bucket after testing *uaddr, that
2359      * would open a race condition where we could block indefinitely with
2360      * cond(var) false, which would violate the guarantee.
2361      *
2362      * On the other hand, we insert q and release the hash-bucket only
2363      * after testing *uaddr.  This guarantees that futex_wait() will NOT
2364      * absorb a wakeup if *uaddr does not match the desired values
2365      * while the syscall executes.
2366      */
2367 retry:
2368     ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q->key, VERIFY_READ);
2369     if (unlikely(ret != 0))
2370         return ret;
2371 
2372 retry_private:
2373     *hb = queue_lock(q);
2374 
2375     ret = get_futex_value_locked(&uval, uaddr);
2376 
2377     if (ret) {
2378         queue_unlock(*hb);
2379 
2380         ret = get_user(uval, uaddr);
2381         if (ret)
2382             goto out;
2383 
2384         if (!(flags & FLAGS_SHARED))
2385             goto retry_private;
2386 
2387         put_futex_key(&q->key);
2388         goto retry;
2389     }
2390 
2391     if (uval != val) {
2392         queue_unlock(*hb);
2393         ret = -EWOULDBLOCK;
2394     }
2395 
2396 out:
2397     if (ret)
2398         put_futex_key(&q->key);
2399     return ret;
2400 }
2401 
2402 static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
2403               ktime_t *abs_time, u32 bitset)
2404 {
2405     struct hrtimer_sleeper timeout, *to = NULL;
2406     struct restart_block *restart;
2407     struct futex_hash_bucket *hb;
2408     struct futex_q q = futex_q_init;
2409     int ret;
2410 
2411     if (!bitset)
2412         return -EINVAL;
2413     q.bitset = bitset;
2414 
2415     if (abs_time) {
2416         to = &timeout;
2417 
2418         hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
2419                       CLOCK_REALTIME : CLOCK_MONOTONIC,
2420                       HRTIMER_MODE_ABS);
2421         hrtimer_init_sleeper(to, current);
2422         hrtimer_set_expires_range_ns(&to->timer, *abs_time,
2423                          current->timer_slack_ns);
2424     }
2425 
2426 retry:
2427     /*
2428      * Prepare to wait on uaddr. On success, holds hb lock and increments
2429      * q.key refs.
2430      */
2431     ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
2432     if (ret)
2433         goto out;
2434 
2435     /* queue_me and wait for wakeup, timeout, or a signal. */
2436     futex_wait_queue_me(hb, &q, to);
2437 
2438     /* If we were woken (and unqueued), we succeeded, whatever. */
2439     ret = 0;
2440     /* unqueue_me() drops q.key ref */
2441     if (!unqueue_me(&q))
2442         goto out;
2443     ret = -ETIMEDOUT;
2444     if (to && !to->task)
2445         goto out;
2446 
2447     /*
2448      * We expect signal_pending(current), but we might be the
2449      * victim of a spurious wakeup as well.
2450      */
2451     if (!signal_pending(current))
2452         goto retry;
2453 
2454     ret = -ERESTARTSYS;
2455     if (!abs_time)
2456         goto out;
2457 
2458     restart = &current->restart_block;
2459     restart->fn = futex_wait_restart;
2460     restart->futex.uaddr = uaddr;
2461     restart->futex.val = val;
2462     restart->futex.time = *abs_time;
2463     restart->futex.bitset = bitset;
2464     restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
2465 
2466     ret = -ERESTART_RESTARTBLOCK;
2467 
2468 out:
2469     if (to) {
2470         hrtimer_cancel(&to->timer);
2471         destroy_hrtimer_on_stack(&to->timer);
2472     }
2473     return ret;
2474 }
2475 
2476 
2477 static long futex_wait_restart(struct restart_block *restart)
2478 {
2479     u32 __user *uaddr = restart->futex.uaddr;
2480     ktime_t t, *tp = NULL;
2481 
2482     if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
2483         t = restart->futex.time;
2484         tp = &t;
2485     }
2486     restart->fn = do_no_restart_syscall;
2487 
2488     return (long)futex_wait(uaddr, restart->futex.flags,
2489                 restart->futex.val, tp, restart->futex.bitset);
2490 }
2491 
2492 
2493 /*
2494  * Userspace tried a 0 -> TID atomic transition of the futex value
2495  * and failed. The kernel side here does the whole locking operation:
2496  * if there are waiters then it will block as a consequence of relying
2497  * on rt-mutexes, it does PI, etc. (Due to races the kernel might see
2498  * a 0 value of the futex too.).
2499  *
2500  * Also serves as futex trylock_pi()'ing, and due semantics.
2501  */
2502 static int futex_lock_pi(u32 __user *uaddr, unsigned int flags,
2503              ktime_t *time, int trylock)
2504 {
2505     struct hrtimer_sleeper timeout, *to = NULL;
2506     struct futex_hash_bucket *hb;
2507     struct futex_q q = futex_q_init;
2508     int res, ret;
2509 
2510     if (refill_pi_state_cache())
2511         return -ENOMEM;
2512 
2513     if (time) {
2514         to = &timeout;
2515         hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,
2516                       HRTIMER_MODE_ABS);
2517         hrtimer_init_sleeper(to, current);
2518         hrtimer_set_expires(&to->timer, *time);
2519     }
2520 
2521 retry:
2522     ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q.key, VERIFY_WRITE);
2523     if (unlikely(ret != 0))
2524         goto out;
2525 
2526 retry_private:
2527     hb = queue_lock(&q);
2528 
2529     ret = futex_lock_pi_atomic(uaddr, hb, &q.key, &q.pi_state, current, 0);
2530     if (unlikely(ret)) {
2531         /*
2532          * Atomic work succeeded and we got the lock,
2533          * or failed. Either way, we do _not_ block.
2534          */
2535         switch (ret) {
2536         case 1:
2537             /* We got the lock. */
2538             ret = 0;
2539             goto out_unlock_put_key;
2540         case -EFAULT:
2541             goto uaddr_faulted;
2542         case -EAGAIN:
2543             /*
2544              * Two reasons for this:
2545              * - Task is exiting and we just wait for the
2546              *   exit to complete.
2547              * - The user space value changed.
2548              */
2549             queue_unlock(hb);
2550             put_futex_key(&q.key);
2551             cond_resched();
2552             goto retry;
2553         default:
2554             goto out_unlock_put_key;
2555         }
2556     }
2557 
2558     /*
2559      * Only actually queue now that the atomic ops are done:
2560      */
2561     queue_me(&q, hb);
2562 
2563     WARN_ON(!q.pi_state);
2564     /*
2565      * Block on the PI mutex:
2566      */
2567     if (!trylock) {
2568         ret = rt_mutex_timed_futex_lock(&q.pi_state->pi_mutex, to);
2569     } else {
2570         ret = rt_mutex_trylock(&q.pi_state->pi_mutex);
2571         /* Fixup the trylock return value: */
2572         ret = ret ? 0 : -EWOULDBLOCK;
2573     }
2574 
2575     spin_lock(q.lock_ptr);
2576     /*
2577      * Fixup the pi_state owner and possibly acquire the lock if we
2578      * haven't already.
2579      */
2580     res = fixup_owner(uaddr, &q, !ret);
2581     /*
2582      * If fixup_owner() returned an error, proprogate that.  If it acquired
2583      * the lock, clear our -ETIMEDOUT or -EINTR.
2584      */
2585     if (res)
2586         ret = (res < 0) ? res : 0;
2587 
2588     /*
2589      * If fixup_owner() faulted and was unable to handle the fault, unlock
2590      * it and return the fault to userspace.
2591      */
2592     if (ret && (rt_mutex_owner(&q.pi_state->pi_mutex) == current))
2593         rt_mutex_unlock(&q.pi_state->pi_mutex);
2594 
2595     /* Unqueue and drop the lock */
2596     unqueue_me_pi(&q);
2597 
2598     goto out_put_key;
2599 
2600 out_unlock_put_key:
2601     queue_unlock(hb);
2602 
2603 out_put_key:
2604     put_futex_key(&q.key);
2605 out:
2606     if (to)
2607         destroy_hrtimer_on_stack(&to->timer);
2608     return ret != -EINTR ? ret : -ERESTARTNOINTR;
2609 
2610 uaddr_faulted:
2611     queue_unlock(hb);
2612 
2613     ret = fault_in_user_writeable(uaddr);
2614     if (ret)
2615         goto out_put_key;
2616 
2617     if (!(flags & FLAGS_SHARED))
2618         goto retry_private;
2619 
2620     put_futex_key(&q.key);
2621     goto retry;
2622 }
2623 
2624 /*
2625  * Userspace attempted a TID -> 0 atomic transition, and failed.
2626  * This is the in-kernel slowpath: we look up the PI state (if any),
2627  * and do the rt-mutex unlock.
2628  */
2629 static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
2630 {
2631     u32 uninitialized_var(curval), uval, vpid = task_pid_vnr(current);
2632     union futex_key key = FUTEX_KEY_INIT;
2633     struct futex_hash_bucket *hb;
2634     struct futex_q *match;
2635     int ret;
2636 
2637 retry:
2638     if (get_user(uval, uaddr))
2639         return -EFAULT;
2640     /*
2641      * We release only a lock we actually own:
2642      */
2643     if ((uval & FUTEX_TID_MASK) != vpid)
2644         return -EPERM;
2645 
2646     ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_WRITE);
2647     if (ret)
2648         return ret;
2649 
2650     hb = hash_futex(&key);
2651     spin_lock(&hb->lock);
2652 
2653     /*
2654      * Check waiters first. We do not trust user space values at
2655      * all and we at least want to know if user space fiddled
2656      * with the futex value instead of blindly unlocking.
2657      */
2658     match = futex_top_waiter(hb, &key);
2659     if (match) {
2660         ret = wake_futex_pi(uaddr, uval, match, hb);
2661         /*
2662          * In case of success wake_futex_pi dropped the hash
2663          * bucket lock.
2664          */
2665         if (!ret)
2666             goto out_putkey;
2667         /*
2668          * The atomic access to the futex value generated a
2669          * pagefault, so retry the user-access and the wakeup:
2670          */
2671         if (ret == -EFAULT)
2672             goto pi_faulted;
2673         /*
2674          * A unconditional UNLOCK_PI op raced against a waiter
2675          * setting the FUTEX_WAITERS bit. Try again.
2676          */
2677         if (ret == -EAGAIN) {
2678             spin_unlock(&hb->lock);
2679             put_futex_key(&key);
2680             goto retry;
2681         }
2682         /*
2683          * wake_futex_pi has detected invalid state. Tell user
2684          * space.
2685          */
2686         goto out_unlock;
2687     }
2688 
2689     /*
2690      * We have no kernel internal state, i.e. no waiters in the
2691      * kernel. Waiters which are about to queue themselves are stuck
2692      * on hb->lock. So we can safely ignore them. We do neither
2693      * preserve the WAITERS bit not the OWNER_DIED one. We are the
2694      * owner.
2695      */
2696     if (cmpxchg_futex_value_locked(&curval, uaddr, uval, 0))
2697         goto pi_faulted;
2698 
2699     /*
2700      * If uval has changed, let user space handle it.
2701      */
2702     ret = (curval == uval) ? 0 : -EAGAIN;
2703 
2704 out_unlock:
2705     spin_unlock(&hb->lock);
2706 out_putkey:
2707     put_futex_key(&key);
2708     return ret;
2709 
2710 pi_faulted:
2711     spin_unlock(&hb->lock);
2712     put_futex_key(&key);
2713 
2714     ret = fault_in_user_writeable(uaddr);
2715     if (!ret)
2716         goto retry;
2717 
2718     return ret;
2719 }
2720 
2721 /**
2722  * handle_early_requeue_pi_wakeup() - Detect early wakeup on the initial futex
2723  * @hb:     the hash_bucket futex_q was original enqueued on
2724  * @q:      the futex_q woken while waiting to be requeued
2725  * @key2:   the futex_key of the requeue target futex
2726  * @timeout:    the timeout associated with the wait (NULL if none)
2727  *
2728  * Detect if the task was woken on the initial futex as opposed to the requeue
2729  * target futex.  If so, determine if it was a timeout or a signal that caused
2730  * the wakeup and return the appropriate error code to the caller.  Must be
2731  * called with the hb lock held.
2732  *
2733  * Return:
2734  *  0 = no early wakeup detected;
2735  * <0 = -ETIMEDOUT or -ERESTARTNOINTR
2736  */
2737 static inline
2738 int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
2739                    struct futex_q *q, union futex_key *key2,
2740                    struct hrtimer_sleeper *timeout)
2741 {
2742     int ret = 0;
2743 
2744     /*
2745      * With the hb lock held, we avoid races while we process the wakeup.
2746      * We only need to hold hb (and not hb2) to ensure atomicity as the
2747      * wakeup code can't change q.key from uaddr to uaddr2 if we hold hb.
2748      * It can't be requeued from uaddr2 to something else since we don't
2749      * support a PI aware source futex for requeue.
2750      */
2751     if (!match_futex(&q->key, key2)) {
2752         WARN_ON(q->lock_ptr && (&hb->lock != q->lock_ptr));
2753         /*
2754          * We were woken prior to requeue by a timeout or a signal.
2755          * Unqueue the futex_q and determine which it was.
2756          */
2757         plist_del(&q->list, &hb->chain);
2758         hb_waiters_dec(hb);
2759 
2760         /* Handle spurious wakeups gracefully */
2761         ret = -EWOULDBLOCK;
2762         if (timeout && !timeout->task)
2763             ret = -ETIMEDOUT;
2764         else if (signal_pending(current))
2765             ret = -ERESTARTNOINTR;
2766     }
2767     return ret;
2768 }
2769 
2770 /**
2771  * futex_wait_requeue_pi() - Wait on uaddr and take uaddr2
2772  * @uaddr:  the futex we initially wait on (non-pi)
2773  * @flags:  futex flags (FLAGS_SHARED, FLAGS_CLOCKRT, etc.), they must be
2774  *      the same type, no requeueing from private to shared, etc.
2775  * @val:    the expected value of uaddr
2776  * @abs_time:   absolute timeout
2777  * @bitset: 32 bit wakeup bitset set by userspace, defaults to all
2778  * @uaddr2: the pi futex we will take prior to returning to user-space
2779  *
2780  * The caller will wait on uaddr and will be requeued by futex_requeue() to
2781  * uaddr2 which must be PI aware and unique from uaddr.  Normal wakeup will wake
2782  * on uaddr2 and complete the acquisition of the rt_mutex prior to returning to
2783  * userspace.  This ensures the rt_mutex maintains an owner when it has waiters;
2784  * without one, the pi logic would not know which task to boost/deboost, if
2785  * there was a need to.
2786  *
2787  * We call schedule in futex_wait_queue_me() when we enqueue and return there
2788  * via the following--
2789  * 1) wakeup on uaddr2 after an atomic lock acquisition by futex_requeue()
2790  * 2) wakeup on uaddr2 after a requeue
2791  * 3) signal
2792  * 4) timeout
2793  *
2794  * If 3, cleanup and return -ERESTARTNOINTR.
2795  *
2796  * If 2, we may then block on trying to take the rt_mutex and return via:
2797  * 5) successful lock
2798  * 6) signal
2799  * 7) timeout
2800  * 8) other lock acquisition failure
2801  *
2802  * If 6, return -EWOULDBLOCK (restarting the syscall would do the same).
2803  *
2804  * If 4 or 7, we cleanup and return with -ETIMEDOUT.
2805  *
2806  * Return:
2807  *  0 - On success;
2808  * <0 - On error
2809  */
2810 static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
2811                  u32 val, ktime_t *abs_time, u32 bitset,
2812                  u32 __user *uaddr2)
2813 {
2814     struct hrtimer_sleeper timeout, *to = NULL;
2815     struct rt_mutex_waiter rt_waiter;
2816     struct rt_mutex *pi_mutex = NULL;
2817     struct futex_hash_bucket *hb;
2818     union futex_key key2 = FUTEX_KEY_INIT;
2819     struct futex_q q = futex_q_init;
2820     int res, ret;
2821 
2822     if (uaddr == uaddr2)
2823         return -EINVAL;
2824 
2825     if (!bitset)
2826         return -EINVAL;
2827 
2828     if (abs_time) {
2829         to = &timeout;
2830         hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
2831                       CLOCK_REALTIME : CLOCK_MONOTONIC,
2832                       HRTIMER_MODE_ABS);
2833         hrtimer_init_sleeper(to, current);
2834         hrtimer_set_expires_range_ns(&to->timer, *abs_time,
2835                          current->timer_slack_ns);
2836     }
2837 
2838     /*
2839      * The waiter is allocated on our stack, manipulated by the requeue
2840      * code while we sleep on uaddr.
2841      */
2842     debug_rt_mutex_init_waiter(&rt_waiter);
2843     RB_CLEAR_NODE(&rt_waiter.pi_tree_entry);
2844     RB_CLEAR_NODE(&rt_waiter.tree_entry);
2845     rt_waiter.task = NULL;
2846 
2847     ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
2848     if (unlikely(ret != 0))
2849         goto out;
2850 
2851     q.bitset = bitset;
2852     q.rt_waiter = &rt_waiter;
2853     q.requeue_pi_key = &key2;
2854 
2855     /*
2856      * Prepare to wait on uaddr. On success, increments q.key (key1) ref
2857      * count.
2858      */
2859     ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
2860     if (ret)
2861         goto out_key2;
2862 
2863     /*
2864      * The check above which compares uaddrs is not sufficient for
2865      * shared futexes. We need to compare the keys:
2866      */
2867     if (match_futex(&q.key, &key2)) {
2868         queue_unlock(hb);
2869         ret = -EINVAL;
2870         goto out_put_keys;
2871     }
2872 
2873     /* Queue the futex_q, drop the hb lock, wait for wakeup. */
2874     futex_wait_queue_me(hb, &q, to);
2875 
2876     spin_lock(&hb->lock);
2877     ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
2878     spin_unlock(&hb->lock);
2879     if (ret)
2880         goto out_put_keys;
2881 
2882     /*
2883      * In order for us to be here, we know our q.key == key2, and since
2884      * we took the hb->lock above, we also know that futex_requeue() has
2885      * completed and we no longer have to concern ourselves with a wakeup
2886      * race with the atomic proxy lock acquisition by the requeue code. The
2887      * futex_requeue dropped our key1 reference and incremented our key2
2888      * reference count.
2889      */
2890 
2891     /* Check if the requeue code acquired the second futex for us. */
2892     if (!q.rt_waiter) {
2893         /*
2894          * Got the lock. We might not be the anticipated owner if we
2895          * did a lock-steal - fix up the PI-state in that case.
2896          */
2897         if (q.pi_state && (q.pi_state->owner != current)) {
2898             spin_lock(q.lock_ptr);
2899             ret = fixup_pi_state_owner(uaddr2, &q, current);
2900             /*
2901              * Drop the reference to the pi state which
2902              * the requeue_pi() code acquired for us.
2903              */
2904             put_pi_state(q.pi_state);
2905             spin_unlock(q.lock_ptr);
2906         }
2907     } else {
2908         /*
2909          * We have been woken up by futex_unlock_pi(), a timeout, or a
2910          * signal.  futex_unlock_pi() will not destroy the lock_ptr nor
2911          * the pi_state.
2912          */
2913         WARN_ON(!q.pi_state);
2914         pi_mutex = &q.pi_state->pi_mutex;
2915         ret = rt_mutex_finish_proxy_lock(pi_mutex, to, &rt_waiter);
2916         debug_rt_mutex_free_waiter(&rt_waiter);
2917 
2918         spin_lock(q.lock_ptr);
2919         /*
2920          * Fixup the pi_state owner and possibly acquire the lock if we
2921          * haven't already.
2922          */
2923         res = fixup_owner(uaddr2, &q, !ret);
2924         /*
2925          * If fixup_owner() returned an error, proprogate that.  If it
2926          * acquired the lock, clear -ETIMEDOUT or -EINTR.
2927          */
2928         if (res)
2929             ret = (res < 0) ? res : 0;
2930 
2931         /* Unqueue and drop the lock. */
2932         unqueue_me_pi(&q);
2933     }
2934 
2935     /*
2936      * If fixup_pi_state_owner() faulted and was unable to handle the
2937      * fault, unlock the rt_mutex and return the fault to userspace.
2938      */
2939     if (ret == -EFAULT) {
2940         if (pi_mutex && rt_mutex_owner(pi_mutex) == current)
2941             rt_mutex_unlock(pi_mutex);
2942     } else if (ret == -EINTR) {
2943         /*
2944          * We've already been requeued, but cannot restart by calling
2945          * futex_lock_pi() directly. We could restart this syscall, but
2946          * it would detect that the user space "val" changed and return
2947          * -EWOULDBLOCK.  Save the overhead of the restart and return
2948          * -EWOULDBLOCK directly.
2949          */
2950         ret = -EWOULDBLOCK;
2951     }
2952 
2953 out_put_keys:
2954     put_futex_key(&q.key);
2955 out_key2:
2956     put_futex_key(&key2);
2957 
2958 out:
2959     if (to) {
2960         hrtimer_cancel(&to->timer);
2961         destroy_hrtimer_on_stack(&to->timer);
2962     }
2963     return ret;
2964 }
2965 
2966 /*
2967  * Support for robust futexes: the kernel cleans up held futexes at
2968  * thread exit time.
2969  *
2970  * Implementation: user-space maintains a per-thread list of locks it
2971  * is holding. Upon do_exit(), the kernel carefully walks this list,
2972  * and marks all locks that are owned by this thread with the
2973  * FUTEX_OWNER_DIED bit, and wakes up a waiter (if any). The list is
2974  * always manipulated with the lock held, so the list is private and
2975  * per-thread. Userspace also maintains a per-thread 'list_op_pending'
2976  * field, to allow the kernel to clean up if the thread dies after
2977  * acquiring the lock, but just before it could have added itself to
2978  * the list. There can only be one such pending lock.
2979  */
2980 
2981 /**
2982  * sys_set_robust_list() - Set the robust-futex list head of a task
2983  * @head:   pointer to the list-head
2984  * @len:    length of the list-head, as userspace expects
2985  */
2986 SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
2987         size_t, len)
2988 {
2989     if (!futex_cmpxchg_enabled)
2990         return -ENOSYS;
2991     /*
2992      * The kernel knows only one size for now:
2993      */
2994     if (unlikely(len != sizeof(*head)))
2995         return -EINVAL;
2996 
2997     current->robust_list = head;
2998 
2999     return 0;
3000 }
3001 
3002 /**
3003  * sys_get_robust_list() - Get the robust-futex list head of a task
3004  * @pid:    pid of the process [zero for current task]
3005  * @head_ptr:   pointer to a list-head pointer, the kernel fills it in
3006  * @len_ptr:    pointer to a length field, the kernel fills in the header size
3007  */
3008 SYSCALL_DEFINE3(get_robust_list, int, pid,
3009         struct robust_list_head __user * __user *, head_ptr,
3010         size_t __user *, len_ptr)
3011 {
3012     struct robust_list_head __user *head;
3013     unsigned long ret;
3014     struct task_struct *p;
3015 
3016     if (!futex_cmpxchg_enabled)
3017         return -ENOSYS;
3018 
3019     rcu_read_lock();
3020 
3021     ret = -ESRCH;
3022     if (!pid)
3023         p = current;
3024     else {
3025         p = find_task_by_vpid(pid);
3026         if (!p)
3027             goto err_unlock;
3028     }
3029 
3030     ret = -EPERM;
3031     if (!ptrace_may_access(p, PTRACE_MODE_READ_REALCREDS))
3032         goto err_unlock;
3033 
3034     head = p->robust_list;
3035     rcu_read_unlock();
3036 
3037     if (put_user(sizeof(*head), len_ptr))
3038         return -EFAULT;
3039     return put_user(head, head_ptr);
3040 
3041 err_unlock:
3042     rcu_read_unlock();
3043 
3044     return ret;
3045 }
3046 
3047 /*
3048  * Process a futex-list entry, check whether it's owned by the
3049  * dying task, and do notification if so:
3050  */
3051 int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
3052 {
3053     u32 uval, uninitialized_var(nval), mval;
3054 
3055 retry:
3056     if (get_user(uval, uaddr))
3057         return -1;
3058 
3059     if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
3060         /*
3061          * Ok, this dying thread is truly holding a futex
3062          * of interest. Set the OWNER_DIED bit atomically
3063          * via cmpxchg, and if the value had FUTEX_WAITERS
3064          * set, wake up a waiter (if any). (We have to do a
3065          * futex_wake() even if OWNER_DIED is already set -
3066          * to handle the rare but possible case of recursive
3067          * thread-death.) The rest of the cleanup is done in
3068          * userspace.
3069          */
3070         mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
3071         /*
3072          * We are not holding a lock here, but we want to have
3073          * the pagefault_disable/enable() protection because
3074          * we want to handle the fault gracefully. If the
3075          * access fails we try to fault in the futex with R/W
3076          * verification via get_user_pages. get_user() above
3077          * does not guarantee R/W access. If that fails we
3078          * give up and leave the futex locked.
3079          */
3080         if (cmpxchg_futex_value_locked(&nval, uaddr, uval, mval)) {
3081             if (fault_in_user_writeable(uaddr))
3082                 return -1;
3083             goto retry;
3084         }
3085         if (nval != uval)
3086             goto retry;
3087 
3088         /*
3089          * Wake robust non-PI futexes here. The wakeup of
3090          * PI futexes happens in exit_pi_state():
3091          */
3092         if (!pi && (uval & FUTEX_WAITERS))
3093             futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
3094     }
3095     return 0;
3096 }
3097 
3098 /*
3099  * Fetch a robust-list pointer. Bit 0 signals PI futexes:
3100  */
3101 static inline int fetch_robust_entry(struct robust_list __user **entry,
3102                      struct robust_list __user * __user *head,
3103                      unsigned int *pi)
3104 {
3105     unsigned long uentry;
3106 
3107     if (get_user(uentry, (unsigned long __user *)head))
3108         return -EFAULT;
3109 
3110     *entry = (void __user *)(uentry & ~1UL);
3111     *pi = uentry & 1;
3112 
3113     return 0;
3114 }
3115 
3116 /*
3117  * Walk curr->robust_list (very carefully, it's a userspace list!)
3118  * and mark any locks found there dead, and notify any waiters.
3119  *
3120  * We silently return on any sign of list-walking problem.
3121  */
3122 void exit_robust_list(struct task_struct *curr)
3123 {
3124     struct robust_list_head __user *head = curr->robust_list;
3125     struct robust_list __user *entry, *next_entry, *pending;
3126     unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
3127     unsigned int uninitialized_var(next_pi);
3128     unsigned long futex_offset;
3129     int rc;
3130 
3131     if (!futex_cmpxchg_enabled)
3132         return;
3133 
3134     /*
3135      * Fetch the list head (which was registered earlier, via
3136      * sys_set_robust_list()):
3137      */
3138     if (fetch_robust_entry(&entry, &head->list.next, &pi))
3139         return;
3140     /*
3141      * Fetch the relative futex offset:
3142      */
3143     if (get_user(futex_offset, &head->futex_offset))
3144         return;
3145     /*
3146      * Fetch any possibly pending lock-add first, and handle it
3147      * if it exists:
3148      */
3149     if (fetch_robust_entry(&pending, &head->list_op_pending, &pip))
3150         return;
3151 
3152     next_entry = NULL;  /* avoid warning with gcc */
3153     while (entry != &head->list) {
3154         /*
3155          * Fetch the next entry in the list before calling
3156          * handle_futex_death:
3157          */
3158         rc = fetch_robust_entry(&next_entry, &entry->next, &next_pi);
3159         /*
3160          * A pending lock might already be on the list, so
3161          * don't process it twice:
3162          */
3163         if (entry != pending)
3164             if (handle_futex_death((void __user *)entry + futex_offset,
3165                         curr, pi))
3166                 return;
3167         if (rc)
3168             return;
3169         entry = next_entry;
3170         pi = next_pi;
3171         /*
3172          * Avoid excessively long or circular lists:
3173          */
3174         if (!--limit)
3175             break;
3176 
3177         cond_resched();
3178     }
3179 
3180     if (pending)
3181         handle_futex_death((void __user *)pending + futex_offset,
3182                    curr, pip);
3183 }
3184 
3185 long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
3186         u32 __user *uaddr2, u32 val2, u32 val3)
3187 {
3188     int cmd = op & FUTEX_CMD_MASK;
3189     unsigned int flags = 0;
3190 
3191     if (!(op & FUTEX_PRIVATE_FLAG))
3192         flags |= FLAGS_SHARED;
3193 
3194     if (op & FUTEX_CLOCK_REALTIME) {
3195         flags |= FLAGS_CLOCKRT;
3196         if (cmd != FUTEX_WAIT && cmd != FUTEX_WAIT_BITSET && \
3197             cmd != FUTEX_WAIT_REQUEUE_PI)
3198             return -ENOSYS;
3199     }
3200 
3201     switch (cmd) {
3202     case FUTEX_LOCK_PI:
3203     case FUTEX_UNLOCK_PI:
3204     case FUTEX_TRYLOCK_PI:
3205     case FUTEX_WAIT_REQUEUE_PI:
3206     case FUTEX_CMP_REQUEUE_PI:
3207         if (!futex_cmpxchg_enabled)
3208             return -ENOSYS;
3209     }
3210 
3211     switch (cmd) {
3212     case FUTEX_WAIT:
3213         val3 = FUTEX_BITSET_MATCH_ANY;
3214     case FUTEX_WAIT_BITSET:
3215         return futex_wait(uaddr, flags, val, timeout, val3);
3216     case FUTEX_WAKE:
3217         val3 = FUTEX_BITSET_MATCH_ANY;
3218     case FUTEX_WAKE_BITSET:
3219         return futex_wake(uaddr, flags, val, val3);
3220     case FUTEX_REQUEUE:
3221         return futex_requeue(uaddr, flags, uaddr2, val, val2, NULL, 0);
3222     case FUTEX_CMP_REQUEUE:
3223         return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 0);
3224     case FUTEX_WAKE_OP:
3225         return futex_wake_op(uaddr, flags, uaddr2, val, val2, val3);
3226     case FUTEX_LOCK_PI:
3227         return futex_lock_pi(uaddr, flags, timeout, 0);
3228     case FUTEX_UNLOCK_PI:
3229         return futex_unlock_pi(uaddr, flags);
3230     case FUTEX_TRYLOCK_PI:
3231         return futex_lock_pi(uaddr, flags, NULL, 1);
3232     case FUTEX_WAIT_REQUEUE_PI:
3233         val3 = FUTEX_BITSET_MATCH_ANY;
3234         return futex_wait_requeue_pi(uaddr, flags, val, timeout, val3,
3235                          uaddr2);
3236     case FUTEX_CMP_REQUEUE_PI:
3237         return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 1);
3238     }
3239     return -ENOSYS;
3240 }
3241 
3242 
3243 SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
3244         struct timespec __user *, utime, u32 __user *, uaddr2,
3245         u32, val3)
3246 {
3247     struct timespec ts;
3248     ktime_t t, *tp = NULL;
3249     u32 val2 = 0;
3250     int cmd = op & FUTEX_CMD_MASK;
3251 
3252     if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
3253               cmd == FUTEX_WAIT_BITSET ||
3254               cmd == FUTEX_WAIT_REQUEUE_PI)) {
3255         if (unlikely(should_fail_futex(!(op & FUTEX_PRIVATE_FLAG))))
3256             return -EFAULT;
3257         if (copy_from_user(&ts, utime, sizeof(ts)) != 0)
3258             return -EFAULT;
3259         if (!timespec_valid(&ts))
3260             return -EINVAL;
3261 
3262         t = timespec_to_ktime(ts);
3263         if (cmd == FUTEX_WAIT)
3264             t = ktime_add_safe(ktime_get(), t);
3265         tp = &t;
3266     }
3267     /*
3268      * requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.
3269      * number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.
3270      */
3271     if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||
3272         cmd == FUTEX_CMP_REQUEUE_PI || cmd == FUTEX_WAKE_OP)
3273         val2 = (u32) (unsigned long) utime;
3274 
3275     return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);
3276 }
3277 
3278 static void __init futex_detect_cmpxchg(void)
3279 {
3280 #ifndef CONFIG_HAVE_FUTEX_CMPXCHG
3281     u32 curval;
3282 
3283     /*
3284      * This will fail and we want it. Some arch implementations do
3285      * runtime detection of the futex_atomic_cmpxchg_inatomic()
3286      * functionality. We want to know that before we call in any
3287      * of the complex code paths. Also we want to prevent
3288      * registration of robust lists in that case. NULL is
3289      * guaranteed to fault and we get -EFAULT on functional
3290      * implementation, the non-functional ones will return
3291      * -ENOSYS.
3292      */
3293     if (cmpxchg_futex_value_locked(&curval, NULL, 0, 0) == -EFAULT)
3294         futex_cmpxchg_enabled = 1;
3295 #endif
3296 }
3297 
3298 static int __init futex_init(void)
3299 {
3300     unsigned int futex_shift;
3301     unsigned long i;
3302 
3303 #if CONFIG_BASE_SMALL
3304     futex_hashsize = 16;
3305 #else
3306     futex_hashsize = roundup_pow_of_two(256 * num_possible_cpus());
3307 #endif
3308 
3309     futex_queues = alloc_large_system_hash("futex", sizeof(*futex_queues),
3310                            futex_hashsize, 0,
3311                            futex_hashsize < 256 ? HASH_SMALL : 0,
3312                            &futex_shift, NULL,
3313                            futex_hashsize, futex_hashsize);
3314     futex_hashsize = 1UL << futex_shift;
3315 
3316     futex_detect_cmpxchg();
3317 
3318     for (i = 0; i < futex_hashsize; i++) {
3319         atomic_set(&futex_queues[i].waiters, 0);
3320         plist_head_init(&futex_queues[i].chain);
3321         spin_lock_init(&futex_queues[i].lock);
3322     }
3323 
3324     return 0;
3325 }
3326 core_initcall(futex_init);