if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
             N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
            N_TRSIZE(ex) || N_DRSIZE(ex) ||
-           bprm->file->f_dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
+           bprm->file->f_path.dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
                return -ENOEXEC;
        }
 
        int retval;
        struct exec ex;
 
-       inode = file->f_dentry->d_inode;
+       inode = file->f_path.dentry->d_inode;
 
        retval = -ENOEXEC;
        error = kernel_read(file, 0, (char *) &ex, sizeof(ex));
 
                file = fget(fd);
                if (!file)
                        goto out;
-               inode = file->f_dentry->d_inode;
+               inode = file->f_path.dentry->d_inode;
                if (imajor(inode) == MEM_MAJOR && iminor(inode) == 5) {
                        flags |= MAP_ANONYMOUS;
                        fput(file);
        if (!file)
                return 0;
 
-       inode = file->f_dentry->d_inode;
+       inode = file->f_path.dentry->d_inode;
 
        socket = SOCKET_I(inode);
        local.sin_family = AF_INET;
 
        error = -EBADF;
        file = fget(fd);
        if (file) {
-               error = report_statvfs(file->f_vfsmnt, file->f_dentry->d_inode, buf);
+               error = report_statvfs(file->f_path.mnt, file->f_path.dentry->d_inode, buf);
                fput(file);
        }
 
        file = fget(fd);
        if (file) {
                lock_kernel();
-               error = report_statvfs64(file->f_vfsmnt, file->f_dentry->d_inode, buf);
+               error = report_statvfs64(file->f_path.mnt, file->f_path.dentry->d_inode, buf);
                unlock_kernel();
                fput(file);
        }
 
        rcu_read_lock();
        fdt = files_fdtable(current->files);
        if (! fdt->fd[fd] ||
-           ! fdt->fd[fd]->f_dentry ||
-           ! (ino = fdt->fd[fd]->f_dentry->d_inode) ||
+           ! fdt->fd[fd]->f_path.dentry ||
+           ! (ino = fdt->fd[fd]->f_path.dentry->d_inode) ||
            ! S_ISSOCK(ino->i_mode)) {
                rcu_read_unlock();
                return TBADF;
         struct sol_socket_struct *sock;
         struct module_info *mi;
 
-        ino = filp->f_dentry->d_inode;
+        ino = filp->f_path.dentry->d_inode;
         if (!S_ISSOCK(ino->i_mode))
                return -EBADF;
         sock = filp->private_data;
 
                if (!file)
                        goto out;
                else {
-                       struct inode * inode = file->f_dentry->d_inode;
+                       struct inode * inode = file->f_path.dentry->d_inode;
                        if(imajor(inode) == MEM_MAJOR &&
                           iminor(inode) == 5) {
                                flags |= MAP_ANONYMOUS;
 
         * No shit.  WTF is it supposed to do, anyway?
         *
         * Try instead:
-        * d_delete(filp->f_dentry), then d_instantiate with sock inode
+        * d_delete(filp->f_path.dentry), then d_instantiate with sock inode
         */
-       dentry = filp->f_dentry;
-       filp->f_dentry = dget(fcheck(fd)->f_dentry);
-       filp->f_dentry->d_inode->i_rdev = inode->i_rdev;
-       filp->f_dentry->d_inode->i_flock = inode->i_flock;
-       SOCKET_I(filp->f_dentry->d_inode)->file = filp;
+       dentry = filp->f_path.dentry;
+       filp->f_path.dentry = dget(fcheck(fd)->f_path.dentry);
+       filp->f_path.dentry->d_inode->i_rdev = inode->i_rdev;
+       filp->f_path.dentry->d_inode->i_flock = inode->i_flock;
+       SOCKET_I(filp->f_path.dentry->d_inode)->file = filp;
        filp->f_op = &socksys_file_ops;
         sock = (struct sol_socket_struct*) 
                mykmalloc(sizeof(struct sol_socket_struct), GFP_KERNEL);
        struct inode *ino;
        unsigned int mask = 0;
 
-       ino=filp->f_dentry->d_inode;
+       ino=filp->f_path.dentry->d_inode;
        if (ino && S_ISSOCK(ino->i_mode)) {
                struct sol_socket_struct *sock;
                sock = (struct sol_socket_struct*)filp->private_data;
 
 
        SOLD("wakeing socket");
        fdt = files_fdtable(current->files);
-       sock = SOCKET_I(fdt->fd[fd]->f_dentry->d_inode);
+       sock = SOCKET_I(fdt->fd[fd]->f_path.dentry->d_inode);
        wake_up_interruptible(&sock->wait);
        read_lock(&sock->sk->sk_callback_lock);
        if (sock->fasync_list && !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
 
        fdt = files_fdtable(current->files);
        filp = fdt->fd[fd];
-       ino = filp->f_dentry->d_inode;
+       ino = filp->f_path.dentry->d_inode;
        sock = (struct sol_socket_struct *)filp->private_data;
        SOLD("entry");
        if (get_user(ret, (int __user *)A(ctl_buf)))
        SOLDD(("%u %p %d %p %p %d %p %d\n", fd, ctl_buf, ctl_maxlen, ctl_len, data_buf, data_maxlen, data_len, *flags_p));
        fdt = files_fdtable(current->files);
        filp = fdt->fd[fd];
-       ino = filp->f_dentry->d_inode;
+       ino = filp->f_path.dentry->d_inode;
        sock = (struct sol_socket_struct *)filp->private_data;
        SOLDD(("%p %p\n", sock->pfirst, sock->pfirst ? sock->pfirst->next : NULL));
        if ( ctl_maxlen > 0 && !sock->pfirst && SOCKET_I(ino)->type == SOCK_STREAM
        filp = fdt->fd[fd];
        if(!filp) goto out;
 
-       ino = filp->f_dentry->d_inode;
+       ino = filp->f_path.dentry->d_inode;
        if (!ino || !S_ISSOCK(ino->i_mode))
                goto out;
 
        filp = fdt->fd[fd];
        if(!filp) goto out;
 
-       ino = filp->f_dentry->d_inode;
+       ino = filp->f_path.dentry->d_inode;
        if (!ino) goto out;
 
        if (!S_ISSOCK(ino->i_mode) &&