vfs: do bulk POLL* -> EPOLL* replacement

This is the mindless scripted replacement of kernel use of POLL*
variables as described by Al, done by this script:

    for V in IN OUT PRI ERR RDNORM RDBAND WRNORM WRBAND HUP RDHUP NVAL MSG; do
        L=`git grep -l -w POLL$V | grep -v '^t' | grep -v /um/ | grep -v '^sa' | grep -v '/poll.h$'|grep -v '^D'`
        for f in $L; do sed -i "-es/^\([^\"]*\)\(\<POLL$V\>\)/\\1E\\2/" $f; done
    done

with de-mangling cleanups yet to come.

NOTE! On almost all architectures, the EPOLL* constants have the same
values as the POLL* constants do.  But they keyword here is "almost".
For various bad reasons they aren't the same, and epoll() doesn't
actually work quite correctly in some cases due to this on Sparc et al.

The next patch from Al will sort out the final differences, and we
should be all done.

Scripted-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 17 insertions, 17 deletions

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index c059aa7df0a9..48636aee23c3 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -512,36 +512,36 @@ __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
         mask = 0;
 
         /*
-         * POLLHUP is certainly not done right. But poll() doesn't
+         * EPOLLHUP is certainly not done right. But poll() doesn't
          * have a notion of HUP in just one direction, and for a
          * socket the read side is more interesting.
          *
-         * Some poll() documentation says that POLLHUP is incompatible
-         * with the POLLOUT/POLLWR flags, so somebody should check this
+         * Some poll() documentation says that EPOLLHUP is incompatible
+         * with the EPOLLOUT/POLLWR flags, so somebody should check this
          * all. But careful, it tends to be safer to return too many
          * bits than too few, and you can easily break real applications
          * if you don't tell them that something has hung up!
          *
          * Check-me.
          *
-         * Check number 1. POLLHUP is _UNMASKABLE_ event (see UNIX98 and
+         * Check number 1. EPOLLHUP is _UNMASKABLE_ event (see UNIX98 and
          * our fs/select.c). It means that after we received EOF,
          * poll always returns immediately, making impossible poll() on write()
-         * in state CLOSE_WAIT. One solution is evident --- to set POLLHUP
+         * in state CLOSE_WAIT. One solution is evident --- to set EPOLLHUP
          * if and only if shutdown has been made in both directions.
          * Actually, it is interesting to look how Solaris and DUX
-         * solve this dilemma. I would prefer, if POLLHUP were maskable,
+         * solve this dilemma. I would prefer, if EPOLLHUP were maskable,
          * then we could set it on SND_SHUTDOWN. BTW examples given
          * in Stevens' books assume exactly this behaviour, it explains
-         * why POLLHUP is incompatible with POLLOUT.    --ANK
+         * why EPOLLHUP is incompatible with EPOLLOUT.  --ANK
          *
          * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
          * blocking on fresh not-connected or disconnected socket. --ANK
          */
         if (sk->sk_shutdown == SHUTDOWN_MASK || state == TCP_CLOSE)
-                mask |= POLLHUP;
+                mask |= EPOLLHUP;
         if (sk->sk_shutdown & RCV_SHUTDOWN)
-                mask |= POLLIN | POLLRDNORM | POLLRDHUP;
+                mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
 
         /* Connected or passive Fast Open socket? */
         if (state != TCP_SYN_SENT &&
@@ -554,11 +554,11 @@ __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
                         target++;
 
                 if (tp->rcv_nxt - tp->copied_seq >= target)
-                        mask |= POLLIN | POLLRDNORM;
+                        mask |= EPOLLIN | EPOLLRDNORM;
 
                 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
                         if (sk_stream_is_writeable(sk)) {
-                                mask |= POLLOUT | POLLWRNORM;
+                                mask |= EPOLLOUT | EPOLLWRNORM;
                         } else {  /* send SIGIO later */
                                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
                                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
@@ -570,24 +570,24 @@ __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
                                  */
                                 smp_mb__after_atomic();
                                 if (sk_stream_is_writeable(sk))
-                                        mask |= POLLOUT | POLLWRNORM;
+                                        mask |= EPOLLOUT | EPOLLWRNORM;
                         }
                 } else
-                        mask |= POLLOUT | POLLWRNORM;
+                        mask |= EPOLLOUT | EPOLLWRNORM;
 
                 if (tp->urg_data & TCP_URG_VALID)
-                        mask |= POLLPRI;
+                        mask |= EPOLLPRI;
         } else if (state == TCP_SYN_SENT && inet_sk(sk)->defer_connect) {
                 /* Active TCP fastopen socket with defer_connect
-                 * Return POLLOUT so application can call write()
+                 * Return EPOLLOUT so application can call write()
                  * in order for kernel to generate SYN+data
                  */
-                mask |= POLLOUT | POLLWRNORM;
+                mask |= EPOLLOUT | EPOLLWRNORM;
         }
         /* This barrier is coupled with smp_wmb() in tcp_reset() */
         smp_rmb();
         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-                mask |= POLLERR;
+                mask |= EPOLLERR;
 
         return mask;
 }