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)))
-  &