forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 9999e48639b3cecb08ffb37358bcba3b48161b29 
 kernel/fs/aio.c
....@@ -27,7 +27,6 @@
2727 #include <linux/file.h>
2828 #include <linux/mm.h>
2929 #include <linux/mman.h>
30
-#include <linux/mmu_context.h>
3130 #include <linux/percpu.h>
3231 #include <linux/slab.h>
3332 #include <linux/timer.h>
....@@ -42,6 +41,7 @@
4241 #include <linux/ramfs.h>
4342 #include <linux/percpu-refcount.h>
4443 #include <linux/mount.h>
44
+#include <linux/pseudo_fs.h>
4545 
4646 #include <asm/kmap_types.h>
4747 #include <linux/uaccess.h>
....@@ -67,8 +67,14 @@
6767 	unsigned	header_length;	/* size of aio_ring */
6868 
6969 
70
-	struct io_event		io_events[0];
70
+	struct io_event		io_events[];
7171 }; /* 128 bytes + ring size */
72
+
73
+/*
74
+ * Plugging is meant to work with larger batches of IOs. If we don't
75
+ * have more than the below, then don't bother setting up a plug.
76
+ */
77
+#define AIO_PLUG_THRESHOLD	2
7278 
7379 #define AIO_RING_PAGES	8
7480 
....@@ -245,15 +251,12 @@
245251 	return file;
246252 }
247253 
248
-static struct dentry *aio_mount(struct file_system_type *fs_type,
249
-				int flags, const char *dev_name, void *data)
254
+static int aio_init_fs_context(struct fs_context *fc)
250255 {
251
-	struct dentry *root = mount_pseudo(fs_type, "aio:", NULL, NULL,
252
-					   AIO_RING_MAGIC);
253
-
254
-	if (!IS_ERR(root))
255
-		root->d_sb->s_iflags |= SB_I_NOEXEC;
256
-	return root;
256
+	if (!init_pseudo(fc, AIO_RING_MAGIC))
257
+		return -ENOMEM;
258
+	fc->s_iflags |= SB_I_NOEXEC;
259
+	return 0;
257260 }
258261 
259262 /* aio_setup
....@@ -264,7 +267,7 @@
264267 {
265268 	static struct file_system_type aio_fs = {
266269 		.name		= "aio",
267
-		.mount		= aio_mount,
270
+		.init_fs_context = aio_init_fs_context,
268271 		.kill_sb	= kill_anon_super,
269272 	};
270273 	aio_mnt = kern_mount(&aio_fs);
....@@ -332,6 +335,9 @@
332335 	spin_lock(&mm->ioctx_lock);
333336 	rcu_read_lock();
334337 	table = rcu_dereference(mm->ioctx_table);
338
+	if (!table)
339
+		goto out_unlock;
340
+
335341 	for (i = 0; i < table->nr; i++) {
336342 		struct kioctx *ctx;
337343 
....@@ -345,6 +351,7 @@
345351 		}
346352 	}
347353 
354
+out_unlock:
348355 	rcu_read_unlock();
349356 	spin_unlock(&mm->ioctx_lock);
350357 	return res;
....@@ -421,7 +428,7 @@
421428 	BUG_ON(PageWriteback(old));
422429 	get_page(new);
423430 
424
-	rc = migrate_page_move_mapping(mapping, new, old, NULL, mode, 1);
431
+	rc = migrate_page_move_mapping(mapping, new, old, 1);
425432 	if (rc != MIGRATEPAGE_SUCCESS) {
426433 		put_page(new);
427434 		goto out_unlock;
....@@ -517,16 +524,16 @@
517524 	ctx->mmap_size = nr_pages * PAGE_SIZE;
518525 	pr_debug("attempting mmap of %lu bytes\n", ctx->mmap_size);
519526 
520
-	if (down_write_killable(&mm->mmap_sem)) {
527
+	if (mmap_write_lock_killable(mm)) {
521528 		ctx->mmap_size = 0;
522529 		aio_free_ring(ctx);
523530 		return -EINTR;
524531 	}
525532 
526
-	ctx->mmap_base = do_mmap_pgoff(ctx->aio_ring_file, 0, ctx->mmap_size,
527
-				       PROT_READ | PROT_WRITE,
528
-				       MAP_SHARED, 0, &unused, NULL);
529
-	up_write(&mm->mmap_sem);
533
+	ctx->mmap_base = do_mmap(ctx->aio_ring_file, 0, ctx->mmap_size,
534
+				 PROT_READ | PROT_WRITE,
535
+				 MAP_SHARED, 0, &unused, NULL);
536
+	mmap_write_unlock(mm);
530537 	if (IS_ERR((void *)ctx->mmap_base)) {
531538 		ctx->mmap_size = 0;
532539 		aio_free_ring(ctx);
....@@ -1029,6 +1036,11 @@
10291036 	if (unlikely(!req))
10301037 		return NULL;
10311038 
1039
+	if (unlikely(!get_reqs_available(ctx))) {
1040
+		kmem_cache_free(kiocb_cachep, req);
1041
+		return NULL;
1042
+	}
1043
+
10321044 	percpu_ref_get(&ctx->reqs);
10331045 	req->ki_ctx = ctx;
10341046 	INIT_LIST_HEAD(&req->ki_list);
....@@ -1067,6 +1079,8 @@
10671079 
10681080 static inline void iocb_destroy(struct aio_kiocb *iocb)
10691081 {
1082
+	if (iocb->ki_eventfd)
1083
+		eventfd_ctx_put(iocb->ki_eventfd);
10701084 	if (iocb->ki_filp)
10711085 		fput(iocb->ki_filp);
10721086 	percpu_ref_put(&iocb->ki_ctx->reqs);
....@@ -1134,10 +1148,8 @@
11341148 	 * eventfd. The eventfd_signal() function is safe to be called
11351149 	 * from IRQ context.
11361150 	 */
1137
-	if (iocb->ki_eventfd) {
1151
+	if (iocb->ki_eventfd)
11381152 		eventfd_signal(iocb->ki_eventfd, 1);
1139
-		eventfd_ctx_put(iocb->ki_eventfd);
1140
-	}
11411153 
11421154 	/*
11431155 	 * We have to order our ring_info tail store above and test
....@@ -1460,7 +1472,7 @@
14601472 
14611473 		req->ki_ioprio = iocb->aio_reqprio;
14621474 	} else
1463
-		req->ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
1475
+		req->ki_ioprio = get_current_ioprio();
14641476 
14651477 	ret = kiocb_set_rw_flags(req, iocb->aio_rw_flags);
14661478 	if (unlikely(ret))
....@@ -1470,8 +1482,9 @@
14701482 	return 0;
14711483 }
14721484 
1473
-static int aio_setup_rw(int rw, const struct iocb *iocb, struct iovec **iovec,
1474
-		bool vectored, bool compat, struct iov_iter *iter)
1485
+static ssize_t aio_setup_rw(int rw, const struct iocb *iocb,
1486
+		struct iovec **iovec, bool vectored, bool compat,
1487
+		struct iov_iter *iter)
14751488 {
14761489 	void __user *buf = (void __user *)(uintptr_t)iocb->aio_buf;
14771490 	size_t len = iocb->aio_nbytes;
....@@ -1481,12 +1494,8 @@
14811494 		*iovec = NULL;
14821495 		return ret;
14831496 	}
1484
-#ifdef CONFIG_COMPAT
1485
-	if (compat)
1486
-		return compat_import_iovec(rw, buf, len, UIO_FASTIOV, iovec,
1487
-				iter);
1488
-#endif
1489
-	return import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter);
1497
+
1498
+	return __import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter, compat);
14901499 }
14911500 
14921501 static inline void aio_rw_done(struct kiocb *req, ssize_t ret)
....@@ -1503,19 +1512,19 @@
15031512 		 * may be already running. Just fail this IO with EINTR.
15041513 		 */
15051514 		ret = -EINTR;
1506
-		/*FALLTHRU*/
1515
+		fallthrough;
15071516 	default:
15081517 		req->ki_complete(req, ret, 0);
15091518 	}
15101519 }
15111520 
1512
-static ssize_t aio_read(struct kiocb *req, const struct iocb *iocb,
1521
+static int aio_read(struct kiocb *req, const struct iocb *iocb,
15131522 			bool vectored, bool compat)
15141523 {
15151524 	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
15161525 	struct iov_iter iter;
15171526 	struct file *file;
1518
-	ssize_t ret;
1527
+	int ret;
15191528 
15201529 	ret = aio_prep_rw(req, iocb);
15211530 	if (ret)
....@@ -1528,7 +1537,7 @@
15281537 		return -EINVAL;
15291538 
15301539 	ret = aio_setup_rw(READ, iocb, &iovec, vectored, compat, &iter);
1531
-	if (ret)
1540
+	if (ret < 0)
15321541 		return ret;
15331542 	ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));
15341543 	if (!ret)
....@@ -1537,13 +1546,13 @@
15371546 	return ret;
15381547 }
15391548 
1540
-static ssize_t aio_write(struct kiocb *req, const struct iocb *iocb,
1549
+static int aio_write(struct kiocb *req, const struct iocb *iocb,
15411550 			 bool vectored, bool compat)
15421551 {
15431552 	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
15441553 	struct iov_iter iter;
15451554 	struct file *file;
1546
-	ssize_t ret;
1555
+	int ret;
15471556 
15481557 	ret = aio_prep_rw(req, iocb);
15491558 	if (ret)
....@@ -1556,7 +1565,7 @@
15561565 		return -EINVAL;
15571566 
15581567 	ret = aio_setup_rw(WRITE, iocb, &iovec, vectored, compat, &iter);
1559
-	if (ret)
1568
+	if (ret < 0)
15601569 		return ret;
15611570 	ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter));
15621571 	if (!ret) {
....@@ -1568,7 +1577,7 @@
15681577 		 * we return to userspace.
15691578 		 */
15701579 		if (S_ISREG(file_inode(file)->i_mode)) {
1571
-			__sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
1580
+			sb_start_write(file_inode(file)->i_sb);
15721581 			__sb_writers_release(file_inode(file)->i_sb, SB_FREEZE_WRITE);
15731582 		}
15741583 		req->ki_flags |= IOCB_WRITE;
....@@ -1832,7 +1841,7 @@
18321841 	add_wait_queue(head, &pt->iocb->poll.wait);
18331842 }
18341843 
1835
-static ssize_t aio_poll(struct aio_kiocb *aiocb, const struct iocb *iocb)
1844
+static int aio_poll(struct aio_kiocb *aiocb, const struct iocb *iocb)
18361845 {
18371846 	struct kioctx *ctx = aiocb->ki_ctx;
18381847 	struct poll_iocb *req = &aiocb->poll;
....@@ -1908,59 +1917,31 @@
19081917 }
19091918 
19101919 static int __io_submit_one(struct kioctx *ctx, const struct iocb *iocb,
1911
-			   struct iocb __user *user_iocb, bool compat)
1920
+			   struct iocb __user *user_iocb, struct aio_kiocb *req,
1921
+			   bool compat)
19121922 {
1913
-	struct aio_kiocb *req;
1914
-	ssize_t ret;
1915
-
1916
-	/* enforce forwards compatibility on users */
1917
-	if (unlikely(iocb->aio_reserved2)) {
1918
-		pr_debug("EINVAL: reserve field set\n");
1919
-		return -EINVAL;
1920
-	}
1921
-
1922
-	/* prevent overflows */
1923
-	if (unlikely(
1924
-	    (iocb->aio_buf != (unsigned long)iocb->aio_buf) ||
1925
-	    (iocb->aio_nbytes != (size_t)iocb->aio_nbytes) ||
1926
-	    ((ssize_t)iocb->aio_nbytes < 0)
1927
-	   )) {
1928
-		pr_debug("EINVAL: overflow check\n");
1929
-		return -EINVAL;
1930
-	}
1931
-
1932
-	if (!get_reqs_available(ctx))
1933
-		return -EAGAIN;
1934
-
1935
-	ret = -EAGAIN;
1936
-	req = aio_get_req(ctx);
1937
-	if (unlikely(!req))
1938
-		goto out_put_reqs_available;
1939
-
19401923 	req->ki_filp = fget(iocb->aio_fildes);
1941
-	ret = -EBADF;
19421924 	if (unlikely(!req->ki_filp))
1943
-		goto out_put_req;
1925
+		return -EBADF;
19441926 
19451927 	if (iocb->aio_flags & IOCB_FLAG_RESFD) {
1928
+		struct eventfd_ctx *eventfd;
19461929 		/*
19471930 		 * If the IOCB_FLAG_RESFD flag of aio_flags is set, get an
19481931 		 * instance of the file* now. The file descriptor must be
19491932 		 * an eventfd() fd, and will be signaled for each completed
19501933 		 * event using the eventfd_signal() function.
19511934 		 */
1952
-		req->ki_eventfd = eventfd_ctx_fdget((int) iocb->aio_resfd);
1953
-		if (IS_ERR(req->ki_eventfd)) {
1954
-			ret = PTR_ERR(req->ki_eventfd);
1955
-			req->ki_eventfd = NULL;
1956
-			goto out_put_req;
1957
-		}
1935
+		eventfd = eventfd_ctx_fdget(iocb->aio_resfd);
1936
+		if (IS_ERR(eventfd))
1937
+			return PTR_ERR(eventfd);
1938
+
1939
+		req->ki_eventfd = eventfd;
19581940 	}
19591941 
1960
-	ret = put_user(KIOCB_KEY, &user_iocb->aio_key);
1961
-	if (unlikely(ret)) {
1942
+	if (unlikely(put_user(KIOCB_KEY, &user_iocb->aio_key))) {
19621943 		pr_debug("EFAULT: aio_key\n");
1963
-		goto out_put_req;
1944
+		return -EFAULT;
19641945 	}
19651946 
19661947 	req->ki_res.obj = (u64)(unsigned long)user_iocb;
....@@ -1970,61 +1951,70 @@
19701951 
19711952 	switch (iocb->aio_lio_opcode) {
19721953 	case IOCB_CMD_PREAD:
1973
-		ret = aio_read(&req->rw, iocb, false, compat);
1974
-		break;
1954
+		return aio_read(&req->rw, iocb, false, compat);
19751955 	case IOCB_CMD_PWRITE:
1976
-		ret = aio_write(&req->rw, iocb, false, compat);
1977
-		break;
1956
+		return aio_write(&req->rw, iocb, false, compat);
19781957 	case IOCB_CMD_PREADV:
1979
-		ret = aio_read(&req->rw, iocb, true, compat);
1980
-		break;
1958
+		return aio_read(&req->rw, iocb, true, compat);
19811959 	case IOCB_CMD_PWRITEV:
1982
-		ret = aio_write(&req->rw, iocb, true, compat);
1983
-		break;
1960
+		return aio_write(&req->rw, iocb, true, compat);
19841961 	case IOCB_CMD_FSYNC:
1985
-		ret = aio_fsync(&req->fsync, iocb, false);
1986
-		break;
1962
+		return aio_fsync(&req->fsync, iocb, false);
19871963 	case IOCB_CMD_FDSYNC:
1988
-		ret = aio_fsync(&req->fsync, iocb, true);
1989
-		break;
1964
+		return aio_fsync(&req->fsync, iocb, true);
19901965 	case IOCB_CMD_POLL:
1991
-		ret = aio_poll(req, iocb);
1992
-		break;
1966
+		return aio_poll(req, iocb);
19931967 	default:
19941968 		pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode);
1995
-		ret = -EINVAL;
1996
-		break;
1969
+		return -EINVAL;
19971970 	}
1998
-
1999
-	/* Done with the synchronous reference */
2000
-	iocb_put(req);
2001
-
2002
-	/*
2003
-	 * If ret is 0, we'd either done aio_complete() ourselves or have
2004
-	 * arranged for that to be done asynchronously.  Anything non-zero
2005
-	 * means that we need to destroy req ourselves.
2006
-	 */
2007
-	if (!ret)
2008
-		return 0;
2009
-
2010
-out_put_req:
2011
-	if (req->ki_eventfd)
2012
-		eventfd_ctx_put(req->ki_eventfd);
2013
-	iocb_destroy(req);
2014
-out_put_reqs_available:
2015
-	put_reqs_available(ctx, 1);
2016
-	return ret;
20171971 }
20181972 
20191973 static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
20201974 			 bool compat)
20211975 {
1976
+	struct aio_kiocb *req;
20221977 	struct iocb iocb;
1978
+	int err;
20231979 
20241980 	if (unlikely(copy_from_user(&iocb, user_iocb, sizeof(iocb))))
20251981 		return -EFAULT;
20261982 
2027
-	return __io_submit_one(ctx, &iocb, user_iocb, compat);
1983
+	/* enforce forwards compatibility on users */
1984
+	if (unlikely(iocb.aio_reserved2)) {
1985
+		pr_debug("EINVAL: reserve field set\n");
1986
+		return -EINVAL;
1987
+	}
1988
+
1989
+	/* prevent overflows */
1990
+	if (unlikely(
1991
+	    (iocb.aio_buf != (unsigned long)iocb.aio_buf) ||
1992
+	    (iocb.aio_nbytes != (size_t)iocb.aio_nbytes) ||
1993
+	    ((ssize_t)iocb.aio_nbytes < 0)
1994
+	   )) {
1995
+		pr_debug("EINVAL: overflow check\n");
1996
+		return -EINVAL;
1997
+	}
1998
+
1999
+	req = aio_get_req(ctx);
2000
+	if (unlikely(!req))
2001
+		return -EAGAIN;
2002
+
2003
+	err = __io_submit_one(ctx, &iocb, user_iocb, req, compat);
2004
+
2005
+	/* Done with the synchronous reference */
2006
+	iocb_put(req);
2007
+
2008
+	/*
2009
+	 * If err is 0, we'd either done aio_complete() ourselves or have
2010
+	 * arranged for that to be done asynchronously.  Anything non-zero
2011
+	 * means that we need to destroy req ourselves.
2012
+	 */
2013
+	if (unlikely(err)) {
2014
+		iocb_destroy(req);
2015
+		put_reqs_available(ctx, 1);
2016
+	}
2017
+	return err;
20282018 }
20292019 
20302020 /* sys_io_submit:
....@@ -2059,7 +2049,8 @@
20592049 	if (nr > ctx->nr_events)
20602050 		nr = ctx->nr_events;
20612051 
2062
-	blk_start_plug(&plug);
2052
+	if (nr > AIO_PLUG_THRESHOLD)
2053
+		blk_start_plug(&plug);
20632054 	for (i = 0; i < nr; i++) {
20642055 		struct iocb __user *user_iocb;
20652056 
....@@ -2072,7 +2063,8 @@
20722063 		if (ret)
20732064 			break;
20742065 	}
2075
-	blk_finish_plug(&plug);
2066
+	if (nr > AIO_PLUG_THRESHOLD)
2067
+		blk_finish_plug(&plug);
20762068 
20772069 	percpu_ref_put(&ctx->users);
20782070 	return i ? i : ret;
....@@ -2099,7 +2091,8 @@
20992091 	if (nr > ctx->nr_events)
21002092 		nr = ctx->nr_events;
21012093 
2102
-	blk_start_plug(&plug);
2094
+	if (nr > AIO_PLUG_THRESHOLD)
2095
+		blk_start_plug(&plug);
21032096 	for (i = 0; i < nr; i++) {
21042097 		compat_uptr_t user_iocb;
21052098 
....@@ -2112,7 +2105,8 @@
21122105 		if (ret)
21132106 			break;
21142107 	}
2115
-	blk_finish_plug(&plug);
2108
+	if (nr > AIO_PLUG_THRESHOLD)
2109
+		blk_finish_plug(&plug);
21162110 
21172111 	percpu_ref_put(&ctx->users);
21182112 	return i ? i : ret;
....@@ -2203,11 +2197,13 @@
22032197  *	specifies an infinite timeout. Note that the timeout pointed to by
22042198  *	timeout is relative.  Will fail with -ENOSYS if not implemented.
22052199  */
2200
+#ifdef CONFIG_64BIT
2201
+
22062202 SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
22072203 		long, min_nr,
22082204 		long, nr,
22092205 		struct io_event __user *, events,
2210
-		struct timespec __user *, timeout)
2206
+		struct __kernel_timespec __user *, timeout)
22112207 {
22122208 	struct timespec64	ts;
22132209 	int			ret;
....@@ -2221,6 +2217,8 @@
22212217 	return ret;
22222218 }
22232219 
2220
+#endif
2221
+
22242222 struct __aio_sigset {
22252223 	const sigset_t __user	*sigmask;
22262224 	size_t		sigsetsize;
....@@ -2231,12 +2229,12 @@
22312229 		long, min_nr,
22322230 		long, nr,
22332231 		struct io_event __user *, events,
2234
-		struct timespec __user *, timeout,
2232
+		struct __kernel_timespec __user *, timeout,
22352233 		const struct __aio_sigset __user *, usig)
22362234 {
22372235 	struct __aio_sigset	ksig = { NULL, };
2238
-	sigset_t		ksigmask, sigsaved;
22392236 	struct timespec64	ts;
2237
+	bool interrupted;
22402238 	int ret;
22412239 
22422240 	if (timeout && unlikely(get_timespec64(&ts, timeout)))
....@@ -2245,43 +2243,70 @@
22452243 	if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
22462244 		return -EFAULT;
22472245 
2248
-	if (ksig.sigmask) {
2249
-		if (ksig.sigsetsize != sizeof(sigset_t))
2250
-			return -EINVAL;
2251
-		if (copy_from_user(&ksigmask, ksig.sigmask, sizeof(ksigmask)))
2252
-			return -EFAULT;
2253
-		sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2254
-		sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
2255
-	}
2246
+	ret = set_user_sigmask(ksig.sigmask, ksig.sigsetsize);
2247
+	if (ret)
2248
+		return ret;
22562249 
22572250 	ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
2258
-	if (signal_pending(current)) {
2259
-		if (ksig.sigmask) {
2260
-			current->saved_sigmask = sigsaved;
2261
-			set_restore_sigmask();
2262
-		}
22632251 
2264
-		if (!ret)
2265
-			ret = -ERESTARTNOHAND;
2266
-	} else {
2267
-		if (ksig.sigmask)
2268
-			sigprocmask(SIG_SETMASK, &sigsaved, NULL);
2269
-	}
2252
+	interrupted = signal_pending(current);
2253
+	restore_saved_sigmask_unless(interrupted);
2254
+	if (interrupted && !ret)
2255
+		ret = -ERESTARTNOHAND;
22702256 
22712257 	return ret;
22722258 }
22732259 
2274
-#ifdef CONFIG_COMPAT
2275
-COMPAT_SYSCALL_DEFINE5(io_getevents, compat_aio_context_t, ctx_id,
2276
-		       compat_long_t, min_nr,
2277
-		       compat_long_t, nr,
2278
-		       struct io_event __user *, events,
2279
-		       struct compat_timespec __user *, timeout)
2260
+#if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
2261
+
2262
+SYSCALL_DEFINE6(io_pgetevents_time32,
2263
+		aio_context_t, ctx_id,
2264
+		long, min_nr,
2265
+		long, nr,
2266
+		struct io_event __user *, events,
2267
+		struct old_timespec32 __user *, timeout,
2268
+		const struct __aio_sigset __user *, usig)
2269
+{
2270
+	struct __aio_sigset	ksig = { NULL, };
2271
+	struct timespec64	ts;
2272
+	bool interrupted;
2273
+	int ret;
2274
+
2275
+	if (timeout && unlikely(get_old_timespec32(&ts, timeout)))
2276
+		return -EFAULT;
2277
+
2278
+	if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
2279
+		return -EFAULT;
2280
+
2281
+
2282
+	ret = set_user_sigmask(ksig.sigmask, ksig.sigsetsize);
2283
+	if (ret)
2284
+		return ret;
2285
+
2286
+	ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
2287
+
2288
+	interrupted = signal_pending(current);
2289
+	restore_saved_sigmask_unless(interrupted);
2290
+	if (interrupted && !ret)
2291
+		ret = -ERESTARTNOHAND;
2292
+
2293
+	return ret;
2294
+}
2295
+
2296
+#endif
2297
+
2298
+#if defined(CONFIG_COMPAT_32BIT_TIME)
2299
+
2300
+SYSCALL_DEFINE5(io_getevents_time32, __u32, ctx_id,
2301
+		__s32, min_nr,
2302
+		__s32, nr,
2303
+		struct io_event __user *, events,
2304
+		struct old_timespec32 __user *, timeout)
22802305 {
22812306 	struct timespec64 t;
22822307 	int ret;
22832308 
2284
-	if (timeout && compat_get_timespec64(&t, timeout))
2309
+	if (timeout && get_old_timespec32(&t, timeout))
22852310 		return -EFAULT;
22862311 
22872312 	ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
....@@ -2290,52 +2315,81 @@
22902315 	return ret;
22912316 }
22922317 
2318
+#endif
2319
+
2320
+#ifdef CONFIG_COMPAT
22932321 
22942322 struct __compat_aio_sigset {
2295
-	compat_sigset_t __user	*sigmask;
2323
+	compat_uptr_t		sigmask;
22962324 	compat_size_t		sigsetsize;
22972325 };
2326
+
2327
+#if defined(CONFIG_COMPAT_32BIT_TIME)
22982328 
22992329 COMPAT_SYSCALL_DEFINE6(io_pgetevents,
23002330 		compat_aio_context_t, ctx_id,
23012331 		compat_long_t, min_nr,
23022332 		compat_long_t, nr,
23032333 		struct io_event __user *, events,
2304
-		struct compat_timespec __user *, timeout,
2334
+		struct old_timespec32 __user *, timeout,
23052335 		const struct __compat_aio_sigset __user *, usig)
23062336 {
2307
-	struct __compat_aio_sigset ksig = { NULL, };
2308
-	sigset_t ksigmask, sigsaved;
2337
+	struct __compat_aio_sigset ksig = { 0, };
23092338 	struct timespec64 t;
2339
+	bool interrupted;
23102340 	int ret;
23112341 
2312
-	if (timeout && compat_get_timespec64(&t, timeout))
2342
+	if (timeout && get_old_timespec32(&t, timeout))
23132343 		return -EFAULT;
23142344 
23152345 	if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
23162346 		return -EFAULT;
23172347 
2318
-	if (ksig.sigmask) {
2319
-		if (ksig.sigsetsize != sizeof(compat_sigset_t))
2320
-			return -EINVAL;
2321
-		if (get_compat_sigset(&ksigmask, ksig.sigmask))
2322
-			return -EFAULT;
2323
-		sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2324
-		sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
2325
-	}
2348
+	ret = set_compat_user_sigmask(compat_ptr(ksig.sigmask), ksig.sigsetsize);
2349
+	if (ret)
2350
+		return ret;
23262351 
23272352 	ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
2328
-	if (signal_pending(current)) {
2329
-		if (ksig.sigmask) {
2330
-			current->saved_sigmask = sigsaved;
2331
-			set_restore_sigmask();
2332
-		}
2333
-		if (!ret)
2334
-			ret = -ERESTARTNOHAND;
2335
-	} else {
2336
-		if (ksig.sigmask)
2337
-			sigprocmask(SIG_SETMASK, &sigsaved, NULL);
2338
-	}
2353
+
2354
+	interrupted = signal_pending(current);
2355
+	restore_saved_sigmask_unless(interrupted);
2356
+	if (interrupted && !ret)
2357
+		ret = -ERESTARTNOHAND;
2358
+
2359
+	return ret;
2360
+}
2361
+
2362
+#endif
2363
+
2364
+COMPAT_SYSCALL_DEFINE6(io_pgetevents_time64,
2365
+		compat_aio_context_t, ctx_id,
2366
+		compat_long_t, min_nr,
2367
+		compat_long_t, nr,
2368
+		struct io_event __user *, events,
2369
+		struct __kernel_timespec __user *, timeout,
2370
+		const struct __compat_aio_sigset __user *, usig)
2371
+{
2372
+	struct __compat_aio_sigset ksig = { 0, };
2373
+	struct timespec64 t;
2374
+	bool interrupted;
2375
+	int ret;
2376
+
2377
+	if (timeout && get_timespec64(&t, timeout))
2378
+		return -EFAULT;
2379
+
2380
+	if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
2381
+		return -EFAULT;
2382
+
2383
+	ret = set_compat_user_sigmask(compat_ptr(ksig.sigmask), ksig.sigsetsize);
2384
+	if (ret)
2385
+		return ret;
2386
+
2387
+	ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
2388
+
2389
+	interrupted = signal_pending(current);
2390
+	restore_saved_sigmask_unless(interrupted);
2391
+	if (interrupted && !ret)
2392
+		ret = -ERESTARTNOHAND;
23392393 
23402394 	return ret;
23412395 }