summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/filesystems/Locking9
-rw-r--r--Documentation/filesystems/vfs.txt15
-rw-r--r--arch/x86/entry/syscalls/syscall_32.tbl1
-rw-r--r--arch/x86/entry/syscalls/syscall_64.tbl1
-rw-r--r--crypto/af_alg.c14
-rw-r--r--crypto/algif_aead.c4
-rw-r--r--crypto/algif_hash.c2
-rw-r--r--crypto/algif_rng.c1
-rw-r--r--crypto/algif_skcipher.c4
-rw-r--r--drivers/char/random.c29
-rw-r--r--drivers/isdn/mISDN/socket.c3
-rw-r--r--drivers/net/ppp/pppoe.c2
-rw-r--r--drivers/net/ppp/pptp.c1
-rw-r--r--drivers/staging/comedi/drivers/serial2002.c4
-rw-r--r--drivers/staging/ipx/af_ipx.c2
-rw-r--r--drivers/vfio/virqfd.c2
-rw-r--r--drivers/vhost/vhost.c2
-rw-r--r--fs/aio.c731
-rw-r--r--fs/eventfd.c15
-rw-r--r--fs/eventpoll.c5
-rw-r--r--fs/pipe.c22
-rw-r--r--fs/select.c85
-rw-r--r--fs/timerfd.c22
-rw-r--r--include/crypto/if_alg.h3
-rw-r--r--include/linux/aio.h2
-rw-r--r--include/linux/compat.h7
-rw-r--r--include/linux/fs.h2
-rw-r--r--include/linux/net.h1
-rw-r--r--include/linux/poll.h14
-rw-r--r--include/linux/skbuff.h3
-rw-r--r--include/linux/syscalls.h6
-rw-r--r--include/net/bluetooth/bluetooth.h2
-rw-r--r--include/net/busy_poll.h15
-rw-r--r--include/net/iucv/af_iucv.h2
-rw-r--r--include/net/sctp/sctp.h3
-rw-r--r--include/net/sock.h2
-rw-r--r--include/net/tcp.h3
-rw-r--r--include/net/udp.h2
-rw-r--r--include/uapi/asm-generic/unistd.h4
-rw-r--r--include/uapi/linux/aio_abi.h12
-rw-r--r--include/uapi/linux/types.h4
-rw-r--r--kernel/sys_ni.c2
-rw-r--r--mm/memcontrol.c2
-rw-r--r--net/9p/trans_fd.c18
-rw-r--r--net/appletalk/ddp.c2
-rw-r--r--net/atm/common.c11
-rw-r--r--net/atm/common.h2
-rw-r--r--net/atm/pvc.c2
-rw-r--r--net/atm/svc.c2
-rw-r--r--net/ax25/af_ax25.c2
-rw-r--r--net/bluetooth/af_bluetooth.c7
-rw-r--r--net/bluetooth/bnep/sock.c1
-rw-r--r--net/bluetooth/cmtp/sock.c1
-rw-r--r--net/bluetooth/hci_sock.c2
-rw-r--r--net/bluetooth/hidp/sock.c1
-rw-r--r--net/bluetooth/l2cap_sock.c2
-rw-r--r--net/bluetooth/rfcomm/sock.c2
-rw-r--r--net/bluetooth/sco.c2
-rw-r--r--net/caif/caif_socket.c12
-rw-r--r--net/can/bcm.c2
-rw-r--r--net/can/raw.c2
-rw-r--r--net/core/datagram.c13
-rw-r--r--net/core/sock.c6
-rw-r--r--net/dccp/dccp.h3
-rw-r--r--net/dccp/ipv4.c2
-rw-r--r--net/dccp/ipv6.c2
-rw-r--r--net/dccp/proto.c13
-rw-r--r--net/decnet/af_decnet.c6
-rw-r--r--net/ieee802154/socket.c4
-rw-r--r--net/ipv4/af_inet.c8
-rw-r--r--net/ipv4/tcp.c23
-rw-r--r--net/ipv4/udp.c10
-rw-r--r--net/ipv6/af_inet6.c4
-rw-r--r--net/ipv6/raw.c4
-rw-r--r--net/iucv/af_iucv.c7
-rw-r--r--net/kcm/kcmsock.c10
-rw-r--r--net/key/af_key.c2
-rw-r--r--net/l2tp/l2tp_ip.c2
-rw-r--r--net/l2tp/l2tp_ip6.c2
-rw-r--r--net/l2tp/l2tp_ppp.c2
-rw-r--r--net/llc/af_llc.c2
-rw-r--r--net/netlink/af_netlink.c2
-rw-r--r--net/netrom/af_netrom.c2
-rw-r--r--net/nfc/llcp_sock.c9
-rw-r--r--net/nfc/rawsock.c4
-rw-r--r--net/packet/af_packet.c9
-rw-r--r--net/phonet/socket.c9
-rw-r--r--net/qrtr/qrtr.c2
-rw-r--r--net/rose/af_rose.c2
-rw-r--r--net/rxrpc/af_rxrpc.c10
-rw-r--r--net/sctp/ipv6.c2
-rw-r--r--net/sctp/protocol.c2
-rw-r--r--net/sctp/socket.c4
-rw-r--r--net/socket.c55
-rw-r--r--net/tipc/socket.c14
-rw-r--r--net/unix/af_unix.c30
-rw-r--r--net/vmw_vsock/af_vsock.c19
-rw-r--r--net/x25/af_x25.c2
-rw-r--r--virt/kvm/eventfd.c2
99 files changed, 849 insertions, 595 deletions
diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 15853d522941..2c391338c675 100644
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -440,7 +440,9 @@ prototypes:
440 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 440 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
441 int (*iterate) (struct file *, struct dir_context *); 441 int (*iterate) (struct file *, struct dir_context *);
442 int (*iterate_shared) (struct file *, struct dir_context *); 442 int (*iterate_shared) (struct file *, struct dir_context *);
443 unsigned int (*poll) (struct file *, struct poll_table_struct *); 443 __poll_t (*poll) (struct file *, struct poll_table_struct *);
444 struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
445 __poll_t (*poll_mask) (struct file *, __poll_t);
444 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 446 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
445 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 447 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
446 int (*mmap) (struct file *, struct vm_area_struct *); 448 int (*mmap) (struct file *, struct vm_area_struct *);
@@ -471,7 +473,7 @@ prototypes:
471}; 473};
472 474
473locking rules: 475locking rules:
474 All may block. 476 All except for ->poll_mask may block.
475 477
476->llseek() locking has moved from llseek to the individual llseek 478->llseek() locking has moved from llseek to the individual llseek
477implementations. If your fs is not using generic_file_llseek, you 479implementations. If your fs is not using generic_file_llseek, you
@@ -503,6 +505,9 @@ in sys_read() and friends.
503the lease within the individual filesystem to record the result of the 505the lease within the individual filesystem to record the result of the
504operation 506operation
505 507
508->poll_mask can be called with or without the waitqueue lock for the waitqueue
509returned from ->get_poll_head.
510
506--------------------------- dquot_operations ------------------------------- 511--------------------------- dquot_operations -------------------------------
507prototypes: 512prototypes:
508 int (*write_dquot) (struct dquot *); 513 int (*write_dquot) (struct dquot *);
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 5fd325df59e2..829a7b7857a4 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -856,7 +856,9 @@ struct file_operations {
856 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 856 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
857 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 857 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
858 int (*iterate) (struct file *, struct dir_context *); 858 int (*iterate) (struct file *, struct dir_context *);
859 unsigned int (*poll) (struct file *, struct poll_table_struct *); 859 __poll_t (*poll) (struct file *, struct poll_table_struct *);
860 struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
861 __poll_t (*poll_mask) (struct file *, __poll_t);
860 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 862 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
861 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 863 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
862 int (*mmap) (struct file *, struct vm_area_struct *); 864 int (*mmap) (struct file *, struct vm_area_struct *);
@@ -901,6 +903,17 @@ otherwise noted.
901 activity on this file and (optionally) go to sleep until there 903 activity on this file and (optionally) go to sleep until there
902 is activity. Called by the select(2) and poll(2) system calls 904 is activity. Called by the select(2) and poll(2) system calls
903 905
906 get_poll_head: Returns the struct wait_queue_head that callers can
907 wait on. Callers need to check the returned events using ->poll_mask
908 once woken. Can return NULL to indicate polling is not supported,
909 or any error code using the ERR_PTR convention to indicate that a
910 grave error occured and ->poll_mask shall not be called.
911
912 poll_mask: return the mask of EPOLL* values describing the file descriptor
913 state. Called either before going to sleep on the waitqueue returned by
914 get_poll_head, or after it has been woken. If ->get_poll_head and
915 ->poll_mask are implemented ->poll does not need to be implement.
916
904 unlocked_ioctl: called by the ioctl(2) system call. 917 unlocked_ioctl: called by the ioctl(2) system call.
905 918
906 compat_ioctl: called by the ioctl(2) system call when 32 bit system calls 919 compat_ioctl: called by the ioctl(2) system call when 32 bit system calls
diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index d6b27dab1b30..14a2f996e543 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -396,3 +396,4 @@
396382 i386 pkey_free sys_pkey_free __ia32_sys_pkey_free 396382 i386 pkey_free sys_pkey_free __ia32_sys_pkey_free
397383 i386 statx sys_statx __ia32_sys_statx 397383 i386 statx sys_statx __ia32_sys_statx
398384 i386 arch_prctl sys_arch_prctl __ia32_compat_sys_arch_prctl 398384 i386 arch_prctl sys_arch_prctl __ia32_compat_sys_arch_prctl
399385 i386 io_pgetevents sys_io_pgetevents __ia32_compat_sys_io_pgetevents
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index 4dfe42666d0c..cd36232ab62f 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -341,6 +341,7 @@
341330 common pkey_alloc __x64_sys_pkey_alloc 341330 common pkey_alloc __x64_sys_pkey_alloc
342331 common pkey_free __x64_sys_pkey_free 342331 common pkey_free __x64_sys_pkey_free
343332 common statx __x64_sys_statx 343332 common statx __x64_sys_statx
344333 common io_pgetevents __x64_sys_io_pgetevents
344 345
345# 346#
346# x32-specific system call numbers start at 512 to avoid cache impact 347# x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/crypto/af_alg.c b/crypto/af_alg.c
index 7846c0c20cfe..89ed613c017e 100644
--- a/crypto/af_alg.c
+++ b/crypto/af_alg.c
@@ -347,7 +347,6 @@ static const struct proto_ops alg_proto_ops = {
347 .sendpage = sock_no_sendpage, 347 .sendpage = sock_no_sendpage,
348 .sendmsg = sock_no_sendmsg, 348 .sendmsg = sock_no_sendmsg,
349 .recvmsg = sock_no_recvmsg, 349 .recvmsg = sock_no_recvmsg,
350 .poll = sock_no_poll,
351 350
352 .bind = alg_bind, 351 .bind = alg_bind,
353 .release = af_alg_release, 352 .release = af_alg_release,
@@ -1061,19 +1060,12 @@ void af_alg_async_cb(struct crypto_async_request *_req, int err)
1061} 1060}
1062EXPORT_SYMBOL_GPL(af_alg_async_cb); 1061EXPORT_SYMBOL_GPL(af_alg_async_cb);
1063 1062
1064/** 1063__poll_t af_alg_poll_mask(struct socket *sock, __poll_t events)
1065 * af_alg_poll - poll system call handler
1066 */
1067__poll_t af_alg_poll(struct file *file, struct socket *sock,
1068 poll_table *wait)
1069{ 1064{
1070 struct sock *sk = sock->sk; 1065 struct sock *sk = sock->sk;
1071 struct alg_sock *ask = alg_sk(sk); 1066 struct alg_sock *ask = alg_sk(sk);
1072 struct af_alg_ctx *ctx = ask->private; 1067 struct af_alg_ctx *ctx = ask->private;
1073 __poll_t mask; 1068 __poll_t mask = 0;
1074
1075 sock_poll_wait(file, sk_sleep(sk), wait);
1076 mask = 0;
1077 1069
1078 if (!ctx->more || ctx->used) 1070 if (!ctx->more || ctx->used)
1079 mask |= EPOLLIN | EPOLLRDNORM; 1071 mask |= EPOLLIN | EPOLLRDNORM;
@@ -1083,7 +1075,7 @@ __poll_t af_alg_poll(struct file *file, struct socket *sock,
1083 1075
1084 return mask; 1076 return mask;
1085} 1077}
1086EXPORT_SYMBOL_GPL(af_alg_poll); 1078EXPORT_SYMBOL_GPL(af_alg_poll_mask);
1087 1079
1088/** 1080/**
1089 * af_alg_alloc_areq - allocate struct af_alg_async_req 1081 * af_alg_alloc_areq - allocate struct af_alg_async_req
diff --git a/crypto/algif_aead.c b/crypto/algif_aead.c
index 4b07edd5a9ff..330cf9f2b767 100644
--- a/crypto/algif_aead.c
+++ b/crypto/algif_aead.c
@@ -375,7 +375,7 @@ static struct proto_ops algif_aead_ops = {
375 .sendmsg = aead_sendmsg, 375 .sendmsg = aead_sendmsg,
376 .sendpage = af_alg_sendpage, 376 .sendpage = af_alg_sendpage,
377 .recvmsg = aead_recvmsg, 377 .recvmsg = aead_recvmsg,
378 .poll = af_alg_poll, 378 .poll_mask = af_alg_poll_mask,
379}; 379};
380 380
381static int aead_check_key(struct socket *sock) 381static int aead_check_key(struct socket *sock)
@@ -471,7 +471,7 @@ static struct proto_ops algif_aead_ops_nokey = {
471 .sendmsg = aead_sendmsg_nokey, 471 .sendmsg = aead_sendmsg_nokey,
472 .sendpage = aead_sendpage_nokey, 472 .sendpage = aead_sendpage_nokey,
473 .recvmsg = aead_recvmsg_nokey, 473 .recvmsg = aead_recvmsg_nokey,
474 .poll = af_alg_poll, 474 .poll_mask = af_alg_poll_mask,
475}; 475};
476 476
477static void *aead_bind(const char *name, u32 type, u32 mask) 477static void *aead_bind(const char *name, u32 type, u32 mask)
diff --git a/crypto/algif_hash.c b/crypto/algif_hash.c
index 6c9b1927a520..bfcf595fd8f9 100644
--- a/crypto/algif_hash.c
+++ b/crypto/algif_hash.c
@@ -288,7 +288,6 @@ static struct proto_ops algif_hash_ops = {
288 .mmap = sock_no_mmap, 288 .mmap = sock_no_mmap,
289 .bind = sock_no_bind, 289 .bind = sock_no_bind,
290 .setsockopt = sock_no_setsockopt, 290 .setsockopt = sock_no_setsockopt,
291 .poll = sock_no_poll,
292 291
293 .release = af_alg_release, 292 .release = af_alg_release,
294 .sendmsg = hash_sendmsg, 293 .sendmsg = hash_sendmsg,
@@ -396,7 +395,6 @@ static struct proto_ops algif_hash_ops_nokey = {
396 .mmap = sock_no_mmap, 395 .mmap = sock_no_mmap,
397 .bind = sock_no_bind, 396 .bind = sock_no_bind,
398 .setsockopt = sock_no_setsockopt, 397 .setsockopt = sock_no_setsockopt,
399 .poll = sock_no_poll,
400 398
401 .release = af_alg_release, 399 .release = af_alg_release,
402 .sendmsg = hash_sendmsg_nokey, 400 .sendmsg = hash_sendmsg_nokey,
diff --git a/crypto/algif_rng.c b/crypto/algif_rng.c
index 150c2b6480ed..22df3799a17b 100644
--- a/crypto/algif_rng.c
+++ b/crypto/algif_rng.c
@@ -106,7 +106,6 @@ static struct proto_ops algif_rng_ops = {
106 .bind = sock_no_bind, 106 .bind = sock_no_bind,
107 .accept = sock_no_accept, 107 .accept = sock_no_accept,
108 .setsockopt = sock_no_setsockopt, 108 .setsockopt = sock_no_setsockopt,
109 .poll = sock_no_poll,
110 .sendmsg = sock_no_sendmsg, 109 .sendmsg = sock_no_sendmsg,
111 .sendpage = sock_no_sendpage, 110 .sendpage = sock_no_sendpage,
112 111
diff --git a/crypto/algif_skcipher.c b/crypto/algif_skcipher.c
index c4e885df4564..15cf3c5222e0 100644
--- a/crypto/algif_skcipher.c
+++ b/crypto/algif_skcipher.c
@@ -205,7 +205,7 @@ static struct proto_ops algif_skcipher_ops = {
205 .sendmsg = skcipher_sendmsg, 205 .sendmsg = skcipher_sendmsg,
206 .sendpage = af_alg_sendpage, 206 .sendpage = af_alg_sendpage,
207 .recvmsg = skcipher_recvmsg, 207 .recvmsg = skcipher_recvmsg,
208 .poll = af_alg_poll, 208 .poll_mask = af_alg_poll_mask,
209}; 209};
210 210
211static int skcipher_check_key(struct socket *sock) 211static int skcipher_check_key(struct socket *sock)
@@ -301,7 +301,7 @@ static struct proto_ops algif_skcipher_ops_nokey = {
301 .sendmsg = skcipher_sendmsg_nokey, 301 .sendmsg = skcipher_sendmsg_nokey,
302 .sendpage = skcipher_sendpage_nokey, 302 .sendpage = skcipher_sendpage_nokey,
303 .recvmsg = skcipher_recvmsg_nokey, 303 .recvmsg = skcipher_recvmsg_nokey,
304 .poll = af_alg_poll, 304 .poll_mask = af_alg_poll_mask,
305}; 305};
306 306
307static void *skcipher_bind(const char *name, u32 type, u32 mask) 307static void *skcipher_bind(const char *name, u32 type, u32 mask)
diff --git a/drivers/char/random.c b/drivers/char/random.c
index cd888d4ee605..a8fb0020ba5c 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -402,8 +402,7 @@ static struct poolinfo {
402/* 402/*
403 * Static global variables 403 * Static global variables
404 */ 404 */
405static DECLARE_WAIT_QUEUE_HEAD(random_read_wait); 405static DECLARE_WAIT_QUEUE_HEAD(random_wait);
406static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
407static struct fasync_struct *fasync; 406static struct fasync_struct *fasync;
408 407
409static DEFINE_SPINLOCK(random_ready_list_lock); 408static DEFINE_SPINLOCK(random_ready_list_lock);
@@ -722,8 +721,8 @@ retry:
722 721
723 /* should we wake readers? */ 722 /* should we wake readers? */
724 if (entropy_bits >= random_read_wakeup_bits && 723 if (entropy_bits >= random_read_wakeup_bits &&
725 wq_has_sleeper(&random_read_wait)) { 724 wq_has_sleeper(&random_wait)) {
726 wake_up_interruptible(&random_read_wait); 725 wake_up_interruptible_poll(&random_wait, POLLIN);
727 kill_fasync(&fasync, SIGIO, POLL_IN); 726 kill_fasync(&fasync, SIGIO, POLL_IN);
728 } 727 }
729 /* If the input pool is getting full, send some 728 /* If the input pool is getting full, send some
@@ -1397,7 +1396,7 @@ retry:
1397 trace_debit_entropy(r->name, 8 * ibytes); 1396 trace_debit_entropy(r->name, 8 * ibytes);
1398 if (ibytes && 1397 if (ibytes &&
1399 (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_bits) { 1398 (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_bits) {
1400 wake_up_interruptible(&random_write_wait); 1399 wake_up_interruptible_poll(&random_wait, POLLOUT);
1401 kill_fasync(&fasync, SIGIO, POLL_OUT); 1400 kill_fasync(&fasync, SIGIO, POLL_OUT);
1402 } 1401 }
1403 1402
@@ -1839,7 +1838,7 @@ _random_read(int nonblock, char __user *buf, size_t nbytes)
1839 if (nonblock) 1838 if (nonblock)
1840 return -EAGAIN; 1839 return -EAGAIN;
1841 1840
1842 wait_event_interruptible(random_read_wait, 1841 wait_event_interruptible(random_wait,
1843 ENTROPY_BITS(&input_pool) >= 1842 ENTROPY_BITS(&input_pool) >=
1844 random_read_wakeup_bits); 1843 random_read_wakeup_bits);
1845 if (signal_pending(current)) 1844 if (signal_pending(current))
@@ -1876,14 +1875,17 @@ urandom_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
1876 return ret; 1875 return ret;
1877} 1876}
1878 1877
1878static struct wait_queue_head *
1879random_get_poll_head(struct file *file, __poll_t events)
1880{
1881 return &random_wait;
1882}
1883
1879static __poll_t 1884static __poll_t
1880random_poll(struct file *file, poll_table * wait) 1885random_poll_mask(struct file *file, __poll_t events)
1881{ 1886{
1882 __poll_t mask; 1887 __poll_t mask = 0;
1883 1888
1884 poll_wait(file, &random_read_wait, wait);
1885 poll_wait(file, &random_write_wait, wait);
1886 mask = 0;
1887 if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits) 1889 if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits)
1888 mask |= EPOLLIN | EPOLLRDNORM; 1890 mask |= EPOLLIN | EPOLLRDNORM;
1889 if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits) 1891 if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits)
@@ -1990,7 +1992,8 @@ static int random_fasync(int fd, struct file *filp, int on)
1990const struct file_operations random_fops = { 1992const struct file_operations random_fops = {
1991 .read = random_read, 1993 .read = random_read,
1992 .write = random_write, 1994 .write = random_write,
1993 .poll = random_poll, 1995 .get_poll_head = random_get_poll_head,
1996 .poll_mask = random_poll_mask,
1994 .unlocked_ioctl = random_ioctl, 1997 .unlocked_ioctl = random_ioctl,
1995 .fasync = random_fasync, 1998 .fasync = random_fasync,
1996 .llseek = noop_llseek, 1999 .llseek = noop_llseek,
@@ -2323,7 +2326,7 @@ void add_hwgenerator_randomness(const char *buffer, size_t count,
2323 * We'll be woken up again once below random_write_wakeup_thresh, 2326 * We'll be woken up again once below random_write_wakeup_thresh,
2324 * or when the calling thread is about to terminate. 2327 * or when the calling thread is about to terminate.
2325 */ 2328 */
2326 wait_event_interruptible(random_write_wait, kthread_should_stop() || 2329 wait_event_interruptible(random_wait, kthread_should_stop() ||
2327 ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits); 2330 ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits);
2328 mix_pool_bytes(poolp, buffer, count); 2331 mix_pool_bytes(poolp, buffer, count);
2329 credit_entropy_bits(poolp, entropy); 2332 credit_entropy_bits(poolp, entropy);
diff --git a/drivers/isdn/mISDN/socket.c b/drivers/isdn/mISDN/socket.c
index 1f8f489b4167..98f90aadd141 100644
--- a/drivers/isdn/mISDN/socket.c
+++ b/drivers/isdn/mISDN/socket.c
@@ -588,7 +588,7 @@ static const struct proto_ops data_sock_ops = {
588 .getname = data_sock_getname, 588 .getname = data_sock_getname,
589 .sendmsg = mISDN_sock_sendmsg, 589 .sendmsg = mISDN_sock_sendmsg,
590 .recvmsg = mISDN_sock_recvmsg, 590 .recvmsg = mISDN_sock_recvmsg,
591 .poll = datagram_poll, 591 .poll_mask = datagram_poll_mask,
592 .listen = sock_no_listen, 592 .listen = sock_no_listen,
593 .shutdown = sock_no_shutdown, 593 .shutdown = sock_no_shutdown,
594 .setsockopt = data_sock_setsockopt, 594 .setsockopt = data_sock_setsockopt,
@@ -745,7 +745,6 @@ static const struct proto_ops base_sock_ops = {
745 .getname = sock_no_getname, 745 .getname = sock_no_getname,
746 .sendmsg = sock_no_sendmsg, 746 .sendmsg = sock_no_sendmsg,
747 .recvmsg = sock_no_recvmsg, 747 .recvmsg = sock_no_recvmsg,
748 .poll = sock_no_poll,
749 .listen = sock_no_listen, 748 .listen = sock_no_listen,
750 .shutdown = sock_no_shutdown, 749 .shutdown = sock_no_shutdown,
751 .setsockopt = sock_no_setsockopt, 750 .setsockopt = sock_no_setsockopt,
diff --git a/drivers/net/ppp/pppoe.c b/drivers/net/ppp/pppoe.c
index ce61231e96ea..de51e8f70f44 100644
--- a/drivers/net/ppp/pppoe.c
+++ b/drivers/net/ppp/pppoe.c
@@ -1107,7 +1107,7 @@ static const struct proto_ops pppoe_ops = {
1107 .socketpair = sock_no_socketpair, 1107 .socketpair = sock_no_socketpair,
1108 .accept = sock_no_accept, 1108 .accept = sock_no_accept,
1109 .getname = pppoe_getname, 1109 .getname = pppoe_getname,
1110 .poll = datagram_poll, 1110 .poll_mask = datagram_poll_mask,
1111 .listen = sock_no_listen, 1111 .listen = sock_no_listen,
1112 .shutdown = sock_no_shutdown, 1112 .shutdown = sock_no_shutdown,
1113 .setsockopt = sock_no_setsockopt, 1113 .setsockopt = sock_no_setsockopt,
diff --git a/drivers/net/ppp/pptp.c b/drivers/net/ppp/pptp.c
index c4267ecefd85..157b67c1bf8e 100644
--- a/drivers/net/ppp/pptp.c
+++ b/drivers/net/ppp/pptp.c
@@ -624,7 +624,6 @@ static const struct proto_ops pptp_ops = {
624 .socketpair = sock_no_socketpair, 624 .socketpair = sock_no_socketpair,
625 .accept = sock_no_accept, 625 .accept = sock_no_accept,
626 .getname = pptp_getname, 626 .getname = pptp_getname,
627 .poll = sock_no_poll,
628 .listen = sock_no_listen, 627 .listen = sock_no_listen,
629 .shutdown = sock_no_shutdown, 628 .shutdown = sock_no_shutdown,
630 .setsockopt = sock_no_setsockopt, 629 .setsockopt = sock_no_setsockopt,
diff --git a/drivers/staging/comedi/drivers/serial2002.c b/drivers/staging/comedi/drivers/serial2002.c
index b3f3b4a201af..5471b2212a62 100644
--- a/drivers/staging/comedi/drivers/serial2002.c
+++ b/drivers/staging/comedi/drivers/serial2002.c
@@ -113,7 +113,7 @@ static void serial2002_tty_read_poll_wait(struct file *f, int timeout)
113 long elapsed; 113 long elapsed;
114 __poll_t mask; 114 __poll_t mask;
115 115
116 mask = f->f_op->poll(f, &table.pt); 116 mask = vfs_poll(f, &table.pt);
117 if (mask & (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN | 117 if (mask & (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |
118 EPOLLHUP | EPOLLERR)) { 118 EPOLLHUP | EPOLLERR)) {
119 break; 119 break;
@@ -136,7 +136,7 @@ static int serial2002_tty_read(struct file *f, int timeout)
136 136
137 result = -1; 137 result = -1;
138 if (!IS_ERR(f)) { 138 if (!IS_ERR(f)) {
139 if (f->f_op->poll) { 139 if (file_can_poll(f)) {
140 serial2002_tty_read_poll_wait(f, timeout); 140 serial2002_tty_read_poll_wait(f, timeout);
141 141
142 if (kernel_read(f, &ch, 1, &pos) == 1) 142 if (kernel_read(f, &ch, 1, &pos) == 1)
diff --git a/drivers/staging/ipx/af_ipx.c b/drivers/staging/ipx/af_ipx.c
index 5703dd176787..208b5c161631 100644
--- a/drivers/staging/ipx/af_ipx.c
+++ b/drivers/staging/ipx/af_ipx.c
@@ -1965,7 +1965,7 @@ static const struct proto_ops ipx_dgram_ops = {
1965 .socketpair = sock_no_socketpair, 1965 .socketpair = sock_no_socketpair,
1966 .accept = sock_no_accept, 1966 .accept = sock_no_accept,
1967 .getname = ipx_getname, 1967 .getname = ipx_getname,
1968 .poll = datagram_poll, 1968 .poll_mask = datagram_poll_mask,
1969 .ioctl = ipx_ioctl, 1969 .ioctl = ipx_ioctl,
1970#ifdef CONFIG_COMPAT 1970#ifdef CONFIG_COMPAT
1971 .compat_ioctl = ipx_compat_ioctl, 1971 .compat_ioctl = ipx_compat_ioctl,
diff --git a/drivers/vfio/virqfd.c b/drivers/vfio/virqfd.c
index 085700f1be10..2a1be859ee71 100644
--- a/drivers/vfio/virqfd.c
+++ b/drivers/vfio/virqfd.c
@@ -166,7 +166,7 @@ int vfio_virqfd_enable(void *opaque,
166 init_waitqueue_func_entry(&virqfd->wait, virqfd_wakeup); 166 init_waitqueue_func_entry(&virqfd->wait, virqfd_wakeup);
167 init_poll_funcptr(&virqfd->pt, virqfd_ptable_queue_proc); 167 init_poll_funcptr(&virqfd->pt, virqfd_ptable_queue_proc);
168 168
169 events = irqfd.file->f_op->poll(irqfd.file, &virqfd->pt); 169 events = vfs_poll(irqfd.file, &virqfd->pt);
170 170
171 /* 171 /*
172 * Check if there was an event already pending on the eventfd 172 * Check if there was an event already pending on the eventfd
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index f0be5f35ab28..895eaa25807c 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -208,7 +208,7 @@ int vhost_poll_start(struct vhost_poll *poll, struct file *file)
208 if (poll->wqh) 208 if (poll->wqh)
209 return 0; 209 return 0;
210 210
211 mask = file->f_op->poll(file, &poll->table); 211 mask = vfs_poll(file, &poll->table);
212 if (mask) 212 if (mask)
213 vhost_poll_wakeup(&poll->wait, 0, 0, poll_to_key(mask)); 213 vhost_poll_wakeup(&poll->wait, 0, 0, poll_to_key(mask));
214 if (mask & EPOLLERR) { 214 if (mask & EPOLLERR) {
diff --git a/fs/aio.c b/fs/aio.c
index 49f53516eef0..b850e92ee0d5 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -5,6 +5,7 @@
5 * Implements an efficient asynchronous io interface. 5 * Implements an efficient asynchronous io interface.
6 * 6 *
7 * Copyright 2000, 2001, 2002 Red Hat, Inc. All Rights Reserved. 7 * Copyright 2000, 2001, 2002 Red Hat, Inc. All Rights Reserved.
8 * Copyright 2018 Christoph Hellwig.
8 * 9 *
9 * See ../COPYING for licensing terms. 10 * See ../COPYING for licensing terms.
10 */ 11 */
@@ -46,6 +47,8 @@
46 47
47#include "internal.h" 48#include "internal.h"
48 49
50#define KIOCB_KEY 0
51
49#define AIO_RING_MAGIC 0xa10a10a1 52#define AIO_RING_MAGIC 0xa10a10a1
50#define AIO_RING_COMPAT_FEATURES 1 53#define AIO_RING_COMPAT_FEATURES 1
51#define AIO_RING_INCOMPAT_FEATURES 0 54#define AIO_RING_INCOMPAT_FEATURES 0
@@ -156,21 +159,29 @@ struct kioctx {
156 unsigned id; 159 unsigned id;
157}; 160};
158 161
159/* 162struct fsync_iocb {
160 * We use ki_cancel == KIOCB_CANCELLED to indicate that a kiocb has been either 163 struct work_struct work;
161 * cancelled or completed (this makes a certain amount of sense because 164 struct file *file;
162 * successful cancellation - io_cancel() - does deliver the completion to 165 bool datasync;
163 * userspace). 166};
164 * 167
165 * And since most things don't implement kiocb cancellation and we'd really like 168struct poll_iocb {
166 * kiocb completion to be lockless when possible, we use ki_cancel to 169 struct file *file;
167 * synchronize cancellation and completion - we only set it to KIOCB_CANCELLED 170 __poll_t events;
168 * with xchg() or cmpxchg(), see batch_complete_aio() and kiocb_cancel(). 171 struct wait_queue_head *head;
169 */ 172
170#define KIOCB_CANCELLED ((void *) (~0ULL)) 173 union {
174 struct wait_queue_entry wait;
175 struct work_struct work;
176 };
177};
171 178
172struct aio_kiocb { 179struct aio_kiocb {
173 struct kiocb common; 180 union {
181 struct kiocb rw;
182 struct fsync_iocb fsync;
183 struct poll_iocb poll;
184 };
174 185
175 struct kioctx *ki_ctx; 186 struct kioctx *ki_ctx;
176 kiocb_cancel_fn *ki_cancel; 187 kiocb_cancel_fn *ki_cancel;
@@ -264,9 +275,6 @@ static int __init aio_setup(void)
264 275
265 kiocb_cachep = KMEM_CACHE(aio_kiocb, SLAB_HWCACHE_ALIGN|SLAB_PANIC); 276 kiocb_cachep = KMEM_CACHE(aio_kiocb, SLAB_HWCACHE_ALIGN|SLAB_PANIC);
266 kioctx_cachep = KMEM_CACHE(kioctx,SLAB_HWCACHE_ALIGN|SLAB_PANIC); 277 kioctx_cachep = KMEM_CACHE(kioctx,SLAB_HWCACHE_ALIGN|SLAB_PANIC);
267
268 pr_debug("sizeof(struct page) = %zu\n", sizeof(struct page));
269
270 return 0; 278 return 0;
271} 279}
272__initcall(aio_setup); 280__initcall(aio_setup);
@@ -552,42 +560,20 @@ static int aio_setup_ring(struct kioctx *ctx, unsigned int nr_events)
552 560
553void kiocb_set_cancel_fn(struct kiocb *iocb, kiocb_cancel_fn *cancel) 561void kiocb_set_cancel_fn(struct kiocb *iocb, kiocb_cancel_fn *cancel)
554{ 562{
555 struct aio_kiocb *req = container_of(iocb, struct aio_kiocb, common); 563 struct aio_kiocb *req = container_of(iocb, struct aio_kiocb, rw);
556 struct kioctx *ctx = req->ki_ctx; 564 struct kioctx *ctx = req->ki_ctx;
557 unsigned long flags; 565 unsigned long flags;
558 566
559 spin_lock_irqsave(&ctx->ctx_lock, flags); 567 if (WARN_ON_ONCE(!list_empty(&req->ki_list)))
560 568 return;
561 if (!req->ki_list.next)
562 list_add(&req->ki_list, &ctx->active_reqs);
563 569
570 spin_lock_irqsave(&ctx->ctx_lock, flags);
571 list_add_tail(&req->ki_list, &ctx->active_reqs);
564 req->ki_cancel = cancel; 572 req->ki_cancel = cancel;
565
566 spin_unlock_irqrestore(&ctx->ctx_lock, flags); 573 spin_unlock_irqrestore(&ctx->ctx_lock, flags);
567} 574}
568EXPORT_SYMBOL(kiocb_set_cancel_fn); 575EXPORT_SYMBOL(kiocb_set_cancel_fn);
569 576
570static int kiocb_cancel(struct aio_kiocb *kiocb)
571{
572 kiocb_cancel_fn *old, *cancel;
573
574 /*
575 * Don't want to set kiocb->ki_cancel = KIOCB_CANCELLED unless it
576 * actually has a cancel function, hence the cmpxchg()
577 */
578
579 cancel = READ_ONCE(kiocb->ki_cancel);
580 do {
581 if (!cancel || cancel == KIOCB_CANCELLED)
582 return -EINVAL;
583
584 old = cancel;
585 cancel = cmpxchg(&kiocb->ki_cancel, old, KIOCB_CANCELLED);
586 } while (cancel != old);
587
588 return cancel(&kiocb->common);
589}
590
591/* 577/*
592 * free_ioctx() should be RCU delayed to synchronize against the RCU 578 * free_ioctx() should be RCU delayed to synchronize against the RCU
593 * protected lookup_ioctx() and also needs process context to call 579 * protected lookup_ioctx() and also needs process context to call
@@ -634,7 +620,7 @@ static void free_ioctx_users(struct percpu_ref *ref)
634 while (!list_empty(&ctx->active_reqs)) { 620 while (!list_empty(&ctx->active_reqs)) {
635 req = list_first_entry(&ctx->active_reqs, 621 req = list_first_entry(&ctx->active_reqs,
636 struct aio_kiocb, ki_list); 622 struct aio_kiocb, ki_list);
637 kiocb_cancel(req); 623 req->ki_cancel(&req->rw);
638 list_del_init(&req->ki_list); 624 list_del_init(&req->ki_list);
639 } 625 }
640 626
@@ -1041,7 +1027,7 @@ static inline struct aio_kiocb *aio_get_req(struct kioctx *ctx)
1041 goto out_put; 1027 goto out_put;
1042 1028
1043 percpu_ref_get(&ctx->reqs); 1029 percpu_ref_get(&ctx->reqs);
1044 1030 INIT_LIST_HEAD(&req->ki_list);
1045 req->ki_ctx = ctx; 1031 req->ki_ctx = ctx;
1046 return req; 1032 return req;
1047out_put: 1033out_put:
@@ -1049,15 +1035,6 @@ out_put:
1049 return NULL; 1035 return NULL;
1050} 1036}
1051 1037
1052static void kiocb_free(struct aio_kiocb *req)
1053{
1054 if (req->common.ki_filp)
1055 fput(req->common.ki_filp);
1056 if (req->ki_eventfd != NULL)
1057 eventfd_ctx_put(req->ki_eventfd);
1058 kmem_cache_free(kiocb_cachep, req);
1059}
1060
1061static struct kioctx *lookup_ioctx(unsigned long ctx_id) 1038static struct kioctx *lookup_ioctx(unsigned long ctx_id)
1062{ 1039{
1063 struct aio_ring __user *ring = (void __user *)ctx_id; 1040 struct aio_ring __user *ring = (void __user *)ctx_id;
@@ -1088,44 +1065,14 @@ out:
1088/* aio_complete 1065/* aio_complete
1089 * Called when the io request on the given iocb is complete. 1066 * Called when the io request on the given iocb is complete.
1090 */ 1067 */
1091static void aio_complete(struct kiocb *kiocb, long res, long res2) 1068static void aio_complete(struct aio_kiocb *iocb, long res, long res2)
1092{ 1069{
1093 struct aio_kiocb *iocb = container_of(kiocb, struct aio_kiocb, common);
1094 struct kioctx *ctx = iocb->ki_ctx; 1070 struct kioctx *ctx = iocb->ki_ctx;
1095 struct aio_ring *ring; 1071 struct aio_ring *ring;
1096 struct io_event *ev_page, *event; 1072 struct io_event *ev_page, *event;
1097 unsigned tail, pos, head; 1073 unsigned tail, pos, head;
1098 unsigned long flags; 1074 unsigned long flags;
1099 1075
1100 if (kiocb->ki_flags & IOCB_WRITE) {
1101 struct file *file = kiocb->ki_filp;
1102
1103 /*
1104 * Tell lockdep we inherited freeze protection from submission
1105 * thread.
1106 */
1107 if (S_ISREG(file_inode(file)->i_mode))
1108 __sb_writers_acquired(file_inode(file)->i_sb, SB_FREEZE_WRITE);
1109 file_end_write(file);
1110 }
1111
1112 /*
1113 * Special case handling for sync iocbs:
1114 * - events go directly into the iocb for fast handling
1115 * - the sync task with the iocb in its stack holds the single iocb
1116 * ref, no other paths have a way to get another ref
1117 * - the sync task helpfully left a reference to itself in the iocb
1118 */
1119 BUG_ON(is_sync_kiocb(kiocb));
1120
1121 if (iocb->ki_list.next) {
1122 unsigned long flags;
1123
1124 spin_lock_irqsave(&ctx->ctx_lock, flags);
1125 list_del(&iocb->ki_list);
1126 spin_unlock_irqrestore(&ctx->ctx_lock, flags);
1127 }
1128
1129 /* 1076 /*
1130 * Add a completion event to the ring buffer. Must be done holding 1077 * Add a completion event to the ring buffer. Must be done holding
1131 * ctx->completion_lock to prevent other code from messing with the tail 1078 * ctx->completion_lock to prevent other code from messing with the tail
@@ -1179,11 +1126,12 @@ static void aio_complete(struct kiocb *kiocb, long res, long res2)
1179 * eventfd. The eventfd_signal() function is safe to be called 1126 * eventfd. The eventfd_signal() function is safe to be called
1180 * from IRQ context. 1127 * from IRQ context.
1181 */ 1128 */
1182 if (iocb->ki_eventfd != NULL) 1129 if (iocb->ki_eventfd) {
1183 eventfd_signal(iocb->ki_eventfd, 1); 1130 eventfd_signal(iocb->ki_eventfd, 1);
1131 eventfd_ctx_put(iocb->ki_eventfd);
1132 }
1184 1133
1185 /* everything turned out well, dispose of the aiocb. */ 1134 kmem_cache_free(kiocb_cachep, iocb);
1186 kiocb_free(iocb);
1187 1135
1188 /* 1136 /*
1189 * We have to order our ring_info tail store above and test 1137 * We have to order our ring_info tail store above and test
@@ -1249,14 +1197,13 @@ static long aio_read_events_ring(struct kioctx *ctx,
1249 if (head == tail) 1197 if (head == tail)
1250 break; 1198 break;
1251 1199
1252 avail = min(avail, nr - ret);
1253 avail = min_t(long, avail, AIO_EVENTS_PER_PAGE -
1254 ((head + AIO_EVENTS_OFFSET) % AIO_EVENTS_PER_PAGE));
1255
1256 pos = head + AIO_EVENTS_OFFSET; 1200 pos = head + AIO_EVENTS_OFFSET;
1257 page = ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE]; 1201 page = ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE];
1258 pos %= AIO_EVENTS_PER_PAGE; 1202 pos %= AIO_EVENTS_PER_PAGE;
1259 1203
1204 avail = min(avail, nr - ret);
1205 avail = min_t(long, avail, AIO_EVENTS_PER_PAGE - pos);
1206
1260 ev = kmap(page); 1207 ev = kmap(page);
1261 copy_ret = copy_to_user(event + ret, ev + pos, 1208 copy_ret = copy_to_user(event + ret, ev + pos,
1262 sizeof(*ev) * avail); 1209 sizeof(*ev) * avail);
@@ -1327,10 +1274,6 @@ static long read_events(struct kioctx *ctx, long min_nr, long nr,
1327 wait_event_interruptible_hrtimeout(ctx->wait, 1274 wait_event_interruptible_hrtimeout(ctx->wait,
1328 aio_read_events(ctx, min_nr, nr, event, &ret), 1275 aio_read_events(ctx, min_nr, nr, event, &ret),
1329 until); 1276 until);
1330
1331 if (!ret && signal_pending(current))
1332 ret = -EINTR;
1333
1334 return ret; 1277 return ret;
1335} 1278}
1336 1279
@@ -1446,6 +1389,58 @@ SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx)
1446 return -EINVAL; 1389 return -EINVAL;
1447} 1390}
1448 1391
1392static void aio_remove_iocb(struct aio_kiocb *iocb)
1393{
1394 struct kioctx *ctx = iocb->ki_ctx;
1395 unsigned long flags;
1396
1397 spin_lock_irqsave(&ctx->ctx_lock, flags);
1398 list_del(&iocb->ki_list);
1399 spin_unlock_irqrestore(&ctx->ctx_lock, flags);
1400}
1401
1402static void aio_complete_rw(struct kiocb *kiocb, long res, long res2)
1403{
1404 struct aio_kiocb *iocb = container_of(kiocb, struct aio_kiocb, rw);
1405
1406 if (!list_empty_careful(&iocb->ki_list))
1407 aio_remove_iocb(iocb);
1408
1409 if (kiocb->ki_flags & IOCB_WRITE) {
1410 struct inode *inode = file_inode(kiocb->ki_filp);
1411
1412 /*
1413 * Tell lockdep we inherited freeze protection from submission
1414 * thread.
1415 */
1416 if (S_ISREG(inode->i_mode))
1417 __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
1418 file_end_write(kiocb->ki_filp);
1419 }
1420
1421 fput(kiocb->ki_filp);
1422 aio_complete(iocb, res, res2);
1423}
1424
1425static int aio_prep_rw(struct kiocb *req, struct iocb *iocb)
1426{
1427 int ret;
1428
1429 req->ki_filp = fget(iocb->aio_fildes);
1430 if (unlikely(!req->ki_filp))
1431 return -EBADF;
1432 req->ki_complete = aio_complete_rw;
1433 req->ki_pos = iocb->aio_offset;
1434 req->ki_flags = iocb_flags(req->ki_filp);
1435 if (iocb->aio_flags & IOCB_FLAG_RESFD)
1436 req->ki_flags |= IOCB_EVENTFD;
1437 req->ki_hint = file_write_hint(req->ki_filp);
1438 ret = kiocb_set_rw_flags(req, iocb->aio_rw_flags);
1439 if (unlikely(ret))
1440 fput(req->ki_filp);
1441 return ret;
1442}
1443
1449static int aio_setup_rw(int rw, struct iocb *iocb, struct iovec **iovec, 1444static int aio_setup_rw(int rw, struct iocb *iocb, struct iovec **iovec,
1450 bool vectored, bool compat, struct iov_iter *iter) 1445 bool vectored, bool compat, struct iov_iter *iter)
1451{ 1446{
@@ -1465,11 +1460,11 @@ static int aio_setup_rw(int rw, struct iocb *iocb, struct iovec **iovec,
1465 return import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter); 1460 return import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter);
1466} 1461}
1467 1462
1468static inline ssize_t aio_ret(struct kiocb *req, ssize_t ret) 1463static inline void aio_rw_done(struct kiocb *req, ssize_t ret)
1469{ 1464{
1470 switch (ret) { 1465 switch (ret) {
1471 case -EIOCBQUEUED: 1466 case -EIOCBQUEUED:
1472 return ret; 1467 break;
1473 case -ERESTARTSYS: 1468 case -ERESTARTSYS:
1474 case -ERESTARTNOINTR: 1469 case -ERESTARTNOINTR:
1475 case -ERESTARTNOHAND: 1470 case -ERESTARTNOHAND:
@@ -1481,85 +1476,270 @@ static inline ssize_t aio_ret(struct kiocb *req, ssize_t ret)
1481 ret = -EINTR; 1476 ret = -EINTR;
1482 /*FALLTHRU*/ 1477 /*FALLTHRU*/
1483 default: 1478 default:
1484 aio_complete(req, ret, 0); 1479 aio_complete_rw(req, ret, 0);
1485 return 0;
1486 } 1480 }
1487} 1481}
1488 1482
1489static ssize_t aio_read(struct kiocb *req, struct iocb *iocb, bool vectored, 1483static ssize_t aio_read(struct kiocb *req, struct iocb *iocb, bool vectored,
1490 bool compat) 1484 bool compat)
1491{ 1485{
1492 struct file *file = req->ki_filp;
1493 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1486 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1494 struct iov_iter iter; 1487 struct iov_iter iter;
1488 struct file *file;
1495 ssize_t ret; 1489 ssize_t ret;
1496 1490
1491 ret = aio_prep_rw(req, iocb);
1492 if (ret)
1493 return ret;
1494 file = req->ki_filp;
1495
1496 ret = -EBADF;
1497 if (unlikely(!(file->f_mode & FMODE_READ))) 1497 if (unlikely(!(file->f_mode & FMODE_READ)))
1498 return -EBADF; 1498 goto out_fput;
1499 ret = -EINVAL;
1499 if (unlikely(!file->f_op->read_iter)) 1500 if (unlikely(!file->f_op->read_iter))
1500 return -EINVAL; 1501 goto out_fput;
1501 1502
1502 ret = aio_setup_rw(READ, iocb, &iovec, vectored, compat, &iter); 1503 ret = aio_setup_rw(READ, iocb, &iovec, vectored, compat, &iter);
1503 if (ret) 1504 if (ret)
1504 return ret; 1505 goto out_fput;
1505 ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter)); 1506 ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));
1506 if (!ret) 1507 if (!ret)
1507 ret = aio_ret(req, call_read_iter(file, req, &iter)); 1508 aio_rw_done(req, call_read_iter(file, req, &iter));
1508 kfree(iovec); 1509 kfree(iovec);
1510out_fput:
1511 if (unlikely(ret))
1512 fput(file);
1509 return ret; 1513 return ret;
1510} 1514}
1511 1515
1512static ssize_t aio_write(struct kiocb *req, struct iocb *iocb, bool vectored, 1516static ssize_t aio_write(struct kiocb *req, struct iocb *iocb, bool vectored,
1513 bool compat) 1517 bool compat)
1514{ 1518{
1515 struct file *file = req->ki_filp;
1516 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1519 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1517 struct iov_iter iter; 1520 struct iov_iter iter;
1521 struct file *file;
1518 ssize_t ret; 1522 ssize_t ret;
1519 1523
1524 ret = aio_prep_rw(req, iocb);
1525 if (ret)
1526 return ret;
1527 file = req->ki_filp;
1528
1529 ret = -EBADF;
1520 if (unlikely(!(file->f_mode & FMODE_WRITE))) 1530 if (unlikely(!(file->f_mode & FMODE_WRITE)))
1521 return -EBADF; 1531 goto out_fput;
1532 ret = -EINVAL;
1522 if (unlikely(!file->f_op->write_iter)) 1533 if (unlikely(!file->f_op->write_iter))
1523 return -EINVAL; 1534 goto out_fput;
1524 1535
1525 ret = aio_setup_rw(WRITE, iocb, &iovec, vectored, compat, &iter); 1536 ret = aio_setup_rw(WRITE, iocb, &iovec, vectored, compat, &iter);
1526 if (ret) 1537 if (ret)
1527 return ret; 1538 goto out_fput;
1528 ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter)); 1539 ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter));
1529 if (!ret) { 1540 if (!ret) {
1530 req->ki_flags |= IOCB_WRITE;
1531 file_start_write(file);
1532 ret = aio_ret(req, call_write_iter(file, req, &iter));
1533 /* 1541 /*
1534 * We release freeze protection in aio_complete(). Fool lockdep 1542 * Open-code file_start_write here to grab freeze protection,
1535 * by telling it the lock got released so that it doesn't 1543 * which will be released by another thread in
1536 * complain about held lock when we return to userspace. 1544 * aio_complete_rw(). Fool lockdep by telling it the lock got
1545 * released so that it doesn't complain about the held lock when
1546 * we return to userspace.
1537 */ 1547 */
1538 if (S_ISREG(file_inode(file)->i_mode)) 1548 if (S_ISREG(file_inode(file)->i_mode)) {
1549 __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
1539 __sb_writers_release(file_inode(file)->i_sb, SB_FREEZE_WRITE); 1550 __sb_writers_release(file_inode(file)->i_sb, SB_FREEZE_WRITE);
1551 }
1552 req->ki_flags |= IOCB_WRITE;
1553 aio_rw_done(req, call_write_iter(file, req, &iter));
1540 } 1554 }
1541 kfree(iovec); 1555 kfree(iovec);
1556out_fput:
1557 if (unlikely(ret))
1558 fput(file);
1542 return ret; 1559 return ret;
1543} 1560}
1544 1561
1562static void aio_fsync_work(struct work_struct *work)
1563{
1564 struct fsync_iocb *req = container_of(work, struct fsync_iocb, work);
1565 int ret;
1566
1567 ret = vfs_fsync(req->file, req->datasync);
1568 fput(req->file);
1569 aio_complete(container_of(req, struct aio_kiocb, fsync), ret, 0);
1570}
1571
1572static int aio_fsync(struct fsync_iocb *req, struct iocb *iocb, bool datasync)
1573{
1574 if (unlikely(iocb->aio_buf || iocb->aio_offset || iocb->aio_nbytes ||
1575 iocb->aio_rw_flags))
1576 return -EINVAL;
1577 req->file = fget(iocb->aio_fildes);
1578 if (unlikely(!req->file))
1579 return -EBADF;
1580 if (unlikely(!req->file->f_op->fsync)) {
1581 fput(req->file);
1582 return -EINVAL;
1583 }
1584
1585 req->datasync = datasync;
1586 INIT_WORK(&req->work, aio_fsync_work);
1587 schedule_work(&req->work);
1588 return 0;
1589}
1590
1591/* need to use list_del_init so we can check if item was present */
1592static inline bool __aio_poll_remove(struct poll_iocb *req)
1593{
1594 if (list_empty(&req->wait.entry))
1595 return false;
1596 list_del_init(&req->wait.entry);
1597 return true;
1598}
1599
1600static inline void __aio_poll_complete(struct aio_kiocb *iocb, __poll_t mask)
1601{
1602 fput(iocb->poll.file);
1603 aio_complete(iocb, mangle_poll(mask), 0);
1604}
1605
1606static void aio_poll_work(struct work_struct *work)
1607{
1608 struct aio_kiocb *iocb = container_of(work, struct aio_kiocb, poll.work);
1609
1610 if (!list_empty_careful(&iocb->ki_list))
1611 aio_remove_iocb(iocb);
1612 __aio_poll_complete(iocb, iocb->poll.events);
1613}
1614
1615static int aio_poll_cancel(struct kiocb *iocb)
1616{
1617 struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);
1618 struct poll_iocb *req = &aiocb->poll;
1619 struct wait_queue_head *head = req->head;
1620 bool found = false;
1621
1622 spin_lock(&head->lock);
1623 found = __aio_poll_remove(req);
1624 spin_unlock(&head->lock);
1625
1626 if (found) {
1627 req->events = 0;
1628 INIT_WORK(&req->work, aio_poll_work);
1629 schedule_work(&req->work);
1630 }
1631 return 0;
1632}
1633
1634static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
1635 void *key)
1636{
1637 struct poll_iocb *req = container_of(wait, struct poll_iocb, wait);
1638 struct aio_kiocb *iocb = container_of(req, struct aio_kiocb, poll);
1639 struct file *file = req->file;
1640 __poll_t mask = key_to_poll(key);
1641
1642 assert_spin_locked(&req->head->lock);
1643
1644 /* for instances that support it check for an event match first: */
1645 if (mask && !(mask & req->events))
1646 return 0;
1647
1648 mask = file->f_op->poll_mask(file, req->events);
1649 if (!mask)
1650 return 0;
1651
1652 __aio_poll_remove(req);
1653
1654 /*
1655 * Try completing without a context switch if we can acquire ctx_lock
1656 * without spinning. Otherwise we need to defer to a workqueue to
1657 * avoid a deadlock due to the lock order.
1658 */
1659 if (spin_trylock(&iocb->ki_ctx->ctx_lock)) {
1660 list_del_init(&iocb->ki_list);
1661 spin_unlock(&iocb->ki_ctx->ctx_lock);
1662
1663 __aio_poll_complete(iocb, mask);
1664 } else {
1665 req->events = mask;
1666 INIT_WORK(&req->work, aio_poll_work);
1667 schedule_work(&req->work);
1668 }
1669
1670 return 1;
1671}
1672
1673static ssize_t aio_poll(struct aio_kiocb *aiocb, struct iocb *iocb)
1674{
1675 struct kioctx *ctx = aiocb->ki_ctx;
1676 struct poll_iocb *req = &aiocb->poll;
1677 __poll_t mask;
1678
1679 /* reject any unknown events outside the normal event mask. */
1680 if ((u16)iocb->aio_buf != iocb->aio_buf)
1681 return -EINVAL;
1682 /* reject fields that are not defined for poll */
1683 if (iocb->aio_offset || iocb->aio_nbytes || iocb->aio_rw_flags)
1684 return -EINVAL;
1685
1686 req->events = demangle_poll(iocb->aio_buf) | EPOLLERR | EPOLLHUP;
1687 req->file = fget(iocb->aio_fildes);
1688 if (unlikely(!req->file))
1689 return -EBADF;
1690 if (!file_has_poll_mask(req->file))
1691 goto out_fail;
1692
1693 req->head = req->file->f_op->get_poll_head(req->file, req->events);
1694 if (!req->head)
1695 goto out_fail;
1696 if (IS_ERR(req->head)) {
1697 mask = EPOLLERR;
1698 goto done;
1699 }
1700
1701 init_waitqueue_func_entry(&req->wait, aio_poll_wake);
1702 aiocb->ki_cancel = aio_poll_cancel;
1703
1704 spin_lock_irq(&ctx->ctx_lock);
1705 spin_lock(&req->head->lock);
1706 mask = req->file->f_op->poll_mask(req->file, req->events);
1707 if (!mask) {
1708 __add_wait_queue(req->head, &req->wait);
1709 list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
1710 }
1711 spin_unlock(&req->head->lock);
1712 spin_unlock_irq(&ctx->ctx_lock);
1713done:
1714 if (mask)
1715 __aio_poll_complete(aiocb, mask);
1716 return 0;
1717out_fail:
1718 fput(req->file);
1719 return -EINVAL; /* same as no support for IOCB_CMD_POLL */
1720}
1721
1545static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb, 1722static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
1546 struct iocb *iocb, bool compat) 1723 bool compat)
1547{ 1724{
1548 struct aio_kiocb *req; 1725 struct aio_kiocb *req;
1549 struct file *file; 1726 struct iocb iocb;
1550 ssize_t ret; 1727 ssize_t ret;
1551 1728
1729 if (unlikely(copy_from_user(&iocb, user_iocb, sizeof(iocb))))
1730 return -EFAULT;
1731
1552 /* enforce forwards compatibility on users */ 1732 /* enforce forwards compatibility on users */
1553 if (unlikely(iocb->aio_reserved2)) { 1733 if (unlikely(iocb.aio_reserved2)) {
1554 pr_debug("EINVAL: reserve field set\n"); 1734 pr_debug("EINVAL: reserve field set\n");
1555 return -EINVAL; 1735 return -EINVAL;
1556 } 1736 }
1557 1737
1558 /* prevent overflows */ 1738 /* prevent overflows */
1559 if (unlikely( 1739 if (unlikely(
1560 (iocb->aio_buf != (unsigned long)iocb->aio_buf) || 1740 (iocb.aio_buf != (unsigned long)iocb.aio_buf) ||
1561 (iocb->aio_nbytes != (size_t)iocb->aio_nbytes) || 1741 (iocb.aio_nbytes != (size_t)iocb.aio_nbytes) ||
1562 ((ssize_t)iocb->aio_nbytes < 0) 1742 ((ssize_t)iocb.aio_nbytes < 0)
1563 )) { 1743 )) {
1564 pr_debug("EINVAL: overflow check\n"); 1744 pr_debug("EINVAL: overflow check\n");
1565 return -EINVAL; 1745 return -EINVAL;
@@ -1569,37 +1749,19 @@ static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
1569 if (unlikely(!req)) 1749 if (unlikely(!req))
1570 return -EAGAIN; 1750 return -EAGAIN;
1571 1751
1572 req->common.ki_filp = file = fget(iocb->aio_fildes); 1752 if (iocb.aio_flags & IOCB_FLAG_RESFD) {
1573 if (unlikely(!req->common.ki_filp)) {
1574 ret = -EBADF;
1575 goto out_put_req;
1576 }
1577 req->common.ki_pos = iocb->aio_offset;
1578 req->common.ki_complete = aio_complete;
1579 req->common.ki_flags = iocb_flags(req->common.ki_filp);
1580 req->common.ki_hint = file_write_hint(file);
1581
1582 if (iocb->aio_flags & IOCB_FLAG_RESFD) {
1583 /* 1753 /*
1584 * If the IOCB_FLAG_RESFD flag of aio_flags is set, get an 1754 * If the IOCB_FLAG_RESFD flag of aio_flags is set, get an
1585 * instance of the file* now. The file descriptor must be 1755 * instance of the file* now. The file descriptor must be
1586 * an eventfd() fd, and will be signaled for each completed 1756 * an eventfd() fd, and will be signaled for each completed
1587 * event using the eventfd_signal() function. 1757 * event using the eventfd_signal() function.
1588 */ 1758 */
1589 req->ki_eventfd = eventfd_ctx_fdget((int) iocb->aio_resfd); 1759 req->ki_eventfd = eventfd_ctx_fdget((int) iocb.aio_resfd);
1590 if (IS_ERR(req->ki_eventfd)) { 1760 if (IS_ERR(req->ki_eventfd)) {
1591 ret = PTR_ERR(req->ki_eventfd); 1761 ret = PTR_ERR(req->ki_eventfd);
1592 req->ki_eventfd = NULL; 1762 req->ki_eventfd = NULL;
1593 goto out_put_req; 1763 goto out_put_req;
1594 } 1764 }
1595
1596 req->common.ki_flags |= IOCB_EVENTFD;
1597 }
1598
1599 ret = kiocb_set_rw_flags(&req->common, iocb->aio_rw_flags);
1600 if (unlikely(ret)) {
1601 pr_debug("EINVAL: aio_rw_flags\n");
1602 goto out_put_req;
1603 } 1765 }
1604 1766
1605 ret = put_user(KIOCB_KEY, &user_iocb->aio_key); 1767 ret = put_user(KIOCB_KEY, &user_iocb->aio_key);
@@ -1609,41 +1771,67 @@ static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
1609 } 1771 }
1610 1772
1611 req->ki_user_iocb = user_iocb; 1773 req->ki_user_iocb = user_iocb;
1612 req->ki_user_data = iocb->aio_data; 1774 req->ki_user_data = iocb.aio_data;
1613 1775
1614 get_file(file); 1776 switch (iocb.aio_lio_opcode) {
1615 switch (iocb->aio_lio_opcode) {
1616 case IOCB_CMD_PREAD: 1777 case IOCB_CMD_PREAD:
1617 ret = aio_read(&req->common, iocb, false, compat); 1778 ret = aio_read(&req->rw, &iocb, false, compat);
1618 break; 1779 break;
1619 case IOCB_CMD_PWRITE: 1780 case IOCB_CMD_PWRITE:
1620 ret = aio_write(&req->common, iocb, false, compat); 1781 ret = aio_write(&req->rw, &iocb, false, compat);
1621 break; 1782 break;
1622 case IOCB_CMD_PREADV: 1783 case IOCB_CMD_PREADV:
1623 ret = aio_read(&req->common, iocb, true, compat); 1784 ret = aio_read(&req->rw, &iocb, true, compat);
1624 break; 1785 break;
1625 case IOCB_CMD_PWRITEV: 1786 case IOCB_CMD_PWRITEV:
1626 ret = aio_write(&req->common, iocb, true, compat); 1787 ret = aio_write(&req->rw, &iocb, true, compat);
1788 break;
1789 case IOCB_CMD_FSYNC:
1790 ret = aio_fsync(&req->fsync, &iocb, false);
1791 break;
1792 case IOCB_CMD_FDSYNC:
1793 ret = aio_fsync(&req->fsync, &iocb, true);
1794 break;
1795 case IOCB_CMD_POLL:
1796 ret = aio_poll(req, &iocb);
1627 break; 1797 break;
1628 default: 1798 default:
1629 pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode); 1799 pr_debug("invalid aio operation %d\n", iocb.aio_lio_opcode);
1630 ret = -EINVAL; 1800 ret = -EINVAL;
1631 break; 1801 break;
1632 } 1802 }
1633 fput(file);
1634 1803
1635 if (ret && ret != -EIOCBQUEUED) 1804 /*
1805 * If ret is 0, we'd either done aio_complete() ourselves or have
1806 * arranged for that to be done asynchronously. Anything non-zero
1807 * means that we need to destroy req ourselves.
1808 */
1809 if (ret)
1636 goto out_put_req; 1810 goto out_put_req;
1637 return 0; 1811 return 0;
1638out_put_req: 1812out_put_req:
1639 put_reqs_available(ctx, 1); 1813 put_reqs_available(ctx, 1);
1640 percpu_ref_put(&ctx->reqs); 1814 percpu_ref_put(&ctx->reqs);
1641 kiocb_free(req); 1815 if (req->ki_eventfd)
1816 eventfd_ctx_put(req->ki_eventfd);
1817 kmem_cache_free(kiocb_cachep, req);
1642 return ret; 1818 return ret;
1643} 1819}
1644 1820
1645static long do_io_submit(aio_context_t ctx_id, long nr, 1821/* sys_io_submit:
1646 struct iocb __user *__user *iocbpp, bool compat) 1822 * Queue the nr iocbs pointed to by iocbpp for processing. Returns
1823 * the number of iocbs queued. May return -EINVAL if the aio_context
1824 * specified by ctx_id is invalid, if nr is < 0, if the iocb at
1825 * *iocbpp[0] is not properly initialized, if the operation specified
1826 * is invalid for the file descriptor in the iocb. May fail with
1827 * -EFAULT if any of the data structures point to invalid data. May
1828 * fail with -EBADF if the file descriptor specified in the first
1829 * iocb is invalid. May fail with -EAGAIN if insufficient resources
1830 * are available to queue any iocbs. Will return 0 if nr is 0. Will
1831 * fail with -ENOSYS if not implemented.
1832 */
1833SYSCALL_DEFINE3(io_submit, aio_context_t, ctx_id, long, nr,
1834 struct iocb __user * __user *, iocbpp)
1647{ 1835{
1648 struct kioctx *ctx; 1836 struct kioctx *ctx;
1649 long ret = 0; 1837 long ret = 0;
@@ -1653,39 +1841,25 @@ static long do_io_submit(aio_context_t ctx_id, long nr,
1653 if (unlikely(nr < 0)) 1841 if (unlikely(nr < 0))
1654 return -EINVAL; 1842 return -EINVAL;
1655 1843
1656 if (unlikely(nr > LONG_MAX/sizeof(*iocbpp)))
1657 nr = LONG_MAX/sizeof(*iocbpp);
1658
1659 if (unlikely(!access_ok(VERIFY_READ, iocbpp, (nr*sizeof(*iocbpp)))))
1660 return -EFAULT;
1661
1662 ctx = lookup_ioctx(ctx_id); 1844 ctx = lookup_ioctx(ctx_id);
1663 if (unlikely(!ctx)) { 1845 if (unlikely(!ctx)) {
1664 pr_debug("EINVAL: invalid context id\n"); 1846 pr_debug("EINVAL: invalid context id\n");
1665 return -EINVAL; 1847 return -EINVAL;
1666 } 1848 }
1667 1849
1668 blk_start_plug(&plug); 1850 if (nr > ctx->nr_events)
1851 nr = ctx->nr_events;
1669 1852
1670 /* 1853 blk_start_plug(&plug);
1671 * AKPM: should this return a partial result if some of the IOs were 1854 for (i = 0; i < nr; i++) {
1672 * successfully submitted?
1673 */
1674 for (i=0; i<nr; i++) {
1675 struct iocb __user *user_iocb; 1855 struct iocb __user *user_iocb;
1676 struct iocb tmp;
1677 1856
1678 if (unlikely(__get_user(user_iocb, iocbpp + i))) { 1857 if (unlikely(get_user(user_iocb, iocbpp + i))) {
1679 ret = -EFAULT; 1858 ret = -EFAULT;
1680 break; 1859 break;
1681 } 1860 }
1682 1861
1683 if (unlikely(copy_from_user(&tmp, user_iocb, sizeof(tmp)))) { 1862 ret = io_submit_one(ctx, user_iocb, false);
1684 ret = -EFAULT;
1685 break;
1686 }
1687
1688 ret = io_submit_one(ctx, user_iocb, &tmp, compat);
1689 if (ret) 1863 if (ret)
1690 break; 1864 break;
1691 } 1865 }
@@ -1695,59 +1869,44 @@ static long do_io_submit(aio_context_t ctx_id, long nr,
1695 return i ? i : ret; 1869 return i ? i : ret;
1696} 1870}
1697 1871
1698/* sys_io_submit:
1699 * Queue the nr iocbs pointed to by iocbpp for processing. Returns
1700 * the number of iocbs queued. May return -EINVAL if the aio_context
1701 * specified by ctx_id is invalid, if nr is < 0, if the iocb at
1702 * *iocbpp[0] is not properly initialized, if the operation specified
1703 * is invalid for the file descriptor in the iocb. May fail with
1704 * -EFAULT if any of the data structures point to invalid data. May
1705 * fail with -EBADF if the file descriptor specified in the first
1706 * iocb is invalid. May fail with -EAGAIN if insufficient resources
1707 * are available to queue any iocbs. Will return 0 if nr is 0. Will
1708 * fail with -ENOSYS if not implemented.
1709 */
1710SYSCALL_DEFINE3(io_submit, aio_context_t, ctx_id, long, nr,
1711 struct iocb __user * __user *, iocbpp)
1712{
1713 return do_io_submit(ctx_id, nr, iocbpp, 0);
1714}
1715
1716#ifdef CONFIG_COMPAT 1872#ifdef CONFIG_COMPAT
1717static inline long 1873COMPAT_SYSCALL_DEFINE3(io_submit, compat_aio_context_t, ctx_id,
1718copy_iocb(long nr, u32 __user *ptr32, struct iocb __user * __user *ptr64) 1874 int, nr, compat_uptr_t __user *, iocbpp)
1719{ 1875{
1720 compat_uptr_t uptr; 1876 struct kioctx *ctx;
1721 int i; 1877 long ret = 0;
1878 int i = 0;
1879 struct blk_plug plug;
1722 1880
1723 for (i = 0; i < nr; ++i) { 1881 if (unlikely(nr < 0))
1724 if (get_user(uptr, ptr32 + i)) 1882 return -EINVAL;
1725 return -EFAULT; 1883
1726 if (put_user(compat_ptr(uptr), ptr64 + i)) 1884 ctx = lookup_ioctx(ctx_id);
1727 return -EFAULT; 1885 if (unlikely(!ctx)) {
1886 pr_debug("EINVAL: invalid context id\n");
1887 return -EINVAL;
1728 } 1888 }
1729 return 0;
1730}
1731 1889
1732#define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *)) 1890 if (nr > ctx->nr_events)
1891 nr = ctx->nr_events;
1733 1892
1734COMPAT_SYSCALL_DEFINE3(io_submit, compat_aio_context_t, ctx_id, 1893 blk_start_plug(&plug);
1735 int, nr, u32 __user *, iocb) 1894 for (i = 0; i < nr; i++) {
1736{ 1895 compat_uptr_t user_iocb;
1737 struct iocb __user * __user *iocb64;
1738 long ret;
1739 1896
1740 if (unlikely(nr < 0)) 1897 if (unlikely(get_user(user_iocb, iocbpp + i))) {
1741 return -EINVAL; 1898 ret = -EFAULT;
1899 break;
1900 }
1742 1901
1743 if (nr > MAX_AIO_SUBMITS) 1902 ret = io_submit_one(ctx, compat_ptr(user_iocb), true);
1744 nr = MAX_AIO_SUBMITS; 1903 if (ret)
1904 break;
1905 }
1906 blk_finish_plug(&plug);
1745 1907
1746 iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64)); 1908 percpu_ref_put(&ctx->users);
1747 ret = copy_iocb(nr, iocb, iocb64); 1909 return i ? i : ret;
1748 if (!ret)
1749 ret = do_io_submit(ctx_id, nr, iocb64, 1);
1750 return ret;
1751} 1910}
1752#endif 1911#endif
1753 1912
@@ -1755,15 +1914,12 @@ COMPAT_SYSCALL_DEFINE3(io_submit, compat_aio_context_t, ctx_id,
1755 * Finds a given iocb for cancellation. 1914 * Finds a given iocb for cancellation.
1756 */ 1915 */
1757static struct aio_kiocb * 1916static struct aio_kiocb *
1758lookup_kiocb(struct kioctx *ctx, struct iocb __user *iocb, u32 key) 1917lookup_kiocb(struct kioctx *ctx, struct iocb __user *iocb)
1759{ 1918{
1760 struct aio_kiocb *kiocb; 1919 struct aio_kiocb *kiocb;
1761 1920
1762 assert_spin_locked(&ctx->ctx_lock); 1921 assert_spin_locked(&ctx->ctx_lock);
1763 1922
1764 if (key != KIOCB_KEY)
1765 return NULL;
1766
1767 /* TODO: use a hash or array, this sucks. */ 1923 /* TODO: use a hash or array, this sucks. */
1768 list_for_each_entry(kiocb, &ctx->active_reqs, ki_list) { 1924 list_for_each_entry(kiocb, &ctx->active_reqs, ki_list) {
1769 if (kiocb->ki_user_iocb == iocb) 1925 if (kiocb->ki_user_iocb == iocb)
@@ -1787,25 +1943,24 @@ SYSCALL_DEFINE3(io_cancel, aio_context_t, ctx_id, struct iocb __user *, iocb,
1787{ 1943{
1788 struct kioctx *ctx; 1944 struct kioctx *ctx;
1789 struct aio_kiocb *kiocb; 1945 struct aio_kiocb *kiocb;
1946 int ret = -EINVAL;
1790 u32 key; 1947 u32 key;
1791 int ret;
1792 1948
1793 ret = get_user(key, &iocb->aio_key); 1949 if (unlikely(get_user(key, &iocb->aio_key)))
1794 if (unlikely(ret))
1795 return -EFAULT; 1950 return -EFAULT;
1951 if (unlikely(key != KIOCB_KEY))
1952 return -EINVAL;
1796 1953
1797 ctx = lookup_ioctx(ctx_id); 1954 ctx = lookup_ioctx(ctx_id);
1798 if (unlikely(!ctx)) 1955 if (unlikely(!ctx))
1799 return -EINVAL; 1956 return -EINVAL;
1800 1957
1801 spin_lock_irq(&ctx->ctx_lock); 1958 spin_lock_irq(&ctx->ctx_lock);
1802 1959 kiocb = lookup_kiocb(ctx, iocb);
1803 kiocb = lookup_kiocb(ctx, iocb, key); 1960 if (kiocb) {
1804 if (kiocb) 1961 ret = kiocb->ki_cancel(&kiocb->rw);
1805 ret = kiocb_cancel(kiocb); 1962 list_del_init(&kiocb->ki_list);
1806 else 1963 }
1807 ret = -EINVAL;
1808
1809 spin_unlock_irq(&ctx->ctx_lock); 1964 spin_unlock_irq(&ctx->ctx_lock);
1810 1965
1811 if (!ret) { 1966 if (!ret) {
@@ -1860,13 +2015,60 @@ SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
1860 struct timespec __user *, timeout) 2015 struct timespec __user *, timeout)
1861{ 2016{
1862 struct timespec64 ts; 2017 struct timespec64 ts;
2018 int ret;
2019
2020 if (timeout && unlikely(get_timespec64(&ts, timeout)))
2021 return -EFAULT;
2022
2023 ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
2024 if (!ret && signal_pending(current))
2025 ret = -EINTR;
2026 return ret;
2027}
2028
2029SYSCALL_DEFINE6(io_pgetevents,
2030 aio_context_t, ctx_id,
2031 long, min_nr,
2032 long, nr,
2033 struct io_event __user *, events,
2034 struct timespec __user *, timeout,
2035 const struct __aio_sigset __user *, usig)
2036{
2037 struct __aio_sigset ksig = { NULL, };
2038 sigset_t ksigmask, sigsaved;
2039 struct timespec64 ts;
2040 int ret;
2041
2042 if (timeout && unlikely(get_timespec64(&ts, timeout)))
2043 return -EFAULT;
2044
2045 if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
2046 return -EFAULT;
1863 2047
1864 if (timeout) { 2048 if (ksig.sigmask) {
1865 if (unlikely(get_timespec64(&ts, timeout))) 2049 if (ksig.sigsetsize != sizeof(sigset_t))
2050 return -EINVAL;
2051 if (copy_from_user(&ksigmask, ksig.sigmask, sizeof(ksigmask)))
1866 return -EFAULT; 2052 return -EFAULT;
2053 sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2054 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
2055 }
2056
2057 ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
2058 if (signal_pending(current)) {
2059 if (ksig.sigmask) {
2060 current->saved_sigmask = sigsaved;
2061 set_restore_sigmask();
2062 }
2063
2064 if (!ret)
2065 ret = -ERESTARTNOHAND;
2066 } else {
2067 if (ksig.sigmask)
2068 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1867 } 2069 }
1868 2070
1869 return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL); 2071 return ret;
1870} 2072}
1871 2073
1872#ifdef CONFIG_COMPAT 2074#ifdef CONFIG_COMPAT
@@ -1877,13 +2079,64 @@ COMPAT_SYSCALL_DEFINE5(io_getevents, compat_aio_context_t, ctx_id,
1877 struct compat_timespec __user *, timeout) 2079 struct compat_timespec __user *, timeout)
1878{ 2080{
1879 struct timespec64 t; 2081 struct timespec64 t;
2082 int ret;
2083
2084 if (timeout && compat_get_timespec64(&t, timeout))
2085 return -EFAULT;
2086
2087 ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
2088 if (!ret && signal_pending(current))
2089 ret = -EINTR;
2090 return ret;
2091}
2092
2093
2094struct __compat_aio_sigset {
2095 compat_sigset_t __user *sigmask;
2096 compat_size_t sigsetsize;
2097};
2098
2099COMPAT_SYSCALL_DEFINE6(io_pgetevents,
2100 compat_aio_context_t, ctx_id,
2101 compat_long_t, min_nr,
2102 compat_long_t, nr,
2103 struct io_event __user *, events,
2104 struct compat_timespec __user *, timeout,
2105 const struct __compat_aio_sigset __user *, usig)
2106{
2107 struct __compat_aio_sigset ksig = { NULL, };
2108 sigset_t ksigmask, sigsaved;
2109 struct timespec64 t;
2110 int ret;
2111
2112 if (timeout && compat_get_timespec64(&t, timeout))
2113 return -EFAULT;
2114
2115 if (usig && copy_from_user(&ksig, usig, sizeof(ksig)))
2116 return -EFAULT;
1880 2117
1881 if (timeout) { 2118 if (ksig.sigmask) {
1882 if (compat_get_timespec64(&t, timeout)) 2119 if (ksig.sigsetsize != sizeof(compat_sigset_t))
2120 return -EINVAL;
2121 if (get_compat_sigset(&ksigmask, ksig.sigmask))
1883 return -EFAULT; 2122 return -EFAULT;
2123 sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2124 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
2125 }
1884 2126
2127 ret = do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
2128 if (signal_pending(current)) {
2129 if (ksig.sigmask) {
2130 current->saved_sigmask = sigsaved;
2131 set_restore_sigmask();
2132 }
2133 if (!ret)
2134 ret = -ERESTARTNOHAND;
2135 } else {
2136 if (ksig.sigmask)
2137 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1885 } 2138 }
1886 2139
1887 return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL); 2140 return ret;
1888} 2141}
1889#endif 2142#endif
diff --git a/fs/eventfd.c b/fs/eventfd.c
index 08d3bd602f73..61c9514da5e9 100644
--- a/fs/eventfd.c
+++ b/fs/eventfd.c
@@ -101,14 +101,20 @@ static int eventfd_release(struct inode *inode, struct file *file)
101 return 0; 101 return 0;
102} 102}
103 103
104static __poll_t eventfd_poll(struct file *file, poll_table *wait) 104static struct wait_queue_head *
105eventfd_get_poll_head(struct file *file, __poll_t events)
106{
107 struct eventfd_ctx *ctx = file->private_data;
108
109 return &ctx->wqh;
110}
111
112static __poll_t eventfd_poll_mask(struct file *file, __poll_t eventmask)
105{ 113{
106 struct eventfd_ctx *ctx = file->private_data; 114 struct eventfd_ctx *ctx = file->private_data;
107 __poll_t events = 0; 115 __poll_t events = 0;
108 u64 count; 116 u64 count;
109 117
110 poll_wait(file, &ctx->wqh, wait);
111
112 /* 118 /*
113 * All writes to ctx->count occur within ctx->wqh.lock. This read 119 * All writes to ctx->count occur within ctx->wqh.lock. This read
114 * can be done outside ctx->wqh.lock because we know that poll_wait 120 * can be done outside ctx->wqh.lock because we know that poll_wait
@@ -305,7 +311,8 @@ static const struct file_operations eventfd_fops = {
305 .show_fdinfo = eventfd_show_fdinfo, 311 .show_fdinfo = eventfd_show_fdinfo,
306#endif 312#endif
307 .release = eventfd_release, 313 .release = eventfd_release,
308 .poll = eventfd_poll, 314 .get_poll_head = eventfd_get_poll_head,
315 .poll_mask = eventfd_poll_mask,
309 .read = eventfd_read, 316 .read = eventfd_read,
310 .write = eventfd_write, 317 .write = eventfd_write,
311 .llseek = noop_llseek, 318 .llseek = noop_llseek,
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 602ca4285b2e..67db22fe99c5 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -884,8 +884,7 @@ static __poll_t ep_item_poll(const struct epitem *epi, poll_table *pt,
884 884
885 pt->_key = epi->event.events; 885 pt->_key = epi->event.events;
886 if (!is_file_epoll(epi->ffd.file)) 886 if (!is_file_epoll(epi->ffd.file))
887 return epi->ffd.file->f_op->poll(epi->ffd.file, pt) & 887 return vfs_poll(epi->ffd.file, pt) & epi->event.events;
888 epi->event.events;
889 888
890 ep = epi->ffd.file->private_data; 889 ep = epi->ffd.file->private_data;
891 poll_wait(epi->ffd.file, &ep->poll_wait, pt); 890 poll_wait(epi->ffd.file, &ep->poll_wait, pt);
@@ -2025,7 +2024,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
2025 2024
2026 /* The target file descriptor must support poll */ 2025 /* The target file descriptor must support poll */
2027 error = -EPERM; 2026 error = -EPERM;
2028 if (!tf.file->f_op->poll) 2027 if (!file_can_poll(tf.file))
2029 goto error_tgt_fput; 2028 goto error_tgt_fput;
2030 2029
2031 /* Check if EPOLLWAKEUP is allowed */ 2030 /* Check if EPOLLWAKEUP is allowed */
diff --git a/fs/pipe.c b/fs/pipe.c
index 39d6f431da83..bb0840e234f3 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -509,19 +509,22 @@ static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
509 } 509 }
510} 510}
511 511
512/* No kernel lock held - fine */ 512static struct wait_queue_head *
513static __poll_t 513pipe_get_poll_head(struct file *filp, __poll_t events)
514pipe_poll(struct file *filp, poll_table *wait)
515{ 514{
516 __poll_t mask;
517 struct pipe_inode_info *pipe = filp->private_data; 515 struct pipe_inode_info *pipe = filp->private_data;
518 int nrbufs;
519 516
520 poll_wait(filp, &pipe->wait, wait); 517 return &pipe->wait;
518}
519
520/* No kernel lock held - fine */
521static __poll_t pipe_poll_mask(struct file *filp, __poll_t events)
522{
523 struct pipe_inode_info *pipe = filp->private_data;
524 int nrbufs = pipe->nrbufs;
525 __poll_t mask = 0;
521 526
522 /* Reading only -- no need for acquiring the semaphore. */ 527 /* Reading only -- no need for acquiring the semaphore. */
523 nrbufs = pipe->nrbufs;
524 mask = 0;
525 if (filp->f_mode & FMODE_READ) { 528 if (filp->f_mode & FMODE_READ) {
526 mask = (nrbufs > 0) ? EPOLLIN | EPOLLRDNORM : 0; 529 mask = (nrbufs > 0) ? EPOLLIN | EPOLLRDNORM : 0;
527 if (!pipe->writers && filp->f_version != pipe->w_counter) 530 if (!pipe->writers && filp->f_version != pipe->w_counter)
@@ -1020,7 +1023,8 @@ const struct file_operations pipefifo_fops = {
1020 .llseek = no_llseek, 1023 .llseek = no_llseek,
1021 .read_iter = pipe_read, 1024 .read_iter = pipe_read,
1022 .write_iter = pipe_write, 1025 .write_iter = pipe_write,
1023 .poll = pipe_poll, 1026 .get_poll_head = pipe_get_poll_head,
1027 .poll_mask = pipe_poll_mask,
1024 .unlocked_ioctl = pipe_ioctl, 1028 .unlocked_ioctl = pipe_ioctl,
1025 .release = pipe_release, 1029 .release = pipe_release,
1026 .fasync = pipe_fasync, 1030 .fasync = pipe_fasync,
diff --git a/fs/select.c b/fs/select.c
index ba879c51288f..bc3cc0f98896 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -34,6 +34,29 @@
34 34
35#include <linux/uaccess.h> 35#include <linux/uaccess.h>
36 36
37__poll_t vfs_poll(struct file *file, struct poll_table_struct *pt)
38{
39 if (file->f_op->poll) {
40 return file->f_op->poll(file, pt);
41 } else if (file_has_poll_mask(file)) {
42 unsigned int events = poll_requested_events(pt);
43 struct wait_queue_head *head;
44
45 if (pt && pt->_qproc) {
46 head = file->f_op->get_poll_head(file, events);
47 if (!head)
48 return DEFAULT_POLLMASK;
49 if (IS_ERR(head))
50 return EPOLLERR;
51 pt->_qproc(file, head, pt);
52 }
53
54 return file->f_op->poll_mask(file, events);
55 } else {
56 return DEFAULT_POLLMASK;
57 }
58}
59EXPORT_SYMBOL_GPL(vfs_poll);
37 60
38/* 61/*
39 * Estimate expected accuracy in ns from a timeval. 62 * Estimate expected accuracy in ns from a timeval.
@@ -233,7 +256,7 @@ static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
233 add_wait_queue(wait_address, &entry->wait); 256 add_wait_queue(wait_address, &entry->wait);
234} 257}
235 258
236int poll_schedule_timeout(struct poll_wqueues *pwq, int state, 259static int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
237 ktime_t *expires, unsigned long slack) 260 ktime_t *expires, unsigned long slack)
238{ 261{
239 int rc = -EINTR; 262 int rc = -EINTR;
@@ -258,7 +281,6 @@ int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
258 281
259 return rc; 282 return rc;
260} 283}
261EXPORT_SYMBOL(poll_schedule_timeout);
262 284
263/** 285/**
264 * poll_select_set_timeout - helper function to setup the timeout value 286 * poll_select_set_timeout - helper function to setup the timeout value
@@ -503,14 +525,10 @@ static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
503 continue; 525 continue;
504 f = fdget(i); 526 f = fdget(i);
505 if (f.file) { 527 if (f.file) {
506 const struct file_operations *f_op; 528 wait_key_set(wait, in, out, bit,
507 f_op = f.file->f_op; 529 busy_flag);
508 mask = DEFAULT_POLLMASK; 530 mask = vfs_poll(f.file, wait);
509 if (f_op->poll) { 531
510 wait_key_set(wait, in, out,
511 bit, busy_flag);
512 mask = (*f_op->poll)(f.file, wait);
513 }
514 fdput(f); 532 fdput(f);
515 if ((mask & POLLIN_SET) && (in & bit)) { 533 if ((mask & POLLIN_SET) && (in & bit)) {
516 res_in |= bit; 534 res_in |= bit;
@@ -813,34 +831,29 @@ static inline __poll_t do_pollfd(struct pollfd *pollfd, poll_table *pwait,
813 bool *can_busy_poll, 831 bool *can_busy_poll,
814 __poll_t busy_flag) 832 __poll_t busy_flag)
815{ 833{
816 __poll_t mask; 834 int fd = pollfd->fd;
817 int fd; 835 __poll_t mask = 0, filter;
818 836 struct fd f;
819 mask = 0; 837
820 fd = pollfd->fd; 838 if (fd < 0)
821 if (fd >= 0) { 839 goto out;
822 struct fd f = fdget(fd); 840 mask = EPOLLNVAL;
823 mask = EPOLLNVAL; 841 f = fdget(fd);
824 if (f.file) { 842 if (!f.file)
825 /* userland u16 ->events contains POLL... bitmap */ 843 goto out;
826 __poll_t filter = demangle_poll(pollfd->events) | 844
827 EPOLLERR | EPOLLHUP; 845 /* userland u16 ->events contains POLL... bitmap */
828 mask = DEFAULT_POLLMASK; 846 filter = demangle_poll(pollfd->events) | EPOLLERR | EPOLLHUP;
829 if (f.file->f_op->poll) { 847 pwait->_key = filter | busy_flag;
830 pwait->_key = filter; 848 mask = vfs_poll(f.file, pwait);
831 pwait->_key |= busy_flag; 849 if (mask & busy_flag)
832 mask = f.file->f_op->poll(f.file, pwait); 850 *can_busy_poll = true;
833 if (mask & busy_flag) 851 mask &= filter; /* Mask out unneeded events. */
834 *can_busy_poll = true; 852 fdput(f);
835 } 853
836 /* Mask out unneeded events. */ 854out:
837 mask &= filter;
838 fdput(f);
839 }
840 }
841 /* ... and so does ->revents */ 855 /* ... and so does ->revents */
842 pollfd->revents = mangle_poll(mask); 856 pollfd->revents = mangle_poll(mask);
843
844 return mask; 857 return mask;
845} 858}
846 859
diff --git a/fs/timerfd.c b/fs/timerfd.c
index cdad49da3ff7..d84a2bee4f82 100644
--- a/fs/timerfd.c
+++ b/fs/timerfd.c
@@ -226,21 +226,20 @@ static int timerfd_release(struct inode *inode, struct file *file)
226 kfree_rcu(ctx, rcu); 226 kfree_rcu(ctx, rcu);
227 return 0; 227 return 0;
228} 228}
229 229
230static __poll_t timerfd_poll(struct file *file, poll_table *wait) 230static struct wait_queue_head *timerfd_get_poll_head(struct file *file,
231 __poll_t eventmask)
231{ 232{
232 struct timerfd_ctx *ctx = file->private_data; 233 struct timerfd_ctx *ctx = file->private_data;
233 __poll_t events = 0;
234 unsigned long flags;
235 234
236 poll_wait(file, &ctx->wqh, wait); 235 return &ctx->wqh;
236}
237 237
238 spin_lock_irqsave(&ctx->wqh.lock, flags); 238static __poll_t timerfd_poll_mask(struct file *file, __poll_t eventmask)
239 if (ctx->ticks) 239{
240 events |= EPOLLIN; 240 struct timerfd_ctx *ctx = file->private_data;
241 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
242 241
243 return events; 242 return ctx->ticks ? EPOLLIN : 0;
244} 243}
245 244
246static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, 245static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
@@ -364,7 +363,8 @@ static long timerfd_ioctl(struct file *file, unsigned int cmd, unsigned long arg
364 363
365static const struct file_operations timerfd_fops = { 364static const struct file_operations timerfd_fops = {
366 .release = timerfd_release, 365 .release = timerfd_release,
367 .poll = timerfd_poll, 366 .get_poll_head = timerfd_get_poll_head,
367 .poll_mask = timerfd_poll_mask,
368 .read = timerfd_read, 368 .read = timerfd_read,
369 .llseek = noop_llseek, 369 .llseek = noop_llseek,
370 .show_fdinfo = timerfd_show, 370 .show_fdinfo = timerfd_show,
diff --git a/include/crypto/if_alg.h b/include/crypto/if_alg.h
index 482461d8931d..cc414db9da0a 100644
--- a/include/crypto/if_alg.h
+++ b/include/crypto/if_alg.h
@@ -245,8 +245,7 @@ ssize_t af_alg_sendpage(struct socket *sock, struct page *page,
245 int offset, size_t size, int flags); 245 int offset, size_t size, int flags);
246void af_alg_free_resources(struct af_alg_async_req *areq); 246void af_alg_free_resources(struct af_alg_async_req *areq);
247void af_alg_async_cb(struct crypto_async_request *_req, int err); 247void af_alg_async_cb(struct crypto_async_request *_req, int err);
248__poll_t af_alg_poll(struct file *file, struct socket *sock, 248__poll_t af_alg_poll_mask(struct socket *sock, __poll_t events);
249 poll_table *wait);
250struct af_alg_async_req *af_alg_alloc_areq(struct sock *sk, 249struct af_alg_async_req *af_alg_alloc_areq(struct sock *sk,
251 unsigned int areqlen); 250 unsigned int areqlen);
252int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags, 251int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags,
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 9d8aabecfe2d..b83e68dd006f 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -8,8 +8,6 @@ struct kioctx;
8struct kiocb; 8struct kiocb;
9struct mm_struct; 9struct mm_struct;
10 10
11#define KIOCB_KEY 0
12
13typedef int (kiocb_cancel_fn)(struct kiocb *); 11typedef int (kiocb_cancel_fn)(struct kiocb *);
14 12
15/* prototypes */ 13/* prototypes */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 081281ad5772..ad192057b887 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -330,6 +330,7 @@ extern int put_compat_rusage(const struct rusage *,
330 struct compat_rusage __user *); 330 struct compat_rusage __user *);
331 331
332struct compat_siginfo; 332struct compat_siginfo;
333struct __compat_aio_sigset;
333 334
334struct compat_dirent { 335struct compat_dirent {
335 u32 d_ino; 336 u32 d_ino;
@@ -553,6 +554,12 @@ asmlinkage long compat_sys_io_getevents(compat_aio_context_t ctx_id,
553 compat_long_t nr, 554 compat_long_t nr,
554 struct io_event __user *events, 555 struct io_event __user *events,
555 struct compat_timespec __user *timeout); 556 struct compat_timespec __user *timeout);
557asmlinkage long compat_sys_io_pgetevents(compat_aio_context_t ctx_id,
558 compat_long_t min_nr,
559 compat_long_t nr,
560 struct io_event __user *events,
561 struct compat_timespec __user *timeout,
562 const struct __compat_aio_sigset __user *usig);
556 563
557/* fs/cookies.c */ 564/* fs/cookies.c */
558asmlinkage long compat_sys_lookup_dcookie(u32, u32, char __user *, compat_size_t); 565asmlinkage long compat_sys_lookup_dcookie(u32, u32, char __user *, compat_size_t);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 7f86730b67a9..d4c37d371da5 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1711,6 +1711,8 @@ struct file_operations {
1711 int (*iterate) (struct file *, struct dir_context *); 1711 int (*iterate) (struct file *, struct dir_context *);
1712 int (*iterate_shared) (struct file *, struct dir_context *); 1712 int (*iterate_shared) (struct file *, struct dir_context *);
1713 __poll_t (*poll) (struct file *, struct poll_table_struct *); 1713 __poll_t (*poll) (struct file *, struct poll_table_struct *);
1714 struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
1715 __poll_t (*poll_mask) (struct file *, __poll_t);
1714 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 1716 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1715 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 1717 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1716 int (*mmap) (struct file *, struct vm_area_struct *); 1718 int (*mmap) (struct file *, struct vm_area_struct *);
diff --git a/include/linux/net.h b/include/linux/net.h
index 2248a052061d..3fd9d8c16581 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -147,6 +147,7 @@ struct proto_ops {
147 int (*getname) (struct socket *sock, 147 int (*getname) (struct socket *sock,
148 struct sockaddr *addr, 148 struct sockaddr *addr,
149 int peer); 149 int peer);
150 __poll_t (*poll_mask) (struct socket *sock, __poll_t events);
150 __poll_t (*poll) (struct file *file, struct socket *sock, 151 __poll_t (*poll) (struct file *file, struct socket *sock,
151 struct poll_table_struct *wait); 152 struct poll_table_struct *wait);
152 int (*ioctl) (struct socket *sock, unsigned int cmd, 153 int (*ioctl) (struct socket *sock, unsigned int cmd,
diff --git a/include/linux/poll.h b/include/linux/poll.h
index f45ebd017eaa..fdf86b4cbc71 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -74,6 +74,18 @@ static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
74 pt->_key = ~(__poll_t)0; /* all events enabled */ 74 pt->_key = ~(__poll_t)0; /* all events enabled */
75} 75}
76 76
77static inline bool file_has_poll_mask(struct file *file)
78{
79 return file->f_op->get_poll_head && file->f_op->poll_mask;
80}
81
82static inline bool file_can_poll(struct file *file)
83{
84 return file->f_op->poll || file_has_poll_mask(file);
85}
86
87__poll_t vfs_poll(struct file *file, struct poll_table_struct *pt);
88
77struct poll_table_entry { 89struct poll_table_entry {
78 struct file *filp; 90 struct file *filp;
79 __poll_t key; 91 __poll_t key;
@@ -96,8 +108,6 @@ struct poll_wqueues {
96 108
97extern void poll_initwait(struct poll_wqueues *pwq); 109extern void poll_initwait(struct poll_wqueues *pwq);
98extern void poll_freewait(struct poll_wqueues *pwq); 110extern void poll_freewait(struct poll_wqueues *pwq);
99extern int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
100 ktime_t *expires, unsigned long slack);
101extern u64 select_estimate_accuracy(struct timespec64 *tv); 111extern u64 select_estimate_accuracy(struct timespec64 *tv);
102 112
103#define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1) 113#define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1)
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 9065477ed255..89198379b39d 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -3250,8 +3250,7 @@ struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
3250 int *peeked, int *off, int *err); 3250 int *peeked, int *off, int *err);
3251struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, 3251struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
3252 int *err); 3252 int *err);
3253__poll_t datagram_poll(struct file *file, struct socket *sock, 3253__poll_t datagram_poll_mask(struct socket *sock, __poll_t events);
3254 struct poll_table_struct *wait);
3255int skb_copy_datagram_iter(const struct sk_buff *from, int offset, 3254int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
3256 struct iov_iter *to, int size); 3255 struct iov_iter *to, int size);
3257static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset, 3256static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset,
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 70fcda1a9049..811172fcb916 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -290,6 +290,12 @@ asmlinkage long sys_io_getevents(aio_context_t ctx_id,
290 long nr, 290 long nr,
291 struct io_event __user *events, 291 struct io_event __user *events,
292 struct timespec __user *timeout); 292 struct timespec __user *timeout);
293asmlinkage long sys_io_pgetevents(aio_context_t ctx_id,
294 long min_nr,
295 long nr,
296 struct io_event __user *events,
297 struct timespec __user *timeout,
298 const struct __aio_sigset *sig);
293 299
294/* fs/xattr.c */ 300/* fs/xattr.c */
295asmlinkage long sys_setxattr(const char __user *path, const char __user *name, 301asmlinkage long sys_setxattr(const char __user *path, const char __user *name,
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index ec9d6bc65855..53ce8176c313 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -271,7 +271,7 @@ int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
271 int flags); 271 int flags);
272int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg, 272int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
273 size_t len, int flags); 273 size_t len, int flags);
274__poll_t bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait); 274__poll_t bt_sock_poll_mask(struct socket *sock, __poll_t events);
275int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg); 275int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
276int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo); 276int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo);
277int bt_sock_wait_ready(struct sock *sk, unsigned long flags); 277int bt_sock_wait_ready(struct sock *sk, unsigned long flags);
diff --git a/include/net/busy_poll.h b/include/net/busy_poll.h
index 71c72a939bf8..c5187438af38 100644
--- a/include/net/busy_poll.h
+++ b/include/net/busy_poll.h
@@ -121,6 +121,21 @@ static inline void sk_busy_loop(struct sock *sk, int nonblock)
121#endif 121#endif
122} 122}
123 123
124static inline void sock_poll_busy_loop(struct socket *sock, __poll_t events)
125{
126 if (sk_can_busy_loop(sock->sk) &&
127 events && (events & POLL_BUSY_LOOP)) {
128 /* once, only if requested by syscall */
129 sk_busy_loop(sock->sk, 1);
130 }
131}
132
133/* if this socket can poll_ll, tell the system call */
134static inline __poll_t sock_poll_busy_flag(struct socket *sock)
135{
136 return sk_can_busy_loop(sock->sk) ? POLL_BUSY_LOOP : 0;
137}
138
124/* used in the NIC receive handler to mark the skb */ 139/* used in the NIC receive handler to mark the skb */
125static inline void skb_mark_napi_id(struct sk_buff *skb, 140static inline void skb_mark_napi_id(struct sk_buff *skb,
126 struct napi_struct *napi) 141 struct napi_struct *napi)
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index f4c21b5a1242..b0eaeb02d46d 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -153,8 +153,6 @@ struct iucv_sock_list {
153 atomic_t autobind_name; 153 atomic_t autobind_name;
154}; 154};
155 155
156__poll_t iucv_sock_poll(struct file *file, struct socket *sock,
157 poll_table *wait);
158void iucv_sock_link(struct iucv_sock_list *l, struct sock *s); 156void iucv_sock_link(struct iucv_sock_list *l, struct sock *s);
159void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *s); 157void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *s);
160void iucv_accept_enqueue(struct sock *parent, struct sock *sk); 158void iucv_accept_enqueue(struct sock *parent, struct sock *sk);
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 35498e613ff5..e6d349b2a791 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -109,8 +109,7 @@ int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb);
109int sctp_inet_listen(struct socket *sock, int backlog); 109int sctp_inet_listen(struct socket *sock, int backlog);
110void sctp_write_space(struct sock *sk); 110void sctp_write_space(struct sock *sk);
111void sctp_data_ready(struct sock *sk); 111void sctp_data_ready(struct sock *sk);
112__poll_t sctp_poll(struct file *file, struct socket *sock, 112__poll_t sctp_poll_mask(struct socket *sock, __poll_t events);
113 poll_table *wait);
114void sctp_sock_rfree(struct sk_buff *skb); 113void sctp_sock_rfree(struct sk_buff *skb);
115void sctp_copy_sock(struct sock *newsk, struct sock *sk, 114void sctp_copy_sock(struct sock *newsk, struct sock *sk,
116 struct sctp_association *asoc); 115 struct sctp_association *asoc);
diff --git a/include/net/sock.h b/include/net/sock.h
index 74d725fdbe0f..4d2e8ad98985 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1591,8 +1591,6 @@ int sock_no_connect(struct socket *, struct sockaddr *, int, int);
1591int sock_no_socketpair(struct socket *, struct socket *); 1591int sock_no_socketpair(struct socket *, struct socket *);
1592int sock_no_accept(struct socket *, struct socket *, int, bool); 1592int sock_no_accept(struct socket *, struct socket *, int, bool);
1593int sock_no_getname(struct socket *, struct sockaddr *, int); 1593int sock_no_getname(struct socket *, struct sockaddr *, int);
1594__poll_t sock_no_poll(struct file *, struct socket *,
1595 struct poll_table_struct *);
1596int sock_no_ioctl(struct socket *, unsigned int, unsigned long); 1594int sock_no_ioctl(struct socket *, unsigned int, unsigned long);
1597int sock_no_listen(struct socket *, int); 1595int sock_no_listen(struct socket *, int);
1598int sock_no_shutdown(struct socket *, int); 1596int sock_no_shutdown(struct socket *, int);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 51dc7a26a2fa..f88f8a2cab0d 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -388,8 +388,7 @@ bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst);
388void tcp_close(struct sock *sk, long timeout); 388void tcp_close(struct sock *sk, long timeout);
389void tcp_init_sock(struct sock *sk); 389void tcp_init_sock(struct sock *sk);
390void tcp_init_transfer(struct sock *sk, int bpf_op); 390void tcp_init_transfer(struct sock *sk, int bpf_op);
391__poll_t tcp_poll(struct file *file, struct socket *sock, 391__poll_t tcp_poll_mask(struct socket *sock, __poll_t events);
392 struct poll_table_struct *wait);
393int tcp_getsockopt(struct sock *sk, int level, int optname, 392int tcp_getsockopt(struct sock *sk, int level, int optname,
394 char __user *optval, int __user *optlen); 393 char __user *optval, int __user *optlen);
395int tcp_setsockopt(struct sock *sk, int level, int optname, 394int tcp_setsockopt(struct sock *sk, int level, int optname,
diff --git a/include/net/udp.h b/include/net/udp.h
index 621778b80e3d..d8ca3b26964d 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -276,7 +276,7 @@ int udp_init_sock(struct sock *sk);
276int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len); 276int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
277int __udp_disconnect(struct sock *sk, int flags); 277int __udp_disconnect(struct sock *sk, int flags);
278int udp_disconnect(struct sock *sk, int flags); 278int udp_disconnect(struct sock *sk, int flags);
279__poll_t udp_poll(struct file *file, struct socket *sock, poll_table *wait); 279__poll_t udp_poll_mask(struct socket *sock, __poll_t events);
280struct sk_buff *skb_udp_tunnel_segment(struct sk_buff *skb, 280struct sk_buff *skb_udp_tunnel_segment(struct sk_buff *skb,
281 netdev_features_t features, 281 netdev_features_t features,
282 bool is_ipv6); 282 bool is_ipv6);
diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/unistd.h
index 8bcb186c6f67..42990676a55e 100644
--- a/include/uapi/asm-generic/unistd.h
+++ b/include/uapi/asm-generic/unistd.h
@@ -732,9 +732,11 @@ __SYSCALL(__NR_pkey_alloc, sys_pkey_alloc)
732__SYSCALL(__NR_pkey_free, sys_pkey_free) 732__SYSCALL(__NR_pkey_free, sys_pkey_free)
733#define __NR_statx 291 733#define __NR_statx 291
734__SYSCALL(__NR_statx, sys_statx) 734__SYSCALL(__NR_statx, sys_statx)
735#define __NR_io_pgetevents 292
736__SC_COMP(__NR_io_pgetevents, sys_io_pgetevents, compat_sys_io_pgetevents)
735 737
736#undef __NR_syscalls 738#undef __NR_syscalls
737#define __NR_syscalls 292 739#define __NR_syscalls 293
738 740
739/* 741/*
740 * 32 bit systems traditionally used different 742 * 32 bit systems traditionally used different
diff --git a/include/uapi/linux/aio_abi.h b/include/uapi/linux/aio_abi.h
index a04adbc70ddf..ed0185945bb2 100644
--- a/include/uapi/linux/aio_abi.h
+++ b/include/uapi/linux/aio_abi.h
@@ -29,6 +29,7 @@
29 29
30#include <linux/types.h> 30#include <linux/types.h>
31#include <linux/fs.h> 31#include <linux/fs.h>
32#include <linux/signal.h>
32#include <asm/byteorder.h> 33#include <asm/byteorder.h>
33 34
34typedef __kernel_ulong_t aio_context_t; 35typedef __kernel_ulong_t aio_context_t;
@@ -38,10 +39,8 @@ enum {
38 IOCB_CMD_PWRITE = 1, 39 IOCB_CMD_PWRITE = 1,
39 IOCB_CMD_FSYNC = 2, 40 IOCB_CMD_FSYNC = 2,
40 IOCB_CMD_FDSYNC = 3, 41 IOCB_CMD_FDSYNC = 3,
41 /* These two are experimental. 42 /* 4 was the experimental IOCB_CMD_PREADX */
42 * IOCB_CMD_PREADX = 4, 43 IOCB_CMD_POLL = 5,
43 * IOCB_CMD_POLL = 5,
44 */
45 IOCB_CMD_NOOP = 6, 44 IOCB_CMD_NOOP = 6,
46 IOCB_CMD_PREADV = 7, 45 IOCB_CMD_PREADV = 7,
47 IOCB_CMD_PWRITEV = 8, 46 IOCB_CMD_PWRITEV = 8,
@@ -108,5 +107,10 @@ struct iocb {
108#undef IFBIG 107#undef IFBIG
109#undef IFLITTLE 108#undef IFLITTLE
110 109
110struct __aio_sigset {
111 sigset_t __user *sigmask;
112 size_t sigsetsize;
113};
114
111#endif /* __LINUX__AIO_ABI_H */ 115#endif /* __LINUX__AIO_ABI_H */
112 116
diff --git a/include/uapi/linux/types.h b/include/uapi/linux/types.h
index cd4f0b897a48..2fce8b6876e9 100644
--- a/include/uapi/linux/types.h
+++ b/include/uapi/linux/types.h
@@ -49,11 +49,7 @@ typedef __u32 __bitwise __wsum;
49#define __aligned_be64 __be64 __attribute__((aligned(8))) 49#define __aligned_be64 __be64 __attribute__((aligned(8)))
50#define __aligned_le64 __le64 __attribute__((aligned(8))) 50#define __aligned_le64 __le64 __attribute__((aligned(8)))
51 51
52#ifdef __CHECK_POLL
53typedef unsigned __bitwise __poll_t; 52typedef unsigned __bitwise __poll_t;
54#else
55typedef unsigned __poll_t;
56#endif
57 53
58#endif /* __ASSEMBLY__ */ 54#endif /* __ASSEMBLY__ */
59#endif /* _UAPI_LINUX_TYPES_H */ 55#endif /* _UAPI_LINUX_TYPES_H */
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 9791364925dc..183169c2a75b 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -43,7 +43,9 @@ COND_SYSCALL(io_submit);
43COND_SYSCALL_COMPAT(io_submit); 43COND_SYSCALL_COMPAT(io_submit);
44COND_SYSCALL(io_cancel); 44COND_SYSCALL(io_cancel);
45COND_SYSCALL(io_getevents); 45COND_SYSCALL(io_getevents);
46COND_SYSCALL(io_pgetevents);
46COND_SYSCALL_COMPAT(io_getevents); 47COND_SYSCALL_COMPAT(io_getevents);
48COND_SYSCALL_COMPAT(io_pgetevents);
47 49
48/* fs/xattr.c */ 50/* fs/xattr.c */
49 51
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 2bd3df3d101a..1695f38630f1 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -3849,7 +3849,7 @@ static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
3849 if (ret) 3849 if (ret)
3850 goto out_put_css; 3850 goto out_put_css;
3851 3851
3852 efile.file->f_op->poll(efile.file, &event->pt); 3852 vfs_poll(efile.file, &event->pt);
3853 3853
3854 spin_lock(&memcg->event_list_lock); 3854 spin_lock(&memcg->event_list_lock);
3855 list_add(&event->list, &memcg->event_list); 3855 list_add(&event->list, &memcg->event_list);
diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 848969fe7979..588bf88c3305 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -231,7 +231,7 @@ static void p9_conn_cancel(struct p9_conn *m, int err)
231static __poll_t 231static __poll_t
232p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err) 232p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err)
233{ 233{
234 __poll_t ret, n; 234 __poll_t ret;
235 struct p9_trans_fd *ts = NULL; 235 struct p9_trans_fd *ts = NULL;
236 236
237 if (client && client->status == Connected) 237 if (client && client->status == Connected)
@@ -243,19 +243,9 @@ p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err)
243 return EPOLLERR; 243 return EPOLLERR;
244 } 244 }
245 245
246 if (!ts->rd->f_op->poll) 246 ret = vfs_poll(ts->rd, pt);
247 ret = DEFAULT_POLLMASK; 247 if (ts->rd != ts->wr)
248 else 248 ret = (ret & ~EPOLLOUT) | (vfs_poll(ts->wr, pt) & ~EPOLLIN);
249 ret = ts->rd->f_op->poll(ts->rd, pt);
250
251 if (ts->rd != ts->wr) {
252 if (!ts->wr->f_op->poll)
253 n = DEFAULT_POLLMASK;
254 else
255 n = ts->wr->f_op->poll(ts->wr, pt);
256 ret = (ret & ~EPOLLOUT) | (n & ~EPOLLIN);
257 }
258
259 return ret; 249 return ret;
260} 250}
261 251
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index 9b6bc5abe946..55fdba05d7d9 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -1869,7 +1869,7 @@ static const struct proto_ops atalk_dgram_ops = {
1869 .socketpair = sock_no_socketpair, 1869 .socketpair = sock_no_socketpair,
1870 .accept = sock_no_accept, 1870 .accept = sock_no_accept,
1871 .getname = atalk_getname, 1871 .getname = atalk_getname,
1872 .poll = datagram_poll, 1872 .poll_mask = datagram_poll_mask,
1873 .ioctl = atalk_ioctl, 1873 .ioctl = atalk_ioctl,
1874#ifdef CONFIG_COMPAT 1874#ifdef CONFIG_COMPAT
1875 .compat_ioctl = atalk_compat_ioctl, 1875 .compat_ioctl = atalk_compat_ioctl,
diff --git a/net/atm/common.c b/net/atm/common.c
index fc78a0508ae1..1f2af59935db 100644
--- a/net/atm/common.c
+++ b/net/atm/common.c
@@ -648,16 +648,11 @@ out:
648 return error; 648 return error;
649} 649}
650 650
651__poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait) 651__poll_t vcc_poll_mask(struct socket *sock, __poll_t events)
652{ 652{
653 struct sock *sk = sock->sk; 653 struct sock *sk = sock->sk;
654 struct atm_vcc *vcc; 654 struct atm_vcc *vcc = ATM_SD(sock);
655 __poll_t mask; 655 __poll_t mask = 0;
656
657 sock_poll_wait(file, sk_sleep(sk), wait);
658 mask = 0;
659
660 vcc = ATM_SD(sock);
661 656
662 /* exceptional events */ 657 /* exceptional events */
663 if (sk->sk_err) 658 if (sk->sk_err)
diff --git a/net/atm/common.h b/net/atm/common.h
index 5850649068bb..526796ad230f 100644
--- a/net/atm/common.h
+++ b/net/atm/common.h
@@ -17,7 +17,7 @@ int vcc_connect(struct socket *sock, int itf, short vpi, int vci);
17int vcc_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 17int vcc_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
18 int flags); 18 int flags);
19int vcc_sendmsg(struct socket *sock, struct msghdr *m, size_t total_len); 19int vcc_sendmsg(struct socket *sock, struct msghdr *m, size_t total_len);
20__poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait); 20__poll_t vcc_poll_mask(struct socket *sock, __poll_t events);
21int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg); 21int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
22int vcc_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg); 22int vcc_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
23int vcc_setsockopt(struct socket *sock, int level, int optname, 23int vcc_setsockopt(struct socket *sock, int level, int optname,
diff --git a/net/atm/pvc.c b/net/atm/pvc.c
index 2cb10af16afc..9f75092fe778 100644
--- a/net/atm/pvc.c
+++ b/net/atm/pvc.c
@@ -113,7 +113,7 @@ static const struct proto_ops pvc_proto_ops = {
113 .socketpair = sock_no_socketpair, 113 .socketpair = sock_no_socketpair,
114 .accept = sock_no_accept, 114 .accept = sock_no_accept,
115 .getname = pvc_getname, 115 .getname = pvc_getname,
116 .poll = vcc_poll, 116 .poll_mask = vcc_poll_mask,
117 .ioctl = vcc_ioctl, 117 .ioctl = vcc_ioctl,
118#ifdef CONFIG_COMPAT 118#ifdef CONFIG_COMPAT
119 .compat_ioctl = vcc_compat_ioctl, 119 .compat_ioctl = vcc_compat_ioctl,
diff --git a/net/atm/svc.c b/net/atm/svc.c
index 2f91b766ac42..53f4ad7087b1 100644
--- a/net/atm/svc.c
+++ b/net/atm/svc.c
@@ -636,7 +636,7 @@ static const struct proto_ops svc_proto_ops = {
636 .socketpair = sock_no_socketpair, 636 .socketpair = sock_no_socketpair,
637 .accept = svc_accept, 637 .accept = svc_accept,
638 .getname = svc_getname, 638 .getname = svc_getname,
639 .poll = vcc_poll, 639 .poll_mask = vcc_poll_mask,
640 .ioctl = svc_ioctl, 640 .ioctl = svc_ioctl,
641#ifdef CONFIG_COMPAT 641#ifdef CONFIG_COMPAT
642 .compat_ioctl = svc_compat_ioctl, 642 .compat_ioctl = svc_compat_ioctl,
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index c603d33d5410..d1d2442ce573 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1941,7 +1941,7 @@ static const struct proto_ops ax25_proto_ops = {
1941 .socketpair = sock_no_socketpair, 1941 .socketpair = sock_no_socketpair,
1942 .accept = ax25_accept, 1942 .accept = ax25_accept,
1943 .getname = ax25_getname, 1943 .getname = ax25_getname,
1944 .poll = datagram_poll, 1944 .poll_mask = datagram_poll_mask,
1945 .ioctl = ax25_ioctl, 1945 .ioctl = ax25_ioctl,
1946 .listen = ax25_listen, 1946 .listen = ax25_listen,
1947 .shutdown = ax25_shutdown, 1947 .shutdown = ax25_shutdown,
diff --git a/net/bluetooth/af_bluetooth.c b/net/bluetooth/af_bluetooth.c
index 3264e1873219..510ab4f55df5 100644
--- a/net/bluetooth/af_bluetooth.c
+++ b/net/bluetooth/af_bluetooth.c
@@ -437,16 +437,13 @@ static inline __poll_t bt_accept_poll(struct sock *parent)
437 return 0; 437 return 0;
438} 438}
439 439
440__poll_t bt_sock_poll(struct file *file, struct socket *sock, 440__poll_t bt_sock_poll_mask(struct socket *sock, __poll_t events)
441 poll_table *wait)
442{ 441{
443 struct sock *sk = sock->sk; 442 struct sock *sk = sock->sk;
444 __poll_t mask = 0; 443 __poll_t mask = 0;
445 444
446 BT_DBG("sock %p, sk %p", sock, sk); 445 BT_DBG("sock %p, sk %p", sock, sk);
447 446
448 poll_wait(file, sk_sleep(sk), wait);
449
450 if (sk->sk_state == BT_LISTEN) 447 if (sk->sk_state == BT_LISTEN)
451 return bt_accept_poll(sk); 448 return bt_accept_poll(sk);
452 449
@@ -478,7 +475,7 @@ __poll_t bt_sock_poll(struct file *file, struct socket *sock,
478 475
479 return mask; 476 return mask;
480} 477}
481EXPORT_SYMBOL(bt_sock_poll); 478EXPORT_SYMBOL(bt_sock_poll_mask);
482 479
483int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 480int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
484{ 481{
diff --git a/net/bluetooth/bnep/sock.c b/net/bluetooth/bnep/sock.c
index b5116fa9835e..00deacdcb51c 100644
--- a/net/bluetooth/bnep/sock.c
+++ b/net/bluetooth/bnep/sock.c
@@ -175,7 +175,6 @@ static const struct proto_ops bnep_sock_ops = {
175 .getname = sock_no_getname, 175 .getname = sock_no_getname,
176 .sendmsg = sock_no_sendmsg, 176 .sendmsg = sock_no_sendmsg,
177 .recvmsg = sock_no_recvmsg, 177 .recvmsg = sock_no_recvmsg,
178 .poll = sock_no_poll,
179 .listen = sock_no_listen, 178 .listen = sock_no_listen,
180 .shutdown = sock_no_shutdown, 179 .shutdown = sock_no_shutdown,
181 .setsockopt = sock_no_setsockopt, 180 .setsockopt = sock_no_setsockopt,
diff --git a/net/bluetooth/cmtp/sock.c b/net/bluetooth/cmtp/sock.c
index ce86a7bae844..e08f28fadd65 100644
--- a/net/bluetooth/cmtp/sock.c
+++ b/net/bluetooth/cmtp/sock.c
@@ -178,7 +178,6 @@ static const struct proto_ops cmtp_sock_ops = {
178 .getname = sock_no_getname, 178 .getname = sock_no_getname,
179 .sendmsg = sock_no_sendmsg, 179 .sendmsg = sock_no_sendmsg,
180 .recvmsg = sock_no_recvmsg, 180 .recvmsg = sock_no_recvmsg,
181 .poll = sock_no_poll,
182 .listen = sock_no_listen, 181 .listen = sock_no_listen,
183 .shutdown = sock_no_shutdown, 182 .shutdown = sock_no_shutdown,
184 .setsockopt = sock_no_setsockopt, 183 .setsockopt = sock_no_setsockopt,
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index 1506e1632394..d6c099861538 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -1975,7 +1975,7 @@ static const struct proto_ops hci_sock_ops = {
1975 .sendmsg = hci_sock_sendmsg, 1975 .sendmsg = hci_sock_sendmsg,
1976 .recvmsg = hci_sock_recvmsg, 1976 .recvmsg = hci_sock_recvmsg,
1977 .ioctl = hci_sock_ioctl, 1977 .ioctl = hci_sock_ioctl,
1978 .poll = datagram_poll, 1978 .poll_mask = datagram_poll_mask,
1979 .listen = sock_no_listen, 1979 .listen = sock_no_listen,
1980 .shutdown = sock_no_shutdown, 1980 .shutdown = sock_no_shutdown,
1981 .setsockopt = hci_sock_setsockopt, 1981 .setsockopt = hci_sock_setsockopt,
diff --git a/net/bluetooth/hidp/sock.c b/net/bluetooth/hidp/sock.c
index 008ba439bd62..1eaac01f85de 100644
--- a/net/bluetooth/hidp/sock.c
+++ b/net/bluetooth/hidp/sock.c
@@ -208,7 +208,6 @@ static const struct proto_ops hidp_sock_ops = {
208 .getname = sock_no_getname, 208 .getname = sock_no_getname,
209 .sendmsg = sock_no_sendmsg, 209 .sendmsg = sock_no_sendmsg,
210 .recvmsg = sock_no_recvmsg, 210 .recvmsg = sock_no_recvmsg,
211 .poll = sock_no_poll,
212 .listen = sock_no_listen, 211 .listen = sock_no_listen,
213 .shutdown = sock_no_shutdown, 212 .shutdown = sock_no_shutdown,
214 .setsockopt = sock_no_setsockopt, 213 .setsockopt = sock_no_setsockopt,
diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
index 686bdc6b35b0..742a190034e6 100644
--- a/net/bluetooth/l2cap_sock.c
+++ b/net/bluetooth/l2cap_sock.c
@@ -1653,7 +1653,7 @@ static const struct proto_ops l2cap_sock_ops = {
1653 .getname = l2cap_sock_getname, 1653 .getname = l2cap_sock_getname,
1654 .sendmsg = l2cap_sock_sendmsg, 1654 .sendmsg = l2cap_sock_sendmsg,
1655 .recvmsg = l2cap_sock_recvmsg, 1655 .recvmsg = l2cap_sock_recvmsg,
1656 .poll = bt_sock_poll, 1656 .poll_mask = bt_sock_poll_mask,
1657 .ioctl = bt_sock_ioctl, 1657 .ioctl = bt_sock_ioctl,
1658 .mmap = sock_no_mmap, 1658 .mmap = sock_no_mmap,
1659 .socketpair = sock_no_socketpair, 1659 .socketpair = sock_no_socketpair,
diff --git a/net/bluetooth/rfcomm/sock.c b/net/bluetooth/rfcomm/sock.c
index d606e9212291..1cf57622473a 100644
--- a/net/bluetooth/rfcomm/sock.c
+++ b/net/bluetooth/rfcomm/sock.c
@@ -1049,7 +1049,7 @@ static const struct proto_ops rfcomm_sock_ops = {
1049 .setsockopt = rfcomm_sock_setsockopt, 1049 .setsockopt = rfcomm_sock_setsockopt,
1050 .getsockopt = rfcomm_sock_getsockopt, 1050 .getsockopt = rfcomm_sock_getsockopt,
1051 .ioctl = rfcomm_sock_ioctl, 1051 .ioctl = rfcomm_sock_ioctl,
1052 .poll = bt_sock_poll, 1052 .poll_mask = bt_sock_poll_mask,
1053 .socketpair = sock_no_socketpair, 1053 .socketpair = sock_no_socketpair,
1054 .mmap = sock_no_mmap 1054 .mmap = sock_no_mmap
1055}; 1055};
diff --git a/net/bluetooth/sco.c b/net/bluetooth/sco.c
index 413b8ee49fec..d60dbc61d170 100644
--- a/net/bluetooth/sco.c
+++ b/net/bluetooth/sco.c
@@ -1197,7 +1197,7 @@ static const struct proto_ops sco_sock_ops = {
1197 .getname = sco_sock_getname, 1197 .getname = sco_sock_getname,
1198 .sendmsg = sco_sock_sendmsg, 1198 .sendmsg = sco_sock_sendmsg,
1199 .recvmsg = sco_sock_recvmsg, 1199 .recvmsg = sco_sock_recvmsg,
1200 .poll = bt_sock_poll, 1200 .poll_mask = bt_sock_poll_mask,
1201 .ioctl = bt_sock_ioctl, 1201 .ioctl = bt_sock_ioctl,
1202 .mmap = sock_no_mmap, 1202 .mmap = sock_no_mmap,
1203 .socketpair = sock_no_socketpair, 1203 .socketpair = sock_no_socketpair,
diff --git a/net/caif/caif_socket.c b/net/caif/caif_socket.c
index a6fb1b3bcad9..c7991867d622 100644
--- a/net/caif/caif_socket.c
+++ b/net/caif/caif_socket.c
@@ -934,15 +934,11 @@ static int caif_release(struct socket *sock)
934} 934}
935 935
936/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */ 936/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
937static __poll_t caif_poll(struct file *file, 937static __poll_t caif_poll_mask(struct socket *sock, __poll_t events)
938 struct socket *sock, poll_table *wait)
939{ 938{
940 struct sock *sk = sock->sk; 939 struct sock *sk = sock->sk;
941 __poll_t mask;
942 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 940 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
943 941 __poll_t mask = 0;
944 sock_poll_wait(file, sk_sleep(sk), wait);
945 mask = 0;
946 942
947 /* exceptional events? */ 943 /* exceptional events? */
948 if (sk->sk_err) 944 if (sk->sk_err)
@@ -976,7 +972,7 @@ static const struct proto_ops caif_seqpacket_ops = {
976 .socketpair = sock_no_socketpair, 972 .socketpair = sock_no_socketpair,
977 .accept = sock_no_accept, 973 .accept = sock_no_accept,
978 .getname = sock_no_getname, 974 .getname = sock_no_getname,
979 .poll = caif_poll, 975 .poll_mask = caif_poll_mask,
980 .ioctl = sock_no_ioctl, 976 .ioctl = sock_no_ioctl,
981 .listen = sock_no_listen, 977 .listen = sock_no_listen,
982 .shutdown = sock_no_shutdown, 978 .shutdown = sock_no_shutdown,
@@ -997,7 +993,7 @@ static const struct proto_ops caif_stream_ops = {
997 .socketpair = sock_no_socketpair, 993 .socketpair = sock_no_socketpair,
998 .accept = sock_no_accept, 994 .accept = sock_no_accept,
999 .getname = sock_no_getname, 995 .getname = sock_no_getname,
1000 .poll = caif_poll, 996 .poll_mask = caif_poll_mask,
1001 .ioctl = sock_no_ioctl, 997 .ioctl = sock_no_ioctl,
1002 .listen = sock_no_listen, 998 .listen = sock_no_listen,
1003 .shutdown = sock_no_shutdown, 999 .shutdown = sock_no_shutdown,
diff --git a/net/can/bcm.c b/net/can/bcm.c
index 6ad89f49b341..97fedff3f0c4 100644
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -1657,7 +1657,7 @@ static const struct proto_ops bcm_ops = {
1657 .socketpair = sock_no_socketpair, 1657 .socketpair = sock_no_socketpair,
1658 .accept = sock_no_accept, 1658 .accept = sock_no_accept,
1659 .getname = sock_no_getname, 1659 .getname = sock_no_getname,
1660 .poll = datagram_poll, 1660 .poll_mask = datagram_poll_mask,
1661 .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */ 1661 .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
1662 .listen = sock_no_listen, 1662 .listen = sock_no_listen,
1663 .shutdown = sock_no_shutdown, 1663 .shutdown = sock_no_shutdown,
diff --git a/net/can/raw.c b/net/can/raw.c
index 1051eee82581..fd7e2f49ea6a 100644
--- a/net/can/raw.c
+++ b/net/can/raw.c
@@ -843,7 +843,7 @@ static const struct proto_ops raw_ops = {
843 .socketpair = sock_no_socketpair, 843 .socketpair = sock_no_socketpair,
844 .accept = sock_no_accept, 844 .accept = sock_no_accept,
845 .getname = raw_getname, 845 .getname = raw_getname,
846 .poll = datagram_poll, 846 .poll_mask = datagram_poll_mask,
847 .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */ 847 .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
848 .listen = sock_no_listen, 848 .listen = sock_no_listen,
849 .shutdown = sock_no_shutdown, 849 .shutdown = sock_no_shutdown,
diff --git a/net/core/datagram.c b/net/core/datagram.c
index 9938952c5c78..f19bf3dc2bd6 100644
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -819,9 +819,8 @@ EXPORT_SYMBOL(skb_copy_and_csum_datagram_msg);
819 819
820/** 820/**
821 * datagram_poll - generic datagram poll 821 * datagram_poll - generic datagram poll
822 * @file: file struct
823 * @sock: socket 822 * @sock: socket
824 * @wait: poll table 823 * @events to wait for
825 * 824 *
826 * Datagram poll: Again totally generic. This also handles 825 * Datagram poll: Again totally generic. This also handles
827 * sequenced packet sockets providing the socket receive queue 826 * sequenced packet sockets providing the socket receive queue
@@ -831,14 +830,10 @@ EXPORT_SYMBOL(skb_copy_and_csum_datagram_msg);
831 * and you use a different write policy from sock_writeable() 830 * and you use a different write policy from sock_writeable()
832 * then please supply your own write_space callback. 831 * then please supply your own write_space callback.
833 */ 832 */
834__poll_t datagram_poll(struct file *file, struct socket *sock, 833__poll_t datagram_poll_mask(struct socket *sock, __poll_t events)
835 poll_table *wait)
836{ 834{
837 struct sock *sk = sock->sk; 835 struct sock *sk = sock->sk;
838 __poll_t mask; 836 __poll_t mask = 0;
839
840 sock_poll_wait(file, sk_sleep(sk), wait);
841 mask = 0;
842 837
843 /* exceptional events? */ 838 /* exceptional events? */
844 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 839 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
@@ -871,4 +866,4 @@ __poll_t datagram_poll(struct file *file, struct socket *sock,
871 866
872 return mask; 867 return mask;
873} 868}
874EXPORT_SYMBOL(datagram_poll); 869EXPORT_SYMBOL(datagram_poll_mask);
diff --git a/net/core/sock.c b/net/core/sock.c
index 815770333d91..2aed99a541d5 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -2567,12 +2567,6 @@ int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
2567} 2567}
2568EXPORT_SYMBOL(sock_no_getname); 2568EXPORT_SYMBOL(sock_no_getname);
2569 2569
2570__poll_t sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
2571{
2572 return 0;
2573}
2574EXPORT_SYMBOL(sock_no_poll);
2575
2576int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 2570int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2577{ 2571{
2578 return -EOPNOTSUPP; 2572 return -EOPNOTSUPP;
diff --git a/net/dccp/dccp.h b/net/dccp/dccp.h
index f91e3816806b..0ea2ee56ac1b 100644
--- a/net/dccp/dccp.h
+++ b/net/dccp/dccp.h
@@ -316,8 +316,7 @@ int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
316 int flags, int *addr_len); 316 int flags, int *addr_len);
317void dccp_shutdown(struct sock *sk, int how); 317void dccp_shutdown(struct sock *sk, int how);
318int inet_dccp_listen(struct socket *sock, int backlog); 318int inet_dccp_listen(struct socket *sock, int backlog);
319__poll_t dccp_poll(struct file *file, struct socket *sock, 319__poll_t dccp_poll_mask(struct socket *sock, __poll_t events);
320 poll_table *wait);
321int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len); 320int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
322void dccp_req_err(struct sock *sk, u64 seq); 321void dccp_req_err(struct sock *sk, u64 seq);
323 322
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index b08feb219b44..a9e478cd3787 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -984,7 +984,7 @@ static const struct proto_ops inet_dccp_ops = {
984 .accept = inet_accept, 984 .accept = inet_accept,
985 .getname = inet_getname, 985 .getname = inet_getname,
986 /* FIXME: work on tcp_poll to rename it to inet_csk_poll */ 986 /* FIXME: work on tcp_poll to rename it to inet_csk_poll */
987 .poll = dccp_poll, 987 .poll_mask = dccp_poll_mask,
988 .ioctl = inet_ioctl, 988 .ioctl = inet_ioctl,
989 /* FIXME: work on inet_listen to rename it to sock_common_listen */ 989 /* FIXME: work on inet_listen to rename it to sock_common_listen */
990 .listen = inet_dccp_listen, 990 .listen = inet_dccp_listen,
diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
index 6344f1b18a6a..17fc4e0166ba 100644
--- a/net/dccp/ipv6.c
+++ b/net/dccp/ipv6.c
@@ -1070,7 +1070,7 @@ static const struct proto_ops inet6_dccp_ops = {
1070 .socketpair = sock_no_socketpair, 1070 .socketpair = sock_no_socketpair,
1071 .accept = inet_accept, 1071 .accept = inet_accept,
1072 .getname = inet6_getname, 1072 .getname = inet6_getname,
1073 .poll = dccp_poll, 1073 .poll_mask = dccp_poll_mask,
1074 .ioctl = inet6_ioctl, 1074 .ioctl = inet6_ioctl,
1075 .listen = inet_dccp_listen, 1075 .listen = inet_dccp_listen,
1076 .shutdown = inet_shutdown, 1076 .shutdown = inet_shutdown,
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index 0d56e36a6db7..ca21c1c76da0 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -312,20 +312,11 @@ int dccp_disconnect(struct sock *sk, int flags)
312 312
313EXPORT_SYMBOL_GPL(dccp_disconnect); 313EXPORT_SYMBOL_GPL(dccp_disconnect);
314 314
315/* 315__poll_t dccp_poll_mask(struct socket *sock, __poll_t events)
316 * Wait for a DCCP event.
317 *
318 * Note that we don't need to lock the socket, as the upper poll layers
319 * take care of normal races (between the test and the event) and we don't
320 * go look at any of the socket buffers directly.
321 */
322__poll_t dccp_poll(struct file *file, struct socket *sock,
323 poll_table *wait)
324{ 316{
325 __poll_t mask; 317 __poll_t mask;
326 struct sock *sk = sock->sk; 318 struct sock *sk = sock->sk;
327 319
328 sock_poll_wait(file, sk_sleep(sk), wait);
329 if (sk->sk_state == DCCP_LISTEN) 320 if (sk->sk_state == DCCP_LISTEN)
330 return inet_csk_listen_poll(sk); 321 return inet_csk_listen_poll(sk);
331 322
@@ -367,7 +358,7 @@ __poll_t dccp_poll(struct file *file, struct socket *sock,
367 return mask; 358 return mask;
368} 359}
369 360
370EXPORT_SYMBOL_GPL(dccp_poll); 361EXPORT_SYMBOL_GPL(dccp_poll_mask);
371 362
372int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg) 363int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
373{ 364{
diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index 7d6ff983ba2c..9a686d890bfa 100644
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -1207,11 +1207,11 @@ static int dn_getname(struct socket *sock, struct sockaddr *uaddr,int peer)
1207} 1207}
1208 1208
1209 1209
1210static __poll_t dn_poll(struct file *file, struct socket *sock, poll_table *wait) 1210static __poll_t dn_poll_mask(struct socket *sock, __poll_t events)
1211{ 1211{
1212 struct sock *sk = sock->sk; 1212 struct sock *sk = sock->sk;
1213 struct dn_scp *scp = DN_SK(sk); 1213 struct dn_scp *scp = DN_SK(sk);
1214 __poll_t mask = datagram_poll(file, sock, wait); 1214 __poll_t mask = datagram_poll_mask(sock, events);
1215 1215
1216 if (!skb_queue_empty(&scp->other_receive_queue)) 1216 if (!skb_queue_empty(&scp->other_receive_queue))
1217 mask |= EPOLLRDBAND; 1217 mask |= EPOLLRDBAND;
@@ -2331,7 +2331,7 @@ static const struct proto_ops dn_proto_ops = {
2331 .socketpair = sock_no_socketpair, 2331 .socketpair = sock_no_socketpair,
2332 .accept = dn_accept, 2332 .accept = dn_accept,
2333 .getname = dn_getname, 2333 .getname = dn_getname,
2334 .poll = dn_poll, 2334 .poll_mask = dn_poll_mask,
2335 .ioctl = dn_ioctl, 2335 .ioctl = dn_ioctl,
2336 .listen = dn_listen, 2336 .listen = dn_listen,
2337 .shutdown = dn_shutdown, 2337 .shutdown = dn_shutdown,
diff --git a/net/ieee802154/socket.c b/net/ieee802154/socket.c
index a60658c85a9a..a0768d2759b8 100644
--- a/net/ieee802154/socket.c
+++ b/net/ieee802154/socket.c
@@ -423,7 +423,7 @@ static const struct proto_ops ieee802154_raw_ops = {
423 .socketpair = sock_no_socketpair, 423 .socketpair = sock_no_socketpair,
424 .accept = sock_no_accept, 424 .accept = sock_no_accept,
425 .getname = sock_no_getname, 425 .getname = sock_no_getname,
426 .poll = datagram_poll, 426 .poll_mask = datagram_poll_mask,
427 .ioctl = ieee802154_sock_ioctl, 427 .ioctl = ieee802154_sock_ioctl,
428 .listen = sock_no_listen, 428 .listen = sock_no_listen,
429 .shutdown = sock_no_shutdown, 429 .shutdown = sock_no_shutdown,
@@ -969,7 +969,7 @@ static const struct proto_ops ieee802154_dgram_ops = {
969 .socketpair = sock_no_socketpair, 969 .socketpair = sock_no_socketpair,
970 .accept = sock_no_accept, 970 .accept = sock_no_accept,
971 .getname = sock_no_getname, 971 .getname = sock_no_getname,
972 .poll = datagram_poll, 972 .poll_mask = datagram_poll_mask,
973 .ioctl = ieee802154_sock_ioctl, 973 .ioctl = ieee802154_sock_ioctl,
974 .listen = sock_no_listen, 974 .listen = sock_no_listen,
975 .shutdown = sock_no_shutdown, 975 .shutdown = sock_no_shutdown,
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index eaed0367e669..8a59428e63ab 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -986,7 +986,7 @@ const struct proto_ops inet_stream_ops = {
986 .socketpair = sock_no_socketpair, 986 .socketpair = sock_no_socketpair,
987 .accept = inet_accept, 987 .accept = inet_accept,
988 .getname = inet_getname, 988 .getname = inet_getname,
989 .poll = tcp_poll, 989 .poll_mask = tcp_poll_mask,
990 .ioctl = inet_ioctl, 990 .ioctl = inet_ioctl,
991 .listen = inet_listen, 991 .listen = inet_listen,
992 .shutdown = inet_shutdown, 992 .shutdown = inet_shutdown,
@@ -1018,7 +1018,7 @@ const struct proto_ops inet_dgram_ops = {
1018 .socketpair = sock_no_socketpair, 1018 .socketpair = sock_no_socketpair,
1019 .accept = sock_no_accept, 1019 .accept = sock_no_accept,
1020 .getname = inet_getname, 1020 .getname = inet_getname,
1021 .poll = udp_poll, 1021 .poll_mask = udp_poll_mask,
1022 .ioctl = inet_ioctl, 1022 .ioctl = inet_ioctl,
1023 .listen = sock_no_listen, 1023 .listen = sock_no_listen,
1024 .shutdown = inet_shutdown, 1024 .shutdown = inet_shutdown,
@@ -1039,7 +1039,7 @@ EXPORT_SYMBOL(inet_dgram_ops);
1039 1039
1040/* 1040/*
1041 * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without 1041 * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
1042 * udp_poll 1042 * udp_poll_mask
1043 */ 1043 */
1044static const struct proto_ops inet_sockraw_ops = { 1044static const struct proto_ops inet_sockraw_ops = {
1045 .family = PF_INET, 1045 .family = PF_INET,
@@ -1050,7 +1050,7 @@ static const struct proto_ops inet_sockraw_ops = {
1050 .socketpair = sock_no_socketpair, 1050 .socketpair = sock_no_socketpair,
1051 .accept = sock_no_accept, 1051 .accept = sock_no_accept,
1052 .getname = inet_getname, 1052 .getname = inet_getname,
1053 .poll = datagram_poll, 1053 .poll_mask = datagram_poll_mask,
1054 .ioctl = inet_ioctl, 1054 .ioctl = inet_ioctl,
1055 .listen = sock_no_listen, 1055 .listen = sock_no_listen,
1056 .shutdown = inet_shutdown, 1056 .shutdown = inet_shutdown,
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index c9d00ef54dec..dec47e6789e7 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -494,32 +494,21 @@ static inline bool tcp_stream_is_readable(const struct tcp_sock *tp,
494} 494}
495 495
496/* 496/*
497 * Wait for a TCP event. 497 * Socket is not locked. We are protected from async events by poll logic and
498 * 498 * correct handling of state changes made by other threads is impossible in
499 * Note that we don't need to lock the socket, as the upper poll layers 499 * any case.
500 * take care of normal races (between the test and the event) and we don't
501 * go look at any of the socket buffers directly.
502 */ 500 */
503__poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait) 501__poll_t tcp_poll_mask(struct socket *sock, __poll_t events)
504{ 502{
505 __poll_t mask;
506 struct sock *sk = sock->sk; 503 struct sock *sk = sock->sk;
507 const struct tcp_sock *tp = tcp_sk(sk); 504 const struct tcp_sock *tp = tcp_sk(sk);
505 __poll_t mask = 0;
508 int state; 506 int state;
509 507
510 sock_poll_wait(file, sk_sleep(sk), wait);
511
512 state = inet_sk_state_load(sk); 508 state = inet_sk_state_load(sk);
513 if (state == TCP_LISTEN) 509 if (state == TCP_LISTEN)
514 return inet_csk_listen_poll(sk); 510 return inet_csk_listen_poll(sk);
515 511
516 /* Socket is not locked. We are protected from async events
517 * by poll logic and correct handling of state changes
518 * made by other threads is impossible in any case.
519 */
520
521 mask = 0;
522
523 /* 512 /*
524 * EPOLLHUP is certainly not done right. But poll() doesn't 513 * EPOLLHUP is certainly not done right. But poll() doesn't
525 * have a notion of HUP in just one direction, and for a 514 * have a notion of HUP in just one direction, and for a
@@ -600,7 +589,7 @@ __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
600 589
601 return mask; 590 return mask;
602} 591}
603EXPORT_SYMBOL(tcp_poll); 592EXPORT_SYMBOL(tcp_poll_mask);
604 593
605int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg) 594int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
606{ 595{
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 051a43ff3fb8..675433eb53a8 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -2501,7 +2501,7 @@ int compat_udp_getsockopt(struct sock *sk, int level, int optname,
2501 * udp_poll - wait for a UDP event. 2501 * udp_poll - wait for a UDP event.
2502 * @file - file struct 2502 * @file - file struct
2503 * @sock - socket 2503 * @sock - socket
2504 * @wait - poll table 2504 * @events - events to wait for
2505 * 2505 *
2506 * This is same as datagram poll, except for the special case of 2506 * This is same as datagram poll, except for the special case of
2507 * blocking sockets. If application is using a blocking fd 2507 * blocking sockets. If application is using a blocking fd
@@ -2510,23 +2510,23 @@ int compat_udp_getsockopt(struct sock *sk, int level, int optname,
2510 * but then block when reading it. Add special case code 2510 * but then block when reading it. Add special case code
2511 * to work around these arguably broken applications. 2511 * to work around these arguably broken applications.
2512 */ 2512 */
2513__poll_t udp_poll(struct file *file, struct socket *sock, poll_table *wait) 2513__poll_t udp_poll_mask(struct socket *sock, __poll_t events)
2514{ 2514{
2515 __poll_t mask = datagram_poll(file, sock, wait); 2515 __poll_t mask = datagram_poll_mask(sock, events);
2516 struct sock *sk = sock->sk; 2516 struct sock *sk = sock->sk;
2517 2517
2518 if (!skb_queue_empty(&udp_sk(sk)->reader_queue)) 2518 if (!skb_queue_empty(&udp_sk(sk)->reader_queue))
2519 mask |= EPOLLIN | EPOLLRDNORM; 2519 mask |= EPOLLIN | EPOLLRDNORM;
2520 2520
2521 /* Check for false positives due to checksum errors */ 2521 /* Check for false positives due to checksum errors */
2522 if ((mask & EPOLLRDNORM) && !(file->f_flags & O_NONBLOCK) && 2522 if ((mask & EPOLLRDNORM) && !(sock->file->f_flags & O_NONBLOCK) &&
2523 !(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1) 2523 !(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1)
2524 mask &= ~(EPOLLIN | EPOLLRDNORM); 2524 mask &= ~(EPOLLIN | EPOLLRDNORM);
2525 2525
2526 return mask; 2526 return mask;
2527 2527
2528} 2528}
2529EXPORT_SYMBOL(udp_poll); 2529EXPORT_SYMBOL(udp_poll_mask);
2530 2530
2531int udp_abort(struct sock *sk, int err) 2531int udp_abort(struct sock *sk, int err)
2532{ 2532{
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 8da0b513f188..d443c18b45fe 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -571,7 +571,7 @@ const struct proto_ops inet6_stream_ops = {
571 .socketpair = sock_no_socketpair, /* a do nothing */ 571 .socketpair = sock_no_socketpair, /* a do nothing */
572 .accept = inet_accept, /* ok */ 572 .accept = inet_accept, /* ok */
573 .getname = inet6_getname, 573 .getname = inet6_getname,
574 .poll = tcp_poll, /* ok */ 574 .poll_mask = tcp_poll_mask, /* ok */
575 .ioctl = inet6_ioctl, /* must change */ 575 .ioctl = inet6_ioctl, /* must change */
576 .listen = inet_listen, /* ok */ 576 .listen = inet_listen, /* ok */
577 .shutdown = inet_shutdown, /* ok */ 577 .shutdown = inet_shutdown, /* ok */
@@ -601,7 +601,7 @@ const struct proto_ops inet6_dgram_ops = {
601 .socketpair = sock_no_socketpair, /* a do nothing */ 601 .socketpair = sock_no_socketpair, /* a do nothing */
602 .accept = sock_no_accept, /* a do nothing */ 602 .accept = sock_no_accept, /* a do nothing */
603 .getname = inet6_getname, 603 .getname = inet6_getname,
604 .poll = udp_poll, /* ok */ 604 .poll_mask = udp_poll_mask, /* ok */
605 .ioctl = inet6_ioctl, /* must change */ 605 .ioctl = inet6_ioctl, /* must change */
606 .listen = sock_no_listen, /* ok */ 606 .listen = sock_no_listen, /* ok */
607 .shutdown = inet_shutdown, /* ok */ 607 .shutdown = inet_shutdown, /* ok */
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index afc307c89d1a..ce6f0d15b5dd 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -1334,7 +1334,7 @@ void raw6_proc_exit(void)
1334} 1334}
1335#endif /* CONFIG_PROC_FS */ 1335#endif /* CONFIG_PROC_FS */
1336 1336
1337/* Same as inet6_dgram_ops, sans udp_poll. */ 1337/* Same as inet6_dgram_ops, sans udp_poll_mask. */
1338const struct proto_ops inet6_sockraw_ops = { 1338const struct proto_ops inet6_sockraw_ops = {
1339 .family = PF_INET6, 1339 .family = PF_INET6,
1340 .owner = THIS_MODULE, 1340 .owner = THIS_MODULE,
@@ -1344,7 +1344,7 @@ const struct proto_ops inet6_sockraw_ops = {
1344 .socketpair = sock_no_socketpair, /* a do nothing */ 1344 .socketpair = sock_no_socketpair, /* a do nothing */
1345 .accept = sock_no_accept, /* a do nothing */ 1345 .accept = sock_no_accept, /* a do nothing */
1346 .getname = inet6_getname, 1346 .getname = inet6_getname,
1347 .poll = datagram_poll, /* ok */ 1347 .poll_mask = datagram_poll_mask, /* ok */
1348 .ioctl = inet6_ioctl, /* must change */ 1348 .ioctl = inet6_ioctl, /* must change */
1349 .listen = sock_no_listen, /* ok */ 1349 .listen = sock_no_listen, /* ok */
1350 .shutdown = inet_shutdown, /* ok */ 1350 .shutdown = inet_shutdown, /* ok */
diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index 893a022f9620..68e86257a549 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -1488,14 +1488,11 @@ static inline __poll_t iucv_accept_poll(struct sock *parent)
1488 return 0; 1488 return 0;
1489} 1489}
1490 1490
1491__poll_t iucv_sock_poll(struct file *file, struct socket *sock, 1491static __poll_t iucv_sock_poll_mask(struct socket *sock, __poll_t events)
1492 poll_table *wait)
1493{ 1492{
1494 struct sock *sk = sock->sk; 1493 struct sock *sk = sock->sk;
1495 __poll_t mask = 0; 1494 __poll_t mask = 0;
1496 1495
1497 sock_poll_wait(file, sk_sleep(sk), wait);
1498
1499 if (sk->sk_state == IUCV_LISTEN) 1496 if (sk->sk_state == IUCV_LISTEN)
1500 return iucv_accept_poll(sk); 1497 return iucv_accept_poll(sk);
1501 1498
@@ -2388,7 +2385,7 @@ static const struct proto_ops iucv_sock_ops = {
2388 .getname = iucv_sock_getname, 2385 .getname = iucv_sock_getname,
2389 .sendmsg = iucv_sock_sendmsg, 2386 .sendmsg = iucv_sock_sendmsg,
2390 .recvmsg = iucv_sock_recvmsg, 2387 .recvmsg = iucv_sock_recvmsg,
2391 .poll = iucv_sock_poll, 2388 .poll_mask = iucv_sock_poll_mask,
2392 .ioctl = sock_no_ioctl, 2389 .ioctl = sock_no_ioctl,
2393 .mmap = sock_no_mmap, 2390 .mmap = sock_no_mmap,
2394 .socketpair = sock_no_socketpair, 2391 .socketpair = sock_no_socketpair,
diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c
index d3601d421571..84b7d5c6fec8 100644
--- a/net/kcm/kcmsock.c
+++ b/net/kcm/kcmsock.c
@@ -1336,9 +1336,9 @@ static void init_kcm_sock(struct kcm_sock *kcm, struct kcm_mux *mux)
1336 struct list_head *head; 1336 struct list_head *head;
1337 int index = 0; 1337 int index = 0;
1338 1338
1339 /* For SOCK_SEQPACKET sock type, datagram_poll checks the sk_state, so 1339 /* For SOCK_SEQPACKET sock type, datagram_poll_mask checks the sk_state,
1340 * we set sk_state, otherwise epoll_wait always returns right away with 1340 * so we set sk_state, otherwise epoll_wait always returns right away
1341 * EPOLLHUP 1341 * with EPOLLHUP
1342 */ 1342 */
1343 kcm->sk.sk_state = TCP_ESTABLISHED; 1343 kcm->sk.sk_state = TCP_ESTABLISHED;
1344 1344
@@ -1903,7 +1903,7 @@ static const struct proto_ops kcm_dgram_ops = {
1903 .socketpair = sock_no_socketpair, 1903 .socketpair = sock_no_socketpair,
1904 .accept = sock_no_accept, 1904 .accept = sock_no_accept,
1905 .getname = sock_no_getname, 1905 .getname = sock_no_getname,
1906 .poll = datagram_poll, 1906 .poll_mask = datagram_poll_mask,
1907 .ioctl = kcm_ioctl, 1907 .ioctl = kcm_ioctl,
1908 .listen = sock_no_listen, 1908 .listen = sock_no_listen,
1909 .shutdown = sock_no_shutdown, 1909 .shutdown = sock_no_shutdown,
@@ -1924,7 +1924,7 @@ static const struct proto_ops kcm_seqpacket_ops = {
1924 .socketpair = sock_no_socketpair, 1924 .socketpair = sock_no_socketpair,
1925 .accept = sock_no_accept, 1925 .accept = sock_no_accept,
1926 .getname = sock_no_getname, 1926 .getname = sock_no_getname,
1927 .poll = datagram_poll, 1927 .poll_mask = datagram_poll_mask,
1928 .ioctl = kcm_ioctl, 1928 .ioctl = kcm_ioctl,
1929 .listen = sock_no_listen, 1929 .listen = sock_no_listen,
1930 .shutdown = sock_no_shutdown, 1930 .shutdown = sock_no_shutdown,
diff --git a/net/key/af_key.c b/net/key/af_key.c
index 5e1d2946ffbf..8bdc1cbe490a 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -3751,7 +3751,7 @@ static const struct proto_ops pfkey_ops = {
3751 3751
3752 /* Now the operations that really occur. */ 3752 /* Now the operations that really occur. */
3753 .release = pfkey_release, 3753 .release = pfkey_release,
3754 .poll = datagram_poll, 3754 .poll_mask = datagram_poll_mask,
3755 .sendmsg = pfkey_sendmsg, 3755 .sendmsg = pfkey_sendmsg,
3756 .recvmsg = pfkey_recvmsg, 3756 .recvmsg = pfkey_recvmsg,
3757}; 3757};
diff --git a/net/l2tp/l2tp_ip.c b/net/l2tp/l2tp_ip.c
index a9c05b2bc1b0..181073bf6925 100644
--- a/net/l2tp/l2tp_ip.c
+++ b/net/l2tp/l2tp_ip.c
@@ -613,7 +613,7 @@ static const struct proto_ops l2tp_ip_ops = {
613 .socketpair = sock_no_socketpair, 613 .socketpair = sock_no_socketpair,
614 .accept = sock_no_accept, 614 .accept = sock_no_accept,
615 .getname = l2tp_ip_getname, 615 .getname = l2tp_ip_getname,
616 .poll = datagram_poll, 616 .poll_mask = datagram_poll_mask,
617 .ioctl = inet_ioctl, 617 .ioctl = inet_ioctl,
618 .listen = sock_no_listen, 618 .listen = sock_no_listen,
619 .shutdown = inet_shutdown, 619 .shutdown = inet_shutdown,
diff --git a/net/l2tp/l2tp_ip6.c b/net/l2tp/l2tp_ip6.c
index 957369192ca1..336e4c00abbc 100644
--- a/net/l2tp/l2tp_ip6.c
+++ b/net/l2tp/l2tp_ip6.c
@@ -754,7 +754,7 @@ static const struct proto_ops l2tp_ip6_ops = {
754 .socketpair = sock_no_socketpair, 754 .socketpair = sock_no_socketpair,
755 .accept = sock_no_accept, 755 .accept = sock_no_accept,
756 .getname = l2tp_ip6_getname, 756 .getname = l2tp_ip6_getname,
757 .poll = datagram_poll, 757 .poll_mask = datagram_poll_mask,
758 .ioctl = inet6_ioctl, 758 .ioctl = inet6_ioctl,
759 .listen = sock_no_listen, 759 .listen = sock_no_listen,
760 .shutdown = inet_shutdown, 760 .shutdown = inet_shutdown,
diff --git a/net/l2tp/l2tp_ppp.c b/net/l2tp/l2tp_ppp.c
index 830469766c1f..3d8ca1231f8f 100644
--- a/net/l2tp/l2tp_ppp.c
+++ b/net/l2tp/l2tp_ppp.c
@@ -1788,7 +1788,7 @@ static const struct proto_ops pppol2tp_ops = {
1788 .socketpair = sock_no_socketpair, 1788 .socketpair = sock_no_socketpair,
1789 .accept = sock_no_accept, 1789 .accept = sock_no_accept,
1790 .getname = pppol2tp_getname, 1790 .getname = pppol2tp_getname,
1791 .poll = datagram_poll, 1791 .poll_mask = datagram_poll_mask,
1792 .listen = sock_no_listen, 1792 .listen = sock_no_listen,
1793 .shutdown = sock_no_shutdown, 1793 .shutdown = sock_no_shutdown,
1794 .setsockopt = pppol2tp_setsockopt, 1794 .setsockopt = pppol2tp_setsockopt,
diff --git a/net/llc/af_llc.c b/net/llc/af_llc.c
index 1beeea9549fa..804de8490186 100644
--- a/net/llc/af_llc.c
+++ b/net/llc/af_llc.c
@@ -1192,7 +1192,7 @@ static const struct proto_ops llc_ui_ops = {
1192 .socketpair = sock_no_socketpair, 1192 .socketpair = sock_no_socketpair,
1193 .accept = llc_ui_accept, 1193 .accept = llc_ui_accept,
1194 .getname = llc_ui_getname, 1194 .getname = llc_ui_getname,
1195 .poll = datagram_poll, 1195 .poll_mask = datagram_poll_mask,
1196 .ioctl = llc_ui_ioctl, 1196 .ioctl = llc_ui_ioctl,
1197 .listen = llc_ui_listen, 1197 .listen = llc_ui_listen,
1198 .shutdown = llc_ui_shutdown, 1198 .shutdown = llc_ui_shutdown,
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 393573a99a5a..1189b84413d5 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -2658,7 +2658,7 @@ static const struct proto_ops netlink_ops = {
2658 .socketpair = sock_no_socketpair, 2658 .socketpair = sock_no_socketpair,
2659 .accept = sock_no_accept, 2659 .accept = sock_no_accept,
2660 .getname = netlink_getname, 2660 .getname = netlink_getname,
2661 .poll = datagram_poll, 2661 .poll_mask = datagram_poll_mask,
2662 .ioctl = netlink_ioctl, 2662 .ioctl = netlink_ioctl,
2663 .listen = sock_no_listen, 2663 .listen = sock_no_listen,
2664 .shutdown = sock_no_shutdown, 2664 .shutdown = sock_no_shutdown,
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index c2888c78d4c1..b97eb766a1d5 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -1355,7 +1355,7 @@ static const struct proto_ops nr_proto_ops = {
1355 .socketpair = sock_no_socketpair, 1355 .socketpair = sock_no_socketpair,
1356 .accept = nr_accept, 1356 .accept = nr_accept,
1357 .getname = nr_getname, 1357 .getname = nr_getname,
1358 .poll = datagram_poll, 1358 .poll_mask = datagram_poll_mask,
1359 .ioctl = nr_ioctl, 1359 .ioctl = nr_ioctl,
1360 .listen = nr_listen, 1360 .listen = nr_listen,
1361 .shutdown = sock_no_shutdown, 1361 .shutdown = sock_no_shutdown,
diff --git a/net/nfc/llcp_sock.c b/net/nfc/llcp_sock.c
index ea0c0c6f1874..ab5bb14b49af 100644
--- a/net/nfc/llcp_sock.c
+++ b/net/nfc/llcp_sock.c
@@ -548,16 +548,13 @@ static inline __poll_t llcp_accept_poll(struct sock *parent)
548 return 0; 548 return 0;
549} 549}
550 550
551static __poll_t llcp_sock_poll(struct file *file, struct socket *sock, 551static __poll_t llcp_sock_poll_mask(struct socket *sock, __poll_t events)
552 poll_table *wait)
553{ 552{
554 struct sock *sk = sock->sk; 553 struct sock *sk = sock->sk;
555 __poll_t mask = 0; 554 __poll_t mask = 0;
556 555
557 pr_debug("%p\n", sk); 556 pr_debug("%p\n", sk);
558 557
559 sock_poll_wait(file, sk_sleep(sk), wait);
560
561 if (sk->sk_state == LLCP_LISTEN) 558 if (sk->sk_state == LLCP_LISTEN)
562 return llcp_accept_poll(sk); 559 return llcp_accept_poll(sk);
563 560
@@ -899,7 +896,7 @@ static const struct proto_ops llcp_sock_ops = {
899 .socketpair = sock_no_socketpair, 896 .socketpair = sock_no_socketpair,
900 .accept = llcp_sock_accept, 897 .accept = llcp_sock_accept,
901 .getname = llcp_sock_getname, 898 .getname = llcp_sock_getname,
902 .poll = llcp_sock_poll, 899 .poll_mask = llcp_sock_poll_mask,
903 .ioctl = sock_no_ioctl, 900 .ioctl = sock_no_ioctl,
904 .listen = llcp_sock_listen, 901 .listen = llcp_sock_listen,
905 .shutdown = sock_no_shutdown, 902 .shutdown = sock_no_shutdown,
@@ -919,7 +916,7 @@ static const struct proto_ops llcp_rawsock_ops = {
919 .socketpair = sock_no_socketpair, 916 .socketpair = sock_no_socketpair,
920 .accept = sock_no_accept, 917 .accept = sock_no_accept,
921 .getname = llcp_sock_getname, 918 .getname = llcp_sock_getname,
922 .poll = llcp_sock_poll, 919 .poll_mask = llcp_sock_poll_mask,
923 .ioctl = sock_no_ioctl, 920 .ioctl = sock_no_ioctl,
924 .listen = sock_no_listen, 921 .listen = sock_no_listen,
925 .shutdown = sock_no_shutdown, 922 .shutdown = sock_no_shutdown,
diff --git a/net/nfc/rawsock.c b/net/nfc/rawsock.c
index e2188deb08dc..60c322531c49 100644
--- a/net/nfc/rawsock.c
+++ b/net/nfc/rawsock.c
@@ -284,7 +284,7 @@ static const struct proto_ops rawsock_ops = {
284 .socketpair = sock_no_socketpair, 284 .socketpair = sock_no_socketpair,
285 .accept = sock_no_accept, 285 .accept = sock_no_accept,
286 .getname = sock_no_getname, 286 .getname = sock_no_getname,
287 .poll = datagram_poll, 287 .poll_mask = datagram_poll_mask,
288 .ioctl = sock_no_ioctl, 288 .ioctl = sock_no_ioctl,
289 .listen = sock_no_listen, 289 .listen = sock_no_listen,
290 .shutdown = sock_no_shutdown, 290 .shutdown = sock_no_shutdown,
@@ -304,7 +304,7 @@ static const struct proto_ops rawsock_raw_ops = {
304 .socketpair = sock_no_socketpair, 304 .socketpair = sock_no_socketpair,
305 .accept = sock_no_accept, 305 .accept = sock_no_accept,
306 .getname = sock_no_getname, 306 .getname = sock_no_getname,
307 .poll = datagram_poll, 307 .poll_mask = datagram_poll_mask,
308 .ioctl = sock_no_ioctl, 308 .ioctl = sock_no_ioctl,
309 .listen = sock_no_listen, 309 .listen = sock_no_listen,
310 .shutdown = sock_no_shutdown, 310 .shutdown = sock_no_shutdown,
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index f9cdd27a7f6f..674390b1f084 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -4110,12 +4110,11 @@ static int packet_ioctl(struct socket *sock, unsigned int cmd,
4110 return 0; 4110 return 0;
4111} 4111}
4112 4112
4113static __poll_t packet_poll(struct file *file, struct socket *sock, 4113static __poll_t packet_poll_mask(struct socket *sock, __poll_t events)
4114 poll_table *wait)
4115{ 4114{
4116 struct sock *sk = sock->sk; 4115 struct sock *sk = sock->sk;
4117 struct packet_sock *po = pkt_sk(sk); 4116 struct packet_sock *po = pkt_sk(sk);
4118 __poll_t mask = datagram_poll(file, sock, wait); 4117 __poll_t mask = datagram_poll_mask(sock, events);
4119 4118
4120 spin_lock_bh(&sk->sk_receive_queue.lock); 4119 spin_lock_bh(&sk->sk_receive_queue.lock);
4121 if (po->rx_ring.pg_vec) { 4120 if (po->rx_ring.pg_vec) {
@@ -4457,7 +4456,7 @@ static const struct proto_ops packet_ops_spkt = {
4457 .socketpair = sock_no_socketpair, 4456 .socketpair = sock_no_socketpair,
4458 .accept = sock_no_accept, 4457 .accept = sock_no_accept,
4459 .getname = packet_getname_spkt, 4458 .getname = packet_getname_spkt,
4460 .poll = datagram_poll, 4459 .poll_mask = datagram_poll_mask,
4461 .ioctl = packet_ioctl, 4460 .ioctl = packet_ioctl,
4462 .listen = sock_no_listen, 4461 .listen = sock_no_listen,
4463 .shutdown = sock_no_shutdown, 4462 .shutdown = sock_no_shutdown,
@@ -4478,7 +4477,7 @@ static const struct proto_ops packet_ops = {
4478 .socketpair = sock_no_socketpair, 4477 .socketpair = sock_no_socketpair,
4479 .accept = sock_no_accept, 4478 .accept = sock_no_accept,
4480 .getname = packet_getname, 4479 .getname = packet_getname,
4481 .poll = packet_poll, 4480 .poll_mask = packet_poll_mask,
4482 .ioctl = packet_ioctl, 4481 .ioctl = packet_ioctl,
4483 .listen = sock_no_listen, 4482 .listen = sock_no_listen,
4484 .shutdown = sock_no_shutdown, 4483 .shutdown = sock_no_shutdown,
diff --git a/net/phonet/socket.c b/net/phonet/socket.c
index 30187990257f..c295c4e20f01 100644
--- a/net/phonet/socket.c
+++ b/net/phonet/socket.c
@@ -340,15 +340,12 @@ static int pn_socket_getname(struct socket *sock, struct sockaddr *addr,
340 return sizeof(struct sockaddr_pn); 340 return sizeof(struct sockaddr_pn);
341} 341}
342 342
343static __poll_t pn_socket_poll(struct file *file, struct socket *sock, 343static __poll_t pn_socket_poll_mask(struct socket *sock, __poll_t events)
344 poll_table *wait)
345{ 344{
346 struct sock *sk = sock->sk; 345 struct sock *sk = sock->sk;
347 struct pep_sock *pn = pep_sk(sk); 346 struct pep_sock *pn = pep_sk(sk);
348 __poll_t mask = 0; 347 __poll_t mask = 0;
349 348
350 poll_wait(file, sk_sleep(sk), wait);
351
352 if (sk->sk_state == TCP_CLOSE) 349 if (sk->sk_state == TCP_CLOSE)
353 return EPOLLERR; 350 return EPOLLERR;
354 if (!skb_queue_empty(&sk->sk_receive_queue)) 351 if (!skb_queue_empty(&sk->sk_receive_queue))
@@ -448,7 +445,7 @@ const struct proto_ops phonet_dgram_ops = {
448 .socketpair = sock_no_socketpair, 445 .socketpair = sock_no_socketpair,
449 .accept = sock_no_accept, 446 .accept = sock_no_accept,
450 .getname = pn_socket_getname, 447 .getname = pn_socket_getname,
451 .poll = datagram_poll, 448 .poll_mask = datagram_poll_mask,
452 .ioctl = pn_socket_ioctl, 449 .ioctl = pn_socket_ioctl,
453 .listen = sock_no_listen, 450 .listen = sock_no_listen,
454 .shutdown = sock_no_shutdown, 451 .shutdown = sock_no_shutdown,
@@ -473,7 +470,7 @@ const struct proto_ops phonet_stream_ops = {
473 .socketpair = sock_no_socketpair, 470 .socketpair = sock_no_socketpair,
474 .accept = pn_socket_accept, 471 .accept = pn_socket_accept,
475 .getname = pn_socket_getname, 472 .getname = pn_socket_getname,
476 .poll = pn_socket_poll, 473 .poll_mask = pn_socket_poll_mask,
477 .ioctl = pn_socket_ioctl, 474 .ioctl = pn_socket_ioctl,
478 .listen = pn_socket_listen, 475 .listen = pn_socket_listen,
479 .shutdown = sock_no_shutdown, 476 .shutdown = sock_no_shutdown,
diff --git a/net/qrtr/qrtr.c b/net/qrtr/qrtr.c
index 2aa07b547b16..1b5025ea5b04 100644
--- a/net/qrtr/qrtr.c
+++ b/net/qrtr/qrtr.c
@@ -1023,7 +1023,7 @@ static const struct proto_ops qrtr_proto_ops = {
1023 .recvmsg = qrtr_recvmsg, 1023 .recvmsg = qrtr_recvmsg,
1024 .getname = qrtr_getname, 1024 .getname = qrtr_getname,
1025 .ioctl = qrtr_ioctl, 1025 .ioctl = qrtr_ioctl,
1026 .poll = datagram_poll, 1026 .poll_mask = datagram_poll_mask,
1027 .shutdown = sock_no_shutdown, 1027 .shutdown = sock_no_shutdown,
1028 .setsockopt = sock_no_setsockopt, 1028 .setsockopt = sock_no_setsockopt,
1029 .getsockopt = sock_no_getsockopt, 1029 .getsockopt = sock_no_getsockopt,
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 22a7f2b413ac..5b73fea849df 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -1470,7 +1470,7 @@ static const struct proto_ops rose_proto_ops = {
1470 .socketpair = sock_no_socketpair, 1470 .socketpair = sock_no_socketpair,
1471 .accept = rose_accept, 1471 .accept = rose_accept,
1472 .getname = rose_getname, 1472 .getname = rose_getname,
1473 .poll = datagram_poll, 1473 .poll_mask = datagram_poll_mask,
1474 .ioctl = rose_ioctl, 1474 .ioctl = rose_ioctl,
1475 .listen = rose_listen, 1475 .listen = rose_listen,
1476 .shutdown = sock_no_shutdown, 1476 .shutdown = sock_no_shutdown,
diff --git a/net/rxrpc/af_rxrpc.c b/net/rxrpc/af_rxrpc.c
index 2b463047dd7b..3b1ac93efee2 100644
--- a/net/rxrpc/af_rxrpc.c
+++ b/net/rxrpc/af_rxrpc.c
@@ -734,15 +734,11 @@ static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
734/* 734/*
735 * permit an RxRPC socket to be polled 735 * permit an RxRPC socket to be polled
736 */ 736 */
737static __poll_t rxrpc_poll(struct file *file, struct socket *sock, 737static __poll_t rxrpc_poll_mask(struct socket *sock, __poll_t events)
738 poll_table *wait)
739{ 738{
740 struct sock *sk = sock->sk; 739 struct sock *sk = sock->sk;
741 struct rxrpc_sock *rx = rxrpc_sk(sk); 740 struct rxrpc_sock *rx = rxrpc_sk(sk);
742 __poll_t mask; 741 __poll_t mask = 0;
743
744 sock_poll_wait(file, sk_sleep(sk), wait);
745 mask = 0;
746 742
747 /* the socket is readable if there are any messages waiting on the Rx 743 /* the socket is readable if there are any messages waiting on the Rx
748 * queue */ 744 * queue */
@@ -949,7 +945,7 @@ static const struct proto_ops rxrpc_rpc_ops = {
949 .socketpair = sock_no_socketpair, 945 .socketpair = sock_no_socketpair,
950 .accept = sock_no_accept, 946 .accept = sock_no_accept,
951 .getname = sock_no_getname, 947 .getname = sock_no_getname,
952 .poll = rxrpc_poll, 948 .poll_mask = rxrpc_poll_mask,
953 .ioctl = sock_no_ioctl, 949 .ioctl = sock_no_ioctl,
954 .listen = rxrpc_listen, 950 .listen = rxrpc_listen,
955 .shutdown = rxrpc_shutdown, 951 .shutdown = rxrpc_shutdown,
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index 0cd2e764f47f..7339918a805d 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -1010,7 +1010,7 @@ static const struct proto_ops inet6_seqpacket_ops = {
1010 .socketpair = sock_no_socketpair, 1010 .socketpair = sock_no_socketpair,
1011 .accept = inet_accept, 1011 .accept = inet_accept,
1012 .getname = sctp_getname, 1012 .getname = sctp_getname,
1013 .poll = sctp_poll, 1013 .poll_mask = sctp_poll_mask,
1014 .ioctl = inet6_ioctl, 1014 .ioctl = inet6_ioctl,
1015 .listen = sctp_inet_listen, 1015 .listen = sctp_inet_listen,
1016 .shutdown = inet_shutdown, 1016 .shutdown = inet_shutdown,
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 6bf0a9971888..11d93377ba5e 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -1016,7 +1016,7 @@ static const struct proto_ops inet_seqpacket_ops = {
1016 .socketpair = sock_no_socketpair, 1016 .socketpair = sock_no_socketpair,
1017 .accept = inet_accept, 1017 .accept = inet_accept,
1018 .getname = inet_getname, /* Semantics are different. */ 1018 .getname = inet_getname, /* Semantics are different. */
1019 .poll = sctp_poll, 1019 .poll_mask = sctp_poll_mask,
1020 .ioctl = inet_ioctl, 1020 .ioctl = inet_ioctl,
1021 .listen = sctp_inet_listen, 1021 .listen = sctp_inet_listen,
1022 .shutdown = inet_shutdown, /* Looks harmless. */ 1022 .shutdown = inet_shutdown, /* Looks harmless. */
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index ae7e7c606f72..bf747094d26b 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -7722,14 +7722,12 @@ out:
7722 * here, again, by modeling the current TCP/UDP code. We don't have 7722 * here, again, by modeling the current TCP/UDP code. We don't have
7723 * a good way to test with it yet. 7723 * a good way to test with it yet.
7724 */ 7724 */
7725__poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait) 7725__poll_t sctp_poll_mask(struct socket *sock, __poll_t events)
7726{ 7726{
7727 struct sock *sk = sock->sk; 7727 struct sock *sk = sock->sk;
7728 struct sctp_sock *sp = sctp_sk(sk); 7728 struct sctp_sock *sp = sctp_sk(sk);
7729 __poll_t mask; 7729 __poll_t mask;
7730 7730
7731 poll_wait(file, sk_sleep(sk), wait);
7732
7733 sock_rps_record_flow(sk); 7731 sock_rps_record_flow(sk);
7734 7732
7735 /* A TCP-style listening socket becomes readable when the accept queue 7733 /* A TCP-style listening socket becomes readable when the accept queue
diff --git a/net/socket.c b/net/socket.c
index f10f1d947c78..2d752e9eb3f9 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -117,8 +117,10 @@ static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
117static int sock_mmap(struct file *file, struct vm_area_struct *vma); 117static int sock_mmap(struct file *file, struct vm_area_struct *vma);
118 118
119static int sock_close(struct inode *inode, struct file *file); 119static int sock_close(struct inode *inode, struct file *file);
120static __poll_t sock_poll(struct file *file, 120static struct wait_queue_head *sock_get_poll_head(struct file *file,
121 struct poll_table_struct *wait); 121 __poll_t events);
122static __poll_t sock_poll_mask(struct file *file, __poll_t);
123static __poll_t sock_poll(struct file *file, struct poll_table_struct *wait);
122static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 124static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
123#ifdef CONFIG_COMPAT 125#ifdef CONFIG_COMPAT
124static long compat_sock_ioctl(struct file *file, 126static long compat_sock_ioctl(struct file *file,
@@ -141,6 +143,8 @@ static const struct file_operations socket_file_ops = {
141 .llseek = no_llseek, 143 .llseek = no_llseek,
142 .read_iter = sock_read_iter, 144 .read_iter = sock_read_iter,
143 .write_iter = sock_write_iter, 145 .write_iter = sock_write_iter,
146 .get_poll_head = sock_get_poll_head,
147 .poll_mask = sock_poll_mask,
144 .poll = sock_poll, 148 .poll = sock_poll,
145 .unlocked_ioctl = sock_ioctl, 149 .unlocked_ioctl = sock_ioctl,
146#ifdef CONFIG_COMPAT 150#ifdef CONFIG_COMPAT
@@ -1114,27 +1118,48 @@ out_release:
1114} 1118}
1115EXPORT_SYMBOL(sock_create_lite); 1119EXPORT_SYMBOL(sock_create_lite);
1116 1120
1117/* No kernel lock held - perfect */ 1121static struct wait_queue_head *sock_get_poll_head(struct file *file,
1118static __poll_t sock_poll(struct file *file, poll_table *wait) 1122 __poll_t events)
1119{ 1123{
1120 __poll_t busy_flag = 0; 1124 struct socket *sock = file->private_data;
1121 struct socket *sock; 1125
1126 if (!sock->ops->poll_mask)
1127 return NULL;
1128 sock_poll_busy_loop(sock, events);
1129 return sk_sleep(sock->sk);
1130}
1131
1132static __poll_t sock_poll_mask(struct file *file, __poll_t events)
1133{
1134 struct socket *sock = file->private_data;
1122 1135
1123 /* 1136 /*
1124 * We can't return errors to poll, so it's either yes or no. 1137 * We need to be sure we are in sync with the socket flags modification.
1138 *
1139 * This memory barrier is paired in the wq_has_sleeper.
1125 */ 1140 */
1126 sock = file->private_data; 1141 smp_mb();
1142
1143 /* this socket can poll_ll so tell the system call */
1144 return sock->ops->poll_mask(sock, events) |
1145 (sk_can_busy_loop(sock->sk) ? POLL_BUSY_LOOP : 0);
1146}
1127 1147
1128 if (sk_can_busy_loop(sock->sk)) { 1148/* No kernel lock held - perfect */
1129 /* this socket can poll_ll so tell the system call */ 1149static __poll_t sock_poll(struct file *file, poll_table *wait)
1130 busy_flag = POLL_BUSY_LOOP; 1150{
1151 struct socket *sock = file->private_data;
1152 __poll_t events = poll_requested_events(wait), mask = 0;
1131 1153
1132 /* once, only if requested by syscall */ 1154 if (sock->ops->poll) {
1133 if (wait && (wait->_key & POLL_BUSY_LOOP)) 1155 sock_poll_busy_loop(sock, events);
1134 sk_busy_loop(sock->sk, 1); 1156 mask = sock->ops->poll(file, sock, wait);
1157 } else if (sock->ops->poll_mask) {
1158 sock_poll_wait(file, sock_get_poll_head(file, events), wait);
1159 mask = sock->ops->poll_mask(sock, events);
1135 } 1160 }
1136 1161
1137 return busy_flag | sock->ops->poll(file, sock, wait); 1162 return mask | sock_poll_busy_flag(sock);
1138} 1163}
1139 1164
1140static int sock_mmap(struct file *file, struct vm_area_struct *vma) 1165static int sock_mmap(struct file *file, struct vm_area_struct *vma)
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 6be21575503a..3bb45042e833 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -692,10 +692,9 @@ static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
692} 692}
693 693
694/** 694/**
695 * tipc_poll - read and possibly block on pollmask 695 * tipc_poll - read pollmask
696 * @file: file structure associated with the socket 696 * @file: file structure associated with the socket
697 * @sock: socket for which to calculate the poll bits 697 * @sock: socket for which to calculate the poll bits
698 * @wait: ???
699 * 698 *
700 * Returns pollmask value 699 * Returns pollmask value
701 * 700 *
@@ -709,15 +708,12 @@ static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
709 * imply that the operation will succeed, merely that it should be performed 708 * imply that the operation will succeed, merely that it should be performed
710 * and will not block. 709 * and will not block.
711 */ 710 */
712static __poll_t tipc_poll(struct file *file, struct socket *sock, 711static __poll_t tipc_poll_mask(struct socket *sock, __poll_t events)
713 poll_table *wait)
714{ 712{
715 struct sock *sk = sock->sk; 713 struct sock *sk = sock->sk;
716 struct tipc_sock *tsk = tipc_sk(sk); 714 struct tipc_sock *tsk = tipc_sk(sk);
717 __poll_t revents = 0; 715 __poll_t revents = 0;
718 716
719 sock_poll_wait(file, sk_sleep(sk), wait);
720
721 if (sk->sk_shutdown & RCV_SHUTDOWN) 717 if (sk->sk_shutdown & RCV_SHUTDOWN)
722 revents |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM; 718 revents |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
723 if (sk->sk_shutdown == SHUTDOWN_MASK) 719 if (sk->sk_shutdown == SHUTDOWN_MASK)
@@ -3028,7 +3024,7 @@ static const struct proto_ops msg_ops = {
3028 .socketpair = tipc_socketpair, 3024 .socketpair = tipc_socketpair,
3029 .accept = sock_no_accept, 3025 .accept = sock_no_accept,
3030 .getname = tipc_getname, 3026 .getname = tipc_getname,
3031 .poll = tipc_poll, 3027 .poll_mask = tipc_poll_mask,
3032 .ioctl = tipc_ioctl, 3028 .ioctl = tipc_ioctl,
3033 .listen = sock_no_listen, 3029 .listen = sock_no_listen,
3034 .shutdown = tipc_shutdown, 3030 .shutdown = tipc_shutdown,
@@ -3049,7 +3045,7 @@ static const struct proto_ops packet_ops = {
3049 .socketpair = tipc_socketpair, 3045 .socketpair = tipc_socketpair,
3050 .accept = tipc_accept, 3046 .accept = tipc_accept,
3051 .getname = tipc_getname, 3047 .getname = tipc_getname,
3052 .poll = tipc_poll, 3048 .poll_mask = tipc_poll_mask,
3053 .ioctl = tipc_ioctl, 3049 .ioctl = tipc_ioctl,
3054 .listen = tipc_listen, 3050 .listen = tipc_listen,
3055 .shutdown = tipc_shutdown, 3051 .shutdown = tipc_shutdown,
@@ -3070,7 +3066,7 @@ static const struct proto_ops stream_ops = {
3070 .socketpair = tipc_socketpair, 3066 .socketpair = tipc_socketpair,
3071 .accept = tipc_accept, 3067 .accept = tipc_accept,
3072 .getname = tipc_getname, 3068 .getname = tipc_getname,
3073 .poll = tipc_poll, 3069 .poll_mask = tipc_poll_mask,
3074 .ioctl = tipc_ioctl, 3070 .ioctl = tipc_ioctl,
3075 .listen = tipc_listen, 3071 .listen = tipc_listen,
3076 .shutdown = tipc_shutdown, 3072 .shutdown = tipc_shutdown,
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index e5473c03d667..95b02a71fd47 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -638,9 +638,8 @@ static int unix_stream_connect(struct socket *, struct sockaddr *,
638static int unix_socketpair(struct socket *, struct socket *); 638static int unix_socketpair(struct socket *, struct socket *);
639static int unix_accept(struct socket *, struct socket *, int, bool); 639static int unix_accept(struct socket *, struct socket *, int, bool);
640static int unix_getname(struct socket *, struct sockaddr *, int); 640static int unix_getname(struct socket *, struct sockaddr *, int);
641static __poll_t unix_poll(struct file *, struct socket *, poll_table *); 641static __poll_t unix_poll_mask(struct socket *, __poll_t);
642static __poll_t unix_dgram_poll(struct file *, struct socket *, 642static __poll_t unix_dgram_poll_mask(struct socket *, __poll_t);
643 poll_table *);
644static int unix_ioctl(struct socket *, unsigned int, unsigned long); 643static int unix_ioctl(struct socket *, unsigned int, unsigned long);
645static int unix_shutdown(struct socket *, int); 644static int unix_shutdown(struct socket *, int);
646static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t); 645static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
@@ -681,7 +680,7 @@ static const struct proto_ops unix_stream_ops = {
681 .socketpair = unix_socketpair, 680 .socketpair = unix_socketpair,
682 .accept = unix_accept, 681 .accept = unix_accept,
683 .getname = unix_getname, 682 .getname = unix_getname,
684 .poll = unix_poll, 683 .poll_mask = unix_poll_mask,
685 .ioctl = unix_ioctl, 684 .ioctl = unix_ioctl,
686 .listen = unix_listen, 685 .listen = unix_listen,
687 .shutdown = unix_shutdown, 686 .shutdown = unix_shutdown,
@@ -704,7 +703,7 @@ static const struct proto_ops unix_dgram_ops = {
704 .socketpair = unix_socketpair, 703 .socketpair = unix_socketpair,
705 .accept = sock_no_accept, 704 .accept = sock_no_accept,
706 .getname = unix_getname, 705 .getname = unix_getname,
707 .poll = unix_dgram_poll, 706 .poll_mask = unix_dgram_poll_mask,
708 .ioctl = unix_ioctl, 707 .ioctl = unix_ioctl,
709 .listen = sock_no_listen, 708 .listen = sock_no_listen,
710 .shutdown = unix_shutdown, 709 .shutdown = unix_shutdown,
@@ -726,7 +725,7 @@ static const struct proto_ops unix_seqpacket_ops = {
726 .socketpair = unix_socketpair, 725 .socketpair = unix_socketpair,
727 .accept = unix_accept, 726 .accept = unix_accept,
728 .getname = unix_getname, 727 .getname = unix_getname,
729 .poll = unix_dgram_poll, 728 .poll_mask = unix_dgram_poll_mask,
730 .ioctl = unix_ioctl, 729 .ioctl = unix_ioctl,
731 .listen = unix_listen, 730 .listen = unix_listen,
732 .shutdown = unix_shutdown, 731 .shutdown = unix_shutdown,
@@ -2630,13 +2629,10 @@ static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2630 return err; 2629 return err;
2631} 2630}
2632 2631
2633static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wait) 2632static __poll_t unix_poll_mask(struct socket *sock, __poll_t events)
2634{ 2633{
2635 struct sock *sk = sock->sk; 2634 struct sock *sk = sock->sk;
2636 __poll_t mask; 2635 __poll_t mask = 0;
2637
2638 sock_poll_wait(file, sk_sleep(sk), wait);
2639 mask = 0;
2640 2636
2641 /* exceptional events? */ 2637 /* exceptional events? */
2642 if (sk->sk_err) 2638 if (sk->sk_err)
@@ -2665,15 +2661,11 @@ static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wa
2665 return mask; 2661 return mask;
2666} 2662}
2667 2663
2668static __poll_t unix_dgram_poll(struct file *file, struct socket *sock, 2664static __poll_t unix_dgram_poll_mask(struct socket *sock, __poll_t events)
2669 poll_table *wait)
2670{ 2665{
2671 struct sock *sk = sock->sk, *other; 2666 struct sock *sk = sock->sk, *other;
2672 unsigned int writable; 2667 int writable;
2673 __poll_t mask; 2668 __poll_t mask = 0;
2674
2675 sock_poll_wait(file, sk_sleep(sk), wait);
2676 mask = 0;
2677 2669
2678 /* exceptional events? */ 2670 /* exceptional events? */
2679 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 2671 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
@@ -2699,7 +2691,7 @@ static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
2699 } 2691 }
2700 2692
2701 /* No write status requested, avoid expensive OUT tests. */ 2693 /* No write status requested, avoid expensive OUT tests. */
2702 if (!(poll_requested_events(wait) & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT))) 2694 if (!(events & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
2703 return mask; 2695 return mask;
2704 2696
2705 writable = unix_writable(sk); 2697 writable = unix_writable(sk);
diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
index c1076c19b858..bb5d5fa68c35 100644
--- a/net/vmw_vsock/af_vsock.c
+++ b/net/vmw_vsock/af_vsock.c
@@ -850,18 +850,11 @@ static int vsock_shutdown(struct socket *sock, int mode)
850 return err; 850 return err;
851} 851}
852 852
853static __poll_t vsock_poll(struct file *file, struct socket *sock, 853static __poll_t vsock_poll_mask(struct socket *sock, __poll_t events)
854 poll_table *wait)
855{ 854{
856 struct sock *sk; 855 struct sock *sk = sock->sk;
857 __poll_t mask; 856 struct vsock_sock *vsk = vsock_sk(sk);
858 struct vsock_sock *vsk; 857 __poll_t mask = 0;
859
860 sk = sock->sk;
861 vsk = vsock_sk(sk);
862
863 poll_wait(file, sk_sleep(sk), wait);
864 mask = 0;
865 858
866 if (sk->sk_err) 859 if (sk->sk_err)
867 /* Signify that there has been an error on this socket. */ 860 /* Signify that there has been an error on this socket. */
@@ -1091,7 +1084,7 @@ static const struct proto_ops vsock_dgram_ops = {
1091 .socketpair = sock_no_socketpair, 1084 .socketpair = sock_no_socketpair,
1092 .accept = sock_no_accept, 1085 .accept = sock_no_accept,
1093 .getname = vsock_getname, 1086 .getname = vsock_getname,
1094 .poll = vsock_poll, 1087 .poll_mask = vsock_poll_mask,
1095 .ioctl = sock_no_ioctl, 1088 .ioctl = sock_no_ioctl,
1096 .listen = sock_no_listen, 1089 .listen = sock_no_listen,
1097 .shutdown = vsock_shutdown, 1090 .shutdown = vsock_shutdown,
@@ -1849,7 +1842,7 @@ static const struct proto_ops vsock_stream_ops = {
1849 .socketpair = sock_no_socketpair, 1842 .socketpair = sock_no_socketpair,
1850 .accept = vsock_accept, 1843 .accept = vsock_accept,
1851 .getname = vsock_getname, 1844 .getname = vsock_getname,
1852 .poll = vsock_poll, 1845 .poll_mask = vsock_poll_mask,
1853 .ioctl = sock_no_ioctl, 1846 .ioctl = sock_no_ioctl,
1854 .listen = vsock_listen, 1847 .listen = vsock_listen,
1855 .shutdown = vsock_shutdown, 1848 .shutdown = vsock_shutdown,
diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c
index d49aa79b7997..f93365ae0fdd 100644
--- a/net/x25/af_x25.c
+++ b/net/x25/af_x25.c
@@ -1750,7 +1750,7 @@ static const struct proto_ops x25_proto_ops = {
1750 .socketpair = sock_no_socketpair, 1750 .socketpair = sock_no_socketpair,
1751 .accept = x25_accept, 1751 .accept = x25_accept,
1752 .getname = x25_getname, 1752 .getname = x25_getname,
1753 .poll = datagram_poll, 1753 .poll_mask = datagram_poll_mask,
1754 .ioctl = x25_ioctl, 1754 .ioctl = x25_ioctl,
1755#ifdef CONFIG_COMPAT 1755#ifdef CONFIG_COMPAT
1756 .compat_ioctl = compat_x25_ioctl, 1756 .compat_ioctl = compat_x25_ioctl,
diff --git a/virt/kvm/eventfd.c b/virt/kvm/eventfd.c
index 6e865e8b5b10..90d30fbe95ae 100644
--- a/virt/kvm/eventfd.c
+++ b/virt/kvm/eventfd.c
@@ -397,7 +397,7 @@ kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
397 * Check if there was an event already pending on the eventfd 397 * Check if there was an event already pending on the eventfd
398 * before we registered, and trigger it as if we didn't miss it. 398 * before we registered, and trigger it as if we didn't miss it.
399 */ 399 */
400 events = f.file->f_op->poll(f.file, &irqfd->pt); 400 events = vfs_poll(f.file, &irqfd->pt);
401 401
402 if (events & EPOLLIN) 402 if (events & EPOLLIN)
403 schedule_work(&irqfd->inject); 403 schedule_work(&irqfd->inject);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-15 18:57:02 -0500