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  *   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  *                              `------->  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 #define FLAGS_SHARED            0x01
183 #define FLAGS_CLOCKRT           0x02
184 #define FLAGS_HAS_TIMEOUT       0x04
185 
186 /*
187  * Priority Inheritance state:
188  */
189 struct futex_pi_state {
190         /*
191          * list of 'owned' pi_state instances - these have to be
192          * cleaned up in do_exit() if the task exits prematurely:
193          */
194         struct list_head list;
195 
196         /*
197          * The PI object:
198          */
199         struct rt_mutex pi_mutex;
200 
201         struct task_struct *owner;
202         atomic_t refcount;
203 
204         union futex_key key;
205 };
206 
207 /**
208  * struct futex_q - The hashed futex queue entry, one per waiting task
209  * @list:               priority-sorted list of tasks waiting on this futex
210  * @task:               the task waiting on the futex
211  * @lock_ptr:           the hash bucket lock
212  * @key:                the key the futex is hashed on
213  * @pi_state:           optional priority inheritance state
214  * @rt_waiter:          rt_waiter storage for use with requeue_pi
215  * @requeue_pi_key:     the requeue_pi target futex key
216  * @bitset:             bitset for the optional bitmasked wakeup
217  *
218  * We use this hashed waitqueue, instead of a normal wait_queue_t, so
219  * we can wake only the relevant ones (hashed queues may be shared).
220  *
221  * A futex_q has a woken state, just like tasks have TASK_RUNNING.
222  * It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
223  * The order of wakeup is always to make the first condition true, then
224  * the second.
225  *
226  * PI futexes are typically woken before they are removed from the hash list via
227  * the rt_mutex code. See unqueue_me_pi().
228  */
229 struct futex_q {
230         struct plist_node list;
231 
232         struct task_struct *task;
233         spinlock_t *lock_ptr;
234         union futex_key key;
235         struct futex_pi_state *pi_state;
236         struct rt_mutex_waiter *rt_waiter;
237         union futex_key *requeue_pi_key;
238         u32 bitset;
239 };
240 
241 static const struct futex_q futex_q_init = {
242         /* list gets initialized in queue_me()*/
243         .key = FUTEX_KEY_INIT,
244         .bitset = FUTEX_BITSET_MATCH_ANY
245 };
246 
247 /*
248  * Hash buckets are shared by all the futex_keys that hash to the same
249  * location.  Each key may have multiple futex_q structures, one for each task
250  * waiting on a futex.
251  */
252 struct futex_hash_bucket {
253         atomic_t waiters;
254         spinlock_t lock;
255         struct plist_head chain;
256 } ____cacheline_aligned_in_smp;
257 
258 /*
259  * The base of the bucket array and its size are always used together
260  * (after initialization only in hash_futex()), so ensure that they
261  * reside in the same cacheline.
262  */
263 static struct {
264         struct futex_hash_bucket *queues;
265         unsigned long            hashsize;
266 } __futex_data __read_mostly __aligned(2*sizeof(long));
267 #define futex_queues   (__futex_data.queues)
268 #define futex_hashsize (__futex_data.hashsize)
269 
270 
271 /*
272  * Fault injections for futexes.
273  */
274 #ifdef CONFIG_FAIL_FUTEX
275 
276 static struct {
277         struct fault_attr attr;
278 
279         bool ignore_private;
280 } fail_futex = {
281         .attr = FAULT_ATTR_INITIALIZER,
282         .ignore_private = false,
283 };
284 
285 static int __init setup_fail_futex(char *str)
286 {
287         return setup_fault_attr(&fail_futex.attr, str);
288 }
289 __setup("fail_futex=", setup_fail_futex);
290 
291 static bool should_fail_futex(bool fshared)
292 {
293         if (fail_futex.ignore_private && !fshared)
294                 return false;
295 
296         return should_fail(&fail_futex.attr, 1);
297 }
298 
299 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
300 
301 static int __init fail_futex_debugfs(void)
302 {
303         umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
304         struct dentry *dir;
305 
306         dir = fault_create_debugfs_attr("fail_futex", NULL,
307                                         &fail_futex.attr);
308         if (IS_ERR(dir))
309                 return PTR_ERR(dir);
310 
311         if (!debugfs_create_bool("ignore-private", mode, dir,
312                                  &fail_futex.ignore_private)) {
313                 debugfs_remove_recursive(dir);
314                 return -ENOMEM;
315         }
316 
317         return 0;
318 }
319 
320 late_initcall(fail_futex_debugfs);
321 
322 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
323 
324 #else
325 static inline bool should_fail_futex(bool fshared)
326 {
327         return false;
328 }
329 #endif /* CONFIG_FAIL_FUTEX */
330 
331 static inline void futex_get_mm(union futex_key *key)
332 {
333         atomic_inc(&key->private.mm->mm_count);
334         /*
335          * Ensure futex_get_mm() implies a full barrier such that
336          * get_futex_key() implies a full barrier. This is relied upon
337          * as full barrier (B), see the ordering comment above.
338          */
339         smp_mb__after_atomic();
340 }
341 
342 /*
343  * Reflects a new waiter being added to the waitqueue.
344  */
345 static inline void hb_waiters_inc(struct futex_hash_bucket *hb)
346 {
347 #ifdef CONFIG_SMP
348         atomic_inc(&hb->waiters);
349         /*
350          * Full barrier (A), see the ordering comment above.
351          */
352         smp_mb__after_atomic();
353 #endif
354 }
355 
356 /*
357  * Reflects a waiter being removed from the waitqueue by wakeup
358  * paths.
359  */
360 static inline void hb_waiters_dec(struct futex_hash_bucket *hb)
361 {
362 #ifdef CONFIG_SMP
363         atomic_dec(&hb->waiters);
364 #endif
365 }
366 
367 static inline int hb_waiters_pending(struct futex_hash_bucket *hb)
368 {
369 #ifdef CONFIG_SMP
370         return atomic_read(&hb->waiters);
371 #else
372         return 1;
373 #endif
374 }
375 
376 /*
377  * We hash on the keys returned from get_futex_key (see below).
378  */
379 static struct futex_hash_bucket *hash_futex(union futex_key *key)
380 {
381         u32 hash = jhash2((u32*)&key->both.word,
382                           (sizeof(key->both.word)+sizeof(key->both.ptr))/4,
383                           key->both.offset);
384         return &futex_queues[hash & (futex_hashsize - 1)];
385 }
386 
387 /*
388  * Return 1 if two futex_keys are equal, 0 otherwise.
389  */
390 static inline int match_futex(union futex_key *key1, union futex_key *key2)
391 {
392         return (key1 && key2
393                 && key1->both.word == key2->both.word
394                 && key1->both.ptr == key2->both.ptr
395                 && key1->both.offset == key2->both.offset);
396 }
397 
398 /*
399  * Take a reference to the resource addressed by a key.
400  * Can be called while holding spinlocks.
401  *
402  */
403 static void get_futex_key_refs(union futex_key *key)
404 {
405         if (!key->both.ptr)
406                 return;
407 
408         switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
409         case FUT_OFF_INODE:
410                 ihold(key->shared.inode); /* implies MB (B) */
411                 break;
412         case FUT_OFF_MMSHARED:
413                 futex_get_mm(key); /* implies MB (B) */
414                 break;
415         default:
416                 /*
417                  * Private futexes do not hold reference on an inode or
418                  * mm, therefore the only purpose of calling get_futex_key_refs
419                  * is because we need the barrier for the lockless waiter check.
420                  */
421                 smp_mb(); /* explicit MB (B) */
422         }
423 }
424 
425 /*
426  * Drop a reference to the resource addressed by a key.
427  * The hash bucket spinlock must not be held. This is
428  * a no-op for private futexes, see comment in the get
429  * counterpart.
430  */
431 static void drop_futex_key_refs(union futex_key *key)
432 {
433         if (!key->both.ptr) {
434                 /* If we're here then we tried to put a key we failed to get */
435                 WARN_ON_ONCE(1);
436                 return;
437         }
438 
439         switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
440         case FUT_OFF_INODE:
441                 iput(key->shared.inode);
442                 break;
443         case FUT_OFF_MMSHARED:
444                 mmdrop(key->private.mm);
445                 break;
446         }
447 }
448 
449 /**
450  * get_futex_key() - Get parameters which are the keys for a futex
451  * @uaddr:      virtual address of the futex
452  * @fshared:    0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
453  * @key:        address where result is stored.
454  * @rw:         mapping needs to be read/write (values: VERIFY_READ,
455  *              VERIFY_WRITE)
456  *
457  * Return: a negative error code or 0
458  *
459  * The key words are stored in *key on success.
460  *
461  * For shared mappings, it's (page->index, file_inode(vma->vm_file),
462  * offset_within_page).  For private mappings, it's (uaddr, current->mm).
463  * We can usually work out the index without swapping in the page.
464  *
465  * lock_page() might sleep, the caller should not hold a spinlock.
466  */
467 static int
468 get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
469 {
470         unsigned long address = (unsigned long)uaddr;
471         struct mm_struct *mm = current->mm;
472         struct page *page, *page_head;
473         int err, ro = 0;
474 
475         /*
476          * The futex address must be "naturally" aligned.
477          */
478         key->both.offset = address % PAGE_SIZE;
479         if (unlikely((address % sizeof(u32)) != 0))
480                 return -EINVAL;
481         address -= key->both.offset;
482 
483         if (unlikely(!access_ok(rw, uaddr, sizeof(u32))))
484                 return -EFAULT;
485 
486         if (unlikely(should_fail_futex(fshared)))
487                 return -EFAULT;
488 
489         /*
490          * PROCESS_PRIVATE futexes are fast.
491          * As the mm cannot disappear under us and the 'key' only needs
492          * virtual address, we dont even have to find the underlying vma.
493          * Note : We do have to check 'uaddr' is a valid user address,
494          *        but access_ok() should be faster than find_vma()
495          */
496         if (!fshared) {
497                 key->private.mm = mm;
498                 key->private.address = address;
499                 get_futex_key_refs(key);  /* implies MB (B) */
500                 return 0;
501         }
502 
503 again:
504         /* Ignore any VERIFY_READ mapping (futex common case) */
505         if (unlikely(should_fail_futex(fshared)))
506                 return -EFAULT;
507 
508         err = get_user_pages_fast(address, 1, 1, &page);
509         /*
510          * If write access is not required (eg. FUTEX_WAIT), try
511          * and get read-only access.
512          */
513         if (err == -EFAULT && rw == VERIFY_READ) {
514                 err = get_user_pages_fast(address, 1, 0, &page);
515                 ro = 1;
516         }
517         if (err < 0)
518                 return err;
519         else
520                 err = 0;
521 
522 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
523         page_head = page;
524         if (unlikely(PageTail(page))) {
525                 put_page(page);
526                 /* serialize against __split_huge_page_splitting() */
527                 local_irq_disable();
528                 if (likely(__get_user_pages_fast(address, 1, !ro, &page) == 1)) {
529                         page_head = compound_head(page);
530                         /*
531                          * page_head is valid pointer but we must pin
532                          * it before taking the PG_lock and/or
533                          * PG_compound_lock. The moment we re-enable
534                          * irqs __split_huge_page_splitting() can
535                          * return and the head page can be freed from
536                          * under us. We can't take the PG_lock and/or
537                          * PG_compound_lock on a page that could be
538                          * freed from under us.
539                          */
540                         if (page != page_head) {
541                                 get_page(page_head);
542                                 put_page(page);
543                         }
544                         local_irq_enable();
545                 } else {
546                         local_irq_enable();
547                         goto again;
548                 }
549         }
550 #else
551         page_head = compound_head(page);
552         if (page != page_head) {
553                 get_page(page_head);
554                 put_page(page);
555         }
556 #endif
557 
558         lock_page(page_head);
559 
560         /*
561          * If page_head->mapping is NULL, then it cannot be a PageAnon
562          * page; but it might be the ZERO_PAGE or in the gate area or
563          * in a special mapping (all cases which we are happy to fail);
564          * or it may have been a good file page when get_user_pages_fast
565          * found it, but truncated or holepunched or subjected to
566          * invalidate_complete_page2 before we got the page lock (also
567          * cases which we are happy to fail).  And we hold a reference,
568          * so refcount care in invalidate_complete_page's remove_mapping
569          * prevents drop_caches from setting mapping to NULL beneath us.
570          *
571          * The case we do have to guard against is when memory pressure made
572          * shmem_writepage move it from filecache to swapcache beneath us:
573          * an unlikely race, but we do need to retry for page_head->mapping.
574          */
575         if (!page_head->mapping) {
576                 int shmem_swizzled = PageSwapCache(page_head);
577                 unlock_page(page_head);
578                 put_page(page_head);
579                 if (shmem_swizzled)
580                         goto again;
581                 return -EFAULT;
582         }
583 
584         /*
585          * Private mappings are handled in a simple way.
586          *
587          * NOTE: When userspace waits on a MAP_SHARED mapping, even if
588          * it's a read-only handle, it's expected that futexes attach to
589          * the object not the particular process.
590          */
591         if (PageAnon(page_head)) {
592                 /*
593                  * A RO anonymous page will never change and thus doesn't make
594                  * sense for futex operations.
595                  */
596                 if (unlikely(should_fail_futex(fshared)) || ro) {
597                         err = -EFAULT;
598                         goto out;
599                 }
600 
601                 key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
602                 key->private.mm = mm;
603                 key->private.address = address;
604         } else {
605                 key->both.offset |= FUT_OFF_INODE; /* inode-based key */
606                 key->shared.inode = page_head->mapping->host;
607                 key->shared.pgoff = basepage_index(page);
608         }
609 
610         get_futex_key_refs(key); /* implies MB (B) */
611 
612 out:
613         unlock_page(page_head);
614         put_page(page_head);
615         return err;
616 }
617 
618 static inline void put_futex_key(union futex_key *key)
619 {
620         drop_futex_key_refs(key);
621 }
622 
623 /**
624  * fault_in_user_writeable() - Fault in user address and verify RW access
625  * @uaddr:      pointer to faulting user space address
626  *
627  * Slow path to fixup the fault we just took in the atomic write
628  * access to @uaddr.
629  *
630  * We have no generic implementation of a non-destructive write to the
631  * user address. We know that we faulted in the atomic pagefault
632  * disabled section so we can as well avoid the #PF overhead by
633  * calling get_user_pages() right away.
634  */
635 static int fault_in_user_writeable(u32 __user *uaddr)
636 {
637         struct mm_struct *mm = current->mm;
638         int ret;
639 
640         down_read(&mm->mmap_sem);
641         ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
642                                FAULT_FLAG_WRITE);
643         up_read(&mm->mmap_sem);
644 
645         return ret < 0 ? ret : 0;
646 }
647 
648 /**
649  * futex_top_waiter() - Return the highest priority waiter on a futex
650  * @hb:         the hash bucket the futex_q's reside in
651  * @key:        the futex key (to distinguish it from other futex futex_q's)
652  *
653  * Must be called with the hb lock held.
654  */
655 static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
656                                         union futex_key *key)
657 {
658         struct futex_q *this;
659 
660         plist_for_each_entry(this, &hb->chain, list) {
661                 if (match_futex(&this->key, key))
662                         return this;
663         }
664         return NULL;
665 }
666 
667 static int cmpxchg_futex_value_locked(u32 *curval, u32 __user *uaddr,
668                                       u32 uval, u32 newval)
669 {
670         int ret;
671 
672         pagefault_disable();
673         ret = futex_atomic_cmpxchg_inatomic(curval, uaddr, uval, newval);
674         pagefault_enable();
675 
676         return ret;
677 }
678 
679 static int get_futex_value_locked(u32 *dest, u32 __user *from)
680 {
681         int ret;
682 
683         pagefault_disable();
684         ret = __copy_from_user_inatomic(dest, from, sizeof(u32));
685         pagefault_enable();
686 
687         return ret ? -EFAULT : 0;
688 }
689 
690 
691 /*
692  * PI code:
693  */
694 static int refill_pi_state_cache(void)
695 {
696         struct futex_pi_state *pi_state;
697 
698         if (likely(current->pi_state_cache))
699                 return 0;
700 
701         pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
702 
703         if (!pi_state)
704                 return -ENOMEM;
705 
706         INIT_LIST_HEAD(&pi_state->list);
707         /* pi_mutex gets initialized later */
708         pi_state->owner = NULL;
709         atomic_set(&pi_state->refcount, 1);
710         pi_state->key = FUTEX_KEY_INIT;
711 
712         current->pi_state_cache = pi_state;
713 
714         return 0;
715 }
716 
717 static struct futex_pi_state * alloc_pi_state(void)
718 {
719         struct futex_pi_state *pi_state = current->pi_state_cache;
720 
721         WARN_ON(!pi_state);
722         current->pi_state_cache = NULL;
723 
724         return pi_state;
725 }
726 
727 /*
728  * Must be called with the hb lock held.
729  */
730 static void free_pi_state(struct futex_pi_state *pi_state)
731 {
732         if (!pi_state)
733                 return;
734 
735         if (!atomic_dec_and_test(&pi_state->refcount))
736                 return;
737 
738         /*
739          * If pi_state->owner is NULL, the owner is most probably dying
740          * and has cleaned up the pi_state already
741          */
742         if (pi_state->owner) {
743                 raw_spin_lock_irq(&pi_state->owner->pi_lock);
744                 list_del_init(&pi_state->list);
745                 raw_spin_unlock_irq(&pi_state->owner->pi_lock);
746 
747                 rt_mutex_proxy_unlock(&pi_state->pi_mutex, pi_state->owner);
748         }
749 
750         if (current->pi_state_cache)
751                 kfree(pi_state);
752         else {
753                 /*
754                  * pi_state->list is already empty.
755                  * clear pi_state->owner.
756                  * refcount is at 0 - put it back to 1.
757                  */
758                 pi_state->owner = NULL;
759                 atomic_set(&pi_state->refcount, 1);
760                 current->pi_state_cache = pi_state;
761         }
762 }
763 
764 /*
765  * Look up the task based on what TID userspace gave us.
766  * We dont trust it.
767  */
768 static struct task_struct * futex_find_get_task(pid_t pid)
769 {
770         struct task_struct *p;
771 
772         rcu_read_lock();
773         p = find_task_by_vpid(pid);
774         if (p)
775                 get_task_struct(p);
776 
777         rcu_read_unlock();
778 
779         return p;
780 }
781 
782 /*
783  * This task is holding PI mutexes at exit time => bad.
784  * Kernel cleans up PI-state, but userspace is likely hosed.
785  * (Robust-futex cleanup is separate and might save the day for userspace.)
786  */
787 void exit_pi_state_list(struct task_struct *curr)
788 {
789         struct list_head *next, *head = &curr->pi_state_list;
790         struct futex_pi_state *pi_state;
791         struct futex_hash_bucket *hb;
792         union futex_key key = FUTEX_KEY_INIT;
793 
794         if (!futex_cmpxchg_enabled)
795                 return;
796         /*
797          * We are a ZOMBIE and nobody can enqueue itself on
798          * pi_state_list anymore, but we have to be careful
799          * versus waiters unqueueing themselves:
800          */
801         raw_spin_lock_irq(&curr->pi_lock);
802         while (!list_empty(head)) {
803 
804                 next = head->next;
805                 pi_state = list_entry(next, struct futex_pi_state, list);
806                 key = pi_state->key;
807                 hb = hash_futex(&key);
808                 raw_spin_unlock_irq(&curr->pi_lock);
809 
810                 spin_lock(&hb->lock);
811 
812                 raw_spin_lock_irq(&curr->pi_lock);
813                 /*
814                  * We dropped the pi-lock, so re-check whether this
815                  * task still owns the PI-state:
816                  */
817                 if (head->next != next) {
818                         spin_unlock(&hb->lock);
819                         continue;
820                 }
821 
822                 WARN_ON(pi_state->owner != curr);
823                 WARN_ON(list_empty(&pi_state->list));
824                 list_del_init(&pi_state->list);
825                 pi_state->owner = NULL;
826                 raw_spin_unlock_irq(&curr->pi_lock);
827 
828                 rt_mutex_unlock(&pi_state->pi_mutex);
829 
830                 spin_unlock(&hb->lock);
831 
832                 raw_spin_lock_irq(&curr->pi_lock);
833         }
834         raw_spin_unlock_irq(&curr->pi_lock);
835 }
836 
837 /*
838  * We need to check the following states:
839  *
840  *      Waiter | pi_state | pi->owner | uTID      | uODIED | ?
841  *
842  * [1]  NULL   | ---      | ---       | 0         | 0/1    | Valid
843  * [2]  NULL   | ---      | ---       | >0        | 0/1    | Valid
844  *
845  * [3]  Found  | NULL     | --        | Any       | 0/1    | Invalid
846  *
847  * [4]  Found  | Found    | NULL      | 0         | 1      | Valid
848  * [5]  Found  | Found    | NULL      | >0        | 1      | Invalid
849  *
850  * [6]  Found  | Found    | task      | 0         | 1      | Valid
851  *
852  * [7]  Found  | Found    | NULL      | Any       | 0      | Invalid
853  *
854  * [8]  Found  | Found    | task      | ==taskTID | 0/1    | Valid
855  * [9]  Found  | Found    | task      | 0         | 0      | Invalid
856  * [10] Found  | Found    | task      | !=taskTID | 0/1    | Invalid
857  *
858  * [1]  Indicates that the kernel can acquire the futex atomically. We
859  *      came came here due to a stale FUTEX_WAITERS/FUTEX_OWNER_DIED bit.
860  *
861  * [2]  Valid, if TID does not belong to a kernel thread. If no matching
862  *      thread is found then it indicates that the owner TID has died.
863  *
864  * [3]  Invalid. The waiter is queued on a non PI futex
865  *
866  * [4]  Valid state after exit_robust_list(), which sets the user space
867  *      value to FUTEX_WAITERS | FUTEX_OWNER_DIED.
868  *
869  * [5]  The user space value got manipulated between exit_robust_list()
870  *      and exit_pi_state_list()
871  *
872  * [6]  Valid state after exit_pi_state_list() which sets the new owner in
873  *      the pi_state but cannot access the user space value.
874  *
875  * [7]  pi_state->owner can only be NULL when the OWNER_DIED bit is set.
876  *
877  * [8]  Owner and user space value match
878  *
879  * [9]  There is no transient state which sets the user space TID to 0
880  *      except exit_robust_list(), but this is indicated by the
881  *      FUTEX_OWNER_DIED bit. See [4]
882  *
883  * [10] There is no transient state which leaves owner and user space
884  *      TID out of sync.
885  */
886 
887 /*
888  * Validate that the existing waiter has a pi_state and sanity check
889  * the pi_state against the user space value. If correct, attach to
890  * it.
891  */
892 static int attach_to_pi_state(u32 uval, struct futex_pi_state *pi_state,
893                               struct futex_pi_state **ps)
894 {
895         pid_t pid = uval & FUTEX_TID_MASK;
896 
897         /*
898          * Userspace might have messed up non-PI and PI futexes [3]
899          */
900         if (unlikely(!pi_state))
901                 return -EINVAL;
902 
903         WARN_ON(!atomic_read(&pi_state->refcount));
904 
905         /*
906          * Handle the owner died case:
907          */
908         if (uval & FUTEX_OWNER_DIED) {
909                 /*
910                  * exit_pi_state_list sets owner to NULL and wakes the
911                  * topmost waiter. The task which acquires the
912                  * pi_state->rt_mutex will fixup owner.
913                  */
914                 if (!pi_state->owner) {
915                         /*
916                          * No pi state owner, but the user space TID
917                          * is not 0. Inconsistent state. [5]
918                          */
919                         if (pid)
920                                 return -EINVAL;
921                         /*
922                          * Take a ref on the state and return success. [4]
923                          */
924                         goto out_state;
925                 }
926 
927                 /*
928                  * If TID is 0, then either the dying owner has not
929                  * yet executed exit_pi_state_list() or some waiter
930                  * acquired the rtmutex in the pi state, but did not
931                  * yet fixup the TID in user space.
932                  *
933                  * Take a ref on the state and return success. [6]
934                  */
935                 if (!pid)
936                         goto out_state;
937         } else {
938                 /*
939                  * If the owner died bit is not set, then the pi_state
940                  * must have an owner. [7]
941                  */
942                 if (!pi_state->owner)
943                         return -EINVAL;
944         }
945 
946         /*
947          * Bail out if user space manipulated the futex value. If pi
948          * state exists then the owner TID must be the same as the
949          * user space TID. [9/10]
950          */
951         if (pid != task_pid_vnr(pi_state->owner))
952                 return -EINVAL;
953 out_state:
954         atomic_inc(&pi_state->refcount);
955         *ps = pi_state;
956         return 0;
957 }
958 
959 /*
960  * Lookup the task for the TID provided from user space and attach to
961  * it after doing proper sanity checks.
962  */
963 static int attach_to_pi_owner(u32 uval, union futex_key *key,
964                               struct futex_pi_state **ps)
965 {
966         pid_t pid = uval & FUTEX_TID_MASK;
967         struct futex_pi_state *pi_state;
968         struct task_struct *p;
969 
970         /*
971          * We are the first waiter - try to look up the real owner and attach
972          * the new pi_state to it, but bail out when TID = 0 [1]
973          */
974         if (!pid)
975                 return -ESRCH;
976         p = futex_find_get_task(pid);
977         if (!p)
978                 return -ESRCH;
979 
980         if (unlikely(p->flags & PF_KTHREAD)) {
981                 put_task_struct(p);
982                 return -EPERM;
983         }
984 
985         /*
986          * We need to look at the task state flags to figure out,
987          * whether the task is exiting. To protect against the do_exit
988          * change of the task flags, we do this protected by
989          * p->pi_lock:
990          */
991         raw_spin_lock_irq(&p->pi_lock);
992         if (unlikely(p->flags & PF_EXITING)) {
993                 /*
994                  * The task is on the way out. When PF_EXITPIDONE is
995                  * set, we know that the task has finished the
996                  * cleanup:
997                  */
998                 int ret = (p->flags & PF_EXITPIDONE) ? -ESRCH : -EAGAIN;
999 
1000                 raw_spin_unlock_irq(&p->pi_lock);
1001                 put_task_struct(p);
1002                 return ret;
1003         }
1004 
1005         /*
1006          * No existing pi state. First waiter. [2]
1007          */
1008         pi_state = alloc_pi_state();
1009 
1010         /*
1011          * Initialize the pi_mutex in locked state and make @p
1012          * the owner of it:
1013          */
1014         rt_mutex_init_proxy_locked(&pi_state->pi_mutex, p);
1015 
1016         /* Store the key for possible exit cleanups: */
1017         pi_state->key = *key;
1018 
1019         WARN_ON(!list_empty(&pi_state->list));
1020         list_add(&pi_state->list, &p->pi_state_list);
1021         pi_state->owner = p;
1022         raw_spin_unlock_irq(&p->pi_lock);
1023 
1024         put_task_struct(p);
1025 
1026         *ps = pi_state;
1027 
1028         return 0;
1029 }
1030 
1031 static int lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
1032                            union futex_key *key, struct futex_pi_state **ps)
1033 {
1034         struct futex_q *match = futex_top_waiter(hb, key);
1035 
1036         /*
1037          * If there is a waiter on that futex, validate it and
1038          * attach to the pi_state when the validation succeeds.
1039          */
1040         if (match)
1041                 return attach_to_pi_state(uval, match->pi_state, ps);
1042 
1043         /*
1044          * We are the first waiter - try to look up the owner based on
1045          * @uval and attach to it.
1046          */
1047         return attach_to_pi_owner(uval, key, ps);
1048 }
1049 
1050 static int lock_pi_update_atomic(u32 __user *uaddr, u32 uval, u32 newval)
1051 {
1052         u32 uninitialized_var(curval);
1053 
1054         if (unlikely(should_fail_futex(true)))
1055                 return -EFAULT;
1056 
1057         if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)))
1058                 return -EFAULT;
1059 
1060         /*If user space value changed, let the caller retry */
1061         return curval != uval ? -EAGAIN : 0;
1062 }
1063 
1064 /**
1065  * futex_lock_pi_atomic() - Atomic work required to acquire a pi aware futex
1066  * @uaddr:              the pi futex user address
1067  * @hb:                 the pi futex hash bucket
1068  * @key:                the futex key associated with uaddr and hb
1069  * @ps:                 the pi_state pointer where we store the result of the
1070  *                      lookup
1071  * @task:               the task to perform the atomic lock work for.  This will
1072  *                      be "current" except in the case of requeue pi.
1073  * @set_waiters:        force setting the FUTEX_WAITERS bit (1) or not (0)
1074  *
1075  * Return:
1076  *  0 - ready to wait;
1077  *  1 - acquired the lock;
1078  * <0 - error
1079  *
1080  * The hb->lock and futex_key refs shall be held by the caller.
1081  */
1082 static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
1083                                 union futex_key *key,
1084                                 struct futex_pi_state **ps,
1085                                 struct task_struct *task, int set_waiters)
1086 {
1087         u32 uval, newval, vpid = task_pid_vnr(task);
1088         struct futex_q *match;
1089         int ret;
1090 
1091         /*
1092          * Read the user space value first so we can validate a few
1093          * things before proceeding further.
1094          */
1095         if (get_futex_value_locked(&uval, uaddr))
1096                 return -EFAULT;
1097 
1098         if (unlikely(should_fail_futex(true)))
1099                 return -EFAULT;
1100 
1101         /*
1102          * Detect deadlocks.
1103          */
1104         if ((unlikely((uval & FUTEX_TID_MASK) == vpid)))
1105                 return -EDEADLK;
1106 
1107         if ((unlikely(should_fail_futex(true))))
1108                 return -EDEADLK;
1109 
1110         /*
1111          * Lookup existing state first. If it exists, try to attach to
1112          * its pi_state.
1113          */
1114         match = futex_top_waiter(hb, key);
1115         if (match)
1116                 return attach_to_pi_state(uval, match->pi_state, ps);
1117 
1118         /*
1119          * No waiter and user TID is 0. We are here because the
1120          * waiters or the owner died bit is set or called from
1121          * requeue_cmp_pi or for whatever reason something took the
1122          * syscall.
1123          */
1124         if (!(uval & FUTEX_TID_MASK)) {
1125                 /*
1126                  * We take over the futex. No other waiters and the user space
1127                  * TID is 0. We preserve the owner died bit.
1128                  */
1129                 newval = uval & FUTEX_OWNER_DIED;
1130                 newval |= vpid;
1131 
1132                 /* The futex requeue_pi code can enforce the waiters bit */
1133                 if (set_waiters)
1134                         newval |= FUTEX_WAITERS;
1135 
1136                 ret = lock_pi_update_atomic(uaddr, uval, newval);
1137                 /* If the take over worked, return 1 */
1138                 return ret < 0 ? ret : 1;
1139         }
1140 
1141         /*
1142          * First waiter. Set the waiters bit before attaching ourself to
1143          * the owner. If owner tries to unlock, it will be forced into
1144          * the kernel and blocked on hb->lock.
1145          */
1146         newval = uval | FUTEX_WAITERS;
1147         ret = lock_pi_update_atomic(uaddr, uval, newval);
1148         if (ret)
1149                 return ret;
1150         /*
1151          * If the update of the user space value succeeded, we try to
1152          * attach to the owner. If that fails, no harm done, we only
1153          * set the FUTEX_WAITERS bit in the user space variable.
1154          */
1155         return attach_to_pi_owner(uval, key, ps);
1156 }
1157 
1158 /**
1159  * __unqueue_futex() - Remove the futex_q from its futex_hash_bucket
1160  * @q:  The futex_q to unqueue
1161  *
1162  * The q->lock_ptr must not be NULL and must be held by the caller.
1163  */
1164 static void __unqueue_futex(struct futex_q *q)
1165 {
1166         struct futex_hash_bucket *hb;
1167 
1168         if (WARN_ON_SMP(!q->lock_ptr || !spin_is_locked(q->lock_ptr))
1169             || WARN_ON(plist_node_empty(&q->list)))
1170                 return;
1171 
1172         hb = container_of(q->lock_ptr, struct futex_hash_bucket, lock);
1173         plist_del(&q->list, &hb->chain);
1174         hb_waiters_dec(hb);
1175 }
1176 
1177 /*
1178  * The hash bucket lock must be held when this is called.
1179  * Afterwards, the futex_q must not be accessed. Callers
1180  * must ensure to later call wake_up_q() for the actual
1181  * wakeups to occur.
1182  */
1183 static void mark_wake_futex(struct wake_q_head *wake_q, struct futex_q *q)
1184 {
1185         struct task_struct *p = q->task;
1186 
1187         if (WARN(q->pi_state || q->rt_waiter, "refusing to wake PI futex\n"))
1188                 return;
1189 
1190         /*
1191          * Queue the task for later wakeup for after we've released
1192          * the hb->lock. wake_q_add() grabs reference to p.
1193          */
1194         wake_q_add(wake_q, p);
1195         __unqueue_futex(q);
1196         /*
1197          * The waiting task can free the futex_q as soon as
1198          * q->lock_ptr = NULL is written, without taking any locks. A
1199          * memory barrier is required here to prevent the following
1200          * store to lock_ptr from getting ahead of the plist_del.
1201          */
1202         smp_wmb();
1203         q->lock_ptr = NULL;
1204 }
1205 
1206 static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this,
1207                          struct futex_hash_bucket *hb)
1208 {
1209         struct task_struct *new_owner;
1210         struct futex_pi_state *pi_state = this->pi_state;
1211         u32 uninitialized_var(curval), newval;
1212         WAKE_Q(wake_q);
1213         bool deboost;
1214         int ret = 0;
1215 
1216         if (!pi_state)
1217                 return -EINVAL;
1218 
1219         /*
1220          * If current does not own the pi_state then the futex is
1221          * inconsistent and user space fiddled with the futex value.
1222          */
1223         if (pi_state->owner != current)
1224                 return -EINVAL;
1225 
1226         raw_spin_lock(&pi_state->pi_mutex.wait_lock);
1227         new_owner = rt_mutex_next_owner(&pi_state->pi_mutex);
1228 
1229         /*
1230          * It is possible that the next waiter (the one that brought
1231          * this owner to the kernel) timed out and is no longer
1232          * waiting on the lock.
1233          */
1234         if (!new_owner)
1235                 new_owner = this->task;
1236 
1237         /*
1238          * We pass it to the next owner. The WAITERS bit is always
1239          * kept enabled while there is PI state around. We cleanup the
1240          * owner died bit, because we are the owner.
1241          */
1242         newval = FUTEX_WAITERS | task_pid_vnr(new_owner);
1243 
1244         if (unlikely(should_fail_futex(true)))
1245                 ret = -EFAULT;
1246 
1247         if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
1248                 ret = -EFAULT;
1249         else if (curval != uval)
1250                 ret = -EINVAL;
1251         if (ret) {
1252                 raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
1253                 return ret;
1254         }
1255 
1256         raw_spin_lock_irq(&pi_state->owner->pi_lock);
1257         WARN_ON(list_empty(&pi_state->list));
1258         list_del_init(&pi_state->list);
1259         raw_spin_unlock_irq(&pi_state->owner->pi_lock);
1260 
1261         raw_spin_lock_irq(&new_owner->pi_lock);
1262         WARN_ON(!list_empty(&pi_state->list));
1263         list_add(&pi_state->list, &new_owner->pi_state_list);
1264         pi_state->owner = new_owner;
1265         raw_spin_unlock_irq(&new_owner->pi_lock);
1266 
1267         raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
1268 
1269         deboost = rt_mutex_futex_unlock(&pi_state->pi_mutex, &wake_q);
1270 
1271         /*
1272          * First unlock HB so the waiter does not spin on it once he got woken
1273          * up. Second wake up the waiter before the priority is adjusted. If we
1274          * deboost first (and lose our higher priority), then the task might get
1275          * scheduled away before the wake up can take place.
1276          */
1277         spin_unlock(&hb->lock);
1278         wake_up_q(&wake_q);
1279         if (deboost)
1280                 rt_mutex_adjust_prio(current);
1281 
1282         return 0;
1283 }
1284 
1285 /*
1286  * Express the locking dependencies for lockdep:
1287  */
1288 static inline void
1289 double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
1290 {
1291         if (hb1 <= hb2) {
1292                 spin_lock(&hb1->lock);
1293                 if (hb1 < hb2)
1294                         spin_lock_nested(&hb2->lock, SINGLE_DEPTH_NESTING);
1295         } else { /* hb1 > hb2 */
1296                 spin_lock(&hb2->lock);
1297                 spin_lock_nested(&hb1->lock, SINGLE_DEPTH_NESTING);
1298         }
1299 }
1300 
1301 static inline void
1302 double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
1303 {
1304         spin_unlock(&hb1->lock);
1305         if (hb1 != hb2)
1306                 spin_unlock(&hb2->lock);
1307 }
1308 
1309 /*
1310  * Wake up waiters matching bitset queued on this futex (uaddr).
1311  */
1312 static int
1313 futex_wake(u32 __user *uaddr, unsigned int flags, int nr_wake, u32 bitset)
1314 {
1315         struct futex_hash_bucket *hb;
1316         struct futex_q *this, *next;
1317         union futex_key key = FUTEX_KEY_INIT;
1318         int ret;
1319         WAKE_Q(wake_q);
1320 
1321         if (!bitset)
1322                 return -EINVAL;
1323 
1324         ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_READ);
1325         if (unlikely(ret != 0))
1326                 goto out;
1327 
1328         hb = hash_futex(&key);
1329 
1330         /* Make sure we really have tasks to wakeup */
1331         if (!hb_waiters_pending(hb))
1332                 goto out_put_key;
1333 
1334         spin_lock(&hb->lock);
1335 
1336         plist_for_each_entry_safe(this, next, &hb->chain, list) {
1337                 if (match_futex (&this->key, &key)) {
1338                         if (this->pi_state || this->rt_waiter) {
1339                                 ret = -EINVAL;
1340                                 break;
1341                         }
1342 
1343                         /* Check if one of the bits is set in both bitsets */
1344                         if (!(this->bitset & bitset))
1345                                 continue;
1346 
1347                         mark_wake_futex(&wake_q, this);
1348                         if (++ret >= nr_wake)
1349                                 break;
1350                 }
1351         }
1352 
1353         spin_unlock(&hb->lock);
1354         wake_up_q(&wake_q);
1355 out_put_key:
1356         put_futex_key(&key);
1357 out:
1358         return ret;
1359 }
1360 
1361 /*
1362  * Wake up all waiters hashed on the physical page that is mapped
1363  * to this virtual address:
1364  */
1365 static int
1366 futex_wake_op(u32 __user *uaddr1, unsigned int flags, u32 __user *uaddr2,
1367               int nr_wake, int nr_wake2, int op)
1368 {
1369         union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
1370         struct futex_hash_bucket *hb1, *hb2;
1371         struct futex_q *this, *next;
1372         int ret, op_ret;
1373         WAKE_Q(wake_q);
1374 
1375 retry:
1376         ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
1377         if (unlikely(ret != 0))
1378                 goto out;
1379         ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
1380         if (unlikely(ret != 0))
1381                 goto out_put_key1;
1382 
1383         hb1 = hash_futex(&key1);
1384         hb2 = hash_futex(&key2);
1385 
1386 retry_private:
1387         double_lock_hb(hb1, hb2);
1388         op_ret = futex_atomic_op_inuser(op, uaddr2);
1389         if (unlikely(op_ret < 0)) {
1390 
1391                 double_unlock_hb(hb1, hb2);
1392 
1393 #ifndef CONFIG_MMU
1394                 /*
1395                  * we don't get EFAULT from MMU faults if we don't have an MMU,
1396                  * but we might get them from range checking
1397                  */
1398                 ret = op_ret;
1399                 goto out_put_keys;
1400 #endif
1401 
1402                 if (unlikely(op_ret != -EFAULT)) {
1403                         ret = op_ret;
1404                         goto out_put_keys;
1405                 }
1406 
1407                 ret = fault_in_user_writeable(uaddr2);
1408                 if (ret)
1409                         goto out_put_keys;
1410 
1411                 if (!(flags & FLAGS_SHARED))
1412                         goto retry_private;
1413 
1414                 put_futex_key(&key2);
1415                 put_futex_key(&key1);
1416                 goto retry;
1417         }
1418 
1419         plist_for_each_entry_safe(this, next, &hb1->chain, list) {
1420                 if (match_futex (&this->key, &key1)) {
1421                         if (this->pi_state || this->rt_waiter) {
1422                                 ret = -EINVAL;
1423                                 goto out_unlock;
1424                         }
1425                         mark_wake_futex(&wake_q, this);
1426                         if (++ret >= nr_wake)
1427                                 break;
1428                 }
1429         }
1430 
1431         if (op_ret > 0) {
1432                 op_ret = 0;
1433                 plist_for_each_entry_safe(this, next, &hb2->chain, list) {
1434                         if (match_futex (&this->key, &key2)) {
1435                                 if (this->pi_state || this->rt_waiter) {
1436                                         ret = -EINVAL;
1437                                         goto out_unlock;
1438                                 }
1439                                 mark_wake_futex(&wake_q, this);
1440                                 if (++op_ret >= nr_wake2)
1441                                         break;
1442                         }
1443                 }
1444                 ret += op_ret;
1445         }
1446 
1447 out_unlock:
1448         double_unlock_hb(hb1, hb2);
1449         wake_up_q(&wake_q);
1450 out_put_keys:
1451         put_futex_key(&key2);
1452 out_put_key1:
1453         put_futex_key(&key1);
1454 out:
1455         return ret;
1456 }
1457 
1458 /**
1459  * requeue_futex() - Requeue a futex_q from one hb to another
1460  * @q:          the futex_q to requeue
1461  * @hb1:        the source hash_bucket
1462  * @hb2:        the target hash_bucket
1463  * @key2:       the new key for the requeued futex_q
1464  */
1465 static inline
1466 void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
1467                    struct futex_hash_bucket *hb2, union futex_key *key2)
1468 {
1469 
1470         /*
1471          * If key1 and key2 hash to the same bucket, no need to
1472          * requeue.
1473          */
1474         if (likely(&hb1->chain != &hb2->chain)) {
1475                 plist_del(&q->list, &hb1->chain);
1476                 hb_waiters_dec(hb1);
1477                 plist_add(&q->list, &hb2->chain);
1478                 hb_waiters_inc(hb2);
1479                 q->lock_ptr = &hb2->lock;
1480         }
1481         get_futex_key_refs(key2);
1482         q->key = *key2;
1483 }
1484 
1485 /**
1486  * requeue_pi_wake_futex() - Wake a task that acquired the lock during requeue
1487  * @q:          the futex_q
1488  * @key:        the key of the requeue target futex
1489  * @hb:         the hash_bucket of the requeue target futex
1490  *
1491  * During futex_requeue, with requeue_pi=1, it is possible to acquire the
1492  * target futex if it is uncontended or via a lock steal.  Set the futex_q key
1493  * to the requeue target futex so the waiter can detect the wakeup on the right
1494  * futex, but remove it from the hb and NULL the rt_waiter so it can detect
1495  * atomic lock acquisition.  Set the q->lock_ptr to the requeue target hb->lock
1496  * to protect access to the pi_state to fixup the owner later.  Must be called
1497  * with both q->lock_ptr and hb->lock held.
1498  */
1499 static inline
1500 void requeue_pi_wake_futex(struct futex_q *q, union futex_key *key,
1501                            struct futex_hash_bucket *hb)
1502 {
1503         get_futex_key_refs(key);
1504         q->key = *key;
1505 
1506         __unqueue_futex(q);
1507 
1508         WARN_ON(!q->rt_waiter);
1509         q->rt_waiter = NULL;
1510 
1511         q->lock_ptr = &hb->lock;
1512 
1513         wake_up_state(q->task, TASK_NORMAL);
1514 }
1515 
1516 /**
1517  * futex_proxy_trylock_atomic() - Attempt an atomic lock for the top waiter
1518  * @pifutex:            the user address of the to futex
1519  * @hb1:                the from futex hash bucket, must be locked by the caller
1520  * @hb2:                the to futex hash bucket, must be locked by the caller
1521  * @key1:               the from futex key
1522  * @key2:               the to futex key
1523  * @ps:                 address to store the pi_state pointer
1524  * @set_waiters:        force setting the FUTEX_WAITERS bit (1) or not (0)
1525  *
1526  * Try and get the lock on behalf of the top waiter if we can do it atomically.
1527  * Wake the top waiter if we succeed.  If the caller specified set_waiters,
1528  * then direct futex_lock_pi_atomic() to force setting the FUTEX_WAITERS bit.
1529  * hb1 and hb2 must be held by the caller.
1530  *
1531  * Return:
1532  *  0 - failed to acquire the lock atomically;
1533  * >0 - acquired the lock, return value is vpid of the top_waiter
1534  * <0 - error
1535  */
1536 static int futex_proxy_trylock_atomic(u32 __user *pifutex,
1537                                  struct futex_hash_bucket *hb1,
1538                                  struct futex_hash_bucket *hb2,
1539                                  union futex_key *key1, union futex_key *key2,
1540                                  struct futex_pi_state **ps, int set_waiters)
1541 {
1542         struct futex_q *top_waiter = NULL;
1543         u32 curval;
1544         int ret, vpid;
1545 
1546         if (get_futex_value_locked(&curval, pifutex))
1547                 return -EFAULT;
1548 
1549         if (unlikely(should_fail_futex(true)))
1550                 return -EFAULT;
1551 
1552         /*
1553          * Find the top_waiter and determine if there are additional waiters.
1554          * If the caller intends to requeue more than 1 waiter to pifutex,
1555          * force futex_lock_pi_atomic() to set the FUTEX_WAITERS bit now,
1556          * as we have means to handle the possible fault.  If not, don't set
1557          * the bit unecessarily as it will force the subsequent unlock to enter
1558          * the kernel.
1559          */
1560         top_waiter = futex_top_waiter(hb1, key1);
1561 
1562         /* There are no waiters, nothing for us to do. */
1563         if (!top_waiter)
1564                 return 0;
1565 
1566         /* Ensure we requeue to the expected futex. */
1567         if (!match_futex(top_waiter->requeue_pi_key, key2))
1568                 return -EINVAL;
1569 
1570         /*
1571          * Try to take the lock for top_waiter.  Set the FUTEX_WAITERS bit in
1572          * the contended case or if set_waiters is 1.  The pi_state is returned
1573          * in ps in contended cases.
1574          */
1575         vpid = task_pid_vnr(top_waiter->task);
1576         ret = futex_lock_pi_atomic(pifutex, hb2, key2, ps, top_waiter->task,
1577                                    set_waiters);
1578         if (ret == 1) {
1579                 requeue_pi_wake_futex(top_waiter, key2, hb2);
1580                 return vpid;
1581         }
1582         return ret;
1583 }
1584 
1585 /**
1586  * futex_requeue() - Requeue waiters from uaddr1 to uaddr2
1587  * @uaddr1:     source futex user address
1588  * @flags:      futex flags (FLAGS_SHARED, etc.)
1589  * @uaddr2:     target futex user address
1590  * @nr_wake:    number of waiters to wake (must be 1 for requeue_pi)
1591  * @nr_requeue: number of waiters to requeue (0-INT_MAX)
1592  * @cmpval:     @uaddr1 expected value (or %NULL)
1593  * @requeue_pi: if we are attempting to requeue from a non-pi futex to a
1594  *              pi futex (pi to pi requeue is not supported)
1595  *
1596  * Requeue waiters on uaddr1 to uaddr2. In the requeue_pi case, try to acquire
1597  * uaddr2 atomically on behalf of the top waiter.
1598  *
1599  * Return:
1600  * >=0 - on success, the number of tasks requeued or woken;
1601  *  <0 - on error
1602  */
1603 static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
1604                          u32 __user *uaddr2, int nr_wake, int nr_requeue,
1605                          u32 *cmpval, int requeue_pi)
1606 {
1607         union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
1608         int drop_count = 0, task_count = 0, ret;
1609         struct futex_pi_state *pi_state = NULL;
1610         struct futex_hash_bucket *hb1, *hb2;
1611         struct futex_q *this, *next;
1612         WAKE_Q(wake_q);
1613 
1614         if (requeue_pi) {
1615                 /*
1616                  * Requeue PI only works on two distinct uaddrs. This
1617                  * check is only valid for private futexes. See below.
1618                  */
1619                 if (uaddr1 == uaddr2)
1620                         return -EINVAL;
1621 
1622                 /*
1623                  * requeue_pi requires a pi_state, try to allocate it now
1624                  * without any locks in case it fails.
1625                  */
1626                 if (refill_pi_state_cache())
1627                         return -ENOMEM;
1628                 /*
1629                  * requeue_pi must wake as many tasks as it can, up to nr_wake
1630                  * + nr_requeue, since it acquires the rt_mutex prior to
1631                  * returning to userspace, so as to not leave the rt_mutex with
1632                  * waiters and no owner.  However, second and third wake-ups
1633                  * cannot be predicted as they involve race conditions with the
1634                  * first wake and a fault while looking up the pi_state.  Both
1635                  * pthread_cond_signal() and pthread_cond_broadcast() should
1636                  * use nr_wake=1.
1637                  */
1638                 if (nr_wake != 1)
1639                         return -EINVAL;
1640         }
1641 
1642 retry:
1643         ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
1644         if (unlikely(ret != 0))
1645                 goto out;
1646         ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2,
1647                             requeue_pi ? VERIFY_WRITE : VERIFY_READ);
1648         if (unlikely(ret != 0))
1649                 goto out_put_key1;
1650 
1651         /*
1652          * The check above which compares uaddrs is not sufficient for
1653          * shared futexes. We need to compare the keys:
1654          */
1655         if (requeue_pi && match_futex(&key1, &key2)) {
1656                 ret = -EINVAL;
1657                 goto out_put_keys;
1658         }
1659 
1660         hb1 = hash_futex(&key1);
1661         hb2 = hash_futex(&key2);
1662 
1663 retry_private:
1664         hb_waiters_inc(hb2);
1665         double_lock_hb(hb1, hb2);
1666 
1667         if (likely(cmpval != NULL)) {
1668                 u32 curval;
1669 
1670                 ret = get_futex_value_locked(&curval, uaddr1);
1671 
1672                 if (unlikely(ret)) {
1673                         double_unlock_hb(hb1, hb2);
1674                         hb_waiters_dec(hb2);
1675 
1676                         ret = get_user(curval, uaddr1);
1677                         if (ret)
1678                                 goto out_put_keys;
1679 
1680                         if (!(flags & FLAGS_SHARED))
1681                                 goto retry_private;
1682 
1683                         put_futex_key(&key2);
1684                         put_futex_key(&key1);
1685                         goto retry;
1686                 }
1687                 if (curval != *cmpval) {
1688                         ret = -EAGAIN;
1689                         goto out_unlock;
1690                 }
1691         }
1692 
1693         if (requeue_pi && (task_count - nr_wake < nr_requeue)) {
1694                 /*
1695                  * Attempt to acquire uaddr2 and wake the top waiter. If we
1696                  * intend to requeue waiters, force setting the FUTEX_WAITERS
1697                  * bit.  We force this here where we are able to easily handle
1698                  * faults rather in the requeue loop below.
1699                  */
1700                 ret = futex_proxy_trylock_atomic(uaddr2, hb1, hb2, &key1,
1701                                                  &key2, &pi_state, nr_requeue);
1702 
1703                 /*
1704                  * At this point the top_waiter has either taken uaddr2 or is
1705                  * waiting on it.  If the former, then the pi_state will not
1706                  * exist yet, look it up one more time to ensure we have a
1707                  * reference to it. If the lock was taken, ret contains the
1708                  * vpid of the top waiter task.
1709                  */
1710                 if (ret > 0) {
1711                         WARN_ON(pi_state);
1712                         drop_count++;
1713                         task_count++;
1714                         /*
1715                          * If we acquired the lock, then the user
1716                          * space value of uaddr2 should be vpid. It
1717                          * cannot be changed by the top waiter as it
1718                          * is blocked on hb2 lock if it tries to do
1719                          * so. If something fiddled with it behind our
1720                          * back the pi state lookup might unearth
1721                          * it. So we rather use the known value than
1722                          * rereading and handing potential crap to
1723                          * lookup_pi_state.
1724                          */
1725                         ret = lookup_pi_state(ret, hb2, &key2, &pi_state);
1726                 }
1727 
1728                 switch (ret) {
1729                 case 0:
1730                         break;
1731                 case -EFAULT:
1732                         free_pi_state(pi_state);
1733                         pi_state = NULL;
1734                         double_unlock_hb(hb1, hb2);
1735                         hb_waiters_dec(hb2);
1736                         put_futex_key(&key2);
1737                         put_futex_key(&key1);
1738                         ret = fault_in_user_writeable(uaddr2);
1739                         if (!ret)
1740                                 goto retry;
1741                         goto out;
1742                 case -EAGAIN:
1743                         /*
1744                          * Two reasons for this:
1745                          * - Owner is exiting and we just wait for the
1746                          *   exit to complete.
1747                          * - The user space value changed.
1748                          */
1749                         free_pi_state(pi_state);
1750                         pi_state = NULL;
1751                         double_unlock_hb(hb1, hb2);
1752                         hb_waiters_dec(hb2);
1753                         put_futex_key(&key2);
1754                         put_futex_key(&key1);
1755                         cond_resched();
1756                         goto retry;
1757                 default:
1758                         goto out_unlock;
1759                 }
1760         }
1761 
1762         plist_for_each_entry_safe(this, next, &hb1->chain, list) {
1763                 if (task_count - nr_wake >= nr_requeue)
1764                         break;
1765 
1766                 if (!match_futex(&this->key, &key1))
1767                         continue;
1768 
1769                 /*
1770                  * FUTEX_WAIT_REQEUE_PI and FUTEX_CMP_REQUEUE_PI should always
1771                  * be paired with each other and no other futex ops.
1772                  *
1773                  * We should never be requeueing a futex_q with a pi_state,
1774                  * which is awaiting a futex_unlock_pi().
1775                  */
1776                 if ((requeue_pi && !this->rt_waiter) ||
1777                     (!requeue_pi && this->rt_waiter) ||
1778                     this->pi_state) {
1779                         ret = -EINVAL;
1780                         break;
1781                 }
1782 
1783                 /*
1784                  * Wake nr_wake waiters.  For requeue_pi, if we acquired the
1785                  * lock, we already woke the top_waiter.  If not, it will be
1786                  * woken by futex_unlock_pi().
1787                  */
1788                 if (++task_count <= nr_wake && !requeue_pi) {
1789                         mark_wake_futex(&wake_q, this);
1790                         continue;
1791                 }
1792 
1793                 /* Ensure we requeue to the expected futex for requeue_pi. */
1794                 if (requeue_pi && !match_futex(this->requeue_pi_key, &key2)) {
1795                         ret = -EINVAL;
1796                         break;
1797                 }
1798 
1799                 /*
1800                  * Requeue nr_requeue waiters and possibly one more in the case
1801                  * of requeue_pi if we couldn't acquire the lock atomically.
1802                  */
1803                 if (requeue_pi) {
1804                         /* Prepare the waiter to take the rt_mutex. */
1805                         atomic_inc(&pi_state->refcount);
1806                         this->pi_state = pi_state;
1807                         ret = rt_mutex_start_proxy_lock(&pi_state->pi_mutex,
1808                                                         this->rt_waiter,
1809                                                         this->task);
1810                         if (ret == 1) {
1811                                 /* We got the lock. */
1812                                 requeue_pi_wake_futex(this, &key2, hb2);
1813                                 drop_count++;
1814                                 continue;
1815                         } else if (ret) {
1816                                 /* -EDEADLK */
1817                                 this->pi_state = NULL;
1818                                 free_pi_state(pi_state);
1819                                 goto out_unlock;
1820                         }
1821                 }
1822                 requeue_futex(this, hb1, hb2, &key2);
1823                 drop_count++;
1824         }
1825 
1826 out_unlock:
1827         free_pi_state(pi_state);
1828         double_unlock_hb(hb1, hb2);
1829         wake_up_q(&wake_q);
1830         hb_waiters_dec(hb2);
1831 
1832         /*
1833          * drop_futex_key_refs() must be called outside the spinlocks. During
1834          * the requeue we moved futex_q's from the hash bucket at key1 to the
1835          * one at key2 and updated their key pointer.  We no longer need to
1836          * hold the references to key1.
1837          */
1838         while (--drop_count >= 0)
1839                 drop_futex_key_refs(&key1);
1840 
1841 out_put_keys:
1842         put_futex_key(&key2);
1843 out_put_key1:
1844         put_futex_key(&key1);
1845 out:
1846         return ret ? ret : task_count;
1847 }
1848 
1849 /* The key must be already stored in q->key. */
1850 static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
1851         __acquires(&hb->lock)
1852 {
1853         struct futex_hash_bucket *hb;
1854 
1855         hb = hash_futex(&q->key);
1856 
1857         /*
1858          * Increment the counter before taking the lock so that
1859          * a potential waker won't miss a to-be-slept task that is
1860          * waiting for the spinlock. This is safe as all queue_lock()
1861          * users end up calling queue_me(). Similarly, for housekeeping,
1862          * decrement the counter at queue_unlock() when some error has
1863          * occurred and we don't end up adding the task to the list.
1864          */
1865         hb_waiters_inc(hb);
1866 
1867         q->lock_ptr = &hb->lock;
1868 
1869         spin_lock(&hb->lock); /* implies MB (A) */
1870         return hb;
1871 }
1872 
1873 static inline void
1874 queue_unlock(struct futex_hash_bucket *hb)
1875         __releases(&hb->lock)
1876 {
1877         spin_unlock(&hb->lock);
1878         hb_waiters_dec(hb);
1879 }
1880 
1881 /**
1882  * queue_me() - Enqueue the futex_q on the futex_hash_bucket
1883  * @q:  The futex_q to enqueue
1884  * @hb: The destination hash bucket
1885  *
1886  * The hb->lock must be held by the caller, and is released here. A call to
1887  * queue_me() is typically paired with exactly one call to unqueue_me().  The
1888  * exceptions involve the PI related operations, which may use unqueue_me_pi()
1889  * or nothing if the unqueue is done as part of the wake process and the unqueue
1890  * state is implicit in the state of woken task (see futex_wait_requeue_pi() for
1891  * an example).
1892  */
1893 static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
1894         __releases(&hb->lock)
1895 {
1896         int prio;
1897 
1898         /*
1899          * The priority used to register this element is
1900          * - either the real thread-priority for the real-time threads
1901          * (i.e. threads with a priority lower than MAX_RT_PRIO)
1902          * - or MAX_RT_PRIO for non-RT threads.
1903          * Thus, all RT-threads are woken first in priority order, and
1904          * the others are woken last, in FIFO order.
1905          */
1906         prio = min(current->normal_prio, MAX_RT_PRIO);
1907 
1908         plist_node_init(&q->list, prio);
1909         plist_add(&q->list, &hb->chain);
1910         q->task = current;
1911         spin_unlock(&hb->lock);
1912 }
1913 
1914 /**
1915  * unqueue_me() - Remove the futex_q from its futex_hash_bucket
1916  * @q:  The futex_q to unqueue
1917  *
1918  * The q->lock_ptr must not be held by the caller. A call to unqueue_me() must
1919  * be paired with exactly one earlier call to queue_me().
1920  *
1921  * Return:
1922  *   1 - if the futex_q was still queued (and we removed unqueued it);
1923  *   0 - if the futex_q was already removed by the waking thread
1924  */
1925 static int unqueue_me(struct futex_q *q)
1926 {
1927         spinlock_t *lock_ptr;
1928         int ret = 0;
1929 
1930         /* In the common case we don't take the spinlock, which is nice. */
1931 retry:
1932         lock_ptr = q->lock_ptr;
1933         barrier();
1934         if (lock_ptr != NULL) {
1935                 spin_lock(lock_ptr);
1936                 /*
1937                  * q->lock_ptr can change between reading it and
1938                  * spin_lock(), causing us to take the wrong lock.  This
1939                  * corrects the race condition.
1940                  *
1941                  * Reasoning goes like this: if we have the wrong lock,
1942                  * q->lock_ptr must have changed (maybe several times)
1943                  * between reading it and the spin_lock().  It can
1944                  * change again after the spin_lock() but only if it was
1945                  * already changed before the spin_lock().  It cannot,
1946                  * however, change back to the original value.  Therefore
1947                  * we can detect whether we acquired the correct lock.
1948                  */
1949                 if (unlikely(lock_ptr != q->lock_ptr)) {
1950                         spin_unlock(lock_ptr);
1951                         goto retry;
1952                 }
1953                 __unqueue_futex(q);
1954 
1955                 BUG_ON(q->pi_state);
1956 
1957                 spin_unlock(lock_ptr);
1958                 ret = 1;
1959         }
1960 
1961         drop_futex_key_refs(&q->key);
1962         return ret;
1963 }
1964 
1965 /*
1966  * PI futexes can not be requeued and must remove themself from the
1967  * hash bucket. The hash bucket lock (i.e. lock_ptr) is held on entry
1968  * and dropped here.
1969  */
1970 static void unqueue_me_pi(struct futex_q *q)
1971         __releases(q->lock_ptr)
1972 {
1973         __unqueue_futex(q);
1974 
1975         BUG_ON(!q->pi_state);
1976         free_pi_state(q->pi_state);
1977         q->pi_state = NULL;
1978 
1979         spin_unlock(q->lock_ptr);
1980 }
1981 
1982 /*
1983  * Fixup the pi_state owner with the new owner.
1984  *
1985  * Must be called with hash bucket lock held and mm->sem held for non
1986  * private futexes.
1987  */
1988 static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
1989                                 struct task_struct *newowner)
1990 {
1991         u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
1992         struct futex_pi_state *pi_state = q->pi_state;
1993         struct task_struct *oldowner = pi_state->owner;
1994         u32 uval, uninitialized_var(curval), newval;
1995         int ret;
1996 
1997         /* Owner died? */
1998         if (!pi_state->owner)
1999                 newtid |= FUTEX_OWNER_DIED;
2000 
2001         /*
2002          * We are here either because we stole the rtmutex from the
2003          * previous highest priority waiter or we are the highest priority
2004          * waiter but failed to get the rtmutex the first time.
2005          * We have to replace the newowner TID in the user space variable.
2006          * This must be atomic as we have to preserve the owner died bit here.
2007          *
2008          * Note: We write the user space value _before_ changing the pi_state
2009          * because we can fault here. Imagine swapped out pages or a fork
2010          * that marked all the anonymous memory readonly for cow.
2011          *
2012          * Modifying pi_state _before_ the user space value would
2013          * leave the pi_state in an inconsistent state when we fault
2014          * here, because we need to drop the hash bucket lock to
2015          * handle the fault. This might be observed in the PID check
2016          * in lookup_pi_state.
2017          */
2018 retry:
2019         if (get_futex_value_locked(&uval, uaddr))
2020                 goto handle_fault;
2021 
2022         while (1) {
2023                 newval = (uval & FUTEX_OWNER_DIED) | newtid;
2024 
2025                 if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
2026                         goto handle_fault;
2027                 if (curval == uval)
2028                         break;
2029                 uval = curval;
2030         }
2031 
2032         /*
2033          * We fixed up user space. Now we need to fix the pi_state
2034          * itself.
2035          */
2036         if (pi_state->owner != NULL) {
2037                 raw_spin_lock_irq(&pi_state->owner->pi_lock);
2038                 WARN_ON(list_empty(&pi_state->list));
2039                 list_del_init(&pi_state->list);
2040                 raw_spin_unlock_irq(&pi_state->owner->pi_lock);
2041         }
2042 
2043         pi_state->owner = newowner;
2044 
2045         raw_spin_lock_irq(&newowner->pi_lock);
2046         WARN_ON(!list_empty(&pi_state->list));
2047         list_add(&pi_state->list, &newowner->pi_state_list);
2048         raw_spin_unlock_irq(&newowner->pi_lock);
2049         return 0;
2050 
2051         /*
2052          * To handle the page fault we need to drop the hash bucket
2053          * lock here. That gives the other task (either the highest priority
2054          * waiter itself or the task which stole the rtmutex) the
2055          * chance to try the fixup of the pi_state. So once we are
2056          * back from handling the fault we need to check the pi_state
2057          * after reacquiring the hash bucket lock and before trying to
2058          * do another fixup. When the fixup has been done already we
2059          * simply return.
2060          */
2061 handle_fault:
2062         spin_unlock(q->lock_ptr);
2063 
2064         ret = fault_in_user_writeable(uaddr);
2065 
2066         spin_lock(q->lock_ptr);
2067 
2068         /*
2069          * Check if someone else fixed it for us:
2070          */
2071         if (pi_state->owner != oldowner)
2072                 return 0;
2073 
2074         if (ret)
2075                 return ret;
2076 
2077         goto retry;
2078 }
2079 
2080 static long futex_wait_restart(struct restart_block *restart);
2081 
2082 /**
2083  * fixup_owner() - Post lock pi_state and corner case management
2084  * @uaddr:      user address of the futex
2085  * @q:          futex_q (contains pi_state and access to the rt_mutex)
2086  * @locked:     if the attempt to take the rt_mutex succeeded (1) or not (0)
2087  *
2088  * After attempting to lock an rt_mutex, this function is called to cleanup
2089  * the pi_state owner as well as handle race conditions that may allow us to
2090  * acquire the lock. Must be called with the hb lock held.
2091  *
2092  * Return:
2093  *  1 - success, lock taken;
2094  *  0 - success, lock not taken;
2095  * <0 - on error (-EFAULT)
2096  */
2097 static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
2098 {
2099         struct task_struct *owner;
2100         int ret = 0;
2101 
2102         if (locked) {
2103                 /*
2104                  * Got the lock. We might not be the anticipated owner if we
2105                  * did a lock-steal - fix up the PI-state in that case:
2106                  */
2107                 if (q->pi_state->owner != current)
2108                         ret = fixup_pi_state_owner(uaddr, q, current);
2109                 goto out;
2110         }
2111 
2112         /*
2113          * Catch the rare case, where the lock was released when we were on the
2114          * way back before we locked the hash bucket.
2115          */
2116         if (q->pi_state->owner == current) {
2117                 /*
2118                  * Try to get the rt_mutex now. This might fail as some other
2119                  * task acquired the rt_mutex after we removed ourself from the
2120                  * rt_mutex waiters list.
2121                  */
2122                 if (rt_mutex_trylock(&q->pi_state->pi_mutex)) {
2123                         locked = 1;
2124                         goto out;
2125                 }
2126 
2127                 /*
2128                  * pi_state is incorrect, some other task did a lock steal and
2129                  * we returned due to timeout or signal without taking the
2130                  * rt_mutex. Too late.
2131                  */
2132                 raw_spin_lock(&q->pi_state->pi_mutex.wait_lock);
2133                 owner = rt_mutex_owner(&q->pi_state->pi_mutex);
2134                 if (!owner)
2135                         owner = rt_mutex_next_owner(&q->pi_state->pi_mutex);
2136                 raw_spin_unlock(&q->pi_state->pi_mutex.wait_lock);
2137                 ret = fixup_pi_state_owner(uaddr, q, owner);
2138                 goto out;
2139         }
2140 
2141         /*
2142          * Paranoia check. If we did not take the lock, then we should not be
2143          * the owner of the rt_mutex.
2144          */
2145         if (rt_mutex_owner(&q->pi_state->pi_mutex) == current)
2146                 printk(KERN_ERR "fixup_owner: ret = %d pi-mutex: %p "
2147                                 "pi-state %p\n", ret,
2148                                 q->pi_state->pi_mutex.owner,
2149                                 q->pi_state->owner);
2150 
2151 out:
2152         return ret ? ret : locked;
2153 }
2154 
2155 /**
2156  * futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal
2157  * @hb:         the futex hash bucket, must be locked by the caller
2158  * @q:          the futex_q to queue up on
2159  * @timeout:    the prepared hrtimer_sleeper, or null for no timeout
2160  */
2161 static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
2162                                 struct hrtimer_sleeper *timeout)
2163 {
2164         /*
2165          * The task state is guaranteed to be set before another task can
2166          * wake it. set_current_state() is implemented using smp_store_mb() and
2167          * queue_me() calls spin_unlock() upon completion, both serializing
2168          * access to the hash list and forcing another memory barrier.
2169          */
2170         set_current_state(TASK_INTERRUPTIBLE);
2171         queue_me(q, hb);
2172 
2173         /* Arm the timer */
2174         if (timeout)
2175                 hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
2176 
2177         /*
2178          * If we have been removed from the hash list, then another task
2179          * has tried to wake us, and we can skip the call to schedule().
2180          */
2181         if (likely(!plist_node_empty(&q->list))) {
2182                 /*
2183                  * If the timer has already expired, current will already be
2184                  * flagged for rescheduling. Only call schedule if there
2185                  * is no timeout, or if it has yet to expire.
2186                  */
2187                 if (!timeout || timeout->task)
2188                         freezable_schedule();
2189         }
2190         __set_current_state(TASK_RUNNING);
2191 }
2192 
2193 /**
2194  * futex_wait_setup() - Prepare to wait on a futex
2195  * @uaddr:      the futex userspace address
2196  * @val:        the expected value
2197  * @flags:      futex flags (FLAGS_SHARED, etc.)
2198  * @q:          the associated futex_q
2199  * @hb:         storage for hash_bucket pointer to be returned to caller
2200  *
2201  * Setup the futex_q and locate the hash_bucket.  Get the futex value and
2202  * compare it with the expected value.  Handle atomic faults internally.
2203  * Return with the hb lock held and a q.key reference on success, and unlocked
2204  * with no q.key reference on failure.
2205  *
2206  * Return:
2207  *  0 - uaddr contains val and hb has been locked;
2208  * <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
2209  */
2210 static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
2211                            struct futex_q *q, struct futex_hash_bucket **hb)
2212 {
2213         u32 uval;
2214         int ret;
2215 
2216         /*
2217          * Access the page AFTER the hash-bucket is locked.
2218          * Order is important:
2219          *
2220          *   Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
2221          *   Userspace waker:  if (cond(var)) { var = new; futex_wake(&var); }
2222          *
2223          * The basic logical guarantee of a futex is that it blocks ONLY
2224          * if cond(var) is known to be true at the time of blocking, for
2225          * any cond.  If we locked the hash-bucket after testing *uaddr, that
2226          * would open a race condition where we could block indefinitely with
2227          * cond(var) false, which would violate the guarantee.
2228          *
2229          * On the other hand, we insert q and release the hash-bucket only
2230          * after testing *uaddr.  This guarantees that futex_wait() will NOT
2231          * absorb a wakeup if *uaddr does not match the desired values
2232          * while the syscall executes.
2233          */
2234 retry:
2235         ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q->key, VERIFY_READ);
2236         if (unlikely(ret != 0))
2237                 return ret;
2238 
2239 retry_private:
2240         *hb = queue_lock(q);
2241 
2242         ret = get_futex_value_locked(&uval, uaddr);
2243 
2244         if (ret) {
2245                 queue_unlock(*hb);
2246 
2247                 ret = get_user(uval, uaddr);
2248                 if (ret)
2249                         goto out;
2250 
2251                 if (!(flags & FLAGS_SHARED))
2252                         goto retry_private;
2253 
2254                 put_futex_key(&q->key);
2255                 goto retry;
2256         }
2257 
2258         if (uval != val) {
2259                 queue_unlock(*hb);
2260                 ret = -EWOULDBLOCK;
2261         }
2262 
2263 out:
2264         if (ret)
2265                 put_futex_key(&q->key);
2266         return ret;
2267 }
2268 
2269 static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
2270                       ktime_t *abs_time, u32 bitset)
2271 {
2272         struct hrtimer_sleeper timeout, *to = NULL;
2273         struct restart_block *restart;
2274         struct futex_hash_bucket *hb;
2275         struct futex_q q = futex_q_init;
2276         int ret;
2277 
2278         if (!bitset)
2279                 return -EINVAL;
2280         q.bitset = bitset;
2281 
2282         if (abs_time) {
2283                 to = &timeout;
2284 
2285                 hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
2286                                       CLOCK_REALTIME : CLOCK_MONOTONIC,
2287                                       HRTIMER_MODE_ABS);
2288                 hrtimer_init_sleeper(to, current);
2289                 hrtimer_set_expires_range_ns(&to->timer, *abs_time,
2290                                              current->timer_slack_ns);
2291         }
2292 
2293 retry:
2294         /*
2295          * Prepare to wait on uaddr. On success, holds hb lock and increments
2296          * q.key refs.
2297          */
2298         ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
2299         if (ret)
2300                 goto out;
2301 
2302         /* queue_me and wait for wakeup, timeout, or a signal. */
2303         futex_wait_queue_me(hb, &q, to);
2304 
2305         /* If we were woken (and unqueued), we succeeded, whatever. */
2306         ret = 0;
2307         /* unqueue_me() drops q.key ref */
2308         if (!unqueue_me(&q))
2309                 goto out;
2310         ret = -ETIMEDOUT;
2311         if (to && !to->task)
2312                 goto out;
2313 
2314         /*
2315          * We expect signal_pending(current), but we might be the
2316          * victim of a spurious wakeup as well.
2317          */
2318         if (!signal_pending(current))
2319                 goto retry;
2320 
2321         ret = -ERESTARTSYS;
2322         if (!abs_time)
2323                 goto out;
2324 
2325         restart = &current->restart_block;
2326         restart->fn = futex_wait_restart;
2327         restart->futex.uaddr = uaddr;
2328         restart->futex.val = val;
2329         restart->futex.time = abs_time->tv64;
2330         restart->futex.bitset = bitset;
2331         restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
2332 
2333         ret = -ERESTART_RESTARTBLOCK;
2334 
2335 out:
2336         if (to) {
2337                 hrtimer_cancel(&to->timer);
2338                 destroy_hrtimer_on_stack(&to->timer);
2339         }
2340         return ret;
2341 }
2342 
2343 
2344 static long futex_wait_restart(struct restart_block *restart)
2345 {
2346         u32 __user *uaddr = restart->futex.uaddr;
2347         ktime_t t, *tp = NULL;
2348 
2349         if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
2350                 t.tv64 = restart->futex.time;
2351                 tp = &t;
2352         }
2353         restart->fn = do_no_restart_syscall;
2354 
2355         return (long)futex_wait(uaddr, restart->futex.flags,
2356                                 restart->futex.val, tp, restart->futex.bitset);
2357 }
2358 
2359 
2360 /*
2361  * Userspace tried a 0 -> TID atomic transition of the futex value
2362  * and failed. The kernel side here does the whole locking operation:
2363  * if there are waiters then it will block as a consequence of relying
2364  * on rt-mutexes, it does PI, etc. (Due to races the kernel might see
2365  * a 0 value of the futex too.).
2366  *
2367  * Also serves as futex trylock_pi()'ing, and due semantics.
2368  */
2369 static int futex_lock_pi(u32 __user *uaddr, unsigned int flags,
2370                          ktime_t *time, int trylock)
2371 {
2372         struct hrtimer_sleeper timeout, *to = NULL;
2373         struct futex_hash_bucket *hb;
2374         struct futex_q q = futex_q_init;
2375         int res, ret;
2376 
2377         if (refill_pi_state_cache())
2378                 return -ENOMEM;
2379 
2380         if (time) {
2381                 to = &timeout;
2382                 hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,
2383                                       HRTIMER_MODE_ABS);
2384                 hrtimer_init_sleeper(to, current);
2385                 hrtimer_set_expires(&to->timer, *time);
2386         }
2387 
2388 retry:
2389         ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q.key, VERIFY_WRITE);
2390         if (unlikely(ret != 0))
2391                 goto out;
2392 
2393 retry_private:
2394         hb = queue_lock(&q);
2395 
2396         ret = futex_lock_pi_atomic(uaddr, hb, &q.key, &q.pi_state, current, 0);
2397         if (unlikely(ret)) {
2398                 /*
2399                  * Atomic work succeeded and we got the lock,
2400                  * or failed. Either way, we do _not_ block.
2401                  */
2402                 switch (ret) {
2403                 case 1:
2404                         /* We got the lock. */
2405                         ret = 0;
2406                         goto out_unlock_put_key;
2407                 case -EFAULT:
2408                         goto uaddr_faulted;
2409                 case -EAGAIN:
2410                         /*
2411                          * Two reasons for this:
2412                          * - Task is exiting and we just wait for the
2413                          *   exit to complete.
2414                          * - The user space value changed.
2415                          */
2416                         queue_unlock(hb);
2417                         put_futex_key(&q.key);
2418                         cond_resched();
2419                         goto retry;
2420                 default:
2421                         goto out_unlock_put_key;
2422                 }
2423         }
2424 
2425         /*
2426          * Only actually queue now that the atomic ops are done:
2427          */
2428         queue_me(&q, hb);
2429 
2430         WARN_ON(!q.pi_state);
2431         /*
2432          * Block on the PI mutex:
2433          */
2434         if (!trylock) {
2435                 ret = rt_mutex_timed_futex_lock(&q.pi_state->pi_mutex, to);
2436         } else {
2437                 ret = rt_mutex_trylock(&q.pi_state->pi_mutex);
2438                 /* Fixup the trylock return value: */
2439                 ret = ret ? 0 : -EWOULDBLOCK;
2440         }
2441 
2442         spin_lock(q.lock_ptr);
2443         /*
2444          * Fixup the pi_state owner and possibly acquire the lock if we
2445          * haven't already.
2446          */
2447         res = fixup_owner(uaddr, &q, !ret);
2448         /*
2449          * If fixup_owner() returned an error, proprogate that.  If it acquired
2450          * the lock, clear our -ETIMEDOUT or -EINTR.
2451          */
2452         if (res)
2453                 ret = (res < 0) ? res : 0;
2454 
2455         /*
2456          * If fixup_owner() faulted and was unable to handle the fault, unlock
2457          * it and return the fault to userspace.
2458          */
2459         if (ret && (rt_mutex_owner(&q.pi_state->pi_mutex) == current))
2460                 rt_mutex_unlock(&q.pi_state->pi_mutex);
2461 
2462         /* Unqueue and drop the lock */
2463         unqueue_me_pi(&q);
2464 
2465         goto out_put_key;
2466 
2467 out_unlock_put_key:
2468         queue_unlock(hb);
2469 
2470 out_put_key:
2471         put_futex_key(&q.key);
2472 out:
2473         if (to)
2474                 destroy_hrtimer_on_stack(&to->timer);
2475         return ret != -EINTR ? ret : -ERESTARTNOINTR;
2476 
2477 uaddr_faulted:
2478         queue_unlock(hb);
2479 
2480         ret = fault_in_user_writeable(uaddr);
2481         if (ret)
2482                 goto out_put_key;
2483 
2484         if (!(flags & FLAGS_SHARED))
2485                 goto retry_private;
2486 
2487         put_futex_key(&q.key);
2488         goto retry;
2489 }
2490 
2491 /*
2492  * Userspace attempted a TID -> 0 atomic transition, and failed.
2493  * This is the in-kernel slowpath: we look up the PI state (if any),
2494  * and do the rt-mutex unlock.
2495  */
2496 static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
2497 {
2498         u32 uninitialized_var(curval), uval, vpid = task_pid_vnr(current);
2499         union futex_key key = FUTEX_KEY_INIT;
2500         struct futex_hash_bucket *hb;
2501         struct futex_q *match;
2502         int ret;
2503 
2504 retry:
2505         if (get_user(uval, uaddr))
2506                 return -EFAULT;
2507         /*
2508          * We release only a lock we actually own:
2509          */
2510         if ((uval & FUTEX_TID_MASK) != vpid)
2511                 return -EPERM;
2512 
2513         ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_WRITE);
2514         if (ret)
2515                 return ret;
2516 
2517         hb = hash_futex(&key);
2518         spin_lock(&hb->lock);
2519 
2520         /*
2521          * Check waiters first. We do not trust user space values at
2522          * all and we at least want to know if user space fiddled
2523          * with the futex value instead of blindly unlocking.
2524          */
2525         match = futex_top_waiter(hb, &key);
2526         if (match) {
2527                 ret = wake_futex_pi(uaddr, uval, match, hb);
2528                 /*
2529                  * In case of success wake_futex_pi dropped the hash
2530                  * bucket lock.
2531                  */
2532                 if (!ret)
2533                         goto out_putkey;
2534                 /*
2535                  * The atomic access to the futex value generated a
2536                  * pagefault, so retry the user-access and the wakeup:
2537                  */
2538                 if (ret == -EFAULT)
2539                         goto pi_faulted;
2540                 /*
2541                  * wake_futex_pi has detected invalid state. Tell user
2542                  * space.
2543                  */
2544                 goto out_unlock;
2545         }
2546 
2547         /*
2548          * We have no kernel internal state, i.e. no waiters in the
2549          * kernel. Waiters which are about to queue themselves are stuck
2550          * on hb->lock. So we can safely ignore them. We do neither
2551          * preserve the WAITERS bit not the OWNER_DIED one. We are the
2552          * owner.
2553          */
2554         if (cmpxchg_futex_value_locked(&curval, uaddr, uval, 0))
2555                 goto pi_faulted;
2556 
2557         /*
2558          * If uval has changed, let user space handle it.
2559          */
2560         ret = (curval == uval) ? 0 : -EAGAIN;
2561 
2562 out_unlock:
2563         spin_unlock(&hb->lock);
2564 out_putkey:
2565         put_futex_key(&key);
2566         return ret;
2567 
2568 pi_faulted:
2569         spin_unlock(&hb->lock);
2570         put_futex_key(&key);
2571 
2572         ret = fault_in_user_writeable(uaddr);
2573         if (!ret)
2574                 goto retry;
2575 
2576         return ret;
2577 }
2578 
2579 /**
2580  * handle_early_requeue_pi_wakeup() - Detect early wakeup on the initial futex
2581  * @hb:         the hash_bucket futex_q was original enqueued on
2582  * @q:          the futex_q woken while waiting to be requeued
2583  * @key2:       the futex_key of the requeue target futex
2584  * @timeout:    the timeout associated with the wait (NULL if none)
2585  *
2586  * Detect if the task was woken on the initial futex as opposed to the requeue
2587  * target futex.  If so, determine if it was a timeout or a signal that caused
2588  * the wakeup and return the appropriate error code to the caller.  Must be
2589  * called with the hb lock held.
2590  *
2591  * Return:
2592  *  0 = no early wakeup detected;
2593  * <0 = -ETIMEDOUT or -ERESTARTNOINTR
2594  */
2595 static inline
2596 int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
2597                                    struct futex_q *q, union futex_key *key2,
2598                                    struct hrtimer_sleeper *timeout)
2599 {
2600         int ret = 0;
2601 
2602         /*
2603          * With the hb lock held, we avoid races while we process the wakeup.
2604          * We only need to hold hb (and not hb2) to ensure atomicity as the
2605          * wakeup code can't change q.key from uaddr to uaddr2 if we hold hb.
2606          * It can't be requeued from uaddr2 to something else since we don't
2607          * support a PI aware source futex for requeue.
2608          */
2609         if (!match_futex(&q->key, key2)) {
2610                 WARN_ON(q->lock_ptr && (&hb->lock != q->lock_ptr));
2611                 /*
2612                  * We were woken prior to requeue by a timeout or a signal.
2613                  * Unqueue the futex_q and determine which it was.
2614                  */
2615                 plist_del(&q->list, &hb->chain);
2616                 hb_waiters_dec(hb);
2617 
2618                 /* Handle spurious wakeups gracefully */
2619                 ret = -EWOULDBLOCK;
2620                 if (timeout && !timeout->task)
2621                         ret = -ETIMEDOUT;
2622                 else if (signal_pending(current))
2623                         ret = -ERESTARTNOINTR;
2624         }
2625         return ret;
2626 }
2627 
2628 /**
2629  * futex_wait_requeue_pi() - Wait on uaddr and take uaddr2
2630  * @uaddr:      the futex we initially wait on (non-pi)
2631  * @flags:      futex flags (FLAGS_SHARED, FLAGS_CLOCKRT, etc.), they must be
2632  *              the same type, no requeueing from private to shared, etc.
2633  * @val:        the expected value of uaddr
2634  * @abs_time:   absolute timeout
2635  * @bitset:     32 bit wakeup bitset set by userspace, defaults to all
2636  * @uaddr2:     the pi futex we will take prior to returning to user-space
2637  *
2638  * The caller will wait on uaddr and will be requeued by futex_requeue() to
2639  * uaddr2 which must be PI aware and unique from uaddr.  Normal wakeup will wake
2640  * on uaddr2 and complete the acquisition of the rt_mutex prior to returning to
2641  * userspace.  This ensures the rt_mutex maintains an owner when it has waiters;
2642  * without one, the pi logic would not know which task to boost/deboost, if
2643  * there was a need to.
2644  *
2645  * We call schedule in futex_wait_queue_me() when we enqueue and return there
2646  * via the following--
2647  * 1) wakeup on uaddr2 after an atomic lock acquisition by futex_requeue()
2648  * 2) wakeup on uaddr2 after a requeue
2649  * 3) signal
2650  * 4) timeout
2651  *
2652  * If 3, cleanup and return -ERESTARTNOINTR.
2653  *
2654  * If 2, we may then block on trying to take the rt_mutex and return via:
2655  * 5) successful lock
2656  * 6) signal
2657  * 7) timeout
2658  * 8) other lock acquisition failure
2659  *
2660  * If 6, return -EWOULDBLOCK (restarting the syscall would do the same).
2661  *
2662  * If 4 or 7, we cleanup and return with -ETIMEDOUT.
2663  *
2664  * Return:
2665  *  0 - On success;
2666  * <0 - On error
2667  */
2668 static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
2669                                  u32 val, ktime_t *abs_time, u32 bitset,
2670                                  u32 __user *uaddr2)
2671 {
2672         struct hrtimer_sleeper timeout, *to = NULL;
2673         struct rt_mutex_waiter rt_waiter;
2674         struct rt_mutex *pi_mutex = NULL;
2675         struct futex_hash_bucket *hb;
2676         union futex_key key2 = FUTEX_KEY_INIT;
2677         struct futex_q q = futex_q_init;
2678         int res, ret;
2679 
2680         if (uaddr == uaddr2)
2681                 return -EINVAL;
2682 
2683         if (!bitset)
2684                 return -EINVAL;
2685 
2686         if (abs_time) {
2687                 to = &timeout;
2688                 hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?
2689                                       CLOCK_REALTIME : CLOCK_MONOTONIC,
2690                                       HRTIMER_MODE_ABS);
2691                 hrtimer_init_sleeper(to, current);
2692                 hrtimer_set_expires_range_ns(&to->timer, *abs_time,
2693                                              current->timer_slack_ns);
2694         }
2695 
2696         /*
2697          * The waiter is allocated on our stack, manipulated by the requeue
2698          * code while we sleep on uaddr.
2699          */
2700         debug_rt_mutex_init_waiter(&rt_waiter);
2701         RB_CLEAR_NODE(&rt_waiter.pi_tree_entry);
2702         RB_CLEAR_NODE(&rt_waiter.tree_entry);
2703         rt_waiter.task = NULL;
2704 
2705         ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
2706         if (unlikely(ret != 0))
2707                 goto out;
2708 
2709         q.bitset = bitset;
2710         q.rt_waiter = &rt_waiter;
2711         q.requeue_pi_key = &key2;
2712 
2713         /*
2714          * Prepare to wait on uaddr. On success, increments q.key (key1) ref
2715          * count.
2716          */
2717         ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
2718         if (ret)
2719                 goto out_key2;
2720 
2721         /*
2722          * The check above which compares uaddrs is not sufficient for
2723          * shared futexes. We need to compare the keys:
2724          */
2725         if (match_futex(&q.key, &key2)) {
2726                 queue_unlock(hb);
2727                 ret = -EINVAL;
2728                 goto out_put_keys;
2729         }
2730 
2731         /* Queue the futex_q, drop the hb lock, wait for wakeup. */
2732         futex_wait_queue_me(hb, &q, to);
2733 
2734         spin_lock(&hb->lock);
2735         ret = handle_early_requeue_pi_wakeup(hb, &q, &key2, to);
2736         spin_unlock(&hb->lock);
2737         if (ret)
2738                 goto out_put_keys;
2739 
2740         /*
2741          * In order for us to be here, we know our q.key == key2, and since
2742          * we took the hb->lock above, we also know that futex_requeue() has
2743          * completed and we no longer have to concern ourselves with a wakeup
2744          * race with the atomic proxy lock acquisition by the requeue code. The
2745          * futex_requeue dropped our key1 reference and incremented our key2
2746          * reference count.
2747          */
2748 
2749         /* Check if the requeue code acquired the second futex for us. */
2750         if (!q.rt_waiter) {
2751                 /*
2752                  * Got the lock. We might not be the anticipated owner if we
2753                  * did a lock-steal - fix up the PI-state in that case.
2754                  */
2755                 if (q.pi_state && (q.pi_state->owner != current)) {
2756                         spin_lock(q.lock_ptr);
2757                         ret = fixup_pi_state_owner(uaddr2, &q, current);
2758                         spin_unlock(q.lock_ptr);
2759                 }
2760         } else {
2761                 /*
2762                  * We have been woken up by futex_unlock_pi(), a timeout, or a
2763                  * signal.  futex_unlock_pi() will not destroy the lock_ptr nor
2764                  * the pi_state.
2765                  */
2766                 WARN_ON(!q.pi_state);
2767                 pi_mutex = &q.pi_state->pi_mutex;
2768                 ret = rt_mutex_finish_proxy_lock(pi_mutex, to, &rt_waiter);
2769                 debug_rt_mutex_free_waiter(&rt_waiter);
2770 
2771                 spin_lock(q.lock_ptr);
2772                 /*
2773                  * Fixup the pi_state owner and possibly acquire the lock if we
2774                  * haven't already.
2775                  */
2776                 res = fixup_owner(uaddr2, &q, !ret);
2777                 /*
2778                  * If fixup_owner() returned an error, proprogate that.  If it
2779                  * acquired the lock, clear -ETIMEDOUT or -EINTR.
2780                  */
2781                 if (res)
2782                         ret = (res < 0) ? res : 0;
2783 
2784                 /* Unqueue and drop the lock. */
2785                 unqueue_me_pi(&q);
2786         }
2787 
2788         /*
2789          * If fixup_pi_state_owner() faulted and was unable to handle the
2790          * fault, unlock the rt_mutex and return the fault to userspace.
2791          */
2792         if (ret == -EFAULT) {
2793                 if (pi_mutex && rt_mutex_owner(pi_mutex) == current)
2794                         rt_mutex_unlock(pi_mutex);
2795         } else if (ret == -EINTR) {
2796                 /*
2797                  * We've already been requeued, but cannot restart by calling
2798                  * futex_lock_pi() directly. We could restart this syscall, but
2799                  * it would detect that the user space "val" changed and return
2800                  * -EWOULDBLOCK.  Save the overhead of the restart and return
2801                  * -EWOULDBLOCK directly.
2802                  */
2803                 ret = -EWOULDBLOCK;
2804         }
2805 
2806 out_put_keys:
2807         put_futex_key(&q.key);
2808 out_key2:
2809         put_futex_key(&key2);
2810 
2811 out:
2812         if (to) {
2813                 hrtimer_cancel(&to->timer);
2814                 destroy_hrtimer_on_stack(&to->timer);
2815         }
2816         return ret;
2817 }
2818 
2819 /*
2820  * Support for robust futexes: the kernel cleans up held futexes at
2821  * thread exit time.
2822  *
2823  * Implementation: user-space maintains a per-thread list of locks it
2824  * is holding. Upon do_exit(), the kernel carefully walks this list,
2825  * and marks all locks that are owned by this thread with the
2826  * FUTEX_OWNER_DIED bit, and wakes up a waiter (if any). The list is
2827  * always manipulated with the lock held, so the list is private and
2828  * per-thread. Userspace also maintains a per-thread 'list_op_pending'
2829  * field, to allow the kernel to clean up if the thread dies after
2830  * acquiring the lock, but just before it could have added itself to
2831  * the list. There can only be one such pending lock.
2832  */
2833 
2834 /**
2835  * sys_set_robust_list() - Set the robust-futex list head of a task
2836  * @head:       pointer to the list-head
2837  * @len:        length of the list-head, as userspace expects
2838  */
2839 SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
2840                 size_t, len)
2841 {
2842         if (!futex_cmpxchg_enabled)
2843                 return -ENOSYS;
2844         /*
2845          * The kernel knows only one size for now:
2846          */
2847         if (unlikely(len != sizeof(*head)))
2848                 return -EINVAL;
2849 
2850         current->robust_list = head;
2851 
2852         return 0;
2853 }
2854 
2855 /**
2856  * sys_get_robust_list() - Get the robust-futex list head of a task
2857  * @pid:        pid of the process [zero for current task]
2858  * @head_ptr:   pointer to a list-head pointer, the kernel fills it in
2859  * @len_ptr:    pointer to a length field, the kernel fills in the header size
2860  */
2861 SYSCALL_DEFINE3(get_robust_list, int, pid,
2862                 struct robust_list_head __user * __user *, head_ptr,
2863                 size_t __user *, len_ptr)
2864 {
2865         struct robust_list_head __user *head;
2866         unsigned long ret;
2867         struct task_struct *p;
2868 
2869         if (!futex_cmpxchg_enabled)
2870                 return -ENOSYS;
2871 
2872         rcu_read_lock();
2873 
2874         ret = -ESRCH;
2875         if (!pid)
2876                 p = current;
2877         else {
2878                 p = find_task_by_vpid(pid);
2879                 if (!p)
2880                         goto err_unlock;
2881         }
2882 
2883         ret = -EPERM;
2884         if (!ptrace_may_access(p, PTRACE_MODE_READ))
2885                 goto err_unlock;
2886 
2887         head = p->robust_list;
2888         rcu_read_unlock();
2889 
2890         if (put_user(sizeof(*head), len_ptr))
2891                 return -EFAULT;
2892         return put_user(head, head_ptr);
2893 
2894 err_unlock:
2895         rcu_read_unlock();
2896 
2897         return ret;
2898 }
2899 
2900 /*
2901  * Process a futex-list entry, check whether it's owned by the
2902  * dying task, and do notification if so:
2903  */
2904 int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
2905 {
2906         u32 uval, uninitialized_var(nval), mval;
2907 
2908 retry:
2909         if (get_user(uval, uaddr))
2910                 return -1;
2911 
2912         if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
2913                 /*
2914                  * Ok, this dying thread is truly holding a futex
2915                  * of interest. Set the OWNER_DIED bit atomically
2916                  * via cmpxchg, and if the value had FUTEX_WAITERS
2917                  * set, wake up a waiter (if any). (We have to do a
2918                  * futex_wake() even if OWNER_DIED is already set -
2919                  * to handle the rare but possible case of recursive
2920                  * thread-death.) The rest of the cleanup is done in
2921                  * userspace.
2922                  */
2923                 mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
2924                 /*
2925                  * We are not holding a lock here, but we want to have
2926                  * the pagefault_disable/enable() protection because
2927                  * we want to handle the fault gracefully. If the
2928                  * access fails we try to fault in the futex with R/W
2929                  * verification via get_user_pages. get_user() above
2930                  * does not guarantee R/W access. If that fails we
2931                  * give up and leave the futex locked.
2932                  */
2933                 if (cmpxchg_futex_value_locked(&nval, uaddr, uval, mval)) {
2934                         if (fault_in_user_writeable(uaddr))
2935                                 return -1;
2936                         goto retry;
2937                 }
2938                 if (nval != uval)
2939                         goto retry;
2940 
2941                 /*
2942                  * Wake robust non-PI futexes here. The wakeup of
2943                  * PI futexes happens in exit_pi_state():
2944                  */
2945                 if (!pi && (uval & FUTEX_WAITERS))
2946                         futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
2947         }
2948         return 0;
2949 }
2950 
2951 /*
2952  * Fetch a robust-list pointer. Bit 0 signals PI futexes:
2953  */
2954 static inline int fetch_robust_entry(struct robust_list __user **entry,
2955                                      struct robust_list __user * __user *head,
2956                                      unsigned int *pi)
2957 {
2958         unsigned long uentry;
2959 
2960         if (get_user(uentry, (unsigned long __user *)head))
2961                 return -EFAULT;
2962 
2963         *entry = (void __user *)(uentry & ~1UL);
2964         *pi = uentry & 1;
2965 
2966         return 0;
2967 }
2968 
2969 /*
2970  * Walk curr->robust_list (very carefully, it's a userspace list!)
2971  * and mark any locks found there dead, and notify any waiters.
2972  *
2973  * We silently return on any sign of list-walking problem.
2974  */
2975 void exit_robust_list(struct task_struct *curr)
2976 {
2977         struct robust_list_head __user *head = curr->robust_list;
2978         struct robust_list __user *entry, *next_entry, *pending;
2979         unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
2980         unsigned int uninitialized_var(next_pi);
2981         unsigned long futex_offset;
2982         int rc;
2983 
2984         if (!futex_cmpxchg_enabled)
2985                 return;
2986 
2987         /*
2988          * Fetch the list head (which was registered earlier, via
2989          * sys_set_robust_list()):
2990          */
2991         if (fetch_robust_entry(&entry, &head->list.next, &pi))
2992                 return;
2993         /*
2994          * Fetch the relative futex offset:
2995          */
2996         if (get_user(futex_offset, &head->futex_offset))
2997                 return;
2998         /*
2999          * Fetch any possibly pending lock-add first, and handle it
3000          * if it exists:
3001          */
3002         if (fetch_robust_entry(&pending, &head->list_op_pending, &pip))
3003                 return;
3004 
3005         next_entry = NULL;      /* avoid warning with gcc */
3006         while (entry != &head->list) {
3007                 /*
3008                  * Fetch the next entry in the list before calling
3009                  * handle_futex_death:
3010                  */
3011                 rc = fetch_robust_entry(&next_entry, &entry->next, &next_pi);
3012                 /*
3013                  * A pending lock might already be on the list, so
3014                  * don't process it twice:
3015                  */
3016                 if (entry != pending)
3017                         if (handle_futex_death((void __user *)entry + futex_offset,
3018                                                 curr, pi))
3019                                 return;
3020                 if (rc)
3021                         return;
3022                 entry = next_entry;
3023                 pi = next_pi;
3024                 /*
3025                  * Avoid excessively long or circular lists:
3026                  */
3027                 if (!--limit)
3028                         break;
3029 
3030                 cond_resched();
3031         }
3032 
3033         if (pending)
3034                 handle_futex_death((void __user *)pending + futex_offset,
3035                                    curr, pip);
3036 }
3037 
3038 long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
3039                 u32 __user *uaddr2, u32 val2, u32 val3)
3040 {
3041         int cmd = op & FUTEX_CMD_MASK;
3042         unsigned int flags = 0;
3043 
3044         if (!(op & FUTEX_PRIVATE_FLAG))
3045                 flags |= FLAGS_SHARED;
3046 
3047         if (op & FUTEX_CLOCK_REALTIME) {
3048                 flags |= FLAGS_CLOCKRT;
3049                 if (cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)
3050                         return -ENOSYS;
3051         }
3052 
3053         switch (cmd) {
3054         case FUTEX_LOCK_PI:
3055         case FUTEX_UNLOCK_PI:
3056         case FUTEX_TRYLOCK_PI:
3057         case FUTEX_WAIT_REQUEUE_PI:
3058         case FUTEX_CMP_REQUEUE_PI:
3059                 if (!futex_cmpxchg_enabled)
3060                         return -ENOSYS;
3061         }
3062 
3063         switch (cmd) {
3064         case FUTEX_WAIT:
3065                 val3 = FUTEX_BITSET_MATCH_ANY;
3066         case FUTEX_WAIT_BITSET:
3067                 return futex_wait(uaddr, flags, val, timeout, val3);
3068         case FUTEX_WAKE:
3069                 val3 = FUTEX_BITSET_MATCH_ANY;
3070         case FUTEX_WAKE_BITSET:
3071                 return futex_wake(uaddr, flags, val, val3);
3072         case FUTEX_REQUEUE:
3073                 return futex_requeue(uaddr, flags, uaddr2, val, val2, NULL, 0);
3074         case FUTEX_CMP_REQUEUE:
3075                 return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 0);
3076         case FUTEX_WAKE_OP:
3077                 return futex_wake_op(uaddr, flags, uaddr2, val, val2, val3);
3078         case FUTEX_LOCK_PI:
3079                 return futex_lock_pi(uaddr, flags, timeout, 0);
3080         case FUTEX_UNLOCK_PI:
3081                 return futex_unlock_pi(uaddr, flags);
3082         case FUTEX_TRYLOCK_PI:
3083                 return futex_lock_pi(uaddr, flags, NULL, 1);
3084         case FUTEX_WAIT_REQUEUE_PI:
3085                 val3 = FUTEX_BITSET_MATCH_ANY;
3086                 return futex_wait_requeue_pi(uaddr, flags, val, timeout, val3,
3087                                              uaddr2);
3088         case FUTEX_CMP_REQUEUE_PI:
3089                 return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 1);
3090         }
3091         return -ENOSYS;
3092 }
3093 
3094 
3095 SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
3096                 struct timespec __user *, utime, u32 __user *, uaddr2,
3097                 u32, val3)
3098 {
3099         struct timespec ts;
3100         ktime_t t, *tp = NULL;
3101         u32 val2 = 0;
3102         int cmd = op & FUTEX_CMD_MASK;
3103 
3104         if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
3105                       cmd == FUTEX_WAIT_BITSET ||
3106                       cmd == FUTEX_WAIT_REQUEUE_PI)) {
3107                 if (unlikely(should_fail_futex(!(op & FUTEX_PRIVATE_FLAG))))
3108                         return -EFAULT;
3109                 if (copy_from_user(&ts, utime, sizeof(ts)) != 0)
3110                         return -EFAULT;
3111                 if (!timespec_valid(&ts))
3112                         return -EINVAL;
3113 
3114                 t = timespec_to_ktime(ts);
3115                 if (cmd == FUTEX_WAIT)
3116                         t = ktime_add_safe(ktime_get(), t);
3117                 tp = &t;
3118         }
3119         /*
3120          * requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.
3121          * number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.
3122          */
3123         if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||
3124             cmd == FUTEX_CMP_REQUEUE_PI || cmd == FUTEX_WAKE_OP)
3125                 val2 = (u32) (unsigned long) utime;
3126 
3127         return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);
3128 }
3129 
3130 static void __init futex_detect_cmpxchg(void)
3131 {
3132 #ifndef CONFIG_HAVE_FUTEX_CMPXCHG
3133         u32 curval;
3134 
3135         /*
3136          * This will fail and we want it. Some arch implementations do
3137          * runtime detection of the futex_atomic_cmpxchg_inatomic()
3138          * functionality. We want to know that before we call in any
3139          * of the complex code paths. Also we want to prevent
3140          * registration of robust lists in that case. NULL is
3141          * guaranteed to fault and we get -EFAULT on functional
3142          * implementation, the non-functional ones will return
3143          * -ENOSYS.
3144          */
3145         if (cmpxchg_futex_value_locked(&curval, NULL, 0, 0) == -EFAULT)
3146                 futex_cmpxchg_enabled = 1;
3147 #endif
3148 }
3149 
3150 static int __init futex_init(void)
3151 {
3152         unsigned int futex_shift;
3153         unsigned long i;
3154 
3155 #if CONFIG_BASE_SMALL
3156         futex_hashsize = 16;
3157 #else
3158         futex_hashsize = roundup_pow_of_two(256 * num_possible_cpus());
3159 #endif
3160 
3161         futex_queues = alloc_large_system_hash("futex", sizeof(*futex_queues),
3162                                                futex_hashsize, 0,
3163                                                futex_hashsize < 256 ? HASH_SMALL : 0,
3164                                                &futex_shift, NULL,
3165                                                futex_hashsize, futex_hashsize);
3166         futex_hashsize = 1UL << futex_shift;
3167 
3168         futex_detect_cmpxchg();
3169 
3170         for (i = 0; i < futex_hashsize; i++) {
3171                 atomic_set(&futex_queues[i].waiters, 0);
3172                 plist_head_init(&futex_queues[i].chain);
3173                 spin_lock_init(&futex_queues[i].lock);
3174         }
3175 
3176         return 0;
3177 }
3178 __initcall(futex_init);
3179 

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