deactivate_fd(chan->fd, irq);
 }
 
-void reactivate_chan(struct chan *chan, int irq)
-{
-       if (chan && chan->enabled)
-               reactivate_fd(chan->fd, irq);
-}
-
 int write_chan(struct chan *chan, const char *buf, int len,
               int write_irq)
 {
        n = chan->ops->write(chan->fd, buf, len, chan->data);
        if (chan->primary) {
                ret = n;
-               if ((ret == -EAGAIN) || ((ret >= 0) && (ret < len)))
-                       reactivate_fd(chan->fd, write_irq);
        }
        return ret;
 }
                        tty_insert_flip_char(port, c, TTY_NORMAL);
        } while (err > 0);
 
-       if (err == 0)
-               reactivate_fd(chan->fd, irq);
        if (err == -EIO) {
                if (chan->primary) {
                        tty_port_tty_hangup(&line->port, false);
 
 
        line->throttled = 0;
        chan_interrupt(line, line->driver->read_irq);
-
-       /*
-        * Maybe there is enough stuff pending that calling the interrupt
-        * throttles us again.  In this case, line->throttled will be 1
-        * again and we shouldn't turn the interrupt back on.
-        */
-       if (!line->throttled)
-               reactivate_chan(line->chan_in, line->driver->read_irq);
 }
 
 static irqreturn_t line_write_interrupt(int irq, void *data)
                tty_kref_put(tty);
        }
  out:
-       if (winch->fd != -1)
-               reactivate_fd(winch->fd, WINCH_IRQ);
        return IRQ_HANDLED;
 }
 
 
        }
        if (!list_empty(&mc_requests))
                schedule_work(&mconsole_work);
-       reactivate_fd(fd, MCONSOLE_IRQ);
        return IRQ_HANDLED;
 }
 
                (*req->cmd->handler)(req);
        }
        os_set_fd_block(req->originating_fd, 0);
-       reactivate_fd(req->originating_fd, MCONSOLE_IRQ);
        mconsole_reply(req, "", 0, 0);
 }
 
 
                schedule_work(&lp->work);
                goto out;
        }
-       reactivate_fd(lp->fd, UM_ETH_IRQ);
-
 out:
        spin_unlock(&lp->lock);
        return IRQ_HANDLED;
 
                if (!port->has_connection)
                        continue;
 
-               reactivate_fd(port->fd, ACCEPT_IRQ);
                while (port_accept(port))
                        ;
                port->has_connection = 0;
 
                                return ret ? : -EAGAIN;
 
                        atomic_inc(&host_sleep_count);
-                       reactivate_fd(random_fd, RANDOM_IRQ);
                        add_sigio_fd(random_fd);
 
                        add_wait_queue(&host_read_wait, &wait);
 
                        kfree(io_req);
                }
        }
-       reactivate_fd(thread_fd, UBD_IRQ);
 }
 
 static irqreturn_t ubd_intr(int irq, void *dev)
 
 struct siginfo;
 extern void sigio_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs);
 extern void free_irq_by_fd(int fd);
-extern void reactivate_fd(int fd, int irqnum);
 extern void deactivate_fd(int fd, int irqnum);
 extern int deactivate_all_fds(void);
 extern int activate_ipi(int fd, int pid);
 
 }
 
 
-void reactivate_fd(int fd, int irqnum)
-{
-       /** NOP - we do auto-EOI now **/
-}
-
 void deactivate_fd(int fd, int irqnum)
 {
        struct irq_entry *to_free;
 }
 
 EXPORT_SYMBOL(um_request_irq);
-EXPORT_SYMBOL(reactivate_fd);
 
 /*
  * irq_chip must define at least enable/disable and ack when
 
        char c;
 
        os_read_file(sigio_irq_fd, &c, sizeof(c));
-       reactivate_fd(sigio_irq_fd, SIGIO_WRITE_IRQ);
        return IRQ_HANDLED;
 }