if (err < 0)
                goto err_out_cleanup_hw;
 
-       sigio_broken(random_fd, 1);
+       sigio_broken(random_fd);
        hwrng.name = RNG_MODULE_NAME;
        hwrng.read = rng_dev_read;
        hwrng.quality = 1024;
 
 #include <os.h>
 #include "vhost_user.h"
 
-/* Workaround due to a conflict between irq_user.h and irqreturn.h */
-#ifdef IRQ_NONE
-#undef IRQ_NONE
-#endif
-
 #define MAX_SUPPORTED_QUEUE_SIZE       256
 
 #define to_virtio_uml_device(_vdev) \
 
 
 #include <linux/interrupt.h>
 #include <asm/ptrace.h>
+#include "irq_user.h"
 
 #define UM_IRQ_ALLOC   -1
 
-int um_request_irq(int irq, int fd, int type, irq_handler_t handler,
-                  unsigned long irqflags,  const char * devname,
-                  void *dev_id);
+int um_request_irq(int irq, int fd, enum um_irq_type type,
+                  irq_handler_t handler, unsigned long irqflags,
+                  const char *devname, void *dev_id);
 void um_free_irq(int irq, void *dev_id);
 #endif
 
 #include <sysdep/ptrace.h>
 #include <stdbool.h>
 
-#define IRQ_READ  0
-#define IRQ_WRITE 1
-#define IRQ_NONE 2
-#define NUM_IRQ_TYPES (IRQ_NONE + 1)
+enum um_irq_type {
+       IRQ_READ,
+       IRQ_WRITE,
+       NUM_IRQ_TYPES,
+};
 
 struct siginfo;
 extern void sigio_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs);
 
 extern int os_waiting_for_events_epoll(void);
 extern void *os_epoll_get_data_pointer(int index);
 extern int os_epoll_triggered(int index, int events);
-extern int os_event_mask(int irq_type);
+extern int os_event_mask(enum um_irq_type irq_type);
 extern int os_setup_epoll(void);
 extern int os_add_epoll_fd(int events, int fd, void *data);
 extern int os_mod_epoll_fd(int events, int fd, void *data);
 /* sigio.c */
 extern int add_sigio_fd(int fd);
 extern int ignore_sigio_fd(int fd);
-extern void maybe_sigio_broken(int fd, int read);
-extern void sigio_broken(int fd, int read);
+extern void maybe_sigio_broken(int fd);
+extern void sigio_broken(int fd);
 
 /* prctl.c */
 extern int os_arch_prctl(int pid, int option, unsigned long *arg2);
 
 
 struct irq_reg {
        void *id;
-       int type;
+       enum um_irq_type type;
        int irq;
        int events;
        bool active;
                }
 
                for (i = 0; i < n ; i++) {
-                       /* Epoll back reference is the entry with 3 irq_reg
+                       /* Epoll back reference is the entry with 2 irq_reg
                         * leaves - one for each irq type.
                         */
                        irq_entry = (struct irq_entry *)
 
 
 
-static int activate_fd(int irq, int fd, int type, void *dev_id)
+static int activate_fd(int irq, int fd, enum um_irq_type type, void *dev_id)
 {
        struct irq_reg *new_fd;
        struct irq_entry *irq_entry;
        /* Turn back IO on with the correct (new) IO event mask */
        assign_epoll_events_to_irq(irq_entry);
        spin_unlock_irqrestore(&irq_lock, flags);
-       maybe_sigio_broken(fd, (type != IRQ_NONE));
+       maybe_sigio_broken(fd);
 
        return 0;
 out_unlock:
 }
 EXPORT_SYMBOL(um_free_irq);
 
-int um_request_irq(int irq, int fd, int type,
-                  irq_handler_t handler,
-                  unsigned long irqflags, const char * devname,
-                  void *dev_id)
+int um_request_irq(int irq, int fd, enum um_irq_type type,
+                  irq_handler_t handler, unsigned long irqflags,
+                  const char *devname, void *dev_id)
 {
        int err;
 
 
  * access to the right includes/defines for EPOLL constants.
  */
 
-int os_event_mask(int irq_type)
+int os_event_mask(enum um_irq_type irq_type)
 {
        if (irq_type == IRQ_READ)
                return EPOLLIN | EPOLLPRI;
 
        close(l_write_sigio_fds[1]);
 }
 
-void sigio_broken(int fd, int read)
+void sigio_broken(int fd)
 {
        int err;
 
 
        all_sigio_fds.poll[all_sigio_fds.used++] =
                ((struct pollfd) { .fd          = fd,
-                                  .events      = read ? POLLIN : POLLOUT,
+                                  .events      = POLLIN,
                                   .revents     = 0 });
 out:
        sigio_unlock();
 
 /* Changed during early boot */
 static int pty_output_sigio;
-static int pty_close_sigio;
 
-void maybe_sigio_broken(int fd, int read)
+void maybe_sigio_broken(int fd)
 {
        if (!isatty(fd))
                return;
 
-       if ((read || pty_output_sigio) && (!read || pty_close_sigio))
+       if (pty_output_sigio)
                return;
 
-       sigio_broken(fd, read);
+       sigio_broken(fd);
 }
 
 static void sigio_cleanup(void)
                printk(UM_KERN_CONT "tty_output : read failed, err = %d\n", n);
 }
 
-static void tty_close(int master, int slave)
-{
-       printk(UM_KERN_INFO "Checking that host ptys support SIGIO on "
-              "close...");
-
-       close(slave);
-       if (got_sigio) {
-               printk(UM_KERN_CONT "Yes\n");
-               pty_close_sigio = 1;
-       } else
-               printk(UM_KERN_CONT "No, enabling workaround\n");
-}
-
 static void __init check_sigio(void)
 {
        if ((access("/dev/ptmx", R_OK) < 0) &&
                return;
        }
        check_one_sigio(tty_output);
-       check_one_sigio(tty_close);
 }
 
 /* Here because it only does the SIGIO testing for now */