]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/commitdiff
vfs: do bulk POLL* -> EPOLL* replacement
authorLinus Torvalds <torvalds@linux-foundation.org>
Sun, 11 Feb 2018 22:34:03 +0000 (14:34 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sun, 11 Feb 2018 22:34:03 +0000 (14:34 -0800)
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>
297 files changed:
arch/cris/arch-v10/drivers/gpio.c
arch/cris/arch-v10/drivers/sync_serial.c
arch/cris/arch-v32/drivers/sync_serial.c
arch/ia64/kernel/perfmon.c
arch/mips/kernel/rtlx.c
arch/powerpc/kernel/rtasd.c
arch/powerpc/platforms/cell/spufs/backing_ops.c
arch/powerpc/platforms/cell/spufs/file.c
arch/powerpc/platforms/cell/spufs/hw_ops.c
arch/powerpc/platforms/powernv/opal-prd.c
arch/x86/kernel/apm_32.c
arch/x86/kernel/cpu/mcheck/dev-mcelog.c
block/bsg.c
crypto/af_alg.c
drivers/acpi/acpi_dbg.c
drivers/android/binder.c
drivers/bluetooth/hci_vhci.c
drivers/char/apm-emulation.c
drivers/char/dsp56k.c
drivers/char/dtlk.c
drivers/char/hpet.c
drivers/char/ipmi/bt-bmc.c
drivers/char/ipmi/ipmi_devintf.c
drivers/char/ipmi/ipmi_watchdog.c
drivers/char/pcmcia/cm4040_cs.c
drivers/char/ppdev.c
drivers/char/random.c
drivers/char/rtc.c
drivers/char/snsc.c
drivers/char/sonypi.c
drivers/char/tpm/tpm_vtpm_proxy.c
drivers/char/virtio_console.c
drivers/char/xillybus/xillybus_core.c
drivers/dma-buf/dma-buf.c
drivers/dma-buf/sync_file.c
drivers/firewire/core-cdev.c
drivers/firewire/nosy.c
drivers/gpio/gpiolib.c
drivers/gpu/drm/drm_file.c
drivers/gpu/drm/i915/i915_perf.c
drivers/gpu/vga/vgaarb.c
drivers/hid/hid-debug.c
drivers/hid/hid-roccat.c
drivers/hid/hid-sensor-custom.c
drivers/hid/hidraw.c
drivers/hid/uhid.c
drivers/hid/usbhid/hiddev.c
drivers/hsi/clients/cmt_speech.c
drivers/hv/hv_utils_transport.c
drivers/iio/buffer/industrialio-buffer-dma.c
drivers/iio/industrialio-buffer.c
drivers/iio/industrialio-event.c
drivers/infiniband/core/ucm.c
drivers/infiniband/core/ucma.c
drivers/infiniband/core/user_mad.c
drivers/infiniband/core/uverbs_main.c
drivers/infiniband/hw/hfi1/file_ops.c
drivers/infiniband/hw/qib/qib_file_ops.c
drivers/infiniband/ulp/iser/iscsi_iser.c
drivers/input/evdev.c
drivers/input/input.c
drivers/input/joydev.c
drivers/input/misc/hp_sdc_rtc.c
drivers/input/misc/uinput.c
drivers/input/mousedev.c
drivers/input/serio/serio_raw.c
drivers/input/serio/userio.c
drivers/isdn/capi/capi.c
drivers/isdn/divert/divert_procfs.c
drivers/isdn/hardware/eicon/divamnt.c
drivers/isdn/hardware/eicon/divasi.c
drivers/isdn/hardware/eicon/divasmain.c
drivers/isdn/hardware/eicon/divasproc.c
drivers/isdn/hysdn/hysdn_proclog.c
drivers/isdn/i4l/isdn_common.c
drivers/isdn/i4l/isdn_ppp.c
drivers/isdn/mISDN/timerdev.c
drivers/leds/uleds.c
drivers/macintosh/smu.c
drivers/macintosh/via-pmu.c
drivers/mailbox/mailbox-test.c
drivers/md/dm-ioctl.c
drivers/md/md.c
drivers/media/cec/cec-api.c
drivers/media/common/saa7146/saa7146_fops.c
drivers/media/common/siano/smsdvb-debugfs.c
drivers/media/common/videobuf2/videobuf2-core.c
drivers/media/common/videobuf2/videobuf2-v4l2.c
drivers/media/dvb-core/dmxdev.c
drivers/media/dvb-core/dvb_ca_en50221.c
drivers/media/dvb-core/dvb_frontend.c
drivers/media/firewire/firedtv-ci.c
drivers/media/i2c/saa6588.c
drivers/media/media-devnode.c
drivers/media/pci/bt8xx/bttv-driver.c
drivers/media/pci/cx18/cx18-fileops.c
drivers/media/pci/ddbridge/ddbridge-core.c
drivers/media/pci/ivtv/ivtv-fileops.c
drivers/media/pci/meye/meye.c
drivers/media/pci/saa7164/saa7164-encoder.c
drivers/media/pci/saa7164/saa7164-vbi.c
drivers/media/pci/ttpci/av7110_av.c
drivers/media/pci/ttpci/av7110_ca.c
drivers/media/pci/zoran/zoran_driver.c
drivers/media/platform/fsl-viu.c
drivers/media/platform/s5p-mfc/s5p_mfc.c
drivers/media/platform/soc_camera/soc_camera.c
drivers/media/platform/vivid/vivid-radio-rx.c
drivers/media/platform/vivid/vivid-radio-tx.c
drivers/media/radio/radio-cadet.c
drivers/media/radio/radio-si476x.c
drivers/media/radio/radio-wl1273.c
drivers/media/radio/si470x/radio-si470x-common.c
drivers/media/radio/wl128x/fmdrv_v4l2.c
drivers/media/rc/lirc_dev.c
drivers/media/usb/cpia2/cpia2_core.c
drivers/media/usb/cx231xx/cx231xx-417.c
drivers/media/usb/cx231xx/cx231xx-video.c
drivers/media/usb/gspca/gspca.c
drivers/media/usb/hdpvr/hdpvr-video.c
drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
drivers/media/usb/stkwebcam/stk-webcam.c
drivers/media/usb/tm6000/tm6000-video.c
drivers/media/v4l2-core/v4l2-ctrls.c
drivers/media/v4l2-core/v4l2-dev.c
drivers/media/v4l2-core/v4l2-mem2mem.c
drivers/media/v4l2-core/v4l2-subdev.c
drivers/media/v4l2-core/videobuf-core.c
drivers/mfd/ab8500-debugfs.c
drivers/misc/cxl/file.c
drivers/misc/hpilo.c
drivers/misc/lis3lv02d/lis3lv02d.c
drivers/misc/mei/main.c
drivers/misc/mic/cosm/cosm_scif_server.c
drivers/misc/mic/cosm_client/cosm_scif_client.c
drivers/misc/mic/scif/scif_api.c
drivers/misc/mic/vop/vop_vringh.c
drivers/misc/ocxl/file.c
drivers/misc/phantom.c
drivers/misc/vmw_vmci/vmci_host.c
drivers/net/ieee802154/ca8210.c
drivers/net/ppp/ppp_generic.c
drivers/net/tap.c
drivers/net/tun.c
drivers/net/wireless/ralink/rt2x00/rt2x00debug.c
drivers/pci/switch/switchtec.c
drivers/platform/chrome/cros_ec_debugfs.c
drivers/platform/goldfish/goldfish_pipe.c
drivers/platform/x86/sony-laptop.c
drivers/pps/pps.c
drivers/ptp/ptp_chardev.c
drivers/rapidio/devices/rio_mport_cdev.c
drivers/rpmsg/qcom_smd.c
drivers/rpmsg/rpmsg_char.c
drivers/rtc/rtc-dev.c
drivers/s390/block/dasd_eer.c
drivers/s390/char/monreader.c
drivers/scsi/megaraid/megaraid_sas_base.c
drivers/scsi/mpt3sas/mpt3sas_ctl.c
drivers/scsi/sg.c
drivers/staging/comedi/comedi_fops.c
drivers/staging/comedi/drivers/serial2002.c
drivers/staging/fwserial/fwserial.c
drivers/staging/greybus/tools/loopback_test.c
drivers/staging/irda/net/af_irda.c
drivers/staging/irda/net/irnet/irnet_ppp.c
drivers/staging/media/atomisp/pci/atomisp2/atomisp_fops.c
drivers/staging/media/bcm2048/radio-bcm2048.c
drivers/staging/most/cdev/cdev.c
drivers/staging/most/video/video.c
drivers/staging/speakup/speakup_soft.c
drivers/tty/n_gsm.c
drivers/tty/n_hdlc.c
drivers/tty/n_r3964.c
drivers/tty/n_tty.c
drivers/tty/pty.c
drivers/tty/tty_io.c
drivers/tty/tty_ldisc.c
drivers/tty/vt/vc_screen.c
drivers/uio/uio.c
drivers/usb/class/cdc-wdm.c
drivers/usb/class/usblp.c
drivers/usb/class/usbtmc.c
drivers/usb/core/devices.c
drivers/usb/core/devio.c
drivers/usb/gadget/function/f_fs.c
drivers/usb/gadget/function/f_hid.c
drivers/usb/gadget/function/f_printer.c
drivers/usb/gadget/legacy/inode.c
drivers/usb/misc/iowarrior.c
drivers/usb/misc/ldusb.c
drivers/usb/misc/legousbtower.c
drivers/usb/mon/mon_bin.c
drivers/vfio/virqfd.c
drivers/vhost/net.c
drivers/vhost/vhost.c
drivers/virt/fsl_hypervisor.c
drivers/xen/evtchn.c
drivers/xen/mcelog.c
drivers/xen/pvcalls-front.c
drivers/xen/xenbus/xenbus_dev_frontend.c
fs/cachefiles/daemon.c
fs/coda/psdev.c
fs/debugfs/file.c
fs/dlm/plock.c
fs/dlm/user.c
fs/ecryptfs/miscdev.c
fs/eventfd.c
fs/eventpoll.c
fs/fcntl.c
fs/fuse/dev.c
fs/fuse/file.c
fs/kernfs/file.c
fs/notify/fanotify/fanotify_user.c
fs/notify/inotify/inotify_user.c
fs/ocfs2/dlmfs/dlmfs.c
fs/orangefs/devorangefs-req.c
fs/pipe.c
fs/proc/kmsg.c
fs/proc/proc_sysctl.c
fs/proc_namespace.c
fs/select.c
fs/signalfd.c
fs/timerfd.c
fs/userfaultfd.c
include/linux/scif.h
include/media/videobuf2-core.h
include/net/inet_connection_sock.h
ipc/mqueue.c
kernel/events/core.c
kernel/events/ring_buffer.c
kernel/printk/printk.c
kernel/relay.c
kernel/time/posix-clock.c
kernel/trace/ring_buffer.c
kernel/trace/trace.c
mm/memcontrol.c
mm/swapfile.c
net/9p/trans_fd.c
net/atm/common.c
net/batman-adv/icmp_socket.c
net/batman-adv/log.c
net/bluetooth/af_bluetooth.c
net/caif/caif_socket.c
net/core/datagram.c
net/core/sock.c
net/core/stream.c
net/dccp/proto.c
net/decnet/af_decnet.c
net/ipv4/af_inet.c
net/ipv4/tcp.c
net/ipv4/tcp_input.c
net/ipv4/udp.c
net/iucv/af_iucv.c
net/kcm/kcmsock.c
net/nfc/llcp_sock.c
net/packet/af_packet.c
net/phonet/socket.c
net/rds/af_rds.c
net/rfkill/core.c
net/rxrpc/af_rxrpc.c
net/sctp/socket.c
net/smc/af_smc.c
net/smc/smc_rx.c
net/smc/smc_tx.c
net/sunrpc/cache.c
net/sunrpc/rpc_pipe.c
net/tipc/socket.c
net/unix/af_unix.c
net/vmw_vsock/af_vsock.c
security/apparmor/apparmorfs.c
security/tomoyo/audit.c
security/tomoyo/common.c
security/tomoyo/securityfs_if.c
sound/core/compress_offload.c
sound/core/control.c
sound/core/info.c
sound/core/init.c
sound/core/oss/pcm_oss.c
sound/core/pcm_native.c
sound/core/rawmidi.c
sound/core/seq/oss/seq_oss_rw.c
sound/core/seq/seq_clientmgr.c
sound/core/timer.c
sound/firewire/bebob/bebob_hwdep.c
sound/firewire/dice/dice-hwdep.c
sound/firewire/digi00x/digi00x-hwdep.c
sound/firewire/fireface/ff-hwdep.c
sound/firewire/fireworks/fireworks_hwdep.c
sound/firewire/motu/motu-hwdep.c
sound/firewire/oxfw/oxfw-hwdep.c
sound/firewire/tascam/tascam-hwdep.c
sound/oss/dmasound/dmasound_core.c
sound/usb/mixer_quirks.c
sound/usb/usx2y/us122l.c
sound/usb/usx2y/usX2Yhwdep.c
virt/kvm/eventfd.c

index a2986c60aaac2cf1c2abe47abdfe34329c760af3..cd0e05d89d42f4adcdc8b66fbc73aaee8cfca423 100644 (file)
@@ -173,7 +173,7 @@ static __poll_t gpio_poll(struct file *file, poll_table *wait)
 
        if ((data & priv->highalarm) ||
            (~data & priv->lowalarm)) {
-               mask = POLLIN|POLLRDNORM;
+               mask = EPOLLIN|EPOLLRDNORM;
        }
 
 out:
index 177843c640715cf374fd1edcd5faeff62d8b5056..ed1a568a72170ca405f128f3067806a316f61962 100644 (file)
@@ -666,16 +666,16 @@ static __poll_t sync_serial_poll(struct file *file, poll_table *wait)
        poll_wait(file, &port->in_wait_q, wait);
        /* Some room to write */
        if (port->out_count < OUT_BUFFER_SIZE)
-               mask |=  POLLOUT | POLLWRNORM;
+               mask |=  EPOLLOUT | EPOLLWRNORM;
        /* At least an inbufchunk of data */
        if (sync_data_avail(port) >= port->inbufchunk)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        DEBUGPOLL(if (mask != prev_mask)
                printk(KERN_DEBUG "sync_serial_poll: mask 0x%08X %s %s\n",
                        mask,
-                       mask & POLLOUT ? "POLLOUT" : "",
-                       mask & POLLIN ? "POLLIN" : "");
+                       mask & EPOLLOUT ? "POLLOUT" : "",
+                       mask & EPOLLIN ? "POLLIN" : "");
                prev_mask = mask;
        );
        return mask;
index e20e0b9a3a5ceef61950ee7c9edec372e1bb3791..1b0ce8a8af1676e38f32fd69c6b5ed624397dcab 100644 (file)
@@ -574,24 +574,24 @@ static __poll_t sync_serial_poll(struct file *file, poll_table *wait)
 
        /* No active transfer, descriptors are available */
        if (port->output && !port->tr_running)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        /* Descriptor and buffer space available. */
        if (port->output &&
            port->active_tr_descr != port->catch_tr_descr &&
            port->out_buf_count < OUT_BUFFER_SIZE)
-               mask |=  POLLOUT | POLLWRNORM;
+               mask |=  EPOLLOUT | EPOLLWRNORM;
 
        /* At least an inbufchunk of data */
        if (port->input && sync_data_avail(port) >= port->inbufchunk)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        DEBUGPOLL(
        if (mask != prev_mask)
                pr_info("sync_serial_poll: mask 0x%08X %s %s\n",
                        mask,
-                       mask & POLLOUT ? "POLLOUT" : "",
-                       mask & POLLIN ? "POLLIN" : "");
+                       mask & EPOLLOUT ? "POLLOUT" : "",
+                       mask & EPOLLIN ? "POLLIN" : "");
                prev_mask = mask;
        );
        return mask;
index 8586024940963bb9e1bf2be5d50d31e3fcc75755..8fb280e33114134c2db59e485836f3c2ee0e9d6d 100644 (file)
@@ -1670,7 +1670,7 @@ pfm_poll(struct file *filp, poll_table * wait)
        PROTECT_CTX(ctx, flags);
 
        if (PFM_CTXQ_EMPTY(ctx) == 0)
-               mask =  POLLIN | POLLRDNORM;
+               mask =  EPOLLIN | EPOLLRDNORM;
 
        UNPROTECT_CTX(ctx, flags);
 
index bbb0f4770c0d89fe33335bdf29a22bbaca108cda..18c509c59f3382beef1b47b37ec53419a4df6ce9 100644 (file)
@@ -349,11 +349,11 @@ static __poll_t file_poll(struct file *file, poll_table *wait)
 
        /* data available to read? */
        if (rtlx_read_poll(minor, 0))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* space to write */
        if (rtlx_write_poll(minor))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        return mask;
 }
index fc600a8b1e77bfff7b5215593ce72729ca483d7d..f915db93cd429d4405089c7f4eb5de1ba708d746 100644 (file)
@@ -392,7 +392,7 @@ static __poll_t rtas_log_poll(struct file *file, poll_table * wait)
 {
        poll_wait(file, &rtas_log_wait, wait);
        if (rtas_log_size)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 1a9a756b0b2f725fc4f44dbab26584d756eab755..857580a78bbd8193971b4532da96b05171f71c95 100644 (file)
@@ -101,9 +101,9 @@ static __poll_t spu_backing_mbox_stat_poll(struct spu_context *ctx,
           but first mark any pending interrupts as done so
           we don't get woken up unnecessarily */
 
-       if (events & (POLLIN | POLLRDNORM)) {
+       if (events & (EPOLLIN | EPOLLRDNORM)) {
                if (stat & 0xff0000)
-                       ret |= POLLIN | POLLRDNORM;
+                       ret |= EPOLLIN | EPOLLRDNORM;
                else {
                        ctx->csa.priv1.int_stat_class2_RW &=
                                ~CLASS2_MAILBOX_INTR;
@@ -111,9 +111,9 @@ static __poll_t spu_backing_mbox_stat_poll(struct spu_context *ctx,
                                CLASS2_ENABLE_MAILBOX_INTR;
                }
        }
-       if (events & (POLLOUT | POLLWRNORM)) {
+       if (events & (EPOLLOUT | EPOLLWRNORM)) {
                if (stat & 0x00ff00)
-                       ret = POLLOUT | POLLWRNORM;
+                       ret = EPOLLOUT | EPOLLWRNORM;
                else {
                        ctx->csa.priv1.int_stat_class2_RW &=
                                ~CLASS2_MAILBOX_THRESHOLD_INTR;
index c1be486da8993fc828e09d0ea678790c47994ecf..469bdd0b748f702b929cf11e85927bd9b1250b4b 100644 (file)
@@ -774,7 +774,7 @@ static __poll_t spufs_ibox_poll(struct file *file, poll_table *wait)
         * that poll should not sleep.  Will be fixed later.
         */
        mutex_lock(&ctx->state_mutex);
-       mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM);
+       mask = ctx->ops->mbox_stat_poll(ctx, EPOLLIN | EPOLLRDNORM);
        spu_release(ctx);
 
        return mask;
@@ -910,7 +910,7 @@ static __poll_t spufs_wbox_poll(struct file *file, poll_table *wait)
         * that poll should not sleep.  Will be fixed later.
         */
        mutex_lock(&ctx->state_mutex);
-       mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM);
+       mask = ctx->ops->mbox_stat_poll(ctx, EPOLLOUT | EPOLLWRNORM);
        spu_release(ctx);
 
        return mask;
@@ -1710,9 +1710,9 @@ static __poll_t spufs_mfc_poll(struct file *file,poll_table *wait)
 
        mask = 0;
        if (free_elements & 0xffff)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        if (tagstatus & ctx->tagwait)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__,
                free_elements, tagstatus, ctx->tagwait);
@@ -2469,7 +2469,7 @@ static __poll_t spufs_switch_log_poll(struct file *file, poll_table *wait)
                return rc;
 
        if (spufs_switch_log_used(ctx) > 0)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        spu_release(ctx);
 
index fff58198b5b6e3540aee33fb276e6a6e57673ae3..ae9d24d31eed885a8ff6824cfeabd0c0e69c11d2 100644 (file)
@@ -70,17 +70,17 @@ static __poll_t spu_hw_mbox_stat_poll(struct spu_context *ctx, __poll_t events)
           but first mark any pending interrupts as done so
           we don't get woken up unnecessarily */
 
-       if (events & (POLLIN | POLLRDNORM)) {
+       if (events & (EPOLLIN | EPOLLRDNORM)) {
                if (stat & 0xff0000)
-                       ret |= POLLIN | POLLRDNORM;
+                       ret |= EPOLLIN | EPOLLRDNORM;
                else {
                        spu_int_stat_clear(spu, 2, CLASS2_MAILBOX_INTR);
                        spu_int_mask_or(spu, 2, CLASS2_ENABLE_MAILBOX_INTR);
                }
        }
-       if (events & (POLLOUT | POLLWRNORM)) {
+       if (events & (EPOLLOUT | EPOLLWRNORM)) {
                if (stat & 0x00ff00)
-                       ret = POLLOUT | POLLWRNORM;
+                       ret = EPOLLOUT | EPOLLWRNORM;
                else {
                        spu_int_stat_clear(spu, 2,
                                        CLASS2_MAILBOX_THRESHOLD_INTR);
index c18de0a9b1bdbae39603428339b43112741ba60a..4070bb4e9da4a21517e1a08ec1bd8e77b94e9f58 100644 (file)
@@ -153,7 +153,7 @@ static __poll_t opal_prd_poll(struct file *file,
        poll_wait(file, &opal_prd_msg_wait, wait);
 
        if (!opal_msg_queue_empty())
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index dc0ca8e29c750beebb936dbcd57276d1853a51c7..dfcbe6924eafa923c9b4aead2eaed896b19fd73d 100644 (file)
@@ -1515,7 +1515,7 @@ static __poll_t do_poll(struct file *fp, poll_table *wait)
                return 0;
        poll_wait(fp, &apm_waitqueue, wait);
        if (!queue_empty(as))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 213e8c2ca702f0f4d80aff9024cee91980b62159..97685a0c317513330385cd2943ffc3ebe1e9a829 100644 (file)
@@ -247,9 +247,9 @@ static __poll_t mce_chrdev_poll(struct file *file, poll_table *wait)
 {
        poll_wait(file, &mce_chrdev_wait, wait);
        if (READ_ONCE(mcelog.next))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        if (!mce_apei_read_done && apei_check_mce())
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 2e2c1e222209724630949ade3de4b3efa321b557..06dc96e1f6700ec74c6c36ccd1c94072a14de877 100644 (file)
@@ -849,9 +849,9 @@ static __poll_t bsg_poll(struct file *file, poll_table *wait)
 
        spin_lock_irq(&bd->lock);
        if (!list_empty(&bd->done_list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (bd->queued_cmds < bd->max_queue)
-               mask |= POLLOUT;
+               mask |= EPOLLOUT;
        spin_unlock_irq(&bd->lock);
 
        return mask;
index 0f8d8d5523c317f954fd4de62299961fed4bb141..c49766b03165ce095d218b09f0e22e7765e05388 100644 (file)
@@ -735,9 +735,9 @@ void af_alg_wmem_wakeup(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
-                                                          POLLRDNORM |
-                                                          POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
+                                                          EPOLLRDNORM |
+                                                          EPOLLRDBAND);
        sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
        rcu_read_unlock();
 }
@@ -800,9 +800,9 @@ void af_alg_data_wakeup(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
-                                                          POLLRDNORM |
-                                                          POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
+                                                          EPOLLRDNORM |
+                                                          EPOLLRDBAND);
        sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
        rcu_read_unlock();
 }
@@ -1076,10 +1076,10 @@ __poll_t af_alg_poll(struct file *file, struct socket *sock,
        mask = 0;
 
        if (!ctx->more || ctx->used)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (af_alg_writable(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        return mask;
 }
index 2ff5c8c04e3b9644fb31218d088895319aadc428..f21c99ec46ee0935605f09d28e4e2161be1abdc4 100644 (file)
@@ -724,9 +724,9 @@ static __poll_t acpi_aml_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &acpi_aml_io.wait, wait);
        if (acpi_aml_user_readable())
-               masks |= POLLIN | POLLRDNORM;
+               masks |= EPOLLIN | EPOLLRDNORM;
        if (acpi_aml_user_writable())
-               masks |= POLLOUT | POLLWRNORM;
+               masks |= EPOLLOUT | EPOLLWRNORM;
 
        return masks;
 }
index d21040c5d343f3fafdd4e97d6bc29bc489aa35db..15e3d3c2260ddc915f49732f1076f3a7ee0f540e 100644 (file)
@@ -4371,7 +4371,7 @@ static int binder_thread_release(struct binder_proc *proc,
         */
        if ((thread->looper & BINDER_LOOPER_STATE_POLL) &&
            waitqueue_active(&thread->wait)) {
-               wake_up_poll(&thread->wait, POLLHUP | POLLFREE);
+               wake_up_poll(&thread->wait, EPOLLHUP | POLLFREE);
        }
 
        binder_inner_proc_unlock(thread->proc);
@@ -4401,7 +4401,7 @@ static __poll_t binder_poll(struct file *filp,
        poll_wait(filp, &thread->wait, wait);
 
        if (binder_has_work(thread, wait_for_proc_work))
-               return POLLIN;
+               return EPOLLIN;
 
        return 0;
 }
index 0521748a1972abfbc4e559920852fd0dcd455a9b..22f9145a426fdd962a17ea9816be43c86a922b8d 100644 (file)
@@ -306,9 +306,9 @@ static __poll_t vhci_poll(struct file *file, poll_table *wait)
        poll_wait(file, &data->read_wait, wait);
 
        if (!skb_queue_empty(&data->readq))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
-       return POLLOUT | POLLWRNORM;
+       return EPOLLOUT | EPOLLWRNORM;
 }
 
 static void vhci_open_timeout(struct work_struct *work)
index a2a1c1478cd0833dc41b7f46ccf197e85668844d..a5e2f9e557eaa09e51092b5a7877c6d3f7f8be11 100644 (file)
@@ -241,7 +241,7 @@ static __poll_t apm_poll(struct file *fp, poll_table * wait)
        struct apm_user *as = fp->private_data;
 
        poll_wait(fp, &apm_waitqueue, wait);
-       return queue_empty(&as->queue) ? 0 : POLLIN | POLLRDNORM;
+       return queue_empty(&as->queue) ? 0 : EPOLLIN | EPOLLRDNORM;
 }
 
 /*
index 2f92cc46698b27e2f791fc2e3e6cdaab03175dbb..06749e295adaff06e2770c296a5f2aeaa28a00d4 100644 (file)
@@ -414,7 +414,7 @@ static __poll_t dsp56k_poll(struct file *file, poll_table *wait)
        {
        case DSP56K_DEV_56001:
                /* poll_wait(file, ???, wait); */
-               return POLLIN | POLLRDNORM | POLLOUT;
+               return EPOLLIN | EPOLLRDNORM | EPOLLOUT;
 
        default:
                printk("DSP56k driver: Unknown minor device: %d\n", dev);
index 2697c22e3be25faac48144a071d08f153303b51a..f882460b5a4429425daad341ef7159fd32847254 100644 (file)
@@ -62,7 +62,7 @@
 #include <linux/uaccess.h>     /* for get_user, etc. */
 #include <linux/wait.h>                /* for wait_queue */
 #include <linux/init.h>                /* for __init, module_{init,exit} */
-#include <linux/poll.h>                /* for POLLIN, etc. */
+#include <linux/poll.h>                /* for EPOLLIN, etc. */
 #include <linux/dtlk.h>                /* local header file for DoubleTalk values */
 
 #ifdef TRACING
@@ -244,11 +244,11 @@ static __poll_t dtlk_poll(struct file *file, poll_table * wait)
 
        if (dtlk_has_indexing && dtlk_readable()) {
                del_timer(&dtlk_timer);
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
        }
        if (dtlk_writeable()) {
                del_timer(&dtlk_timer);
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        }
        /* there are no exception conditions */
 
index dbed4953f86cde60b4feb63504d9eef3f3ca03ff..be426eb2a3535ce16479fd805591913118ea1d0d 100644 (file)
@@ -359,7 +359,7 @@ static __poll_t hpet_poll(struct file *file, poll_table * wait)
        spin_unlock_irq(&hpet_lock);
 
        if (v != 0)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 7992c870b0a213accc71d39d88efada496076826..c95b93b7598bacf429bd7b5249719d5e37170d58 100644 (file)
@@ -349,10 +349,10 @@ static __poll_t bt_bmc_poll(struct file *file, poll_table *wait)
        ctrl = bt_inb(bt_bmc, BT_CTRL);
 
        if (ctrl & BT_CTRL_H2B_ATN)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        if (!(ctrl & (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN)))
-               mask |= POLLOUT;
+               mask |= EPOLLOUT;
 
        return mask;
 }
index a011a7739f5e78b6c30db001ff1ce7af8cb843bd..5f1bc91747358db9f11b7b93f6f4fad7cde2183e 100644 (file)
@@ -89,7 +89,7 @@ static __poll_t ipmi_poll(struct file *file, poll_table *wait)
        spin_lock_irqsave(&priv->recv_msg_lock, flags);
 
        if (!list_empty(&(priv->recv_msgs)))
-               mask |= (POLLIN | POLLRDNORM);
+               mask |= (EPOLLIN | EPOLLRDNORM);
 
        spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
 
index 34bc1f3ca41436279e9694c5d9a32d913b0f80f7..a58acdcf7414605c9858219204cb14470c21437f 100644 (file)
@@ -895,7 +895,7 @@ static __poll_t ipmi_poll(struct file *file, poll_table *wait)
 
        spin_lock(&ipmi_read_lock);
        if (data_to_read)
-               mask |= (POLLIN | POLLRDNORM);
+               mask |= (EPOLLIN | EPOLLRDNORM);
        spin_unlock(&ipmi_read_lock);
 
        return mask;
index 819fe37a3683b3bf96423deadf746edaaa9527a0..f80965407d3ccc74d132cb8817aa886661581067 100644 (file)
@@ -423,9 +423,9 @@ static __poll_t cm4040_poll(struct file *filp, poll_table *wait)
        poll_wait(filp, &dev->poll_wait, wait);
 
        if (test_and_clear_bit(BS_READABLE, &dev->buffer_status))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (test_and_clear_bit(BS_WRITABLE, &dev->buffer_status))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        DEBUGP(2, dev, "<- cm4040_poll(%u)\n", mask);
 
index 7a56d1a13ec3af64f10b87101a7a51488a09320c..1ae77b41050abb8404046261718cf6e8a6386da5 100644 (file)
@@ -776,7 +776,7 @@ static __poll_t pp_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &pp->irq_wait, wait);
        if (atomic_read(&pp->irqc))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 80f2c326db47dd95fb27e1c8421c036c42bf7c18..e5b3d3ba46604f7c0bb5612f3da867ea16884d20 100644 (file)
@@ -1793,9 +1793,9 @@ random_poll(struct file *file, poll_table * wait)
        poll_wait(file, &random_write_wait, wait);
        mask = 0;
        if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 }
 
index c6a317120a55077f8fdbaf2eb6ad24af6fc5141e..0c858d027bf3d606790900190415c78bf3db07be 100644 (file)
@@ -804,7 +804,7 @@ static __poll_t rtc_poll(struct file *file, poll_table *wait)
        spin_unlock_irq(&rtc_lock);
 
        if (l != 0)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 #endif
index 7f49fa0f41d77d62a59951305364502102287fe1..5918ea7499bb15b40ac05dc98d71a919fbac1881 100644 (file)
@@ -340,10 +340,10 @@ scdrv_poll(struct file *file, struct poll_table_struct *wait)
 
        if (status > 0) {
                if (status & SAL_IROUTER_INTR_RECV) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                }
                if (status & SAL_IROUTER_INTR_XMIT) {
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
                }
        }
 
index fc041c462aa4e9f00cb2e511378fe72cd2ef2d5c..186689833231d4878825b8427cc3f58959370839 100644 (file)
@@ -944,7 +944,7 @@ static __poll_t sonypi_misc_poll(struct file *file, poll_table *wait)
 {
        poll_wait(file, &sonypi_device.fifo_proc_list, wait);
        if (kfifo_len(&sonypi_device.fifo))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 674218b50b13b0c2b63cfb61bb2a42d3ff0f1f84..e4f79f92045073a6e16a5bc75f77cd61b6c8860c 100644 (file)
@@ -180,15 +180,15 @@ static __poll_t vtpm_proxy_fops_poll(struct file *filp, poll_table *wait)
 
        poll_wait(filp, &proxy_dev->wq, wait);
 
-       ret = POLLOUT;
+       ret = EPOLLOUT;
 
        mutex_lock(&proxy_dev->buf_lock);
 
        if (proxy_dev->req_len)
-               ret |= POLLIN | POLLRDNORM;
+               ret |= EPOLLIN | EPOLLRDNORM;
 
        if (!(proxy_dev->state & STATE_OPENED_FLAG))
-               ret |= POLLHUP;
+               ret |= EPOLLHUP;
 
        mutex_unlock(&proxy_dev->buf_lock);
 
index 813a2e46824d40a2802853531c7fa1d2e22d3654..468f0613401268205762709e2382b5444a06ed91 100644 (file)
@@ -992,15 +992,15 @@ static __poll_t port_fops_poll(struct file *filp, poll_table *wait)
 
        if (!port->guest_connected) {
                /* Port got unplugged */
-               return POLLHUP;
+               return EPOLLHUP;
        }
        ret = 0;
        if (!will_read_block(port))
-               ret |= POLLIN | POLLRDNORM;
+               ret |= EPOLLIN | EPOLLRDNORM;
        if (!will_write_block(port))
-               ret |= POLLOUT;
+               ret |= EPOLLOUT;
        if (!port->host_connected)
-               ret |= POLLHUP;
+               ret |= EPOLLHUP;
 
        return ret;
 }
index 88e1cf475d3f565f8075e356ff74eccc7685f1f8..a11af94e2e6507480ae17d7ec1ebc96458701073 100644 (file)
@@ -1758,15 +1758,15 @@ static __poll_t xillybus_poll(struct file *filp, poll_table *wait)
 
                spin_lock_irqsave(&channel->wr_spinlock, flags);
                if (!channel->wr_empty || channel->wr_ready)
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
 
                if (channel->wr_hangup)
                        /*
-                        * Not POLLHUP, because its behavior is in the
-                        * mist, and POLLIN does what we want: Wake up
+                        * Not EPOLLHUP, because its behavior is in the
+                        * mist, and EPOLLIN does what we want: Wake up
                         * the read file descriptor so it sees EOF.
                         */
-                       mask |=  POLLIN | POLLRDNORM;
+                       mask |=  EPOLLIN | EPOLLRDNORM;
                spin_unlock_irqrestore(&channel->wr_spinlock, flags);
        }
 
@@ -1781,12 +1781,12 @@ static __poll_t xillybus_poll(struct file *filp, poll_table *wait)
 
                spin_lock_irqsave(&channel->rd_spinlock, flags);
                if (!channel->rd_full)
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
                spin_unlock_irqrestore(&channel->rd_spinlock, flags);
        }
 
        if (channel->endpoint->fatal_error)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
 
        return mask;
 }
index 5394507138381d7e5da309a0d6497ed08df4f0a9..d78d5fc173dc3d9b05b523462301a060e5482473 100644 (file)
@@ -135,10 +135,10 @@ static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence)
  * Userspace can query the state of these implicitly tracked fences using poll()
  * and related system calls:
  *
- * - Checking for POLLIN, i.e. read access, can be use to query the state of the
+ * - Checking for EPOLLIN, i.e. read access, can be use to query the state of the
  *   most recent write or exclusive fence.
  *
- * - Checking for POLLOUT, i.e. write access, can be used to query the state of
+ * - Checking for EPOLLOUT, i.e. write access, can be used to query the state of
  *   all attached fences, shared and exclusive ones.
  *
  * Note that this only signals the completion of the respective fences, i.e. the
@@ -168,13 +168,13 @@ static __poll_t dma_buf_poll(struct file *file, poll_table *poll)
 
        dmabuf = file->private_data;
        if (!dmabuf || !dmabuf->resv)
-               return POLLERR;
+               return EPOLLERR;
 
        resv = dmabuf->resv;
 
        poll_wait(file, &dmabuf->poll, poll);
 
-       events = poll_requested_events(poll) & (POLLIN | POLLOUT);
+       events = poll_requested_events(poll) & (EPOLLIN | EPOLLOUT);
        if (!events)
                return 0;
 
@@ -193,12 +193,12 @@ retry:
                goto retry;
        }
 
-       if (fence_excl && (!(events & POLLOUT) || shared_count == 0)) {
+       if (fence_excl && (!(events & EPOLLOUT) || shared_count == 0)) {
                struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_excl;
-               __poll_t pevents = POLLIN;
+               __poll_t pevents = EPOLLIN;
 
                if (shared_count == 0)
-                       pevents |= POLLOUT;
+                       pevents |= EPOLLOUT;
 
                spin_lock_irq(&dmabuf->poll.lock);
                if (dcb->active) {
@@ -228,19 +228,19 @@ retry:
                }
        }
 
-       if ((events & POLLOUT) && shared_count > 0) {
+       if ((events & EPOLLOUT) && shared_count > 0) {
                struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_shared;
                int i;
 
                /* Only queue a new callback if no event has fired yet */
                spin_lock_irq(&dmabuf->poll.lock);
                if (dcb->active)
-                       events &= ~POLLOUT;
+                       events &= ~EPOLLOUT;
                else
-                       dcb->active = POLLOUT;
+                       dcb->active = EPOLLOUT;
                spin_unlock_irq(&dmabuf->poll.lock);
 
-               if (!(events & POLLOUT))
+               if (!(events & EPOLLOUT))
                        goto out;
 
                for (i = 0; i < shared_count; ++i) {
@@ -253,14 +253,14 @@ retry:
                                 *
                                 * call dma_buf_poll_cb and force a recheck!
                                 */
-                               events &= ~POLLOUT;
+                               events &= ~EPOLLOUT;
                                dma_buf_poll_cb(NULL, &dcb->cb);
                                break;
                        }
                        if (!dma_fence_add_callback(fence, &dcb->cb,
                                                    dma_buf_poll_cb)) {
                                dma_fence_put(fence);
-                               events &= ~POLLOUT;
+                               events &= ~EPOLLOUT;
                                break;
                        }
                        dma_fence_put(fence);
index 8e8c4a12a0bc03608d8252392613292d5ea65d19..35dd06479867fad9636db14fc58747ee60dbf198 100644 (file)
@@ -325,7 +325,7 @@ static __poll_t sync_file_poll(struct file *file, poll_table *wait)
                        wake_up_all(&sync_file->wq);
        }
 
-       return dma_fence_is_signaled(sync_file->fence) ? POLLIN : 0;
+       return dma_fence_is_signaled(sync_file->fence) ? EPOLLIN : 0;
 }
 
 static long sync_file_ioctl_merge(struct sync_file *sync_file,
index 523391bb3fbe3c0a3fbee57c2b4d70aa3c295682..f0587273940e4eb211bc43385786b02456fdaa62 100644 (file)
@@ -1792,9 +1792,9 @@ static __poll_t fw_device_op_poll(struct file *file, poll_table * pt)
        poll_wait(file, &client->wait, pt);
 
        if (fw_device_is_shutdown(client->device))
-               mask |= POLLHUP | POLLERR;
+               mask |= EPOLLHUP | EPOLLERR;
        if (!list_empty(&client->event_list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index fee2e9e7ea20a8adb1d82e108a7ee96ff984842a..a128dd1126ae458c323d7ca6a43293bef05dd14f 100644 (file)
@@ -337,10 +337,10 @@ nosy_poll(struct file *file, poll_table *pt)
        poll_wait(file, &client->buffer.wait, pt);
 
        if (atomic_read(&client->buffer.size) > 0)
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
 
        if (list_empty(&client->lynx->link))
-               ret |= POLLHUP;
+               ret |= EPOLLHUP;
 
        return ret;
 }
index 36ca5064486e88acb70390480a83be85e3615bb0..d66de67ef307cef79a03fae9fb586fb3f55be0bf 100644 (file)
@@ -630,7 +630,7 @@ static __poll_t lineevent_poll(struct file *filep,
        poll_wait(filep, &le->wait, wait);
 
        if (!kfifo_is_empty(&le->events))
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
 
        return events;
 }
@@ -775,7 +775,7 @@ static irqreturn_t lineevent_irq_thread(int irq, void *p)
 
        ret = kfifo_put(&le->events, ge);
        if (ret != 0)
-               wake_up_poll(&le->wait, POLLIN);
+               wake_up_poll(&le->wait, EPOLLIN);
 
        return IRQ_HANDLED;
 }
index 9a17bd3639d12bf72a90c0d4b866157b7eee152b..e394799979a6eabce5c91a7a6b87773dd4b45186 100644 (file)
@@ -567,7 +567,7 @@ __poll_t drm_poll(struct file *filp, struct poll_table_struct *wait)
        poll_wait(filp, &file_priv->event_wait, wait);
 
        if (!list_empty(&file_priv->event_list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index e42d9a4de322ebcaad15aaea50cb4ae4b1a8e124..0be50e43507de0e15ef06245335940eed75d3f6b 100644 (file)
  * The two separate pointers let us decouple read()s from tail pointer aging.
  *
  * The tail pointers are checked and updated at a limited rate within a hrtimer
- * callback (the same callback that is used for delivering POLLIN events)
+ * callback (the same callback that is used for delivering EPOLLIN events)
  *
  * Initially the tails are marked invalid with %INVALID_TAIL_PTR which
  * indicates that an updated tail pointer is needed.
@@ -2292,13 +2292,13 @@ static ssize_t i915_perf_read(struct file *file,
                mutex_unlock(&dev_priv->perf.lock);
        }
 
-       /* We allow the poll checking to sometimes report false positive POLLIN
+       /* We allow the poll checking to sometimes report false positive EPOLLIN
         * events where we might actually report EAGAIN on read() if there's
         * not really any data available. In this situation though we don't
-        * want to enter a busy loop between poll() reporting a POLLIN event
+        * want to enter a busy loop between poll() reporting a EPOLLIN event
         * and read() returning -EAGAIN. Clearing the oa.pollin state here
         * effectively ensures we back off until the next hrtimer callback
-        * before reporting another POLLIN event.
+        * before reporting another EPOLLIN event.
         */
        if (ret >= 0 || ret == -EAGAIN) {
                /* Maybe make ->pollin per-stream state if we support multiple
@@ -2358,7 +2358,7 @@ static __poll_t i915_perf_poll_locked(struct drm_i915_private *dev_priv,
         * samples to read.
         */
        if (dev_priv->perf.oa.pollin)
-               events |= POLLIN;
+               events |= EPOLLIN;
 
        return events;
 }
index dfd8d0048980a4989f96d9b50a8d0a62418e455c..1c5e74cb9279bbbea68b220b233c16cc4403f02e 100644 (file)
@@ -1271,7 +1271,7 @@ static __poll_t vga_arb_fpoll(struct file *file, poll_table *wait)
        pr_debug("%s\n", __func__);
 
        poll_wait(file, &vga_wait_queue, wait);
-       return POLLIN;
+       return EPOLLIN;
 }
 
 static int vga_arb_open(struct inode *inode, struct file *file)
index c783fd5ef80961fce106e9f3a1cdc123978bc8a7..4f4e7a08a07be5c0a37c129905e89d4e03aa10e0 100644 (file)
@@ -1185,9 +1185,9 @@ static __poll_t hid_debug_events_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &list->hdev->debug_wait, wait);
        if (list->head != list->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        if (!list->hdev->debug)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        return 0;
 }
 
index b7e86aba6f337de6ee727d4082d7acbeed3e7260..5be8de70c65172c23bf3c6b7e761219f534dc978 100644 (file)
@@ -142,9 +142,9 @@ static __poll_t roccat_poll(struct file *file, poll_table *wait)
        struct roccat_reader *reader = file->private_data;
        poll_wait(file, &reader->device->wait, wait);
        if (reader->cbuf_start != reader->device->cbuf_end)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        if (!reader->device->exist)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        return 0;
 }
 
index 21ed6c55c40a4ae67b69c0519742a2275eeda5cd..e8a114157f87b81593225469dbb7f838cb450480 100644 (file)
@@ -714,7 +714,7 @@ static __poll_t hid_sensor_custom_poll(struct file *file,
        poll_wait(file, &sensor_inst->wait, wait);
 
        if (!kfifo_is_empty(&sensor_inst->data_fifo))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index be210219f98296ba50828b902bb2e6f1c62d1dcd..fbfcc80094329e561c7dfaa0fd3e411144503a49 100644 (file)
@@ -255,9 +255,9 @@ static __poll_t hidraw_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &list->hidraw->wait, wait);
        if (list->head != list->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        if (!list->hidraw->exist)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        return 0;
 }
 
index fc43850a155eeb5633b638c80deb31044d9cb99c..4e0e7baf85136d28573745d40e457e8de94e34cb 100644 (file)
@@ -760,7 +760,7 @@ static __poll_t uhid_char_poll(struct file *file, poll_table *wait)
        poll_wait(file, &uhid->waitq, wait);
 
        if (uhid->head != uhid->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 0ff3e7e70c8df48095906d1e9933e89b45611fd3..e3ce233f8bdcc5bdcae97ffa217f65e022938b0e 100644 (file)
@@ -428,9 +428,9 @@ static __poll_t hiddev_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &list->hiddev->wait, wait);
        if (list->head != list->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        if (!list->hiddev->exist)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        return 0;
 }
 
index 8fbbacb0fe21ec5937ad8a123b1aefb6f5ee44a6..324cb8ec94050165acd13ac12c3fc211f864303f 100644 (file)
@@ -1132,9 +1132,9 @@ static __poll_t cs_char_poll(struct file *file, poll_table *wait)
        poll_wait(file, &cs_char_data.wait, wait);
        spin_lock_bh(&csdata->lock);
        if (!list_empty(&csdata->chardev_queue))
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
        else if (!list_empty(&csdata->dataind_queue))
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
        spin_unlock_bh(&csdata->lock);
 
        return ret;
index 047959e74bb10e1674b11237c2a8acb14bc2156d..8327775279362a8c5ecd95635f3a751a56577414 100644 (file)
@@ -113,10 +113,10 @@ static __poll_t hvt_op_poll(struct file *file, poll_table *wait)
        poll_wait(file, &hvt->outmsg_q, wait);
 
        if (hvt->mode == HVUTIL_TRANSPORT_DESTROY)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        if (hvt->outmsg_len > 0)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index ff03324dee132f49455fd156bacbc9b450146a19..05e0c353e08984d370fe394a5f5139df5b67d486 100644 (file)
@@ -222,7 +222,7 @@ void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
        spin_unlock_irqrestore(&queue->list_lock, flags);
 
        iio_buffer_block_put_atomic(block);
-       wake_up_interruptible_poll(&queue->buffer.pollq, POLLIN | POLLRDNORM);
+       wake_up_interruptible_poll(&queue->buffer.pollq, EPOLLIN | EPOLLRDNORM);
 }
 EXPORT_SYMBOL_GPL(iio_dma_buffer_block_done);
 
@@ -251,7 +251,7 @@ void iio_dma_buffer_block_list_abort(struct iio_dma_buffer_queue *queue,
        }
        spin_unlock_irqrestore(&queue->list_lock, flags);
 
-       wake_up_interruptible_poll(&queue->buffer.pollq, POLLIN | POLLRDNORM);
+       wake_up_interruptible_poll(&queue->buffer.pollq, EPOLLIN | EPOLLRDNORM);
 }
 EXPORT_SYMBOL_GPL(iio_dma_buffer_block_list_abort);
 
index 6184c100a94a5cd0f7e94aa998db50b898522bda..79abf70a126ddde78e0a60fe5adecb829f0423ce 100644 (file)
@@ -166,7 +166,7 @@ ssize_t iio_buffer_read_first_n_outer(struct file *filp, char __user *buf,
  * @wait:      Poll table structure pointer for which the driver adds
  *             a wait queue
  *
- * Return: (POLLIN | POLLRDNORM) if data is available for reading
+ * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading
  *        or 0 for other cases
  */
 __poll_t iio_buffer_poll(struct file *filp,
@@ -180,7 +180,7 @@ __poll_t iio_buffer_poll(struct file *filp,
 
        poll_wait(filp, &rb->pollq, wait);
        if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
@@ -1396,7 +1396,7 @@ static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
         * We can't just test for watermark to decide if we wake the poll queue
         * because read may request less samples than the watermark.
         */
-       wake_up_interruptible_poll(&buffer->pollq, POLLIN | POLLRDNORM);
+       wake_up_interruptible_poll(&buffer->pollq, EPOLLIN | EPOLLRDNORM);
        return 0;
 }
 
index 0bcf073e46dbea69f07e89dd3cf5751abe8e5da1..c6dfdf0aaac5144bc0c5448e4881af5940649ec1 100644 (file)
@@ -80,7 +80,7 @@ int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp)
 
                copied = kfifo_put(&ev_int->det_events, ev);
                if (copied != 0)
-                       wake_up_poll(&ev_int->wait, POLLIN);
+                       wake_up_poll(&ev_int->wait, EPOLLIN);
        }
 
        return 0;
@@ -92,7 +92,7 @@ EXPORT_SYMBOL(iio_push_event);
  * @filep:     File structure pointer to identify the device
  * @wait:      Poll table pointer to add the wait queue on
  *
- * Return: (POLLIN | POLLRDNORM) if data is available for reading
+ * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading
  *        or a negative error code on failure
  */
 static __poll_t iio_event_poll(struct file *filep,
@@ -108,7 +108,7 @@ static __poll_t iio_event_poll(struct file *filep,
        poll_wait(filep, &ev_int->wait, wait);
 
        if (!kfifo_is_empty(&ev_int->det_events))
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
 
        return events;
 }
index 8ae636bb09e577a7089cce07c4c784df69190e00..01702265c1e1a5175f05499c66f1ebe046a06e21 100644 (file)
@@ -1144,7 +1144,7 @@ static __poll_t ib_ucm_poll(struct file *filp,
        poll_wait(filp, &file->poll_wait, wait);
 
        if (!list_empty(&file->events))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 6ba4231f2b0739311bcd6553c1c8141a5758b9e8..f015f1bf88c9c8c52c2a739bb130c2949348f0e4 100644 (file)
@@ -1639,7 +1639,7 @@ static __poll_t ucma_poll(struct file *filp, struct poll_table_struct *wait)
        poll_wait(filp, &file->poll_wait, wait);
 
        if (!list_empty(&file->event_list))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 78c77962422e0b648f37855611bc173fcb9c1069..bb98c9e4a7fd25fe94370f2eda5486e4d64bdb66 100644 (file)
@@ -633,12 +633,12 @@ static __poll_t ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
        struct ib_umad_file *file = filp->private_data;
 
        /* we will always be able to post a MAD send */
-       __poll_t mask = POLLOUT | POLLWRNORM;
+       __poll_t mask = EPOLLOUT | EPOLLWRNORM;
 
        poll_wait(filp, &file->recv_wait, wait);
 
        if (!list_empty(&file->recv_list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 5b811bf574d6948440c6951ca4903c6cc66277d9..395a3b091229fbec064e17698e8dcc5967b9f9e5 100644 (file)
@@ -351,7 +351,7 @@ static __poll_t ib_uverbs_event_poll(struct ib_uverbs_event_queue *ev_queue,
 
        spin_lock_irq(&ev_queue->lock);
        if (!list_empty(&ev_queue->event_list))
-               pollflags = POLLIN | POLLRDNORM;
+               pollflags = EPOLLIN | EPOLLRDNORM;
        spin_unlock_irq(&ev_queue->lock);
 
        return pollflags;
index d9a0f2590294b8fedf487aff586c08047b113135..41fafebe3b0d97875ff8266cc227071acde9d87e 100644 (file)
@@ -612,13 +612,13 @@ static __poll_t hfi1_poll(struct file *fp, struct poll_table_struct *pt)
 
        uctxt = ((struct hfi1_filedata *)fp->private_data)->uctxt;
        if (!uctxt)
-               pollflag = POLLERR;
+               pollflag = EPOLLERR;
        else if (uctxt->poll_type == HFI1_POLL_TYPE_URGENT)
                pollflag = poll_urgent(fp, pt);
        else  if (uctxt->poll_type == HFI1_POLL_TYPE_ANYRCV)
                pollflag = poll_next(fp, pt);
        else /* invalid */
-               pollflag = POLLERR;
+               pollflag = EPOLLERR;
 
        return pollflag;
 }
@@ -1435,7 +1435,7 @@ static __poll_t poll_urgent(struct file *fp,
 
        spin_lock_irq(&dd->uctxt_lock);
        if (uctxt->urgent != uctxt->urgent_poll) {
-               pollflag = POLLIN | POLLRDNORM;
+               pollflag = EPOLLIN | EPOLLRDNORM;
                uctxt->urgent_poll = uctxt->urgent;
        } else {
                pollflag = 0;
@@ -1462,7 +1462,7 @@ static __poll_t poll_next(struct file *fp,
                hfi1_rcvctrl(dd, HFI1_RCVCTRL_INTRAVAIL_ENB, uctxt);
                pollflag = 0;
        } else {
-               pollflag = POLLIN | POLLRDNORM;
+               pollflag = EPOLLIN | EPOLLRDNORM;
        }
        spin_unlock_irq(&dd->uctxt_lock);
 
index f7593b5e2b7617f4e82c6149164ed6ba54db648f..52c29db3a2f4a08dbfe9b6504c8ecc7768d3c34a 100644 (file)
@@ -1085,7 +1085,7 @@ static __poll_t qib_poll_urgent(struct qib_ctxtdata *rcd,
 
        spin_lock_irq(&dd->uctxt_lock);
        if (rcd->urgent != rcd->urgent_poll) {
-               pollflag = POLLIN | POLLRDNORM;
+               pollflag = EPOLLIN | EPOLLRDNORM;
                rcd->urgent_poll = rcd->urgent;
        } else {
                pollflag = 0;
@@ -1111,7 +1111,7 @@ static __poll_t qib_poll_next(struct qib_ctxtdata *rcd,
                dd->f_rcvctrl(rcd->ppd, QIB_RCVCTRL_INTRAVAIL_ENB, rcd->ctxt);
                pollflag = 0;
        } else
-               pollflag = POLLIN | POLLRDNORM;
+               pollflag = EPOLLIN | EPOLLRDNORM;
        spin_unlock_irq(&dd->uctxt_lock);
 
        return pollflag;
@@ -1124,13 +1124,13 @@ static __poll_t qib_poll(struct file *fp, struct poll_table_struct *pt)
 
        rcd = ctxt_fp(fp);
        if (!rcd)
-               pollflag = POLLERR;
+               pollflag = EPOLLERR;
        else if (rcd->poll_type == QIB_POLL_TYPE_URGENT)
                pollflag = qib_poll_urgent(rcd, fp, pt);
        else  if (rcd->poll_type == QIB_POLL_TYPE_ANYRCV)
                pollflag = qib_poll_next(rcd, fp, pt);
        else /* invalid */
-               pollflag = POLLERR;
+               pollflag = EPOLLERR;
 
        return pollflag;
 }
index 19624e023ebd9d079e15cd4297f264d0ab7832ee..0336643c2ed65c24e822c04a4635c68afdc57ef0 100644 (file)
@@ -874,7 +874,7 @@ iscsi_iser_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
        iser_info("iser conn %p rc = %d\n", iser_conn, rc);
 
        if (rc > 0)
-               return 1; /* success, this is the equivalent of POLLOUT */
+               return 1; /* success, this is the equivalent of EPOLLOUT */
        else if (!rc)
                return 0; /* timeout */
        else
index 94049fdc583cce8900bdaab9f69ac7f20ff7dd0e..c81c79d01d93078fb2a4357e6f0c51aea6a2b12b 100644 (file)
@@ -650,12 +650,12 @@ static __poll_t evdev_poll(struct file *file, poll_table *wait)
        poll_wait(file, &evdev->wait, wait);
 
        if (evdev->exist && !client->revoked)
-               mask = POLLOUT | POLLWRNORM;
+               mask = EPOLLOUT | EPOLLWRNORM;
        else
-               mask = POLLHUP | POLLERR;
+               mask = EPOLLHUP | EPOLLERR;
 
        if (client->packet_head != client->tail)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 0d0b2ab1bb6bc30888325e5550597ad9f2d285c0..9785546420a7237aecffb817631d4826f052c03e 100644 (file)
@@ -1053,7 +1053,7 @@ static __poll_t input_proc_devices_poll(struct file *file, poll_table *wait)
        poll_wait(file, &input_devices_poll_wait, wait);
        if (file->f_version != input_devices_state) {
                file->f_version = input_devices_state;
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        }
 
        return 0;
index fe3255572886c6b5f604cba58b96361a5b8cef55..4c1e427dfabb984b04af577c749299336cd510d2 100644 (file)
@@ -442,8 +442,8 @@ static __poll_t joydev_poll(struct file *file, poll_table *wait)
        struct joydev *joydev = client->joydev;
 
        poll_wait(file, &joydev->wait, wait);
-       return (joydev_data_pending(client) ? (POLLIN | POLLRDNORM) : 0) |
-               (joydev->exist ?  0 : (POLLHUP | POLLERR));
+       return (joydev_data_pending(client) ? (EPOLLIN | EPOLLRDNORM) : 0) |
+               (joydev->exist ?  0 : (EPOLLHUP | EPOLLERR));
 }
 
 static int joydev_handle_JSIOCSAXMAP(struct joydev *joydev,
index 9c3f7ec3bd3d65efb1141675689a9a079be95127..49b34de0aed4d64fdbbff8bb4c97751b8f07ae7c 100644 (file)
@@ -414,7 +414,7 @@ static __poll_t hp_sdc_rtc_poll(struct file *file, poll_table *wait)
 
        l = 0;
         if (l != 0)
-                return POLLIN | POLLRDNORM;
+                return EPOLLIN | EPOLLRDNORM;
         return 0;
 }
 
index f640c591ef23fde4a6b753976917983e5f057e75..96a887f336982f7efc0d971e145ded52829b2dc8 100644 (file)
@@ -704,7 +704,7 @@ static __poll_t uinput_poll(struct file *file, poll_table *wait)
        poll_wait(file, &udev->waitq, wait);
 
        if (udev->head != udev->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 731d84ae510176cc6b0c4073ddb86356b0c88866..e08228061bcdd2f97aaadece31d6c83eb7539ae5 100644 (file)
@@ -765,9 +765,9 @@ static __poll_t mousedev_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &mousedev->wait, wait);
 
-       mask = mousedev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
+       mask = mousedev->exist ? EPOLLOUT | EPOLLWRNORM : EPOLLHUP | EPOLLERR;
        if (client->ready || client->buffer)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index fccf55a380b2f59313e6941a81acd54a7c6f8586..17b7fbecd9fe7134c86823c2d9c88c5a24dc6ddb 100644 (file)
@@ -247,9 +247,9 @@ static __poll_t serio_raw_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &serio_raw->wait, wait);
 
-       mask = serio_raw->dead ? POLLHUP | POLLERR : POLLOUT | POLLWRNORM;
+       mask = serio_raw->dead ? EPOLLHUP | EPOLLERR : EPOLLOUT | EPOLLWRNORM;
        if (serio_raw->head != serio_raw->tail)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index a63de06b08bcce6df880f1a10cda9a4c2b745dab..9ab5c45c3a9fe1d0008170a205ee55a4cadec438 100644 (file)
@@ -255,7 +255,7 @@ static __poll_t userio_char_poll(struct file *file, poll_table *wait)
        poll_wait(file, &userio->waitq, wait);
 
        if (userio->head != userio->tail)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index e268811dc544bb3c7644e4f81659317dc223d544..19cd93783c87d1269f2de40147784f8abbf88f85 100644 (file)
@@ -731,12 +731,12 @@ capi_poll(struct file *file, poll_table *wait)
        __poll_t mask = 0;
 
        if (!cdev->ap.applid)
-               return POLLERR;
+               return EPOLLERR;
 
        poll_wait(file, &(cdev->recvwait), wait);
-       mask = POLLOUT | POLLWRNORM;
+       mask = EPOLLOUT | EPOLLWRNORM;
        if (!skb_queue_empty(&cdev->recvqueue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        return mask;
 }
 
index 34b7704042a4a5341bc577a455ece0678eb630a7..342585e04fd3f1786f70c28c3dcd0244aaa9d81f 100644 (file)
@@ -125,9 +125,9 @@ isdn_divert_poll(struct file *file, poll_table *wait)
        __poll_t mask = 0;
 
        poll_wait(file, &(rd_queue), wait);
-       /* mask = POLLOUT | POLLWRNORM; */
+       /* mask = EPOLLOUT | EPOLLWRNORM; */
        if (*((struct divert_info **) file->private_data)) {
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
        return mask;
 }                              /* isdn_divert_poll */
index 70f16102a00109b8f60ccfda971752c3d6d1988d..5a95587b311722431f38355a3aa2d295e4910bc6 100644 (file)
@@ -103,9 +103,9 @@ static __poll_t maint_poll(struct file *file, poll_table *wait)
        __poll_t mask = 0;
 
        poll_wait(file, &msgwaitq, wait);
-       mask = POLLOUT | POLLWRNORM;
+       mask = EPOLLOUT | EPOLLWRNORM;
        if (file->private_data || diva_dbg_q_length()) {
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
        return (mask);
 }
index da5cc5ab7e2dea5cbd375ec90e4b764d5aa86338..525518c945fe6b4646771fa8dba3ed2ac45b0fa7 100644 (file)
@@ -370,31 +370,31 @@ static __poll_t um_idi_poll(struct file *file, poll_table *wait)
        diva_um_idi_os_context_t *p_os;
 
        if (!file->private_data) {
-               return (POLLERR);
+               return (EPOLLERR);
        }
 
        if ((!(p_os =
               (diva_um_idi_os_context_t *)
               diva_um_id_get_os_context(file->private_data)))
            || p_os->aborted) {
-               return (POLLERR);
+               return (EPOLLERR);
        }
 
        poll_wait(file, &p_os->read_wait, wait);
 
        if (p_os->aborted) {
-               return (POLLERR);
+               return (EPOLLERR);
        }
 
        switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
        case (-1):
-               return (POLLERR);
+               return (EPOLLERR);
 
        case 0:
                return (0);
        }
 
-       return (POLLIN | POLLRDNORM);
+       return (EPOLLIN | EPOLLRDNORM);
 }
 
 static int um_idi_open(struct inode *inode, struct file *file)
index fbc788e6f0db9b751913f88ce87945a172264802..b9980e84f9db56570ef9c2dbc8b007e8818978d3 100644 (file)
@@ -653,9 +653,9 @@ static ssize_t divas_read(struct file *file, char __user *buf,
 static __poll_t divas_poll(struct file *file, poll_table *wait)
 {
        if (!file->private_data) {
-               return (POLLERR);
+               return (EPOLLERR);
        }
-       return (POLLIN | POLLRDNORM);
+       return (EPOLLIN | EPOLLRDNORM);
 }
 
 static const struct file_operations divas_fops = {
index 3478f6f099eba8b67d96b44231491567a80fdab4..f52f4622b10b0e015bb3676e5811d12da171b782 100644 (file)
@@ -101,7 +101,7 @@ divas_write(struct file *file, const char __user *buf, size_t count, loff_t *off
 
 static __poll_t divas_poll(struct file *file, poll_table *wait)
 {
-       return (POLLERR);
+       return (EPOLLERR);
 }
 
 static int divas_open(struct inode *inode, struct file *file)
index 6abea6915f494c6184c599ee849a98d1135138c4..6e898b90e86e69aac5d17419de4f34d87a88718d 100644 (file)
@@ -294,7 +294,7 @@ hysdn_log_poll(struct file *file, poll_table *wait)
        poll_wait(file, &(pd->rd_queue), wait);
 
        if (*((struct log_data **) file->private_data))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }                              /* hysdn_log_poll */
index 0521c32949d47eb84ccddad5efddb00a9ee82172..7c6f3f5d9d9a2dc11f7bf2c950b6244b984ef429 100644 (file)
@@ -1237,22 +1237,22 @@ isdn_poll(struct file *file, poll_table *wait)
        mutex_lock(&isdn_mutex);
        if (minor == ISDN_MINOR_STATUS) {
                poll_wait(file, &(dev->info_waitq), wait);
-               /* mask = POLLOUT | POLLWRNORM; */
+               /* mask = EPOLLOUT | EPOLLWRNORM; */
                if (file->private_data) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                }
                goto out;
        }
        if (minor >= ISDN_MINOR_CTRL && minor <= ISDN_MINOR_CTRLMAX) {
                if (drvidx < 0) {
                        /* driver deregistered while file open */
-                       mask = POLLHUP;
+                       mask = EPOLLHUP;
                        goto out;
                }
                poll_wait(file, &(dev->drv[drvidx]->st_waitq), wait);
-               mask = POLLOUT | POLLWRNORM;
+               mask = EPOLLOUT | EPOLLWRNORM;
                if (dev->drv[drvidx]->stavail) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                }
                goto out;
        }
@@ -1262,7 +1262,7 @@ isdn_poll(struct file *file, poll_table *wait)
                goto out;
        }
 #endif
-       mask = POLLERR;
+       mask = EPOLLERR;
 out:
        mutex_unlock(&isdn_mutex);
        return mask;
index 57884319b4b13cb7282dd1f9bf4d1fa55c92f701..a7b275ea5de1da57471dc47d9cb66510adbd5d12 100644 (file)
@@ -704,12 +704,12 @@ isdn_ppp_poll(struct file *file, poll_table *wait)
 
        if (!(is->state & IPPP_OPEN)) {
                if (is->state == IPPP_CLOSEWAIT)
-                       return POLLHUP;
+                       return EPOLLHUP;
                printk(KERN_DEBUG "isdn_ppp: device not open\n");
-               return POLLERR;
+               return EPOLLERR;
        }
        /* we're always ready to send .. */
-       mask = POLLOUT | POLLWRNORM;
+       mask = EPOLLOUT | EPOLLWRNORM;
 
        spin_lock_irqsave(&is->buflock, flags);
        bl = is->last;
@@ -719,7 +719,7 @@ isdn_ppp_poll(struct file *file, poll_table *wait)
         */
        if (bf->next != bl || (is->state & IPPP_NOBLOCK)) {
                is->state &= ~IPPP_NOBLOCK;
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
        spin_unlock_irqrestore(&is->buflock, flags);
        return mask;
index f4272d4e0a26c41431438423ae493fc8593b3f14..211ed6cffd10e1be817884a7724f3f37687afb93 100644 (file)
@@ -145,7 +145,7 @@ static __poll_t
 mISDN_poll(struct file *filep, poll_table *wait)
 {
        struct mISDNtimerdev    *dev = filep->private_data;
-       __poll_t                mask = POLLERR;
+       __poll_t                mask = EPOLLERR;
 
        if (*debug & DEBUG_TIMER)
                printk(KERN_DEBUG "%s(%p, %p)\n", __func__, filep, wait);
@@ -153,7 +153,7 @@ mISDN_poll(struct file *filep, poll_table *wait)
                poll_wait(filep, &dev->wait, wait);
                mask = 0;
                if (dev->work || !list_empty(&dev->expired))
-                       mask |= (POLLIN | POLLRDNORM);
+                       mask |= (EPOLLIN | EPOLLRDNORM);
                if (*debug & DEBUG_TIMER)
                        printk(KERN_DEBUG "%s work(%d) empty(%d)\n", __func__,
                               dev->work, list_empty(&dev->expired));
index 5beacab05ed74aa57a8302fb375191342f999824..0c43bfac9598e32788f39118ab8902c57d05a775 100644 (file)
@@ -183,7 +183,7 @@ static __poll_t uleds_poll(struct file *file, poll_table *wait)
        poll_wait(file, &udev->waitq, wait);
 
        if (udev->new_data)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 346e6f5f77be7e0510daf61ae1db48ada6e56677..e8ae2e54151cc2d913f1d5159610e9813d2a8799 100644 (file)
@@ -1259,7 +1259,7 @@ static __poll_t smu_fpoll(struct file *file, poll_table *wait)
 
                spin_lock_irqsave(&pp->lock, flags);
                if (pp->busy && pp->cmd.status != 1)
-                       mask |= POLLIN;
+                       mask |= EPOLLIN;
                spin_unlock_irqrestore(&pp->lock, flags);
        }
        if (pp->mode == smu_file_events) {
index 08849e33c567949e606c44a2874d4f37f8aebef3..94c0f3f7df699c1c58b83b2573e7e2d2c4cfa7ed 100644 (file)
@@ -2169,7 +2169,7 @@ pmu_fpoll(struct file *filp, poll_table *wait)
        poll_wait(filp, &pp->wait, wait);
        spin_lock_irqsave(&pp->lock, flags);
        if (pp->rb_get != pp->rb_put)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
        spin_unlock_irqrestore(&pp->lock, flags);
        return mask;
 }
index f84730d63b1f207f341a6abe4ad25a78848215a1..58bfafc34bc46978121d81c63662677392499f20 100644 (file)
@@ -243,7 +243,7 @@ mbox_test_message_poll(struct file *filp, struct poll_table_struct *wait)
        poll_wait(filp, &tdev->waitq, wait);
 
        if (mbox_test_message_data_ready(tdev))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 3f6791afd3e4501148057aea0c333aae2f7c0969..a89fd8f44453e7ce3a0a658c31ecc0b3fd8e3f76 100644 (file)
@@ -1937,7 +1937,7 @@ static __poll_t dm_poll(struct file *filp, poll_table *wait)
        poll_wait(filp, &dm_global_eventq, wait);
 
        if ((int)(atomic_read(&dm_global_event_nr) - priv->global_event_nr) > 0)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        return mask;
 }
index 0081ace39a6494e8a168c310788348505aa6ca3b..bc67ab6844f02d540cf4ae3725ebdad13ee568b8 100644 (file)
@@ -7891,14 +7891,14 @@ static __poll_t mdstat_poll(struct file *filp, poll_table *wait)
        __poll_t mask;
 
        if (md_unloading)
-               return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
+               return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
        poll_wait(filp, &md_event_waiters, wait);
 
        /* always allow read */
-       mask = POLLIN | POLLRDNORM;
+       mask = EPOLLIN | EPOLLRDNORM;
 
        if (seq->poll_event != atomic_read(&md_event_count))
-               mask |= POLLERR | POLLPRI;
+               mask |= EPOLLERR | EPOLLPRI;
        return mask;
 }
 
index ecc89d9a279b288419c9a1a227b2e3c5607cbb64..492db12b8c4dc8a0040ffdc922f5786f66dd6c47 100644 (file)
@@ -51,15 +51,15 @@ static __poll_t cec_poll(struct file *filp,
        __poll_t res = 0;
 
        if (!cec_is_registered(adap))
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        mutex_lock(&adap->lock);
        if (adap->is_configured &&
            adap->transmit_queue_sz < CEC_MAX_MSG_TX_QUEUE_SZ)
-               res |= POLLOUT | POLLWRNORM;
+               res |= EPOLLOUT | EPOLLWRNORM;
        if (fh->queued_msgs)
-               res |= POLLIN | POLLRDNORM;
+               res |= EPOLLIN | EPOLLRDNORM;
        if (fh->total_queued_events)
-               res |= POLLPRI;
+               res |= EPOLLPRI;
        poll_wait(filp, &fh->wait, poll);
        mutex_unlock(&adap->lock);
        return res;
index 8ee3eebef4dbd582e4cc80bb6f776e4822831275..d4987fd05d05f5b089e18b482fddf3deca2ac2ad 100644 (file)
@@ -332,7 +332,7 @@ static __poll_t __fops_poll(struct file *file, struct poll_table_struct *wait)
 
        if (vdev->vfl_type == VFL_TYPE_VBI) {
                if (fh->dev->ext_vv_data->capabilities & V4L2_CAP_SLICED_VBI_OUTPUT)
-                       return res | POLLOUT | POLLWRNORM;
+                       return res | EPOLLOUT | EPOLLWRNORM;
                if( 0 == fh->vbi_q.streaming )
                        return res | videobuf_poll_stream(file, &fh->vbi_q, wait);
                q = &fh->vbi_q;
@@ -346,13 +346,13 @@ static __poll_t __fops_poll(struct file *file, struct poll_table_struct *wait)
 
        if (!buf) {
                DEB_D("buf == NULL!\n");
-               return res | POLLERR;
+               return res | EPOLLERR;
        }
 
        poll_wait(file, &buf->done, wait);
        if (buf->state == VIDEOBUF_DONE || buf->state == VIDEOBUF_ERROR) {
                DEB_D("poll succeeded!\n");
-               return res | POLLIN | POLLRDNORM;
+               return res | EPOLLIN | EPOLLRDNORM;
        }
 
        DEB_D("nothing to poll for, buf->state:%d\n", buf->state);
index 403645fe9079592f25b816e99b3f0ccea28b84bb..40891f4f842b90dd7193c56097177256f7fc0c13 100644 (file)
@@ -371,7 +371,7 @@ static __poll_t smsdvb_stats_poll(struct file *file, poll_table *wait)
        rc = smsdvb_stats_wait_read(debug_data);
        kref_put(&debug_data->refcount, smsdvb_debugfs_data_release);
 
-       return rc > 0 ? POLLIN | POLLRDNORM : 0;
+       return rc > 0 ? EPOLLIN | EPOLLRDNORM : 0;
 }
 
 static ssize_t smsdvb_stats_read(struct file *file, char __user *user_buf,
index 9a84c70927145af83193ffa85e8f9697cc232d47..debe35fc66b4102559f4ea1ba5deb079be526b61 100644 (file)
@@ -2038,9 +2038,9 @@ __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file,
        struct vb2_buffer *vb = NULL;
        unsigned long flags;
 
-       if (!q->is_output && !(req_events & (POLLIN | POLLRDNORM)))
+       if (!q->is_output && !(req_events & (EPOLLIN | EPOLLRDNORM)))
                return 0;
-       if (q->is_output && !(req_events & (POLLOUT | POLLWRNORM)))
+       if (q->is_output && !(req_events & (EPOLLOUT | EPOLLWRNORM)))
                return 0;
 
        /*
@@ -2048,18 +2048,18 @@ __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file,
         */
        if (q->num_buffers == 0 && !vb2_fileio_is_active(q)) {
                if (!q->is_output && (q->io_modes & VB2_READ) &&
-                               (req_events & (POLLIN | POLLRDNORM))) {
+                               (req_events & (EPOLLIN | EPOLLRDNORM))) {
                        if (__vb2_init_fileio(q, 1))
-                               return POLLERR;
+                               return EPOLLERR;
                }
                if (q->is_output && (q->io_modes & VB2_WRITE) &&
-                               (req_events & (POLLOUT | POLLWRNORM))) {
+                               (req_events & (EPOLLOUT | EPOLLWRNORM))) {
                        if (__vb2_init_fileio(q, 0))
-                               return POLLERR;
+                               return EPOLLERR;
                        /*
                         * Write to OUTPUT queue can be done immediately.
                         */
-                       return POLLOUT | POLLWRNORM;
+                       return EPOLLOUT | EPOLLWRNORM;
                }
        }
 
@@ -2068,24 +2068,24 @@ __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file,
         * error flag is set.
         */
        if (!vb2_is_streaming(q) || q->error)
-               return POLLERR;
+               return EPOLLERR;
 
        /*
         * If this quirk is set and QBUF hasn't been called yet then
-        * return POLLERR as well. This only affects capture queues, output
+        * return EPOLLERR as well. This only affects capture queues, output
         * queues will always initialize waiting_for_buffers to false.
         * This quirk is set by V4L2 for backwards compatibility reasons.
         */
        if (q->quirk_poll_must_check_waiting_for_buffers &&
-           q->waiting_for_buffers && (req_events & (POLLIN | POLLRDNORM)))
-               return POLLERR;
+           q->waiting_for_buffers && (req_events & (EPOLLIN | EPOLLRDNORM)))
+               return EPOLLERR;
 
        /*
         * For output streams you can call write() as long as there are fewer
         * buffers queued than there are buffers available.
         */
        if (q->is_output && q->fileio && q->queued_count < q->num_buffers)
-               return POLLOUT | POLLWRNORM;
+               return EPOLLOUT | EPOLLWRNORM;
 
        if (list_empty(&q->done_list)) {
                /*
@@ -2093,7 +2093,7 @@ __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file,
                 * return immediately. DQBUF will return -EPIPE.
                 */
                if (q->last_buffer_dequeued)
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
 
                poll_wait(file, &q->done_wq, wait);
        }
@@ -2110,8 +2110,8 @@ __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file,
        if (vb && (vb->state == VB2_BUF_STATE_DONE
                        || vb->state == VB2_BUF_STATE_ERROR)) {
                return (q->is_output) ?
-                               POLLOUT | POLLWRNORM :
-                               POLLIN | POLLRDNORM;
+                               EPOLLOUT | EPOLLWRNORM :
+                               EPOLLIN | EPOLLRDNORM;
        }
        return 0;
 }
index d9a487aab99c9cf468b08b21ef3a0e798c5896bd..886a2d8d5c6c424790ecc13874e9ba4949c1161a 100644 (file)
@@ -658,7 +658,7 @@ int vb2_queue_init(struct vb2_queue *q)
                        == V4L2_BUF_FLAG_TIMESTAMP_COPY;
        /*
         * For compatibility with vb1: if QBUF hasn't been called yet, then
-        * return POLLERR as well. This only affects capture queues, output
+        * return EPOLLERR as well. This only affects capture queues, output
         * queues will always initialize waiting_for_buffers to false.
         */
        q->quirk_poll_must_check_waiting_for_buffers = true;
@@ -683,8 +683,8 @@ __poll_t vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)
                struct v4l2_fh *fh = file->private_data;
 
                if (v4l2_event_pending(fh))
-                       res = POLLPRI;
-               else if (req_events & POLLPRI)
+                       res = EPOLLPRI;
+               else if (req_events & EPOLLPRI)
                        poll_wait(file, &fh->wait, wait);
        }
 
@@ -921,7 +921,7 @@ __poll_t vb2_fop_poll(struct file *file, poll_table *wait)
        WARN_ON(!lock);
 
        if (lock && mutex_lock_interruptible(lock))
-               return POLLERR;
+               return EPOLLERR;
 
        fileio = q->fileio;
 
index bc198f84b9cd0d06e0af783331259b43802613c7..6d53af00190e396fda03bab661b56d4e4a1fc4a2 100644 (file)
@@ -1179,7 +1179,7 @@ static __poll_t dvb_demux_poll(struct file *file, poll_table *wait)
        __poll_t mask = 0;
 
        if ((!dmxdevfilter) || dmxdevfilter->dev->exit)
-               return POLLERR;
+               return EPOLLERR;
        if (dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx))
                return dvb_vb2_poll(&dmxdevfilter->vb2_ctx, file, wait);
 
@@ -1191,10 +1191,10 @@ static __poll_t dvb_demux_poll(struct file *file, poll_table *wait)
                return 0;
 
        if (dmxdevfilter->buffer.error)
-               mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
+               mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI | EPOLLERR);
 
        if (!dvb_ringbuffer_empty(&dmxdevfilter->buffer))
-               mask |= (POLLIN | POLLRDNORM | POLLPRI);
+               mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI);
 
        return mask;
 }
@@ -1331,7 +1331,7 @@ static __poll_t dvb_dvr_poll(struct file *file, poll_table *wait)
        dprintk("%s\n", __func__);
 
        if (dmxdev->exit)
-               return POLLERR;
+               return EPOLLERR;
        if (dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
                return dvb_vb2_poll(&dmxdev->dvr_vb2_ctx, file, wait);
 
@@ -1343,12 +1343,12 @@ static __poll_t dvb_dvr_poll(struct file *file, poll_table *wait)
 #endif
        if (need_ringbuffer) {
                if (dmxdev->dvr_buffer.error)
-                       mask |= (POLLIN | POLLRDNORM | POLLPRI | POLLERR);
+                       mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI | EPOLLERR);
 
                if (!dvb_ringbuffer_empty(&dmxdev->dvr_buffer))
-                       mask |= (POLLIN | POLLRDNORM | POLLPRI);
+                       mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI);
        } else
-               mask |= (POLLOUT | POLLWRNORM | POLLPRI);
+               mask |= (EPOLLOUT | EPOLLWRNORM | EPOLLPRI);
 
        return mask;
 }
index b462ebc0c544d47d56e341004f1f0e6870bf9204..204d0f6c678daaabd1f46b50aaba819f03a7f259 100644 (file)
@@ -1796,7 +1796,7 @@ static __poll_t dvb_ca_en50221_io_poll(struct file *file, poll_table *wait)
        dprintk("%s\n", __func__);
 
        if (dvb_ca_en50221_io_read_condition(ca, &result, &slot) == 1)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        /* if there is something, return now */
        if (mask)
@@ -1806,7 +1806,7 @@ static __poll_t dvb_ca_en50221_io_poll(struct file *file, poll_table *wait)
        poll_wait(file, &ca->wait_queue, wait);
 
        if (dvb_ca_en50221_io_read_condition(ca, &result, &slot) == 1)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        return mask;
 }
index 87fc1bcae5ae6c5d610d02321de48e5895724932..a7ed16e0841d5001174cc19c78a98b510290fac5 100644 (file)
@@ -2646,7 +2646,7 @@ static __poll_t dvb_frontend_poll(struct file *file, struct poll_table_struct *w
        poll_wait (file, &fepriv->events.wait_queue, wait);
 
        if (fepriv->events.eventw != fepriv->events.eventr)
-               return (POLLIN | POLLRDNORM | POLLPRI);
+               return (EPOLLIN | EPOLLRDNORM | EPOLLPRI);
 
        return 0;
 }
index b4ddfff742671140a3c393b23c893c85be9973c9..8dc5a7495abeec407d8a1e3772fdcf06f819c1c1 100644 (file)
@@ -209,7 +209,7 @@ static int fdtv_ca_ioctl(struct file *file, unsigned int cmd, void *arg)
 
 static __poll_t fdtv_ca_io_poll(struct file *file, poll_table *wait)
 {
-       return POLLIN;
+       return EPOLLIN;
 }
 
 static const struct file_operations fdtv_ca_fops = {
index 00640233a5e3207bec9c14eb27439e084b6837a3..c3089bd34df252daabc5ef49384f37ff1a2f2e40 100644 (file)
@@ -413,7 +413,7 @@ static long saa6588_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
        case SAA6588_CMD_POLL:
                a->result = 0;
                if (s->data_available_for_read)
-                       a->result |= POLLIN | POLLRDNORM;
+                       a->result |= EPOLLIN | EPOLLRDNORM;
                poll_wait(a->instance, &s->read_queue, a->event_list);
                break;
 
index 3049b1f505e589e65e5a38558bf1ee5ac73afffe..67ac51eff15c354e82ac5fad60d88166b6a788a8 100644 (file)
@@ -105,7 +105,7 @@ static __poll_t media_poll(struct file *filp,
        struct media_devnode *devnode = media_devnode_data(filp);
 
        if (!media_devnode_is_registered(devnode))
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
        if (!devnode->fops->poll)
                return DEFAULT_POLLMASK;
        return devnode->fops->poll(filp, poll);
index c988669e22ff92a6d52ab27e040c602f2a5e3f9a..f697698fe38ded00117586ada77a8eb7c3a1b13c 100644 (file)
@@ -2964,39 +2964,39 @@ static __poll_t bttv_poll(struct file *file, poll_table *wait)
        __poll_t req_events = poll_requested_events(wait);
 
        if (v4l2_event_pending(&fh->fh))
-               rc = POLLPRI;
-       else if (req_events & POLLPRI)
+               rc = EPOLLPRI;
+       else if (req_events & EPOLLPRI)
                poll_wait(file, &fh->fh.wait, wait);
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return rc;
 
        if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
                if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
-                       return rc | POLLERR;
+                       return rc | EPOLLERR;
                return rc | videobuf_poll_stream(file, &fh->vbi, wait);
        }
 
        if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
                /* streaming capture */
                if (list_empty(&fh->cap.stream))
-                       return rc | POLLERR;
+                       return rc | EPOLLERR;
                buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
        } else {
                /* read() capture */
                if (NULL == fh->cap.read_buf) {
                        /* need to capture a new frame */
                        if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
-                               return rc | POLLERR;
+                               return rc | EPOLLERR;
                        fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
                        if (NULL == fh->cap.read_buf)
-                               return rc | POLLERR;
+                               return rc | EPOLLERR;
                        fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
                        field = videobuf_next_field(&fh->cap);
                        if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
                                kfree (fh->cap.read_buf);
                                fh->cap.read_buf = NULL;
-                               return rc | POLLERR;
+                               return rc | EPOLLERR;
                        }
                        fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
                        fh->cap.read_off = 0;
@@ -3007,7 +3007,7 @@ static __poll_t bttv_poll(struct file *file, poll_table *wait)
        poll_wait(file, &buf->vb.done, wait);
        if (buf->vb.state == VIDEOBUF_DONE ||
            buf->vb.state == VIDEOBUF_ERROR)
-               rc = rc | POLLIN|POLLRDNORM;
+               rc = rc | EPOLLIN|EPOLLRDNORM;
        return rc;
 }
 
@@ -3338,8 +3338,8 @@ static __poll_t radio_poll(struct file *file, poll_table *wait)
        __poll_t res = 0;
 
        if (v4l2_event_pending(&fh->fh))
-               res = POLLPRI;
-       else if (req_events & POLLPRI)
+               res = EPOLLPRI;
+       else if (req_events & EPOLLPRI)
                poll_wait(file, &fh->fh.wait, wait);
        radio_enable(btv);
        cmd.instance = file;
index a8dbb922ba4b9d4f036daa59f7aa48e16faf9371..a3f44e30f821921b88acfbffce824c7d42b34744 100644 (file)
@@ -613,7 +613,7 @@ __poll_t cx18_v4l2_enc_poll(struct file *filp, poll_table *wait)
 
        /* Start a capture if there is none */
        if (!eof && !test_bit(CX18_F_S_STREAMING, &s->s_flags) &&
-                       (req_events & (POLLIN | POLLRDNORM))) {
+                       (req_events & (EPOLLIN | EPOLLRDNORM))) {
                int rc;
 
                mutex_lock(&cx->serialize_lock);
@@ -622,7 +622,7 @@ __poll_t cx18_v4l2_enc_poll(struct file *filp, poll_table *wait)
                if (rc) {
                        CX18_DEBUG_INFO("Could not start capture for %s (%d)\n",
                                        s->name, rc);
-                       return POLLERR;
+                       return EPOLLERR;
                }
                CX18_DEBUG_FILE("Encoder poll started capture\n");
        }
@@ -632,23 +632,23 @@ __poll_t cx18_v4l2_enc_poll(struct file *filp, poll_table *wait)
                __poll_t videobuf_poll = videobuf_poll_stream(filp, &s->vbuf_q, wait);
 
                if (v4l2_event_pending(&id->fh))
-                       res |= POLLPRI;
-               if (eof && videobuf_poll == POLLERR)
-                       return res | POLLHUP;
+                       res |= EPOLLPRI;
+               if (eof && videobuf_poll == EPOLLERR)
+                       return res | EPOLLHUP;
                return res | videobuf_poll;
        }
 
        /* add stream's waitq to the poll list */
        CX18_DEBUG_HI_FILE("Encoder poll\n");
        if (v4l2_event_pending(&id->fh))
-               res |= POLLPRI;
+               res |= EPOLLPRI;
        else
                poll_wait(filp, &s->waitq, wait);
 
        if (atomic_read(&s->q_full.depth))
-               return res | POLLIN | POLLRDNORM;
+               return res | EPOLLIN | EPOLLRDNORM;
        if (eof)
-               return res | POLLHUP;
+               return res | EPOLLHUP;
        return res;
 }
 
index 42b42824382cf1488ac05139e12911864a27d615..f9bee36f1cadbdee2cc2a7cea951ad3e7b745d0d 100644 (file)
@@ -745,9 +745,9 @@ static __poll_t ts_poll(struct file *file, poll_table *wait)
        poll_wait(file, &input->dma->wq, wait);
        poll_wait(file, &output->dma->wq, wait);
        if (ddb_input_avail(input) >= 188)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (ddb_output_free(output) >= 188)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 }
 
index 4aa773507201770a1d790b7bb054aebd8f5d3c9e..6196daae4b3e0e05053bc16b6f6974ebb404e811 100644 (file)
@@ -747,7 +747,7 @@ __poll_t ivtv_v4l2_dec_poll(struct file *filp, poll_table *wait)
                /* Turn off the old-style vsync events */
                clear_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
                if (v4l2_event_pending(&id->fh))
-                       res = POLLPRI;
+                       res = EPOLLPRI;
        } else {
                /* This is the old-style API which is here only for backwards
                   compatibility. */
@@ -755,12 +755,12 @@ __poll_t ivtv_v4l2_dec_poll(struct file *filp, poll_table *wait)
                set_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags);
                if (test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags) ||
                    test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags))
-                       res = POLLPRI;
+                       res = EPOLLPRI;
        }
 
        /* Allow write if buffers are available for writing */
        if (s->q_free.buffers)
-               res |= POLLOUT | POLLWRNORM;
+               res |= EPOLLOUT | EPOLLWRNORM;
        return res;
 }
 
@@ -776,7 +776,7 @@ __poll_t ivtv_v4l2_enc_poll(struct file *filp, poll_table *wait)
        /* Start a capture if there is none */
        if (!eof && !test_bit(IVTV_F_S_STREAMING, &s->s_flags) &&
                        s->type != IVTV_ENC_STREAM_TYPE_RAD &&
-                       (req_events & (POLLIN | POLLRDNORM))) {
+                       (req_events & (EPOLLIN | EPOLLRDNORM))) {
                int rc;
 
                mutex_lock(&itv->serialize_lock);
@@ -785,7 +785,7 @@ __poll_t ivtv_v4l2_enc_poll(struct file *filp, poll_table *wait)
                if (rc) {
                        IVTV_DEBUG_INFO("Could not start capture for %s (%d)\n",
                                        s->name, rc);
-                       return POLLERR;
+                       return EPOLLERR;
                }
                IVTV_DEBUG_FILE("Encoder poll started capture\n");
        }
@@ -794,14 +794,14 @@ __poll_t ivtv_v4l2_enc_poll(struct file *filp, poll_table *wait)
        IVTV_DEBUG_HI_FILE("Encoder poll\n");
        poll_wait(filp, &s->waitq, wait);
        if (v4l2_event_pending(&id->fh))
-               res |= POLLPRI;
+               res |= EPOLLPRI;
        else
                poll_wait(filp, &id->fh.wait, wait);
 
        if (s->q_full.length || s->q_io.length)
-               return res | POLLIN | POLLRDNORM;
+               return res | EPOLLIN | EPOLLRDNORM;
        if (eof)
-               return res | POLLHUP;
+               return res | EPOLLHUP;
        return res;
 }
 
index ae83293723bacfb31d1549b9dc375d2fdd873fbd..dedcdb57342705720a6e3a149904dd7b370b78fc 100644 (file)
@@ -1430,7 +1430,7 @@ static __poll_t meye_poll(struct file *file, poll_table *wait)
        mutex_lock(&meye.lock);
        poll_wait(file, &meye.proc_list, wait);
        if (kfifo_len(&meye.doneq))
-               res |= POLLIN | POLLRDNORM;
+               res |= EPOLLIN | EPOLLRDNORM;
        mutex_unlock(&meye.lock);
        return res;
 }
index e7b31a5b14fddd228dcae4e1e08fb05e1155a42b..32136ebe4f61c638c3eaa0e613ff4589655bdccd 100644 (file)
@@ -925,13 +925,13 @@ static __poll_t fops_poll(struct file *file, poll_table *wait)
        saa7164_histogram_update(&port->poll_interval,
                port->last_poll_msecs_diff);
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return mask;
 
        if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
                if (atomic_inc_return(&port->v4l_reader_count) == 1) {
                        if (saa7164_encoder_initialize(port) < 0)
-                               return mask | POLLERR;
+                               return mask | EPOLLERR;
                        saa7164_encoder_start_streaming(port);
                        msleep(200);
                }
@@ -939,7 +939,7 @@ static __poll_t fops_poll(struct file *file, poll_table *wait)
 
        /* Pull the first buffer from the used list */
        if (!list_empty(&port->list_buf_used.list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 6f97c8f2e00d8e004dc8d3c8c7dc447b66e656bd..64ab91c24c18610113f373419d9467d965c58fe3 100644 (file)
@@ -650,7 +650,7 @@ static __poll_t fops_poll(struct file *file, poll_table *wait)
 
        /* Pull the first buffer from the used list */
        if (!list_empty(&port->list_buf_used.list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 4d10e2f979d20918f650e69c4ceed2726d59ee4b..4daba76ec240bc382e3b48e17f3d1cbafaaa6858 100644 (file)
@@ -951,15 +951,15 @@ static __poll_t dvb_video_poll(struct file *file, poll_table *wait)
        poll_wait(file, &av7110->video_events.wait_queue, wait);
 
        if (av7110->video_events.eventw != av7110->video_events.eventr)
-               mask = POLLPRI;
+               mask = EPOLLPRI;
 
        if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
                if (av7110->playing) {
                        if (FREE_COND)
-                               mask |= (POLLOUT | POLLWRNORM);
+                               mask |= (EPOLLOUT | EPOLLWRNORM);
                } else {
                        /* if not playing: may play if asked for */
-                       mask |= (POLLOUT | POLLWRNORM);
+                       mask |= (EPOLLOUT | EPOLLWRNORM);
                }
        }
 
@@ -1001,9 +1001,9 @@ static __poll_t dvb_audio_poll(struct file *file, poll_table *wait)
 
        if (av7110->playing) {
                if (dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
-                       mask |= (POLLOUT | POLLWRNORM);
+                       mask |= (EPOLLOUT | EPOLLWRNORM);
        } else /* if not playing: may play if asked for */
-               mask = (POLLOUT | POLLWRNORM);
+               mask = (EPOLLOUT | EPOLLWRNORM);
 
        return mask;
 }
index 96ca227cf51b69afe8a077a7ce63a51994329aac..d8c2f1b34d74c9ca059d7092c358ed3b1e70309e 100644 (file)
@@ -237,10 +237,10 @@ static __poll_t dvb_ca_poll (struct file *file, poll_table *wait)
        poll_wait(file, &wbuf->queue, wait);
 
        if (!dvb_ringbuffer_empty(rbuf))
-               mask |= (POLLIN | POLLRDNORM);
+               mask |= (EPOLLIN | EPOLLRDNORM);
 
        if (dvb_ringbuffer_free(wbuf) > 1024)
-               mask |= (POLLOUT | POLLWRNORM);
+               mask |= (EPOLLOUT | EPOLLWRNORM);
 
        return mask;
 }
index c464dae0389c9db2fb660dea899147a7451cc320..8d4e7d930a663a2d15e2b7e187b66069af2dbe93 100644 (file)
@@ -2513,10 +2513,10 @@ zoran_poll (struct file *file,
 
        /* we should check whether buffers are ready to be synced on
         * (w/o waits - O_NONBLOCK) here
-        * if ready for read (sync), return POLLIN|POLLRDNORM,
-        * if ready for write (sync), return POLLOUT|POLLWRNORM,
-        * if error, return POLLERR,
-        * if no buffers queued or so, return POLLNVAL
+        * if ready for read (sync), return EPOLLIN|EPOLLRDNORM,
+        * if ready for write (sync), return EPOLLOUT|EPOLLWRNORM,
+        * if error, return EPOLLERR,
+        * if no buffers queued or so, return EPOLLNVAL
         */
 
        switch (fh->map_mode) {
@@ -2536,7 +2536,7 @@ zoran_poll (struct file *file,
                if (fh->buffers.active != ZORAN_FREE &&
                    /* Buffer ready to DQBUF? */
                    zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)
-                       res |= POLLIN | POLLRDNORM;
+                       res |= EPOLLIN | EPOLLRDNORM;
                spin_unlock_irqrestore(&zr->spinlock, flags);
 
                break;
@@ -2557,9 +2557,9 @@ zoran_poll (struct file *file,
                if (fh->buffers.active != ZORAN_FREE &&
                    zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {
                        if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)
-                               res |= POLLIN | POLLRDNORM;
+                               res |= EPOLLIN | EPOLLRDNORM;
                        else
-                               res |= POLLOUT | POLLWRNORM;
+                               res |= EPOLLOUT | EPOLLWRNORM;
                }
                spin_unlock_irqrestore(&zr->spinlock, flags);
 
@@ -2570,7 +2570,7 @@ zoran_poll (struct file *file,
                        KERN_ERR
                        "%s: %s - internal error, unknown map_mode=%d\n",
                        ZR_DEVNAME(zr), __func__, fh->map_mode);
-               res |= POLLERR;
+               res |= EPOLLERR;
        }
 
        return res;
index de285a269390a18b7cd244f63b59d3accc68528f..200c47c69a758320d497b4f22459675771f64770 100644 (file)
@@ -1272,9 +1272,9 @@ static __poll_t viu_poll(struct file *file, struct poll_table_struct *wait)
        __poll_t res = v4l2_ctrl_poll(file, wait);
 
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
-               return POLLERR;
+               return EPOLLERR;
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return res;
 
        mutex_lock(&dev->lock);
index f15cf24c1c639edc99ea9699da97de6919e007d0..d5b94fc0040e4f8081cf99de46367504780ed3d4 100644 (file)
@@ -1008,7 +1008,7 @@ static __poll_t s5p_mfc_poll(struct file *file,
         */
        if ((!src_q->streaming || list_empty(&src_q->queued_list))
                && (!dst_q->streaming || list_empty(&dst_q->queued_list))) {
-               rc = POLLERR;
+               rc = EPOLLERR;
                goto end;
        }
        mutex_unlock(&dev->mfc_mutex);
@@ -1017,14 +1017,14 @@ static __poll_t s5p_mfc_poll(struct file *file,
        poll_wait(file, &dst_q->done_wq, wait);
        mutex_lock(&dev->mfc_mutex);
        if (v4l2_event_pending(&ctx->fh))
-               rc |= POLLPRI;
+               rc |= EPOLLPRI;
        spin_lock_irqsave(&src_q->done_lock, flags);
        if (!list_empty(&src_q->done_list))
                src_vb = list_first_entry(&src_q->done_list, struct vb2_buffer,
                                                                done_entry);
        if (src_vb && (src_vb->state == VB2_BUF_STATE_DONE
                                || src_vb->state == VB2_BUF_STATE_ERROR))
-               rc |= POLLOUT | POLLWRNORM;
+               rc |= EPOLLOUT | EPOLLWRNORM;
        spin_unlock_irqrestore(&src_q->done_lock, flags);
        spin_lock_irqsave(&dst_q->done_lock, flags);
        if (!list_empty(&dst_q->done_list))
@@ -1032,7 +1032,7 @@ static __poll_t s5p_mfc_poll(struct file *file,
                                                                done_entry);
        if (dst_vb && (dst_vb->state == VB2_BUF_STATE_DONE
                                || dst_vb->state == VB2_BUF_STATE_ERROR))
-               rc |= POLLIN | POLLRDNORM;
+               rc |= EPOLLIN | EPOLLRDNORM;
        spin_unlock_irqrestore(&dst_q->done_lock, flags);
 end:
        mutex_unlock(&dev->mfc_mutex);
index 70fc5f01942dede25a35144d1def324ea5274b27..c86dd2fdab84add0c3d06b5f76bd0850323316b4 100644 (file)
@@ -809,10 +809,10 @@ static __poll_t soc_camera_poll(struct file *file, poll_table *pt)
 {
        struct soc_camera_device *icd = file->private_data;
        struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-       __poll_t res = POLLERR;
+       __poll_t res = EPOLLERR;
 
        if (icd->streamer != file)
-               return POLLERR;
+               return EPOLLERR;
 
        mutex_lock(&ici->host_lock);
        res = ici->ops->poll(file, pt);
index fcb7a9f015b6bf1250821f7a7fb4f8abd324fb45..f834f7df8cf9f53d268043be18dc95f1a762c099 100644 (file)
@@ -142,7 +142,7 @@ retry:
 
 __poll_t vivid_radio_rx_poll(struct file *file, struct poll_table_struct *wait)
 {
-       return POLLIN | POLLRDNORM | v4l2_ctrl_poll(file, wait);
+       return EPOLLIN | EPOLLRDNORM | v4l2_ctrl_poll(file, wait);
 }
 
 int vivid_radio_rx_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
index af4907a197a33702889595f211988550f51ecc72..308b13f85dc08ad862fb4dddcbf9225f7ff2da7f 100644 (file)
@@ -105,7 +105,7 @@ retry:
 
 __poll_t vivid_radio_tx_poll(struct file *file, struct poll_table_struct *wait)
 {
-       return POLLOUT | POLLWRNORM | v4l2_ctrl_poll(file, wait);
+       return EPOLLOUT | EPOLLWRNORM | v4l2_ctrl_poll(file, wait);
 }
 
 int vidioc_g_modulator(struct file *file, void *fh, struct v4l2_modulator *a)
index af7c68b344d1a04972cba5cd42103323f254ca67..5b82e63885cdd845a744451b0f2ed8f16056c0e2 100644 (file)
@@ -488,14 +488,14 @@ static __poll_t cadet_poll(struct file *file, struct poll_table_struct *wait)
        __poll_t res = v4l2_ctrl_poll(file, wait);
 
        poll_wait(file, &dev->read_queue, wait);
-       if (dev->rdsstat == 0 && (req_events & (POLLIN | POLLRDNORM))) {
+       if (dev->rdsstat == 0 && (req_events & (EPOLLIN | EPOLLRDNORM))) {
                mutex_lock(&dev->lock);
                if (dev->rdsstat == 0)
                        cadet_start_rds(dev);
                mutex_unlock(&dev->lock);
        }
        if (cadet_has_rds_data(dev))
-               res |= POLLIN | POLLRDNORM;
+               res |= EPOLLIN | EPOLLRDNORM;
        return res;
 }
 
index bff9789ae9bc1940e95d1e49029d54739c90af5d..b52e678c6901cfa8b115d7790be029cbd37cfc2f 100644 (file)
@@ -1158,15 +1158,15 @@ static __poll_t si476x_radio_fops_poll(struct file *file,
        __poll_t req_events = poll_requested_events(pts);
        __poll_t err = v4l2_ctrl_poll(file, pts);
 
-       if (req_events & (POLLIN | POLLRDNORM)) {
+       if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                if (atomic_read(&radio->core->is_alive))
                        poll_wait(file, &radio->core->rds_read_queue, pts);
 
                if (!atomic_read(&radio->core->is_alive))
-                       err = POLLHUP;
+                       err = EPOLLHUP;
 
                if (!kfifo_is_empty(&radio->core->rds_fifo))
-                       err = POLLIN | POLLRDNORM;
+                       err = EPOLLIN | EPOLLRDNORM;
        }
 
        return err;
index f92b0f9241a9944b1a73230660dbe03c3121d5f4..58e944591602617e4af5e0913d99054340935f8c 100644 (file)
@@ -1104,10 +1104,10 @@ static __poll_t wl1273_fm_fops_poll(struct file *file,
                poll_wait(file, &radio->read_queue, pts);
 
                if (radio->rd_index != radio->wr_index)
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
 
        } else if (core->mode == WL1273_MODE_TX) {
-               return POLLOUT | POLLWRNORM;
+               return EPOLLOUT | EPOLLWRNORM;
        }
 
        return 0;
index 5b477b7d6a66df973d440e9bd4de07e47b858aec..e0054e0f410df09db5c239e52fccc7db211c886b 100644 (file)
@@ -514,7 +514,7 @@ static __poll_t si470x_fops_poll(struct file *file,
        __poll_t req_events = poll_requested_events(pts);
        __poll_t retval = v4l2_ctrl_poll(file, pts);
 
-       if (req_events & (POLLIN | POLLRDNORM)) {
+       if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                /* switch on rds reception */
                if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
                        si470x_rds_on(radio);
@@ -522,7 +522,7 @@ static __poll_t si470x_fops_poll(struct file *file,
                poll_wait(file, &radio->read_queue, pts);
 
                if (radio->rd_index != radio->wr_index)
-                       retval |= POLLIN | POLLRDNORM;
+                       retval |= EPOLLIN | EPOLLRDNORM;
        }
 
        return retval;
index fd603c1b96bbfbaeebaec239d0b85d2c7b37d109..dccdf6558e6ab7ce4e1e613453acdd5558badd3a 100644 (file)
@@ -112,7 +112,7 @@ static __poll_t fm_v4l2_fops_poll(struct file *file, struct poll_table_struct *p
        ret = fmc_is_rds_data_available(fmdev, file, pts);
        mutex_unlock(&fmdev->mutex);
        if (ret < 0)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index b3544988586e881397847260ab984abb126b66c8..cc863044c880ab301ee8c31a2cb1c62b6b057f72 100644 (file)
@@ -109,7 +109,7 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
                if (LIRC_IS_TIMEOUT(sample) && !fh->send_timeout_reports)
                        continue;
                if (kfifo_put(&fh->rawir, sample))
-                       wake_up_poll(&fh->wait_poll, POLLIN | POLLRDNORM);
+                       wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
        }
        spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 }
@@ -130,7 +130,7 @@ void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc)
        spin_lock_irqsave(&dev->lirc_fh_lock, flags);
        list_for_each_entry(fh, &dev->lirc_fh, list) {
                if (kfifo_put(&fh->scancodes, *lsc))
-                       wake_up_poll(&fh->wait_poll, POLLIN | POLLRDNORM);
+                       wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
        }
        spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 }
@@ -603,15 +603,15 @@ static __poll_t ir_lirc_poll(struct file *file, struct poll_table_struct *wait)
        poll_wait(file, &fh->wait_poll, wait);
 
        if (!rcdev->registered) {
-               events = POLLHUP | POLLERR;
+               events = EPOLLHUP | EPOLLERR;
        } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) {
                if (fh->rec_mode == LIRC_MODE_SCANCODE &&
                    !kfifo_is_empty(&fh->scancodes))
-                       events = POLLIN | POLLRDNORM;
+                       events = EPOLLIN | EPOLLRDNORM;
 
                if (fh->rec_mode == LIRC_MODE_MODE2 &&
                    !kfifo_is_empty(&fh->rawir))
-                       events = POLLIN | POLLRDNORM;
+                       events = EPOLLIN | EPOLLRDNORM;
        }
 
        return events;
@@ -779,7 +779,7 @@ void ir_lirc_unregister(struct rc_dev *dev)
 
        spin_lock_irqsave(&dev->lirc_fh_lock, flags);
        list_for_each_entry(fh, &dev->lirc_fh, list)
-               wake_up_poll(&fh->wait_poll, POLLHUP | POLLERR);
+               wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
        spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 
        cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
index e7524920c6187ed7e07346f504c2362369883701..3dfbb545c0e3859e9481575d235868f51fcd48f0 100644 (file)
@@ -2375,7 +2375,7 @@ __poll_t cpia2_poll(struct camera_data *cam, struct file *filp,
 {
        __poll_t status = v4l2_ctrl_poll(filp, wait);
 
-       if ((poll_requested_events(wait) & (POLLIN | POLLRDNORM)) &&
+       if ((poll_requested_events(wait) & (EPOLLIN | EPOLLRDNORM)) &&
                        !cam->streaming) {
                /* Start streaming */
                cpia2_usb_stream_start(cam,
@@ -2385,7 +2385,7 @@ __poll_t cpia2_poll(struct camera_data *cam, struct file *filp,
        poll_wait(filp, &cam->wq_stream, wait);
 
        if (cam->curbuff->status == FRAME_READY)
-               status |= POLLIN | POLLRDNORM;
+               status |= EPOLLIN | EPOLLRDNORM;
 
        return status;
 }
index 103e3299b77f15f055a45ac51f74daa13223e898..b80e6857e2ebaae0dfe3a368e83057afa5191fe0 100644 (file)
@@ -1821,11 +1821,11 @@ static __poll_t mpeg_poll(struct file *file,
        __poll_t res = 0;
 
        if (v4l2_event_pending(&fh->fh))
-               res |= POLLPRI;
+               res |= EPOLLPRI;
        else
                poll_wait(file, &fh->fh.wait, wait);
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return res;
 
        mutex_lock(&dev->lock);
index 271f35208c4947925f91c0de7e6ccd316ce67fbb..5b321b8ada3ac3a93eed58e82a0d8a839fc7d315 100644 (file)
@@ -2018,19 +2018,19 @@ static __poll_t cx231xx_v4l2_poll(struct file *filp, poll_table *wait)
 
        rc = check_dev(dev);
        if (rc < 0)
-               return POLLERR;
+               return EPOLLERR;
 
        rc = res_get(fh);
 
        if (unlikely(rc < 0))
-               return POLLERR;
+               return EPOLLERR;
 
        if (v4l2_event_pending(&fh->fh))
-               res |= POLLPRI;
+               res |= EPOLLPRI;
        else
                poll_wait(filp, &fh->fh.wait, wait);
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return res;
 
        if ((V4L2_BUF_TYPE_VIDEO_CAPTURE == fh->type) ||
@@ -2040,7 +2040,7 @@ static __poll_t cx231xx_v4l2_poll(struct file *filp, poll_table *wait)
                mutex_unlock(&dev->lock);
                return res;
        }
-       return res | POLLERR;
+       return res | EPOLLERR;
 }
 
 /*
index 87e18d0c57664d999a8d37e8d684466ebbd5adf6..d29773b8f696d2751d435155969c13e03efbbedb 100644 (file)
@@ -1877,14 +1877,14 @@ static __poll_t dev_poll(struct file *file, poll_table *wait)
 
        gspca_dbg(gspca_dev, D_FRAM, "poll\n");
 
-       if (req_events & POLLPRI)
+       if (req_events & EPOLLPRI)
                ret |= v4l2_ctrl_poll(file, wait);
 
-       if (req_events & (POLLIN | POLLRDNORM)) {
+       if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                /* if reqbufs is not done, the user would use read() */
                if (gspca_dev->memory == GSPCA_MEMORY_NO) {
                        if (read_alloc(gspca_dev, file) != 0) {
-                               ret |= POLLERR;
+                               ret |= EPOLLERR;
                                goto out;
                        }
                }
@@ -1893,17 +1893,17 @@ static __poll_t dev_poll(struct file *file, poll_table *wait)
 
                /* check if an image has been received */
                if (mutex_lock_interruptible(&gspca_dev->queue_lock) != 0) {
-                       ret |= POLLERR;
+                       ret |= EPOLLERR;
                        goto out;
                }
                if (gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i))
-                       ret |= POLLIN | POLLRDNORM;
+                       ret |= EPOLLIN | EPOLLRDNORM;
                mutex_unlock(&gspca_dev->queue_lock);
        }
 
 out:
        if (!gspca_dev->present)
-               ret |= POLLHUP;
+               ret |= EPOLLHUP;
 
        return ret;
 }
index 660d4a65401f5a9b8856007bab097a30299bbfe3..77c3d331ff31491e7bb86417d29ab4763c8535dc 100644 (file)
@@ -528,7 +528,7 @@ static __poll_t hdpvr_poll(struct file *filp, poll_table *wait)
        struct hdpvr_device *dev = video_drvdata(filp);
        __poll_t mask = v4l2_ctrl_poll(filp, wait);
 
-       if (!(req_events & (POLLIN | POLLRDNORM)))
+       if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
                return mask;
 
        mutex_lock(&dev->io_mutex);
@@ -553,7 +553,7 @@ static __poll_t hdpvr_poll(struct file *filp, poll_table *wait)
                buf = hdpvr_get_next_buffer(dev);
        }
        if (buf && buf->status == BUFSTAT_READY)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index ad6290e1b6999615e8bb78c2212c9790ce59799b..9fdc57c1658fcc3d8dc028e126259255459c3f07 100644 (file)
@@ -1181,19 +1181,19 @@ static __poll_t pvr2_v4l2_poll(struct file *file, poll_table *wait)
        int ret;
 
        if (fh->fw_mode_flag) {
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
                return mask;
        }
 
        if (!fh->rhp) {
                ret = pvr2_v4l2_iosetup(fh);
-               if (ret) return POLLERR;
+               if (ret) return EPOLLERR;
        }
 
        poll_wait(file,&fh->wait_data,wait);
 
        if (pvr2_ioread_avail(fh->rhp) >= 0) {
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        return mask;
index 17ad978c01726fc801c24c05199cbdfa792e95b2..22389b56ec24664e2df6e3ed412348941f4035c5 100644 (file)
@@ -729,10 +729,10 @@ static __poll_t v4l_stk_poll(struct file *fp, poll_table *wait)
        poll_wait(fp, &dev->wait_frame, wait);
 
        if (!is_present(dev))
-               return POLLERR;
+               return EPOLLERR;
 
        if (!list_empty(&dev->sio_full))
-               return res | POLLIN | POLLRDNORM;
+               return res | EPOLLIN | EPOLLRDNORM;
 
        return res;
 }
index 96266fa4738c55c2f916590b6d51c44602486216..8314d3fa9241b322f8f15b9473a3616b2033de46 100644 (file)
@@ -1424,25 +1424,25 @@ __tm6000_poll(struct file *file, struct poll_table_struct *wait)
        __poll_t res = 0;
 
        if (v4l2_event_pending(&fh->fh))
-               res = POLLPRI;
-       else if (req_events & POLLPRI)
+               res = EPOLLPRI;
+       else if (req_events & EPOLLPRI)
                poll_wait(file, &fh->fh.wait, wait);
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
-               return res | POLLERR;
+               return res | EPOLLERR;
 
        if (!!is_res_streaming(fh->dev, fh))
-               return res | POLLERR;
+               return res | EPOLLERR;
 
        if (!is_res_read(fh->dev, fh)) {
                /* streaming capture */
                if (list_empty(&fh->vb_vidq.stream))
-                       return res | POLLERR;
+                       return res | EPOLLERR;
                buf = list_entry(fh->vb_vidq.stream.next, struct tm6000_buffer, vb.stream);
                poll_wait(file, &buf->vb.done, wait);
                if (buf->vb.state == VIDEOBUF_DONE ||
                    buf->vb.state == VIDEOBUF_ERROR)
-                       return res | POLLIN | POLLRDNORM;
-       } else if (req_events & (POLLIN | POLLRDNORM)) {
+                       return res | EPOLLIN | EPOLLRDNORM;
+       } else if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                /* read() capture */
                return res | videobuf_poll_stream(file, &fh->vb_vidq, wait);
        }
index b076571494345f0d4a13b4816bbba2570891c125..ce08b50b829006fce4cb2b97c7e348e84bd32c1d 100644 (file)
@@ -3462,7 +3462,7 @@ __poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
        struct v4l2_fh *fh = file->private_data;
 
        if (v4l2_event_pending(fh))
-               return POLLPRI;
+               return EPOLLPRI;
        poll_wait(file, &fh->wait, wait);
        return 0;
 }
index cd8127d3f863b7d25fbc7a5dada11d43bc8b1c6f..0301fe426a4358cb136e6980ef3577329219cd97 100644 (file)
@@ -334,7 +334,7 @@ static ssize_t v4l2_write(struct file *filp, const char __user *buf,
 static __poll_t v4l2_poll(struct file *filp, struct poll_table_struct *poll)
 {
        struct video_device *vdev = video_devdata(filp);
-       __poll_t res = POLLERR | POLLHUP;
+       __poll_t res = EPOLLERR | EPOLLHUP;
 
        if (!vdev->fops->poll)
                return DEFAULT_POLLMASK;
index 186156f8952ab15d57ff7d1a092ec17e24b70037..c4f963d96a79d05c5dea819dd3d028a7b3c32bd6 100644 (file)
@@ -514,10 +514,10 @@ __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                struct v4l2_fh *fh = file->private_data;
 
                if (v4l2_event_pending(fh))
-                       rc = POLLPRI;
-               else if (req_events & POLLPRI)
+                       rc = EPOLLPRI;
+               else if (req_events & EPOLLPRI)
                        poll_wait(file, &fh->wait, wait);
-               if (!(req_events & (POLLOUT | POLLWRNORM | POLLIN | POLLRDNORM)))
+               if (!(req_events & (EPOLLOUT | EPOLLWRNORM | EPOLLIN | EPOLLRDNORM)))
                        return rc;
        }
 
@@ -531,7 +531,7 @@ __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
         */
        if ((!src_q->streaming || list_empty(&src_q->queued_list))
                && (!dst_q->streaming || list_empty(&dst_q->queued_list))) {
-               rc |= POLLERR;
+               rc |= EPOLLERR;
                goto end;
        }
 
@@ -548,7 +548,7 @@ __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                 */
                if (dst_q->last_buffer_dequeued) {
                        spin_unlock_irqrestore(&dst_q->done_lock, flags);
-                       return rc | POLLIN | POLLRDNORM;
+                       return rc | EPOLLIN | EPOLLRDNORM;
                }
 
                poll_wait(file, &dst_q->done_wq, wait);
@@ -561,7 +561,7 @@ __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                                                done_entry);
        if (src_vb && (src_vb->state == VB2_BUF_STATE_DONE
                        || src_vb->state == VB2_BUF_STATE_ERROR))
-               rc |= POLLOUT | POLLWRNORM;
+               rc |= EPOLLOUT | EPOLLWRNORM;
        spin_unlock_irqrestore(&src_q->done_lock, flags);
 
        spin_lock_irqsave(&dst_q->done_lock, flags);
@@ -570,7 +570,7 @@ __poll_t v4l2_m2m_poll(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                                                done_entry);
        if (dst_vb && (dst_vb->state == VB2_BUF_STATE_DONE
                        || dst_vb->state == VB2_BUF_STATE_ERROR))
-               rc |= POLLIN | POLLRDNORM;
+               rc |= EPOLLIN | EPOLLRDNORM;
        spin_unlock_irqrestore(&dst_q->done_lock, flags);
 
 end:
index 28966fa8c6100ad141e89cce7cdfdd161a26ec05..c5639817db34902a3c7ada8552d63abbd9ea492f 100644 (file)
@@ -476,12 +476,12 @@ static __poll_t subdev_poll(struct file *file, poll_table *wait)
        struct v4l2_fh *fh = file->private_data;
 
        if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS))
-               return POLLERR;
+               return EPOLLERR;
 
        poll_wait(file, &fh->wait, wait);
 
        if (v4l2_event_pending(fh))
-               return POLLPRI;
+               return EPOLLPRI;
 
        return 0;
 }
index 9a89d3ae170fd0f4454e146aa3b3a12beda25856..2b3981842b4b7539a68757b6e9f25d8d0e422c54 100644 (file)
@@ -1131,11 +1131,11 @@ __poll_t videobuf_poll_stream(struct file *file,
                if (!list_empty(&q->stream))
                        buf = list_entry(q->stream.next,
                                         struct videobuf_buffer, stream);
-       } else if (req_events & (POLLIN | POLLRDNORM)) {
+       } else if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                if (!q->reading)
                        __videobuf_read_start(q);
                if (!q->reading) {
-                       rc = POLLERR;
+                       rc = EPOLLERR;
                } else if (NULL == q->read_buf) {
                        q->read_buf = list_entry(q->stream.next,
                                                 struct videobuf_buffer,
@@ -1146,7 +1146,7 @@ __poll_t videobuf_poll_stream(struct file *file,
                buf = q->read_buf;
        }
        if (!buf)
-               rc = POLLERR;
+               rc = EPOLLERR;
 
        if (0 == rc) {
                poll_wait(file, &buf->done, wait);
@@ -1157,10 +1157,10 @@ __poll_t videobuf_poll_stream(struct file *file,
                        case V4L2_BUF_TYPE_VBI_OUTPUT:
                        case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
                        case V4L2_BUF_TYPE_SDR_OUTPUT:
-                               rc = POLLOUT | POLLWRNORM;
+                               rc = EPOLLOUT | EPOLLWRNORM;
                                break;
                        default:
-                               rc = POLLIN | POLLRDNORM;
+                               rc = EPOLLIN | EPOLLRDNORM;
                                break;
                        }
                }
index fcb3a92ae85f8b2d2b819eeece89dcb96528d825..8ba41073dd89f1cdb210bd015c86979fd5c3a083 100644 (file)
@@ -1267,7 +1267,7 @@ static irqreturn_t ab8500_debug_handler(int irq, void *data)
        if (irq_abb < num_irqs)
                irq_count[irq_abb]++;
        /*
-        * This makes it possible to use poll for events (POLLPRI | POLLERR)
+        * This makes it possible to use poll for events (EPOLLPRI | EPOLLERR)
         * from userspace on sysfs file named <irq-nr>
         */
        sprintf(buf, "%d", irq);
index 0162516f5e57b1f5297f1a443da849f69407f91e..bd6ddbdb5cd16c50e5b4b3989909b814157e0379 100644 (file)
@@ -378,11 +378,11 @@ __poll_t afu_poll(struct file *file, struct poll_table_struct *poll)
 
        spin_lock_irqsave(&ctx->lock, flags);
        if (ctx_event_pending(ctx))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        else if (ctx->status == CLOSED)
                /* Only error on closed when there are no futher events pending
                 */
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        spin_unlock_irqrestore(&ctx->lock, flags);
 
        pr_devel("afu_poll pe: %i returning %#x\n", ctx->pe, mask);
index 35693c0a78e28cf916dacf9a80f7e628c2508b98..e9c9ef52c76a879909ffe6abb0b2362824df1084 100644 (file)
@@ -519,9 +519,9 @@ static __poll_t ilo_poll(struct file *fp, poll_table *wait)
        poll_wait(fp, &data->ccb_waitq, wait);
 
        if (is_channel_reset(driver_ccb))
-               return POLLERR;
+               return EPOLLERR;
        else if (ilo_pkt_recv(data->ilo_hw, driver_ccb))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index e49888eab87d5f80b04b8321c4fd9b605e5ba9d8..e9bb1cfa6a7a2b80d6ce15df9f50b86061cc193d 100644 (file)
@@ -658,7 +658,7 @@ static __poll_t lis3lv02d_misc_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &lis3->misc_wait, wait);
        if (atomic_read(&lis3->count))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 505b710291e6927a3763b327064ca128de0021bf..758dc73602d5ed4618ccf2347daaad0c526f1161 100644 (file)
@@ -551,31 +551,31 @@ static __poll_t mei_poll(struct file *file, poll_table *wait)
        bool notify_en;
 
        if (WARN_ON(!cl || !cl->dev))
-               return POLLERR;
+               return EPOLLERR;
 
        dev = cl->dev;
 
        mutex_lock(&dev->device_lock);
 
-       notify_en = cl->notify_en && (req_events & POLLPRI);
+       notify_en = cl->notify_en && (req_events & EPOLLPRI);
 
        if (dev->dev_state != MEI_DEV_ENABLED ||
            !mei_cl_is_connected(cl)) {
-               mask = POLLERR;
+               mask = EPOLLERR;
                goto out;
        }
 
        if (notify_en) {
                poll_wait(file, &cl->ev_wait, wait);
                if (cl->notify_ev)
-                       mask |= POLLPRI;
+                       mask |= EPOLLPRI;
        }
 
-       if (req_events & (POLLIN | POLLRDNORM)) {
+       if (req_events & (EPOLLIN | EPOLLRDNORM)) {
                poll_wait(file, &cl->rx_wait, wait);
 
                if (!list_empty(&cl->rd_completed))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                else
                        mei_cl_read_start(cl, mei_cl_mtu(cl), file);
        }
index 85f7d09cc65fd116332058796946de8dfa89f0fc..05a63286741c841979962fd6dc305e8558255913 100644 (file)
@@ -55,7 +55,7 @@
  *    message being sent to host SCIF. SCIF_DISCNCT message processing on the
  *    host SCIF sets the host COSM SCIF endpoint state to DISCONNECTED and wakes
  *    up the host COSM thread blocked in scif_poll(..) resulting in
- *    scif_poll(..)  returning POLLHUP.
+ *    scif_poll(..)  returning EPOLLHUP.
  * 5. On the card, scif_peer_release_dev is next called which results in an
  *    SCIF_EXIT message being sent to the host and after receiving the
  *    SCIF_EXIT_ACK from the host the peer device teardown on the card is
@@ -79,7 +79,7 @@
  *    processing. This results in the COSM endpoint on the card being closed and
  *    the SCIF host peer device on the card getting unregistered similar to
  *    steps 3, 4 and 5 for the card shutdown case above. scif_poll(..) on the
- *    host returns POLLHUP as a result.
+ *    host returns EPOLLHUP as a result.
  * 4. On the host, card peer device unregister and SCIF HW remove(..) also
  *    subsequently complete.
  *
  * ----------
  * If a reset is issued after the card has crashed, there is no SCIF_DISCNT
  * message from the card which would result in scif_poll(..) returning
- * POLLHUP. In this case when the host SCIF driver sends a SCIF_REMOVE_NODE
+ * EPOLLHUP. In this case when the host SCIF driver sends a SCIF_REMOVE_NODE
  * message to itself resulting in the card SCIF peer device being unregistered,
  * this results in a scif_peer_release_dev -> scif_cleanup_scifdev->
  * scif_invalidate_ep call sequence which sets the endpoint state to
- * DISCONNECTED and results in scif_poll(..) returning POLLHUP.
+ * DISCONNECTED and results in scif_poll(..) returning EPOLLHUP.
  */
 
 #define COSM_SCIF_BACKLOG 16
@@ -190,7 +190,7 @@ static void cosm_send_time(struct cosm_device *cdev)
 
 /*
  * Close this cosm_device's endpoint after its peer endpoint on the card has
- * been closed. In all cases except MIC card crash POLLHUP on the host is
+ * been closed. In all cases except MIC card crash EPOLLHUP on the host is
  * triggered by the client's endpoint being closed.
  */
 static void cosm_scif_close(struct cosm_device *cdev)
@@ -252,7 +252,7 @@ void cosm_scif_work(struct work_struct *work)
 
        while (1) {
                pollepd.epd = cdev->epd;
-               pollepd.events = POLLIN;
+               pollepd.events = EPOLLIN;
 
                /* Drop the mutex before blocking in scif_poll(..) */
                mutex_unlock(&cdev->cosm_mutex);
@@ -266,11 +266,11 @@ void cosm_scif_work(struct work_struct *work)
                }
 
                /* There is a message from the card */
-               if (pollepd.revents & POLLIN)
+               if (pollepd.revents & EPOLLIN)
                        cosm_scif_recv(cdev);
 
                /* The peer endpoint is closed or this endpoint disconnected */
-               if (pollepd.revents & POLLHUP) {
+               if (pollepd.revents & EPOLLHUP) {
                        cosm_scif_close(cdev);
                        break;
                }
index aa530fcceaa9959fc8b9f387de07e148d9acc2ee..beafc0da402788bd1d581409d34217e92927dfed 100644 (file)
@@ -160,7 +160,7 @@ static int cosm_scif_client(void *unused)
 
        while (!kthread_should_stop()) {
                pollepd.epd = client_epd;
-               pollepd.events = POLLIN;
+               pollepd.events = EPOLLIN;
 
                rc = scif_poll(&pollepd, 1, COSM_HEARTBEAT_SEND_MSEC);
                if (rc < 0) {
@@ -171,7 +171,7 @@ static int cosm_scif_client(void *unused)
                        continue;
                }
 
-               if (pollepd.revents & POLLIN)
+               if (pollepd.revents & EPOLLIN)
                        cosm_client_recv();
 
                msg.id = COSM_MSG_HEARTBEAT;
index 8a3e48ec37dd6622d40e04d63de33c7d0c45172c..7b2dddcdd46d5200421c4065e5480f5d6a0e1c29 100644 (file)
@@ -1328,7 +1328,7 @@ __scif_pollfd(struct file *f, poll_table *wait, struct scif_endpt *ep)
                        if (ep->state == SCIFEP_CONNECTED ||
                            ep->state == SCIFEP_DISCONNECTED ||
                            ep->conn_err)
-                               mask |= POLLOUT;
+                               mask |= EPOLLOUT;
                        goto exit;
                }
        }
@@ -1338,34 +1338,34 @@ __scif_pollfd(struct file *f, poll_table *wait, struct scif_endpt *ep)
                _scif_poll_wait(f, &ep->conwq, wait, ep);
                if (ep->state == SCIFEP_LISTENING) {
                        if (ep->conreqcnt)
-                               mask |= POLLIN;
+                               mask |= EPOLLIN;
                        goto exit;
                }
        }
 
        /* Endpoint is connected or disconnected */
        if (ep->state == SCIFEP_CONNECTED || ep->state == SCIFEP_DISCONNECTED) {
-               if (poll_requested_events(wait) & POLLIN)
+               if (poll_requested_events(wait) & EPOLLIN)
                        _scif_poll_wait(f, &ep->recvwq, wait, ep);
-               if (poll_requested_events(wait) & POLLOUT)
+               if (poll_requested_events(wait) & EPOLLOUT)
                        _scif_poll_wait(f, &ep->sendwq, wait, ep);
                if (ep->state == SCIFEP_CONNECTED ||
                    ep->state == SCIFEP_DISCONNECTED) {
                        /* Data can be read without blocking */
                        if (scif_rb_count(&ep->qp_info.qp->inbound_q, 1))
-                               mask |= POLLIN;
+                               mask |= EPOLLIN;
                        /* Data can be written without blocking */
                        if (scif_rb_space(&ep->qp_info.qp->outbound_q))
-                               mask |= POLLOUT;
-                       /* Return POLLHUP if endpoint is disconnected */
+                               mask |= EPOLLOUT;
+                       /* Return EPOLLHUP if endpoint is disconnected */
                        if (ep->state == SCIFEP_DISCONNECTED)
-                               mask |= POLLHUP;
+                               mask |= EPOLLHUP;
                        goto exit;
                }
        }
 
-       /* Return POLLERR if the endpoint is in none of the above states */
-       mask |= POLLERR;
+       /* Return EPOLLERR if the endpoint is in none of the above states */
+       mask |= EPOLLERR;
 exit:
        spin_unlock(&ep->lock);
        return mask;
@@ -1398,10 +1398,10 @@ scif_poll(struct scif_pollepd *ufds, unsigned int nfds, long timeout_msecs)
        pt = &table.pt;
        while (1) {
                for (i = 0; i < nfds; i++) {
-                       pt->_key = ufds[i].events | POLLERR | POLLHUP;
+                       pt->_key = ufds[i].events | EPOLLERR | EPOLLHUP;
                        mask = __scif_pollfd(ufds[i].epd->anon,
                                             pt, ufds[i].epd);
-                       mask &= ufds[i].events | POLLERR | POLLHUP;
+                       mask &= ufds[i].events | EPOLLERR | EPOLLHUP;
                        if (mask) {
                                count++;
                                pt->_qproc = NULL;
index 01d1f2ba7bb82116b7c11c3b0b50f408608c2b5d..cbc8ebcff5cfe19ae917ff1cfe3465930dc800b4 100644 (file)
@@ -1010,7 +1010,7 @@ __unlock_ret:
 }
 
 /*
- * We return POLLIN | POLLOUT from poll when new buffers are enqueued, and
+ * We return EPOLLIN | EPOLLOUT from poll when new buffers are enqueued, and
  * not when previously enqueued buffers may be available. This means that
  * in the card->host (TX) path, when userspace is unblocked by poll it
  * must drain all available descriptors or it can stall.
@@ -1022,15 +1022,15 @@ static __poll_t vop_poll(struct file *f, poll_table *wait)
 
        mutex_lock(&vdev->vdev_mutex);
        if (vop_vdev_inited(vdev)) {
-               mask = POLLERR;
+               mask = EPOLLERR;
                goto done;
        }
        poll_wait(f, &vdev->waitq, wait);
        if (vop_vdev_inited(vdev)) {
-               mask = POLLERR;
+               mask = EPOLLERR;
        } else if (vdev->poll_wake) {
                vdev->poll_wake = 0;
-               mask = POLLIN | POLLOUT;
+               mask = EPOLLIN | EPOLLOUT;
        }
 done:
        mutex_unlock(&vdev->vdev_mutex);
index c90c1a578d2f1a60e22c1300dd6e4c03501eb3e4..d9aa407db06a11acd4c369b993c242c6a5bac3bd 100644 (file)
@@ -215,9 +215,9 @@ static unsigned int afu_poll(struct file *file, struct poll_table_struct *wait)
        mutex_unlock(&ctx->status_mutex);
 
        if (afu_events_pending(ctx))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
        else if (closed)
-               mask = POLLERR;
+               mask = EPOLLERR;
 
        return mask;
 }
index 8fa68cf308e024074d01491e9e539c3a904a5e34..b084245f6238ed6b2c00b3db7b3059ff1591d0f0 100644 (file)
@@ -265,9 +265,9 @@ static __poll_t phantom_poll(struct file *file, poll_table *wait)
        poll_wait(file, &dev->wait, wait);
 
        if (!(dev->status & PHB_RUNNING))
-               mask = POLLERR;
+               mask = EPOLLERR;
        else if (atomic_read(&dev->counter))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
 
        pr_debug("phantom_poll end: %x/%d\n", mask, atomic_read(&dev->counter));
 
index 6640e765153393106a96983c07ef7003a9a8b9e2..83e0c95d20a47e4cfc7ad792882ceb66df481a7e 100644 (file)
@@ -182,7 +182,7 @@ static __poll_t vmci_host_poll(struct file *filp, poll_table *wait)
                if (context->pending_datagrams > 0 ||
                    vmci_handle_arr_get_size(
                                context->pending_doorbell_array) > 0) {
-                       mask = POLLIN;
+                       mask = EPOLLIN;
                }
                spin_unlock(&context->lock);
        }
index e412dfdda7ddd1682ed43ddcb69565d38b7d8d9a..377af43b81b3d7ab6aa73f6bec45c88a88b337e7 100644 (file)
@@ -2648,11 +2648,11 @@ static __poll_t ca8210_test_int_poll(
 
        poll_wait(filp, &priv->test.readq, ptable);
        if (!kfifo_is_empty(&priv->test.up_fifo))
-               return_flags |= (POLLIN | POLLRDNORM);
+               return_flags |= (EPOLLIN | EPOLLRDNORM);
        if (wait_event_interruptible(
                priv->test.readq,
                !kfifo_is_empty(&priv->test.up_fifo))) {
-               return POLLERR;
+               return EPOLLERR;
        }
        return return_flags;
 }
index ef6b2126b23a25c540d690e13391af3547b73940..255a5def56e941939e02642d0ee9868ec1fff5bd 100644 (file)
@@ -539,11 +539,11 @@ static __poll_t ppp_poll(struct file *file, poll_table *wait)
        if (!pf)
                return 0;
        poll_wait(file, &pf->rwait, wait);
-       mask = POLLOUT | POLLWRNORM;
+       mask = EPOLLOUT | EPOLLWRNORM;
        if (skb_peek(&pf->rq))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (pf->dead)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        else if (pf->kind == INTERFACE) {
                /* see comment in ppp_read */
                struct ppp *ppp = PF_TO_PPP(pf);
@@ -551,7 +551,7 @@ static __poll_t ppp_poll(struct file *file, poll_table *wait)
                ppp_recv_lock(ppp);
                if (ppp->n_channels == 0 &&
                    (ppp->flags & SC_LOOP_TRAFFIC) == 0)
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                ppp_recv_unlock(ppp);
        }
 
index 0a5ed004781cb6bdcce765f66c28a2821a3056b8..9b6cb780affec603f8200d258988785c5edf55a0 100644 (file)
@@ -377,7 +377,7 @@ rx_handler_result_t tap_handle_frame(struct sk_buff **pskb)
        }
 
 wake_up:
-       wake_up_interruptible_poll(sk_sleep(&q->sk), POLLIN | POLLRDNORM | POLLRDBAND);
+       wake_up_interruptible_poll(sk_sleep(&q->sk), EPOLLIN | EPOLLRDNORM | EPOLLRDBAND);
        return RX_HANDLER_CONSUMED;
 
 drop:
@@ -487,7 +487,7 @@ static void tap_sock_write_space(struct sock *sk)
 
        wqueue = sk_sleep(sk);
        if (wqueue && waitqueue_active(wqueue))
-               wake_up_interruptible_poll(wqueue, POLLOUT | POLLWRNORM | POLLWRBAND);
+               wake_up_interruptible_poll(wqueue, EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND);
 }
 
 static void tap_sock_destruct(struct sock *sk)
@@ -572,7 +572,7 @@ static int tap_release(struct inode *inode, struct file *file)
 static __poll_t tap_poll(struct file *file, poll_table *wait)
 {
        struct tap_queue *q = file->private_data;
-       __poll_t mask = POLLERR;
+       __poll_t mask = EPOLLERR;
 
        if (!q)
                goto out;
@@ -581,12 +581,12 @@ static __poll_t tap_poll(struct file *file, poll_table *wait)
        poll_wait(file, &q->wq.wait, wait);
 
        if (!ptr_ring_empty(&q->ring))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (sock_writeable(&q->sk) ||
            (!test_and_set_bit(SOCKWQ_ASYNC_NOSPACE, &q->sock.flags) &&
             sock_writeable(&q->sk)))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
 out:
        return mask;
index 17e496b88f8122b084c31aed6addadc1d68988e3..81e6cc951e7fc7c983919365c34842c34bcaedcf 100644 (file)
@@ -1437,7 +1437,7 @@ static __poll_t tun_chr_poll(struct file *file, poll_table *wait)
        __poll_t mask = 0;
 
        if (!tun)
-               return POLLERR;
+               return EPOLLERR;
 
        sk = tfile->socket.sk;
 
@@ -1446,16 +1446,16 @@ static __poll_t tun_chr_poll(struct file *file, poll_table *wait)
        poll_wait(file, sk_sleep(sk), wait);
 
        if (!ptr_ring_empty(&tfile->tx_ring))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (tun->dev->flags & IFF_UP &&
            (sock_writeable(sk) ||
             (!test_and_set_bit(SOCKWQ_ASYNC_NOSPACE, &sk->sk_socket->flags) &&
              sock_writeable(sk))))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        if (tun->dev->reg_state != NETREG_REGISTERED)
-               mask = POLLERR;
+               mask = EPOLLERR;
 
        tun_put(tun);
        return mask;
@@ -2310,8 +2310,8 @@ static void tun_sock_write_space(struct sock *sk)
 
        wqueue = sk_sleep(sk);
        if (wqueue && waitqueue_active(wqueue))
-               wake_up_interruptible_sync_poll(wqueue, POLLOUT |
-                                               POLLWRNORM | POLLWRBAND);
+               wake_up_interruptible_sync_poll(wqueue, EPOLLOUT |
+                                               EPOLLWRNORM | EPOLLWRBAND);
 
        tfile = container_of(sk, struct tun_file, sk);
        kill_fasync(&tfile->fasync, SIGIO, POLL_OUT);
index 72c55d1f8903e824c84cc5bf0187afd6aceee6b9..ac2572943ed085031307bc30cd0941dc8f611ad1 100644 (file)
@@ -309,7 +309,7 @@ static __poll_t rt2x00debug_poll_queue_dump(struct file *file,
        poll_wait(file, &intf->frame_dump_waitqueue, wait);
 
        if (!skb_queue_empty(&intf->frame_dump_skbqueue))
-               return POLLOUT | POLLWRNORM;
+               return EPOLLOUT | EPOLLWRNORM;
 
        return 0;
 }
index a60c0ab7883d1c187d8b3262cafba8a4b8182a00..47cd0c037433d1e4795a901b2ca3df4f58ee5cb6 100644 (file)
@@ -511,15 +511,15 @@ static __poll_t switchtec_dev_poll(struct file *filp, poll_table *wait)
        poll_wait(filp, &stdev->event_wq, wait);
 
        if (lock_mutex_and_test_alive(stdev))
-               return POLLIN | POLLRDHUP | POLLOUT | POLLERR | POLLHUP;
+               return EPOLLIN | EPOLLRDHUP | EPOLLOUT | EPOLLERR | EPOLLHUP;
 
        mutex_unlock(&stdev->mrpc_mutex);
 
        if (try_wait_for_completion(&stuser->comp))
-               ret |= POLLIN | POLLRDNORM;
+               ret |= EPOLLIN | EPOLLRDNORM;
 
        if (stuser->event_cnt != atomic_read(&stdev->event_cnt))
-               ret |= POLLPRI | POLLRDBAND;
+               ret |= EPOLLPRI | EPOLLRDBAND;
 
        return ret;
 }
index 5473e602f7e0f0943779b7db4c894e1be29a4596..0e88e18362c100435a9cd1e53606114819060877 100644 (file)
@@ -200,7 +200,7 @@ static __poll_t cros_ec_console_log_poll(struct file *file,
        if (CIRC_CNT(debug_info->log_buffer.head,
                     debug_info->log_buffer.tail,
                     LOG_SIZE))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        mutex_unlock(&debug_info->log_mutex);
 
        return mask;
index 999f1152655abb9e0154663f698b7e58dc670dfe..3e32a4c14d5fcabb2799ae0df22ee7525f29d2a7 100644 (file)
@@ -549,13 +549,13 @@ static __poll_t goldfish_pipe_poll(struct file *filp, poll_table *wait)
                return -ERESTARTSYS;
 
        if (status & PIPE_POLL_IN)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (status & PIPE_POLL_OUT)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        if (status & PIPE_POLL_HUP)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
-               mask |= POLLERR;
+               mask |= EPOLLERR;
 
        return mask;
 }
index a4fabf9d75f332a3464185316fff28a41a346cb5..b205b037fd61e6cb71eb16d5c0ee019569de71aa 100644 (file)
@@ -4128,7 +4128,7 @@ static __poll_t sonypi_misc_poll(struct file *file, poll_table *wait)
 {
        poll_wait(file, &sonypi_compat.fifo_proc_list, wait);
        if (kfifo_len(&sonypi_compat.fifo))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 1d42385b1aa55cba7084a68e264462e5c5fe555e..8febacb8fc54df3965cf53b64d040ea705bb68cf 100644 (file)
@@ -55,7 +55,7 @@ static __poll_t pps_cdev_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &pps->queue, wait);
 
-       return POLLIN | POLLRDNORM;
+       return EPOLLIN | EPOLLRDNORM;
 }
 
 static int pps_cdev_fasync(int fd, struct file *file, int on)
index a593b4cf47bf219995289f459c79f93557a4815a..767c485af59b2ee0583242b7dbf31581f76cb91a 100644 (file)
@@ -286,7 +286,7 @@ __poll_t ptp_poll(struct posix_clock *pc, struct file *fp, poll_table *wait)
 
        poll_wait(fp, &ptp->tsev_wq, wait);
 
-       return queue_cnt(&ptp->tsevq) ? POLLIN : 0;
+       return queue_cnt(&ptp->tsevq) ? EPOLLIN : 0;
 }
 
 #define EXTTS_BUFSIZE (PTP_BUF_TIMESTAMPS * sizeof(struct ptp_extts_event))
index 6092b3a5978e93d458158a69add379e5791c7255..cfb54e01d758fb240f1cb4f030873c7eba071e8a 100644 (file)
@@ -2325,7 +2325,7 @@ static __poll_t mport_cdev_poll(struct file *filp, poll_table *wait)
 
        poll_wait(filp, &priv->event_rx_wait, wait);
        if (kfifo_len(&priv->event_fifo))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 8428eba8cb73629b9aa608f7c2300b732218c643..92d0c6a7a837248252e112e1157d674aa6506f47 100644 (file)
@@ -967,7 +967,7 @@ static __poll_t qcom_smd_poll(struct rpmsg_endpoint *ept,
        poll_wait(filp, &channel->fblockread_event, wait);
 
        if (qcom_smd_get_tx_avail(channel) > 20)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        return mask;
 }
index e622fcda30faba193c084e5bfa7638f58a8033a5..64b6de9763ee2f92e7e615915ffcc16afeacb6c5 100644 (file)
@@ -262,12 +262,12 @@ static __poll_t rpmsg_eptdev_poll(struct file *filp, poll_table *wait)
        __poll_t mask = 0;
 
        if (!eptdev->ept)
-               return POLLERR;
+               return EPOLLERR;
 
        poll_wait(filp, &eptdev->readq, wait);
 
        if (!skb_queue_empty(&eptdev->queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        mask |= rpmsg_poll(eptdev->ept, filp, wait);
 
index 5a7b30d0773bc9d633fef1832aaf9f6011ec0be0..efa221e8bc22da4b60f788b48768f59ef5fff220 100644 (file)
@@ -203,7 +203,7 @@ static __poll_t rtc_dev_poll(struct file *file, poll_table *wait)
 
        data = rtc->irq_data;
 
-       return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
+       return (data != 0) ? (EPOLLIN | EPOLLRDNORM) : 0;
 }
 
 static long rtc_dev_ioctl(struct file *file,
index 0c075d100252b73382f910a172edf91108e09cee..fb2c3599d95c20e3d2cc7f400889e65aea6449c6 100644 (file)
@@ -671,7 +671,7 @@ static __poll_t dasd_eer_poll(struct file *filp, poll_table *ptable)
        poll_wait(filp, &dasd_eer_read_wait_queue, ptable);
        spin_lock_irqsave(&bufferlock, flags);
        if (eerb->head != eerb->tail)
-               mask = POLLIN | POLLRDNORM ;
+               mask = EPOLLIN | EPOLLRDNORM ;
        else
                mask = 0;
        spin_unlock_irqrestore(&bufferlock, flags);
index 956f662908a65320c40e16f0fbc2993922de4e5b..7bc616b253f1684b72c9dd8dc9286fa77456368f 100644 (file)
@@ -435,9 +435,9 @@ static __poll_t mon_poll(struct file *filp, struct poll_table_struct *p)
 
        poll_wait(filp, &mon_read_wait_queue, p);
        if (unlikely(atomic_read(&monpriv->iucv_severed)))
-               return POLLERR;
+               return EPOLLERR;
        if (atomic_read(&monpriv->read_ready))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 2791141bd03561553b93667bf6c01b2bd785ec30..a71ee67df0847721a98b2a2504a6a41f7e68bd44 100644 (file)
@@ -7041,7 +7041,7 @@ static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)
        poll_wait(file, &megasas_poll_wait, wait);
        spin_lock_irqsave(&poll_aen_lock, flags);
        if (megasas_poll_wait_aen)
-               mask = (POLLIN | POLLRDNORM);
+               mask = (EPOLLIN | EPOLLRDNORM);
        else
                mask = 0;
        megasas_poll_wait_aen = 0;
index 9cddc3074cd1563355c29b2f3571ed92fb8e2ea1..523971aeb4c171aa5baa60893e0e038313983cd0 100644 (file)
@@ -546,7 +546,7 @@ _ctl_poll(struct file *filep, poll_table *wait)
        list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
                if (ioc->aen_event_read_flag) {
                        spin_unlock(&gioc_lock);
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
                }
        }
        spin_unlock(&gioc_lock);
index 0c434453aab38386d6d0c2b727568141fc205aa1..c198b96368dd69beba2dcffbe16efe7a3c74ae1d 100644 (file)
@@ -1152,27 +1152,27 @@ sg_poll(struct file *filp, poll_table * wait)
 
        sfp = filp->private_data;
        if (!sfp)
-               return POLLERR;
+               return EPOLLERR;
        sdp = sfp->parentdp;
        if (!sdp)
-               return POLLERR;
+               return EPOLLERR;
        poll_wait(filp, &sfp->read_wait, wait);
        read_lock_irqsave(&sfp->rq_list_lock, iflags);
        list_for_each_entry(srp, &sfp->rq_list, entry) {
                /* if any read waiting, flag it */
                if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
-                       res = POLLIN | POLLRDNORM;
+                       res = EPOLLIN | EPOLLRDNORM;
                ++count;
        }
        read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
 
        if (atomic_read(&sdp->detaching))
-               res |= POLLHUP;
+               res |= EPOLLHUP;
        else if (!sfp->cmd_q) {
                if (0 == count)
-                       res |= POLLOUT | POLLWRNORM;
+                       res |= EPOLLOUT | EPOLLWRNORM;
        } else if (count < SG_MAX_QUEUE)
-               res |= POLLOUT | POLLWRNORM;
+               res |= EPOLLOUT | EPOLLWRNORM;
        SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
                                      "sg_poll: res=0x%x\n", (__force u32) res));
        return res;
index ef733847eebedac08410511c3aa6790e98656e3a..c13772a0df58a4191c8bba129b75eac49f87bee6 100644 (file)
@@ -2288,7 +2288,7 @@ static __poll_t comedi_poll(struct file *file, poll_table *wait)
                if (s->busy != file || !comedi_is_subdevice_running(s) ||
                    (s->async->cmd.flags & CMDF_WRITE) ||
                    comedi_buf_read_n_available(s) > 0)
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        s = comedi_file_write_subdevice(file);
@@ -2300,7 +2300,7 @@ static __poll_t comedi_poll(struct file *file, poll_table *wait)
                if (s->busy != file || !comedi_is_subdevice_running(s) ||
                    !(s->async->cmd.flags & CMDF_WRITE) ||
                    comedi_buf_write_n_available(s) >= bps)
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
 
 done:
index ab69eeb2c1f18d5eded92a1e956c5a449922d34f..b3f3b4a201af15e98aef01f3a8ff294566273c7d 100644 (file)
@@ -114,8 +114,8 @@ static void serial2002_tty_read_poll_wait(struct file *f, int timeout)
                __poll_t mask;
 
                mask = f->f_op->poll(f, &table.pt);
-               if (mask & (POLLRDNORM | POLLRDBAND | POLLIN |
-                           POLLHUP | POLLERR)) {
+               if (mask & (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |
+                           EPOLLHUP | EPOLLERR)) {
                        break;
                }
                now = ktime_get();
index 1993b03a6f2d6fdc40540a00959d65670aa41aca..e8bfe5520bc79cf6a041fa9dd3ba346850c64102 100644 (file)
@@ -37,7 +37,7 @@ module_param_named(loop, create_loop_dev, bool, 0644);
 /*
  * Threshold below which the tty is woken for writing
  * - should be equal to WAKEUP_CHARS in drivers/tty/n_tty.c because
- *   even if the writer is woken, n_tty_poll() won't set POLLOUT until
+ *   even if the writer is woken, n_tty_poll() won't set EPOLLOUT until
  *   our fifo is below this level
  */
 #define WAKEUP_CHARS             256
index c51610ce24af82fe534c56f846ef773238445a29..b82e2befe9355338295d3a3c237b0c5594c29cd5 100644 (file)
@@ -663,7 +663,7 @@ static int open_poll_files(struct loopback_test *t)
                        goto err;
                }
                read(t->fds[fds_idx].fd, &dummy, 1);
-               t->fds[fds_idx].events = POLLERR|POLLPRI;
+               t->fds[fds_idx].events = EPOLLERR|EPOLLPRI;
                t->fds[fds_idx].revents = 0;
                fds_idx++;
        }
@@ -756,7 +756,7 @@ static int wait_for_complete(struct loopback_test *t)
                }
 
                for (i = 0; i < t->poll_count; i++) {
-                       if (t->fds[i].revents & POLLPRI) {
+                       if (t->fds[i].revents & EPOLLPRI) {
                                /* Dummy read to clear the event */
                                read(t->fds[i].fd, &dummy, 1);
                                number_of_events++;
index f1d128b2dae9eac1f7ebc483b031966d7d3fe649..2f1e9ab3d6d0ff10c59a99f917567b5fd339ec52 100644 (file)
@@ -1749,16 +1749,16 @@ static __poll_t irda_poll(struct file * file, struct socket *sock,
 
        /* Exceptional events? */
        if (sk->sk_err)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        if (sk->sk_shutdown & RCV_SHUTDOWN) {
                pr_debug("%s(), POLLHUP\n", __func__);
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        }
 
        /* Readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue)) {
                pr_debug("Socket is readable\n");
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        /* Connection-based need to check for termination and startup */
@@ -1766,14 +1766,14 @@ static __poll_t irda_poll(struct file * file, struct socket *sock,
        case SOCK_STREAM:
                if (sk->sk_state == TCP_CLOSE) {
                        pr_debug("%s(), POLLHUP\n", __func__);
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                }
 
                if (sk->sk_state == TCP_ESTABLISHED) {
                        if ((self->tx_flow == FLOW_START) &&
                            sock_writeable(sk))
                        {
-                               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+                               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
                        }
                }
                break;
@@ -1781,12 +1781,12 @@ static __poll_t irda_poll(struct file * file, struct socket *sock,
                if ((self->tx_flow == FLOW_START) &&
                    sock_writeable(sk))
                {
-                       mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+                       mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
                }
                break;
        case SOCK_DGRAM:
                if (sock_writeable(sk))
-                       mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+                       mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
                break;
        default:
                break;
index 75bf9e34311d5c2cb52de8df650b843163022df8..c90a158af4b73de38a4ff06022169d388ceb6cba 100644 (file)
@@ -429,10 +429,10 @@ irnet_ctrl_poll(irnet_socket *    ap,
   DENTER(CTRL_TRACE, "(ap=0x%p)\n", ap);
 
   poll_wait(file, &irnet_events.rwait, wait);
-  mask = POLLOUT | POLLWRNORM;
+  mask = EPOLLOUT | EPOLLWRNORM;
   /* If there is unread events */
   if(ap->event_index != irnet_events.index)
-    mask |= POLLIN | POLLRDNORM;
+    mask |= EPOLLIN | EPOLLRDNORM;
 #ifdef INITIAL_DISCOVERY
   if(ap->disco_number != -1)
     {
@@ -441,7 +441,7 @@ irnet_ctrl_poll(irnet_socket *      ap,
        irnet_get_discovery_log(ap);
       /* Recheck */
       if(ap->disco_number != -1)
-       mask |= POLLIN | POLLRDNORM;
+       mask |= EPOLLIN | EPOLLRDNORM;
     }
 #endif /* INITIAL_DISCOVERY */
 
@@ -618,7 +618,7 @@ dev_irnet_poll(struct file *        file,
   DENTER(FS_TRACE, "(file=0x%p, ap=0x%p)\n",
         file, ap);
 
-  mask = POLLOUT | POLLWRNORM;
+  mask = EPOLLOUT | EPOLLWRNORM;
   DABORT(ap == NULL, mask, FS_ERROR, "ap is NULL !!!\n");
 
   /* If we are connected to ppp_generic, let it handle the job */
index 6657ebbe068a1da39e2034722b7d9cdd5b0bca9b..4f9f9dca5e6a1181324ba78e869d7f67681ef418 100644 (file)
@@ -1265,7 +1265,7 @@ static __poll_t atomisp_poll(struct file *file,
        rt_mutex_lock(&isp->mutex);
        if (pipe->capq.streaming != 1) {
                rt_mutex_unlock(&isp->mutex);
-               return POLLERR;
+               return EPOLLERR;
        }
        rt_mutex_unlock(&isp->mutex);
 
index 4ffff6f8b809cd685d1436eb36574b9c4364ae2e..06d1920150da352332e2d27bd5ae864ac2ad415b 100644 (file)
@@ -2183,7 +2183,7 @@ static __poll_t bcm2048_fops_poll(struct file *file,
        poll_wait(file, &bdev->read_queue, pts);
 
        if (bdev->rds_data_available)
-               retval = POLLIN | POLLRDNORM;
+               retval = EPOLLIN | EPOLLRDNORM;
 
        return retval;
 }
index c183489c4a1c59224cb18ae9396ecd56ef9eba5c..4d7fce8731fe6a50cf340fb6f120c24f86d4ac0a 100644 (file)
@@ -292,10 +292,10 @@ static __poll_t comp_poll(struct file *filp, poll_table *wait)
 
        if (c->cfg->direction == MOST_CH_RX) {
                if (!kfifo_is_empty(&c->fifo))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        } else {
                if (!kfifo_is_empty(&c->fifo) || ch_has_mbo(c))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
        return mask;
 }
index ef23e8524b1e07143d77bdb5c682b627987193f0..9d7e747519d9a51afa1061eb1590c4c75783c976 100644 (file)
@@ -213,7 +213,7 @@ static __poll_t comp_vdev_poll(struct file *filp, poll_table *wait)
        if (!data_ready(mdev))
                poll_wait(filp, &mdev->wait_data, wait);
        if (data_ready(mdev))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index 0e74d09e18ea3e1db8f997c28c4f68e016c67c42..0a1a7c259ab0aacdbbe278ab130508a5bdbde6c7 100644 (file)
@@ -325,7 +325,7 @@ static __poll_t softsynth_poll(struct file *fp, struct poll_table_struct *wait)
 
        spin_lock_irqsave(&speakup_info.spinlock, flags);
        if (!synth_buffer_empty() || speakup_info.flushing)
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
        spin_unlock_irqrestore(&speakup_info.spinlock, flags);
        return ret;
 }
index 3b3af7e0ce1c7730463ef356d9569fe81e4522d7..3b3e1f6632d71c1aae24d690679b4b53673ce148 100644 (file)
@@ -2477,11 +2477,11 @@ static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file,
        poll_wait(file, &tty->read_wait, wait);
        poll_wait(file, &tty->write_wait, wait);
        if (tty_hung_up_p(file))
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        if (gsm->dead)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        return mask;
 }
 
index 929434ebee5066a7b2ae2632aa8c7ba277023ff1..dabb391909aad63d9152e2cdd5dab35f73d1fe7e 100644 (file)
@@ -814,14 +814,14 @@ static __poll_t n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
 
                /* set bits for operations that won't block */
                if (!list_empty(&n_hdlc->rx_buf_list.list))
-                       mask |= POLLIN | POLLRDNORM;    /* readable */
+                       mask |= EPOLLIN | EPOLLRDNORM;  /* readable */
                if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                if (tty_hung_up_p(filp))
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                if (!tty_is_writelocked(tty) &&
                                !list_empty(&n_hdlc->tx_free_buf_list.list))
-                       mask |= POLLOUT | POLLWRNORM;   /* writable */
+                       mask |= EPOLLOUT | EPOLLWRNORM; /* writable */
        }
        return mask;
 }      /* end of n_hdlc_tty_poll() */
index e81d3db8ad6329df7d6d9d25e2c94e026fbaf67a..dbf1ab36758ebd6404e97a2fb0fbc4273f6c0460 100644 (file)
@@ -1223,7 +1223,7 @@ static __poll_t r3964_poll(struct tty_struct *tty, struct file *file,
        struct r3964_client_info *pClient;
        struct r3964_message *pMsg = NULL;
        unsigned long flags;
-       __poll_t result = POLLOUT;
+       __poll_t result = EPOLLOUT;
 
        TRACE_L("POLL");
 
@@ -1234,7 +1234,7 @@ static __poll_t r3964_poll(struct tty_struct *tty, struct file *file,
                pMsg = pClient->first_msg;
                spin_unlock_irqrestore(&pInfo->lock, flags);
                if (pMsg)
-                       result |= POLLIN | POLLRDNORM;
+                       result |= EPOLLIN | EPOLLRDNORM;
        } else {
                result = -EINVAL;
        }
index 478a9b40fd03968e650ec0752b10be63a4897cb8..5c0e59e8fe46b087b58b213d6ee04ecfc7f36e3a 100644 (file)
@@ -1344,7 +1344,7 @@ handle_newline:
                        put_tty_queue(c, ldata);
                        smp_store_release(&ldata->canon_head, ldata->read_head);
                        kill_fasync(&tty->fasync, SIGIO, POLL_IN);
-                       wake_up_interruptible_poll(&tty->read_wait, POLLIN);
+                       wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
                        return 0;
                }
        }
@@ -1625,7 +1625,7 @@ static void __receive_buf(struct tty_struct *tty, const unsigned char *cp,
 
        if (read_cnt(ldata)) {
                kill_fasync(&tty->fasync, SIGIO, POLL_IN);
-               wake_up_interruptible_poll(&tty->read_wait, POLLIN);
+               wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
        }
 }
 
@@ -2376,22 +2376,22 @@ static __poll_t n_tty_poll(struct tty_struct *tty, struct file *file,
        poll_wait(file, &tty->read_wait, wait);
        poll_wait(file, &tty->write_wait, wait);
        if (input_available_p(tty, 1))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        else {
                tty_buffer_flush_work(tty->port);
                if (input_available_p(tty, 1))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
        if (tty->packet && tty->link->ctrl_status)
-               mask |= POLLPRI | POLLIN | POLLRDNORM;
+               mask |= EPOLLPRI | EPOLLIN | EPOLLRDNORM;
        if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (tty_hung_up_p(file))
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (tty->ops->write && !tty_is_writelocked(tty) &&
                        tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
                        tty_write_room(tty) > 0)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 }
 
index 64338442050ef9d4e47e48edc72676159952090c..6c7151edd7155d2fda27046467d646e714af00e7 100644 (file)
@@ -344,7 +344,7 @@ static void pty_start(struct tty_struct *tty)
                tty->ctrl_status &= ~TIOCPKT_STOP;
                tty->ctrl_status |= TIOCPKT_START;
                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
-               wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
+               wake_up_interruptible_poll(&tty->link->read_wait, EPOLLIN);
        }
 }
 
@@ -357,7 +357,7 @@ static void pty_stop(struct tty_struct *tty)
                tty->ctrl_status &= ~TIOCPKT_START;
                tty->ctrl_status |= TIOCPKT_STOP;
                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
-               wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
+               wake_up_interruptible_poll(&tty->link->read_wait, EPOLLIN);
        }
 }
 
index 6a89835453d3b73668817c7f6c2a04dad89b599c..eb9133b472f4849e831fd1a4a1c70cf6e917ba28 100644 (file)
@@ -445,7 +445,7 @@ static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
 /* No kernel lock held - none needed ;) */
 static __poll_t hung_up_tty_poll(struct file *filp, poll_table *wait)
 {
-       return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
+       return EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | EPOLLWRNORM;
 }
 
 static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
@@ -533,7 +533,7 @@ void tty_wakeup(struct tty_struct *tty)
                        tty_ldisc_deref(ld);
                }
        }
-       wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
+       wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
 }
 
 EXPORT_SYMBOL_GPL(tty_wakeup);
@@ -867,7 +867,7 @@ static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
 static void tty_write_unlock(struct tty_struct *tty)
 {
        mutex_unlock(&tty->atomic_write_lock);
-       wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
+       wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
 }
 
 static int tty_write_lock(struct tty_struct *tty, int ndelay)
@@ -1667,21 +1667,21 @@ int tty_release(struct inode *inode, struct file *filp)
 
                if (tty->count <= 1) {
                        if (waitqueue_active(&tty->read_wait)) {
-                               wake_up_poll(&tty->read_wait, POLLIN);
+                               wake_up_poll(&tty->read_wait, EPOLLIN);
                                do_sleep++;
                        }
                        if (waitqueue_active(&tty->write_wait)) {
-                               wake_up_poll(&tty->write_wait, POLLOUT);
+                               wake_up_poll(&tty->write_wait, EPOLLOUT);
                                do_sleep++;
                        }
                }
                if (o_tty && o_tty->count <= 1) {
                        if (waitqueue_active(&o_tty->read_wait)) {
-                               wake_up_poll(&o_tty->read_wait, POLLIN);
+                               wake_up_poll(&o_tty->read_wait, EPOLLIN);
                                do_sleep++;
                        }
                        if (waitqueue_active(&o_tty->write_wait)) {
-                               wake_up_poll(&o_tty->write_wait, POLLOUT);
+                               wake_up_poll(&o_tty->write_wait, EPOLLOUT);
                                do_sleep++;
                        }
                }
index 4e7946c0484bf94b7e049d87b28cde6b2dcbccf2..050f4d650891763f96800244869821afb9d1586e 100644 (file)
@@ -735,8 +735,8 @@ void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
                tty_ldisc_deref(ld);
        }
 
-       wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
-       wake_up_interruptible_poll(&tty->read_wait, POLLIN);
+       wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
+       wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
 
        /*
         * Shutdown the current line discipline, and reset it to
index 3e64ccd0040f8e17f4089ead6d0678d4dcadb496..e4a66e1fd05fb9a91076e83d922e2dd3859935b8 100644 (file)
@@ -563,7 +563,7 @@ static __poll_t
 vcs_poll(struct file *file, poll_table *wait)
 {
        struct vcs_poll_data *poll = vcs_poll_data_get(file);
-       __poll_t ret = DEFAULT_POLLMASK|POLLERR|POLLPRI;
+       __poll_t ret = DEFAULT_POLLMASK|EPOLLERR|EPOLLPRI;
 
        if (poll) {
                poll_wait(file, &poll->waitq, wait);
index 85bc1aaea4a42e65fa9944f66e7065775b7c2212..fd4848392e0ddfddbdf5d57888c6aa056087b23b 100644 (file)
@@ -506,7 +506,7 @@ static __poll_t uio_poll(struct file *filep, poll_table *wait)
 
        poll_wait(filep, &idev->wait, wait);
        if (listener->event_count != atomic_read(&idev->event))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 9627ea6ec3aea1c980170d8a2814700d3c5dbd5d..a0d284ef3f40ad369cc34f093bb15723124ef4a2 100644 (file)
@@ -603,16 +603,16 @@ static __poll_t wdm_poll(struct file *file, struct poll_table_struct *wait)
 
        spin_lock_irqsave(&desc->iuspin, flags);
        if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
-               mask = POLLHUP | POLLERR;
+               mask = EPOLLHUP | EPOLLERR;
                spin_unlock_irqrestore(&desc->iuspin, flags);
                goto desc_out;
        }
        if (test_bit(WDM_READ, &desc->flags))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
        if (desc->rerr || desc->werr)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        if (!test_bit(WDM_IN_USE, &desc->flags))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        spin_unlock_irqrestore(&desc->iuspin, flags);
 
        poll_wait(file, &desc->wait, wait);
index 425247b7f7281dc41432ddae51d0c33f69b11e01..d058d7a31e7c35a32259e81e8136ce3280df3b0c 100644 (file)
@@ -479,8 +479,8 @@ static __poll_t usblp_poll(struct file *file, struct poll_table_struct *wait)
        poll_wait(file, &usblp->rwait, wait);
        poll_wait(file, &usblp->wwait, wait);
        spin_lock_irqsave(&usblp->lock, flags);
-       ret = ((usblp->bidir && usblp->rcomplete) ? POLLIN  | POLLRDNORM : 0) |
-          ((usblp->no_paper || usblp->wcomplete) ? POLLOUT | POLLWRNORM : 0);
+       ret = ((usblp->bidir && usblp->rcomplete) ? EPOLLIN  | EPOLLRDNORM : 0) |
+          ((usblp->no_paper || usblp->wcomplete) ? EPOLLOUT | EPOLLWRNORM : 0);
        spin_unlock_irqrestore(&usblp->lock, flags);
        return ret;
 }
index 7ea67a55be103804c026889cd1275492de955fa5..bdb1de0c0cef6f41bf9b9e982608d0f48b62da07 100644 (file)
@@ -1265,13 +1265,13 @@ static __poll_t usbtmc_poll(struct file *file, poll_table *wait)
        mutex_lock(&data->io_mutex);
 
        if (data->zombie) {
-               mask = POLLHUP | POLLERR;
+               mask = EPOLLHUP | EPOLLERR;
                goto no_poll;
        }
 
        poll_wait(file, &data->waitq, wait);
 
-       mask = (atomic_read(&data->srq_asserted)) ? POLLIN | POLLRDNORM : 0;
+       mask = (atomic_read(&data->srq_asserted)) ? EPOLLIN | EPOLLRDNORM : 0;
 
 no_poll:
        mutex_unlock(&data->io_mutex);
index e2cec448779e499c257bbb57dc2c7aed956ad4d7..3de3c750b5f6e01414d84e1579c001a36e53e478 100644 (file)
@@ -632,7 +632,7 @@ static __poll_t usb_device_poll(struct file *file,
        event_count = atomic_read(&device_event.count);
        if (file->f_version != event_count) {
                file->f_version = event_count;
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        }
 
        return 0;
index bf00166cbee01202736d1525c513d527c31fa6e4..d526595bc959c495b4578be386822ddd1ab62365 100644 (file)
@@ -2578,11 +2578,11 @@ static __poll_t usbdev_poll(struct file *file,
 
        poll_wait(file, &ps->wait, wait);
        if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        if (!connected(ps))
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (list_empty(&ps->list))
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        return mask;
 }
 
index 67564725e3710a48bc8ca9c6d4e37bfc459aa6b4..8f2cf3baa19c10676915acbf4406a474e2e3e2a2 100644 (file)
@@ -644,7 +644,7 @@ static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
 static __poll_t ffs_ep0_poll(struct file *file, poll_table *wait)
 {
        struct ffs_data *ffs = file->private_data;
-       __poll_t mask = POLLWRNORM;
+       __poll_t mask = EPOLLWRNORM;
        int ret;
 
        poll_wait(file, &ffs->ev.waitq, wait);
@@ -656,19 +656,19 @@ static __poll_t ffs_ep0_poll(struct file *file, poll_table *wait)
        switch (ffs->state) {
        case FFS_READ_DESCRIPTORS:
        case FFS_READ_STRINGS:
-               mask |= POLLOUT;
+               mask |= EPOLLOUT;
                break;
 
        case FFS_ACTIVE:
                switch (ffs->setup_state) {
                case FFS_NO_SETUP:
                        if (ffs->ev.count)
-                               mask |= POLLIN;
+                               mask |= EPOLLIN;
                        break;
 
                case FFS_SETUP_PENDING:
                case FFS_SETUP_CANCELLED:
-                       mask |= (POLLIN | POLLOUT);
+                       mask |= (EPOLLIN | EPOLLOUT);
                        break;
                }
        case FFS_CLOSING:
index a73efb1c47d0aeadc473c4dc9591a845fe8a43a9..54e859dcb25c3c136795ce605ee50dac47c54d0a 100644 (file)
@@ -422,10 +422,10 @@ static __poll_t f_hidg_poll(struct file *file, poll_table *wait)
        poll_wait(file, &hidg->write_queue, wait);
 
        if (WRITE_COND)
-               ret |= POLLOUT | POLLWRNORM;
+               ret |= EPOLLOUT | EPOLLWRNORM;
 
        if (READ_COND)
-               ret |= POLLIN | POLLRDNORM;
+               ret |= EPOLLIN | EPOLLRDNORM;
 
        return ret;
 }
index 453578c4af696a33cb5c2fb15261ceb2d0be9c80..d359efe06c769d9f63235c4b562dbe2f97d97e04 100644 (file)
@@ -698,11 +698,11 @@ printer_poll(struct file *fd, poll_table *wait)
 
        spin_lock_irqsave(&dev->lock, flags);
        if (likely(!list_empty(&dev->tx_reqs)))
-               status |= POLLOUT | POLLWRNORM;
+               status |= EPOLLOUT | EPOLLWRNORM;
 
        if (likely(dev->current_rx_bytes) ||
                        likely(!list_empty(&dev->rx_buffers)))
-               status |= POLLIN | POLLRDNORM;
+               status |= EPOLLIN | EPOLLRDNORM;
 
        spin_unlock_irqrestore(&dev->lock, flags);
 
index 5960e76f4c751173cb2bc93d43bba0083f8fc40b..37ca0e669bd85401c2337d75aa888ea5f9772d0d 100644 (file)
@@ -1225,16 +1225,16 @@ ep0_poll (struct file *fd, poll_table *wait)
        /* report fd mode change before acting on it */
        if (dev->setup_abort) {
                dev->setup_abort = 0;
-               mask = POLLHUP;
+               mask = EPOLLHUP;
                goto out;
        }
 
        if (dev->state == STATE_DEV_SETUP) {
                if (dev->setup_in || dev->setup_can_stall)
-                       mask = POLLOUT;
+                       mask = EPOLLOUT;
        } else {
                if (dev->ev_next != 0)
-                       mask = POLLIN;
+                       mask = EPOLLIN;
        }
 out:
        spin_unlock_irq(&dev->lock);
index 1fa00b35f4adb8e8d50f021e54d3ec37c11d34b3..8d33187ce2af3a790e12fb7108a962bfbf244479 100644 (file)
@@ -683,19 +683,19 @@ static __poll_t iowarrior_poll(struct file *file, poll_table * wait)
        __poll_t mask = 0;
 
        if (!dev->present)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        poll_wait(file, &dev->read_wait, wait);
        poll_wait(file, &dev->write_wait, wait);
 
        if (!dev->present)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        if (read_index(dev) != -1)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (atomic_read(&dev->write_busy) < MAX_WRITES_IN_FLIGHT)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 }
 
index 074398c1e410f14522fcc64ec3d20f2783c7da94..63b9e85dc0e9365254bc8752a833fd6fd1ba24dd 100644 (file)
@@ -417,15 +417,15 @@ static __poll_t ld_usb_poll(struct file *file, poll_table *wait)
        dev = file->private_data;
 
        if (!dev->intf)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        poll_wait(file, &dev->read_wait, wait);
        poll_wait(file, &dev->write_wait, wait);
 
        if (dev->ring_head != dev->ring_tail)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (!dev->interrupt_out_busy)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        return mask;
 }
index 941c45028828d49f06e38513169009ee7b264084..bf47bd8bc76f7e49349b12f1e0a74d0e51e9934e 100644 (file)
@@ -517,17 +517,17 @@ static __poll_t tower_poll (struct file *file, poll_table *wait)
        dev = file->private_data;
 
        if (!dev->udev)
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        poll_wait(file, &dev->read_wait, wait);
        poll_wait(file, &dev->write_wait, wait);
 
        tower_check_for_read_packet(dev);
        if (dev->read_packet_length > 0) {
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        }
        if (!dev->interrupt_out_busy) {
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        }
 
        return mask;
index cc5b296bff3fd80c399e58bc6cc72ca47282c464..2761fad66b95e6c5fe38adf4605535a895ec9e4a 100644 (file)
@@ -1203,7 +1203,7 @@ mon_bin_poll(struct file *file, struct poll_table_struct *wait)
 
        spin_lock_irqsave(&rp->b_lock, flags);
        if (!MON_RING_EMPTY(rp))
-               mask |= POLLIN | POLLRDNORM;    /* readable */
+               mask |= EPOLLIN | EPOLLRDNORM;    /* readable */
        spin_unlock_irqrestore(&rp->b_lock, flags);
        return mask;
 }
index 8cc4b48ff1273db3b6a7f3cb3607b7fae8debf78..085700f1be100c7c4dd2787efb33bcbf33e59f8f 100644 (file)
@@ -48,7 +48,7 @@ static int virqfd_wakeup(wait_queue_entry_t *wait, unsigned mode, int sync, void
        struct virqfd *virqfd = container_of(wait, struct virqfd, wait);
        __poll_t flags = key_to_poll(key);
 
-       if (flags & POLLIN) {
+       if (flags & EPOLLIN) {
                /* An event has been signaled, call function */
                if ((!virqfd->handler ||
                     virqfd->handler(virqfd->opaque, virqfd->data)) &&
@@ -56,7 +56,7 @@ static int virqfd_wakeup(wait_queue_entry_t *wait, unsigned mode, int sync, void
                        schedule_work(&virqfd->inject);
        }
 
-       if (flags & POLLHUP) {
+       if (flags & EPOLLHUP) {
                unsigned long flags;
                spin_lock_irqsave(&virqfd_lock, flags);
 
@@ -172,14 +172,14 @@ int vfio_virqfd_enable(void *opaque,
         * Check if there was an event already pending on the eventfd
         * before we registered and trigger it as if we didn't miss it.
         */
-       if (events & POLLIN) {
+       if (events & EPOLLIN) {
                if ((!handler || handler(opaque, data)) && thread)
                        schedule_work(&virqfd->inject);
        }
 
        /*
         * Do not drop the file until the irqfd is fully initialized,
-        * otherwise we might race against the POLLHUP.
+        * otherwise we might race against the EPOLLHUP.
         */
        fdput(irqfd);
 
index c613d2e3d371cdef615e3c04548557a1efa9f3dc..610cba276d4762a2b69d90a49dc0f846c6822835 100644 (file)
@@ -952,8 +952,8 @@ static int vhost_net_open(struct inode *inode, struct file *f)
        }
        vhost_dev_init(dev, vqs, VHOST_NET_VQ_MAX);
 
-       vhost_poll_init(n->poll + VHOST_NET_VQ_TX, handle_tx_net, POLLOUT, dev);
-       vhost_poll_init(n->poll + VHOST_NET_VQ_RX, handle_rx_net, POLLIN, dev);
+       vhost_poll_init(n->poll + VHOST_NET_VQ_TX, handle_tx_net, EPOLLOUT, dev);
+       vhost_poll_init(n->poll + VHOST_NET_VQ_RX, handle_rx_net, EPOLLIN, dev);
 
        f->private_data = n;
 
index 2db5af8e8652aebacc7a58dbcd67281262e967ea..1b3e8d2d5c8b44442616c1ee6fa9f7bf455b456d 100644 (file)
@@ -211,7 +211,7 @@ int vhost_poll_start(struct vhost_poll *poll, struct file *file)
        mask = file->f_op->poll(file, &poll->table);
        if (mask)
                vhost_poll_wakeup(&poll->wait, 0, 0, poll_to_key(mask));
-       if (mask & POLLERR) {
+       if (mask & EPOLLERR) {
                if (poll->wqh)
                        remove_wait_queue(poll->wqh, &poll->wait);
                ret = -EINVAL;
@@ -440,7 +440,7 @@ void vhost_dev_init(struct vhost_dev *dev,
                vhost_vq_reset(dev, vq);
                if (vq->handle_kick)
                        vhost_poll_init(&vq->poll, vq->handle_kick,
-                                       POLLIN, dev);
+                                       EPOLLIN, dev);
        }
 }
 EXPORT_SYMBOL_GPL(vhost_dev_init);
@@ -630,7 +630,7 @@ void vhost_dev_cleanup(struct vhost_dev *dev)
        vhost_umem_clean(dev->iotlb);
        dev->iotlb = NULL;
        vhost_clear_msg(dev);
-       wake_up_interruptible_poll(&dev->wait, POLLIN | POLLRDNORM);
+       wake_up_interruptible_poll(&dev->wait, EPOLLIN | EPOLLRDNORM);
        WARN_ON(!llist_empty(&dev->work_list));
        if (dev->worker) {
                kthread_stop(dev->worker);
@@ -1057,7 +1057,7 @@ __poll_t vhost_chr_poll(struct file *file, struct vhost_dev *dev,
        poll_wait(file, &dev->wait, wait);
 
        if (!list_empty(&dev->read_list))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
@@ -2356,7 +2356,7 @@ void vhost_enqueue_msg(struct vhost_dev *dev, struct list_head *head,
        list_add_tail(&node->node, head);
        spin_unlock(&dev->iotlb_lock);
 
-       wake_up_interruptible_poll(&dev->wait, POLLIN | POLLRDNORM);
+       wake_up_interruptible_poll(&dev->wait, EPOLLIN | EPOLLRDNORM);
 }
 EXPORT_SYMBOL_GPL(vhost_enqueue_msg);
 
index b0597bef45551bbc0b657cd32975c03b96e45ce1..4e05d7f711fefede62fe047ffcfda573dc8f67c7 100644 (file)
@@ -574,7 +574,7 @@ static __poll_t fsl_hv_poll(struct file *filp, struct poll_table_struct *p)
        spin_lock_irqsave(&dbq->lock, flags);
 
        poll_wait(filp, &dbq->wait, p);
-       mask = (dbq->head == dbq->tail) ? 0 : (POLLIN | POLLRDNORM);
+       mask = (dbq->head == dbq->tail) ? 0 : (EPOLLIN | EPOLLRDNORM);
 
        spin_unlock_irqrestore(&dbq->lock, flags);
 
index 72c0416a01cc39003251402f1b152705c7ae7c9e..8cac07ab60abd4bc2c200be8bfd63fc5aa70b477 100644 (file)
@@ -623,14 +623,14 @@ static long evtchn_ioctl(struct file *file,
 
 static __poll_t evtchn_poll(struct file *file, poll_table *wait)
 {
-       __poll_t mask = POLLOUT | POLLWRNORM;
+       __poll_t mask = EPOLLOUT | EPOLLWRNORM;
        struct per_user_data *u = file->private_data;
 
        poll_wait(file, &u->evtchn_wait, wait);
        if (u->ring_cons != u->ring_prod)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (u->ring_overflow)
-               mask = POLLERR;
+               mask = EPOLLERR;
        return mask;
 }
 
index 9ade533d9e406e2bf835fadca4ddcace46f351c1..262835ace35d42c983bbff50d034316c7a53aade 100644 (file)
@@ -144,7 +144,7 @@ static __poll_t xen_mce_chrdev_poll(struct file *file, poll_table *wait)
        poll_wait(file, &xen_mce_chrdev_wait, wait);
 
        if (xen_mcelog.next)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 78804e71f9a6bfec8ef8afac860c25bce6de2fc7..753d9cb437d02597aa07452dabaac64263d35691 100644 (file)
@@ -892,7 +892,7 @@ static __poll_t pvcalls_front_poll_passive(struct file *file,
 
                if (req_id != PVCALLS_INVALID_ID &&
                    READ_ONCE(bedata->rsp[req_id].req_id) == req_id)
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
 
                poll_wait(file, &map->passive.inflight_accept_req, wait);
                return 0;
@@ -900,7 +900,7 @@ static __poll_t pvcalls_front_poll_passive(struct file *file,
 
        if (test_and_clear_bit(PVCALLS_FLAG_POLL_RET,
                               (void *)&map->passive.flags))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        /*
         * First check RET, then INFLIGHT. No barriers necessary to
@@ -949,11 +949,11 @@ static __poll_t pvcalls_front_poll_active(struct file *file,
 
        poll_wait(file, &map->active.inflight_conn_req, wait);
        if (pvcalls_front_write_todo(map))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        if (pvcalls_front_read_todo(map))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (in_error != 0 || out_error != 0)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
 
        return mask;
 }
@@ -968,14 +968,14 @@ __poll_t pvcalls_front_poll(struct file *file, struct socket *sock,
        pvcalls_enter();
        if (!pvcalls_front_dev) {
                pvcalls_exit();
-               return POLLNVAL;
+               return EPOLLNVAL;
        }
        bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
 
        map = (struct sock_mapping *) sock->sk->sk_send_head;
        if (!map) {
                pvcalls_exit();
-               return POLLNVAL;
+               return EPOLLNVAL;
        }
        if (map->active_socket)
                ret = pvcalls_front_poll_active(file, bedata, map, wait);
index e17ec3fce590e0e2d3595e49cc7b8b144da07c0c..a493e99bed2131a33afc65e50110f5e0ff6d5244 100644 (file)
@@ -651,7 +651,7 @@ static __poll_t xenbus_file_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &u->read_waitq, wait);
        if (!list_empty(&u->read_buffers))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 7edbd0679952080109d8ac7eaf4df23067d266f2..3fdee214a5bbca7ffe1ab9fcc90c540dc5f7c158 100644 (file)
@@ -289,7 +289,7 @@ found_command:
 
 /*
  * poll for culling state
- * - use POLLOUT to indicate culling state
+ * - use EPOLLOUT to indicate culling state
  */
 static __poll_t cachefiles_daemon_poll(struct file *file,
                                           struct poll_table_struct *poll)
@@ -301,10 +301,10 @@ static __poll_t cachefiles_daemon_poll(struct file *file,
        mask = 0;
 
        if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        if (test_bit(CACHEFILES_CULLING, &cache->flags))
-               mask |= POLLOUT;
+               mask |= EPOLLOUT;
 
        return mask;
 }
index 80b9b84391a9db589a86cd50fdec8c3998fa2b7a..c5234c21b539405a452417ce4d9cb9e977186637 100644 (file)
@@ -64,12 +64,12 @@ static struct class *coda_psdev_class;
 static __poll_t coda_psdev_poll(struct file *file, poll_table * wait)
 {
         struct venus_comm *vcp = (struct venus_comm *) file->private_data;
-       __poll_t mask = POLLOUT | POLLWRNORM;
+       __poll_t mask = EPOLLOUT | EPOLLWRNORM;
 
        poll_wait(file, &vcp->vc_waitq, wait);
        mutex_lock(&vcp->vc_mutex);
        if (!list_empty(&vcp->vc_pending))
-                mask |= POLLIN | POLLRDNORM;
+                mask |= EPOLLIN | EPOLLRDNORM;
        mutex_unlock(&vcp->vc_mutex);
 
        return mask;
index 20bb73a931dd2ec877da89751434ae30937b23f8..1f99678ff5d3ed67d52740c8e89ab95f8e87abab 100644 (file)
@@ -214,7 +214,7 @@ static __poll_t full_proxy_poll(struct file *filp,
        const struct file_operations *real_fops;
 
        if (debugfs_file_get(dentry))
-               return POLLHUP;
+               return EPOLLHUP;
 
        real_fops = debugfs_real_fops(filp);
        r = real_fops->poll(filp, wait);
index a4c63e9e638545a916fd1d25ed8058e1d77acad9..c7d5a2ea3d030ed37e1c35441d6a24fdc065c1cd 100644 (file)
@@ -471,7 +471,7 @@ static __poll_t dev_poll(struct file *file, poll_table *wait)
 
        spin_lock(&ops_lock);
        if (!list_empty(&send_list))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
        spin_unlock(&ops_lock);
 
        return mask;
index 662432af8ce8845dd303975a49df3b7e62e32e2d..2a669390cd7f64ce3c42e96cdba05017e82ea193 100644 (file)
@@ -896,7 +896,7 @@ static __poll_t device_poll(struct file *file, poll_table *wait)
        spin_lock(&proc->asts_spin);
        if (!list_empty(&proc->asts)) {
                spin_unlock(&proc->asts_spin);
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        }
        spin_unlock(&proc->asts_spin);
        return 0;
index 7423e792a092eb13c36da4809331eebaad32f23c..2d1158e5f9505bfb9e2f9231bd221c487db15052 100644 (file)
@@ -59,7 +59,7 @@ ecryptfs_miscdev_poll(struct file *file, poll_table *pt)
        poll_wait(file, &daemon->wait, pt);
        mutex_lock(&daemon->mux);
        if (!list_empty(&daemon->msg_ctx_out_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 out_unlock_daemon:
        daemon->flags &= ~ECRYPTFS_DAEMON_IN_POLL;
        mutex_unlock(&daemon->mux);
index 04fd824142a12b606015281ac79a15f30a68012c..012f5bd46dfa1485b612620b1f54ff86f87d266d 100644 (file)
@@ -45,7 +45,7 @@ struct eventfd_ctx {
  *
  * This function is supposed to be called by the kernel in paths that do not
  * allow sleeping. In this function we allow the counter to reach the ULLONG_MAX
- * value, and we signal this as overflow condition by returning a POLLERR
+ * value, and we signal this as overflow condition by returning a EPOLLERR
  * to poll(2).
  *
  * Returns the amount by which the counter was incremented.  This will be less
@@ -60,7 +60,7 @@ __u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n)
                n = ULLONG_MAX - ctx->count;
        ctx->count += n;
        if (waitqueue_active(&ctx->wqh))
-               wake_up_locked_poll(&ctx->wqh, POLLIN);
+               wake_up_locked_poll(&ctx->wqh, EPOLLIN);
        spin_unlock_irqrestore(&ctx->wqh.lock, flags);
 
        return n;
@@ -96,7 +96,7 @@ static int eventfd_release(struct inode *inode, struct file *file)
 {
        struct eventfd_ctx *ctx = file->private_data;
 
-       wake_up_poll(&ctx->wqh, POLLHUP);
+       wake_up_poll(&ctx->wqh, EPOLLHUP);
        eventfd_ctx_put(ctx);
        return 0;
 }
@@ -150,11 +150,11 @@ static __poll_t eventfd_poll(struct file *file, poll_table *wait)
        count = READ_ONCE(ctx->count);
 
        if (count > 0)
-               events |= POLLIN;
+               events |= EPOLLIN;
        if (count == ULLONG_MAX)
-               events |= POLLERR;
+               events |= EPOLLERR;
        if (ULLONG_MAX - 1 > count)
-               events |= POLLOUT;
+               events |= EPOLLOUT;
 
        return events;
 }
@@ -187,7 +187,7 @@ int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *w
        eventfd_ctx_do_read(ctx, cnt);
        __remove_wait_queue(&ctx->wqh, wait);
        if (*cnt != 0 && waitqueue_active(&ctx->wqh))
-               wake_up_locked_poll(&ctx->wqh, POLLOUT);
+               wake_up_locked_poll(&ctx->wqh, EPOLLOUT);
        spin_unlock_irqrestore(&ctx->wqh.lock, flags);
 
        return *cnt != 0 ? 0 : -EAGAIN;
@@ -231,7 +231,7 @@ static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count,
        if (likely(res > 0)) {
                eventfd_ctx_do_read(ctx, &ucnt);
                if (waitqueue_active(&ctx->wqh))
-                       wake_up_locked_poll(&ctx->wqh, POLLOUT);
+                       wake_up_locked_poll(&ctx->wqh, EPOLLOUT);
        }
        spin_unlock_irq(&ctx->wqh.lock);
 
@@ -281,7 +281,7 @@ static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t c
        if (likely(res > 0)) {
                ctx->count += ucnt;
                if (waitqueue_active(&ctx->wqh))
-                       wake_up_locked_poll(&ctx->wqh, POLLIN);
+                       wake_up_locked_poll(&ctx->wqh, EPOLLIN);
        }
        spin_unlock_irq(&ctx->wqh.lock);
 
index d1a490c7e6c3c83b3a6539b99d8e9181bc28542a..0f3494ed3ed0cf17f0bc7c7148c312512abb32b4 100644 (file)
@@ -95,9 +95,9 @@
 /* Epoll private bits inside the event mask */
 #define EP_PRIVATE_BITS (EPOLLWAKEUP | EPOLLONESHOT | EPOLLET | EPOLLEXCLUSIVE)
 
-#define EPOLLINOUT_BITS (POLLIN | POLLOUT)
+#define EPOLLINOUT_BITS (EPOLLIN | EPOLLOUT)
 
-#define EPOLLEXCLUSIVE_OK_BITS (EPOLLINOUT_BITS | POLLERR | POLLHUP | \
+#define EPOLLEXCLUSIVE_OK_BITS (EPOLLINOUT_BITS | EPOLLERR | EPOLLHUP | \
                                EPOLLWAKEUP | EPOLLET | EPOLLEXCLUSIVE)
 
 /* Maximum number of nesting allowed inside epoll sets */
@@ -555,7 +555,7 @@ static int ep_poll_wakeup_proc(void *priv, void *cookie, int call_nests)
        wait_queue_head_t *wqueue = (wait_queue_head_t *)cookie;
 
        spin_lock_irqsave_nested(&wqueue->lock, flags, call_nests + 1);
-       wake_up_locked_poll(wqueue, POLLIN);
+       wake_up_locked_poll(wqueue, EPOLLIN);
        spin_unlock_irqrestore(&wqueue->lock, flags);
 
        return 0;
@@ -575,7 +575,7 @@ static void ep_poll_safewake(wait_queue_head_t *wq)
 
 static void ep_poll_safewake(wait_queue_head_t *wq)
 {
-       wake_up_poll(wq, POLLIN);
+       wake_up_poll(wq, EPOLLIN);
 }
 
 #endif
@@ -908,7 +908,7 @@ static __poll_t ep_read_events_proc(struct eventpoll *ep, struct list_head *head
 
        list_for_each_entry_safe(epi, tmp, head, rdllink) {
                if (ep_item_poll(epi, &pt, depth)) {
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
                } else {
                        /*
                         * Item has been dropped into the ready list by the poll
@@ -1181,12 +1181,12 @@ static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, v
                if ((epi->event.events & EPOLLEXCLUSIVE) &&
                                        !(pollflags & POLLFREE)) {
                        switch (pollflags & EPOLLINOUT_BITS) {
-                       case POLLIN:
-                               if (epi->event.events & POLLIN)
+                       case EPOLLIN:
+                               if (epi->event.events & EPOLLIN)
                                        ewake = 1;
                                break;
-                       case POLLOUT:
-                               if (epi->event.events & POLLOUT)
+                       case EPOLLOUT:
+                               if (epi->event.events & EPOLLOUT)
                                        ewake = 1;
                                break;
                        case 0:
@@ -2105,7 +2105,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
        switch (op) {
        case EPOLL_CTL_ADD:
                if (!epi) {
-                       epds.events |= POLLERR | POLLHUP;
+                       epds.events |= EPOLLERR | EPOLLHUP;
                        error = ep_insert(ep, &epds, tf.file, fd, full_check);
                } else
                        error = -EEXIST;
@@ -2121,7 +2121,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
        case EPOLL_CTL_MOD:
                if (epi) {
                        if (!(epi->event.events & EPOLLEXCLUSIVE)) {
-                               epds.events |= POLLERR | POLLHUP;
+                               epds.events |= EPOLLERR | EPOLLHUP;
                                error = ep_modify(ep, epi, &epds);
                        }
                } else
index 4fc731876d6ba94f45767abe9884bbcb9a5d48d0..1e97f1fda90c9fe9db90e7cdc70405eadcd721d4 100644 (file)
@@ -691,12 +691,12 @@ COMPAT_SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd,
 /* Table to convert sigio signal codes into poll band bitmaps */
 
 static const __poll_t band_table[NSIGPOLL] = {
-       POLLIN | POLLRDNORM,                    /* POLL_IN */
-       POLLOUT | POLLWRNORM | POLLWRBAND,      /* POLL_OUT */
-       POLLIN | POLLRDNORM | POLLMSG,          /* POLL_MSG */
-       POLLERR,                                /* POLL_ERR */
-       POLLPRI | POLLRDBAND,                   /* POLL_PRI */
-       POLLHUP | POLLERR                       /* POLL_HUP */
+       EPOLLIN | EPOLLRDNORM,                  /* POLL_IN */
+       EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND,   /* POLL_OUT */
+       EPOLLIN | EPOLLRDNORM | EPOLLMSG,               /* POLL_MSG */
+       EPOLLERR,                               /* POLL_ERR */
+       EPOLLPRI | EPOLLRDBAND,                 /* POLL_PRI */
+       EPOLLHUP | EPOLLERR                     /* POLL_HUP */
 };
 
 static inline int sigio_perm(struct task_struct *p,
index aa089a6925d0ea6bfa3d3104305084b240e35bc4..5d06384c2cae3c746ef2e2865956ea2871cd1c1c 100644 (file)
@@ -2006,21 +2006,21 @@ out:
 
 static __poll_t fuse_dev_poll(struct file *file, poll_table *wait)
 {
-       __poll_t mask = POLLOUT | POLLWRNORM;
+       __poll_t mask = EPOLLOUT | EPOLLWRNORM;
        struct fuse_iqueue *fiq;
        struct fuse_dev *fud = fuse_get_dev(file);
 
        if (!fud)
-               return POLLERR;
+               return EPOLLERR;
 
        fiq = &fud->fc->iq;
        poll_wait(file, &fiq->waitq, wait);
 
        spin_lock(&fiq->waitq.lock);
        if (!fiq->connected)
-               mask = POLLERR;
+               mask = EPOLLERR;
        else if (request_pending(fiq))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        spin_unlock(&fiq->waitq.lock);
 
        return mask;
index e85e974dd211d3f8efb469b06ddc58ea50a0eb46..a201fb0ac64f9cd7f978a82806167db6f9555aeb 100644 (file)
@@ -2791,7 +2791,7 @@ __poll_t fuse_file_poll(struct file *file, poll_table *wait)
                fc->no_poll = 1;
                return DEFAULT_POLLMASK;
        }
-       return POLLERR;
+       return EPOLLERR;
 }
 EXPORT_SYMBOL_GPL(fuse_file_poll);
 
index a03ce34225787fdbdeb720f8ad31d46495a93ed7..fd5ce883072e6b22eabe1f01ee1836c8c777d7ee 100644 (file)
@@ -823,7 +823,7 @@ void kernfs_drain_open_files(struct kernfs_node *kn)
  * the content and then you use 'poll' or 'select' to wait for
  * the content to change.  When the content changes (assuming the
  * manager for the kobject supports notification), poll will
- * return POLLERR|POLLPRI, and select will return the fd whether
+ * return EPOLLERR|EPOLLPRI, and select will return the fd whether
  * it is waiting for read, write, or exceptions.
  * Once poll/select indicates that the value has changed, you
  * need to close and re-open the file, or seek to 0 and read again.
@@ -851,7 +851,7 @@ static __poll_t kernfs_fop_poll(struct file *filp, poll_table *wait)
        return DEFAULT_POLLMASK;
 
  trigger:
-       return DEFAULT_POLLMASK|POLLERR|POLLPRI;
+       return DEFAULT_POLLMASK|EPOLLERR|EPOLLPRI;
 }
 
 static void kernfs_notify_workfn(struct work_struct *work)
index ef08d64c84b8659d9d44e6febb9db5b0ad7dca91..c07eb3d655eaeb3be93c8245ba3dd5fa279320ac 100644 (file)
@@ -247,7 +247,7 @@ static __poll_t fanotify_poll(struct file *file, poll_table *wait)
        poll_wait(file, &group->notification_waitq, wait);
        spin_lock(&group->notification_lock);
        if (!fsnotify_notify_queue_is_empty(group))
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
        spin_unlock(&group->notification_lock);
 
        return ret;
index 5c29bf16814f48633d57a5537c9ba9134c09e4df..2c908b31d6c93dcf49dd821ffd6ddfb67ac027f4 100644 (file)
@@ -115,7 +115,7 @@ static __poll_t inotify_poll(struct file *file, poll_table *wait)
        poll_wait(file, &group->notification_waitq, wait);
        spin_lock(&group->notification_lock);
        if (!fsnotify_notify_queue_is_empty(group))
-               ret = POLLIN | POLLRDNORM;
+               ret = EPOLLIN | EPOLLRDNORM;
        spin_unlock(&group->notification_lock);
 
        return ret;
index 385fcefa8bc53ec6db840fde60eefe30d91cf282..602c71f32740941e57d34a1aa21a3af48a4b60d4 100644 (file)
@@ -71,7 +71,7 @@ struct workqueue_struct *user_dlm_worker;
  * Over time, dlmfs has added some features that were not part of the
  * initial ABI.  Unfortunately, some of these features are not detectable
  * via standard usage.  For example, Linux's default poll always returns
- * POLLIN, so there is no way for a caller of poll(2) to know when dlmfs
+ * EPOLLIN, so there is no way for a caller of poll(2) to know when dlmfs
  * added poll support.  Instead, we provide this list of new capabilities.
  *
  * Capabilities is a read-only attribute.  We do it as a module parameter
@@ -83,7 +83,7 @@ struct workqueue_struct *user_dlm_worker;
  * interaction.
  *
  * Capabilities:
- * - bast      : POLLIN against the file descriptor of a held lock
+ * - bast      : EPOLLIN against the file descriptor of a held lock
  *               signifies a bast fired on the lock.
  */
 #define DLMFS_CAPABILITIES "bast stackglue"
@@ -230,7 +230,7 @@ static __poll_t dlmfs_file_poll(struct file *file, poll_table *wait)
 
        spin_lock(&ip->ip_lockres.l_lock);
        if (ip->ip_lockres.l_flags & USER_LOCK_BLOCKED)
-               event = POLLIN | POLLRDNORM;
+               event = EPOLLIN | EPOLLRDNORM;
        spin_unlock(&ip->ip_lockres.l_lock);
 
        return event;
index f073cd9e6687b58bfd29a2f2da32ed8ea28456bf..b03057afac2a0489244458c994891007e9f9a63a 100644 (file)
@@ -823,7 +823,7 @@ static __poll_t orangefs_devreq_poll(struct file *file,
        poll_wait(file, &orangefs_request_list_waitq, poll_table);
 
        if (!list_empty(&orangefs_request_list))
-               poll_revent_mask |= POLLIN;
+               poll_revent_mask |= EPOLLIN;
        return poll_revent_mask;
 }
 
index 0913aed7fd0de8b8b95dd13d6c27f29eebfb0c00..7b1954caf3885d1c24458aa3a1843802c0506a09 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -327,7 +327,7 @@ pipe_read(struct kiocb *iocb, struct iov_iter *to)
                        break;
                }
                if (do_wakeup) {
-                       wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
+                       wake_up_interruptible_sync_poll(&pipe->wait, EPOLLOUT | EPOLLWRNORM);
                        kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
                }
                pipe_wait(pipe);
@@ -336,7 +336,7 @@ pipe_read(struct kiocb *iocb, struct iov_iter *to)
 
        /* Signal writers asynchronously that there is more room. */
        if (do_wakeup) {
-               wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
+               wake_up_interruptible_sync_poll(&pipe->wait, EPOLLOUT | EPOLLWRNORM);
                kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
        }
        if (ret > 0)
@@ -463,7 +463,7 @@ pipe_write(struct kiocb *iocb, struct iov_iter *from)
                        break;
                }
                if (do_wakeup) {
-                       wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
+                       wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLRDNORM);
                        kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
                        do_wakeup = 0;
                }
@@ -474,7 +474,7 @@ pipe_write(struct kiocb *iocb, struct iov_iter *from)
 out:
        __pipe_unlock(pipe);
        if (do_wakeup) {
-               wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
+               wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLRDNORM);
                kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
        }
        if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
@@ -523,19 +523,19 @@ pipe_poll(struct file *filp, poll_table *wait)
        nrbufs = pipe->nrbufs;
        mask = 0;
        if (filp->f_mode & FMODE_READ) {
-               mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
+               mask = (nrbufs > 0) ? EPOLLIN | EPOLLRDNORM : 0;
                if (!pipe->writers && filp->f_version != pipe->w_counter)
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
        }
 
        if (filp->f_mode & FMODE_WRITE) {
-               mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
+               mask |= (nrbufs < pipe->buffers) ? EPOLLOUT | EPOLLWRNORM : 0;
                /*
-                * Most Unices do not set POLLERR for FIFOs but on Linux they
+                * Most Unices do not set EPOLLERR for FIFOs but on Linux they
                 * behave exactly like pipes for poll().
                 */
                if (!pipe->readers)
-                       mask |= POLLERR;
+                       mask |= EPOLLERR;
        }
 
        return mask;
@@ -568,7 +568,7 @@ pipe_release(struct inode *inode, struct file *file)
                pipe->writers--;
 
        if (pipe->readers || pipe->writers) {
-               wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP);
+               wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLOUT | EPOLLRDNORM | EPOLLWRNORM | EPOLLERR | EPOLLHUP);
                kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
                kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
        }
@@ -936,7 +936,7 @@ static int fifo_open(struct inode *inode, struct file *filp)
 
                if (!is_pipe && !pipe->writers) {
                        if ((filp->f_flags & O_NONBLOCK)) {
-                               /* suppress POLLHUP until we have
+                               /* suppress EPOLLHUP until we have
                                 * seen a writer */
                                filp->f_version = pipe->w_counter;
                        } else {
index f0bfb45c3f9fea791d65816efed720e4f21f11a1..4f4a2abb225eb99a1621d6c74c34cdbe90959e41 100644 (file)
@@ -44,7 +44,7 @@ static __poll_t kmsg_poll(struct file *file, poll_table *wait)
 {
        poll_wait(file, &log_wait, wait);
        if (do_syslog(SYSLOG_ACTION_SIZE_UNREAD, NULL, 0, SYSLOG_FROM_PROC))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 63325377621a91d814fbc348b4902341b80bee97..c41ab261397df2875951db47ea38b7cbe2a5bae1 100644 (file)
@@ -640,7 +640,7 @@ static __poll_t proc_sys_poll(struct file *filp, poll_table *wait)
 
        /* sysctl was unregistered */
        if (IS_ERR(head))
-               return POLLERR | POLLHUP;
+               return EPOLLERR | EPOLLHUP;
 
        if (!table->proc_handler)
                goto out;
@@ -653,7 +653,7 @@ static __poll_t proc_sys_poll(struct file *filp, poll_table *wait)
 
        if (event != atomic_read(&table->poll->event)) {
                filp->private_data = proc_sys_poll_event(table->poll);
-               ret = POLLIN | POLLRDNORM | POLLERR | POLLPRI;
+               ret = EPOLLIN | EPOLLRDNORM | EPOLLERR | EPOLLPRI;
        }
 
 out:
index c8528d587e09d3e856a39c848b998add4a29d7ed..e16fb8f2049e76dafdd533158fa534dc321d6dbc 100644 (file)
@@ -23,7 +23,7 @@ static __poll_t mounts_poll(struct file *file, poll_table *wait)
        struct seq_file *m = file->private_data;
        struct proc_mounts *p = m->private;
        struct mnt_namespace *ns = p->ns;
-       __poll_t res = POLLIN | POLLRDNORM;
+       __poll_t res = EPOLLIN | EPOLLRDNORM;
        int event;
 
        poll_wait(file, &p->ns->poll, wait);
@@ -31,7 +31,7 @@ static __poll_t mounts_poll(struct file *file, poll_table *wait)
        event = READ_ONCE(ns->event);
        if (m->poll_event != event) {
                m->poll_event = event;
-               res |= POLLERR | POLLPRI;
+               res |= EPOLLERR | EPOLLPRI;
        }
 
        return res;
index ec14171dd78a32c448dada2d8c96029b6e3e0bd0..b6c36254028ad1f48c5edc79186c52882caf61d1 100644 (file)
@@ -432,9 +432,9 @@ get_max:
        return max;
 }
 
-#define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP | POLLERR)
-#define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
-#define POLLEX_SET (POLLPRI)
+#define POLLIN_SET (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN | EPOLLHUP | EPOLLERR)
+#define POLLOUT_SET (EPOLLWRBAND | EPOLLWRNORM | EPOLLOUT | EPOLLERR)
+#define POLLEX_SET (EPOLLPRI)
 
 static inline void wait_key_set(poll_table *wait, unsigned long in,
                                unsigned long out, unsigned long bit,
@@ -814,11 +814,11 @@ static inline __poll_t do_pollfd(struct pollfd *pollfd, poll_table *pwait,
        fd = pollfd->fd;
        if (fd >= 0) {
                struct fd f = fdget(fd);
-               mask = POLLNVAL;
+               mask = EPOLLNVAL;
                if (f.file) {
                        /* userland u16 ->events contains POLL... bitmap */
                        __poll_t filter = demangle_poll(pollfd->events) |
-                                               POLLERR | POLLHUP;
+                                               EPOLLERR | EPOLLHUP;
                        mask = DEFAULT_POLLMASK;
                        if (f.file->f_op->poll) {
                                pwait->_key = filter;
index 31e923bec99af0eabe81414dd167b2d851879e27..9990957264e3cc9460f287e7b1ef4f1dc94a1ea4 100644 (file)
@@ -45,7 +45,7 @@ void signalfd_cleanup(struct sighand_struct *sighand)
                return;
 
        /* wait_queue_entry_t->func(POLLFREE) should do remove_wait_queue() */
-       wake_up_poll(wqh, POLLHUP | POLLFREE);
+       wake_up_poll(wqh, EPOLLHUP | POLLFREE);
 }
 
 struct signalfd_ctx {
@@ -69,7 +69,7 @@ static __poll_t signalfd_poll(struct file *file, poll_table *wait)
        if (next_signal(&current->pending, &ctx->sigmask) ||
            next_signal(&current->signal->shared_pending,
                        &ctx->sigmask))
-               events |= POLLIN;
+               events |= EPOLLIN;
        spin_unlock_irq(&current->sighand->siglock);
 
        return events;
index 0510717f3a53525ad47003631c4a3e4c8dce5eb7..cdad49da3ff710e6fd2cc1adf4bf4877623af670 100644 (file)
@@ -237,7 +237,7 @@ static __poll_t timerfd_poll(struct file *file, poll_table *wait)
 
        spin_lock_irqsave(&ctx->wqh.lock, flags);
        if (ctx->ticks)
-               events |= POLLIN;
+               events |= EPOLLIN;
        spin_unlock_irqrestore(&ctx->wqh.lock, flags);
 
        return events;
index 87a13a7c8270bce8428f3d89fa3fb04f08e49f63..cec550c8468f484a3f14d6a6b3e5dcc2a09ea70f 100644 (file)
@@ -483,7 +483,7 @@ int handle_userfault(struct vm_fault *vmf, unsigned long reason)
        if (likely(must_wait && !READ_ONCE(ctx->released) &&
                   (return_to_userland ? !signal_pending(current) :
                    !fatal_signal_pending(current)))) {
-               wake_up_poll(&ctx->fd_wqh, POLLIN);
+               wake_up_poll(&ctx->fd_wqh, EPOLLIN);
                schedule();
                ret |= VM_FAULT_MAJOR;
 
@@ -614,7 +614,7 @@ static void userfaultfd_event_wait_completion(struct userfaultfd_ctx *ctx,
 
                spin_unlock(&ctx->event_wqh.lock);
 
-               wake_up_poll(&ctx->fd_wqh, POLLIN);
+               wake_up_poll(&ctx->fd_wqh, EPOLLIN);
                schedule();
 
                spin_lock(&ctx->event_wqh.lock);
@@ -904,7 +904,7 @@ wakeup:
        /* Flush pending events that may still wait on event_wqh */
        wake_up_all(&ctx->event_wqh);
 
-       wake_up_poll(&ctx->fd_wqh, POLLHUP);
+       wake_up_poll(&ctx->fd_wqh, EPOLLHUP);
        userfaultfd_ctx_put(ctx);
        return 0;
 }
@@ -949,14 +949,14 @@ static __poll_t userfaultfd_poll(struct file *file, poll_table *wait)
 
        switch (ctx->state) {
        case UFFD_STATE_WAIT_API:
-               return POLLERR;
+               return EPOLLERR;
        case UFFD_STATE_RUNNING:
                /*
                 * poll() never guarantees that read won't block.
                 * userfaults can be waken before they're read().
                 */
                if (unlikely(!(file->f_flags & O_NONBLOCK)))
-                       return POLLERR;
+                       return EPOLLERR;
                /*
                 * lockless access to see if there are pending faults
                 * __pollwait last action is the add_wait_queue but
@@ -970,14 +970,14 @@ static __poll_t userfaultfd_poll(struct file *file, poll_table *wait)
                ret = 0;
                smp_mb();
                if (waitqueue_active(&ctx->fault_pending_wqh))
-                       ret = POLLIN;
+                       ret = EPOLLIN;
                else if (waitqueue_active(&ctx->event_wqh))
-                       ret = POLLIN;
+                       ret = EPOLLIN;
 
                return ret;
        default:
                WARN_ON_ONCE(1);
-               return POLLERR;
+               return EPOLLERR;
        }
 }
 
index 7046111b8d0aa6623dab59db8e3f68cb1714f462..eeb250b73c4b950557fa83f65cffe2eccb6afa22 100644 (file)
@@ -1266,8 +1266,8 @@ int scif_put_pages(struct scif_range *pages);
  * events is a bitmask specifying the events which the application is
  * interested in. The field revents is an output parameter, filled by the
  * kernel with the events that actually occurred. The bits returned in revents
- * can include any of those specified in events, or one of the values POLLERR,
- * POLLHUP, or POLLNVAL. (These three bits are meaningless in the events
+ * can include any of those specified in events, or one of the values EPOLLERR,
+ * EPOLLHUP, or EPOLLNVAL. (These three bits are meaningless in the events
  * field, and will be set in the revents field whenever the corresponding
  * condition is true.)
  *
@@ -1279,20 +1279,20 @@ int scif_put_pages(struct scif_range *pages);
  * timeout means an infinite timeout.
  *
  * The following bits may be set in events and returned in revents.
- * POLLIN - Data may be received without blocking. For a connected
+ * EPOLLIN - Data may be received without blocking. For a connected
  * endpoint, this means that scif_recv() may be called without blocking. For a
  * listening endpoint, this means that scif_accept() may be called without
  * blocking.
- * POLLOUT - Data may be sent without blocking. For a connected endpoint, this
- * means that scif_send() may be called without blocking. POLLOUT may also be
+ * EPOLLOUT - Data may be sent without blocking. For a connected endpoint, this
+ * means that scif_send() may be called without blocking. EPOLLOUT may also be
  * used to block waiting for a non-blocking connect to complete. This bit value
  * has no meaning for a listening endpoint and is ignored if specified.
  *
  * The following bits are only returned in revents, and are ignored if set in
  * events.
- * POLLERR - An error occurred on the endpoint
- * POLLHUP - The connection to the peer endpoint was disconnected
- * POLLNVAL - The specified endpoint descriptor is invalid.
+ * EPOLLERR - An error occurred on the endpoint
+ * EPOLLHUP - The connection to the peer endpoint was disconnected
+ * EPOLLNVAL - The specified endpoint descriptor is invalid.
  *
  * Return:
  * Upon successful completion, scif_poll() returns a non-negative value. A
index aa16c064294f0139188950bdf72f8cbdb7e5c1ba..5b6c541e4e1b14145c468c5f5b9caaf6504d299d 100644 (file)
@@ -443,7 +443,7 @@ struct vb2_buf_ops {
  * @fileio_read_once:          report EOF after reading the first buffer
  * @fileio_write_immediately:  queue buffer after each write() call
  * @allow_zero_bytesused:      allow bytesused == 0 to be passed to the driver
- * @quirk_poll_must_check_waiting_for_buffers: Return %POLLERR at poll when QBUF
+ * @quirk_poll_must_check_waiting_for_buffers: Return %EPOLLERR at poll when QBUF
  *              has not been called. This is a vb1 idiom that has been adopted
  *              also by vb2.
  * @lock:      pointer to a mutex that protects the &struct vb2_queue. The
@@ -493,7 +493,7 @@ struct vb2_buf_ops {
  * @error:     a fatal error occurred on the queue
  * @waiting_for_buffers: used in poll() to check if vb2 is still waiting for
  *             buffers. Only set for capture queues if qbuf has not yet been
- *             called since poll() needs to return %POLLERR in that situation.
+ *             called since poll() needs to return %EPOLLERR in that situation.
  * @is_multiplanar: set if buffer type is multiplanar
  * @is_output: set if buffer type is output
  * @copy_timestamp: set if vb2-core should set timestamps
@@ -869,7 +869,7 @@ void vb2_core_queue_release(struct vb2_queue *q);
  * @q:         pointer to &struct vb2_queue with videobuf2 queue.
  *
  * Flag that a fatal unrecoverable error has occurred and wake up all processes
- * waiting on the queue. Polling will now set %POLLERR and queuing and dequeuing
+ * waiting on the queue. Polling will now set %EPOLLERR and queuing and dequeuing
  * buffers will return %-EIO.
  *
  * The error flag will be cleared when canceling the queue, either from
index 6692d67e92450a763a88af438a70d71c12b96e57..c1a93ce35e6239f3b4f0bd560ffe2fcd8baf41d7 100644 (file)
@@ -310,7 +310,7 @@ void inet_csk_prepare_forced_close(struct sock *sk);
 static inline __poll_t inet_csk_listen_poll(const struct sock *sk)
 {
        return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ?
-                       (POLLIN | POLLRDNORM) : 0;
+                       (EPOLLIN | EPOLLRDNORM) : 0;
 }
 
 int inet_csk_listen_start(struct sock *sk, int backlog);
index 360e564ae7d1ffcacb31ec292b9a5b437e887e07..d7f309f74dec243f295e211d60cd76a9088460f9 100644 (file)
@@ -578,10 +578,10 @@ static __poll_t mqueue_poll_file(struct file *filp, struct poll_table_struct *po
 
        spin_lock(&info->lock);
        if (info->attr.mq_curmsgs)
-               retval = POLLIN | POLLRDNORM;
+               retval = EPOLLIN | EPOLLRDNORM;
 
        if (info->attr.mq_curmsgs < info->attr.mq_maxmsg)
-               retval |= POLLOUT | POLLWRNORM;
+               retval |= EPOLLOUT | EPOLLWRNORM;
        spin_unlock(&info->lock);
 
        return retval;
index f0549e79978b222a380e7438bf1250dd7c400184..96db9ae5d5af751edd61189407aa064d591b54dd 100644 (file)
@@ -4524,7 +4524,7 @@ static __poll_t perf_poll(struct file *file, poll_table *wait)
 {
        struct perf_event *event = file->private_data;
        struct ring_buffer *rb;
-       __poll_t events = POLLHUP;
+       __poll_t events = EPOLLHUP;
 
        poll_wait(file, &event->waitq, wait);
 
index 141aa2ca87288dfbf08c702c6edd2b411fe0b546..6c6b3c48db7159c57035964d5a3403be475b6d83 100644 (file)
@@ -19,7 +19,7 @@
 
 static void perf_output_wakeup(struct perf_output_handle *handle)
 {
-       atomic_set(&handle->rb->poll, POLLIN);
+       atomic_set(&handle->rb->poll, EPOLLIN);
 
        handle->event->pending_wakeup = 1;
        irq_work_queue(&handle->event->pending);
index db4b9b8929ebf9afb425e36c3908b9f3ca1908e9..fc1123583fa6edadb19214bb1922f7ce4ccdf1e1 100644 (file)
@@ -930,7 +930,7 @@ static __poll_t devkmsg_poll(struct file *file, poll_table *wait)
        __poll_t ret = 0;
 
        if (!user)
-               return POLLERR|POLLNVAL;
+               return EPOLLERR|EPOLLNVAL;
 
        poll_wait(file, &log_wait, wait);
 
@@ -938,9 +938,9 @@ static __poll_t devkmsg_poll(struct file *file, poll_table *wait)
        if (user->seq < log_next_seq) {
                /* return error when data has vanished underneath us */
                if (user->seq < log_first_seq)
-                       ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
+                       ret = EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
                else
-                       ret = POLLIN|POLLRDNORM;
+                       ret = EPOLLIN|EPOLLRDNORM;
        }
        logbuf_unlock_irq();
 
index f7f40a6e63528b2bff1fc056fde148ec9b3b0da9..c3029402f15c3367bdd3d59210eee471b6bb41c0 100644 (file)
@@ -924,12 +924,12 @@ static __poll_t relay_file_poll(struct file *filp, poll_table *wait)
        struct rchan_buf *buf = filp->private_data;
 
        if (buf->finalized)
-               return POLLERR;
+               return EPOLLERR;
 
        if (filp->f_mode & FMODE_READ) {
                poll_wait(filp, &buf->read_wait, wait);
                if (!relay_buf_empty(buf))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        return mask;
index 94ad46d50b56dfc21ff5a29e0955b50425c563f3..fe56c4e06c5143187a32c37db604b3899cd4d686 100644 (file)
@@ -74,7 +74,7 @@ static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
        __poll_t result = 0;
 
        if (!clk)
-               return POLLERR;
+               return EPOLLERR;
 
        if (clk->ops.poll)
                result = clk->ops.poll(clk, fp, wait);
index ca6930e0d25e96c74fd4b371a523eb9b90f537ee..dcf1c4dd3efe6954b7d030b986f43bd0a897f052 100644 (file)
@@ -627,7 +627,7 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full)
  * as data is added to any of the @buffer's cpu buffers. Otherwise
  * it will wait for data to be added to a specific cpu buffer.
  *
- * Returns POLLIN | POLLRDNORM if data exists in the buffers,
+ * Returns EPOLLIN | EPOLLRDNORM if data exists in the buffers,
  * zero otherwise.
  */
 __poll_t ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
@@ -665,7 +665,7 @@ __poll_t ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
 
        if ((cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer)) ||
            (cpu != RING_BUFFER_ALL_CPUS && !ring_buffer_empty_cpu(buffer, cpu)))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
index 56608538a4ad61cc56d5a2cdaccfacd2eede4906..20a2300ae4e8671629e9b516b389c0e6c4dee2db 100644 (file)
@@ -5623,13 +5623,13 @@ trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_tabl
 
        /* Iterators are static, they should be filled or empty */
        if (trace_buffer_iter(iter, iter->cpu_file))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        if (tr->trace_flags & TRACE_ITER_BLOCK)
                /*
                 * Always select as readable when in blocking mode
                 */
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        else
                return ring_buffer_poll_wait(iter->trace_buffer->buffer, iter->cpu_file,
                                             filp, poll_table);
index 13b35ffa021e3b0d22492a42cda31832c3327969..670e99b68aa60567ecb4195bdace787e2378620c 100644 (file)
@@ -3688,7 +3688,7 @@ static void memcg_event_remove(struct work_struct *work)
 }
 
 /*
- * Gets called on POLLHUP on eventfd when user closes it.
+ * Gets called on EPOLLHUP on eventfd when user closes it.
  *
  * Called with wqh->lock held and interrupts disabled.
  */
@@ -3700,7 +3700,7 @@ static int memcg_event_wake(wait_queue_entry_t *wait, unsigned mode,
        struct mem_cgroup *memcg = event->memcg;
        __poll_t flags = key_to_poll(key);
 
-       if (flags & POLLHUP) {
+       if (flags & EPOLLHUP) {
                /*
                 * If the event has been detached at cgroup removal, we
                 * can simply return knowing the other side will cleanup
index 42fe5653814adcdce7d41a8df2a4e30af854cc1a..c7a33717d079b1fd03ccf49f857684d3364ac908 100644 (file)
@@ -2705,10 +2705,10 @@ static __poll_t swaps_poll(struct file *file, poll_table *wait)
 
        if (seq->poll_event != atomic_read(&proc_poll_event)) {
                seq->poll_event = atomic_read(&proc_poll_event);
-               return POLLIN | POLLRDNORM | POLLERR | POLLPRI;
+               return EPOLLIN | EPOLLRDNORM | EPOLLERR | EPOLLPRI;
        }
 
-       return POLLIN | POLLRDNORM;
+       return EPOLLIN | EPOLLRDNORM;
 }
 
 /* iterator */
index d6f7f7cb79c45fc478630ef836b33f7eec5d7a29..0cfba919d167db9042dcf3fc2b4be7d1c8eaa852 100644 (file)
@@ -240,7 +240,7 @@ p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err)
        if (!ts) {
                if (err)
                        *err = -EREMOTEIO;
-               return POLLERR;
+               return EPOLLERR;
        }
 
        if (!ts->rd->f_op->poll)
@@ -253,7 +253,7 @@ p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err)
                        n = DEFAULT_POLLMASK;
                else
                        n = ts->wr->f_op->poll(ts->wr, pt);
-               ret = (ret & ~POLLOUT) | (n & ~POLLIN);
+               ret = (ret & ~EPOLLOUT) | (n & ~EPOLLIN);
        }
 
        return ret;
@@ -396,11 +396,11 @@ end_clear:
 
        if (!list_empty(&m->req_list)) {
                if (test_and_clear_bit(Rpending, &m->wsched))
-                       n = POLLIN;
+                       n = EPOLLIN;
                else
                        n = p9_fd_poll(m->client, NULL, NULL);
 
-               if ((n & POLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
+               if ((n & EPOLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
                        p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
                        schedule_work(&m->rq);
                }
@@ -505,11 +505,11 @@ end_clear:
 
        if (m->wsize || !list_empty(&m->unsent_req_list)) {
                if (test_and_clear_bit(Wpending, &m->wsched))
-                       n = POLLOUT;
+                       n = EPOLLOUT;
                else
                        n = p9_fd_poll(m->client, NULL, NULL);
 
-               if ((n & POLLOUT) &&
+               if ((n & EPOLLOUT) &&
                   !test_and_set_bit(Wworksched, &m->wsched)) {
                        p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
                        schedule_work(&m->wq);
@@ -599,12 +599,12 @@ static void p9_conn_create(struct p9_client *client)
        init_poll_funcptr(&m->pt, p9_pollwait);
 
        n = p9_fd_poll(client, &m->pt, NULL);
-       if (n & POLLIN) {
+       if (n & EPOLLIN) {
                p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
                set_bit(Rpending, &m->wsched);
        }
 
-       if (n & POLLOUT) {
+       if (n & EPOLLOUT) {
                p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
                set_bit(Wpending, &m->wsched);
        }
@@ -625,12 +625,12 @@ static void p9_poll_mux(struct p9_conn *m)
                return;
 
        n = p9_fd_poll(m->client, NULL, &err);
-       if (n & (POLLERR | POLLHUP | POLLNVAL)) {
+       if (n & (EPOLLERR | EPOLLHUP | EPOLLNVAL)) {
                p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
                p9_conn_cancel(m, err);
        }
 
-       if (n & POLLIN) {
+       if (n & EPOLLIN) {
                set_bit(Rpending, &m->wsched);
                p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
                if (!test_and_set_bit(Rworksched, &m->wsched)) {
@@ -639,7 +639,7 @@ static void p9_poll_mux(struct p9_conn *m)
                }
        }
 
-       if (n & POLLOUT) {
+       if (n & EPOLLOUT) {
                set_bit(Wpending, &m->wsched);
                p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
                if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
@@ -678,11 +678,11 @@ static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
        spin_unlock(&client->lock);
 
        if (test_and_clear_bit(Wpending, &m->wsched))
-               n = POLLOUT;
+               n = EPOLLOUT;
        else
                n = p9_fd_poll(m->client, NULL, NULL);
 
-       if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
+       if (n & EPOLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
                schedule_work(&m->wq);
 
        return 0;
index 6523f38c4957f33a5400f753d348f510e48f4e4f..fc78a0508ae1b3f78019bd0312a61b2cd0da6192 100644 (file)
@@ -661,15 +661,15 @@ __poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
 
        /* exceptional events */
        if (sk->sk_err)
-               mask = POLLERR;
+               mask = EPOLLERR;
 
        if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
            test_bit(ATM_VF_CLOSE, &vcc->flags))
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        /* readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* writable? */
        if (sock->state == SS_CONNECTING &&
@@ -678,7 +678,7 @@ __poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
 
        if (vcc->qos.txtp.traffic_class != ATM_NONE &&
            vcc_writable(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        return mask;
 }
index 581375d0eed260ee43b19e7c687572aed98be2b3..e91f29c7c638a5f9fede10b08cdd11f37d2ee1e6 100644 (file)
@@ -304,7 +304,7 @@ static __poll_t batadv_socket_poll(struct file *file, poll_table *wait)
        poll_wait(file, &socket_client->queue_wait, wait);
 
        if (socket_client->queue_len > 0)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index 9be74a44e99d01846602c72381cbb63c441e3fd9..dc9fa37ddd14145b90053e59beb78211f3a22d23 100644 (file)
@@ -193,7 +193,7 @@ static __poll_t batadv_log_poll(struct file *file, poll_table *wait)
        poll_wait(file, &debug_log->queue_wait, wait);
 
        if (!batadv_log_empty(debug_log))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 
        return 0;
 }
index f897681780db70a0ed010b68d49a9d64d15027c2..84d92a0778343d0ee99f71ad3d691ca716ed36c6 100644 (file)
@@ -431,7 +431,7 @@ static inline __poll_t bt_accept_poll(struct sock *parent)
                if (sk->sk_state == BT_CONNECTED ||
                    (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
                     sk->sk_state == BT_CONNECT2))
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
        }
 
        return 0;
@@ -451,20 +451,20 @@ __poll_t bt_sock_poll(struct file *file, struct socket *sock,
                return bt_accept_poll(sk);
 
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
 
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (sk->sk_state == BT_CLOSED)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (sk->sk_state == BT_CONNECT ||
                        sk->sk_state == BT_CONNECT2 ||
@@ -472,7 +472,7 @@ __poll_t bt_sock_poll(struct file *file, struct socket *sock,
                return mask;
 
        if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
        else
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 
index b109445a1df928ec85978bf97a48c103ab8b627b..a6fb1b3bcad9b2f3c1c24b2a3496ad21b07c69d9 100644 (file)
@@ -924,7 +924,7 @@ static int caif_release(struct socket *sock)
 
        caif_disconnect_client(sock_net(sk), &cf_sk->layer);
        cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
-       wake_up_interruptible_poll(sk_sleep(sk), POLLERR|POLLHUP);
+       wake_up_interruptible_poll(sk_sleep(sk), EPOLLERR|EPOLLHUP);
 
        sock_orphan(sk);
        sk_stream_kill_queues(&cf_sk->sk);
@@ -946,23 +946,23 @@ static __poll_t caif_poll(struct file *file,
 
        /* exceptional events? */
        if (sk->sk_err)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP;
+               mask |= EPOLLRDHUP;
 
        /* readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue) ||
                (sk->sk_shutdown & RCV_SHUTDOWN))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /*
         * we set writable also when the other side has shut down the
         * connection. This prevents stuck sockets.
         */
        if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        return mask;
 }
index b7d9293940b5a58417784f84d77b709adf68c920..9938952c5c78f1e72ef13f44517ef054a60205b2 100644 (file)
@@ -75,7 +75,7 @@ static int receiver_wake_function(wait_queue_entry_t *wait, unsigned int mode, i
        /*
         * Avoid a wakeup if event not interesting for us
         */
-       if (key && !(key_to_poll(key) & (POLLIN | POLLERR)))
+       if (key && !(key_to_poll(key) & (EPOLLIN | EPOLLERR)))
                return 0;
        return autoremove_wake_function(wait, mode, sync, key);
 }
@@ -842,22 +842,22 @@ __poll_t datagram_poll(struct file *file, struct socket *sock,
 
        /* exceptional events? */
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        /* readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* Connection-based need to check for termination and startup */
        if (connection_based(sk)) {
                if (sk->sk_state == TCP_CLOSE)
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                /* connection hasn't started yet? */
                if (sk->sk_state == TCP_SYN_SENT)
                        return mask;
@@ -865,7 +865,7 @@ __poll_t datagram_poll(struct file *file, struct socket *sock,
 
        /* writable? */
        if (sock_writeable(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
        else
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 
index b026e1717df4e5b58186b07b3225820fe9eb66cb..c501499a04fe973e80e18655b306d762d348ff44 100644 (file)
@@ -2619,7 +2619,7 @@ static void sock_def_error_report(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_poll(&wq->wait, POLLERR);
+               wake_up_interruptible_poll(&wq->wait, EPOLLERR);
        sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
        rcu_read_unlock();
 }
@@ -2631,8 +2631,8 @@ static void sock_def_readable(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
-                                               POLLRDNORM | POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
+                                               EPOLLRDNORM | EPOLLRDBAND);
        sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
        rcu_read_unlock();
 }
@@ -2649,8 +2649,8 @@ static void sock_def_write_space(struct sock *sk)
        if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
                wq = rcu_dereference(sk->sk_wq);
                if (skwq_has_sleeper(wq))
-                       wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
-                                               POLLWRNORM | POLLWRBAND);
+                       wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
+                                               EPOLLWRNORM | EPOLLWRBAND);
 
                /* Should agree with poll, otherwise some programs break */
                if (sock_writeable(sk))
index 1cff9c6270c6b98472eae26c67e0d5e694af0f31..7d329fb1f553a832e277e12989b8c49ede21ea0e 100644 (file)
@@ -38,8 +38,8 @@ void sk_stream_write_space(struct sock *sk)
                rcu_read_lock();
                wq = rcu_dereference(sk->sk_wq);
                if (skwq_has_sleeper(wq))
-                       wake_up_interruptible_poll(&wq->wait, POLLOUT |
-                                               POLLWRNORM | POLLWRBAND);
+                       wake_up_interruptible_poll(&wq->wait, EPOLLOUT |
+                                               EPOLLWRNORM | EPOLLWRBAND);
                if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
                        sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
                rcu_read_unlock();
index 74685fecfdb9636588d4abe59870ad0320efe0c3..15bdc002d90c0fba1a532a330348facdf50547c8 100644 (file)
@@ -338,21 +338,21 @@ __poll_t dccp_poll(struct file *file, struct socket *sock,
 
        mask = 0;
        if (sk->sk_err)
-               mask = POLLERR;
+               mask = EPOLLERR;
 
        if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == DCCP_CLOSED)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLIN | POLLRDNORM | POLLRDHUP;
+               mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
 
        /* Connected? */
        if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_RESPOND)) {
                if (atomic_read(&sk->sk_rmem_alloc) > 0)
-                       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);
@@ -362,7 +362,7 @@ __poll_t dccp_poll(struct file *file, struct socket *sock,
                                 * IO signal will be lost.
                                 */
                                if (sk_stream_is_writeable(sk))
-                                       mask |= POLLOUT | POLLWRNORM;
+                                       mask |= EPOLLOUT | EPOLLWRNORM;
                        }
                }
        }
index cc1b505453a8aba76f6fe1005448e58804232743..91dd09f798089e1a1144579f128e5c6dae3a9c0e 100644 (file)
@@ -1216,7 +1216,7 @@ static __poll_t dn_poll(struct file *file, struct socket *sock, poll_table  *wai
        __poll_t mask = datagram_poll(file, sock, wait);
 
        if (!skb_queue_empty(&scp->other_receive_queue))
-               mask |= POLLRDBAND;
+               mask |= EPOLLRDBAND;
 
        return mask;
 }
index c24008daa3d8763f547745a68ddd581f26c08e3c..e4329e161943636e1cb3a705fd1c2afb6c74026b 100644 (file)
@@ -828,7 +828,7 @@ int inet_shutdown(struct socket *sock, int how)
        case TCP_CLOSE:
                err = -ENOTCONN;
                /* Hack to wake up other listeners, who can poll for
-                  POLLHUP, even on eg. unconnected UDP sockets -- RR */
+                  EPOLLHUP, even on eg. unconnected UDP sockets -- RR */
                /* fall through */
        default:
                sk->sk_shutdown |= how;
index c059aa7df0a9436964d837897b1e16ede80f6930..48636aee23c31244494b7c7acbc911a7f1823691 100644 (file)
@@ -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;
 }
index cfa51cfd2d999342018aee3511d5760a17b1493b..575d3c1fb6e835e225834ca45f58b74ea29e000b 100644 (file)
@@ -315,7 +315,7 @@ static void tcp_sndbuf_expand(struct sock *sk)
 
        /* Fast Recovery (RFC 5681 3.2) :
         * Cubic needs 1.7 factor, rounded to 2 to include
-        * extra cushion (application might react slowly to POLLOUT)
+        * extra cushion (application might react slowly to EPOLLOUT)
         */
        sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
        sndmem *= nr_segs * per_mss;
index f81f969f9c0658075f4921284cf2cfbd626a4054..bfaefe560b5ce32bbf383469d8f77795d1322ed9 100644 (file)
@@ -2501,12 +2501,12 @@ __poll_t udp_poll(struct file *file, struct socket *sock, poll_table *wait)
        struct sock *sk = sock->sk;
 
        if (!skb_queue_empty(&udp_sk(sk)->reader_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* Check for false positives due to checksum errors */
-       if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
+       if ((mask & EPOLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
            !(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1)
-               mask &= ~(POLLIN | POLLRDNORM);
+               mask &= ~(EPOLLIN | EPOLLRDNORM);
 
        return mask;
 
index 64331158d6938f42709286efa04e2c3e67073208..1e8cc7bcbca3a4fe830b7668fd9b143988e4fb46 100644 (file)
@@ -1483,7 +1483,7 @@ static inline __poll_t iucv_accept_poll(struct sock *parent)
                sk = (struct sock *) isk;
 
                if (sk->sk_state == IUCV_CONNECTED)
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
        }
 
        return 0;
@@ -1501,27 +1501,27 @@ __poll_t iucv_sock_poll(struct file *file, struct socket *sock,
                return iucv_accept_poll(sk);
 
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP;
+               mask |= EPOLLRDHUP;
 
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (!skb_queue_empty(&sk->sk_receive_queue) ||
            (sk->sk_shutdown & RCV_SHUTDOWN))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (sk->sk_state == IUCV_CLOSED)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (sk->sk_state == IUCV_DISCONN)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        if (sock_writeable(sk) && iucv_below_msglim(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
        else
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 
index 4a8d407f8902210b6edb1c9803877686687c4edb..f297d53a11aa0be823d4235449c9a6474f39469f 100644 (file)
@@ -396,8 +396,8 @@ static int kcm_read_sock_done(struct strparser *strp, int err)
 
 static void psock_state_change(struct sock *sk)
 {
-       /* TCP only does a POLLIN for a half close. Do a POLLHUP here
-        * since application will normally not poll with POLLIN
+       /* TCP only does a EPOLLIN for a half close. Do a EPOLLHUP here
+        * since application will normally not poll with EPOLLIN
         * on the TCP sockets.
         */
 
@@ -1338,7 +1338,7 @@ static void init_kcm_sock(struct kcm_sock *kcm, struct kcm_mux *mux)
 
        /* For SOCK_SEQPACKET sock type, datagram_poll checks the sk_state, so
         * we set sk_state, otherwise epoll_wait always returns right away with
-        * POLLHUP
+        * EPOLLHUP
         */
        kcm->sk.sk_state = TCP_ESTABLISHED;
 
index 985909f105eb784fa41829e7703c6b236b3481fa..376040092142d335a6e09e27faf6190fad73aef5 100644 (file)
@@ -543,7 +543,7 @@ static inline __poll_t llcp_accept_poll(struct sock *parent)
                sk = &llcp_sock->sk;
 
                if (sk->sk_state == LLCP_CONNECTED)
-                       return POLLIN | POLLRDNORM;
+                       return EPOLLIN | EPOLLRDNORM;
        }
 
        return 0;
@@ -563,23 +563,23 @@ static __poll_t llcp_sock_poll(struct file *file, struct socket *sock,
                return llcp_accept_poll(sk);
 
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
 
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        if (sk->sk_state == LLCP_CLOSED)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
 
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        if (sock_writeable(sk) && sk->sk_state == LLCP_CONNECTED)
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
        else
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 
index 1d1483007e46105c282d6c0b7a3a1e2544eda314..e0f3f4aeeb4fb93b253f2487cfb3cf7c484dbd7c 100644 (file)
@@ -4085,7 +4085,7 @@ static __poll_t packet_poll(struct file *file, struct socket *sock,
        if (po->rx_ring.pg_vec) {
                if (!packet_previous_rx_frame(po, &po->rx_ring,
                        TP_STATUS_KERNEL))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
        if (po->pressure && __packet_rcv_has_room(po, NULL) == ROOM_NORMAL)
                po->pressure = 0;
@@ -4093,7 +4093,7 @@ static __poll_t packet_poll(struct file *file, struct socket *sock,
        spin_lock_bh(&sk->sk_write_queue.lock);
        if (po->tx_ring.pg_vec) {
                if (packet_current_frame(po, &po->tx_ring, TP_STATUS_AVAILABLE))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
        spin_unlock_bh(&sk->sk_write_queue.lock);
        return mask;
index 08f6751d2030ca7317f4c31f45149df4db0b9411..fffcd69f63ff4d10b5471348b130052fc491d852 100644 (file)
@@ -351,18 +351,18 @@ static __poll_t pn_socket_poll(struct file *file, struct socket *sock,
        poll_wait(file, sk_sleep(sk), wait);
 
        if (sk->sk_state == TCP_CLOSE)
-               return POLLERR;
+               return EPOLLERR;
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (!skb_queue_empty(&pn->ctrlreq_queue))
-               mask |= POLLPRI;
+               mask |= EPOLLPRI;
        if (!mask && sk->sk_state == TCP_CLOSE_WAIT)
-               return POLLHUP;
+               return EPOLLHUP;
 
        if (sk->sk_state == TCP_ESTABLISHED &&
                refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf &&
                atomic_read(&pn->tx_credits))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        return mask;
 }
index 88aa8ad0f5b67c251e2830d1d6244df08ba91471..744c637c86b01b68ce52fd8f5453f2d2b88beeb1 100644 (file)
@@ -137,17 +137,17 @@ static int rds_getname(struct socket *sock, struct sockaddr *uaddr,
 
 /*
  * RDS' poll is without a doubt the least intuitive part of the interface,
- * as POLLIN and POLLOUT do not behave entirely as you would expect from
+ * as EPOLLIN and EPOLLOUT do not behave entirely as you would expect from
  * a network protocol.
  *
- * POLLIN is asserted if
+ * EPOLLIN is asserted if
  *  -  there is data on the receive queue.
  *  -  to signal that a previously congested destination may have become
  *     uncongested
  *  -  A notification has been queued to the socket (this can be a congestion
  *     update, or a RDMA completion).
  *
- * POLLOUT is asserted if there is room on the send queue. This does not mean
+ * EPOLLOUT is asserted if there is room on the send queue. This does not mean
  * however, that the next sendmsg() call will succeed. If the application tries
  * to send to a congested destination, the system call may still fail (and
  * return ENOBUFS).
@@ -167,22 +167,22 @@ static __poll_t rds_poll(struct file *file, struct socket *sock,
 
        read_lock_irqsave(&rs->rs_recv_lock, flags);
        if (!rs->rs_cong_monitor) {
-               /* When a congestion map was updated, we signal POLLIN for
+               /* When a congestion map was updated, we signal EPOLLIN for
                 * "historical" reasons. Applications can also poll for
                 * WRBAND instead. */
                if (rds_cong_updated_since(&rs->rs_cong_track))
-                       mask |= (POLLIN | POLLRDNORM | POLLWRBAND);
+                       mask |= (EPOLLIN | EPOLLRDNORM | EPOLLWRBAND);
        } else {
                spin_lock(&rs->rs_lock);
                if (rs->rs_cong_notify)
-                       mask |= (POLLIN | POLLRDNORM);
+                       mask |= (EPOLLIN | EPOLLRDNORM);
                spin_unlock(&rs->rs_lock);
        }
        if (!list_empty(&rs->rs_recv_queue) ||
            !list_empty(&rs->rs_notify_queue))
-               mask |= (POLLIN | POLLRDNORM);
+               mask |= (EPOLLIN | EPOLLRDNORM);
        if (rs->rs_snd_bytes < rds_sk_sndbuf(rs))
-               mask |= (POLLOUT | POLLWRNORM);
+               mask |= (EPOLLOUT | EPOLLWRNORM);
        read_unlock_irqrestore(&rs->rs_recv_lock, flags);
 
        /* clear state any time we wake a seen-congested socket */
index 124c77e9d05827928b1817163f235fbba6daa979..59d0eb96027585f77197aa7516f8ee2c6c35763d 100644 (file)
@@ -1142,13 +1142,13 @@ static int rfkill_fop_open(struct inode *inode, struct file *file)
 static __poll_t rfkill_fop_poll(struct file *file, poll_table *wait)
 {
        struct rfkill_data *data = file->private_data;
-       __poll_t res = POLLOUT | POLLWRNORM;
+       __poll_t res = EPOLLOUT | EPOLLWRNORM;
 
        poll_wait(file, &data->read_wait, wait);
 
        mutex_lock(&data->mtx);
        if (!list_empty(&data->events))
-               res = POLLIN | POLLRDNORM;
+               res = EPOLLIN | EPOLLRDNORM;
        mutex_unlock(&data->mtx);
 
        return res;
index 21ad6a3a465ce8bd6e2b08e3d356cf8fdb9343ba..0c9c18aa7c77b280c0dff27322a245948529624b 100644 (file)
@@ -742,13 +742,13 @@ static __poll_t rxrpc_poll(struct file *file, struct socket *sock,
        /* the socket is readable if there are any messages waiting on the Rx
         * queue */
        if (!list_empty(&rx->recvmsg_q))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* the socket is writable if there is space to add new data to the
         * socket; there is no guarantee that any particular call in progress
         * on the socket may have space in the Tx ACK window */
        if (rxrpc_writable(sk))
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
 
        return mask;
 }
index ebb8cb9eb0bd8fe7d62dffe64237b2d6b5af6689..bf271f8c2dc9b28c992f9be3bc9b6a7bfa5fdb82 100644 (file)
@@ -7602,22 +7602,22 @@ __poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
         */
        if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
                return (!list_empty(&sp->ep->asocs)) ?
-                       (POLLIN | POLLRDNORM) : 0;
+                       (EPOLLIN | EPOLLRDNORM) : 0;
 
        mask = 0;
 
        /* Is there any exceptional events?  */
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        /* Is it readable?  Reconsider this code with TCP-style support.  */
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* The association is either gone or not ready.  */
        if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
@@ -7625,7 +7625,7 @@ __poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
 
        /* Is it writable?  */
        if (sctp_writeable(sk)) {
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        } else {
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
                /*
@@ -7637,7 +7637,7 @@ __poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
                 * in the following code to cover it as well.
                 */
                if (sctp_writeable(sk))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
        return mask;
 }
@@ -8161,8 +8161,8 @@ void sctp_data_ready(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
-                                               POLLRDNORM | POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
+                                               EPOLLRDNORM | EPOLLRDBAND);
        sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
        rcu_read_unlock();
 }
index ba4b84debc5a03dff26299070fed7bd26439a022..da1a5cdefd13e96ac4acbec1a891a73af09dfa77 100644 (file)
@@ -1145,7 +1145,7 @@ static __poll_t smc_accept_poll(struct sock *parent)
 
        spin_lock(&isk->accept_q_lock);
        if (!list_empty(&isk->accept_q))
-               mask = POLLIN | POLLRDNORM;
+               mask = EPOLLIN | EPOLLRDNORM;
        spin_unlock(&isk->accept_q_lock);
 
        return mask;
@@ -1160,7 +1160,7 @@ static __poll_t smc_poll(struct file *file, struct socket *sock,
        int rc;
 
        if (!sk)
-               return POLLNVAL;
+               return EPOLLNVAL;
 
        smc = smc_sk(sock->sk);
        sock_hold(sk);
@@ -1171,16 +1171,16 @@ static __poll_t smc_poll(struct file *file, struct socket *sock,
                mask = smc->clcsock->ops->poll(file, smc->clcsock, wait);
                /* if non-blocking connect finished ... */
                lock_sock(sk);
-               if ((sk->sk_state == SMC_INIT) && (mask & POLLOUT)) {
+               if ((sk->sk_state == SMC_INIT) && (mask & EPOLLOUT)) {
                        sk->sk_err = smc->clcsock->sk->sk_err;
                        if (sk->sk_err) {
-                               mask |= POLLERR;
+                               mask |= EPOLLERR;
                        } else {
                                rc = smc_connect_rdma(smc);
                                if (rc < 0)
-                                       mask |= POLLERR;
+                                       mask |= EPOLLERR;
                                /* success cases including fallback */
-                               mask |= POLLOUT | POLLWRNORM;
+                               mask |= EPOLLOUT | EPOLLWRNORM;
                        }
                }
        } else {
@@ -1190,27 +1190,27 @@ static __poll_t smc_poll(struct file *file, struct socket *sock,
                        lock_sock(sk);
                }
                if (sk->sk_err)
-                       mask |= POLLERR;
+                       mask |= EPOLLERR;
                if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
                    (sk->sk_state == SMC_CLOSED))
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                if (sk->sk_state == SMC_LISTEN) {
                        /* woken up by sk_data_ready in smc_listen_work() */
                        mask = smc_accept_poll(sk);
                } else {
                        if (atomic_read(&smc->conn.sndbuf_space) ||
                            sk->sk_shutdown & SEND_SHUTDOWN) {
-                               mask |= POLLOUT | POLLWRNORM;
+                               mask |= EPOLLOUT | EPOLLWRNORM;
                        } else {
                                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
                                set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
                        }
                        if (atomic_read(&smc->conn.bytes_to_rcv))
-                               mask |= POLLIN | POLLRDNORM;
+                               mask |= EPOLLIN | EPOLLRDNORM;
                        if (sk->sk_shutdown & RCV_SHUTDOWN)
-                               mask |= POLLIN | POLLRDNORM | POLLRDHUP;
+                               mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
                        if (sk->sk_state == SMC_APPCLOSEWAIT1)
-                               mask |= POLLIN;
+                               mask |= EPOLLIN;
                }
 
        }
index 9dc392ca06bfb529911ac3ad5c962dbf2e0f6d9d..eff4e0d0bb31098149d523d5744d4a1ff22e7ddd 100644 (file)
@@ -35,8 +35,8 @@ static void smc_rx_data_ready(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
-                                               POLLRDNORM | POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
+                                               EPOLLRDNORM | EPOLLRDBAND);
        sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
        if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
            (sk->sk_state == SMC_CLOSED))
index 838bce20c3610a16d2d5f6d1533f1f6300e7438b..72f004c9c9b13c2f9b4637af8e77aba3772d7bec 100644 (file)
@@ -46,8 +46,8 @@ static void smc_tx_write_space(struct sock *sk)
                wq = rcu_dereference(sk->sk_wq);
                if (skwq_has_sleeper(wq))
                        wake_up_interruptible_poll(&wq->wait,
-                                                  POLLOUT | POLLWRNORM |
-                                                  POLLWRBAND);
+                                                  EPOLLOUT | EPOLLWRNORM |
+                                                  EPOLLWRBAND);
                if (wq && wq->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
                        sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
                rcu_read_unlock();
index aa36dad32db16a59c81aee434536a50dcf3aaa71..8a7e1c774f9c5933e6de54e992ded2c0540066fc 100644 (file)
@@ -940,7 +940,7 @@ static __poll_t cache_poll(struct file *filp, poll_table *wait,
        poll_wait(filp, &queue_wait, wait);
 
        /* alway allow write */
-       mask = POLLOUT | POLLWRNORM;
+       mask = EPOLLOUT | EPOLLWRNORM;
 
        if (!rp)
                return mask;
@@ -950,7 +950,7 @@ static __poll_t cache_poll(struct file *filp, poll_table *wait,
        for (cq= &rp->q; &cq->list != &cd->queue;
             cq = list_entry(cq->list.next, struct cache_queue, list))
                if (!cq->reader) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                        break;
                }
        spin_unlock(&queue_lock);
index 5c43303257873695be24007be71d463ff9b8228b..fc97fc3ed637a55f96f5970e86d21bb781bfbf87 100644 (file)
@@ -345,15 +345,15 @@ rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
 {
        struct inode *inode = file_inode(filp);
        struct rpc_inode *rpci = RPC_I(inode);
-       __poll_t mask = POLLOUT | POLLWRNORM;
+       __poll_t mask = EPOLLOUT | EPOLLWRNORM;
 
        poll_wait(filp, &rpci->waitq, wait);
 
        inode_lock(inode);
        if (rpci->pipe == NULL)
-               mask |= POLLERR | POLLHUP;
+               mask |= EPOLLERR | EPOLLHUP;
        else if (filp->private_data || !list_empty(&rpci->pipe->pipe))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        inode_unlock(inode);
        return mask;
 }
index 163f3a54750148891153feed71a7c5297e514474..b0323ec7971ed04cca532674fc85e9882f03c373 100644 (file)
@@ -721,31 +721,31 @@ static __poll_t tipc_poll(struct file *file, struct socket *sock,
        sock_poll_wait(file, sk_sleep(sk), wait);
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               revents |= POLLRDHUP | POLLIN | POLLRDNORM;
+               revents |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               revents |= POLLHUP;
+               revents |= EPOLLHUP;
 
        switch (sk->sk_state) {
        case TIPC_ESTABLISHED:
        case TIPC_CONNECTING:
                if (!tsk->cong_link_cnt && !tsk_conn_cong(tsk))
-                       revents |= POLLOUT;
+                       revents |= EPOLLOUT;
                /* fall thru' */
        case TIPC_LISTEN:
                if (!skb_queue_empty(&sk->sk_receive_queue))
-                       revents |= POLLIN | POLLRDNORM;
+                       revents |= EPOLLIN | EPOLLRDNORM;
                break;
        case TIPC_OPEN:
                if (tsk->group_is_open && !tsk->cong_link_cnt)
-                       revents |= POLLOUT;
+                       revents |= EPOLLOUT;
                if (!tipc_sk_type_connectionless(sk))
                        break;
                if (skb_queue_empty(&sk->sk_receive_queue))
                        break;
-               revents |= POLLIN | POLLRDNORM;
+               revents |= EPOLLIN | EPOLLRDNORM;
                break;
        case TIPC_DISCONNECTING:
-               revents = POLLIN | POLLRDNORM | POLLHUP;
+               revents = EPOLLIN | EPOLLRDNORM | EPOLLHUP;
                break;
        }
        return revents;
@@ -1897,8 +1897,8 @@ static void tipc_write_space(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
-                                               POLLWRNORM | POLLWRBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
+                                               EPOLLWRNORM | EPOLLWRBAND);
        rcu_read_unlock();
 }
 
@@ -1914,8 +1914,8 @@ static void tipc_data_ready(struct sock *sk)
        rcu_read_lock();
        wq = rcu_dereference(sk->sk_wq);
        if (skwq_has_sleeper(wq))
-               wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
-                                               POLLRDNORM | POLLRDBAND);
+               wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
+                                               EPOLLRDNORM | EPOLLRDBAND);
        rcu_read_unlock();
 }
 
index 0214acbd6bffb40bb5aea289fb784d7497292188..d545e1d0dea22cf15426c73224a8ce38855f202b 100644 (file)
@@ -415,9 +415,9 @@ static void unix_dgram_peer_wake_disconnect_wakeup(struct sock *sk,
 {
        unix_dgram_peer_wake_disconnect(sk, other);
        wake_up_interruptible_poll(sk_sleep(sk),
-                                  POLLOUT |
-                                  POLLWRNORM |
-                                  POLLWRBAND);
+                                  EPOLLOUT |
+                                  EPOLLWRNORM |
+                                  EPOLLWRBAND);
 }
 
 /* preconditions:
@@ -454,7 +454,7 @@ static void unix_write_space(struct sock *sk)
                wq = rcu_dereference(sk->sk_wq);
                if (skwq_has_sleeper(wq))
                        wake_up_interruptible_sync_poll(&wq->wait,
-                               POLLOUT | POLLWRNORM | POLLWRBAND);
+                               EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND);
                sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
        }
        rcu_read_unlock();
@@ -2129,8 +2129,8 @@ static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
 
        if (wq_has_sleeper(&u->peer_wait))
                wake_up_interruptible_sync_poll(&u->peer_wait,
-                                               POLLOUT | POLLWRNORM |
-                                               POLLWRBAND);
+                                               EPOLLOUT | EPOLLWRNORM |
+                                               EPOLLWRBAND);
 
        if (msg->msg_name)
                unix_copy_addr(msg, skb->sk);
@@ -2650,27 +2650,27 @@ static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wa
 
        /* exceptional events? */
        if (sk->sk_err)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
 
        /* readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* Connection-based need to check for termination and startup */
        if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
            sk->sk_state == TCP_CLOSE)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        /*
         * we set writable also when the other side has shut down the
         * connection. This prevents stuck sockets.
         */
        if (unix_writable(sk))
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        return mask;
 }
@@ -2687,29 +2687,29 @@ static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
 
        /* exceptional events? */
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
-               mask |= POLLERR |
-                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
+               mask |= EPOLLERR |
+                       (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
-               mask |= POLLRDHUP | POLLIN | POLLRDNORM;
+               mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
        if (sk->sk_shutdown == SHUTDOWN_MASK)
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
 
        /* readable? */
        if (!skb_queue_empty(&sk->sk_receive_queue))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        /* Connection-based need to check for termination and startup */
        if (sk->sk_type == SOCK_SEQPACKET) {
                if (sk->sk_state == TCP_CLOSE)
-                       mask |= POLLHUP;
+                       mask |= EPOLLHUP;
                /* connection hasn't started yet? */
                if (sk->sk_state == TCP_SYN_SENT)
                        return mask;
        }
 
        /* No write status requested, avoid expensive OUT tests. */
-       if (!(poll_requested_events(wait) & (POLLWRBAND|POLLWRNORM|POLLOUT)))
+       if (!(poll_requested_events(wait) & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
                return mask;
 
        writable = unix_writable(sk);
@@ -2726,7 +2726,7 @@ static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
        }
 
        if (writable)
-               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+               mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
        else
                sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 
index 9d95e773f4c8c0b3cda5963c383455d663ba28e8..e0fc84daed944b7753a11b8d8629a78380425414 100644 (file)
@@ -865,20 +865,20 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
 
        if (sk->sk_err)
                /* Signify that there has been an error on this socket. */
-               mask |= POLLERR;
+               mask |= EPOLLERR;
 
        /* INET sockets treat local write shutdown and peer write shutdown as a
-        * case of POLLHUP set.
+        * case of EPOLLHUP set.
         */
        if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
            ((sk->sk_shutdown & SEND_SHUTDOWN) &&
             (vsk->peer_shutdown & SEND_SHUTDOWN))) {
-               mask |= POLLHUP;
+               mask |= EPOLLHUP;
        }
 
        if (sk->sk_shutdown & RCV_SHUTDOWN ||
            vsk->peer_shutdown & SEND_SHUTDOWN) {
-               mask |= POLLRDHUP;
+               mask |= EPOLLRDHUP;
        }
 
        if (sock->type == SOCK_DGRAM) {
@@ -888,11 +888,11 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
                 */
                if (!skb_queue_empty(&sk->sk_receive_queue) ||
                    (sk->sk_shutdown & RCV_SHUTDOWN)) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                }
 
                if (!(sk->sk_shutdown & SEND_SHUTDOWN))
-                       mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
+                       mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 
        } else if (sock->type == SOCK_STREAM) {
                lock_sock(sk);
@@ -902,7 +902,7 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
                 */
                if (sk->sk_state == TCP_LISTEN
                    && !vsock_is_accept_queue_empty(sk))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
 
                /* If there is something in the queue then we can read. */
                if (transport->stream_is_active(vsk) &&
@@ -911,10 +911,10 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
                        int ret = transport->notify_poll_in(
                                        vsk, 1, &data_ready_now);
                        if (ret < 0) {
-                               mask |= POLLERR;
+                               mask |= EPOLLERR;
                        } else {
                                if (data_ready_now)
-                                       mask |= POLLIN | POLLRDNORM;
+                                       mask |= EPOLLIN | EPOLLRDNORM;
 
                        }
                }
@@ -925,7 +925,7 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
                 */
                if (sk->sk_shutdown & RCV_SHUTDOWN ||
                    vsk->peer_shutdown & SEND_SHUTDOWN) {
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                }
 
                /* Connected sockets that can produce data can be written. */
@@ -935,25 +935,25 @@ static __poll_t vsock_poll(struct file *file, struct socket *sock,
                                int ret = transport->notify_poll_out(
                                                vsk, 1, &space_avail_now);
                                if (ret < 0) {
-                                       mask |= POLLERR;
+                                       mask |= EPOLLERR;
                                } else {
                                        if (space_avail_now)
-                                               /* Remove POLLWRBAND since INET
+                                               /* Remove EPOLLWRBAND since INET
                                                 * sockets are not setting it.
                                                 */
-                                               mask |= POLLOUT | POLLWRNORM;
+                                               mask |= EPOLLOUT | EPOLLWRNORM;
 
                                }
                        }
                }
 
                /* Simulate INET socket poll behaviors, which sets
-                * POLLOUT|POLLWRNORM when peer is closed and nothing to read,
+                * EPOLLOUT|EPOLLWRNORM when peer is closed and nothing to read,
                 * but local send is not shutdown.
                 */
                if (sk->sk_state == TCP_CLOSE || sk->sk_state == TCP_CLOSING) {
                        if (!(sk->sk_shutdown & SEND_SHUTDOWN))
-                               mask |= POLLOUT | POLLWRNORM;
+                               mask |= EPOLLOUT | EPOLLWRNORM;
 
                }
 
index 4d202b73a0e11a948c1920c0121254c22007c66c..a9428daa69f3096367d028adc6c48f1280d4e139 100644 (file)
@@ -580,7 +580,7 @@ static __poll_t ns_revision_poll(struct file *file, poll_table *pt)
                mutex_lock_nested(&rev->ns->lock, rev->ns->level);
                poll_wait(file, &rev->ns->wait, pt);
                if (rev->last_read < rev->ns->revision)
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                mutex_unlock(&rev->ns->lock);
        }
 
index 558e3076d38c18d96f278225d565e959ffedee6d..479b03a7a17effb75a81212f48fa16580dc7fc3a 100644 (file)
@@ -456,14 +456,14 @@ void tomoyo_read_log(struct tomoyo_io_buffer *head)
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table". Maybe NULL.
  *
- * Returns POLLIN | POLLRDNORM when ready to read an audit log.
+ * Returns EPOLLIN | EPOLLRDNORM when ready to read an audit log.
  */
 __poll_t tomoyo_poll_log(struct file *file, poll_table *wait)
 {
        if (tomoyo_log_count)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        poll_wait(file, &tomoyo_log_wait, wait);
        if (tomoyo_log_count)
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
index 70c73bf66c88fb69ce9238550286713997c111c4..03923a138ef54430612eceeee9d962b9f37f6699 100644 (file)
@@ -2116,17 +2116,17 @@ static struct tomoyo_domain_info *tomoyo_find_domain_by_qid
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
  *
- * Returns POLLIN | POLLRDNORM when ready to read, 0 otherwise.
+ * Returns EPOLLIN | EPOLLRDNORM when ready to read, 0 otherwise.
  *
  * Waits for access requests which violated policy in enforcing mode.
  */
 static __poll_t tomoyo_poll_query(struct file *file, poll_table *wait)
 {
        if (!list_empty(&tomoyo_query_list))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        poll_wait(file, &tomoyo_query_wait, wait);
        if (!list_empty(&tomoyo_query_list))
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
        return 0;
 }
 
@@ -2450,15 +2450,15 @@ int tomoyo_open_control(const u8 type, struct file *file)
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table". Maybe NULL.
  *
- * Returns POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM if ready to read/write,
- * POLLOUT | POLLWRNORM otherwise.
+ * Returns EPOLLIN | EPOLLRDNORM | EPOLLOUT | EPOLLWRNORM if ready to read/write,
+ * EPOLLOUT | EPOLLWRNORM otherwise.
  */
 __poll_t tomoyo_poll_control(struct file *file, poll_table *wait)
 {
        struct tomoyo_io_buffer *head = file->private_data;
        if (head->poll)
-               return head->poll(file, wait) | POLLOUT | POLLWRNORM;
-       return POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM;
+               return head->poll(file, wait) | EPOLLOUT | EPOLLWRNORM;
+       return EPOLLIN | EPOLLRDNORM | EPOLLOUT | EPOLLWRNORM;
 }
 
 /**
index fb9bf99deb35de73a19c894c49328990ad5288fd..1d3d7e7a1f055a187aac486506ca3d13cba7da20 100644 (file)
@@ -154,8 +154,8 @@ static int tomoyo_release(struct inode *inode, struct file *file)
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table". Maybe NULL.
  *
- * Returns POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM if ready to read/write,
- * POLLOUT | POLLWRNORM otherwise.
+ * Returns EPOLLIN | EPOLLRDNORM | EPOLLOUT | EPOLLWRNORM if ready to read/write,
+ * EPOLLOUT | EPOLLWRNORM otherwise.
  */
 static __poll_t tomoyo_poll(struct file *file, poll_table *wait)
 {
index a12b9555e9107fb601b3227956174bd19309a547..4563432badba56e37c670541bda344b6c805392b 100644 (file)
@@ -399,9 +399,9 @@ static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
 static __poll_t snd_compr_get_poll(struct snd_compr_stream *stream)
 {
        if (stream->direction == SND_COMPRESS_PLAYBACK)
-               return POLLOUT | POLLWRNORM;
+               return EPOLLOUT | EPOLLWRNORM;
        else
-               return POLLIN | POLLRDNORM;
+               return EPOLLIN | EPOLLRDNORM;
 }
 
 static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
@@ -412,7 +412,7 @@ static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
        __poll_t retval = 0;
 
        if (snd_BUG_ON(!data))
-               return POLLERR;
+               return EPOLLERR;
 
        stream = &data->stream;
 
@@ -421,7 +421,7 @@ static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
        switch (stream->runtime->state) {
        case SNDRV_PCM_STATE_OPEN:
        case SNDRV_PCM_STATE_XRUN:
-               retval = snd_compr_get_poll(stream) | POLLERR;
+               retval = snd_compr_get_poll(stream) | EPOLLERR;
                goto out;
        default:
                break;
@@ -447,7 +447,7 @@ static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
                        retval = snd_compr_get_poll(stream);
                break;
        default:
-               retval = snd_compr_get_poll(stream) | POLLERR;
+               retval = snd_compr_get_poll(stream) | EPOLLERR;
                break;
        }
 out:
index 50fa16022f1fe67eb88881f2a8f4d4544934ea90..0b3026d937b101918581edab80aa3b2803ecec5a 100644 (file)
@@ -1679,7 +1679,7 @@ static __poll_t snd_ctl_poll(struct file *file, poll_table * wait)
 
        mask = 0;
        if (!list_empty(&ctl->events))
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
 
        return mask;
 }
index aa86f3f8e056506f0a5e1ba1fd2764481ce4b4cc..4b36767af9e15cef0b04d6308b9e8d7d57e68850 100644 (file)
@@ -214,9 +214,9 @@ static __poll_t snd_info_entry_poll(struct file *file, poll_table *wait)
                                          data->file_private_data,
                                          file, wait);
        if (entry->c.ops->read)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (entry->c.ops->write)
-               mask |= POLLOUT | POLLWRNORM;
+               mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 }
 
index 8753440c3a6eaed76736e920ccbc66dea45f7d6a..4fa5dd955740a0d061acb9cbc8fd0b786e3dd109 100644 (file)
@@ -346,7 +346,7 @@ static int snd_disconnect_release(struct inode *inode, struct file *file)
 
 static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
 {
-       return POLLERR | POLLNVAL;
+       return EPOLLERR | EPOLLNVAL;
 }
 
 static long snd_disconnect_ioctl(struct file *file,
index 3ebba9c7f86e028813a7bf7fbfacb65ab89645e6..b044c0a5a674b116e9441c13558deb0c0a4e70f9 100644 (file)
@@ -2705,7 +2705,7 @@ static __poll_t snd_pcm_oss_poll(struct file *file, poll_table * wait)
                if (runtime->status->state != SNDRV_PCM_STATE_DRAINING &&
                    (runtime->status->state != SNDRV_PCM_STATE_RUNNING ||
                     snd_pcm_oss_playback_ready(psubstream)))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
                snd_pcm_stream_unlock_irq(psubstream);
        }
        if (csubstream != NULL) {
@@ -2715,7 +2715,7 @@ static __poll_t snd_pcm_oss_poll(struct file *file, poll_table * wait)
                snd_pcm_stream_lock_irq(csubstream);
                if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING ||
                    snd_pcm_oss_capture_ready(csubstream))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
                snd_pcm_stream_unlock_irq(csubstream);
                if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) {
                        struct snd_pcm_oss_file ofile;
index 51104df924e10928eb8a8628ca1f97e5f0eb91e9..77ba50ddcf9e346f799b2c099abfec5694921afb 100644 (file)
@@ -3147,7 +3147,7 @@ static __poll_t snd_pcm_playback_poll(struct file *file, poll_table * wait)
 
        substream = pcm_file->substream;
        if (PCM_RUNTIME_CHECK(substream))
-               return POLLOUT | POLLWRNORM | POLLERR;
+               return EPOLLOUT | EPOLLWRNORM | EPOLLERR;
        runtime = substream->runtime;
 
        poll_wait(file, &runtime->sleep, wait);
@@ -3159,7 +3159,7 @@ static __poll_t snd_pcm_playback_poll(struct file *file, poll_table * wait)
        case SNDRV_PCM_STATE_PREPARED:
        case SNDRV_PCM_STATE_PAUSED:
                if (avail >= runtime->control->avail_min) {
-                       mask = POLLOUT | POLLWRNORM;
+                       mask = EPOLLOUT | EPOLLWRNORM;
                        break;
                }
                /* Fall through */
@@ -3167,7 +3167,7 @@ static __poll_t snd_pcm_playback_poll(struct file *file, poll_table * wait)
                mask = 0;
                break;
        default:
-               mask = POLLOUT | POLLWRNORM | POLLERR;
+               mask = EPOLLOUT | EPOLLWRNORM | EPOLLERR;
                break;
        }
        snd_pcm_stream_unlock_irq(substream);
@@ -3186,7 +3186,7 @@ static __poll_t snd_pcm_capture_poll(struct file *file, poll_table * wait)
 
        substream = pcm_file->substream;
        if (PCM_RUNTIME_CHECK(substream))
-               return POLLIN | POLLRDNORM | POLLERR;
+               return EPOLLIN | EPOLLRDNORM | EPOLLERR;
        runtime = substream->runtime;
 
        poll_wait(file, &runtime->sleep, wait);
@@ -3198,19 +3198,19 @@ static __poll_t snd_pcm_capture_poll(struct file *file, poll_table * wait)
        case SNDRV_PCM_STATE_PREPARED:
        case SNDRV_PCM_STATE_PAUSED:
                if (avail >= runtime->control->avail_min) {
-                       mask = POLLIN | POLLRDNORM;
+                       mask = EPOLLIN | EPOLLRDNORM;
                        break;
                }
                mask = 0;
                break;
        case SNDRV_PCM_STATE_DRAINING:
                if (avail > 0) {
-                       mask = POLLIN | POLLRDNORM;
+                       mask = EPOLLIN | EPOLLRDNORM;
                        break;
                }
                /* Fall through */
        default:
-               mask = POLLIN | POLLRDNORM | POLLERR;
+               mask = EPOLLIN | EPOLLRDNORM | EPOLLERR;
                break;
        }
        snd_pcm_stream_unlock_irq(substream);
index fae21311723f145607900d16bdd2edba2a7ea3bb..69616d00481c2cdff6331d8406bb18550db7824d 100644 (file)
@@ -1385,11 +1385,11 @@ static __poll_t snd_rawmidi_poll(struct file *file, poll_table * wait)
        mask = 0;
        if (rfile->input != NULL) {
                if (snd_rawmidi_ready(rfile->input))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
        if (rfile->output != NULL) {
                if (snd_rawmidi_ready(rfile->output))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
        return mask;
 }
index c538e78ca3102eca37ba970eae465e00e24ddf32..30886f5fb1001084e2904610c6f634b79a3f0dfd 100644 (file)
@@ -204,13 +204,13 @@ snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *file, poll_table * wai
        /* input */
        if (dp->readq && is_read_mode(dp->file_mode)) {
                if (snd_seq_oss_readq_poll(dp->readq, file, wait))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        /* output */
        if (dp->writeq && is_write_mode(dp->file_mode)) {
                if (snd_seq_kernel_client_write_poll(dp->cseq, file, wait))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
        return mask;
 }
index b611deef81f5b719a6fd97aeaf75fcd53e38f74c..60db32785f6229773fdf752a93e01f7bf42398eb 100644 (file)
@@ -1101,7 +1101,7 @@ static __poll_t snd_seq_poll(struct file *file, poll_table * wait)
 
                /* check if data is available in the outqueue */
                if (snd_seq_fifo_poll_wait(client->data.user.fifo, file, wait))
-                       mask |= POLLIN | POLLRDNORM;
+                       mask |= EPOLLIN | EPOLLRDNORM;
        }
 
        if (snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_OUTPUT) {
@@ -1109,7 +1109,7 @@ static __poll_t snd_seq_poll(struct file *file, poll_table * wait)
                /* check if data is available in the pool */
                if (!snd_seq_write_pool_allocated(client) ||
                    snd_seq_pool_poll_wait(client->pool, file, wait))
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        }
 
        return mask;
index da05e314917f92ee272b3c53682492ca1b9ca04c..dc87728c5b745e5a8e36e7adfc853470ae91ab7f 100644 (file)
@@ -2084,9 +2084,9 @@ static __poll_t snd_timer_user_poll(struct file *file, poll_table * wait)
        mask = 0;
        spin_lock_irq(&tu->qlock);
        if (tu->qused)
-               mask |= POLLIN | POLLRDNORM;
+               mask |= EPOLLIN | EPOLLRDNORM;
        if (tu->disconnected)
-               mask |= POLLERR;
+               mask |= EPOLLERR;
        spin_unlock_irq(&tu->qlock);
 
        return mask;
index 83e791810c52ed69d37c67b5092e2652fed4d517..04c321e08c626ba7ba6ea4084ebf17de55fec4cd 100644 (file)
@@ -63,7 +63,7 @@ hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait)
 
        spin_lock_irq(&bebob->lock);
        if (bebob->dev_lock_changed)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&bebob->lock);
index 7a8af0f91c96eb4361f4a3a8db4bc9f3d1964ab0..6498bf6909ba907499cd269f198656c8952a5c5a 100644 (file)
@@ -62,7 +62,7 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&dice->lock);
        if (dice->dev_lock_changed || dice->notification_bits != 0)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&dice->lock);
index a084c2a834db9284ba6b3d4d10475e2dc15b860a..426cd39e023381805a1cb3cd0147b2dd162b5e18 100644 (file)
@@ -70,7 +70,7 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&dg00x->lock);
        if (dg00x->dev_lock_changed || dg00x->msg)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&dg00x->lock);
index 68e273fa5d233f164763bc9ef22933f3803787c1..336c0076ec42150c9b936dd66d326e8a1430a089 100644 (file)
@@ -62,7 +62,7 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&ff->lock);
        if (ff->dev_lock_changed)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&ff->lock);
index e0eff9328ee10040f337df7aeddee64784822e0d..5cac26ab20b7105db6534c56b4fa577f1d2d4f21 100644 (file)
@@ -194,12 +194,12 @@ hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait)
 
        spin_lock_irq(&efw->lock);
        if (efw->dev_lock_changed || efw->pull_ptr != efw->push_ptr)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&efw->lock);
 
-       return events | POLLOUT;
+       return events | EPOLLOUT;
 }
 
 static int
index 7b6a086866e7a26fe06732e70aa8f14e529b3ce2..5f772eab588ba8cdbaff7e9f4373808c3dbae8fb 100644 (file)
@@ -69,12 +69,12 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&motu->lock);
        if (motu->dev_lock_changed || motu->msg)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&motu->lock);
 
-       return events | POLLOUT;
+       return events | EPOLLOUT;
 }
 
 static int hwdep_get_info(struct snd_motu *motu, void __user *arg)
index 6c1828aff672ded8ba21072e0587cd5768ed0df3..50a1c03b42b9aa2bb6f86b820b58acb0fe74a8af 100644 (file)
@@ -62,7 +62,7 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&oxfw->lock);
        if (oxfw->dev_lock_changed)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&oxfw->lock);
index 37b21647b471661f5fd1c87a21354bd428209b2c..4e4c1e9020e8cb3e930828513949a07c087cf717 100644 (file)
@@ -60,7 +60,7 @@ static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 
        spin_lock_irq(&tscm->lock);
        if (tscm->dev_lock_changed)
-               events = POLLIN | POLLRDNORM;
+               events = EPOLLIN | EPOLLRDNORM;
        else
                events = 0;
        spin_unlock_irq(&tscm->lock);
index 6b57f8aac1b700c621768dbf202b9d8b786fdc9f..8c0f8a9ee0baef5bd42961742b91b50356f90bbb 100644 (file)
@@ -684,7 +684,7 @@ static __poll_t sq_poll(struct file *file, struct poll_table_struct *wait)
                poll_wait(file, &write_sq.action_queue, wait);
        if (file->f_mode & FMODE_WRITE)
                if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
-                       mask |= POLLOUT | POLLWRNORM;
+                       mask |= EPOLLOUT | EPOLLWRNORM;
        return mask;
 
 }
index 05ccc7fdcc09f82c94f8e79a4753310fd0a549b0..56537a1565800a0ff3cb58f1c0b159b15b5987c8 100644 (file)
@@ -246,7 +246,7 @@ static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
        struct usb_mixer_interface *mixer = hw->private_data;
 
        poll_wait(file, &mixer->rc_waitq, wait);
-       return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
+       return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
 }
 
 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
index e2be10d1711833f3803b5609abe08d60e5fb9065..ebcab5c5465d28dfff6b0fbebc5185b3e8f30001 100644 (file)
@@ -280,7 +280,7 @@ static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw,
 
        poll_wait(file, &us122l->sk.sleep, wait);
 
-       mask = POLLIN | POLLOUT | POLLWRNORM | POLLERR;
+       mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM | EPOLLERR;
        if (mutex_trylock(&us122l->mutex)) {
                struct usb_stream *s = us122l->sk.s;
                if (s && s->state == usb_stream_ready) {
@@ -290,7 +290,7 @@ static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw,
                                polled = &us122l->second_periods_polled;
                        if (*polled != s->periods_done) {
                                *polled = s->periods_done;
-                               mask = POLLIN | POLLOUT | POLLWRNORM;
+                               mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM;
                        } else
                                mask = 0;
                }
index 07d15bae75bceb8efa5c211a248bdb8551d902cc..d8bd7c99b48c91ab5a64914af75a434755922256 100644 (file)
@@ -92,12 +92,12 @@ static __poll_t snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll
        struct usX2Ydev *us428 = hw->private_data;
        struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem;
        if (us428->chip_status & USX2Y_STAT_CHIP_HUP)
-               return POLLHUP;
+               return EPOLLHUP;
 
        poll_wait(file, &us428->us428ctls_wait_queue_head, wait);
 
        if (shm != NULL && shm->CtlSnapShotLast != shm->CtlSnapShotRed)
-               mask |= POLLIN;
+               mask |= EPOLLIN;
 
        return mask;
 }
index a334399fafec5c19231b61bd1c032a5bffa10c7b..6e865e8b5b1096b103bfb0d6e8509d1eafb10beb 100644 (file)
@@ -194,7 +194,7 @@ irqfd_wakeup(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
        unsigned seq;
        int idx;
 
-       if (flags & POLLIN) {
+       if (flags & EPOLLIN) {
                idx = srcu_read_lock(&kvm->irq_srcu);
                do {
                        seq = read_seqcount_begin(&irqfd->irq_entry_sc);
@@ -208,7 +208,7 @@ irqfd_wakeup(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
                srcu_read_unlock(&kvm->irq_srcu, idx);
        }
 
-       if (flags & POLLHUP) {
+       if (flags & EPOLLHUP) {
                /* The eventfd is closing, detach from KVM */
                unsigned long flags;
 
@@ -399,12 +399,12 @@ kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
         */
        events = f.file->f_op->poll(f.file, &irqfd->pt);
 
-       if (events & POLLIN)
+       if (events & EPOLLIN)
                schedule_work(&irqfd->inject);
 
        /*
         * do not drop the file until the irqfd is fully initialized, otherwise
-        * we might race against the POLLHUP
+        * we might race against the EPOLLHUP
         */
        fdput(f);
 #ifdef CONFIG_HAVE_KVM_IRQ_BYPASS