set_bit(TTY_OTHER_CLOSED, &tty->flags);
 #ifdef CONFIG_UNIX98_PTYS
                if (tty->driver == ptm_driver)
-                       devpts_pty_kill(tty->index);
+                       devpts_pty_kill(tty->link);
 #endif
                tty_vhangup(tty->link);
        }
  *     This provides our locking.
  */
 
-static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver, int idx)
+static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
+               struct inode *ptm_inode, int idx)
 {
-       struct tty_struct *tty = devpts_get_tty(idx);
+       struct tty_struct *tty = devpts_get_tty(ptm_inode, idx);
        if (tty)
                tty = tty->link;
        return tty;
  *     This provides our locking.
  */
 
-static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver, int idx)
+static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
+               struct inode *pts_inode, int idx)
 {
-       struct tty_struct *tty = devpts_get_tty(idx);
+       struct tty_struct *tty = devpts_get_tty(pts_inode, idx);
        /* Master must be open before slave */
        if (!tty)
                return ERR_PTR(-EIO);
        nonseekable_open(inode, filp);
 
        /* find a device that is not in use. */
-       index = devpts_new_index();
+       index = devpts_new_index(inode);
        if (index < 0)
                return index;
 
        filp->private_data = tty;
        file_move(filp, &tty->tty_files);
 
-       retval = devpts_pty_new(tty->link);
+       retval = devpts_pty_new(inode, tty->link);
        if (retval)
                goto out1;
 
        tty_release_dev(filp);
        return retval;
 out:
-       devpts_kill_index(index);
+       devpts_kill_index(inode, index);
        return retval;
 }
 
 
  *     be held until the 'fast-open' is also done. Will change once we
  *     have refcounting in the driver and per driver locking
  */
-struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver, int idx)
+struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
+               struct inode *inode, int idx)
 {
        struct tty_struct *tty;
 
        if (driver->ops->lookup)
-               return driver->ops->lookup(driver, idx);
+               return driver->ops->lookup(driver, inode, idx);
 
        tty = driver->ttys[idx];
        return tty;
        int     devpts;
        int     idx;
        char    buf[64];
+       struct  inode *inode;
 
+       inode = filp->f_path.dentry->d_inode;
        tty = (struct tty_struct *)filp->private_data;
-       if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode,
-                                                       "tty_release_dev"))
+       if (tty_paranoia_check(tty, inode, "tty_release_dev"))
                return;
 
        check_tty_count(tty, "tty_release_dev");
 
        /* Make this pty number available for reallocation */
        if (devpts)
-               devpts_kill_index(idx);
+               devpts_kill_index(inode, idx);
 }
 
 /**
 got_driver:
        if (!tty) {
                /* check whether we're reopening an existing tty */
-               tty = tty_driver_lookup_tty(driver, index);
+               tty = tty_driver_lookup_tty(driver, inode, index);
 
                if (IS_ERR(tty))
                        return PTR_ERR(tty);
 
        return lookup_one_len(s, root, sprintf(s, "%d", num));
 }
 
-int devpts_new_index(void)
+int devpts_new_index(struct inode *ptmx_inode)
 {
        int index;
        int ida_ret;
        return index;
 }
 
-void devpts_kill_index(int idx)
+void devpts_kill_index(struct inode *ptmx_inode, int idx)
 {
        mutex_lock(&allocated_ptys_lock);
        ida_remove(&allocated_ptys, idx);
        mutex_unlock(&allocated_ptys_lock);
 }
 
-int devpts_pty_new(struct tty_struct *tty)
+int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty)
 {
        int number = tty->index; /* tty layer puts index from devpts_new_index() in here */
        struct tty_driver *driver = tty->driver;
        return 0;
 }
 
-struct tty_struct *devpts_get_tty(int number)
+struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number)
 {
        struct dentry *dentry = get_node(number);
        struct tty_struct *tty;
        return tty;
 }
 
-void devpts_pty_kill(int number)
+void devpts_pty_kill(struct tty_struct *tty)
 {
+       int number = tty->index;
        struct dentry *dentry = get_node(number);
 
        if (!IS_ERR(dentry)) {
 
 
 #ifdef CONFIG_UNIX98_PTYS
 
-int devpts_new_index(void);
-void devpts_kill_index(int idx);
-int devpts_pty_new(struct tty_struct *tty);      /* mknod in devpts */
-struct tty_struct *devpts_get_tty(int number);  /* get tty structure */
-void devpts_pty_kill(int number);               /* unlink */
+int devpts_new_index(struct inode *ptmx_inode);
+void devpts_kill_index(struct inode *ptmx_inode, int idx);
+/* mknod in devpts */
+int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty);
+/* get tty structure */
+struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number);
+/* unlink */
+void devpts_pty_kill(struct tty_struct *tty);
 
 #else
 
 /* Dummy stubs in the no-pty case */
-static inline int devpts_new_index(void) { return -EINVAL; }
-static inline void devpts_kill_index(int idx) { }
-static inline int devpts_pty_new(struct tty_struct *tty) { return -EINVAL; }
-static inline struct tty_struct *devpts_get_tty(int number) { return NULL; }
-static inline void devpts_pty_kill(int number) { }
+static inline int devpts_new_index(struct inode *ptmx_inode) { return -EINVAL; }
+static inline void devpts_kill_index(struct inode *ptmx_inode, int idx) { }
+static inline int devpts_pty_new(struct inode *ptmx_inode,
+                               struct tty_struct *tty)
+{
+       return -EINVAL;
+}
+static inline struct tty_struct *devpts_get_tty(struct inode *pts_inode,
+               int number)
+{
+       return NULL;
+}
+static inline void devpts_pty_kill(struct tty_struct *tty) { }
 
 #endif
 
 
 struct tty_driver;
 
 struct tty_operations {
-       struct tty_struct * (*lookup)(struct tty_driver *driver, int idx);
+       struct tty_struct * (*lookup)(struct tty_driver *driver,
+                       struct inode *inode, int idx);
        int  (*install)(struct tty_driver *driver, struct tty_struct *tty);
        void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
        int  (*open)(struct tty_struct * tty, struct file * filp);