Commit | Line | Data |
---|---|---|
34f192c6 IM |
1 | /* |
2 | * linux/kernel/futex_compat.c | |
3 | * | |
4 | * Futex compatibililty routines. | |
5 | * | |
6 | * Copyright 2006, Red Hat, Inc., Ingo Molnar | |
7 | */ | |
8 | ||
9 | #include <linux/linkage.h> | |
10 | #include <linux/compat.h> | |
11 | #include <linux/futex.h> | |
12 | ||
13 | #include <asm/uaccess.h> | |
14 | ||
e3f2ddea IM |
15 | |
16 | /* | |
17 | * Fetch a robust-list pointer. Bit 0 signals PI futexes: | |
18 | */ | |
19 | static inline int | |
20 | fetch_robust_entry(compat_uptr_t *uentry, struct robust_list __user **entry, | |
ba46df98 | 21 | compat_uptr_t __user *head, int *pi) |
e3f2ddea IM |
22 | { |
23 | if (get_user(*uentry, head)) | |
24 | return -EFAULT; | |
25 | ||
26 | *entry = compat_ptr((*uentry) & ~1); | |
27 | *pi = (unsigned int)(*uentry) & 1; | |
28 | ||
29 | return 0; | |
30 | } | |
31 | ||
34f192c6 IM |
32 | /* |
33 | * Walk curr->robust_list (very carefully, it's a userspace list!) | |
34 | * and mark any locks found there dead, and notify any waiters. | |
35 | * | |
36 | * We silently return on any sign of list-walking problem. | |
37 | */ | |
38 | void compat_exit_robust_list(struct task_struct *curr) | |
39 | { | |
40 | struct compat_robust_list_head __user *head = curr->compat_robust_list; | |
9f96cb1e MS |
41 | struct robust_list __user *entry, *next_entry, *pending; |
42 | unsigned int limit = ROBUST_LIST_LIMIT, pi, next_pi, pip; | |
43 | compat_uptr_t uentry, next_uentry, upending; | |
34f192c6 | 44 | compat_long_t futex_offset; |
9f96cb1e | 45 | int rc; |
34f192c6 IM |
46 | |
47 | /* | |
48 | * Fetch the list head (which was registered earlier, via | |
49 | * sys_set_robust_list()): | |
50 | */ | |
e3f2ddea | 51 | if (fetch_robust_entry(&uentry, &entry, &head->list.next, &pi)) |
34f192c6 | 52 | return; |
34f192c6 IM |
53 | /* |
54 | * Fetch the relative futex offset: | |
55 | */ | |
56 | if (get_user(futex_offset, &head->futex_offset)) | |
57 | return; | |
58 | /* | |
59 | * Fetch any possibly pending lock-add first, and handle it | |
60 | * if it exists: | |
61 | */ | |
e3f2ddea | 62 | if (fetch_robust_entry(&upending, &pending, |
ce2c6b53 | 63 | &head->list_op_pending, &pip)) |
34f192c6 | 64 | return; |
34f192c6 | 65 | |
9f96cb1e | 66 | next_entry = NULL; /* avoid warning with gcc */ |
179c85ea | 67 | while (entry != (struct robust_list __user *) &head->list) { |
9f96cb1e MS |
68 | /* |
69 | * Fetch the next entry in the list before calling | |
70 | * handle_futex_death: | |
71 | */ | |
72 | rc = fetch_robust_entry(&next_uentry, &next_entry, | |
73 | (compat_uptr_t __user *)&entry->next, &next_pi); | |
34f192c6 IM |
74 | /* |
75 | * A pending lock might already be on the list, so | |
76 | * dont process it twice: | |
77 | */ | |
78 | if (entry != pending) | |
ba46df98 | 79 | if (handle_futex_death((void __user *)entry + futex_offset, |
e3f2ddea | 80 | curr, pi)) |
34f192c6 IM |
81 | return; |
82 | ||
9f96cb1e | 83 | if (rc) |
34f192c6 | 84 | return; |
9f96cb1e MS |
85 | uentry = next_uentry; |
86 | entry = next_entry; | |
87 | pi = next_pi; | |
34f192c6 IM |
88 | /* |
89 | * Avoid excessively long or circular lists: | |
90 | */ | |
91 | if (!--limit) | |
92 | break; | |
93 | ||
94 | cond_resched(); | |
95 | } | |
9f96cb1e MS |
96 | if (pending) |
97 | handle_futex_death((void __user *)pending + futex_offset, | |
98 | curr, pip); | |
34f192c6 IM |
99 | } |
100 | ||
101 | asmlinkage long | |
102 | compat_sys_set_robust_list(struct compat_robust_list_head __user *head, | |
103 | compat_size_t len) | |
104 | { | |
105 | if (unlikely(len != sizeof(*head))) | |
106 | return -EINVAL; | |
107 | ||
108 | current->compat_robust_list = head; | |
109 | ||
110 | return 0; | |
111 | } | |
112 | ||
113 | asmlinkage long | |
ba46df98 | 114 | compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr, |
34f192c6 IM |
115 | compat_size_t __user *len_ptr) |
116 | { | |
ba46df98 | 117 | struct compat_robust_list_head __user *head; |
34f192c6 IM |
118 | unsigned long ret; |
119 | ||
120 | if (!pid) | |
121 | head = current->compat_robust_list; | |
122 | else { | |
123 | struct task_struct *p; | |
124 | ||
125 | ret = -ESRCH; | |
126 | read_lock(&tasklist_lock); | |
127 | p = find_task_by_pid(pid); | |
128 | if (!p) | |
129 | goto err_unlock; | |
130 | ret = -EPERM; | |
131 | if ((current->euid != p->euid) && (current->euid != p->uid) && | |
132 | !capable(CAP_SYS_PTRACE)) | |
133 | goto err_unlock; | |
134 | head = p->compat_robust_list; | |
135 | read_unlock(&tasklist_lock); | |
136 | } | |
137 | ||
138 | if (put_user(sizeof(*head), len_ptr)) | |
139 | return -EFAULT; | |
140 | return put_user(ptr_to_compat(head), head_ptr); | |
141 | ||
142 | err_unlock: | |
143 | read_unlock(&tasklist_lock); | |
144 | ||
145 | return ret; | |
146 | } | |
147 | ||
8f17d3a5 | 148 | asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val, |
34f192c6 | 149 | struct compat_timespec __user *utime, u32 __user *uaddr2, |
8f17d3a5 | 150 | u32 val3) |
34f192c6 | 151 | { |
c19384b5 PP |
152 | struct timespec ts; |
153 | ktime_t t, *tp = NULL; | |
34f192c6 | 154 | int val2 = 0; |
f0ede66f | 155 | int cmd = op & FUTEX_CMD_MASK; |
34f192c6 | 156 | |
f0ede66f | 157 | if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI)) { |
c19384b5 | 158 | if (get_compat_timespec(&ts, utime)) |
34f192c6 | 159 | return -EFAULT; |
c19384b5 | 160 | if (!timespec_valid(&ts)) |
9741ef96 | 161 | return -EINVAL; |
c19384b5 PP |
162 | |
163 | t = timespec_to_ktime(ts); | |
f0ede66f | 164 | if (cmd == FUTEX_WAIT) |
c19384b5 PP |
165 | t = ktime_add(ktime_get(), t); |
166 | tp = &t; | |
34f192c6 | 167 | } |
bd197234 | 168 | if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE) |
34f192c6 IM |
169 | val2 = (int) (unsigned long) utime; |
170 | ||
c19384b5 | 171 | return do_futex(uaddr, op, val, tp, uaddr2, val2, val3); |
34f192c6 | 172 | } |