btrfs_end_transaction(trans, root);
 
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 
        ret = 0;
  out_unlock:
        dput(dentry);
 out_unlock_dir:
        mutex_unlock(&dir->i_mutex);
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 out:
        kfree(vol_args);
        return err;
                ret = -EINVAL;
        }
 out:
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
        return ret;
 }
 
 out_fput:
        fput(src_file);
 out_drop_write:
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
        return ret;
 }
 
 
 out_drop:
        atomic_dec(&root->fs_info->open_ioctl_trans);
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 out:
        return ret;
 }
 
        atomic_dec(&root->fs_info->open_ioctl_trans);
 
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
        return 0;
 }
 
 
                inode->i_ctime = CURRENT_TIME_SEC;
                mark_inode_dirty(inode);
 setflags_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return ret;
        }
        case EXT2_IOC_GETVERSION:
                        inode->i_ctime = CURRENT_TIME_SEC;
                        mark_inode_dirty(inode);
                }
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return ret;
        case EXT2_IOC_GETRSVSZ:
                if (test_opt(inode->i_sb, RESERVATION)
                        rsv->rsv_goal_size = rsv_window_size;
                }
                mutex_unlock(&ei->truncate_mutex);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return 0;
        }
        default:
 
                        err = ext3_change_inode_journal_flag(inode, jflag);
 flags_out:
                mutex_unlock(&inode->i_mutex);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT3_IOC_GETVERSION:
                }
                ext3_journal_stop(handle);
 setversion_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT3_IOC_GETRSVSZ:
                }
                mutex_unlock(&ei->truncate_mutex);
 setrsvsz_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT3_IOC_GROUP_EXTEND: {
                if (err == 0)
                        err = err2;
 group_extend_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT3_IOC_GROUP_ADD: {
                if (err == 0)
                        err = err2;
 group_add_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case FITRIM: {
 
                        err = ext4_ext_migrate(inode);
 flags_out:
                mutex_unlock(&inode->i_mutex);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT4_IOC_GETVERSION:
                }
                ext4_journal_stop(handle);
 setversion_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        case EXT4_IOC_GROUP_EXTEND: {
                }
                if (err == 0)
                        err = err2;
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                ext4_resize_end(sb);
 
                return err;
 
                err = ext4_move_extents(filp, donor_filp, me.orig_start,
                                        me.donor_start, me.len, &me.moved_len);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                if (me.moved_len > 0)
                        file_remove_suid(donor_filp);
 
                }
                if (err == 0)
                        err = err2;
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                ext4_resize_end(sb);
 
                return err;
                mutex_lock(&(inode->i_mutex));
                err = ext4_ext_migrate(inode);
                mutex_unlock(&(inode->i_mutex));
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
 
                if (err)
                        return err;
                err = ext4_alloc_da_blocks(inode);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
 
 
        fat_save_attrs(inode, attr);
        mark_inode_dirty(inode);
 out_drop_write:
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 out_unlock_inode:
        mutex_unlock(&inode->i_mutex);
 out:
 
 out:
        gfs2_glock_dq_uninit(&gh);
 out_drop_write:
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
        return error;
 }
 
 
 out_unlock_inode:
        mutex_unlock(&inode->i_mutex);
 out_drop_write:
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 out:
        return err;
 }
 
        if (sync_it & S_MTIME)
                inode->i_mtime = now;
        mark_inode_dirty_sync(inode);
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 }
 EXPORT_SYMBOL(file_update_time);
 
 
                inode->i_ctime = CURRENT_TIME_SEC;
                mark_inode_dirty(inode);
 setflags_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return err;
        }
        default:
 
 }
 EXPORT_SYMBOL_GPL(mnt_drop_write);
 
+void mnt_drop_write_file(struct file *file)
+{
+       mnt_drop_write(file->f_path.mnt);
+}
+EXPORT_SYMBOL(mnt_drop_write_file);
+
 static int mnt_make_readonly(struct vfsmount *mnt)
 {
        int ret = 0;
 
        ret = __ncp_ioctl(inode, cmd, arg);
 outDropWrite:
        if (need_drop_write)
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
 out:
        return ret;
 }
 
        if (status)
                goto out_put;
        status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
-       mnt_drop_write(rec_file->f_path.mnt);
+       mnt_drop_write_file(rec_file);
 out_put:
        dput(dentry);
 out_unlock:
        nfs4_reset_creds(original_cred);
        if (status == 0)
                vfs_fsync(rec_file, 0);
-       mnt_drop_write(rec_file->f_path.mnt);
+       mnt_drop_write_file(rec_file);
 out:
        if (status)
                printk("NFSD: Failed to remove expired client state directory"
        status = nfsd4_list_rec_dir(purge_old);
        if (status == 0)
                vfs_fsync(rec_file, 0);
-       mnt_drop_write(rec_file->f_path.mnt);
+       mnt_drop_write_file(rec_file);
 out:
        if (status)
                printk("nfsd4: failed to purge old clients from recovery"
 
 #include <linux/uaccess.h>     /* copy_from_user(), copy_to_user() */
 #include <linux/vmalloc.h>
 #include <linux/compat.h>      /* compat_ptr() */
-#include <linux/mount.h>       /* mnt_want_write_file(), mnt_drop_write() */
+#include <linux/mount.h>       /* mnt_want_write_file(), mnt_drop_write_file() */
 #include <linux/buffer_head.h>
 #include <linux/nilfs2_fs.h>
 #include "nilfs.h"
        ret = nilfs_transaction_commit(inode->i_sb);
 out:
        mutex_unlock(&inode->i_mutex);
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
        return ret;
 }
 
 
        up_read(&inode->i_sb->s_umount);
 out:
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
        return ret;
 }
 
        else
                nilfs_transaction_commit(inode->i_sb); /* never fails */
 out:
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
        return ret;
 }
 
                vfree(kbufs[n]);
        kfree(kbufs[4]);
 out:
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
        return ret;
 }
 
        ret = nilfs_resize_fs(inode->i_sb, newsize);
 
 out_drop_write:
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
 out:
        return ret;
 }
 
                        return status;
                status = ocfs2_set_inode_attr(inode, flags,
                        OCFS2_FL_MODIFIABLE);
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                return status;
        case OCFS2_IOC_RESVSP:
        case OCFS2_IOC_RESVSP64:
 
 
        kfree(context);
 
-       mnt_drop_write(filp->f_path.mnt);
+       mnt_drop_write_file(filp);
 
        return status;
 }
 
        dentry = file->f_path.dentry;
        audit_inode(NULL, dentry);
        error = chown_common(&file->f_path, user, group);
-       mnt_drop_write(file->f_path.mnt);
+       mnt_drop_write_file(file);
 out_fput:
        fput(file);
 out:
 
                        inode->i_ctime = CURRENT_TIME_SEC;
                        mark_inode_dirty(inode);
 setflags_out:
-                       mnt_drop_write(filp->f_path.mnt);
+                       mnt_drop_write_file(filp);
                        break;
                }
        case REISERFS_IOC_GETVERSION:
                inode->i_ctime = CURRENT_TIME_SEC;
                mark_inode_dirty(inode);
 setversion_out:
-               mnt_drop_write(filp->f_path.mnt);
+               mnt_drop_write_file(filp);
                break;
        default:
                err = -ENOTTY;
 
                        return err;
                dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
                err = setflags(inode, flags);
-               mnt_drop_write(file->f_path.mnt);
+               mnt_drop_write_file(file);
                return err;
        }
 
 
        error = mnt_want_write_file(f);
        if (!error) {
                error = setxattr(dentry, name, value, size, flags);
-               mnt_drop_write(f->f_path.mnt);
+               mnt_drop_write_file(f);
        }
        fput(f);
        return error;
        error = mnt_want_write_file(f);
        if (!error) {
                error = removexattr(dentry, name);
-               mnt_drop_write(f->f_path.mnt);
+               mnt_drop_write_file(f);
        }
        fput(f);
        return error;
 
                                        dentry->d_inode, attr_name,
                                        ops[i].am_attrvalue, ops[i].am_length,
                                        ops[i].am_flags);
-                       mnt_drop_write(parfilp->f_path.mnt);
+                       mnt_drop_write_file(parfilp);
                        break;
                case ATTR_OP_REMOVE:
                        ops[i].am_error = mnt_want_write_file(parfilp);
                        ops[i].am_error = xfs_attrmulti_attr_remove(
                                        dentry->d_inode, attr_name,
                                        ops[i].am_flags);
-                       mnt_drop_write(parfilp->f_path.mnt);
+                       mnt_drop_write_file(parfilp);
                        break;
                default:
                        ops[i].am_error = EINVAL;
 
                                        dentry->d_inode, attr_name,
                                        compat_ptr(ops[i].am_attrvalue),
                                        ops[i].am_length, ops[i].am_flags);
-                       mnt_drop_write(parfilp->f_path.mnt);
+                       mnt_drop_write_file(parfilp);
                        break;
                case ATTR_OP_REMOVE:
                        ops[i].am_error = mnt_want_write_file(parfilp);
                        ops[i].am_error = xfs_attrmulti_attr_remove(
                                        dentry->d_inode, attr_name,
                                        ops[i].am_flags);
-                       mnt_drop_write(parfilp->f_path.mnt);
+                       mnt_drop_write_file(parfilp);
                        break;
                default:
                        ops[i].am_error = EINVAL;
 
 extern int mnt_want_write_file(struct file *file);
 extern int mnt_clone_write(struct vfsmount *mnt);
 extern void mnt_drop_write(struct vfsmount *mnt);
+extern void mnt_drop_write_file(struct file *file);
 extern void mntput(struct vfsmount *mnt);
 extern struct vfsmount *mntget(struct vfsmount *mnt);
 extern void mnt_pin(struct vfsmount *mnt);