Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/kernel/futex.c

  1 /*
  2  *  Fast Userspace Mutexes (which I call "Futexes!").
  3  *  (C) Rusty Russell, IBM 2002
  4  *
  5  *  Generalized futexes, futex requeueing, misc fixes by Ingo Molnar
  6  *  (C) Copyright 2003 Red Hat Inc, All Rights Reserved
  7  *
  8  *  Removed page pinning, fix privately mapped COW pages and other cleanups
  9  *  (C) Copyright 2003, 2004 Jamie Lokier
 10  *
 11  *  Robust futex support started by Ingo Molnar
 12  *  (C) Copyright 2006 Red Hat Inc, All Rights Reserved
 13  *  Thanks to Thomas Gleixner for suggestions, analysis and fixes.
 14  *
 15  *  PI-futex support started by Ingo Molnar and Thomas Gleixner
 16  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
 17  *  Copyright (C) 2006 Timesys Corp., Thomas Gleixner <tglx@timesys.com>
 18  *
 19  *  PRIVATE futexes by Eric Dumazet
 20  *  Copyright (C) 2007 Eric Dumazet <dada1@cosmosbay.com>
 21  *
 22  *  Requeue-PI support by Darren Hart <dvhltc@us.ibm.com>
 23  *  Copyright (C) IBM Corporation, 2009
 24  *  Thanks to Thomas Gleixner for conceptual design and careful reviews.
 25  *
 26  *  Thanks to Ben LaHaise for yelling "hashed waitqueues" loudly
 27  *  enough at me, Linus for the original (flawed) idea, Matthew
 28  *  Kirkwood for proof-of-concept implementation.
 29  *
 30  *  "The futexes are also cursed."
 31  *  "But they come in a choice of three flavours!"
 32  *
 33  *  This program is free software; you can redistribute it and/or modify
 34  *  it under the terms of the GNU General Public License as published by
 35  *  the Free Software Foundation; either version 2 of the License, or
 36  *  (at your option) any later version.
 37  *
 38  *  This program is distributed in the hope that it will be useful,
 39  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 40  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 41  *  GNU General Public License for more details.
 42  *
 43  *  You should have received a copy of the GNU General Public License
 44  *  along with this program; if not, write to the Free Software
 45  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 46  */
 47 #include <linux/slab.h>
 48 #include <linux/poll.h>
 49 #include <linux/fs.h>
 50 #include <linux/file.h>
 51 #include <linux/jhash.h>
 52 #include <linux/init.h>
 53 #include <linux/futex.h>
 54 #include <linux/mount.h>
 55 #include <linux/pagemap.h>
 56 #include <linux/syscalls.h>
 57 #include <linux/signal.h>
 58 #include <linux/export.h>
 59 #include <linux/magic.h>
 60 #include <linux/pid.h>
 61 #include <linux/nsproxy.h>
 62 #include <linux/ptrace.h>
 63 #include <linux/sched/rt.h>
 64 #include <linux/hugetlb.h>
 65 #include <linux/freezer.h>
 66 #include <linux/bootmem.h>
 67 #include <linux/fault-inject.h>
 68 
 69 #include <asm/futex.h>
 70 
 71 #include "locking/rtmutex_common.h"
 72 
 73 /*
 74  * READ this before attempting to hack on futexes!
 75  *
 76  * Basic futex operation and ordering guarantees
 77  * =============================================
 78  *
 79  * The waiter reads the futex value in user space and calls
 80  * futex_wait(). This function computes the hash bucket and acquires
 81  * the hash bucket lock. After that it reads the futex user space value
 82  * again and verifies that the data has not changed. If it has not changed
 83  * it enqueues itself into the hash bucket, releases the hash bucket lock
 84  * and schedules.
 85  *
 86  * The waker side modifies the user space value of the futex and calls
 87  * futex_wake(). This function computes the hash bucket and acquires the
 88  * hash bucket lock. Then it looks for waiters on that futex in the hash
 89  * bucket and wakes them.
 90  *
 91  * In futex wake up scenarios where no tasks are blocked on a futex, taking
 92  * the hb spinlock can be avoided and simply return. In order for this
 93  * optimization to work, ordering guarantees must exist so that the waiter
 94  * being added to the list is acknowledged when the list is concurrently being
 95  * checked by the waker, avoiding scenarios like the following:
 96  *
 97  * CPU 0                               CPU 1
 98  * val = *futex;
 99  * sys_futex(WAIT, futex, val);
100  *   futex_wait(futex, val);
101  *   uval = *futex;
102  *                                     *futex = newval;
103  *                                     sys_futex(WAKE, futex);
104  *                                       futex_wake(futex);
105  *                                       if (queue_empty())
106  *                                         return;
107  *   if (uval == val)
108  *      lock(hash_bucket(futex));
109  *      queue();
110  *     unlock(hash_bucket(futex));
111  *     schedule();
112  *
113  * This would cause the waiter on CPU 0 to wait forever because it
114  * missed the transition of the user space value from val to newval
115  * and the waker did not find the waiter in the hash bucket queue.
116  *
117  * The correct serialization ensures that a waiter either observes
118  * the changed user space value before blocking or is woken by a
119  * concurrent waker:
120  *
121  * CPU 0                                 CPU 1
122  * val = *futex;
123  * sys_futex(WAIT, futex, val);
124  *   futex_wait(futex, val);
125  *
126  *   waiters++; (a)
127  *   smp_mb(); (A) <-- paired with -.
128  *                                  |
129  *   lock(hash_bucket(futex));      |
130  *                                  |
131  *   uval = *futex;                 |
132  *                                  |        *futex = newval;
133  *                                  |        sys_futex(WAKE, futex);
134  *                                  |          futex_wake(futex);
135  *                                  |
136  *                                  `--------> smp_mb(); (B)
137  *   if (uval == val)
138  *     queue();
139  *     unlock(hash_bucket(futex));
140  *     schedule();                         if (waiters)
141  *                                           lock(hash_bucket(futex));
142  *   else                                    wake_waiters(futex);
143  *     waiters--; (b)                        unlock(hash_bucket(futex));
144  *
145  * Where (A) orders the waiters increment and the futex value read through
146  * atomic operations (see hb_waiters_inc) and where (B) orders the write
147  * to futex and the waiters read -- this is done by the barriers for both
148  * shared and private futexes in get_futex_key_refs().
149  *
150  * This yields the following case (where X:=waiters, Y:=futex):
151  *
152  *      X = Y = 0
153  *
154  *      w[X]=1          w[Y]=1
155  *      MB              MB
156  *      r[Y]=y          r[X]=x
157  *
158  * Which guarantees that x==0 && y==0 is impossible; which translates back into
159  * the guarantee that we cannot both miss the futex variable change and the
160  * enqueue.
161  *
162  * Note that a new waiter is accounted for in (a) even when it is possible that
163  * the wait call can return error, in which case we backtrack from it in (b).
164  * Refer to the comment in queue_lock().
165  *
166  * Similarly, in order to account for waiters being requeued on another
167  * address we always increment the waiters for the destination bucket before
168  * acquiring the lock. It then decrements them again  after releasing it -
169  * the code that actually moves the futex(es) between hash buckets (requeue_futex)
170  * will do the additional required waiter count housekeeping. This is done for
171  * double_lock_hb() and double_unlock_hb(), respectively.
172  */
173 
174 #ifndef CONFIG_HAVE_FUTEX_CMPXCHG
175 int __read_mostly futex_cmpxchg_enabled;
176 #endif
177 
178 /*
179  * Futex flags used to encode options to functions and preserve them across
180  * restarts.
181  */
182 #ifdef CONFIG_MMU
183 # define FLAGS_SHARED           0x01
184 #else
185 /*
186  * NOMMU does not have per process address space. Let the compiler optimize
187  * code away.
188  */
189 # define FLAGS_SHARED           0x00
190 #endif
191 #define FLAGS_CLOCKRT           0x02
192 #define FLAGS_HAS_TIMEOUT       0x04
193 
194 /*
195  * Priority Inheritance state:
196  */
197 struct futex_pi_state {
198         /*
199          * list of 'owned' pi_state instances - these have to be
200          * cleaned up in do_exit() if the task exits prematurely:
201          */
202         struct list_head list;
203 
204         /*
205          * The PI object:
206          */
207         struct rt_mutex pi_mutex;
208 
209         struct task_struct *owner;
210         atomic_t refcount;
211 
212         union futex_key key;
213 };
214 
215 /**
216  * struct futex_q - The hashed futex queue entry, one per waiting task
217  * @list:               priority-sorted list of tasks waiting on this futex
218  * @task:               the task waiting on the futex
219  * @lock_ptr:           the hash bucket lock
220  * @key:                the key the futex is hashed on
221  * @pi_state:           optional priority inheritance state
222  * @rt_waiter:          rt_waiter storage for use with requeue_pi
223  * @requeue_pi_key:     the requeue_pi target futex key
224  * @bitset:             bitset for the optional bitmasked wakeup
225  *
226  * We use this hashed waitqueue, instead of a normal wait_queue_t, so
227  * we can wake only the relevant ones (hashed queues may be shared).
228  *
229  * A futex_q has a woken state, just like tasks have TASK_RUNNING.
230  * It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
231  * The order of wakeup is always to make the first condition true, then
232  * the second.
233  *
234  * PI futexes are typically woken before they are removed from the hash list via
235  * the rt_mutex code. See unqueue_me_pi().
236  */
237 struct futex_q {
238         struct plist_node list;
239 
240         struct task_struct *task;
241         spinlock_t *lock_ptr;
242         union futex_key key;
243         struct futex_pi_state *pi_state;
244         struct rt_mutex_waiter *rt_waiter;
245         union futex_key *requeue_pi_key;
246         u32 bitset;
247 };
248 
249 static const struct futex_q futex_q_init = {
250         /* list gets initialized in queue_me()*/
251         .key = FUTEX_KEY_INIT,
252         .bitset = FUTEX_BITSET_MATCH_ANY
253 };
254 
255 /*
256  * Hash buckets are shared by all the futex_keys that hash to the same
257  * location.  Each key may have multiple futex_q structures, one for each task
258  * waiting on a futex.
259  */
260 struct futex_hash_bucket {
261         atomic_t waiters;
262         spinlock_t lock;
263         struct plist_head chain;
264 } ____cacheline_aligned_in_smp;
265 
266 /*
267  * The base of the bucket array and its size are always used together
268  * (after initialization only in hash_futex()), so ensure that they
269  * reside in the same cacheline.
270  */
271 static struct {
272         struct futex_hash_bucket *queues;
273         unsigned long            hashsize;
274 } __futex_data __read_mostly __aligned(2*sizeof(long));
275 #define futex_queues   (__futex_data.queues)
276 #define futex_hashsize (__futex_data.hashsize)
277 
278 
279 /*
280  * Fault injections for futexes.
281  */
282 #ifdef CONFIG_FAIL_FUTEX
283 
284 static struct {
285         struct fault_attr attr;
286 
287         bool ignore_private;
288 } fail_futex = {
289         .attr = FAULT_ATTR_INITIALIZER,
290         .ignore_private = false,
291 };
292 
293 static int __init setup_fail_futex(char *str)
294 {
295         return setup_fault_attr(&fail_futex.attr, str);
296 }
297 __setup("fail_futex=", setup_fail_futex);
298 
299 static bool should_fail_futex(bool fshared)
300 {
301         if (fail_futex.ignore_private && !fshared)
302                 return false;
303 
304         return should_fail(&fail_futex.attr, 1);
305 }
306 
307 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
308 
309 static int __init fail_futex_debugfs(void)
310 {
311         umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
312         struct dentry *dir;
313 
314         dir = fault_create_debugfs_attr("fail_futex", NULL,
315                                         &fail_futex.attr);
316         if (IS_ERR(dir))
317                 return PTR_ERR(dir);
318 
319         if (!debugfs_create_bool("ignore-private", mode, dir,
320                                  &fail_futex.ignore_private)) {
321                 debugfs_remove_recursive(dir);
322                 return -ENOMEM;
323         }
324 
325         return 0;
326 }
327 
328 late_initcall(fail_futex_debugfs);
329 
330 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
331 
332 #else
333 static inline bool should_fail_futex(bool fshared)
334 {
335         return false;
336 }
337 #endif /* CONFIG_FAIL_FUTEX */
338 
339 static inline void futex_get_mm(union futex_key *key)
340 {
341         atomic_inc(&key->private.mm->mm_count);
342         /*
343          * Ensure futex_get_mm() implies a full barrier such that
344          * get_futex_key() implies a full barrier. This is relied upon
345          * as smp_mb(); (B), see the ordering comment above.
346          */
347         smp_mb__after_atomic();
348 }
349 
350 /*
351  * Reflects a new waiter being added to the waitqueue.
352  */
353 static inline void hb_waiters_inc(struct futex_hash_bucket *hb)
354 {
355 #ifdef CONFIG_SMP
356         atomic_inc(&hb->waiters);
357         /*
358          * Full barrier (A), see the ordering comment above.
359          */
360         smp_mb__after_atomic();
361 #endif
362 }
363 
364 /*
365  * Reflects a waiter being removed from the waitqueue by wakeup
366  * paths.
367  */
368 static inline void hb_waiters_dec(struct futex_hash_bucket *hb)
369 {
370 #ifdef CONFIG_SMP
371         atomic_dec(&hb->waiters);
372 #endif
373 }
374 
375 static inline int hb_waiters_pending(struct futex_hash_bucket *hb)
376 {
377 #ifdef CONFIG_SMP
378         return atomic_read(&hb->waiters);
379 #else
380         return 1;
381 #endif
382 }
383 
384 /**
385  * hash_futex - Return the hash bucket in the global hash
386  * @key:        Pointer to the futex key for which the hash is calculated
387  *
388  * We hash on the keys returned from get_futex_key (see below) and return the
389  * corresponding hash bucket in the global hash.
390  */
391 static struct futex_hash_bucket *hash_futex(union futex_key *key)
392 {
393         u32 hash = jhash2((u32*)&key->both.word,
394                           (sizeof(key->both.word)+sizeof(key->both.ptr))/4,
395                           key->both.offset);
396         return &futex_queues[hash & (futex_hashsize - 1)];
397 }
398 
399 
400 /**
401  * match_futex - Check whether two futex keys are equal
402  * @key1:       Pointer to key1
403  * @key2:       Pointer to key2
404  *
405  * Return 1 if two futex_keys are equal, 0 otherwise.
406  */
407 static inline int match_futex(union futex_key *key1, union futex_key *key2)
408 {
409         return (key1 && key2
410                 && key1->both.word == key2->both.word
411                 && key1->both.ptr == key2->both.ptr
412                 && key1->both.offset == key2->both.offset);
413 }
414 
415 /*
416  * Take a reference to the resource addressed by a key.
417  * Can be called while holding spinlocks.
418  *
419  */
420 static void get_futex_key_refs(union futex_key *key)
421 {
422         if (!key->both.ptr)
423                 return;
424 
425         /*
426          * On MMU less systems futexes are always "private" as there is no per
427          * process address space. We need the smp wmb nevertheless - yes,
428          * arch/blackfin has MMU less SMP ...
429          */
430         if (!IS_ENABLED(CONFIG_MMU)) {
431                 smp_mb(); /* explicit smp_mb(); (B) */
432                 return;
433         }
434 
435         switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
436         case FUT_OFF_INODE:
437                 ihold(key->shared.inode); /* implies smp_mb(); (B) */
438                 break;
439         case FUT_OFF_MMSHARED:
440                 futex_get_mm(key); /* implies smp_mb(); (B) */
441                 break;
442         default:
443                 /*
444                  * Private futexes do not hold reference on an inode or
445                  * mm, therefore the only purpose of calling get_futex_key_refs
446                  * is because we need the barrier for the lockless waiter check.
447                  */
448                 smp_mb(); /* explicit smp_mb(); (B) */
449         }
450 }
451 
452 /*
453  * Drop a reference to the resource addressed by a key.
454  * The hash bucket spinlock must not be held. This is
455  * a no-op for private futexes, see comment in the get
456  * counterpart.
457  */
458 static void drop_futex_key_refs(union futex_key *key)
459 {
460         if (!key->both.ptr) {
461                 /* If we're here then we tried to put a key we failed to get */
462                 WARN_ON_ONCE(1);
463                 return;
464         }
465 
466         if (!IS_ENABLED(CONFIG_MMU))
467                 return;
468 
469         switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
470         case FUT_OFF_INODE:
471                 iput(key->shared.inode);
472                 break;
473         case FUT_OFF_MMSHARED:
474                 mmdrop(key->private.mm);
475                 break;
476         }
477 }
478 
479 /**
480  * get_futex_key() - Get parameters which are the keys for a futex
481  * @uaddr:      virtual address of the futex
482  * @fshared:    0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
483  * @key:        address where result is stored.
484  * @rw:         mapping needs to be read/write (values: VERIFY_READ,
485  *              VERIFY_WRITE)
486  *
487  * Return: a negative error code or 0
488  *
489  * The key words are stored in *key on success.
490  *
491  * For shared mappings, it's (page->index, file_inode(vma->vm_file),
492  * offset_within_page).  For private mappings, it's (uaddr, current->mm).
493  * We can usually work out the index without swapping in the page.
494  *
495  * lock_page() might sleep, the caller should not hold a spinlock.
496  */
497 static int
498 get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
499 {
500         unsigned long address = (unsigned long)uaddr;
501         struct mm_struct *mm = current->mm;
502         struct page *page, *tail;
503         struct address_space *mapping;
504         int err, ro = 0;
505 
506         /*
507          * The futex address must be "naturally" aligned.
508          */
509         key->both.offset = address % PAGE_SIZE;
510         if (unlikely((address % sizeof(u32)) != 0))
511                 return -EINVAL;
512         address -= key->both.offset;
513 
514         if (unlikely(!access_ok(rw, uaddr, sizeof(u32))))
515                 return -EFAULT;
516 
517         if (unlikely(should_fail_futex(fshared)))
518                 return -EFAULT;
519 
520         /*
521          * PROCESS_PRIVATE futexes are fast.
522          * As the mm cannot disappear under us and the 'key' only needs
523          * virtual address, we dont even have to find the underlying vma.
524          * Note : We do have to check 'uaddr' is a valid user address,
525          *        but access_ok() should be faster than find_vma()
526          */
527         if (!fshared) {
528                 key->private.mm = mm;
529                 key->private.address = address;
530                 get_futex_key_refs(key);  /* implies smp_mb(); (B) */
531                 return 0;
532         }
533 
534 again:
535         /* Ignore any VERIFY_READ mapping (futex common case) */
536         if (unlikely(should_fail_futex(fshared)))
537                 return -EFAULT;
538 
539         err = get_user_pages_fast(address, 1, 1, &page);
540         /*
541          * If write access is not required (eg. FUTEX_WAIT), try
542          * and get read-only access.
543          */
544         if (err == -EFAULT && rw == VERIFY_READ) {
545                 err = get_user_pages_fast(address, 1, 0, &page);
546                 ro = 1;
547         }
548         if (err < 0)
549                 return err;
550         else
551                 err = 0;
552 
553         /*
554          * The treatment of mapping from this point on is critical. The page
555          * lock protects many things but in this context the page lock
556          * stabilizes mapping, prevents inode freeing in the shared
557          * file-backed region case and guards against movement to swap cache.
558          *
559          * Strictly speaking the page lock is not needed in all cases being
560          * considered here and page lock forces unnecessarily serialization
561          * From this point on, mapping will be re-verified if necessary and
562          * page lock will be acquired only if it is unavoidable
563          *
564          * Mapping checks require the head page for any compound page so the
565          * head page and mapping is looked up now. For anonymous pages, it
566          * does not matter if the page splits in the future as the key is
567          * based on the address. For filesystem-backed pages, the tail is
568          * required as the index of the page determines the key. For
569          * base pages, there is no tail page and tail == page.
570          */
571         tail = page;
572         page = compound_head(page);
573         mapping = READ_ONCE(page->mapping);
574 
575         /*
576          * If page->mapping is NULL, then it cannot be a PageAnon
577          * page; but it might be the ZERO_PAGE or in the gate area or
578          * in a special mapping (all cases which we are happy to fail);
579          * or it may have been a good file page when get_user_pages_fast
580          * found it, but truncated or holepunched or subjected to
581          * invalidate_complete_page2 before we got the page lock (also
582          * cases which we are happy to fail).  And we hold a reference,
583          * so refcount care in invalidate_complete_page's remove_mapping
584          * prevents drop_caches from setting mapping to NULL beneath us.
585          *
586          * The case we do have to guard against is when memory pressure made
587          * shmem_writepage move it from filecache to swapcache beneath us:
588          * an unlikely race, but we do need to retry for page->mapping.
589          */
590         if (unlikely(!mapping)) {
591                 int shmem_swizzled;
592 
593                 /*
594                  * Page lock is required to identify which special case above
595                  * applies. If this is really a shmem page then the page lock
596                  * will prevent unexpected transitions.
597                  */
598                 lock_page(page);
599                 shmem_swizzled = PageSwapCache(page) || page->mapping;
600                 unlock_page(page);
601                 put_page(page);
602 
603                 if (shmem_swizzled)
604                         goto again;
605 
606                 return -EFAULT;
607         }
608 
609         /*
610          * Private mappings are handled in a simple way.
611          *
612          * If the futex key is stored on an anonymous page, then the associated
613          * object is the mm which is implicitly pinned by the calling process.
614          *
615          * NOTE: When userspace waits on a MAP_SHARED mapping, even if
616          * it's a read-only handle, it's expected that futexes attach to
617          * the object not the particular process.
618          */
619         if (PageAnon(page)) {
620                 /*
621                  * A RO anonymous page will never change and thus doesn't make
622                  * sense for futex operations.
623                  */
624                 if (unlikely(should_fail_futex(fshared)) || ro) {
625                         err = -EFAULT;
626                         goto out;
627                 }
628 
629                 key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
630                 key->private.mm = mm;
631                 key->private.address = address;
632 
633                 get_futex_key_refs(key); /* implies smp_mb(); (B) */
634 
635         } else {
636                 struct inode *inode;
637 
638                 /*
639                  * The associated futex object in this case is the inode and
640                  * the page->mapping must be traversed. Ordinarily this should
641                  * be stabilised under page lock but it's not strictly
642                  * necessary in this case as we just want to pin the inode, not
643                  * update the radix tree or anything like that.
644                  *
645                  * The RCU read lock is taken as the inode is finally freed
646                  * under RCU. If the mapping still matches expectations then the
647                  * mapping->host can be safely accessed as being a valid inode.
648                  */
649                 rcu_read_lock();
650 
651                 if (READ_ONCE(page->mapping) != mapping) {
652                         rcu_read_unlock();
653                         put_page(page);
654 
655                         goto again;
656                 }
657 
658                 inode = READ_ONCE(mapping->host);
659                 if (!inode) {
660                         rcu_read_unlock();
661                         put_page(page);
662 
663                         goto again;
664                 }
665 
666                 /*
667                  * Take a reference unless it is about to be freed. Previously
668                  * this reference was taken by ihold under the page lock
669                  * pinning the inode in place so i_lock was unnecessary. The
670                  * only way for this check to fail is if the inode was
671                  * truncated in parallel so warn for now if this happens.
672                  *
673                  * We are not calling into get_futex_key_refs() in file-backed
674                  * cases, therefore a successful atomic_inc return below will
675                  * guarantee that get_futex_key() will still imply smp_mb(); (B).
676                  */
677                 if (WARN_ON_ONCE(!atomic_inc_not_zero(&inode->i_count))) {
678                         rcu_read_unlock();
679                         put_page(page);
680 
681                         goto again;
682                 }
683 
684                 /* Should be impossible but lets be paranoid for now */
685                 if (WARN_ON_ONCE(inode->i_mapping != mapping)) {
686                         err = -EFAULT;
687                         rcu_read_unlock();
688                         iput(inode);
689 
690                         goto out;
691                 }
692 
693                 key->both.offset |= FUT_OFF_INODE; /* inode-based key */
694                 key->shared.inode = inode;
695                 key->shared.pgoff = basepage_index(tail);
696                 rcu_read_unlock();
697         }
698 
699 out:
700         put_page(page);
701         return err;
702 }
703 
704 static inline void put_futex_key(union futex_key *key)
705 {
706         drop_futex_key_refs(key);
707 }
708 
709 /**
710  * fault_in_user_writeable() - Fault in user address and verify RW access
711  * @uaddr:      pointer to faulting user space address
712  *
713  * Slow path to fixup the fault we just took in the atomic write
714  * access to @uaddr.
715  *
716  * We have no generic implementation of a non-destructive write to the
717  * user address. We know that we faulted in the atomic pagefault
718  * disabled section so we can as well avoid the #PF overhead by
719  * calling get_user_pages() right away.
720  */
721 static int fault_in_user_writeable(u32 __user *uaddr)
722 {
723         struct mm_struct *mm = current->mm;
724         int ret;
725 
726         down_read(&mm->mmap_sem);
727         ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
728                                FAULT_FLAG_WRITE, NULL);
729         up_read(&mm->mmap_sem);
730 
731         return ret < 0 ? ret : 0;
732 }
733 
734 /**
735  * futex_top_waiter() - Return the highest priority waiter on a futex
736  * @hb:         the hash bucket the futex_q's reside in
737  * @key:        the futex key (to distinguish it from other futex futex_q's)
738  *
739  * Must be called with the hb lock held.
740  */
741 static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
742                                         union futex_key *key)
743 {
744         struct futex_q *this;
745 
746         plist_for_each_entry(this, &hb->chain, list) {
747                 if (match_futex(&this->key, key))
748                         return this;
749         }
750         return NULL;
751 }
752 
753 static int cmpxchg_futex_value_locked(u32 *curval, u32 __user *uaddr,
754                                       u32 uval, u32 newval)
755 {
756         int ret;
757 
758         pagefault_disable();
759         ret = futex_atomic_cmpxchg_inatomic(curval, uaddr, uval, newval);
760         pagefault_enable();
761 
762         return ret;
763 }
764 
765 static int get_futex_value_locked(u32 *dest, u32 __user *from)
766 {
767         int ret;
768 
769         pagefault_disable();
770         ret = __get_user(*dest, from);
771         pagefault_enable();
772 
773         return ret ? -EFAULT : 0;
774 }
775 
776 
777 /*
778  * PI code:
779  */
780 static int refill_pi_state_cache(void)
781 {
782         struct futex_pi_state *pi_state;
783 
784         if (likely(current->pi_state_cache))
785                 return 0;
786 
787         pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
788 
789         if (!pi_state)
790                 return -ENOMEM;
791 
792         INIT_LIST_HEAD(&pi_state->list);
793         /* pi_mutex gets initialized later */
794         pi_state->owner = NULL;
795         atomic_set(&pi_state->refcount, 1);
796         pi_state->key = FUTEX_KEY_INIT;
797 
798         current->pi_state_cache = pi_state;
799 
800         return 0;
801 }
802 
803 static struct futex_pi_state * alloc_pi_state(void)
804 {
805         struct futex_pi_state *pi_state = current->pi_state_cache;
806 
807         WARN_ON(!pi_state);
808         current->pi_state_cache = NULL;
809 
810         return pi_state;
811 }
812 
813 /*
814  * Drops a reference to the pi_state object and frees or caches it
815  * when the last reference is gone.
816  *
817  * Must be called with the hb lock held.
818  */
819 static void put_pi_state(struct futex_pi_state *pi_state)
820 {
821         if (!pi_state)
822                 return;
823 
824         if (!atomic_dec_and_test(&pi_state->refcount))
825                 return;
826 
827         /*
828          * If pi_state->owner is NULL, the owner is most probably dying
829          * and has cleaned up the pi_state already
830          */
831         if (pi_state->owner) {
832                 raw_spin_lock_irq(&pi_state->owner->pi_lock);
833                 list_del_init(&pi_state->list);
834                 raw_spin_unlock_irq(&pi_state->owner->pi_lock);
835 
836                 rt_mutex_proxy_unlock(&pi_state->pi_mutex, pi_state->owner);
837         }
838 
839         if (current->pi_state_cache)
840                 kfree(pi_state);
841         else {
842                 /*
843                  * pi_state->list is already empty.
844                  * clear pi_state->owner.
845                  * refcount is at 0 - put it back to 1.
846                  */
847                 pi_state->owner = NULL;
848                 atomic_set(&pi_state->refcount, 1);
849                 current->pi_state_cache = pi_state;
850         }
851 }
852 
853 /*
854  * Look up the task based on what TID userspace gave us.
855  * We dont trust it.
856  */
857 static struct task_struct * futex_find_get_task(pid_t pid)
858 {
859         struct task_struct *p;
860 
861         rcu_read_lock();
862         p = find_task_by_vpid(pid);
863         if (p)
864                 get_task_struct(p);
865 
866         rcu_read_unlock();
867 
868         return p;
869 }
870 
871 /*
872  * This task is holding PI mutexes at exit time => bad.
873  * Kernel cleans up PI-state, but userspace is likely hosed.
874  * (Robust-futex cleanup is separate and might save the day for userspace.)
875  */
876 void exit_pi_state_list(struct task_struct *curr)
877 {
878         struct list_head *next, *head = &curr->pi_state_list;
879         struct futex_pi_state *pi_state;
880         struct futex_hash_bucket *hb;
881         union futex_key key = FUTEX_KEY_INIT;
882 
883         if (!futex_cmpxchg_enabled)
884                 return;
885         /*
886          * We are a ZOMBIE and nobody can enqueue itself on
887          * pi_state_list anymore, but we have to be careful
888          * versus waiters unqueueing themselves:
889          */
890         raw_spin_lock_irq(&curr->pi_lock);
891         while (!list_empty(head)) {
892 
893                 next = head->next;
894                 pi_state = list_entry(next, struct futex_pi_state, list);
895                 key = pi_state->key;
896                 hb = hash_futex(&key);
897                 raw_spin_unlock_irq(&curr->pi_lock);
898 
899                 spin_lock(&hb->lock);
900 
901                 raw_spin_lock_irq(&curr->pi_lock);
902                 /*
903                  * We dropped the pi-lock, so re-check whether this
904                  * task still owns the PI-state:
905                  */
906                 if (head->next != next) {
907                         spin_unlock(&hb->lock);
908                         continue;
909                 }
910 
911                 WARN_ON(pi_state->owner != curr);
912                 WARN_ON(list_empty(&pi_state->list));
913                 list_del_init(&pi_state->list);
914                 pi_state->owner = NULL;
915                 raw_spin_unlock_irq(&curr->pi_lock);
916 
917                 rt_mutex_unlock(&pi_state->pi_mutex);
918 
919                 spin_unlock(&hb->lock);
920 
921                 raw_spin_lock_irq(&curr->pi_lock);
922         }
923         raw_spin_unlock_irq(&curr->pi_lock);
924 }
925 
926 /*
927  * We need to check the following states:
928  *
929  *      Waiter | pi_state | pi->owner | uTID      | uODIED | ?
930  *
931  * [1]  NULL   | ---      | ---       | 0         | 0/1    | Valid
932  * [2]  NULL   | ---      | ---       | >0        | 0/1    | Valid
933  *
934  * [3]  Found  | NULL     | --        | Any       | 0/1    | Invalid
935  *
936  * [4]  Found  | Found    | NULL      | 0         | 1      | Valid
937  * [5]  Found  | Found    | NULL      | >0        | 1      | Invalid
938  *
939  * [6]  Found  | Found    | task      | 0         | 1      | Valid
940  *
941  * [7]  Found  | Found    | NULL      | Any       | 0      | Invalid
942  *
943  * [8]  Found  | Found    | task      | ==taskTID | 0/1    | Valid
944  * [9]  Found  | Found    | task      | 0         | 0      | Invalid
945  * [10] Found  | Found    | task      | !=taskTID | 0/1    | Invalid
946  *
947  * [1]  Indicates that the kernel can acquire the futex atomically. We
948  *      came came here due to a stale FUTEX_WAITERS/FUTEX_OWNER_DIED bit.
949  *
950  * [2]  Valid, if TID does not belong to a kernel thread. If no matching
951  *      thread is found then it indicates that the owner TID has died.
952  *
953  * [3]  Invalid. The waiter is queued on a non PI futex
954  *
955  * [4]  Valid state after exit_robust_list(), which sets the user space
956  *      value to FUTEX_WAITERS | FUTEX_OWNER_DIED.
957  *
958  * [5]  The user space value got manipulated between exit_robust_list()
959  *      and exit_pi_state_list()
960  *
961  * [6]  Valid state after exit_pi_state_list() which sets the new owner in
962  *      the pi_state but cannot access the user space value.
963  *
964  * [7]  pi_state->owner can only be NULL when the OWNER_DIED bit is set.
965  *
966  * [8]  Owner and user space value match
967  *
968  * [9]  There is no transient state which sets the user space TID to 0
969  *      except exit_robust_list(), but this is indicated by the
970  *      FUTEX_OWNER_DIED bit. See [4]
971  *
972  * [10] There is no transient state which leaves owner and user space
973  *      TID out of sync.
974  */
975 
976 /*
977  * Validate that the existing waiter has a pi_state and sanity check
978  * the pi_state against the user space value. If correct, attach to
979  * it.
980  */
981 static int attach_to_pi_state(u32 uval, struct futex_pi_state *pi_state,
982                               struct futex_pi_state **ps)
983 {
984         pid_t pid = uval & FUTEX_TID_MASK;
985 
986         /*
987          * Userspace might have messed up non-PI and PI futexes [3]
988          */
989         if (unlikely(!pi_state))
990                 return -EINVAL;
991 
992         WARN_ON(!atomic_read(&pi_state->refcount));
993 
994         /*
995          * Handle the owner died case:
996          */
997         if (uval & FUTEX_OWNER_DIED) {
998                 /*
999                  * 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         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         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         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         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->tv64;
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.tv64 = 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 __initcall(futex_init);
3327 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us