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