1 // SPDX-License-Identifier: GPL-2.0 <<
2 /* 1 /*
3 * This file contains the procedures for the h 2 * This file contains the procedures for the handling of select and poll
4 * 3 *
5 * Created for Linux based loosely upon Mathiu 4 * Created for Linux based loosely upon Mathius Lattner's minix
6 * patches by Peter MacDonald. Heavily edited 5 * patches by Peter MacDonald. Heavily edited by Linus.
7 * 6 *
8 * 4 February 1994 7 * 4 February 1994
9 * COFF/ELF binary emulation. If the proce 8 * COFF/ELF binary emulation. If the process has the STICKY_TIMEOUTS
10 * flag set in its personality we do *not* 9 * flag set in its personality we do *not* modify the given timeout
11 * parameter to reflect time remaining. 10 * parameter to reflect time remaining.
12 * 11 *
13 * 24 January 2000 12 * 24 January 2000
14 * Changed sys_poll()/do_poll() to use PAG 13 * Changed sys_poll()/do_poll() to use PAGE_SIZE chunk-based allocation
15 * of fds to overcome nfds < 16390 descrip 14 * of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
16 */ 15 */
17 16
18 #include <linux/compat.h> !! 17 #include <linux/module.h>
19 #include <linux/kernel.h> <<
20 #include <linux/sched/signal.h> <<
21 #include <linux/sched/rt.h> <<
22 #include <linux/syscalls.h> <<
23 #include <linux/export.h> <<
24 #include <linux/slab.h> 18 #include <linux/slab.h>
>> 19 #include <linux/smp_lock.h>
25 #include <linux/poll.h> 20 #include <linux/poll.h>
26 #include <linux/personality.h> /* for STICKY_T 21 #include <linux/personality.h> /* for STICKY_TIMEOUTS */
27 #include <linux/file.h> 22 #include <linux/file.h>
28 #include <linux/fdtable.h> <<
29 #include <linux/fs.h> 23 #include <linux/fs.h>
30 #include <linux/rcupdate.h> <<
31 #include <linux/hrtimer.h> <<
32 #include <linux/freezer.h> <<
33 #include <net/busy_poll.h> <<
34 #include <linux/vmalloc.h> <<
35 24
36 #include <linux/uaccess.h> !! 25 #include <asm/uaccess.h>
37 <<
38 <<
39 /* <<
40 * Estimate expected accuracy in ns from a tim <<
41 * <<
42 * After quite a bit of churning around, we've <<
43 * a simple thing of taking 0.1% of the timeou <<
44 * slack, with a cap of 100 msec. <<
45 * "nice" tasks get a 0.5% slack instead. <<
46 * <<
47 * Consider this comment an open invitation to <<
48 * better solutions.. <<
49 */ <<
50 <<
51 #define MAX_SLACK (100 * NSEC_PER_MSEC) <<
52 <<
53 static long __estimate_accuracy(struct timespe <<
54 { <<
55 long slack; <<
56 int divfactor = 1000; <<
57 <<
58 if (tv->tv_sec < 0) <<
59 return 0; <<
60 <<
61 if (task_nice(current) > 0) <<
62 divfactor = divfactor / 5; <<
63 <<
64 if (tv->tv_sec > MAX_SLACK / (NSEC_PER <<
65 return MAX_SLACK; <<
66 <<
67 slack = tv->tv_nsec / divfactor; <<
68 slack += tv->tv_sec * (NSEC_PER_SEC/di <<
69 <<
70 if (slack > MAX_SLACK) <<
71 return MAX_SLACK; <<
72 <<
73 return slack; <<
74 } <<
75 <<
76 u64 select_estimate_accuracy(struct timespec64 <<
77 { <<
78 u64 ret; <<
79 struct timespec64 now; <<
80 u64 slack = current->timer_slack_ns; <<
81 <<
82 if (slack == 0) <<
83 return 0; <<
84 <<
85 ktime_get_ts64(&now); <<
86 now = timespec64_sub(*tv, now); <<
87 ret = __estimate_accuracy(&now); <<
88 if (ret < slack) <<
89 return slack; <<
90 return ret; <<
91 } <<
92 26
>> 27 #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
>> 28 #define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
93 29
>> 30 struct poll_table_entry {
>> 31 struct file * filp;
>> 32 wait_queue_t wait;
>> 33 wait_queue_head_t * wait_address;
>> 34 };
94 35
95 struct poll_table_page { 36 struct poll_table_page {
96 struct poll_table_page * next; 37 struct poll_table_page * next;
97 struct poll_table_entry * entry; 38 struct poll_table_entry * entry;
98 struct poll_table_entry entries[]; !! 39 struct poll_table_entry entries[0];
99 }; 40 };
100 41
101 #define POLL_TABLE_FULL(table) \ 42 #define POLL_TABLE_FULL(table) \
102 ((unsigned long)((table)->entry+1) > P 43 ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
103 44
104 /* 45 /*
105 * Ok, Peter made a complicated, but straightf 46 * Ok, Peter made a complicated, but straightforward multiple_wait() function.
106 * I have rewritten this, taking some shortcut 47 * I have rewritten this, taking some shortcuts: This code may not be easy to
107 * follow, but it should be free of race-condi 48 * follow, but it should be free of race-conditions, and it's practical. If you
108 * understand what I'm doing here, then you un 49 * understand what I'm doing here, then you understand how the linux
109 * sleep/wakeup mechanism works. 50 * sleep/wakeup mechanism works.
110 * 51 *
111 * Two very simple procedures, poll_wait() and 52 * Two very simple procedures, poll_wait() and poll_freewait() make all the
112 * work. poll_wait() is an inline-function de 53 * work. poll_wait() is an inline-function defined in <linux/poll.h>,
113 * as all select/poll functions have to call i 54 * as all select/poll functions have to call it to add an entry to the
114 * poll table. 55 * poll table.
115 */ 56 */
116 static void __pollwait(struct file *filp, wait !! 57 void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p);
117 poll_table *p); <<
118 58
119 void poll_initwait(struct poll_wqueues *pwq) 59 void poll_initwait(struct poll_wqueues *pwq)
120 { 60 {
121 init_poll_funcptr(&pwq->pt, __pollwait 61 init_poll_funcptr(&pwq->pt, __pollwait);
122 pwq->polling_task = current; <<
123 pwq->triggered = 0; <<
124 pwq->error = 0; 62 pwq->error = 0;
125 pwq->table = NULL; 63 pwq->table = NULL;
126 pwq->inline_index = 0; <<
127 } 64 }
128 EXPORT_SYMBOL(poll_initwait); <<
129 65
130 static void free_poll_entry(struct poll_table_ !! 66 EXPORT_SYMBOL(poll_initwait);
131 { <<
132 remove_wait_queue(entry->wait_address, <<
133 fput(entry->filp); <<
134 } <<
135 67
136 void poll_freewait(struct poll_wqueues *pwq) 68 void poll_freewait(struct poll_wqueues *pwq)
137 { 69 {
138 struct poll_table_page * p = pwq->tabl 70 struct poll_table_page * p = pwq->table;
139 int i; <<
140 for (i = 0; i < pwq->inline_index; i++ <<
141 free_poll_entry(pwq->inline_en <<
142 while (p) { 71 while (p) {
143 struct poll_table_entry * entr 72 struct poll_table_entry * entry;
144 struct poll_table_page *old; 73 struct poll_table_page *old;
145 74
146 entry = p->entry; 75 entry = p->entry;
147 do { 76 do {
148 entry--; 77 entry--;
149 free_poll_entry(entry) !! 78 remove_wait_queue(entry->wait_address,&entry->wait);
>> 79 fput(entry->filp);
150 } while (entry > p->entries); 80 } while (entry > p->entries);
151 old = p; 81 old = p;
152 p = p->next; 82 p = p->next;
153 free_page((unsigned long) old) 83 free_page((unsigned long) old);
154 } 84 }
155 } 85 }
>> 86
156 EXPORT_SYMBOL(poll_freewait); 87 EXPORT_SYMBOL(poll_freewait);
157 88
158 static struct poll_table_entry *poll_get_entry !! 89 void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *_p)
159 { 90 {
>> 91 struct poll_wqueues *p = container_of(_p, struct poll_wqueues, pt);
160 struct poll_table_page *table = p->tab 92 struct poll_table_page *table = p->table;
161 93
162 if (p->inline_index < N_INLINE_POLL_EN <<
163 return p->inline_entries + p-> <<
164 <<
165 if (!table || POLL_TABLE_FULL(table)) 94 if (!table || POLL_TABLE_FULL(table)) {
166 struct poll_table_page *new_ta 95 struct poll_table_page *new_table;
167 96
168 new_table = (struct poll_table 97 new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
169 if (!new_table) { 98 if (!new_table) {
170 p->error = -ENOMEM; 99 p->error = -ENOMEM;
171 return NULL; !! 100 __set_current_state(TASK_RUNNING);
>> 101 return;
172 } 102 }
173 new_table->entry = new_table-> 103 new_table->entry = new_table->entries;
174 new_table->next = table; 104 new_table->next = table;
175 p->table = new_table; 105 p->table = new_table;
176 table = new_table; 106 table = new_table;
177 } 107 }
178 108
179 return table->entry++; !! 109 /* Add a new entry */
180 } !! 110 {
181 !! 111 struct poll_table_entry * entry = table->entry;
182 static int __pollwake(wait_queue_entry_t *wait !! 112 table->entry = entry+1;
183 { !! 113 get_file(filp);
184 struct poll_wqueues *pwq = wait->priva !! 114 entry->filp = filp;
185 DECLARE_WAITQUEUE(dummy_wait, pwq->pol !! 115 entry->wait_address = wait_address;
186 !! 116 init_waitqueue_entry(&entry->wait, current);
187 /* !! 117 add_wait_queue(wait_address,&entry->wait);
188 * Although this function is called un <<
189 * doesn't imply write barrier and the <<
190 * barrier semantics on wakeup functio <<
191 * smp_wmb() is equivalent to smp_wmb( <<
192 * and is paired with smp_store_mb() i <<
193 */ <<
194 smp_wmb(); <<
195 pwq->triggered = 1; <<
196 <<
197 /* <<
198 * Perform the default wake up operati <<
199 * waitqueue. <<
200 * <<
201 * TODO: This is hacky but there curre <<
202 * pass in @sync. @sync is scheduled <<
203 * that happens, wake_up_process() can <<
204 */ <<
205 return default_wake_function(&dummy_wa <<
206 } <<
207 <<
208 static int pollwake(wait_queue_entry_t *wait, <<
209 { <<
210 struct poll_table_entry *entry; <<
211 <<
212 entry = container_of(wait, struct poll <<
213 if (key && !(key_to_poll(key) & entry- <<
214 return 0; <<
215 return __pollwake(wait, mode, sync, ke <<
216 } <<
217 <<
218 /* Add a new entry */ <<
219 static void __pollwait(struct file *filp, wait <<
220 poll_table *p) <<
221 { <<
222 struct poll_wqueues *pwq = container_o <<
223 struct poll_table_entry *entry = poll_ <<
224 if (!entry) <<
225 return; <<
226 entry->filp = get_file(filp); <<
227 entry->wait_address = wait_address; <<
228 entry->key = p->_key; <<
229 init_waitqueue_func_entry(&entry->wait <<
230 entry->wait.private = pwq; <<
231 add_wait_queue(wait_address, &entry->w <<
232 } <<
233 <<
234 static int poll_schedule_timeout(struct poll_w <<
235 ktime_t *expires, un <<
236 { <<
237 int rc = -EINTR; <<
238 <<
239 set_current_state(state); <<
240 if (!pwq->triggered) <<
241 rc = schedule_hrtimeout_range( <<
242 __set_current_state(TASK_RUNNING); <<
243 <<
244 /* <<
245 * Prepare for the next iteration. <<
246 * <<
247 * The following smp_store_mb() serves <<
248 * the counterpart rmb of the wmb in p <<
249 * written before wake up is always vi <<
250 * Second, the full barrier guarantees <<
251 * doesn't pass event check of the nex <<
252 * this problem doesn't exist for the <<
253 * add_wait_queue() has full barrier s <<
254 */ <<
255 smp_store_mb(pwq->triggered, 0); <<
256 <<
257 return rc; <<
258 } <<
259 <<
260 /** <<
261 * poll_select_set_timeout - helper function t <<
262 * @to: pointer to timespec64 variable <<
263 * @sec: seconds (from user space) <<
264 * @nsec: nanoseconds (from user space) <<
265 * <<
266 * Note, we do not use a timespec for the user <<
267 * way we can use the function for timeval and <<
268 * <<
269 * Returns -EINVAL if sec/nsec are not normali <<
270 */ <<
271 int poll_select_set_timeout(struct timespec64 <<
272 { <<
273 struct timespec64 ts = {.tv_sec = sec, <<
274 <<
275 if (!timespec64_valid(&ts)) <<
276 return -EINVAL; <<
277 <<
278 /* Optimize for the zero timeout value <<
279 if (!sec && !nsec) { <<
280 to->tv_sec = to->tv_nsec = 0; <<
281 } else { <<
282 ktime_get_ts64(to); <<
283 *to = timespec64_add_safe(*to, <<
284 } 118 }
285 return 0; <<
286 } 119 }
287 120
288 enum poll_time_type { <<
289 PT_TIMEVAL = 0, <<
290 PT_OLD_TIMEVAL = 1, <<
291 PT_TIMESPEC = 2, <<
292 PT_OLD_TIMESPEC = 3, <<
293 }; <<
294 <<
295 static int poll_select_finish(struct timespec6 <<
296 void __user *p, <<
297 enum poll_time_t <<
298 { <<
299 struct timespec64 rts; <<
300 <<
301 restore_saved_sigmask_unless(ret == -E <<
302 <<
303 if (!p) <<
304 return ret; <<
305 <<
306 if (current->personality & STICKY_TIME <<
307 goto sticky; <<
308 <<
309 /* No update for zero timeout */ <<
310 if (!end_time->tv_sec && !end_time->tv <<
311 return ret; <<
312 121
313 ktime_get_ts64(&rts); !! 122 #define __IN(fds, n) (fds->in + n)
314 rts = timespec64_sub(*end_time, rts); !! 123 #define __OUT(fds, n) (fds->out + n)
315 if (rts.tv_sec < 0) !! 124 #define __EX(fds, n) (fds->ex + n)
316 rts.tv_sec = rts.tv_nsec = 0; !! 125 #define __RES_IN(fds, n) (fds->res_in + n)
>> 126 #define __RES_OUT(fds, n) (fds->res_out + n)
>> 127 #define __RES_EX(fds, n) (fds->res_ex + n)
317 128
318 !! 129 #define BITS(fds, n) (*__IN(fds, n)|*__OUT(fds, n)|*__EX(fds, n))
319 switch (pt_type) { <<
320 case PT_TIMEVAL: <<
321 { <<
322 struct __kernel_old_ti <<
323 <<
324 if (sizeof(rtv) > size <<
325 memset(&rtv, 0 <<
326 rtv.tv_sec = rts.tv_se <<
327 rtv.tv_usec = rts.tv_n <<
328 if (!copy_to_user(p, & <<
329 return ret; <<
330 } <<
331 break; <<
332 case PT_OLD_TIMEVAL: <<
333 { <<
334 struct old_timeval32 r <<
335 <<
336 rtv.tv_sec = rts.tv_se <<
337 rtv.tv_usec = rts.tv_n <<
338 if (!copy_to_user(p, & <<
339 return ret; <<
340 } <<
341 break; <<
342 case PT_TIMESPEC: <<
343 if (!put_timespec64(&rts, p)) <<
344 return ret; <<
345 break; <<
346 case PT_OLD_TIMESPEC: <<
347 if (!put_old_timespec32(&rts, <<
348 return ret; <<
349 break; <<
350 default: <<
351 BUG(); <<
352 } <<
353 /* <<
354 * If an application puts its timeval <<
355 * don't want the Linux-specific updat <<
356 * cause a fault after the select has <<
357 * successfully. However, because we'r <<
358 * timeval, we can't restart the syste <<
359 */ <<
360 <<
361 sticky: <<
362 if (ret == -ERESTARTNOHAND) <<
363 ret = -EINTR; <<
364 return ret; <<
365 } <<
366 <<
367 /* <<
368 * Scalable version of the fd_set. <<
369 */ <<
370 <<
371 typedef struct { <<
372 unsigned long *in, *out, *ex; <<
373 unsigned long *res_in, *res_out, *res_ <<
374 } fd_set_bits; <<
375 <<
376 /* <<
377 * How many longwords for "nr" bits? <<
378 */ <<
379 #define FDS_BITPERLONG (8*sizeof(long)) <<
380 #define FDS_LONGS(nr) (((nr)+FDS_BITPERLONG- <<
381 #define FDS_BYTES(nr) (FDS_LONGS(nr)*sizeof( <<
382 <<
383 /* <<
384 * Use "unsigned long" accesses to let user-mo <<
385 */ <<
386 static inline <<
387 int get_fd_set(unsigned long nr, void __user * <<
388 { <<
389 nr = FDS_BYTES(nr); <<
390 if (ufdset) <<
391 return copy_from_user(fdset, u <<
392 <<
393 memset(fdset, 0, nr); <<
394 return 0; <<
395 } <<
396 <<
397 static inline unsigned long __must_check <<
398 set_fd_set(unsigned long nr, void __user *ufds <<
399 { <<
400 if (ufdset) <<
401 return __copy_to_user(ufdset, <<
402 return 0; <<
403 } <<
404 <<
405 static inline <<
406 void zero_fd_set(unsigned long nr, unsigned lo <<
407 { <<
408 memset(fdset, 0, FDS_BYTES(nr)); <<
409 } <<
410 <<
411 #define FDS_IN(fds, n) (fds->in + n) <<
412 #define FDS_OUT(fds, n) (fds->out + n) <<
413 #define FDS_EX(fds, n) (fds->ex + n) <<
414 <<
415 #define BITS(fds, n) (*FDS_IN(fds, n)|*FDS_ <<
416 130
417 static int max_select_fd(unsigned long n, fd_s 131 static int max_select_fd(unsigned long n, fd_set_bits *fds)
418 { 132 {
419 unsigned long *open_fds; 133 unsigned long *open_fds;
420 unsigned long set; 134 unsigned long set;
421 int max; 135 int max;
422 struct fdtable *fdt; <<
423 136
424 /* handle last in-complete long-word f 137 /* handle last in-complete long-word first */
425 set = ~(~0UL << (n & (BITS_PER_LONG-1) !! 138 set = ~(~0UL << (n & (__NFDBITS-1)));
426 n /= BITS_PER_LONG; !! 139 n /= __NFDBITS;
427 fdt = files_fdtable(current->files); !! 140 open_fds = current->files->open_fds->fds_bits+n;
428 open_fds = fdt->open_fds + n; <<
429 max = 0; 141 max = 0;
430 if (set) { 142 if (set) {
431 set &= BITS(fds, n); 143 set &= BITS(fds, n);
432 if (set) { 144 if (set) {
433 if (!(set & ~*open_fds 145 if (!(set & ~*open_fds))
434 goto get_max; 146 goto get_max;
435 return -EBADF; 147 return -EBADF;
436 } 148 }
437 } 149 }
438 while (n) { 150 while (n) {
439 open_fds--; 151 open_fds--;
440 n--; 152 n--;
441 set = BITS(fds, n); 153 set = BITS(fds, n);
442 if (!set) 154 if (!set)
443 continue; 155 continue;
444 if (set & ~*open_fds) 156 if (set & ~*open_fds)
445 return -EBADF; 157 return -EBADF;
446 if (max) 158 if (max)
447 continue; 159 continue;
448 get_max: 160 get_max:
449 do { 161 do {
450 max++; 162 max++;
451 set >>= 1; 163 set >>= 1;
452 } while (set); 164 } while (set);
453 max += n * BITS_PER_LONG; !! 165 max += n * __NFDBITS;
454 } 166 }
455 167
456 return max; 168 return max;
457 } 169 }
458 170
459 #define POLLIN_SET (EPOLLRDNORM | EPOLLRDBAND !! 171 #define BIT(i) (1UL << ((i)&(__NFDBITS-1)))
460 EPOLLNVAL) !! 172 #define MEM(i,m) ((m)+(unsigned)(i)/__NFDBITS)
461 #define POLLOUT_SET (EPOLLWRBAND | EPOLLWRNORM !! 173 #define ISSET(i,m) (((i)&*(m)) != 0)
462 EPOLLNVAL) !! 174 #define SET(i,m) (*(m) |= (i))
463 #define POLLEX_SET (EPOLLPRI | EPOLLNVAL) !! 175
464 !! 176 #define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP | POLLERR)
465 static inline void wait_key_set(poll_table *wa !! 177 #define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
466 unsigned long !! 178 #define POLLEX_SET (POLLPRI)
467 __poll_t ll_fl <<
468 { <<
469 wait->_key = POLLEX_SET | ll_flag; <<
470 if (in & bit) <<
471 wait->_key |= POLLIN_SET; <<
472 if (out & bit) <<
473 wait->_key |= POLLOUT_SET; <<
474 } <<
475 179
476 static noinline_for_stack int do_select(int n, !! 180 int do_select(int n, fd_set_bits *fds, long *timeout)
477 { 181 {
478 ktime_t expire, *to = NULL; <<
479 struct poll_wqueues table; 182 struct poll_wqueues table;
480 poll_table *wait; 183 poll_table *wait;
481 int retval, i, timed_out = 0; !! 184 int retval, i;
482 u64 slack = 0; !! 185 long __timeout = *timeout;
483 __poll_t busy_flag = net_busy_loop_on( <<
484 unsigned long busy_start = 0; <<
485 186
486 rcu_read_lock(); !! 187 spin_lock(¤t->files->file_lock);
487 retval = max_select_fd(n, fds); 188 retval = max_select_fd(n, fds);
488 rcu_read_unlock(); !! 189 spin_unlock(¤t->files->file_lock);
489 190
490 if (retval < 0) 191 if (retval < 0)
491 return retval; 192 return retval;
492 n = retval; 193 n = retval;
493 194
494 poll_initwait(&table); 195 poll_initwait(&table);
495 wait = &table.pt; 196 wait = &table.pt;
496 if (end_time && !end_time->tv_sec && ! !! 197 if (!__timeout)
497 wait->_qproc = NULL; !! 198 wait = NULL;
498 timed_out = 1; <<
499 } <<
500 <<
501 if (end_time && !timed_out) <<
502 slack = select_estimate_accura <<
503 <<
504 retval = 0; 199 retval = 0;
505 for (;;) { 200 for (;;) {
506 unsigned long *rinp, *routp, * 201 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
507 bool can_busy_loop = false; !! 202
>> 203 set_current_state(TASK_INTERRUPTIBLE);
508 204
509 inp = fds->in; outp = fds->out 205 inp = fds->in; outp = fds->out; exp = fds->ex;
510 rinp = fds->res_in; routp = fd 206 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
511 207
512 for (i = 0; i < n; ++rinp, ++r 208 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
513 unsigned long in, out, !! 209 unsigned long in, out, ex, all_bits, bit = 1, mask, j;
514 unsigned long res_in = 210 unsigned long res_in = 0, res_out = 0, res_ex = 0;
515 __poll_t mask; !! 211 struct file_operations *f_op = NULL;
>> 212 struct file *file = NULL;
516 213
517 in = *inp++; out = *ou 214 in = *inp++; out = *outp++; ex = *exp++;
518 all_bits = in | out | 215 all_bits = in | out | ex;
519 if (all_bits == 0) { 216 if (all_bits == 0) {
520 i += BITS_PER_ !! 217 i += __NFDBITS;
521 continue; 218 continue;
522 } 219 }
523 220
524 for (j = 0; j < BITS_P !! 221 for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
525 struct fd f; <<
526 if (i >= n) 222 if (i >= n)
527 break; 223 break;
528 if (!(bit & al 224 if (!(bit & all_bits))
529 contin 225 continue;
530 mask = EPOLLNV !! 226 file = fget(i);
531 f = fdget(i); !! 227 if (file) {
532 if (fd_file(f) !! 228 f_op = file->f_op;
533 wait_k !! 229 mask = DEFAULT_POLLMASK;
534 !! 230 if (f_op && f_op->poll)
535 mask = !! 231 mask = (*f_op->poll)(file, retval ? NULL : wait);
536 !! 232 fput(file);
537 fdput( !! 233 if ((mask & POLLIN_SET) && (in & bit)) {
538 } !! 234 res_in |= bit;
539 if ((mask & PO !! 235 retval++;
540 res_in !! 236 }
541 retval !! 237 if ((mask & POLLOUT_SET) && (out & bit)) {
542 wait-> !! 238 res_out |= bit;
543 } !! 239 retval++;
544 if ((mask & PO !! 240 }
545 res_ou !! 241 if ((mask & POLLEX_SET) && (ex & bit)) {
546 retval !! 242 res_ex |= bit;
547 wait-> !! 243 retval++;
548 } !! 244 }
549 if ((mask & PO <<
550 res_ex <<
551 retval <<
552 wait-> <<
553 } 245 }
554 /* got somethi <<
555 if (retval) { <<
556 can_bu <<
557 busy_f <<
558 <<
559 /* <<
560 * only rememb <<
561 * POLL_BUSY_L <<
562 */ <<
563 } else if (bus <<
564 can_bu <<
565 <<
566 } 246 }
567 if (res_in) 247 if (res_in)
568 *rinp = res_in 248 *rinp = res_in;
569 if (res_out) 249 if (res_out)
570 *routp = res_o 250 *routp = res_out;
571 if (res_ex) 251 if (res_ex)
572 *rexp = res_ex 252 *rexp = res_ex;
573 cond_resched(); <<
574 } 253 }
575 wait->_qproc = NULL; !! 254 wait = NULL;
576 if (retval || timed_out || sig !! 255 if (retval || !__timeout || signal_pending(current))
577 break; 256 break;
578 if (table.error) { !! 257 if(table.error) {
579 retval = table.error; 258 retval = table.error;
580 break; 259 break;
581 } 260 }
582 !! 261 __timeout = schedule_timeout(__timeout);
583 /* only if found POLL_BUSY_LOO <<
584 if (can_busy_loop && !need_res <<
585 if (!busy_start) { <<
586 busy_start = b <<
587 continue; <<
588 } <<
589 if (!busy_loop_timeout <<
590 continue; <<
591 } <<
592 busy_flag = 0; <<
593 <<
594 /* <<
595 * If this is the first loop a <<
596 * given, then we convert to k <<
597 * pointer to the expiry value <<
598 */ <<
599 if (end_time && !to) { <<
600 expire = timespec64_to <<
601 to = &expire; <<
602 } <<
603 <<
604 if (!poll_schedule_timeout(&ta <<
605 to, <<
606 timed_out = 1; <<
607 } 262 }
>> 263 __set_current_state(TASK_RUNNING);
608 264
609 poll_freewait(&table); 265 poll_freewait(&table);
610 266
>> 267 /*
>> 268 * Up-to-date the caller timeout.
>> 269 */
>> 270 *timeout = __timeout;
611 return retval; 271 return retval;
612 } 272 }
613 273
>> 274 EXPORT_SYMBOL(do_select);
>> 275
>> 276 static void *select_bits_alloc(int size)
>> 277 {
>> 278 return kmalloc(6 * size, GFP_KERNEL);
>> 279 }
>> 280
>> 281 static void select_bits_free(void *bits, int size)
>> 282 {
>> 283 kfree(bits);
>> 284 }
>> 285
614 /* 286 /*
615 * We can actually return ERESTARTSYS instead 287 * We can actually return ERESTARTSYS instead of EINTR, but I'd
616 * like to be certain this leads to no problem 288 * like to be certain this leads to no problems. So I return
617 * EINTR just for safety. 289 * EINTR just for safety.
618 * 290 *
619 * Update: ERESTARTSYS breaks at least the xvi 291 * Update: ERESTARTSYS breaks at least the xview clock binary, so
620 * I'm trying ERESTARTNOHAND which restart onl 292 * I'm trying ERESTARTNOHAND which restart only when you want to.
621 */ 293 */
622 int core_sys_select(int n, fd_set __user *inp, !! 294 #define MAX_SELECT_SECONDS \
623 fd_set __user *exp, !! 295 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
>> 296
>> 297 asmlinkage long
>> 298 sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
624 { 299 {
625 fd_set_bits fds; 300 fd_set_bits fds;
626 void *bits; !! 301 char *bits;
627 int ret, max_fds; !! 302 long timeout;
628 size_t size, alloc_size; !! 303 int ret, size, max_fdset;
629 struct fdtable *fdt; !! 304
630 /* Allocate small arguments on the sta !! 305 timeout = MAX_SCHEDULE_TIMEOUT;
631 long stack_fds[SELECT_STACK_ALLOC/size !! 306 if (tvp) {
>> 307 time_t sec, usec;
>> 308
>> 309 if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
>> 310 || (ret = __get_user(sec, &tvp->tv_sec))
>> 311 || (ret = __get_user(usec, &tvp->tv_usec)))
>> 312 goto out_nofds;
>> 313
>> 314 ret = -EINVAL;
>> 315 if (sec < 0 || usec < 0)
>> 316 goto out_nofds;
>> 317
>> 318 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
>> 319 timeout = ROUND_UP(usec, 1000000/HZ);
>> 320 timeout += sec * (unsigned long) HZ;
>> 321 }
>> 322 }
632 323
633 ret = -EINVAL; 324 ret = -EINVAL;
634 if (n < 0) 325 if (n < 0)
635 goto out_nofds; 326 goto out_nofds;
636 327
637 /* max_fds can increase, so grab it on !! 328 /* max_fdset can increase, so grab it once to avoid race */
638 rcu_read_lock(); !! 329 max_fdset = current->files->max_fdset;
639 fdt = files_fdtable(current->files); !! 330 if (n > max_fdset)
640 max_fds = fdt->max_fds; !! 331 n = max_fdset;
641 rcu_read_unlock(); <<
642 if (n > max_fds) <<
643 n = max_fds; <<
644 332
645 /* 333 /*
646 * We need 6 bitmaps (in/out/ex for bo 334 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
647 * since we used fdset we need to allo 335 * since we used fdset we need to allocate memory in units of
648 * long-words. 336 * long-words.
649 */ 337 */
>> 338 ret = -ENOMEM;
650 size = FDS_BYTES(n); 339 size = FDS_BYTES(n);
651 bits = stack_fds; !! 340 bits = select_bits_alloc(size);
652 if (size > sizeof(stack_fds) / 6) { !! 341 if (!bits)
653 /* Not enough space in on-stac !! 342 goto out_nofds;
654 ret = -ENOMEM; !! 343 fds.in = (unsigned long *) bits;
655 if (size > (SIZE_MAX / 6)) !! 344 fds.out = (unsigned long *) (bits + size);
656 goto out_nofds; !! 345 fds.ex = (unsigned long *) (bits + 2*size);
657 !! 346 fds.res_in = (unsigned long *) (bits + 3*size);
658 alloc_size = 6 * size; !! 347 fds.res_out = (unsigned long *) (bits + 4*size);
659 bits = kvmalloc(alloc_size, GF !! 348 fds.res_ex = (unsigned long *) (bits + 5*size);
660 if (!bits) <<
661 goto out_nofds; <<
662 } <<
663 fds.in = bits; <<
664 fds.out = bits + size; <<
665 fds.ex = bits + 2*size; <<
666 fds.res_in = bits + 3*size; <<
667 fds.res_out = bits + 4*size; <<
668 fds.res_ex = bits + 5*size; <<
669 349
670 if ((ret = get_fd_set(n, inp, fds.in)) 350 if ((ret = get_fd_set(n, inp, fds.in)) ||
671 (ret = get_fd_set(n, outp, fds.out 351 (ret = get_fd_set(n, outp, fds.out)) ||
672 (ret = get_fd_set(n, exp, fds.ex)) 352 (ret = get_fd_set(n, exp, fds.ex)))
673 goto out; 353 goto out;
674 zero_fd_set(n, fds.res_in); 354 zero_fd_set(n, fds.res_in);
675 zero_fd_set(n, fds.res_out); 355 zero_fd_set(n, fds.res_out);
676 zero_fd_set(n, fds.res_ex); 356 zero_fd_set(n, fds.res_ex);
677 357
678 ret = do_select(n, &fds, end_time); !! 358 ret = do_select(n, &fds, &timeout);
>> 359
>> 360 if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
>> 361 time_t sec = 0, usec = 0;
>> 362 if (timeout) {
>> 363 sec = timeout / HZ;
>> 364 usec = timeout % HZ;
>> 365 usec *= (1000000/HZ);
>> 366 }
>> 367 put_user(sec, &tvp->tv_sec);
>> 368 put_user(usec, &tvp->tv_usec);
>> 369 }
679 370
680 if (ret < 0) 371 if (ret < 0)
681 goto out; 372 goto out;
682 if (!ret) { 373 if (!ret) {
683 ret = -ERESTARTNOHAND; 374 ret = -ERESTARTNOHAND;
684 if (signal_pending(current)) 375 if (signal_pending(current))
685 goto out; 376 goto out;
686 ret = 0; 377 ret = 0;
687 } 378 }
688 379
689 if (set_fd_set(n, inp, fds.res_in) || !! 380 set_fd_set(n, inp, fds.res_in);
690 set_fd_set(n, outp, fds.res_out) | !! 381 set_fd_set(n, outp, fds.res_out);
691 set_fd_set(n, exp, fds.res_ex)) !! 382 set_fd_set(n, exp, fds.res_ex);
692 ret = -EFAULT; <<
693 383
694 out: 384 out:
695 if (bits != stack_fds) !! 385 select_bits_free(bits, size);
696 kvfree(bits); <<
697 out_nofds: 386 out_nofds:
698 return ret; 387 return ret;
699 } 388 }
700 389
701 static int kern_select(int n, fd_set __user *i <<
702 fd_set __user *exp, str <<
703 { <<
704 struct timespec64 end_time, *to = NULL <<
705 struct __kernel_old_timeval tv; <<
706 int ret; <<
707 <<
708 if (tvp) { <<
709 if (copy_from_user(&tv, tvp, s <<
710 return -EFAULT; <<
711 <<
712 to = &end_time; <<
713 if (poll_select_set_timeout(to <<
714 tv.tv_sec + (t <<
715 (tv.tv_usec % <<
716 return -EINVAL; <<
717 } <<
718 <<
719 ret = core_sys_select(n, inp, outp, ex <<
720 return poll_select_finish(&end_time, t <<
721 } <<
722 <<
723 SYSCALL_DEFINE5(select, int, n, fd_set __user <<
724 fd_set __user *, exp, struct _ <<
725 { <<
726 return kern_select(n, inp, outp, exp, <<
727 } <<
728 <<
729 static long do_pselect(int n, fd_set __user *i <<
730 fd_set __user *exp, voi <<
731 const sigset_t __user * <<
732 enum poll_time_type typ <<
733 { <<
734 struct timespec64 ts, end_time, *to = <<
735 int ret; <<
736 <<
737 if (tsp) { <<
738 switch (type) { <<
739 case PT_TIMESPEC: <<
740 if (get_timespec64(&ts <<
741 return -EFAULT <<
742 break; <<
743 case PT_OLD_TIMESPEC: <<
744 if (get_old_timespec32 <<
745 return -EFAULT <<
746 break; <<
747 default: <<
748 BUG(); <<
749 } <<
750 <<
751 to = &end_time; <<
752 if (poll_select_set_timeout(to <<
753 return -EINVAL; <<
754 } <<
755 <<
756 ret = set_user_sigmask(sigmask, sigset <<
757 if (ret) <<
758 return ret; <<
759 <<
760 ret = core_sys_select(n, inp, outp, ex <<
761 return poll_select_finish(&end_time, t <<
762 } <<
763 <<
764 /* <<
765 * Most architectures can't handle 7-argument <<
766 * 6-argument version where the sixth argument <<
767 * which has a pointer to the sigset_t itself <<
768 * the sigset size. <<
769 */ <<
770 struct sigset_argpack { <<
771 sigset_t __user *p; <<
772 size_t size; <<
773 }; <<
774 <<
775 static inline int get_sigset_argpack(struct si <<
776 struct si <<
777 { <<
778 // the path is hot enough for overhead <<
779 if (from) { <<
780 if (can_do_masked_user_access( <<
781 from = masked_user_acc <<
782 else if (!user_read_access_beg <<
783 return -EFAULT; <<
784 unsafe_get_user(to->p, &from-> <<
785 unsafe_get_user(to->size, &fro <<
786 user_read_access_end(); <<
787 } <<
788 return 0; <<
789 Efault: <<
790 user_access_end(); <<
791 return -EFAULT; <<
792 } <<
793 <<
794 SYSCALL_DEFINE6(pselect6, int, n, fd_set __use <<
795 fd_set __user *, exp, struct _ <<
796 void __user *, sig) <<
797 { <<
798 struct sigset_argpack x = {NULL, 0}; <<
799 <<
800 if (get_sigset_argpack(&x, sig)) <<
801 return -EFAULT; <<
802 <<
803 return do_pselect(n, inp, outp, exp, t <<
804 } <<
805 <<
806 #if defined(CONFIG_COMPAT_32BIT_TIME) && !defi <<
807 <<
808 SYSCALL_DEFINE6(pselect6_time32, int, n, fd_se <<
809 fd_set __user *, exp, struct o <<
810 void __user *, sig) <<
811 { <<
812 struct sigset_argpack x = {NULL, 0}; <<
813 <<
814 if (get_sigset_argpack(&x, sig)) <<
815 return -EFAULT; <<
816 <<
817 return do_pselect(n, inp, outp, exp, t <<
818 } <<
819 <<
820 #endif <<
821 <<
822 #ifdef __ARCH_WANT_SYS_OLD_SELECT <<
823 struct sel_arg_struct { <<
824 unsigned long n; <<
825 fd_set __user *inp, *outp, *exp; <<
826 struct __kernel_old_timeval __user *tv <<
827 }; <<
828 <<
829 SYSCALL_DEFINE1(old_select, struct sel_arg_str <<
830 { <<
831 struct sel_arg_struct a; <<
832 <<
833 if (copy_from_user(&a, arg, sizeof(a)) <<
834 return -EFAULT; <<
835 return kern_select(a.n, a.inp, a.outp, <<
836 } <<
837 #endif <<
838 <<
839 struct poll_list { 390 struct poll_list {
840 struct poll_list *next; 391 struct poll_list *next;
841 unsigned int len; !! 392 int len;
842 struct pollfd entries[] __counted_by(l !! 393 struct pollfd entries[0];
843 }; 394 };
844 395
845 #define POLLFD_PER_PAGE ((PAGE_SIZE-sizeof(st 396 #define POLLFD_PER_PAGE ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
846 397
847 /* !! 398 static void do_pollfd(unsigned int num, struct pollfd * fdpage,
848 * Fish for pollable events on the pollfd->fd !! 399 poll_table ** pwait, int *count)
849 * interested in events matching the pollfd->e <<
850 * matching that mask is both recorded in poll <<
851 * pwait poll_table will be used by the fd-pro <<
852 * if pwait->_qproc is non-NULL. <<
853 */ <<
854 static inline __poll_t do_pollfd(struct pollfd <<
855 bool *can <<
856 __poll_t <<
857 { 400 {
858 int fd = pollfd->fd; !! 401 int i;
859 __poll_t mask = 0, filter; <<
860 struct fd f; <<
861 <<
862 if (fd < 0) <<
863 goto out; <<
864 mask = EPOLLNVAL; <<
865 f = fdget(fd); <<
866 if (!fd_file(f)) <<
867 goto out; <<
868 <<
869 /* userland u16 ->events contains POLL <<
870 filter = demangle_poll(pollfd->events) <<
871 pwait->_key = filter | busy_flag; <<
872 mask = vfs_poll(fd_file(f), pwait); <<
873 if (mask & busy_flag) <<
874 *can_busy_poll = true; <<
875 mask &= filter; /* Mask out un <<
876 fdput(f); <<
877 402
878 out: !! 403 for (i = 0; i < num; i++) {
879 /* ... and so does ->revents */ !! 404 int fd;
880 pollfd->revents = mangle_poll(mask); !! 405 unsigned int mask;
881 return mask; !! 406 struct pollfd *fdp;
>> 407
>> 408 mask = 0;
>> 409 fdp = fdpage+i;
>> 410 fd = fdp->fd;
>> 411 if (fd >= 0) {
>> 412 struct file * file = fget(fd);
>> 413 mask = POLLNVAL;
>> 414 if (file != NULL) {
>> 415 mask = DEFAULT_POLLMASK;
>> 416 if (file->f_op && file->f_op->poll)
>> 417 mask = file->f_op->poll(file, *pwait);
>> 418 mask &= fdp->events | POLLERR | POLLHUP;
>> 419 fput(file);
>> 420 }
>> 421 if (mask) {
>> 422 *pwait = NULL;
>> 423 (*count)++;
>> 424 }
>> 425 }
>> 426 fdp->revents = mask;
>> 427 }
882 } 428 }
883 429
884 static int do_poll(struct poll_list *list, str !! 430 static int do_poll(unsigned int nfds, struct poll_list *list,
885 struct timespec64 *end_time !! 431 struct poll_wqueues *wait, long timeout)
886 { 432 {
>> 433 int count = 0;
887 poll_table* pt = &wait->pt; 434 poll_table* pt = &wait->pt;
888 ktime_t expire, *to = NULL; <<
889 int timed_out = 0, count = 0; <<
890 u64 slack = 0; <<
891 __poll_t busy_flag = net_busy_loop_on( <<
892 unsigned long busy_start = 0; <<
893 <<
894 /* Optimise the no-wait case */ <<
895 if (end_time && !end_time->tv_sec && ! <<
896 pt->_qproc = NULL; <<
897 timed_out = 1; <<
898 } <<
899 <<
900 if (end_time && !timed_out) <<
901 slack = select_estimate_accura <<
902 435
>> 436 if (!timeout)
>> 437 pt = NULL;
>> 438
903 for (;;) { 439 for (;;) {
904 struct poll_list *walk; 440 struct poll_list *walk;
905 bool can_busy_loop = false; !! 441 set_current_state(TASK_INTERRUPTIBLE);
906 !! 442 walk = list;
907 for (walk = list; walk != NULL !! 443 while(walk != NULL) {
908 struct pollfd * pfd, * !! 444 do_pollfd( walk->len, walk->entries, &pt, &count);
909 !! 445 walk = walk->next;
910 pfd = walk->entries; <<
911 pfd_end = pfd + walk-> <<
912 for (; pfd != pfd_end; <<
913 /* <<
914 * Fish for ev <<
915 * and kill po <<
916 * needlessly <<
917 * this. They' <<
918 * when we bre <<
919 */ <<
920 if (do_pollfd( <<
921 <<
922 count+ <<
923 pt->_q <<
924 /* fou <<
925 busy_f <<
926 can_bu <<
927 } <<
928 } <<
929 } <<
930 /* <<
931 * All waiters have already be <<
932 * a poll_table->_qproc to the <<
933 */ <<
934 pt->_qproc = NULL; <<
935 if (!count) { <<
936 count = wait->error; <<
937 if (signal_pending(cur <<
938 count = -EREST <<
939 } 446 }
940 if (count || timed_out) !! 447 pt = NULL;
>> 448 if (count || !timeout || signal_pending(current))
941 break; 449 break;
942 !! 450 count = wait->error;
943 /* only if found POLL_BUSY_LOO !! 451 if (count)
944 if (can_busy_loop && !need_res !! 452 break;
945 if (!busy_start) { !! 453 timeout = schedule_timeout(timeout);
946 busy_start = b <<
947 continue; <<
948 } <<
949 if (!busy_loop_timeout <<
950 continue; <<
951 } <<
952 busy_flag = 0; <<
953 <<
954 /* <<
955 * If this is the first loop a <<
956 * given, then we convert to k <<
957 * pointer to the expiry value <<
958 */ <<
959 if (end_time && !to) { <<
960 expire = timespec64_to <<
961 to = &expire; <<
962 } <<
963 <<
964 if (!poll_schedule_timeout(wai <<
965 timed_out = 1; <<
966 } 454 }
>> 455 __set_current_state(TASK_RUNNING);
967 return count; 456 return count;
968 } 457 }
969 458
970 #define N_STACK_PPS ((sizeof(stack_pps) - size !! 459 asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout)
971 sizeof(struct pollfd)) <<
972 <<
973 static int do_sys_poll(struct pollfd __user *u <<
974 struct timespec64 *end_time) <<
975 { 460 {
976 struct poll_wqueues table; 461 struct poll_wqueues table;
977 int err = -EFAULT, fdcount; !! 462 int fdcount, err;
978 /* Allocate small arguments on the sta !! 463 unsigned int i;
979 faster - use long to make sure the !! 464 struct poll_list *head;
980 on 64 bit archs to avoid unaligned !! 465 struct poll_list *walk;
981 long stack_pps[POLL_STACK_ALLOC/sizeof <<
982 struct poll_list *const head = (struct <<
983 struct poll_list *walk = head; <<
984 unsigned int todo = nfds; <<
985 unsigned int len; <<
986 466
987 if (nfds > rlimit(RLIMIT_NOFILE)) !! 467 /* Do a sanity check on nfds ... */
>> 468 if (nfds > current->files->max_fdset && nfds > OPEN_MAX)
988 return -EINVAL; 469 return -EINVAL;
989 470
990 len = min_t(unsigned int, nfds, N_STAC !! 471 if (timeout) {
991 for (;;) { !! 472 /* Careful about overflow in the intermediate values */
992 walk->next = NULL; !! 473 if ((unsigned long) timeout < MAX_SCHEDULE_TIMEOUT / HZ)
993 walk->len = len; !! 474 timeout = (unsigned long)(timeout*HZ+999)/1000+1;
994 if (!len) !! 475 else /* Negative or overflow */
995 break; !! 476 timeout = MAX_SCHEDULE_TIMEOUT;
996 !! 477 }
997 if (copy_from_user(walk->entri <<
998 sizeof <<
999 goto out_fds; <<
1000 478
1001 if (walk->len >= todo) !! 479 poll_initwait(&table);
1002 break; <<
1003 todo -= walk->len; <<
1004 480
1005 len = min(todo, POLLFD_PER_PA !! 481 head = NULL;
1006 walk = walk->next = kmalloc(s !! 482 walk = NULL;
1007 G !! 483 i = nfds;
1008 if (!walk) { !! 484 err = -ENOMEM;
1009 err = -ENOMEM; !! 485 while(i!=0) {
>> 486 struct poll_list *pp;
>> 487 pp = kmalloc(sizeof(struct poll_list)+
>> 488 sizeof(struct pollfd)*
>> 489 (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i),
>> 490 GFP_KERNEL);
>> 491 if(pp==NULL)
>> 492 goto out_fds;
>> 493 pp->next=NULL;
>> 494 pp->len = (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i);
>> 495 if (head == NULL)
>> 496 head = pp;
>> 497 else
>> 498 walk->next = pp;
>> 499
>> 500 walk = pp;
>> 501 if (copy_from_user(pp->entries, ufds + nfds-i,
>> 502 sizeof(struct pollfd)*pp->len)) {
>> 503 err = -EFAULT;
1010 goto out_fds; 504 goto out_fds;
1011 } 505 }
>> 506 i -= pp->len;
1012 } 507 }
>> 508 fdcount = do_poll(nfds, head, &table, timeout);
1013 509
1014 poll_initwait(&table); !! 510 /* OK, now copy the revents fields back to user space. */
1015 fdcount = do_poll(head, &table, end_t !! 511 walk = head;
1016 poll_freewait(&table); !! 512 err = -EFAULT;
1017 !! 513 while(walk != NULL) {
1018 if (!user_write_access_begin(ufds, nf <<
1019 goto out_fds; <<
1020 <<
1021 for (walk = head; walk; walk = walk-> <<
1022 struct pollfd *fds = walk->en 514 struct pollfd *fds = walk->entries;
1023 unsigned int j; !! 515 int j;
1024 516
1025 for (j = walk->len; j; fds++, !! 517 for (j=0; j < walk->len; j++, ufds++) {
1026 unsafe_put_user(fds-> !! 518 if(__put_user(fds[j].revents, &ufds->revents))
>> 519 goto out_fds;
>> 520 }
>> 521 walk = walk->next;
1027 } 522 }
1028 user_write_access_end(); <<
1029 <<
1030 err = fdcount; 523 err = fdcount;
>> 524 if (!fdcount && signal_pending(current))
>> 525 err = -EINTR;
1031 out_fds: 526 out_fds:
1032 walk = head->next; !! 527 walk = head;
1033 while (walk) { !! 528 while(walk!=NULL) {
1034 struct poll_list *pos = walk; !! 529 struct poll_list *pp = walk->next;
1035 walk = walk->next; !! 530 kfree(walk);
1036 kfree(pos); !! 531 walk = pp;
1037 } 532 }
1038 !! 533 poll_freewait(&table);
1039 return err; 534 return err;
1040 <<
1041 Efault: <<
1042 user_write_access_end(); <<
1043 err = -EFAULT; <<
1044 goto out_fds; <<
1045 } <<
1046 <<
1047 static long do_restart_poll(struct restart_bl <<
1048 { <<
1049 struct pollfd __user *ufds = restart_ <<
1050 int nfds = restart_block->poll.nfds; <<
1051 struct timespec64 *to = NULL, end_tim <<
1052 int ret; <<
1053 <<
1054 if (restart_block->poll.has_timeout) <<
1055 end_time.tv_sec = restart_blo <<
1056 end_time.tv_nsec = restart_bl <<
1057 to = &end_time; <<
1058 } <<
1059 <<
1060 ret = do_sys_poll(ufds, nfds, to); <<
1061 <<
1062 if (ret == -ERESTARTNOHAND) <<
1063 ret = set_restart_fn(restart_ <<
1064 <<
1065 return ret; <<
1066 } <<
1067 <<
1068 SYSCALL_DEFINE3(poll, struct pollfd __user *, <<
1069 int, timeout_msecs) <<
1070 { <<
1071 struct timespec64 end_time, *to = NUL <<
1072 int ret; <<
1073 <<
1074 if (timeout_msecs >= 0) { <<
1075 to = &end_time; <<
1076 poll_select_set_timeout(to, t <<
1077 NSEC_PER_MSEC * (time <<
1078 } <<
1079 <<
1080 ret = do_sys_poll(ufds, nfds, to); <<
1081 <<
1082 if (ret == -ERESTARTNOHAND) { <<
1083 struct restart_block *restart <<
1084 <<
1085 restart_block = ¤t->res <<
1086 restart_block->poll.ufds = uf <<
1087 restart_block->poll.nfds = nf <<
1088 <<
1089 if (timeout_msecs >= 0) { <<
1090 restart_block->poll.t <<
1091 restart_block->poll.t <<
1092 restart_block->poll.h <<
1093 } else <<
1094 restart_block->poll.h <<
1095 <<
1096 ret = set_restart_fn(restart_ <<
1097 } <<
1098 return ret; <<
1099 } <<
1100 <<
1101 SYSCALL_DEFINE5(ppoll, struct pollfd __user * <<
1102 struct __kernel_timespec __us <<
1103 size_t, sigsetsize) <<
1104 { <<
1105 struct timespec64 ts, end_time, *to = <<
1106 int ret; <<
1107 <<
1108 if (tsp) { <<
1109 if (get_timespec64(&ts, tsp)) <<
1110 return -EFAULT; <<
1111 <<
1112 to = &end_time; <<
1113 if (poll_select_set_timeout(t <<
1114 return -EINVAL; <<
1115 } <<
1116 <<
1117 ret = set_user_sigmask(sigmask, sigse <<
1118 if (ret) <<
1119 return ret; <<
1120 <<
1121 ret = do_sys_poll(ufds, nfds, to); <<
1122 return poll_select_finish(&end_time, <<
1123 } <<
1124 <<
1125 #if defined(CONFIG_COMPAT_32BIT_TIME) && !def <<
1126 <<
1127 SYSCALL_DEFINE5(ppoll_time32, struct pollfd _ <<
1128 struct old_timespec32 __user <<
1129 size_t, sigsetsize) <<
1130 { <<
1131 struct timespec64 ts, end_time, *to = <<
1132 int ret; <<
1133 <<
1134 if (tsp) { <<
1135 if (get_old_timespec32(&ts, t <<
1136 return -EFAULT; <<
1137 <<
1138 to = &end_time; <<
1139 if (poll_select_set_timeout(t <<
1140 return -EINVAL; <<
1141 } <<
1142 <<
1143 ret = set_user_sigmask(sigmask, sigse <<
1144 if (ret) <<
1145 return ret; <<
1146 <<
1147 ret = do_sys_poll(ufds, nfds, to); <<
1148 return poll_select_finish(&end_time, <<
1149 } <<
1150 #endif <<
1151 <<
1152 #ifdef CONFIG_COMPAT <<
1153 #define __COMPAT_NFDBITS (8 * sizeof(co <<
1154 <<
1155 /* <<
1156 * Ooo, nasty. We need here to frob 32-bit u <<
1157 * 64-bit unsigned longs. <<
1158 */ <<
1159 static <<
1160 int compat_get_fd_set(unsigned long nr, compa <<
1161 unsigned long *fdset) <<
1162 { <<
1163 if (ufdset) { <<
1164 return compat_get_bitmap(fdse <<
1165 } else { <<
1166 zero_fd_set(nr, fdset); <<
1167 return 0; <<
1168 } <<
1169 } <<
1170 <<
1171 static <<
1172 int compat_set_fd_set(unsigned long nr, compa <<
1173 unsigned long *fdset) <<
1174 { <<
1175 if (!ufdset) <<
1176 return 0; <<
1177 return compat_put_bitmap(ufdset, fdse <<
1178 } <<
1179 <<
1180 <<
1181 /* <<
1182 * This is a virtual copy of sys_select from <<
1183 * should be compared to it from time to time <<
1184 */ <<
1185 <<
1186 /* <<
1187 * We can actually return ERESTARTSYS instead <<
1188 * like to be certain this leads to no proble <<
1189 * EINTR just for safety. <<
1190 * <<
1191 * Update: ERESTARTSYS breaks at least the xv <<
1192 * I'm trying ERESTARTNOHAND which restart on <<
1193 */ <<
1194 static int compat_core_sys_select(int n, comp <<
1195 compat_ulong_t __user *outp, compat_u <<
1196 struct timespec64 *end_time) <<
1197 { <<
1198 fd_set_bits fds; <<
1199 void *bits; <<
1200 int size, max_fds, ret = -EINVAL; <<
1201 struct fdtable *fdt; <<
1202 long stack_fds[SELECT_STACK_ALLOC/siz <<
1203 <<
1204 if (n < 0) <<
1205 goto out_nofds; <<
1206 <<
1207 /* max_fds can increase, so grab it o <<
1208 rcu_read_lock(); <<
1209 fdt = files_fdtable(current->files); <<
1210 max_fds = fdt->max_fds; <<
1211 rcu_read_unlock(); <<
1212 if (n > max_fds) <<
1213 n = max_fds; <<
1214 <<
1215 /* <<
1216 * We need 6 bitmaps (in/out/ex for b <<
1217 * since we used fdset we need to all <<
1218 * long-words. <<
1219 */ <<
1220 size = FDS_BYTES(n); <<
1221 bits = stack_fds; <<
1222 if (size > sizeof(stack_fds) / 6) { <<
1223 bits = kmalloc_array(6, size, <<
1224 ret = -ENOMEM; <<
1225 if (!bits) <<
1226 goto out_nofds; <<
1227 } <<
1228 fds.in = (unsigned long *) bits <<
1229 fds.out = (unsigned long *) (bits <<
1230 fds.ex = (unsigned long *) (bits <<
1231 fds.res_in = (unsigned long *) (bits <<
1232 fds.res_out = (unsigned long *) (bits <<
1233 fds.res_ex = (unsigned long *) (bits <<
1234 <<
1235 if ((ret = compat_get_fd_set(n, inp, <<
1236 (ret = compat_get_fd_set(n, outp, <<
1237 (ret = compat_get_fd_set(n, exp, <<
1238 goto out; <<
1239 zero_fd_set(n, fds.res_in); <<
1240 zero_fd_set(n, fds.res_out); <<
1241 zero_fd_set(n, fds.res_ex); <<
1242 <<
1243 ret = do_select(n, &fds, end_time); <<
1244 <<
1245 if (ret < 0) <<
1246 goto out; <<
1247 if (!ret) { <<
1248 ret = -ERESTARTNOHAND; <<
1249 if (signal_pending(current)) <<
1250 goto out; <<
1251 ret = 0; <<
1252 } <<
1253 <<
1254 if (compat_set_fd_set(n, inp, fds.res <<
1255 compat_set_fd_set(n, outp, fds.re <<
1256 compat_set_fd_set(n, exp, fds.res <<
1257 ret = -EFAULT; <<
1258 out: <<
1259 if (bits != stack_fds) <<
1260 kfree(bits); <<
1261 out_nofds: <<
1262 return ret; <<
1263 } <<
1264 <<
1265 static int do_compat_select(int n, compat_ulo <<
1266 compat_ulong_t __user *outp, compat_u <<
1267 struct old_timeval32 __user *tvp) <<
1268 { <<
1269 struct timespec64 end_time, *to = NUL <<
1270 struct old_timeval32 tv; <<
1271 int ret; <<
1272 <<
1273 if (tvp) { <<
1274 if (copy_from_user(&tv, tvp, <<
1275 return -EFAULT; <<
1276 <<
1277 to = &end_time; <<
1278 if (poll_select_set_timeout(t <<
1279 tv.tv_sec + ( <<
1280 (tv.tv_usec % <<
1281 return -EINVAL; <<
1282 } <<
1283 <<
1284 ret = compat_core_sys_select(n, inp, <<
1285 return poll_select_finish(&end_time, <<
1286 } <<
1287 <<
1288 COMPAT_SYSCALL_DEFINE5(select, int, n, compat <<
1289 compat_ulong_t __user *, outp, compat <<
1290 struct old_timeval32 __user *, tvp) <<
1291 { <<
1292 return do_compat_select(n, inp, outp, <<
1293 } <<
1294 <<
1295 struct compat_sel_arg_struct { <<
1296 compat_ulong_t n; <<
1297 compat_uptr_t inp; <<
1298 compat_uptr_t outp; <<
1299 compat_uptr_t exp; <<
1300 compat_uptr_t tvp; <<
1301 }; <<
1302 <<
1303 COMPAT_SYSCALL_DEFINE1(old_select, struct com <<
1304 { <<
1305 struct compat_sel_arg_struct a; <<
1306 <<
1307 if (copy_from_user(&a, arg, sizeof(a) <<
1308 return -EFAULT; <<
1309 return do_compat_select(a.n, compat_p <<
1310 compat_ptr(a. <<
1311 } <<
1312 <<
1313 static long do_compat_pselect(int n, compat_u <<
1314 compat_ulong_t __user *outp, compat_u <<
1315 void __user *tsp, compat_sigset_t __u <<
1316 compat_size_t sigsetsize, enum poll_t <<
1317 { <<
1318 struct timespec64 ts, end_time, *to = <<
1319 int ret; <<
1320 <<
1321 if (tsp) { <<
1322 switch (type) { <<
1323 case PT_OLD_TIMESPEC: <<
1324 if (get_old_timespec3 <<
1325 return -EFAUL <<
1326 break; <<
1327 case PT_TIMESPEC: <<
1328 if (get_timespec64(&t <<
1329 return -EFAUL <<
1330 break; <<
1331 default: <<
1332 BUG(); <<
1333 } <<
1334 <<
1335 to = &end_time; <<
1336 if (poll_select_set_timeout(t <<
1337 return -EINVAL; <<
1338 } <<
1339 <<
1340 ret = set_compat_user_sigmask(sigmask <<
1341 if (ret) <<
1342 return ret; <<
1343 <<
1344 ret = compat_core_sys_select(n, inp, <<
1345 return poll_select_finish(&end_time, <<
1346 } 535 }
1347 <<
1348 struct compat_sigset_argpack { <<
1349 compat_uptr_t p; <<
1350 compat_size_t size; <<
1351 }; <<
1352 static inline int get_compat_sigset_argpack(s <<
1353 s <<
1354 { <<
1355 if (from) { <<
1356 if (!user_read_access_begin(f <<
1357 return -EFAULT; <<
1358 unsafe_get_user(to->p, &from- <<
1359 unsafe_get_user(to->size, &fr <<
1360 user_read_access_end(); <<
1361 } <<
1362 return 0; <<
1363 Efault: <<
1364 user_access_end(); <<
1365 return -EFAULT; <<
1366 } <<
1367 <<
1368 COMPAT_SYSCALL_DEFINE6(pselect6_time64, int, <<
1369 compat_ulong_t __user *, outp, compat <<
1370 struct __kernel_timespec __user *, ts <<
1371 { <<
1372 struct compat_sigset_argpack x = {0, <<
1373 <<
1374 if (get_compat_sigset_argpack(&x, sig <<
1375 return -EFAULT; <<
1376 <<
1377 return do_compat_pselect(n, inp, outp <<
1378 x.size, PT_T <<
1379 } <<
1380 <<
1381 #if defined(CONFIG_COMPAT_32BIT_TIME) <<
1382 <<
1383 COMPAT_SYSCALL_DEFINE6(pselect6_time32, int, <<
1384 compat_ulong_t __user *, outp, compat <<
1385 struct old_timespec32 __user *, tsp, <<
1386 { <<
1387 struct compat_sigset_argpack x = {0, <<
1388 <<
1389 if (get_compat_sigset_argpack(&x, sig <<
1390 return -EFAULT; <<
1391 <<
1392 return do_compat_pselect(n, inp, outp <<
1393 x.size, PT_O <<
1394 } <<
1395 <<
1396 #endif <<
1397 <<
1398 #if defined(CONFIG_COMPAT_32BIT_TIME) <<
1399 COMPAT_SYSCALL_DEFINE5(ppoll_time32, struct p <<
1400 unsigned int, nfds, struct old_times <<
1401 const compat_sigset_t __user *, sigma <<
1402 { <<
1403 struct timespec64 ts, end_time, *to = <<
1404 int ret; <<
1405 <<
1406 if (tsp) { <<
1407 if (get_old_timespec32(&ts, t <<
1408 return -EFAULT; <<
1409 <<
1410 to = &end_time; <<
1411 if (poll_select_set_timeout(t <<
1412 return -EINVAL; <<
1413 } <<
1414 <<
1415 ret = set_compat_user_sigmask(sigmask <<
1416 if (ret) <<
1417 return ret; <<
1418 <<
1419 ret = do_sys_poll(ufds, nfds, to); <<
1420 return poll_select_finish(&end_time, <<
1421 } <<
1422 #endif <<
1423 <<
1424 /* New compat syscall for 64 bit time_t*/ <<
1425 COMPAT_SYSCALL_DEFINE5(ppoll_time64, struct p <<
1426 unsigned int, nfds, struct __kernel_ <<
1427 const compat_sigset_t __user *, sigma <<
1428 { <<
1429 struct timespec64 ts, end_time, *to = <<
1430 int ret; <<
1431 <<
1432 if (tsp) { <<
1433 if (get_timespec64(&ts, tsp)) <<
1434 return -EFAULT; <<
1435 <<
1436 to = &end_time; <<
1437 if (poll_select_set_timeout(t <<
1438 return -EINVAL; <<
1439 } <<
1440 <<
1441 ret = set_compat_user_sigmask(sigmask <<
1442 if (ret) <<
1443 return ret; <<
1444 <<
1445 ret = do_sys_poll(ufds, nfds, to); <<
1446 return poll_select_finish(&end_time, <<
1447 } <<
1448 <<
1449 #endif <<
1450 536
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.