179 files changed, 426 insertions, 6536 deletions

diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index 410ffd6ceb5f..dc95a252523d 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -54,9 +54,9 @@ extern struct kmem_cache *v9fs_inode_cache;
 
 struct inode *v9fs_alloc_inode(struct super_block *sb);
 void v9fs_destroy_inode(struct inode *inode);
-struct inode *v9fs_get_inode(struct super_block *sb, int mode, dev_t);
+struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t);
 int v9fs_init_inode(struct v9fs_session_info *v9ses,
-                    struct inode *inode, int mode, dev_t);
+                    struct inode *inode, umode_t mode, dev_t);
 void v9fs_evict_inode(struct inode *inode);
 ino_t v9fs_qid2ino(struct p9_qid *qid);
 void v9fs_stat2inode(struct p9_wstat *, struct inode *, struct super_block *);
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 2310cc9eb402..e0f20de6aa2b 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -59,15 +59,13 @@ static const struct inode_operations v9fs_symlink_inode_operations;
  *
  */
 
-static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
+static u32 unixmode2p9mode(struct v9fs_session_info *v9ses, umode_t mode)
 {
         int res;
         res = mode & 0777;
         if (S_ISDIR(mode))
                 res |= P9_DMDIR;
         if (v9fs_proto_dotu(v9ses)) {
-                if (S_ISLNK(mode))
-                        res |= P9_DMSYMLINK;
                 if (v9ses->nodev == 0) {
                         if (S_ISSOCK(mode))
                                 res |= P9_DMSOCKET;
@@ -85,10 +83,7 @@ static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
                         res |= P9_DMSETGID;
                 if ((mode & S_ISVTX) == S_ISVTX)
                         res |= P9_DMSETVTX;
-                if ((mode & P9_DMLINK))
-                        res |= P9_DMLINK;
         }
-
         return res;
 }
 
@@ -99,11 +94,11 @@ static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
  * @rdev: major number, minor number in case of device files.
  *
  */
-static int p9mode2unixmode(struct v9fs_session_info *v9ses,
-                           struct p9_wstat *stat, dev_t *rdev)
+static umode_t p9mode2unixmode(struct v9fs_session_info *v9ses,
+                               struct p9_wstat *stat, dev_t *rdev)
 {
         int res;
-        int mode = stat->mode;
+        u32 mode = stat->mode;
 
         res = mode & S_IALLUGO;
         *rdev = 0;
@@ -260,7 +255,7 @@ void v9fs_destroy_inode(struct inode *inode)
 }
 
 int v9fs_init_inode(struct v9fs_session_info *v9ses,
-                    struct inode *inode, int mode, dev_t rdev)
+                    struct inode *inode, umode_t mode, dev_t rdev)
 {
         int err = 0;
 
@@ -334,7 +329,7 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
 
                 break;
         default:
-                P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
+                P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
                            mode, mode & S_IFMT);
                 err = -EINVAL;
                 goto error;
@@ -351,13 +346,13 @@ error:
  *
  */
 
-struct inode *v9fs_get_inode(struct super_block *sb, int mode, dev_t rdev)
+struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
 {
         int err;
         struct inode *inode;
         struct v9fs_session_info *v9ses = sb->s_fs_info;
 
-        P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
+        P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
 
         inode = new_inode(sb);
         if (!inode) {
@@ -491,7 +486,8 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
                                    int new)
 {
         dev_t rdev;
-        int retval, umode;
+        int retval;
+        umode_t umode;
         unsigned long i_ino;
         struct inode *inode;
         struct v9fs_session_info *v9ses = sb->s_fs_info;
@@ -702,7 +698,7 @@ error:
  */
 
 static int
-v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
+v9fs_vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         int err;
@@ -785,7 +781,7 @@ error:
  *
  */
 
-static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int err;
         u32 perm;
@@ -1130,7 +1126,7 @@ void
 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
         struct super_block *sb)
 {
-        mode_t mode;
+        umode_t mode;
         char ext[32];
         char tag_name[14];
         unsigned int i_nlink;
@@ -1303,9 +1299,8 @@ v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
  */
 
 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
-        int mode, const char *extension)
+        u32 perm, const char *extension)
 {
-        u32 perm;
         struct p9_fid *fid;
         struct v9fs_session_info *v9ses;
 
@@ -1315,7 +1310,6 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
                 return -EPERM;
         }
 
-        perm = unixmode2p9mode(v9ses, mode);
         fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
                                                                 P9_OREAD);
         if (IS_ERR(fid))
@@ -1342,7 +1336,7 @@ v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
         P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
                                         dentry->d_name.name, symname);
 
-        return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
+        return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
 }
 
 /**
@@ -1397,13 +1391,15 @@ clunk_fid:
  */
 
 static int
-v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
+v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
+        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
         int retval;
         char *name;
+        u32 perm;
 
         P9_DPRINTK(P9_DEBUG_VFS,
-                " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
+                " %lu,%s mode: %hx MAJOR: %u MINOR: %u\n", dir->i_ino,
                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
 
         if (!new_valid_dev(rdev))
@@ -1426,7 +1422,8 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
                 return -EINVAL;
         }
 
-        retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
+        perm = unixmode2p9mode(v9ses, mode);
+        retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
         __putname(name);
 
         return retval;
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 0b5745e21946..8ef152ac6a16 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -48,7 +48,7 @@
 #include "acl.h"
 
 static int
-v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
+v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                     dev_t rdev);
 
 /**
@@ -253,7 +253,7 @@ int v9fs_open_to_dotl_flags(int flags)
  */
 
 static int
-v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
+v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                 struct nameidata *nd)
 {
         int err = 0;
@@ -284,7 +284,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
 
         name = (char *) dentry->d_name.name;
         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_create_dotl: name:%s flags:0x%x "
-                        "mode:0x%x\n", name, flags, omode);
+                        "mode:0x%hx\n", name, flags, omode);
 
         dfid = v9fs_fid_lookup(dentry->d_parent);
         if (IS_ERR(dfid)) {
@@ -395,7 +395,7 @@ err_clunk_old_fid:
  */
 
 static int v9fs_vfs_mkdir_dotl(struct inode *dir,
-                               struct dentry *dentry, int omode)
+                               struct dentry *dentry, umode_t omode)
 {
         int err;
         struct v9fs_session_info *v9ses;
@@ -594,7 +594,7 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
 void
 v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
 {
-        mode_t mode;
+        umode_t mode;
         struct v9fs_inode *v9inode = V9FS_I(inode);
 
         if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
@@ -799,7 +799,7 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
  *
  */
 static int
-v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
+v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                 dev_t rdev)
 {
         int err;
@@ -814,7 +814,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
         struct posix_acl *dacl = NULL, *pacl = NULL;
 
         P9_DPRINTK(P9_DEBUG_VFS,
-                " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
+                " %lu,%s mode: %hx MAJOR: %u MINOR: %u\n", dir->i_ino,
                 dentry->d_name.name, omode, MAJOR(rdev), MINOR(rdev));
 
         if (!new_valid_dev(rdev))
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index c70251d47ed1..f68ff65a32a5 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -117,7 +117,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
         struct inode *inode = NULL;
         struct dentry *root = NULL;
         struct v9fs_session_info *v9ses = NULL;
-        int mode = S_IRWXUGO | S_ISVTX;
+        umode_t mode = S_IRWXUGO | S_ISVTX;
         struct p9_fid *fid;
         int retval = 0;
 
diff --git a/fs/Kconfig b/fs/Kconfig
index 5f4c45d4aa10..30145d886bc2 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -266,14 +266,6 @@ source "fs/9p/Kconfig"
 
 endif # NETWORK_FILESYSTEMS
 
-if BLOCK
-menu "Partition Types"
-
-source "fs/partitions/Kconfig"
-
-endmenu
-endif
-
 source "fs/nls/Kconfig"
 source "fs/dlm/Kconfig"
 
diff --git a/fs/Makefile b/fs/Makefile
index 310cfc4e69d3..93804d4d66e1 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -54,7 +54,6 @@ obj-$(CONFIG_FHANDLE)		+= fhandle.o
 obj-y                           += quota/
 
 obj-$(CONFIG_PROC_FS)           += proc/
-obj-y                           += partitions/
 obj-$(CONFIG_SYSFS)             += sysfs/
 obj-$(CONFIG_CONFIGFS_FS)       += configfs/
 obj-y                           += devpts/
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index c2b9c79eb64e..45a0ce45d7b4 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -136,7 +136,7 @@ extern int	affs_remove_header(struct dentry *dentry);
 extern u32      affs_checksum_block(struct super_block *sb, struct buffer_head *bh);
 extern void     affs_fix_checksum(struct super_block *sb, struct buffer_head *bh);
 extern void     secs_to_datestamp(time_t secs, struct affs_date *ds);
-extern mode_t   prot_to_mode(u32 prot);
+extern umode_t  prot_to_mode(u32 prot);
 extern void     mode_to_prot(struct inode *inode);
 extern void     affs_error(struct super_block *sb, const char *function, const char *fmt, ...);
 extern void     affs_warning(struct super_block *sb, const char *function, const char *fmt, ...);
@@ -156,8 +156,8 @@ extern void	affs_free_bitmap(struct super_block *sb);
 extern int      affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len);
 extern struct dentry *affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *);
 extern int      affs_unlink(struct inode *dir, struct dentry *dentry);
-extern int      affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *);
-extern int      affs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
+extern int      affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *);
+extern int      affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
 extern int      affs_rmdir(struct inode *dir, struct dentry *dentry);
 extern int      affs_link(struct dentry *olddentry, struct inode *dir,
                           struct dentry *dentry);
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index de37ec842340..52a6407682e6 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -390,10 +390,10 @@ secs_to_datestamp(time_t secs, struct affs_date *ds)
         ds->ticks = cpu_to_be32(secs * 50);
 }
 
-mode_t
+umode_t
 prot_to_mode(u32 prot)
 {
-        int mode = 0;
+        umode_t mode = 0;
 
         if (!(prot & FIBF_NOWRITE))
                 mode |= S_IWUSR;
@@ -421,7 +421,7 @@ void
 mode_to_prot(struct inode *inode)
 {
         u32 prot = AFFS_I(inode)->i_protect;
-        mode_t mode = inode->i_mode;
+        umode_t mode = inode->i_mode;
 
         if (!(mode & S_IXUSR))
                 prot |= FIBF_NOEXECUTE;
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 780a11dc6318..47806940aac0 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -255,13 +255,13 @@ affs_unlink(struct inode *dir, struct dentry *dentry)
 }
 
 int
-affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
+affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
 {
         struct super_block *sb = dir->i_sb;
         struct inode    *inode;
         int              error;
 
-        pr_debug("AFFS: create(%lu,\"%.*s\",0%o)\n",dir->i_ino,(int)dentry->d_name.len,
+        pr_debug("AFFS: create(%lu,\"%.*s\",0%ho)\n",dir->i_ino,(int)dentry->d_name.len,
                  dentry->d_name.name,mode);
 
         inode = affs_new_inode(dir);
@@ -285,12 +285,12 @@ affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata
 }
 
 int
-affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode            *inode;
         int                      error;
 
-        pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%o)\n",dir->i_ino,
+        pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%ho)\n",dir->i_ino,
                  (int)dentry->d_name.len,dentry->d_name.name,mode);
 
         inode = affs_new_inode(dir);
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 1b0b19550015..e22dc4b4a503 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -28,9 +28,9 @@ static int afs_d_delete(const struct dentry *dentry);
 static void afs_d_release(struct dentry *dentry);
 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
                                   loff_t fpos, u64 ino, unsigned dtype);
-static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                       struct nameidata *nd);
-static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
+static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
 static int afs_unlink(struct inode *dir, struct dentry *dentry);
 static int afs_link(struct dentry *from, struct inode *dir,
@@ -764,7 +764,7 @@ static void afs_d_release(struct dentry *dentry)
 /*
  * create a directory on an AFS filesystem
  */
-static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct afs_file_status status;
         struct afs_callback cb;
@@ -777,7 +777,7 @@ static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s},%o",
+        _enter("{%x:%u},{%s},%ho",
                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 
         ret = -ENAMETOOLONG;
@@ -948,7 +948,7 @@ error:
 /*
  * create a regular file on an AFS filesystem
  */
-static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                       struct nameidata *nd)
 {
         struct afs_file_status status;
@@ -962,7 +962,7 @@ static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s},%o,",
+        _enter("{%x:%u},{%s},%ho,",
                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 
         ret = -ENAMETOOLONG;
diff --git a/fs/attr.c b/fs/attr.c
index 7ee7ba488313..95053ad8abcc 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -166,7 +166,7 @@ EXPORT_SYMBOL(setattr_copy);
 int notify_change(struct dentry * dentry, struct iattr * attr)
 {
         struct inode *inode = dentry->d_inode;
-        mode_t mode = inode->i_mode;
+        umode_t mode = inode->i_mode;
         int error;
         struct timespec now;
         unsigned int ia_valid = attr->ia_valid;
@@ -177,7 +177,7 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
         }
 
         if ((ia_valid & ATTR_MODE)) {
-                mode_t amode = attr->ia_mode;
+                umode_t amode = attr->ia_mode;
                 /* Flag setting protected by i_mutex */
                 if (is_sxid(amode))
                         inode->i_flags &= ~S_NOSEC;
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index 326dc08d3e3f..5869d4e974a9 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -155,7 +155,7 @@ static inline int autofs4_ispending(struct dentry *dentry)
         return 0;
 }
 
-struct inode *autofs4_get_inode(struct super_block *, mode_t);
+struct inode *autofs4_get_inode(struct super_block *, umode_t);
 void autofs4_free_ino(struct autofs_info *);
 
 /* Expiration */
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 8179f1ab8175..f799efad52a8 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -326,7 +326,7 @@ fail_unlock:
         return -EINVAL;
 }
 
-struct inode *autofs4_get_inode(struct super_block *sb, mode_t mode)
+struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode)
 {
         struct inode *inode = new_inode(sb);
 
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index f55ae23b137e..75e5f1c8e028 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -26,7 +26,7 @@
 static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
 static int autofs4_dir_unlink(struct inode *,struct dentry *);
 static int autofs4_dir_rmdir(struct inode *,struct dentry *);
-static int autofs4_dir_mkdir(struct inode *,struct dentry *,int);
+static int autofs4_dir_mkdir(struct inode *,struct dentry *,umode_t);
 static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long);
 #ifdef CONFIG_COMPAT
 static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long);
@@ -699,7 +699,7 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
         return 0;
 }
 
-static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 9205cf25f1c6..22e9a78872ff 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -173,7 +173,7 @@ static const struct file_operations bad_file_ops =
 };
 
 static int bad_inode_create (struct inode *dir, struct dentry *dentry,
-                int mode, struct nameidata *nd)
+                umode_t mode, struct nameidata *nd)
 {
         return -EIO;
 }
@@ -202,7 +202,7 @@ static int bad_inode_symlink (struct inode *dir, struct dentry *dentry,
 }
 
 static int bad_inode_mkdir(struct inode *dir, struct dentry *dentry,
-                        int mode)
+                        umode_t mode)
 {
         return -EIO;
 }
@@ -213,7 +213,7 @@ static int bad_inode_rmdir (struct inode *dir, struct dentry *dentry)
 }
 
 static int bad_inode_mknod (struct inode *dir, struct dentry *dentry,
-                        int mode, dev_t rdev)
+                        umode_t mode, dev_t rdev)
 {
         return -EIO;
 }
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 9cc074019479..d12c7966db27 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -84,7 +84,7 @@ const struct file_operations bfs_dir_operations = {
 
 extern void dump_imap(const char *, struct super_block *);
 
-static int bfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int bfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                                                 struct nameidata *nd)
 {
         int err;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 7866cdd9fe70..69a5b6fbee2b 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -17,6 +17,7 @@
 #include <linux/module.h>
 #include <linux/blkpg.h>
 #include <linux/buffer_head.h>
+#include <linux/swap.h>
 #include <linux/pagevec.h>
 #include <linux/writeback.h>
 #include <linux/mpage.h>
@@ -25,6 +26,7 @@
 #include <linux/namei.h>
 #include <linux/log2.h>
 #include <linux/kmemleak.h>
+#include <linux/cleancache.h>
 #include <asm/uaccess.h>
 #include "internal.h"
 
@@ -82,13 +84,35 @@ static sector_t max_block(struct block_device *bdev)
 }
 
 /* Kill _all_ buffers and pagecache , dirty or not.. */
-static void kill_bdev(struct block_device *bdev)
+void kill_bdev(struct block_device *bdev)
 {
-        if (bdev->bd_inode->i_mapping->nrpages == 0)
+        struct address_space *mapping = bdev->bd_inode->i_mapping;
+
+        if (mapping->nrpages == 0)
                 return;
+
         invalidate_bh_lrus();
-        truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
+        truncate_inode_pages(mapping, 0);
 }       
+EXPORT_SYMBOL(kill_bdev);
+
+/* Invalidate clean unused buffers and pagecache. */
+void invalidate_bdev(struct block_device *bdev)
+{
+        struct address_space *mapping = bdev->bd_inode->i_mapping;
+
+        if (mapping->nrpages == 0)
+                return;
+
+        invalidate_bh_lrus();
+        lru_add_drain_all();    /* make sure all lru add caches are flushed */
+        invalidate_mapping_pages(mapping, 0, -1);
+        /* 99% of the time, we don't need to flush the cleancache on the bdev.
+         * But, for the strange corners, lets be cautious
+         */
+        cleancache_flush_inode(mapping);
+}
+EXPORT_SYMBOL(invalidate_bdev);
 
 int set_blocksize(struct block_device *bdev, int size)
 {
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index f8ff9738558a..2f426a51e60d 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4412,8 +4412,8 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
                                      struct btrfs_root *root,
                                      struct inode *dir,
                                      const char *name, int name_len,
-                                     u64 ref_objectid, u64 objectid, int mode,
-                                     u64 *index)
+                                     u64 ref_objectid, u64 objectid,
+                                     umode_t mode, u64 *index)
 {
         struct inode *inode;
         struct btrfs_inode_item *inode_item;
@@ -4596,7 +4596,7 @@ static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
 }
 
 static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
-                        int mode, dev_t rdev)
+                        umode_t mode, dev_t rdev)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
@@ -4665,7 +4665,7 @@ out_unlock:
 }
 
 static int btrfs_create(struct inode *dir, struct dentry *dentry,
-                        int mode, struct nameidata *nd)
+                        umode_t mode, struct nameidata *nd)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
@@ -4792,7 +4792,7 @@ fail:
         return err;
 }
 
-static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode = NULL;
         struct btrfs_trans_handle *trans;
diff --git a/fs/buffer.c b/fs/buffer.c
index 19d8eb7fdc81..1a30db77af32 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -41,7 +41,6 @@
 #include <linux/bitops.h>
 #include <linux/mpage.h>
 #include <linux/bit_spinlock.h>
-#include <linux/cleancache.h>
 
 static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);
 
@@ -231,55 +230,6 @@ out:
         return ret;
 }
 
-/* If invalidate_buffers() will trash dirty buffers, it means some kind
-   of fs corruption is going on. Trashing dirty data always imply losing
-   information that was supposed to be just stored on the physical layer
-   by the user.
-
-   Thus invalidate_buffers in general usage is not allwowed to trash
-   dirty buffers. For example ioctl(FLSBLKBUF) expects dirty data to
-   be preserved.  These buffers are simply skipped.
-  
-   We also skip buffers which are still in use.  For example this can
-   happen if a userspace program is reading the block device.
-
-   NOTE: In the case where the user removed a removable-media-disk even if
-   there's still dirty data not synced on disk (due a bug in the device driver
-   or due an error of the user), by not destroying the dirty buffers we could
-   generate corruption also on the next media inserted, thus a parameter is
-   necessary to handle this case in the most safe way possible (trying
-   to not corrupt also the new disk inserted with the data belonging to
-   the old now corrupted disk). Also for the ramdisk the natural thing
-   to do in order to release the ramdisk memory is to destroy dirty buffers.
-
-   These are two special cases. Normal usage imply the device driver
-   to issue a sync on the device (without waiting I/O completion) and
-   then an invalidate_buffers call that doesn't trash dirty buffers.
-
-   For handling cache coherency with the blkdev pagecache the 'update' case
-   is been introduced. It is needed to re-read from disk any pinned
-   buffer. NOTE: re-reading from disk is destructive so we can do it only
-   when we assume nobody is changing the buffercache under our I/O and when
-   we think the disk contains more recent information than the buffercache.
-   The update == 1 pass marks the buffers we need to update, the update == 2
-   pass does the actual I/O. */
-void invalidate_bdev(struct block_device *bdev)
-{
-        struct address_space *mapping = bdev->bd_inode->i_mapping;
-
-        if (mapping->nrpages == 0)
-                return;
-
-        invalidate_bh_lrus();
-        lru_add_drain_all();    /* make sure all lru add caches are flushed */
-        invalidate_mapping_pages(mapping, 0, -1);
-        /* 99% of the time, we don't need to flush the cleancache on the bdev.
-         * But, for the strange corners, lets be cautious
-         */
-        cleancache_flush_inode(mapping);
-}
-EXPORT_SYMBOL(invalidate_bdev);
-
 /*
  * Kick the writeback threads then try to free up some ZONE_NORMAL memory.
  */
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 1064805e653b..67bef6d01484 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -11,7 +11,6 @@
 
 #include <linux/slab.h>
 #include <linux/mount.h>
-#include <linux/buffer_head.h>
 #include "internal.h"
 
 #define list_to_page(head) (list_entry((head)->prev, struct page, lru))
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 8b53193e4f7c..b60fc8bfb3e9 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -928,7 +928,7 @@ static int send_cap_msg(struct ceph_mds_session *session,
                         u64 size, u64 max_size,
                         struct timespec *mtime, struct timespec *atime,
                         u64 time_warp_seq,
-                        uid_t uid, gid_t gid, mode_t mode,
+                        uid_t uid, gid_t gid, umode_t mode,
                         u64 xattr_version,
                         struct ceph_buffer *xattrs_buf,
                         u64 follows)
@@ -1078,7 +1078,7 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
         u64 size, max_size;
         struct timespec mtime, atime;
         int wake = 0;
-        mode_t mode;
+        umode_t mode;
         uid_t uid;
         gid_t gid;
         struct ceph_mds_session *session;
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 98954003a8d3..74fd74719dc2 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -666,7 +666,7 @@ int ceph_handle_notrace_create(struct inode *dir, struct dentry *dentry)
 }
 
 static int ceph_mknod(struct inode *dir, struct dentry *dentry,
-                      int mode, dev_t rdev)
+                      umode_t mode, dev_t rdev)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -676,7 +676,7 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
         if (ceph_snap(dir) != CEPH_NOSNAP)
                 return -EROFS;
 
-        dout("mknod in dir %p dentry %p mode 0%o rdev %d\n",
+        dout("mknod in dir %p dentry %p mode 0%ho rdev %d\n",
              dir, dentry, mode, rdev);
         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, USE_AUTH_MDS);
         if (IS_ERR(req)) {
@@ -699,7 +699,7 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
         return err;
 }
 
-static int ceph_create(struct inode *dir, struct dentry *dentry, int mode,
+static int ceph_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                        struct nameidata *nd)
 {
         dout("create in dir %p dentry %p name '%.*s'\n",
@@ -753,7 +753,7 @@ static int ceph_symlink(struct inode *dir, struct dentry *dentry,
         return err;
 }
 
-static int ceph_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -767,7 +767,7 @@ static int ceph_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                 dout("mksnap dir %p snap '%.*s' dn %p\n", dir,
                      dentry->d_name.len, dentry->d_name.name, dentry);
         } else if (ceph_snap(dir) == CEPH_NOSNAP) {
-                dout("mkdir dir %p dn %p mode 0%o\n", dir, dentry, mode);
+                dout("mkdir dir %p dn %p mode 0%ho\n", dir, dentry, mode);
                 op = CEPH_MDS_OP_MKDIR;
         } else {
                 goto out;
@@ -870,7 +870,7 @@ static int ceph_unlink(struct inode *dir, struct dentry *dentry)
         } else if (ceph_snap(dir) == CEPH_NOSNAP) {
                 dout("unlink/rmdir dir %p dn %p inode %p\n",
                      dir, dentry, inode);
-                op = ((dentry->d_inode->i_mode & S_IFMT) == S_IFDIR) ?
+                op = S_ISDIR(dentry->d_inode->i_mode) ?
                         CEPH_MDS_OP_RMDIR : CEPH_MDS_OP_UNLINK;
         } else
                 goto out;
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index edcbf3774a56..cb3652b37271 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -136,7 +136,7 @@ struct ceph_cap_snap {
         int issued, dirty;
         struct ceph_snap_context *context;
 
-        mode_t mode;
+        umode_t mode;
         uid_t uid;
         gid_t gid;
 
diff --git a/fs/cifs/cifs_fs_sb.h b/fs/cifs/cifs_fs_sb.h
index 500d65859279..c865bfdfe819 100644
--- a/fs/cifs/cifs_fs_sb.h
+++ b/fs/cifs/cifs_fs_sb.h
@@ -59,8 +59,8 @@ struct cifs_sb_info {
         gid_t   mnt_gid;
         uid_t   mnt_backupuid;
         gid_t   mnt_backupgid;
-        mode_t  mnt_file_mode;
-        mode_t  mnt_dir_mode;
+        umode_t mnt_file_mode;
+        umode_t mnt_dir_mode;
         unsigned int mnt_cifs_flags;
         char   *mountdata; /* options received at mount time or via DFS refs */
         struct backing_dev_info bdi;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8f1fe324162b..5bb961c13c4d 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -393,7 +393,7 @@ cifs_show_options(struct seq_file *s, struct vfsmount *m)
         cifs_show_address(s, tcon->ses->server);
 
         if (!tcon->unix_ext)
-                seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
+                seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
                                            cifs_sb->mnt_file_mode,
                                            cifs_sb->mnt_dir_mode);
         if (tcon->seal)
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 30ff56005d8f..fe5ecf1b422a 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -44,14 +44,14 @@ extern const struct address_space_operations cifs_addr_ops_smallbuf;
 /* Functions related to inodes */
 extern const struct inode_operations cifs_dir_inode_ops;
 extern struct inode *cifs_root_iget(struct super_block *);
-extern int cifs_create(struct inode *, struct dentry *, int,
+extern int cifs_create(struct inode *, struct dentry *, umode_t,
                        struct nameidata *);
 extern struct dentry *cifs_lookup(struct inode *, struct dentry *,
                                   struct nameidata *);
 extern int cifs_unlink(struct inode *dir, struct dentry *dentry);
 extern int cifs_hardlink(struct dentry *, struct inode *, struct dentry *);
-extern int cifs_mknod(struct inode *, struct dentry *, int, dev_t);
-extern int cifs_mkdir(struct inode *, struct dentry *, int);
+extern int cifs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
+extern int cifs_mkdir(struct inode *, struct dentry *, umode_t);
 extern int cifs_rmdir(struct inode *, struct dentry *);
 extern int cifs_rename(struct inode *, struct dentry *, struct inode *,
                        struct dentry *);
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 8238aa13e01c..ba53c1c6c6cc 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -169,8 +169,8 @@ struct smb_vol {
         gid_t linux_gid;
         uid_t backupuid;
         gid_t backupgid;
-        mode_t file_mode;
-        mode_t dir_mode;
+        umode_t file_mode;
+        umode_t dir_mode;
         unsigned secFlg;
         bool retry:1;
         bool intr:1;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 8cd4b52d4217..be1e8f91c0ad 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -2819,7 +2819,7 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
-        cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
+        cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
 
         cifs_sb->actimeo = pvolume_info->actimeo;
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index d7eeb9d3ed6f..df8fecb5b993 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -136,7 +136,7 @@ cifs_bp_rename_retry:
 /* Inode operations in similar order to how they appear in Linux file fs.h */
 
 int
-cifs_create(struct inode *inode, struct dentry *direntry, int mode,
+cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
                 struct nameidata *nd)
 {
         int rc = -ENOENT;
@@ -355,7 +355,7 @@ cifs_create_out:
         return rc;
 }
 
-int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
+int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
                 dev_t device_number)
 {
         int rc = -EPERM;
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index e851d5b8931e..a5f54b7d9822 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1264,7 +1264,7 @@ unlink_out:
         return rc;
 }
 
-int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
+int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
 {
         int rc = 0, tmprc;
         int xid;
@@ -1275,7 +1275,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
         struct inode *newinode = NULL;
         struct cifs_fattr fattr;
 
-        cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
+        cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);
 
         cifs_sb = CIFS_SB(inode->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 28e7e135cfab..83d2fd8ec24b 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -30,14 +30,14 @@
 #include "coda_int.h"
 
 /* dir inode-ops */
-static int coda_create(struct inode *dir, struct dentry *new, int mode, struct nameidata *nd);
+static int coda_create(struct inode *dir, struct dentry *new, umode_t mode, struct nameidata *nd);
 static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd);
 static int coda_link(struct dentry *old_dentry, struct inode *dir_inode, 
                      struct dentry *entry);
 static int coda_unlink(struct inode *dir_inode, struct dentry *entry);
 static int coda_symlink(struct inode *dir_inode, struct dentry *entry,
                         const char *symname);
-static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, int mode);
+static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, umode_t mode);
 static int coda_rmdir(struct inode *dir_inode, struct dentry *entry);
 static int coda_rename(struct inode *old_inode, struct dentry *old_dentry, 
                        struct inode *new_inode, struct dentry *new_dentry);
@@ -191,7 +191,7 @@ static inline void coda_dir_drop_nlink(struct inode *dir)
 }
 
 /* creation routines: create, mknod, mkdir, link, symlink */
-static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd)
+static int coda_create(struct inode *dir, struct dentry *de, umode_t mode, struct nameidata *nd)
 {
         int error;
         const char *name=de->d_name.name;
@@ -223,7 +223,7 @@ err_out:
         return error;
 }
 
-static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
+static int coda_mkdir(struct inode *dir, struct dentry *de, umode_t mode)
 {
         struct inode *inode;
         struct coda_vattr attrs;
diff --git a/fs/compat.c b/fs/compat.c
index 9db5a6076610..fa9d721ecfee 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1281,7 +1281,7 @@ compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32,
  * O_LARGEFILE flag.
  */
 asmlinkage long
-compat_sys_open(const char __user *filename, int flags, int mode)
+compat_sys_open(const char __user *filename, int flags, umode_t mode)
 {
         return do_sys_open(AT_FDCWD, filename, flags, mode);
 }
@@ -1291,7 +1291,7 @@ compat_sys_open(const char __user *filename, int flags, int mode)
  * O_LARGEFILE flag.
  */
 asmlinkage long
-compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode)
+compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, umode_t mode)
 {
         return do_sys_open(dfd, filename, flags, mode);
 }
diff --git a/fs/configfs/configfs_internal.h b/fs/configfs/configfs_internal.h
index 82bda8fdfc1c..ede857d20a04 100644
--- a/fs/configfs/configfs_internal.h
+++ b/fs/configfs/configfs_internal.h
@@ -63,8 +63,8 @@ extern struct kmem_cache *configfs_dir_cachep;
 
 extern int configfs_is_root(struct config_item *item);
 
-extern struct inode * configfs_new_inode(mode_t mode, struct configfs_dirent *);
-extern int configfs_create(struct dentry *, int mode, int (*init)(struct inode *));
+extern struct inode * configfs_new_inode(umode_t mode, struct configfs_dirent *);
+extern int configfs_create(struct dentry *, umode_t mode, int (*init)(struct inode *));
 extern int configfs_inode_init(void);
 extern void configfs_inode_exit(void);
 
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 1c5296911104..5ddd7ebd9dcd 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -1170,7 +1170,7 @@ void configfs_undepend_item(struct configfs_subsystem *subsys,
 }
 EXPORT_SYMBOL(configfs_undepend_item);
 
-static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int configfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int ret = 0;
         int module_got = 0;
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 9d8715c45f25..3ee36d418863 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -116,7 +116,7 @@ int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
         return error;
 }
 
-static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
+static inline void set_default_inode_attr(struct inode * inode, umode_t mode)
 {
         inode->i_mode = mode;
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
@@ -132,7 +132,7 @@ static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
         inode->i_ctime = iattr->ia_ctime;
 }
 
-struct inode * configfs_new_inode(mode_t mode, struct configfs_dirent * sd)
+struct inode *configfs_new_inode(umode_t mode, struct configfs_dirent * sd)
 {
         struct inode * inode = new_inode(configfs_sb);
         if (inode) {
@@ -185,7 +185,7 @@ static void configfs_set_inode_lock_class(struct configfs_dirent *sd,
 
 #endif /* CONFIG_LOCKDEP */
 
-int configfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
+int configfs_create(struct dentry * dentry, umode_t mode, int (*init)(struct inode *))
 {
         int error = 0;
         struct inode * inode = NULL;
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 739fb59bcdc2..a2ee8f9f5a38 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -20,7 +20,6 @@
 #include <linux/cramfs_fs.h>
 #include <linux/slab.h>
 #include <linux/cramfs_fs_sb.h>
-#include <linux/buffer_head.h>
 #include <linux/vfs.h>
 #include <linux/mutex.h>
 
@@ -378,7 +377,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 unsigned long nextoffset;
                 char *name;
                 ino_t ino;
-                mode_t mode;
+                umode_t mode;
                 int namelen, error;
 
                 mutex_lock(&read_mutex);
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index 90f76575c056..d5016606fb27 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -95,7 +95,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_u8(const char *name, mode_t mode,
+struct dentry *debugfs_create_u8(const char *name, umode_t mode,
                                  struct dentry *parent, u8 *value)
 {
         /* if there are no write bits set, make read only */
@@ -147,7 +147,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_u16(const char *name, mode_t mode,
+struct dentry *debugfs_create_u16(const char *name, umode_t mode,
                                   struct dentry *parent, u16 *value)
 {
         /* if there are no write bits set, make read only */
@@ -199,7 +199,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_u32(const char *name, mode_t mode,
+struct dentry *debugfs_create_u32(const char *name, umode_t mode,
                                  struct dentry *parent, u32 *value)
 {
         /* if there are no write bits set, make read only */
@@ -252,7 +252,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_u64(const char *name, mode_t mode,
+struct dentry *debugfs_create_u64(const char *name, umode_t mode,
                                  struct dentry *parent, u64 *value)
 {
         /* if there are no write bits set, make read only */
@@ -298,7 +298,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n
  * @value: a pointer to the variable that the file should read to and write
  *         from.
  */
-struct dentry *debugfs_create_x8(const char *name, mode_t mode,
+struct dentry *debugfs_create_x8(const char *name, umode_t mode,
                                  struct dentry *parent, u8 *value)
 {
         /* if there are no write bits set, make read only */
@@ -322,7 +322,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x8);
  * @value: a pointer to the variable that the file should read to and write
  *         from.
  */
-struct dentry *debugfs_create_x16(const char *name, mode_t mode,
+struct dentry *debugfs_create_x16(const char *name, umode_t mode,
                                  struct dentry *parent, u16 *value)
 {
         /* if there are no write bits set, make read only */
@@ -346,7 +346,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x16);
  * @value: a pointer to the variable that the file should read to and write
  *         from.
  */
-struct dentry *debugfs_create_x32(const char *name, mode_t mode,
+struct dentry *debugfs_create_x32(const char *name, umode_t mode,
                                  struct dentry *parent, u32 *value)
 {
         /* if there are no write bits set, make read only */
@@ -370,7 +370,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x32);
  * @value: a pointer to the variable that the file should read to and write
  *         from.
  */
-struct dentry *debugfs_create_x64(const char *name, mode_t mode,
+struct dentry *debugfs_create_x64(const char *name, umode_t mode,
                                  struct dentry *parent, u64 *value)
 {
         return debugfs_create_file(name, mode, parent, value, &fops_x64);
@@ -401,7 +401,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
  * @value: a pointer to the variable that the file should read to and write
  *         from.
  */
-struct dentry *debugfs_create_size_t(const char *name, mode_t mode,
+struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
                                      struct dentry *parent, size_t *value)
 {
         return debugfs_create_file(name, mode, parent, value, &fops_size_t);
@@ -473,7 +473,7 @@ static const struct file_operations fops_bool = {
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_bool(const char *name, mode_t mode,
+struct dentry *debugfs_create_bool(const char *name, umode_t mode,
                                    struct dentry *parent, u32 *value)
 {
         return debugfs_create_file(name, mode, parent, value, &fops_bool);
@@ -518,7 +518,7 @@ static const struct file_operations fops_blob = {
  * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
  * code.
  */
-struct dentry *debugfs_create_blob(const char *name, mode_t mode,
+struct dentry *debugfs_create_blob(const char *name, umode_t mode,
                                    struct dentry *parent,
                                    struct debugfs_blob_wrapper *blob)
 {
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index c9dc08d0c100..956d5ddddf6e 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -30,7 +30,7 @@ static struct vfsmount *debugfs_mount;
 static int debugfs_mount_count;
 static bool debugfs_registered;
 
-static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev,
+static struct inode *debugfs_get_inode(struct super_block *sb, umode_t mode, dev_t dev,
                                        void *data, const struct file_operations *fops)
 
 {
@@ -69,7 +69,7 @@ static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t d
 
 /* SMP-safe */
 static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
-                         int mode, dev_t dev, void *data,
+                         umode_t mode, dev_t dev, void *data,
                          const struct file_operations *fops)
 {
         struct inode *inode;
@@ -87,7 +87,7 @@ static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
         return error;
 }
 
-static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode,
+static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode,
                          void *data, const struct file_operations *fops)
 {
         int res;
@@ -101,14 +101,14 @@ static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode,
         return res;
 }
 
-static int debugfs_link(struct inode *dir, struct dentry *dentry, int mode,
+static int debugfs_link(struct inode *dir, struct dentry *dentry, umode_t mode,
                         void *data, const struct file_operations *fops)
 {
         mode = (mode & S_IALLUGO) | S_IFLNK;
         return debugfs_mknod(dir, dentry, mode, 0, data, fops);
 }
 
-static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int debugfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                           void *data, const struct file_operations *fops)
 {
         int res;
@@ -146,7 +146,7 @@ static struct file_system_type debug_fs_type = {
         .kill_sb =      kill_litter_super,
 };
 
-static int debugfs_create_by_name(const char *name, mode_t mode,
+static int debugfs_create_by_name(const char *name, umode_t mode,
                                   struct dentry *parent,
                                   struct dentry **dentry,
                                   void *data,
@@ -214,7 +214,7 @@ static int debugfs_create_by_name(const char *name, mode_t mode,
  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
  * returned.
  */
-struct dentry *debugfs_create_file(const char *name, mode_t mode,
+struct dentry *debugfs_create_file(const char *name, umode_t mode,
                                    struct dentry *parent, void *data,
                                    const struct file_operations *fops)
 {
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 32f90a3ae63e..19a8ca4ab1dd 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -144,24 +144,6 @@ static int ecryptfs_interpose(struct dentry *lower_dentry,
 }
 
 /**
- * ecryptfs_create_underlying_file
- * @lower_dir_inode: inode of the parent in the lower fs of the new file
- * @dentry: New file's dentry
- * @mode: The mode of the new file
- *
- * Creates the file in the lower file system.
- *
- * Returns zero on success; non-zero on error condition
- */
-static int
-ecryptfs_create_underlying_file(struct inode *lower_dir_inode,
-                                struct dentry *dentry, int mode)
-{
-        struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
-        return vfs_create(lower_dir_inode, lower_dentry, mode, NULL);
-}
-
-/**
  * ecryptfs_do_create
  * @directory_inode: inode of the new file's dentry's parent in ecryptfs
  * @ecryptfs_dentry: New file's dentry in ecryptfs
@@ -176,7 +158,7 @@ ecryptfs_create_underlying_file(struct inode *lower_dir_inode,
  */
 static struct inode *
 ecryptfs_do_create(struct inode *directory_inode,
-                   struct dentry *ecryptfs_dentry, int mode)
+                   struct dentry *ecryptfs_dentry, umode_t mode)
 {
         int rc;
         struct dentry *lower_dentry;
@@ -191,8 +173,7 @@ ecryptfs_do_create(struct inode *directory_inode,
                 inode = ERR_CAST(lower_dir_dentry);
                 goto out;
         }
-        rc = ecryptfs_create_underlying_file(lower_dir_dentry->d_inode,
-                                             ecryptfs_dentry, mode);
+        rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, NULL);
         if (rc) {
                 printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                        "rc = [%d]\n", __func__, rc);
@@ -267,7 +248,7 @@ out:
  */
 static int
 ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry,
-                int mode, struct nameidata *nd)
+                umode_t mode, struct nameidata *nd)
 {
         struct inode *ecryptfs_inode;
         int rc;
@@ -559,7 +540,7 @@ out_lock:
         return rc;
 }
 
-static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int rc;
         struct dentry *lower_dentry;
@@ -607,7 +588,7 @@ static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
 }
 
 static int
-ecryptfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 {
         int rc;
         struct dentry *lower_dentry;
diff --git a/fs/exofs/dir.c b/fs/exofs/dir.c
index d0941c6a1f72..80405836ba6e 100644
--- a/fs/exofs/dir.c
+++ b/fs/exofs/dir.c
@@ -234,7 +234,7 @@ static unsigned char exofs_type_by_mode[S_IFMT >> S_SHIFT] = {
 static inline
 void exofs_set_de_type(struct exofs_dir_entry *de, struct inode *inode)
 {
-        mode_t mode = inode->i_mode;
+        umode_t mode = inode->i_mode;
         de->file_type = exofs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
 }
 
diff --git a/fs/exofs/exofs.h b/fs/exofs/exofs.h
index 51f4b4c40f09..ca9d49665ef6 100644
--- a/fs/exofs/exofs.h
+++ b/fs/exofs/exofs.h
@@ -154,7 +154,7 @@ int exofs_write_begin(struct file *file, struct address_space *mapping,
                 loff_t pos, unsigned len, unsigned flags,
                 struct page **pagep, void **fsdata);
 extern struct inode *exofs_iget(struct super_block *, unsigned long);
-struct inode *exofs_new_inode(struct inode *, int);
+struct inode *exofs_new_inode(struct inode *, umode_t);
 extern int exofs_write_inode(struct inode *, struct writeback_control *wbc);
 extern void exofs_evict_inode(struct inode *);
 
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index f6dbf7768ce6..ea5e1f97806a 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -1276,7 +1276,7 @@ static void create_done(struct ore_io_state *ios, void *p)
 /*
  * Set up a new inode and create an object for it on the OSD
  */
-struct inode *exofs_new_inode(struct inode *dir, int mode)
+struct inode *exofs_new_inode(struct inode *dir, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct exofs_sb_info *sbi = sb->s_fs_info;
diff --git a/fs/exofs/namei.c b/fs/exofs/namei.c
index b54c43775f17..9dbf0c301030 100644
--- a/fs/exofs/namei.c
+++ b/fs/exofs/namei.c
@@ -59,7 +59,7 @@ static struct dentry *exofs_lookup(struct inode *dir, struct dentry *dentry,
         return d_splice_alias(inode, dentry);
 }
 
-static int exofs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int exofs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                          struct nameidata *nd)
 {
         struct inode *inode = exofs_new_inode(dir, mode);
@@ -74,7 +74,7 @@ static int exofs_create(struct inode *dir, struct dentry *dentry, int mode,
         return err;
 }
 
-static int exofs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+static int exofs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                        dev_t rdev)
 {
         struct inode *inode;
@@ -153,7 +153,7 @@ static int exofs_link(struct dentry *old_dentry, struct inode *dir,
         return exofs_add_nondir(dentry, inode);
 }
 
-static int exofs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int exofs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
         int err = -EMLINK;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 47cda410b548..d37df352d324 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -279,7 +279,7 @@ static unsigned char ext2_type_by_mode[S_IFMT >> S_SHIFT] = {
 
 static inline void ext2_set_de_type(ext2_dirent *de, struct inode *inode)
 {
-        mode_t mode = inode->i_mode;
+        umode_t mode = inode->i_mode;
         if (EXT2_HAS_INCOMPAT_FEATURE(inode->i_sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
                 de->file_type = ext2_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
         else
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 9a4e5e206d08..75ad433c6691 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -110,7 +110,7 @@ extern struct ext2_dir_entry_2 * ext2_dotdot (struct inode *, struct page **);
 extern void ext2_set_link(struct inode *, struct ext2_dir_entry_2 *, struct page *, struct inode *, int);
 
 /* ialloc.c */
-extern struct inode * ext2_new_inode (struct inode *, int, const struct qstr *);
+extern struct inode * ext2_new_inode (struct inode *, umode_t, const struct qstr *);
 extern void ext2_free_inode (struct inode *);
 extern unsigned long ext2_count_free_inodes (struct super_block *);
 extern void ext2_check_inodes_bitmap (struct super_block *);
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index c4e81dfb74ba..cd7f5f424a75 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -429,7 +429,7 @@ found:
         return group;
 }
 
-struct inode *ext2_new_inode(struct inode *dir, int mode,
+struct inode *ext2_new_inode(struct inode *dir, umode_t mode,
                              const struct qstr *qstr)
 {
         struct super_block *sb;
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index 761fde807fc9..080419814bae 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -94,7 +94,7 @@ struct dentry *ext2_get_parent(struct dentry *child)
  * If the create succeeds, we fill in the inode information
  * with d_instantiate(). 
  */
-static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)
+static int ext2_create (struct inode * dir, struct dentry * dentry, umode_t mode, struct nameidata *nd)
 {
         struct inode *inode;
 
@@ -119,7 +119,7 @@ static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, st
         return ext2_add_nondir(dentry, inode);
 }
 
-static int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
+static int ext2_mknod (struct inode * dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         struct inode * inode;
         int err;
@@ -214,7 +214,7 @@ static int ext2_link (struct dentry * old_dentry, struct inode * dir,
         return err;
 }
 
-static int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+static int ext2_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
 {
         struct inode * inode;
         int err = -EMLINK;
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 5c866e06e7ab..92cc86dfa23d 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -371,7 +371,7 @@ static int find_group_other(struct super_block *sb, struct inode *parent)
  * group to find a free inode.
  */
 struct inode *ext3_new_inode(handle_t *handle, struct inode * dir,
-                             const struct qstr *qstr, int mode)
+                             const struct qstr *qstr, umode_t mode)
 {
         struct super_block *sb;
         struct buffer_head *bitmap_bh = NULL;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 642dc6d66dfd..4f35b2f315d4 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1698,7 +1698,7 @@ static int ext3_add_nondir(handle_t *handle,
  * If the create succeeds, we fill in the inode information
  * with d_instantiate().
  */
-static int ext3_create (struct inode * dir, struct dentry * dentry, int mode,
+static int ext3_create (struct inode * dir, struct dentry * dentry, umode_t mode,
                 struct nameidata *nd)
 {
         handle_t *handle;
@@ -1732,7 +1732,7 @@ retry:
 }
 
 static int ext3_mknod (struct inode * dir, struct dentry *dentry,
-                        int mode, dev_t rdev)
+                        umode_t mode, dev_t rdev)
 {
         handle_t *handle;
         struct inode *inode;
@@ -1768,7 +1768,7 @@ retry:
         return err;
 }
 
-static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+static int ext3_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
 {
         handle_t *handle;
         struct inode * inode;
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 5b0e26a1272d..1554b15f91bc 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1819,7 +1819,7 @@ extern int ext4fs_dirhash(const char *name, int len, struct
                           dx_hash_info *hinfo);
 
 /* ialloc.c */
-extern struct inode *ext4_new_inode(handle_t *, struct inode *, int,
+extern struct inode *ext4_new_inode(handle_t *, struct inode *, umode_t,
                                     const struct qstr *qstr, __u32 goal,
                                     uid_t *owner);
 extern void ext4_free_inode(handle_t *, struct inode *);
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 00beb4f9cc4f..4637af036d9c 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -351,7 +351,7 @@ static void get_orlov_stats(struct super_block *sb, ext4_group_t g,
  */
 
 static int find_group_orlov(struct super_block *sb, struct inode *parent,
-                            ext4_group_t *group, int mode,
+                            ext4_group_t *group, umode_t mode,
                             const struct qstr *qstr)
 {
         ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
@@ -497,7 +497,7 @@ fallback_retry:
 }
 
 static int find_group_other(struct super_block *sb, struct inode *parent,
-                            ext4_group_t *group, int mode)
+                            ext4_group_t *group, umode_t mode)
 {
         ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
         ext4_group_t i, last, ngroups = ext4_get_groups_count(sb);
@@ -602,7 +602,7 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
  */
 static int ext4_claim_inode(struct super_block *sb,
                         struct buffer_head *inode_bitmap_bh,
-                        unsigned long ino, ext4_group_t group, int mode)
+                        unsigned long ino, ext4_group_t group, umode_t mode)
 {
         int free = 0, retval = 0, count;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
@@ -690,7 +690,7 @@ err_ret:
  * For other inodes, search forward from the parent directory's block
  * group to find a free inode.
  */
-struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode,
+struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, umode_t mode,
                              const struct qstr *qstr, __u32 goal, uid_t *owner)
 {
         struct super_block *sb;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index aa4c782c9dd7..86edc45b52a4 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1736,7 +1736,7 @@ static int ext4_add_nondir(handle_t *handle,
  * If the create succeeds, we fill in the inode information
  * with d_instantiate().
  */
-static int ext4_create(struct inode *dir, struct dentry *dentry, int mode,
+static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                        struct nameidata *nd)
 {
         handle_t *handle;
@@ -1770,7 +1770,7 @@ retry:
 }
 
 static int ext4_mknod(struct inode *dir, struct dentry *dentry,
-                      int mode, dev_t rdev)
+                      umode_t mode, dev_t rdev)
 {
         handle_t *handle;
         struct inode *inode;
@@ -1806,7 +1806,7 @@ retry:
         return err;
 }
 
-static int ext4_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         handle_t *handle;
         struct inode *inode;
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index 1510a4d51990..66994f316e18 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -141,7 +141,7 @@ static inline struct msdos_inode_info *MSDOS_I(struct inode *inode)
 static inline int fat_mode_can_hold_ro(struct inode *inode)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
-        mode_t mask;
+        umode_t mask;
 
         if (S_ISDIR(inode->i_mode)) {
                 if (!sbi->options.rodir)
@@ -156,8 +156,8 @@ static inline int fat_mode_can_hold_ro(struct inode *inode)
 }
 
 /* Convert attribute bits and a mask to the UNIX mode. */
-static inline mode_t fat_make_mode(struct msdos_sb_info *sbi,
-                                   u8 attrs, mode_t mode)
+static inline umode_t fat_make_mode(struct msdos_sb_info *sbi,
+                                   u8 attrs, umode_t mode)
 {
         if (attrs & ATTR_RO && !((attrs & ATTR_DIR) && !sbi->options.rodir))
                 mode &= ~S_IWUGO;
diff --git a/fs/fat/file.c b/fs/fat/file.c
index d81d01a99b2c..a71fe3715ee8 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -314,7 +314,7 @@ EXPORT_SYMBOL_GPL(fat_getattr);
 static int fat_sanitize_mode(const struct msdos_sb_info *sbi,
                              struct inode *inode, umode_t *mode_ptr)
 {
-        mode_t mask, perm;
+        umode_t mask, perm;
 
         /*
          * Note, the basic check is already done by a caller of
@@ -351,7 +351,7 @@ static int fat_sanitize_mode(const struct msdos_sb_info *sbi,
 
 static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
 {
-        mode_t allow_utime = sbi->options.allow_utime;
+        umode_t allow_utime = sbi->options.allow_utime;
 
         if (current_fsuid() != inode->i_uid) {
                 if (in_group_p(inode->i_gid))
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index 216b419f30e2..c5938c9084b9 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -264,7 +264,7 @@ static int msdos_add_entry(struct inode *dir, const unsigned char *name,
 }
 
 /***** Create a file */
-static int msdos_create(struct inode *dir, struct dentry *dentry, int mode,
+static int msdos_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                         struct nameidata *nd)
 {
         struct super_block *sb = dir->i_sb;
@@ -346,7 +346,7 @@ out:
 }
 
 /***** Make a directory */
-static int msdos_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int msdos_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct fat_slot_info sinfo;
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index a87a65663c25..3a444b4e2368 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -781,7 +781,7 @@ error:
         return ERR_PTR(err);
 }
 
-static int vfat_create(struct inode *dir, struct dentry *dentry, int mode,
+static int vfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                        struct nameidata *nd)
 {
         struct super_block *sb = dir->i_sb;
@@ -870,7 +870,7 @@ out:
         return err;
 }
 
-static int vfat_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int vfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct inode *inode;
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index 41ef6e715d2f..cf9ef918a2a9 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -187,10 +187,10 @@ vxfs_stiget(struct super_block *sbp, ino_t ino)
  *  vxfs_transmod returns a Linux mode_t for a given
  *  VxFS inode structure.
  */
-static __inline__ mode_t
+static __inline__ umode_t
 vxfs_transmod(struct vxfs_inode_info *vip)
 {
-        mode_t                  ret = vip->vii_mode & ~VXFS_TYPE_MASK;
+        umode_t                 ret = vip->vii_mode & ~VXFS_TYPE_MASK;
 
         if (VXFS_ISFIFO(vip))
                 ret |= S_IFIFO;
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 517f211a3bd4..80a4574028f1 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -25,7 +25,6 @@
 #include <linux/writeback.h>
 #include <linux/blkdev.h>
 #include <linux/backing-dev.h>
-#include <linux/buffer_head.h>
 #include <linux/tracepoint.h>
 #include "internal.h"
 
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 9f63e493a9b6..5ddd6ea8f839 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -369,8 +369,8 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
  * If the filesystem doesn't support this, then fall back to separate
  * 'mknod' + 'open' requests.
  */
-static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
-                            struct nameidata *nd)
+static int fuse_create_open(struct inode *dir, struct dentry *entry,
+                            umode_t mode, struct nameidata *nd)
 {
         int err;
         struct inode *inode;
@@ -480,7 +480,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
  */
 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
                             struct inode *dir, struct dentry *entry,
-                            int mode)
+                            umode_t mode)
 {
         struct fuse_entry_out outarg;
         struct inode *inode;
@@ -547,7 +547,7 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
         return err;
 }
 
-static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
+static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
                       dev_t rdev)
 {
         struct fuse_mknod_in inarg;
@@ -573,7 +573,7 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
         return create_new_entry(fc, req, dir, entry, mode);
 }
 
-static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
+static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
                        struct nameidata *nd)
 {
         if (nd) {
@@ -585,7 +585,7 @@ static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
         return fuse_mknod(dir, entry, mode, 0);
 }
 
-static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
+static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
 {
         struct fuse_mkdir_in inarg;
         struct fuse_conn *fc = get_fuse_conn(dir);
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index cf6db0a93219..1964da0257d9 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -80,7 +80,7 @@ struct fuse_inode {
 
         /** The sticky bit in inode->i_mode may have been removed, so
             preserve the original mode */
-        mode_t orig_i_mode;
+        umode_t orig_i_mode;
 
         /** Version of last attribute change */
         u64 attr_version;
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index cfd4959b218c..4b0e59e0a249 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -333,7 +333,7 @@ out:
  */
 
 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
-                     unsigned int mode)
+                     umode_t mode)
 {
         int error;
 
@@ -364,7 +364,7 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
         return 0;
 }
 
-static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
+static void munge_mode_uid_gid(struct gfs2_inode *dip, umode_t *mode,
                                unsigned int *uid, unsigned int *gid)
 {
         if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
@@ -447,7 +447,7 @@ static void gfs2_init_dir(struct buffer_head *dibh,
  */
 
 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
-                        const struct gfs2_inum_host *inum, unsigned int mode,
+                        const struct gfs2_inum_host *inum, umode_t mode,
                         unsigned int uid, unsigned int gid,
                         const u64 *generation, dev_t dev, const char *symname,
                         unsigned size, struct buffer_head **bhp)
@@ -516,7 +516,7 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 }
 
 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
-                       unsigned int mode, const struct gfs2_inum_host *inum,
+                       umode_t mode, const struct gfs2_inum_host *inum,
                        const u64 *generation, dev_t dev, const char *symname,
                        unsigned int size, struct buffer_head **bhp)
 {
@@ -659,7 +659,7 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
  */
 
 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
-                             unsigned int mode, dev_t dev, const char *symname,
+                             umode_t mode, dev_t dev, const char *symname,
                              unsigned int size, int excl)
 {
         const struct qstr *name = &dentry->d_name;
@@ -760,7 +760,7 @@ fail:
  */
 
 static int gfs2_create(struct inode *dir, struct dentry *dentry,
-                       int mode, struct nameidata *nd)
+                       umode_t mode, struct nameidata *nd)
 {
         int excl = 0;
         if (nd && (nd->flags & LOOKUP_EXCL))
@@ -1129,7 +1129,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
  * Returns: errno
  */
 
-static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0, 0);
 }
@@ -1143,7 +1143,7 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  *
  */
 
-static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
+static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                       dev_t dev)
 {
         return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index bce4eef91a06..62fc14ea4b73 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -186,7 +186,7 @@ static int hfs_dir_release(struct inode *inode, struct file *file)
  * a directory and return a corresponding inode, given the inode for
  * the directory and the name (and its length) of the new file.
  */
-static int hfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                       struct nameidata *nd)
 {
         struct inode *inode;
@@ -216,7 +216,7 @@ static int hfs_create(struct inode *dir, struct dentry *dentry, int mode,
  * in a directory, given the inode for the parent directory and the
  * name (and its length) of the new directory.
  */
-static int hfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
         int res;
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index ad97c2d58287..1bf967c6bfdc 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -184,7 +184,7 @@ extern int hfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern const struct address_space_operations hfs_aops;
 extern const struct address_space_operations hfs_btree_aops;
 
-extern struct inode *hfs_new_inode(struct inode *, struct qstr *, int);
+extern struct inode *hfs_new_inode(struct inode *, struct qstr *, umode_t);
 extern void hfs_inode_write_fork(struct inode *, struct hfs_extent *, __be32 *, __be32 *);
 extern int hfs_write_inode(struct inode *, struct writeback_control *);
 extern int hfs_inode_setattr(struct dentry *, struct iattr *);
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index a1a9fdcd2a00..737dbeb64320 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -169,7 +169,7 @@ const struct address_space_operations hfs_aops = {
 /*
  * hfs_new_inode
  */
-struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, int mode)
+struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct inode *inode = new_inode(sb);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 4536cd3f15ae..88e155f895c6 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -424,7 +424,7 @@ out:
 }
 
 static int hfsplus_mknod(struct inode *dir, struct dentry *dentry,
-                         int mode, dev_t rdev)
+                         umode_t mode, dev_t rdev)
 {
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
         struct inode *inode;
@@ -453,13 +453,13 @@ out:
         return res;
 }
 
-static int hfsplus_create(struct inode *dir, struct dentry *dentry, int mode,
+static int hfsplus_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                           struct nameidata *nd)
 {
         return hfsplus_mknod(dir, dentry, mode, 0);
 }
 
-static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         return hfsplus_mknod(dir, dentry, mode | S_IFDIR, 0);
 }
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index d7674d051f52..3a6c025414e2 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -402,7 +402,7 @@ void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
 void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
 int hfsplus_cat_read_inode(struct inode *, struct hfs_find_data *);
 int hfsplus_cat_write_inode(struct inode *);
-struct inode *hfsplus_new_inode(struct super_block *, int);
+struct inode *hfsplus_new_inode(struct super_block *, umode_t);
 void hfsplus_delete_inode(struct inode *);
 int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
                        int datasync);
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 40e1413be4cf..6643b242bdd7 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -378,7 +378,7 @@ static const struct file_operations hfsplus_file_operations = {
         .unlocked_ioctl = hfsplus_ioctl,
 };
 
-struct inode *hfsplus_new_inode(struct super_block *sb, int mode)
+struct inode *hfsplus_new_inode(struct super_block *sb, umode_t mode)
 {
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
         struct inode *inode = new_inode(sb);
diff --git a/fs/hostfs/hostfs.h b/fs/hostfs/hostfs.h
index bf15a43016b9..3cbfa93cd782 100644
--- a/fs/hostfs/hostfs.h
+++ b/fs/hostfs/hostfs.h
@@ -39,7 +39,7 @@
 
 struct hostfs_iattr {
         unsigned int    ia_valid;
-        mode_t          ia_mode;
+        unsigned short  ia_mode;
         uid_t           ia_uid;
         gid_t           ia_gid;
         loff_t          ia_size;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 343ea632b97c..a7340e710a90 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -551,7 +551,7 @@ static int read_name(struct inode *ino, char *name)
         return 0;
 }
 
-int hostfs_create(struct inode *dir, struct dentry *dentry, int mode,
+int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                   struct nameidata *nd)
 {
         struct inode *inode;
@@ -676,7 +676,7 @@ int hostfs_symlink(struct inode *ino, struct dentry *dentry, const char *to)
         return err;
 }
 
-int hostfs_mkdir(struct inode *ino, struct dentry *dentry, int mode)
+int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
 {
         char *file;
         int err;
@@ -700,7 +700,7 @@ int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
         return err;
 }
 
-int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 {
         struct inode *inode;
         char *name;
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index ea91fcb0ef9b..30dd7b10b507 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -8,7 +8,7 @@
 #include <linux/sched.h>
 #include "hpfs_fn.h"
 
-static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         const unsigned char *name = dentry->d_name.name;
         unsigned len = dentry->d_name.len;
@@ -115,7 +115,7 @@ bail:
         return err;
 }
 
-static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
+static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
 {
         const unsigned char *name = dentry->d_name.name;
         unsigned len = dentry->d_name.len;
@@ -201,7 +201,7 @@ bail:
         return err;
 }
 
-static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
+static int hpfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         const unsigned char *name = dentry->d_name.name;
         unsigned len = dentry->d_name.len;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 9c4ec538725b..e425ad9d0490 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -447,8 +447,8 @@ static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
         return 0;
 }
 
-static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid, 
-                                        gid_t gid, int mode, dev_t dev)
+static struct inode *hugetlbfs_get_root(struct super_block *sb,
+                                        struct hugetlbfs_config *config)
 {
         struct inode *inode;
 
@@ -456,9 +456,31 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid,
         if (inode) {
                 struct hugetlbfs_inode_info *info;
                 inode->i_ino = get_next_ino();
-                inode->i_mode = mode;
-                inode->i_uid = uid;
-                inode->i_gid = gid;
+                inode->i_mode = S_IFDIR | config->mode;
+                inode->i_uid = config->uid;
+                inode->i_gid = config->gid;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                info = HUGETLBFS_I(inode);
+                mpol_shared_policy_init(&info->policy, NULL);
+                inode->i_op = &hugetlbfs_dir_inode_operations;
+                inode->i_fop = &simple_dir_operations;
+                /* directory inodes start off with i_nlink == 2 (for "." entry) */
+                inc_nlink(inode);
+        }
+        return inode;
+}
+
+static struct inode *hugetlbfs_get_inode(struct super_block *sb,
+                                        struct inode *dir,
+                                        umode_t mode, dev_t dev)
+{
+        struct inode *inode;
+
+        inode = new_inode(sb);
+        if (inode) {
+                struct hugetlbfs_inode_info *info;
+                inode->i_ino = get_next_ino();
+                inode_init_owner(inode, dir, mode);
                 inode->i_mapping->a_ops = &hugetlbfs_aops;
                 inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
@@ -500,20 +522,12 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid,
  * File creation. Allocate an inode, and we're done..
  */
 static int hugetlbfs_mknod(struct inode *dir,
-                        struct dentry *dentry, int mode, dev_t dev)
+                        struct dentry *dentry, umode_t mode, dev_t dev)
 {
         struct inode *inode;
         int error = -ENOSPC;
-        gid_t gid;
-
-        if (dir->i_mode & S_ISGID) {
-                gid = dir->i_gid;
-                if (S_ISDIR(mode))
-                        mode |= S_ISGID;
-        } else {
-                gid = current_fsgid();
-        }
-        inode = hugetlbfs_get_inode(dir->i_sb, current_fsuid(), gid, mode, dev);
+
+        inode = hugetlbfs_get_inode(dir->i_sb, dir, mode, dev);
         if (inode) {
                 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
                 d_instantiate(dentry, inode);
@@ -523,7 +537,7 @@ static int hugetlbfs_mknod(struct inode *dir,
         return error;
 }
 
-static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int retval = hugetlbfs_mknod(dir, dentry, mode | S_IFDIR, 0);
         if (!retval)
@@ -531,7 +545,7 @@ static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return retval;
 }
 
-static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
+static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
 {
         return hugetlbfs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
@@ -541,15 +555,8 @@ static int hugetlbfs_symlink(struct inode *dir,
 {
         struct inode *inode;
         int error = -ENOSPC;
-        gid_t gid;
-
-        if (dir->i_mode & S_ISGID)
-                gid = dir->i_gid;
-        else
-                gid = current_fsgid();
 
-        inode = hugetlbfs_get_inode(dir->i_sb, current_fsuid(),
-                                        gid, S_IFLNK|S_IRWXUGO, 0);
+        inode = hugetlbfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
         if (inode) {
                 int l = strlen(symname)+1;
                 error = page_symlink(inode, symname, l);
@@ -857,8 +864,7 @@ hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_magic = HUGETLBFS_MAGIC;
         sb->s_op = &hugetlbfs_ops;
         sb->s_time_gran = 1;
-        inode = hugetlbfs_get_inode(sb, config.uid, config.gid,
-                                        S_IFDIR | config.mode, 0);
+        inode = hugetlbfs_get_root(sb, &config);
         if (!inode)
                 goto out_free;
 
@@ -956,8 +962,7 @@ struct file *hugetlb_file_setup(const char *name, size_t size,
 
         path.mnt = mntget(hugetlbfs_vfsmount);
         error = -ENOSPC;
-        inode = hugetlbfs_get_inode(root->d_sb, current_fsuid(),
-                                current_fsgid(), S_IFREG | S_IRWXUGO, 0);
+        inode = hugetlbfs_get_inode(root->d_sb, NULL, S_IFREG | S_IRWXUGO, 0);
         if (!inode)
                 goto out_dentry;
 
diff --git a/fs/inode.c b/fs/inode.c
index 24d02907e196..961355d00e38 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1646,7 +1646,7 @@ EXPORT_SYMBOL(init_special_inode);
  * @mode: mode of the new inode
  */
 void inode_init_owner(struct inode *inode, const struct inode *dir,
-                        mode_t mode)
+                        umode_t mode)
 {
         inode->i_uid = current_fsuid();
         if (dir && dir->i_mode & S_ISGID) {
diff --git a/fs/internal.h b/fs/internal.h
index 6aab61a4f36f..2523a4029452 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -88,7 +88,7 @@ extern struct file *nameidata_to_filp(struct nameidata *);
 extern void release_open_intent(struct nameidata *);
 struct open_flags {
         int open_flag;
-        int mode;
+        umode_t mode;
         int acc_mode;
         int intent;
 };
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index b71f6311a337..7b99f5f460be 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -169,8 +169,8 @@ struct iso9660_options{
         unsigned char map;
         unsigned char check;
         unsigned int blocksize;
-        mode_t fmode;
-        mode_t dmode;
+        umode_t fmode;
+        umode_t dmode;
         gid_t gid;
         uid_t uid;
         char *iocharset;
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index 7d33de84f52a..0e73f63d9274 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -50,14 +50,14 @@ struct isofs_sb_info {
         unsigned int  s_uid_set:1;
         unsigned int  s_gid_set:1;
 
-        mode_t s_fmode;
-        mode_t s_dmode;
+        umode_t s_fmode;
+        umode_t s_dmode;
         gid_t s_gid;
         uid_t s_uid;
         struct nls_table *s_nls_iocharset; /* Native language support table */
 };
 
-#define ISOFS_INVALID_MODE ((mode_t) -1)
+#define ISOFS_INVALID_MODE ((umode_t) -1)
 
 static inline struct isofs_sb_info *ISOFS_SB(struct super_block *sb)
 {
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index be6169bd8acd..973ac5822bd7 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -22,16 +22,16 @@
 
 static int jffs2_readdir (struct file *, void *, filldir_t);
 
-static int jffs2_create (struct inode *,struct dentry *,int,
+static int jffs2_create (struct inode *,struct dentry *,umode_t,
                          struct nameidata *);
 static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
                                     struct nameidata *);
 static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
 static int jffs2_unlink (struct inode *,struct dentry *);
 static int jffs2_symlink (struct inode *,struct dentry *,const char *);
-static int jffs2_mkdir (struct inode *,struct dentry *,int);
+static int jffs2_mkdir (struct inode *,struct dentry *,umode_t);
 static int jffs2_rmdir (struct inode *,struct dentry *);
-static int jffs2_mknod (struct inode *,struct dentry *,int,dev_t);
+static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t);
 static int jffs2_rename (struct inode *, struct dentry *,
                          struct inode *, struct dentry *);
 
@@ -169,8 +169,8 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
 /***********************************************************************/
 
 
-static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode,
-                        struct nameidata *nd)
+static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
+                        umode_t mode, struct nameidata *nd)
 {
         struct jffs2_raw_inode *ri;
         struct jffs2_inode_info *f, *dir_f;
@@ -450,7 +450,7 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
 }
 
 
-static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
+static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode)
 {
         struct jffs2_inode_info *f, *dir_f;
         struct jffs2_sb_info *c;
@@ -618,7 +618,7 @@ static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
         return ret;
 }
 
-static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, dev_t rdev)
+static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         struct jffs2_inode_info *f, *dir_f;
         struct jffs2_sb_info *c;
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index a112ad96e474..5f7c160ea64f 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -72,7 +72,7 @@ static inline void free_ea_wmap(struct inode *inode)
  * RETURN:      Errors from subroutines
  *
  */
-static int jfs_create(struct inode *dip, struct dentry *dentry, int mode,
+static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         int rc = 0;
@@ -205,7 +205,7 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, int mode,
  * note:
  * EACCESS: user needs search+write permission on the parent directory
  */
-static int jfs_mkdir(struct inode *dip, struct dentry *dentry, int mode)
+static int jfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
 {
         int rc = 0;
         tid_t tid;              /* transaction id */
@@ -1353,7 +1353,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  * FUNCTION:    Create a special file (device)
  */
 static int jfs_mknod(struct inode *dir, struct dentry *dentry,
-                int mode, dev_t rdev)
+                umode_t mode, dev_t rdev)
 {
         struct jfs_inode_info *jfs_ip;
         struct btstack btstack;
diff --git a/fs/libfs.c b/fs/libfs.c
index f6d411eef1e7..5b2dbb3ba4fc 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -12,7 +12,7 @@
 #include <linux/mutex.h>
 #include <linux/exportfs.h>
 #include <linux/writeback.h>
-#include <linux/buffer_head.h>
+#include <linux/buffer_head.h> /* sync_mapping_buffers */
 
 #include <asm/uaccess.h>
 
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index b7d7f67cee5a..501043e8966c 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -482,7 +482,7 @@ out:
         return ret;
 }
 
-static int logfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int logfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
 
@@ -501,7 +501,7 @@ static int logfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return __logfs_create(dir, dentry, inode, NULL, 0);
 }
 
-static int logfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int logfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         struct inode *inode;
@@ -517,7 +517,7 @@ static int logfs_create(struct inode *dir, struct dentry *dentry, int mode,
         return __logfs_create(dir, dentry, inode, NULL, 0);
 }
 
-static int logfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+static int logfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                 dev_t rdev)
 {
         struct inode *inode;
diff --git a/fs/logfs/inode.c b/fs/logfs/inode.c
index 4d1af42bfd24..388df1aa35e5 100644
--- a/fs/logfs/inode.c
+++ b/fs/logfs/inode.c
@@ -323,7 +323,7 @@ static void logfs_set_ino_generation(struct super_block *sb,
         mutex_unlock(&super->s_journal_mutex);
 }
 
-struct inode *logfs_new_inode(struct inode *dir, int mode)
+struct inode *logfs_new_inode(struct inode *dir, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct inode *inode;
diff --git a/fs/logfs/logfs.h b/fs/logfs/logfs.h
index 398ecff6e548..926373866a55 100644
--- a/fs/logfs/logfs.h
+++ b/fs/logfs/logfs.h
@@ -520,7 +520,7 @@ extern const struct super_operations logfs_super_operations;
 struct inode *logfs_iget(struct super_block *sb, ino_t ino);
 struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie);
 void logfs_safe_iput(struct inode *inode, int cookie);
-struct inode *logfs_new_inode(struct inode *dir, int mode);
+struct inode *logfs_new_inode(struct inode *dir, umode_t mode);
 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino);
 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino);
 int logfs_init_inode_cache(void);
diff --git a/fs/minix/bitmap.c b/fs/minix/bitmap.c
index ef175cb8cfd8..4bc50dac8e97 100644
--- a/fs/minix/bitmap.c
+++ b/fs/minix/bitmap.c
@@ -209,7 +209,7 @@ void minix_free_inode(struct inode * inode)
         mark_buffer_dirty(bh);
 }
 
-struct inode *minix_new_inode(const struct inode *dir, int mode, int *error)
+struct inode *minix_new_inode(const struct inode *dir, umode_t mode, int *error)
 {
         struct super_block *sb = dir->i_sb;
         struct minix_sb_info *sbi = minix_sb(sb);
diff --git a/fs/minix/minix.h b/fs/minix/minix.h
index 26bbd55e82ea..c889ef0aa571 100644
--- a/fs/minix/minix.h
+++ b/fs/minix/minix.h
@@ -46,7 +46,7 @@ struct minix_sb_info {
 extern struct inode *minix_iget(struct super_block *, unsigned long);
 extern struct minix_inode * minix_V1_raw_inode(struct super_block *, ino_t, struct buffer_head **);
 extern struct minix2_inode * minix_V2_raw_inode(struct super_block *, ino_t, struct buffer_head **);
-extern struct inode * minix_new_inode(const struct inode *, int, int *);
+extern struct inode * minix_new_inode(const struct inode *, umode_t, int *);
 extern void minix_free_inode(struct inode * inode);
 extern unsigned long minix_count_free_inodes(struct super_block *sb);
 extern int minix_new_block(struct inode * inode);
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index 6e6777f1b4b2..2f76e38c2065 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -36,7 +36,7 @@ static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, st
         return NULL;
 }
 
-static int minix_mknod(struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
+static int minix_mknod(struct inode * dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         int error;
         struct inode *inode;
@@ -54,7 +54,7 @@ static int minix_mknod(struct inode * dir, struct dentry *dentry, int mode, dev_
         return error;
 }
 
-static int minix_create(struct inode * dir, struct dentry *dentry, int mode,
+static int minix_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         return minix_mknod(dir, dentry, mode, 0);
@@ -103,7 +103,7 @@ static int minix_link(struct dentry * old_dentry, struct inode * dir,
         return add_nondir(dentry, inode);
 }
 
-static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
+static int minix_mkdir(struct inode * dir, struct dentry *dentry, umode_t mode)
 {
         struct inode * inode;
         int err = -EMLINK;
diff --git a/fs/namei.c b/fs/namei.c
index 87363aab43f0..c283a1ec008e 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1979,7 +1979,7 @@ void unlock_rename(struct dentry *p1, struct dentry *p2)
         }
 }
 
-int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
+int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         int error = may_create(dir, dentry);
@@ -2180,7 +2180,7 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
 
         /* Negative dentry, just create the file */
         if (!dentry->d_inode) {
-                int mode = op->mode;
+                umode_t mode = op->mode;
                 if (!IS_POSIXACL(dir->d_inode))
                         mode &= ~current_umask();
                 /*
@@ -2447,7 +2447,7 @@ struct dentry *user_path_create(int dfd, const char __user *pathname, struct pat
 }
 EXPORT_SYMBOL(user_path_create);
 
-int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 {
         int error = may_create(dir, dentry);
 
@@ -2475,7 +2475,7 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
         return error;
 }
 
-static int may_mknod(mode_t mode)
+static int may_mknod(umode_t mode)
 {
         switch (mode & S_IFMT) {
         case S_IFREG:
@@ -2492,7 +2492,7 @@ static int may_mknod(mode_t mode)
         }
 }
 
-SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
+SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
                 unsigned, dev)
 {
         struct dentry *dentry;
@@ -2539,12 +2539,12 @@ out_dput:
         return error;
 }
 
-SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
+SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev)
 {
         return sys_mknodat(AT_FDCWD, filename, mode, dev);
 }
 
-int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int error = may_create(dir, dentry);
 
@@ -2565,7 +2565,7 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return error;
 }
 
-SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
+SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
 {
         struct dentry *dentry;
         struct path path;
@@ -2593,7 +2593,7 @@ out_dput:
         return error;
 }
 
-SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
+SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
 {
         return sys_mkdirat(AT_FDCWD, pathname, mode);
 }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 9c51f621e901..aeed93a6bde0 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -30,15 +30,15 @@ static void ncp_do_readdir(struct file *, void *, filldir_t,
 
 static int ncp_readdir(struct file *, void *, filldir_t);
 
-static int ncp_create(struct inode *, struct dentry *, int, struct nameidata *);
+static int ncp_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
 static struct dentry *ncp_lookup(struct inode *, struct dentry *, struct nameidata *);
 static int ncp_unlink(struct inode *, struct dentry *);
-static int ncp_mkdir(struct inode *, struct dentry *, int);
+static int ncp_mkdir(struct inode *, struct dentry *, umode_t);
 static int ncp_rmdir(struct inode *, struct dentry *);
 static int ncp_rename(struct inode *, struct dentry *,
                       struct inode *, struct dentry *);
 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
-                     int mode, dev_t rdev);
+                     umode_t mode, dev_t rdev);
 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
 extern int ncp_symlink(struct inode *, struct dentry *, const char *);
 #else
@@ -919,7 +919,7 @@ out_close:
         goto out;
 }
 
-int ncp_create_new(struct inode *dir, struct dentry *dentry, int mode,
+int ncp_create_new(struct inode *dir, struct dentry *dentry, umode_t mode,
                    dev_t rdev, __le32 attributes)
 {
         struct ncp_server *server = NCP_SERVER(dir);
@@ -928,7 +928,7 @@ int ncp_create_new(struct inode *dir, struct dentry *dentry, int mode,
         int opmode;
         __u8 __name[NCP_MAXPATHLEN + 1];
         
-        PPRINTK("ncp_create_new: creating %s/%s, mode=%x\n",
+        PPRINTK("ncp_create_new: creating %s/%s, mode=%hx\n",
                 dentry->d_parent->d_name.name, dentry->d_name.name, mode);
 
         ncp_age_dentry(server, dentry);
@@ -979,13 +979,13 @@ out:
         return error;
 }
 
-static int ncp_create(struct inode *dir, struct dentry *dentry, int mode,
+static int ncp_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         return ncp_create_new(dir, dentry, mode, 0, 0);
 }
 
-static int ncp_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ncp_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct ncp_entry_info finfo;
         struct ncp_server *server = NCP_SERVER(dir);
@@ -1201,12 +1201,12 @@ out:
 }
 
 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
-                     int mode, dev_t rdev)
+                     umode_t mode, dev_t rdev)
 {
         if (!new_valid_dev(rdev))
                 return -EINVAL;
         if (ncp_is_nfs_extras(NCP_SERVER(dir), NCP_FINFO(dir)->volNumber)) {
-                DPRINTK(KERN_DEBUG "ncp_mknod: mode = 0%o\n", mode);
+                DPRINTK(KERN_DEBUG "ncp_mknod: mode = 0%ho\n", mode);
                 return ncp_create_new(dir, dentry, mode, rdev, 0);
         }
         return -EPERM; /* Strange, but true */
diff --git a/fs/ncpfs/ncplib_kernel.h b/fs/ncpfs/ncplib_kernel.h
index 09881e6aa5ad..32c06587351a 100644
--- a/fs/ncpfs/ncplib_kernel.h
+++ b/fs/ncpfs/ncplib_kernel.h
@@ -114,7 +114,7 @@ int ncp_dirhandle_alloc(struct ncp_server *, __u8 vol, __le32 dirent, __u8 *dirh
 int ncp_dirhandle_free(struct ncp_server *, __u8 dirhandle);
 
 int ncp_create_new(struct inode *dir, struct dentry *dentry,
-                          int mode, dev_t rdev, __le32 attributes);
+                          umode_t mode, dev_t rdev, __le32 attributes);
 
 static inline int ncp_is_nfs_extras(struct ncp_server* server, unsigned int volnum) {
 #ifdef CONFIG_NCPFS_NFS_NS
diff --git a/fs/ncpfs/symlink.c b/fs/ncpfs/symlink.c
index 661f861d80c6..52439ddc8de0 100644
--- a/fs/ncpfs/symlink.c
+++ b/fs/ncpfs/symlink.c
@@ -108,7 +108,7 @@ int ncp_symlink(struct inode *dir, struct dentry *dentry, const char *symname) {
         char *rawlink;
         int length, err, i, outlen;
         int kludge;
-        int mode;
+        umode_t mode;
         __le32 attr;
         unsigned int hdr;
 
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 23be134b3193..fd9a872fada0 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -47,13 +47,13 @@ static int nfs_opendir(struct inode *, struct file *);
 static int nfs_closedir(struct inode *, struct file *);
 static int nfs_readdir(struct file *, void *, filldir_t);
 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
-static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *);
-static int nfs_mkdir(struct inode *, struct dentry *, int);
+static int nfs_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
+static int nfs_mkdir(struct inode *, struct dentry *, umode_t);
 static int nfs_rmdir(struct inode *, struct dentry *);
 static int nfs_unlink(struct inode *, struct dentry *);
 static int nfs_symlink(struct inode *, struct dentry *, const char *);
 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
-static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
+static int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
 static int nfs_rename(struct inode *, struct dentry *,
                       struct inode *, struct dentry *);
 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
@@ -112,7 +112,7 @@ const struct inode_operations nfs3_dir_inode_operations = {
 #ifdef CONFIG_NFS_V4
 
 static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
-static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd);
+static int nfs_open_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd);
 const struct inode_operations nfs4_dir_inode_operations = {
         .create         = nfs_open_create,
         .lookup         = nfs_atomic_lookup,
@@ -1573,8 +1573,8 @@ no_open:
         return nfs_lookup_revalidate(dentry, nd);
 }
 
-static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
-                struct nameidata *nd)
+static int nfs_open_create(struct inode *dir, struct dentry *dentry,
+                umode_t mode, struct nameidata *nd)
 {
         struct nfs_open_context *ctx = NULL;
         struct iattr attr;
@@ -1664,8 +1664,8 @@ out_error:
  * that the operation succeeded on the server, but an error in the
  * reply path made it appear to have failed.
  */
-static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
-                struct nameidata *nd)
+static int nfs_create(struct inode *dir, struct dentry *dentry,
+                umode_t mode, struct nameidata *nd)
 {
         struct iattr attr;
         int error;
@@ -1693,7 +1693,7 @@ out_err:
  * See comments for nfs_proc_create regarding failed operations.
  */
 static int
-nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
+nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         struct iattr attr;
         int status;
@@ -1719,7 +1719,7 @@ out_err:
 /*
  * See comments for nfs_proc_create regarding failed operations.
  */
-static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct iattr attr;
         int error;
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index c763de5c1157..68454e75fce9 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -59,7 +59,7 @@ static int nfsd_acceptable(void *expv, struct dentry *dentry)
  * the write call).
  */
 static inline __be32
-nfsd_mode_check(struct svc_rqst *rqstp, umode_t mode, int requested)
+nfsd_mode_check(struct svc_rqst *rqstp, umode_t mode, umode_t requested)
 {
         mode &= S_IFMT;
 
@@ -293,7 +293,7 @@ out:
  * include/linux/nfsd/nfsd.h.
  */
 __be32
-fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
+fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, int access)
 {
         struct svc_export *exp;
         struct dentry   *dentry;
diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index c16f8d8331b5..e5e6707ba687 100644
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -102,7 +102,7 @@ extern char * SVCFH_fmt(struct svc_fh *fhp);
 /*
  * Function prototypes
  */
-__be32  fh_verify(struct svc_rqst *, struct svc_fh *, int, int);
+__be32  fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int);
 __be32  fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
 __be32  fh_update(struct svc_fh *);
 void    fh_put(struct svc_fh *);
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 29b1202313e9..d25a723b68ad 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -307,7 +307,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
         struct dentry   *dentry;
         struct inode    *inode;
         int             accmode = NFSD_MAY_SATTR;
-        int             ftype = 0;
+        umode_t         ftype = 0;
         __be32          err;
         int             host_err;
         int             size_change = 0;
@@ -730,7 +730,7 @@ static int nfsd_open_break_lease(struct inode *inode, int access)
  * N.B. After this call fhp needs an fh_put
  */
 __be32
-nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
+nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
                         int access, struct file **filp)
 {
         struct dentry   *dentry;
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index cee6a12296e8..1dcd238e11a0 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -66,7 +66,7 @@ __be32		do_nfsd_create(struct svc_rqst *, struct svc_fh *,
 __be32          nfsd_commit(struct svc_rqst *, struct svc_fh *,
                                 loff_t, unsigned long);
 #endif /* CONFIG_NFSD_V3 */
-__be32          nfsd_open(struct svc_rqst *, struct svc_fh *, int,
+__be32          nfsd_open(struct svc_rqst *, struct svc_fh *, umode_t,
                                 int, struct file **);
 void            nfsd_close(struct file *);
 __be32          nfsd_read(struct svc_rqst *, struct svc_fh *,
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 3a1923943b14..ca35b3a46d17 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -251,7 +251,7 @@ nilfs_type_by_mode[S_IFMT >> S_SHIFT] = {
 
 static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
 {
-        mode_t mode = inode->i_mode;
+        umode_t mode = inode->i_mode;
 
         de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
 }
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index b50ffb72e5b3..8f7b95ac1f7e 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -291,7 +291,7 @@ const struct address_space_operations nilfs_aops = {
         .is_partially_uptodate  = block_is_partially_uptodate,
 };
 
-struct inode *nilfs_new_inode(struct inode *dir, int mode)
+struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct the_nilfs *nilfs = sb->s_fs_info;
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 768982de10e4..1cd3f624dffc 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -84,7 +84,7 @@ nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
  * If the create succeeds, we fill in the inode information
  * with d_instantiate().
  */
-static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int nilfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                         struct nameidata *nd)
 {
         struct inode *inode;
@@ -112,7 +112,7 @@ static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode,
 }
 
 static int
-nilfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
+nilfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         struct inode *inode;
         struct nilfs_transaction_info ti;
@@ -213,7 +213,7 @@ static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
         return err;
 }
 
-static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
         struct nilfs_transaction_info ti;
diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index 3777d138f895..250add84da76 100644
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -246,7 +246,7 @@ int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *, struct nilfs_argv *,
 /* inode.c */
 void nilfs_inode_add_blocks(struct inode *inode, int n);
 void nilfs_inode_sub_blocks(struct inode *inode, int n);
-extern struct inode *nilfs_new_inode(struct inode *, int);
+extern struct inode *nilfs_new_inode(struct inode *, umode_t);
 extern void nilfs_free_inode(struct inode *);
 extern int nilfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern void nilfs_set_inode_flags(struct inode *);
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index b52706da4645..608be4516091 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -104,7 +104,7 @@ static bool parse_options(ntfs_volume *vol, char *opt)
         int errors = 0, sloppy = 0;
         uid_t uid = (uid_t)-1;
         gid_t gid = (gid_t)-1;
-        mode_t fmask = (mode_t)-1, dmask = (mode_t)-1;
+        umode_t fmask = (umode_t)-1, dmask = (umode_t)-1;
         int mft_zone_multiplier = -1, on_errors = -1;
         int show_sys_files = -1, case_sensitive = -1, disable_sparse = -1;
         struct nls_table *nls_map = NULL, *old_nls;
@@ -287,9 +287,9 @@ no_mount_options:
                 vol->uid = uid;
         if (gid != (gid_t)-1)
                 vol->gid = gid;
-        if (fmask != (mode_t)-1)
+        if (fmask != (umode_t)-1)
                 vol->fmask = fmask;
-        if (dmask != (mode_t)-1)
+        if (dmask != (umode_t)-1)
                 vol->dmask = dmask;
         if (show_sys_files != -1) {
                 if (show_sys_files)
diff --git a/fs/ntfs/volume.h b/fs/ntfs/volume.h
index 406ab55dfb32..15e3ba8d521a 100644
--- a/fs/ntfs/volume.h
+++ b/fs/ntfs/volume.h
@@ -48,8 +48,8 @@ typedef struct {
         unsigned long flags;            /* Miscellaneous flags, see below. */
         uid_t uid;                      /* uid that files will be mounted as. */
         gid_t gid;                      /* gid that files will be mounted as. */
-        mode_t fmask;                   /* The mask for file permissions. */
-        mode_t dmask;                   /* The mask for directory
+        umode_t fmask;                  /* The mask for file permissions. */
+        umode_t dmask;                  /* The mask for directory
                                            permissions. */
         u8 mft_zone_multiplier;         /* Initial mft zone multiplier. */
         u8 on_errors;                   /* What to do on filesystem errors. */
diff --git a/fs/ocfs2/cluster/netdebug.c b/fs/ocfs2/cluster/netdebug.c
index dc45deb19e68..73ba81928bce 100644
--- a/fs/ocfs2/cluster/netdebug.c
+++ b/fs/ocfs2/cluster/netdebug.c
@@ -553,7 +553,7 @@ void o2net_debugfs_exit(void)
 
 int o2net_debugfs_init(void)
 {
-        mode_t mode = S_IFREG|S_IRUSR;
+        umode_t mode = S_IFREG|S_IRUSR;
 
         o2net_dentry = debugfs_create_dir(O2NET_DEBUG_DIR, NULL);
         if (o2net_dentry)
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index a9f007de1da8..abfac0d7ae9c 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -400,16 +400,14 @@ static struct backing_dev_info dlmfs_backing_dev_info = {
 static struct inode *dlmfs_get_root_inode(struct super_block *sb)
 {
         struct inode *inode = new_inode(sb);
-        int mode = S_IFDIR | 0755;
+        umode_t mode = S_IFDIR | 0755;
         struct dlmfs_inode_private *ip;
 
         if (inode) {
                 ip = DLMFS_I(inode);
 
                 inode->i_ino = get_next_ino();
-                inode->i_mode = mode;
-                inode->i_uid = current_fsuid();
-                inode->i_gid = current_fsgid();
+                inode_init_owner(inode, NULL, mode);
                 inode->i_mapping->backing_dev_info = &dlmfs_backing_dev_info;
                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
                 inc_nlink(inode);
@@ -423,7 +421,7 @@ static struct inode *dlmfs_get_root_inode(struct super_block *sb)
 
 static struct inode *dlmfs_get_inode(struct inode *parent,
                                      struct dentry *dentry,
-                                     int mode)
+                                     umode_t mode)
 {
         struct super_block *sb = parent->i_sb;
         struct inode * inode = new_inode(sb);
@@ -433,9 +431,7 @@ static struct inode *dlmfs_get_inode(struct inode *parent,
                 return NULL;
 
         inode->i_ino = get_next_ino();
-        inode->i_mode = mode;
-        inode->i_uid = current_fsuid();
-        inode->i_gid = current_fsgid();
+        inode_init_owner(inode, parent, mode);
         inode->i_mapping->backing_dev_info = &dlmfs_backing_dev_info;
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 
@@ -472,13 +468,6 @@ static struct inode *dlmfs_get_inode(struct inode *parent,
                 inc_nlink(inode);
                 break;
         }
-
-        if (parent->i_mode & S_ISGID) {
-                inode->i_gid = parent->i_gid;
-                if (S_ISDIR(mode))
-                        inode->i_mode |= S_ISGID;
-        }
-
         return inode;
 }
 
@@ -488,7 +477,7 @@ static struct inode *dlmfs_get_inode(struct inode *parent,
 /* SMP-safe */
 static int dlmfs_mkdir(struct inode * dir,
                        struct dentry * dentry,
-                       int mode)
+                       umode_t mode)
 {
         int status;
         struct inode *inode = NULL;
@@ -536,7 +525,7 @@ bail:
 
 static int dlmfs_create(struct inode *dir,
                         struct dentry *dentry,
-                        int mode,
+                        umode_t mode,
                         struct nameidata *nd)
 {
         int status = 0;
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index a8b2bfea574e..be244692550d 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -185,7 +185,7 @@ bail:
         return ret;
 }
 
-static struct inode *ocfs2_get_init_inode(struct inode *dir, int mode)
+static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
 {
         struct inode *inode;
 
@@ -207,7 +207,7 @@ static struct inode *ocfs2_get_init_inode(struct inode *dir, int mode)
 
 static int ocfs2_mknod(struct inode *dir,
                        struct dentry *dentry,
-                       int mode,
+                       umode_t mode,
                        dev_t dev)
 {
         int status = 0;
@@ -602,7 +602,7 @@ static int ocfs2_mknod_locked(struct ocfs2_super *osb,
 
 static int ocfs2_mkdir(struct inode *dir,
                        struct dentry *dentry,
-                       int mode)
+                       umode_t mode)
 {
         int ret;
 
@@ -617,7 +617,7 @@ static int ocfs2_mkdir(struct inode *dir,
 
 static int ocfs2_create(struct inode *dir,
                         struct dentry *dentry,
-                        int mode,
+                        umode_t mode,
                         struct nameidata *nd)
 {
         int ret;
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index aa9e8777b09a..0ba9ea1e7961 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -623,7 +623,7 @@ int ocfs2_calc_security_init(struct inode *dir,
 
 int ocfs2_calc_xattr_init(struct inode *dir,
                           struct buffer_head *dir_bh,
-                          int mode,
+                          umode_t mode,
                           struct ocfs2_security_xattr_info *si,
                           int *want_clusters,
                           int *xattr_credits,
diff --git a/fs/ocfs2/xattr.h b/fs/ocfs2/xattr.h
index d63cfb72316b..e5c7f15465b4 100644
--- a/fs/ocfs2/xattr.h
+++ b/fs/ocfs2/xattr.h
@@ -68,7 +68,7 @@ int ocfs2_calc_security_init(struct inode *,
                              struct ocfs2_security_xattr_info *,
                              int *, int *, struct ocfs2_alloc_context **);
 int ocfs2_calc_xattr_init(struct inode *, struct buffer_head *,
-                          int, struct ocfs2_security_xattr_info *,
+                          umode_t, struct ocfs2_security_xattr_info *,
                           int *, int *, int *);
 
 /*
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index 98e544274390..f00576ec320f 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -255,7 +255,7 @@ static int omfs_remove(struct inode *dir, struct dentry *dentry)
         return 0;
 }
 
-static int omfs_add_node(struct inode *dir, struct dentry *dentry, int mode)
+static int omfs_add_node(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int err;
         struct inode *inode = omfs_new_inode(dir, mode);
@@ -279,12 +279,12 @@ out_free_inode:
         return err;
 }
 
-static int omfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int omfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         return omfs_add_node(dir, dentry, mode | S_IFDIR);
 }
 
-static int omfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int omfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 struct nameidata *nd)
 {
         return omfs_add_node(dir, dentry, mode | S_IFREG);
diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index e043c4cb9a97..6065bb0ba207 100644
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -28,7 +28,7 @@ struct buffer_head *omfs_bread(struct super_block *sb, sector_t block)
         return sb_bread(sb, clus_to_blk(sbi, block));
 }
 
-struct inode *omfs_new_inode(struct inode *dir, int mode)
+struct inode *omfs_new_inode(struct inode *dir, umode_t mode)
 {
         struct inode *inode;
         u64 new_block;
diff --git a/fs/omfs/omfs.h b/fs/omfs/omfs.h
index 7d414fef501a..8941f12c6b01 100644
--- a/fs/omfs/omfs.h
+++ b/fs/omfs/omfs.h
@@ -60,7 +60,7 @@ extern int omfs_shrink_inode(struct inode *inode);
 /* inode.c */
 extern struct buffer_head *omfs_bread(struct super_block *sb, sector_t block);
 extern struct inode *omfs_iget(struct super_block *sb, ino_t inode);
-extern struct inode *omfs_new_inode(struct inode *dir, int mode);
+extern struct inode *omfs_new_inode(struct inode *dir, umode_t mode);
 extern int omfs_reserve_block(struct super_block *sb, sector_t block);
 extern int omfs_find_empty_block(struct super_block *sb, int mode, ino_t *ino);
 extern int omfs_sync_inode(struct inode *inode);
diff --git a/fs/open.c b/fs/open.c
index 4ef8d868a448..2659f596f4c5 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -468,7 +468,7 @@ out_unlock:
         return error;
 }
 
-SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
+SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
 {
         struct file * file;
         int err = -EBADF;
@@ -482,7 +482,7 @@ SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
         return err;
 }
 
-SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
+SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, umode_t, mode)
 {
         struct path path;
         int error;
@@ -495,7 +495,7 @@ SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
         return error;
 }
 
-SYSCALL_DEFINE2(chmod, const char __user *, filename, mode_t, mode)
+SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
 {
         return sys_fchmodat(AT_FDCWD, filename, mode);
 }
@@ -877,7 +877,7 @@ void fd_install(unsigned int fd, struct file *file)
 
 EXPORT_SYMBOL(fd_install);
 
-static inline int build_open_flags(int flags, int mode, struct open_flags *op)
+static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
 {
         int lookup_flags = 0;
         int acc_mode;
@@ -948,7 +948,7 @@ static inline int build_open_flags(int flags, int mode, struct open_flags *op)
  * have to.  But in generally you should not do this, so please move
  * along, nothing to see here..
  */
-struct file *filp_open(const char *filename, int flags, int mode)
+struct file *filp_open(const char *filename, int flags, umode_t mode)
 {
         struct open_flags op;
         int lookup = build_open_flags(flags, mode, &op);
@@ -970,7 +970,7 @@ struct file *file_open_root(struct dentry *dentry, struct vfsmount *mnt,
 }
 EXPORT_SYMBOL(file_open_root);
 
-long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
+long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
 {
         struct open_flags op;
         int lookup = build_open_flags(flags, mode, &op);
@@ -994,7 +994,7 @@ long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
         return fd;
 }
 
-SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
+SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
 {
         long ret;
 
@@ -1008,7 +1008,7 @@ SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
 }
 
 SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
-                int, mode)
+                umode_t, mode)
 {
         long ret;
 
@@ -1027,7 +1027,7 @@ SYSCALL_DEFINE4(openat, int, dfd, const char __user *, filename, int, flags,
  * For backward compatibility?  Maybe this should be moved
  * into arch/i386 instead?
  */
-SYSCALL_DEFINE2(creat, const char __user *, pathname, int, mode)
+SYSCALL_DEFINE2(creat, const char __user *, pathname, umode_t, mode)
 {
         return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }
diff --git a/fs/partitions/Kconfig b/fs/partitions/Kconfig
deleted file mode 100644
index cb5f0a3f1b03..000000000000
--- a/fs/partitions/Kconfig
+++ /dev/null
@@ -1,251 +0,0 @@
-#
-# Partition configuration
-#
-config PARTITION_ADVANCED
-        bool "Advanced partition selection"
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned under an operating system running on a different
-          architecture than your Linux system.
-
-          Note that the answer to this question won't directly affect the
-          kernel: saying N will just cause the configurator to skip all
-          the questions about foreign partitioning schemes.
-
-          If unsure, say N.
-
-config ACORN_PARTITION
-        bool "Acorn partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        help
-          Support hard disks partitioned under Acorn operating systems.
-
-config ACORN_PARTITION_CUMANA
-        bool "Cumana partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned using the Cumana interface on Acorn machines.
-
-config ACORN_PARTITION_EESOX
-        bool "EESOX partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-
-config ACORN_PARTITION_ICS
-        bool "ICS partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned using the ICS interface on Acorn machines.
-
-config ACORN_PARTITION_ADFS
-        bool "Native filecore partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-        help
-          The Acorn Disc Filing System is the standard file system of the
-          RiscOS operating system which runs on Acorn's ARM-based Risc PC
-          systems and the Acorn Archimedes range of machines.  If you say
-          `Y' here, Linux will support disk partitions created under ADFS.
-
-config ACORN_PARTITION_POWERTEC
-        bool "PowerTec partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-        help
-          Support reading partition tables created on Acorn machines using
-          the PowerTec SCSI drive.
-
-config ACORN_PARTITION_RISCIX
-        bool "RISCiX partition support" if PARTITION_ADVANCED
-        default y if ARCH_ACORN
-        depends on ACORN_PARTITION
-        help
-          Once upon a time, there was a native Unix port for the Acorn series
-          of machines called RISCiX.  If you say 'Y' here, Linux will be able
-          to read disks partitioned under RISCiX.
-
-config OSF_PARTITION
-        bool "Alpha OSF partition support" if PARTITION_ADVANCED
-        default y if ALPHA
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned on an Alpha machine.
-
-config AMIGA_PARTITION
-        bool "Amiga partition table support" if PARTITION_ADVANCED
-        default y if (AMIGA || AFFS_FS=y)
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned under AmigaOS.
-
-config ATARI_PARTITION
-        bool "Atari partition table support" if PARTITION_ADVANCED
-        default y if ATARI
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned under the Atari OS.
-
-config IBM_PARTITION
-        bool "IBM disk label and partition support"
-        depends on PARTITION_ADVANCED && S390
-        help
-          Say Y here if you would like to be able to read the hard disk
-          partition table format used by IBM DASD disks operating under CMS.
-          Otherwise, say N.
-
-config MAC_PARTITION
-        bool "Macintosh partition map support" if PARTITION_ADVANCED
-        default y if (MAC || PPC_PMAC)
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned on a Macintosh.
-
-config MSDOS_PARTITION
-        bool "PC BIOS (MSDOS partition tables) support" if PARTITION_ADVANCED
-        default y
-        help
-          Say Y here.
-
-config BSD_DISKLABEL
-        bool "BSD disklabel (FreeBSD partition tables) support"
-        depends on PARTITION_ADVANCED && MSDOS_PARTITION
-        help
-          FreeBSD uses its own hard disk partition scheme on your PC. It
-          requires only one entry in the primary partition table of your disk
-          and manages it similarly to DOS extended partitions, putting in its
-          first sector a new partition table in BSD disklabel format. Saying Y
-          here allows you to read these disklabels and further mount FreeBSD
-          partitions from within Linux if you have also said Y to "UFS
-          file system support", above. If you don't know what all this is
-          about, say N.
-
-config MINIX_SUBPARTITION
-        bool "Minix subpartition support"
-        depends on PARTITION_ADVANCED && MSDOS_PARTITION
-        help
-          Minix 2.0.0/2.0.2 subpartition table support for Linux.
-          Say Y here if you want to mount and use Minix 2.0.0/2.0.2
-          subpartitions.
-
-config SOLARIS_X86_PARTITION
-        bool "Solaris (x86) partition table support"
-        depends on PARTITION_ADVANCED && MSDOS_PARTITION
-        help
-          Like most systems, Solaris x86 uses its own hard disk partition
-          table format, incompatible with all others. Saying Y here allows you
-          to read these partition tables and further mount Solaris x86
-          partitions from within Linux if you have also said Y to "UFS
-          file system support", above.
-
-config UNIXWARE_DISKLABEL
-        bool "Unixware slices support"
-        depends on PARTITION_ADVANCED && MSDOS_PARTITION
-        ---help---
-          Like some systems, UnixWare uses its own slice table inside a
-          partition (VTOC - Virtual Table of Contents). Its format is
-          incompatible with all other OSes. Saying Y here allows you to read
-          VTOC and further mount UnixWare partitions read-only from within
-          Linux if you have also said Y to "UFS file system support" or
-          "System V and Coherent file system support", above.
-
-          This is mainly used to carry data from a UnixWare box to your
-          Linux box via a removable medium like magneto-optical, ZIP or
-          removable IDE drives. Note, however, that a good portable way to
-          transport files and directories between unixes (and even other
-          operating systems) is given by the tar program ("man tar" or
-          preferably "info tar").
-
-          If you don't know what all this is about, say N.
-
-config LDM_PARTITION
-        bool "Windows Logical Disk Manager (Dynamic Disk) support"
-        depends on PARTITION_ADVANCED
-        ---help---
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned using Windows 2000's/XP's or Vista's Logical Disk
-          Manager.  They are also known as "Dynamic Disks".
-
-          Note this driver only supports Dynamic Disks with a protective MBR
-          label, i.e. DOS partition table.  It does not support GPT labelled
-          Dynamic Disks yet as can be created with Vista.
-
-          Windows 2000 introduced the concept of Dynamic Disks to get around
-          the limitations of the PC's partitioning scheme.  The Logical Disk
-          Manager allows the user to repartition a disk and create spanned,
-          mirrored, striped or RAID volumes, all without the need for
-          rebooting.
-
-          Normal partitions are now called Basic Disks under Windows 2000, XP,
-          and Vista.
-
-          For a fuller description read <file:Documentation/ldm.txt>.
-
-          If unsure, say N.
-
-config LDM_DEBUG
-        bool "Windows LDM extra logging"
-        depends on LDM_PARTITION
-        help
-          Say Y here if you would like LDM to log verbosely.  This could be
-          helpful if the driver doesn't work as expected and you'd like to
-          report a bug.
-
-          If unsure, say N.
-
-config SGI_PARTITION
-        bool "SGI partition support" if PARTITION_ADVANCED
-        default y if DEFAULT_SGI_PARTITION
-        help
-          Say Y here if you would like to be able to read the hard disk
-          partition table format used by SGI machines.
-
-config ULTRIX_PARTITION
-        bool "Ultrix partition table support" if PARTITION_ADVANCED
-        default y if MACH_DECSTATION
-        help
-          Say Y here if you would like to be able to read the hard disk
-          partition table format used by DEC (now Compaq) Ultrix machines.
-          Otherwise, say N.
-
-config SUN_PARTITION
-        bool "Sun partition tables support" if PARTITION_ADVANCED
-        default y if (SPARC || SUN3 || SUN3X)
-        ---help---
-          Like most systems, SunOS uses its own hard disk partition table
-          format, incompatible with all others. Saying Y here allows you to
-          read these partition tables and further mount SunOS partitions from
-          within Linux if you have also said Y to "UFS file system support",
-          above. This is mainly used to carry data from a SPARC under SunOS to
-          your Linux box via a removable medium like magneto-optical or ZIP
-          drives; note however that a good portable way to transport files and
-          directories between unixes (and even other operating systems) is
-          given by the tar program ("man tar" or preferably "info tar"). If
-          you don't know what all this is about, say N.
-
-config KARMA_PARTITION
-        bool "Karma Partition support"
-        depends on PARTITION_ADVANCED
-        help
-          Say Y here if you would like to mount the Rio Karma MP3 player, as it
-          uses a proprietary partition table.
-
-config EFI_PARTITION
-        bool "EFI GUID Partition support"
-        depends on PARTITION_ADVANCED
-        select CRC32
-        help
-          Say Y here if you would like to use hard disks under Linux which
-          were partitioned using EFI GPT.
-
-config SYSV68_PARTITION
-        bool "SYSV68 partition table support" if PARTITION_ADVANCED
-        default y if VME
-        help
-          Say Y here if you would like to be able to read the hard disk
-          partition table format used by Motorola Delta machines (using
-          sysv68).
-          Otherwise, say N.
diff --git a/fs/partitions/Makefile b/fs/partitions/Makefile
deleted file mode 100644
index 03af8eac51da..000000000000
--- a/fs/partitions/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Makefile for the linux kernel.
-#
-
-obj-$(CONFIG_BLOCK) := check.o
-
-obj-$(CONFIG_ACORN_PARTITION) += acorn.o
-obj-$(CONFIG_AMIGA_PARTITION) += amiga.o
-obj-$(CONFIG_ATARI_PARTITION) += atari.o
-obj-$(CONFIG_MAC_PARTITION) += mac.o
-obj-$(CONFIG_LDM_PARTITION) += ldm.o
-obj-$(CONFIG_MSDOS_PARTITION) += msdos.o
-obj-$(CONFIG_OSF_PARTITION) += osf.o
-obj-$(CONFIG_SGI_PARTITION) += sgi.o
-obj-$(CONFIG_SUN_PARTITION) += sun.o
-obj-$(CONFIG_ULTRIX_PARTITION) += ultrix.o
-obj-$(CONFIG_IBM_PARTITION) += ibm.o
-obj-$(CONFIG_EFI_PARTITION) += efi.o
-obj-$(CONFIG_KARMA_PARTITION) += karma.o
-obj-$(CONFIG_SYSV68_PARTITION) += sysv68.o
diff --git a/fs/partitions/acorn.c b/fs/partitions/acorn.c
deleted file mode 100644
index fbeb697374d5..000000000000
--- a/fs/partitions/acorn.c
+++ /dev/null
@@ -1,556 +0,0 @@
-/*
- *  linux/fs/partitions/acorn.c
- *
- *  Copyright (c) 1996-2000 Russell King.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- *  Scan ADFS partitions on hard disk drives.  Unfortunately, there
- *  isn't a standard for partitioning drives on Acorn machines, so
- *  every single manufacturer of SCSI and IDE cards created their own
- *  method.
- */
-#include <linux/buffer_head.h>
-#include <linux/adfs_fs.h>
-
-#include "check.h"
-#include "acorn.h"
-
-/*
- * Partition types. (Oh for reusability)
- */
-#define PARTITION_RISCIX_MFM    1
-#define PARTITION_RISCIX_SCSI   2
-#define PARTITION_LINUX         9
-
-#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
-        defined(CONFIG_ACORN_PARTITION_ADFS)
-static struct adfs_discrecord *
-adfs_partition(struct parsed_partitions *state, char *name, char *data,
-               unsigned long first_sector, int slot)
-{
-        struct adfs_discrecord *dr;
-        unsigned int nr_sects;
-
-        if (adfs_checkbblk(data))
-                return NULL;
-
-        dr = (struct adfs_discrecord *)(data + 0x1c0);
-
-        if (dr->disc_size == 0 && dr->disc_size_high == 0)
-                return NULL;
-
-        nr_sects = (le32_to_cpu(dr->disc_size_high) << 23) |
-                   (le32_to_cpu(dr->disc_size) >> 9);
-
-        if (name) {
-                strlcat(state->pp_buf, " [", PAGE_SIZE);
-                strlcat(state->pp_buf, name, PAGE_SIZE);
-                strlcat(state->pp_buf, "]", PAGE_SIZE);
-        }
-        put_partition(state, slot, first_sector, nr_sects);
-        return dr;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_RISCIX
-
-struct riscix_part {
-        __le32  start;
-        __le32  length;
-        __le32  one;
-        char    name[16];
-};
-
-struct riscix_record {
-        __le32  magic;
-#define RISCIX_MAGIC    cpu_to_le32(0x4a657320)
-        __le32  date;
-        struct riscix_part part[8];
-};
-
-#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
-        defined(CONFIG_ACORN_PARTITION_ADFS)
-static int riscix_partition(struct parsed_partitions *state,
-                            unsigned long first_sect, int slot,
-                            unsigned long nr_sects)
-{
-        Sector sect;
-        struct riscix_record *rr;
-        
-        rr = read_part_sector(state, first_sect, &sect);
-        if (!rr)
-                return -1;
-
-        strlcat(state->pp_buf, " [RISCiX]", PAGE_SIZE);
-
-
-        if (rr->magic == RISCIX_MAGIC) {
-                unsigned long size = nr_sects > 2 ? 2 : nr_sects;
-                int part;
-
-                strlcat(state->pp_buf, " <", PAGE_SIZE);
-
-                put_partition(state, slot++, first_sect, size);
-                for (part = 0; part < 8; part++) {
-                        if (rr->part[part].one &&
-                            memcmp(rr->part[part].name, "All\0", 4)) {
-                                put_partition(state, slot++,
-                                        le32_to_cpu(rr->part[part].start),
-                                        le32_to_cpu(rr->part[part].length));
-                                strlcat(state->pp_buf, "(", PAGE_SIZE);
-                                strlcat(state->pp_buf, rr->part[part].name, PAGE_SIZE);
-                                strlcat(state->pp_buf, ")", PAGE_SIZE);
-                        }
-                }
-
-                strlcat(state->pp_buf, " >\n", PAGE_SIZE);
-        } else {
-                put_partition(state, slot++, first_sect, nr_sects);
-        }
-
-        put_dev_sector(sect);
-        return slot;
-}
-#endif
-#endif
-
-#define LINUX_NATIVE_MAGIC 0xdeafa1de
-#define LINUX_SWAP_MAGIC   0xdeafab1e
-
-struct linux_part {
-        __le32 magic;
-        __le32 start_sect;
-        __le32 nr_sects;
-};
-
-#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
-        defined(CONFIG_ACORN_PARTITION_ADFS)
-static int linux_partition(struct parsed_partitions *state,
-                           unsigned long first_sect, int slot,
-                           unsigned long nr_sects)
-{
-        Sector sect;
-        struct linux_part *linuxp;
-        unsigned long size = nr_sects > 2 ? 2 : nr_sects;
-
-        strlcat(state->pp_buf, " [Linux]", PAGE_SIZE);
-
-        put_partition(state, slot++, first_sect, size);
-
-        linuxp = read_part_sector(state, first_sect, &sect);
-        if (!linuxp)
-                return -1;
-
-        strlcat(state->pp_buf, " <", PAGE_SIZE);
-        while (linuxp->magic == cpu_to_le32(LINUX_NATIVE_MAGIC) ||
-               linuxp->magic == cpu_to_le32(LINUX_SWAP_MAGIC)) {
-                if (slot == state->limit)
-                        break;
-                put_partition(state, slot++, first_sect +
-                                 le32_to_cpu(linuxp->start_sect),
-                                 le32_to_cpu(linuxp->nr_sects));
-                linuxp ++;
-        }
-        strlcat(state->pp_buf, " >", PAGE_SIZE);
-
-        put_dev_sector(sect);
-        return slot;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_CUMANA
-int adfspart_check_CUMANA(struct parsed_partitions *state)
-{
-        unsigned long first_sector = 0;
-        unsigned int start_blk = 0;
-        Sector sect;
-        unsigned char *data;
-        char *name = "CUMANA/ADFS";
-        int first = 1;
-        int slot = 1;
-
-        /*
-         * Try Cumana style partitions - sector 6 contains ADFS boot block
-         * with pointer to next 'drive'.
-         *
-         * There are unknowns in this code - is the 'cylinder number' of the
-         * next partition relative to the start of this one - I'm assuming
-         * it is.
-         *
-         * Also, which ID did Cumana use?
-         *
-         * This is totally unfinished, and will require more work to get it
-         * going. Hence it is totally untested.
-         */
-        do {
-                struct adfs_discrecord *dr;
-                unsigned int nr_sects;
-
-                data = read_part_sector(state, start_blk * 2 + 6, &sect);
-                if (!data)
-                        return -1;
-
-                if (slot == state->limit)
-                        break;
-
-                dr = adfs_partition(state, name, data, first_sector, slot++);
-                if (!dr)
-                        break;
-
-                name = NULL;
-
-                nr_sects = (data[0x1fd] + (data[0x1fe] << 8)) *
-                           (dr->heads + (dr->lowsector & 0x40 ? 1 : 0)) *
-                           dr->secspertrack;
-
-                if (!nr_sects)
-                        break;
-
-                first = 0;
-                first_sector += nr_sects;
-                start_blk += nr_sects >> (BLOCK_SIZE_BITS - 9);
-                nr_sects = 0; /* hmm - should be partition size */
-
-                switch (data[0x1fc] & 15) {
-                case 0: /* No partition / ADFS? */
-                        break;
-
-#ifdef CONFIG_ACORN_PARTITION_RISCIX
-                case PARTITION_RISCIX_SCSI:
-                        /* RISCiX - we don't know how to find the next one. */
-                        slot = riscix_partition(state, first_sector, slot,
-                                                nr_sects);
-                        break;
-#endif
-
-                case PARTITION_LINUX:
-                        slot = linux_partition(state, first_sector, slot,
-                                               nr_sects);
-                        break;
-                }
-                put_dev_sector(sect);
-                if (slot == -1)
-                        return -1;
-        } while (1);
-        put_dev_sector(sect);
-        return first ? 0 : 1;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_ADFS
-/*
- * Purpose: allocate ADFS partitions.
- *
- * Params : hd          - pointer to gendisk structure to store partition info.
- *          dev         - device number to access.
- *
- * Returns: -1 on error, 0 for no ADFS boot sector, 1 for ok.
- *
- * Alloc  : hda  = whole drive
- *          hda1 = ADFS partition on first drive.
- *          hda2 = non-ADFS partition.
- */
-int adfspart_check_ADFS(struct parsed_partitions *state)
-{
-        unsigned long start_sect, nr_sects, sectscyl, heads;
-        Sector sect;
-        unsigned char *data;
-        struct adfs_discrecord *dr;
-        unsigned char id;
-        int slot = 1;
-
-        data = read_part_sector(state, 6, &sect);
-        if (!data)
-                return -1;
-
-        dr = adfs_partition(state, "ADFS", data, 0, slot++);
-        if (!dr) {
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        heads = dr->heads + ((dr->lowsector >> 6) & 1);
-        sectscyl = dr->secspertrack * heads;
-        start_sect = ((data[0x1fe] << 8) + data[0x1fd]) * sectscyl;
-        id = data[0x1fc] & 15;
-        put_dev_sector(sect);
-
-        /*
-         * Work out start of non-adfs partition.
-         */
-        nr_sects = (state->bdev->bd_inode->i_size >> 9) - start_sect;
-
-        if (start_sect) {
-                switch (id) {
-#ifdef CONFIG_ACORN_PARTITION_RISCIX
-                case PARTITION_RISCIX_SCSI:
-                case PARTITION_RISCIX_MFM:
-                        slot = riscix_partition(state, start_sect, slot,
-                                                nr_sects);
-                        break;
-#endif
-
-                case PARTITION_LINUX:
-                        slot = linux_partition(state, start_sect, slot,
-                                               nr_sects);
-                        break;
-                }
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        return 1;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_ICS
-
-struct ics_part {
-        __le32 start;
-        __le32 size;
-};
-
-static int adfspart_check_ICSLinux(struct parsed_partitions *state,
-                                   unsigned long block)
-{
-        Sector sect;
-        unsigned char *data = read_part_sector(state, block, &sect);
-        int result = 0;
-
-        if (data) {
-                if (memcmp(data, "LinuxPart", 9) == 0)
-                        result = 1;
-                put_dev_sector(sect);
-        }
-
-        return result;
-}
-
-/*
- * Check for a valid ICS partition using the checksum.
- */
-static inline int valid_ics_sector(const unsigned char *data)
-{
-        unsigned long sum;
-        int i;
-
-        for (i = 0, sum = 0x50617274; i < 508; i++)
-                sum += data[i];
-
-        sum -= le32_to_cpu(*(__le32 *)(&data[508]));
-
-        return sum == 0;
-}
-
-/*
- * Purpose: allocate ICS partitions.
- * Params : hd          - pointer to gendisk structure to store partition info.
- *          dev         - device number to access.
- * Returns: -1 on error, 0 for no ICS table, 1 for partitions ok.
- * Alloc  : hda  = whole drive
- *          hda1 = ADFS partition 0 on first drive.
- *          hda2 = ADFS partition 1 on first drive.
- *              ..etc..
- */
-int adfspart_check_ICS(struct parsed_partitions *state)
-{
-        const unsigned char *data;
-        const struct ics_part *p;
-        int slot;
-        Sector sect;
-
-        /*
-         * Try ICS style partitions - sector 0 contains partition info.
-         */
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-
-        if (!valid_ics_sector(data)) {
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        strlcat(state->pp_buf, " [ICS]", PAGE_SIZE);
-
-        for (slot = 1, p = (const struct ics_part *)data; p->size; p++) {
-                u32 start = le32_to_cpu(p->start);
-                s32 size = le32_to_cpu(p->size); /* yes, it's signed. */
-
-                if (slot == state->limit)
-                        break;
-
-                /*
-                 * Negative sizes tell the RISC OS ICS driver to ignore
-                 * this partition - in effect it says that this does not
-                 * contain an ADFS filesystem.
-                 */
-                if (size < 0) {
-                        size = -size;
-
-                        /*
-                         * Our own extension - We use the first sector
-                         * of the partition to identify what type this
-                         * partition is.  We must not make this visible
-                         * to the filesystem.
-                         */
-                        if (size > 1 && adfspart_check_ICSLinux(state, start)) {
-                                start += 1;
-                                size -= 1;
-                        }
-                }
-
-                if (size)
-                        put_partition(state, slot++, start, size);
-        }
-
-        put_dev_sector(sect);
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        return 1;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_POWERTEC
-struct ptec_part {
-        __le32 unused1;
-        __le32 unused2;
-        __le32 start;
-        __le32 size;
-        __le32 unused5;
-        char type[8];
-};
-
-static inline int valid_ptec_sector(const unsigned char *data)
-{
-        unsigned char checksum = 0x2a;
-        int i;
-
-        /*
-         * If it looks like a PC/BIOS partition, then it
-         * probably isn't PowerTec.
-         */
-        if (data[510] == 0x55 && data[511] == 0xaa)
-                return 0;
-
-        for (i = 0; i < 511; i++)
-                checksum += data[i];
-
-        return checksum == data[511];
-}
-
-/*
- * Purpose: allocate ICS partitions.
- * Params : hd          - pointer to gendisk structure to store partition info.
- *          dev         - device number to access.
- * Returns: -1 on error, 0 for no ICS table, 1 for partitions ok.
- * Alloc  : hda  = whole drive
- *          hda1 = ADFS partition 0 on first drive.
- *          hda2 = ADFS partition 1 on first drive.
- *              ..etc..
- */
-int adfspart_check_POWERTEC(struct parsed_partitions *state)
-{
-        Sector sect;
-        const unsigned char *data;
-        const struct ptec_part *p;
-        int slot = 1;
-        int i;
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-
-        if (!valid_ptec_sector(data)) {
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        strlcat(state->pp_buf, " [POWERTEC]", PAGE_SIZE);
-
-        for (i = 0, p = (const struct ptec_part *)data; i < 12; i++, p++) {
-                u32 start = le32_to_cpu(p->start);
-                u32 size = le32_to_cpu(p->size);
-
-                if (size)
-                        put_partition(state, slot++, start, size);
-        }
-
-        put_dev_sector(sect);
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        return 1;
-}
-#endif
-
-#ifdef CONFIG_ACORN_PARTITION_EESOX
-struct eesox_part {
-        char    magic[6];
-        char    name[10];
-        __le32  start;
-        __le32  unused6;
-        __le32  unused7;
-        __le32  unused8;
-};
-
-/*
- * Guess who created this format?
- */
-static const char eesox_name[] = {
-        'N', 'e', 'i', 'l', ' ',
-        'C', 'r', 'i', 't', 'c', 'h', 'e', 'l', 'l', ' ', ' '
-};
-
-/*
- * EESOX SCSI partition format.
- *
- * This is a goddamned awful partition format.  We don't seem to store
- * the size of the partition in this table, only the start addresses.
- *
- * There are two possibilities where the size comes from:
- *  1. The individual ADFS boot block entries that are placed on the disk.
- *  2. The start address of the next entry.
- */
-int adfspart_check_EESOX(struct parsed_partitions *state)
-{
-        Sector sect;
-        const unsigned char *data;
-        unsigned char buffer[256];
-        struct eesox_part *p;
-        sector_t start = 0;
-        int i, slot = 1;
-
-        data = read_part_sector(state, 7, &sect);
-        if (!data)
-                return -1;
-
-        /*
-         * "Decrypt" the partition table.  God knows why...
-         */
-        for (i = 0; i < 256; i++)
-                buffer[i] = data[i] ^ eesox_name[i & 15];
-
-        put_dev_sector(sect);
-
-        for (i = 0, p = (struct eesox_part *)buffer; i < 8; i++, p++) {
-                sector_t next;
-
-                if (memcmp(p->magic, "Eesox", 6))
-                        break;
-
-                next = le32_to_cpu(p->start);
-                if (i)
-                        put_partition(state, slot++, start, next - start);
-                start = next;
-        }
-
-        if (i != 0) {
-                sector_t size;
-
-                size = get_capacity(state->bdev->bd_disk);
-                put_partition(state, slot++, start, size - start);
-                strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        }
-
-        return i ? 1 : 0;
-}
-#endif
diff --git a/fs/partitions/acorn.h b/fs/partitions/acorn.h
deleted file mode 100644
index ede828529692..000000000000
--- a/fs/partitions/acorn.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * linux/fs/partitions/acorn.h
- *
- * Copyright (C) 1996-2001 Russell King.
- *
- *  I _hate_ this partitioning mess - why can't we have one defined
- *  format, and everyone stick to it?
- */
-
-int adfspart_check_CUMANA(struct parsed_partitions *state);
-int adfspart_check_ADFS(struct parsed_partitions *state);
-int adfspart_check_ICS(struct parsed_partitions *state);
-int adfspart_check_POWERTEC(struct parsed_partitions *state);
-int adfspart_check_EESOX(struct parsed_partitions *state);
diff --git a/fs/partitions/amiga.c b/fs/partitions/amiga.c
deleted file mode 100644
index 70cbf44a1560..000000000000
--- a/fs/partitions/amiga.c
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- *  fs/partitions/amiga.c
- *
- *  Code extracted from drivers/block/genhd.c
- *
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- */
-
-#include <linux/types.h>
-#include <linux/affs_hardblocks.h>
-
-#include "check.h"
-#include "amiga.h"
-
-static __inline__ u32
-checksum_block(__be32 *m, int size)
-{
-        u32 sum = 0;
-
-        while (size--)
-                sum += be32_to_cpu(*m++);
-        return sum;
-}
-
-int amiga_partition(struct parsed_partitions *state)
-{
-        Sector sect;
-        unsigned char *data;
-        struct RigidDiskBlock *rdb;
-        struct PartitionBlock *pb;
-        int start_sect, nr_sects, blk, part, res = 0;
-        int blksize = 1;        /* Multiplier for disk block size */
-        int slot = 1;
-        char b[BDEVNAME_SIZE];
-
-        for (blk = 0; ; blk++, put_dev_sector(sect)) {
-                if (blk == RDB_ALLOCATION_LIMIT)
-                        goto rdb_done;
-                data = read_part_sector(state, blk, &sect);
-                if (!data) {
-                        if (warn_no_part)
-                                printk("Dev %s: unable to read RDB block %d\n",
-                                       bdevname(state->bdev, b), blk);
-                        res = -1;
-                        goto rdb_done;
-                }
-                if (*(__be32 *)data != cpu_to_be32(IDNAME_RIGIDDISK))
-                        continue;
-
-                rdb = (struct RigidDiskBlock *)data;
-                if (checksum_block((__be32 *)data, be32_to_cpu(rdb->rdb_SummedLongs) & 0x7F) == 0)
-                        break;
-                /* Try again with 0xdc..0xdf zeroed, Windows might have
-                 * trashed it.
-                 */
-                *(__be32 *)(data+0xdc) = 0;
-                if (checksum_block((__be32 *)data,
-                                be32_to_cpu(rdb->rdb_SummedLongs) & 0x7F)==0) {
-                        printk("Warning: Trashed word at 0xd0 in block %d "
-                                "ignored in checksum calculation\n",blk);
-                        break;
-                }
-
-                printk("Dev %s: RDB in block %d has bad checksum\n",
-                       bdevname(state->bdev, b), blk);
-        }
-
-        /* blksize is blocks per 512 byte standard block */
-        blksize = be32_to_cpu( rdb->rdb_BlockBytes ) / 512;
-
-        {
-                char tmp[7 + 10 + 1 + 1];
-
-                /* Be more informative */
-                snprintf(tmp, sizeof(tmp), " RDSK (%d)", blksize * 512);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-        }
-        blk = be32_to_cpu(rdb->rdb_PartitionList);
-        put_dev_sector(sect);
-        for (part = 1; blk>0 && part<=16; part++, put_dev_sector(sect)) {
-                blk *= blksize; /* Read in terms partition table understands */
-                data = read_part_sector(state, blk, &sect);
-                if (!data) {
-                        if (warn_no_part)
-                                printk("Dev %s: unable to read partition block %d\n",
-                                       bdevname(state->bdev, b), blk);
-                        res = -1;
-                        goto rdb_done;
-                }
-                pb  = (struct PartitionBlock *)data;
-                blk = be32_to_cpu(pb->pb_Next);
-                if (pb->pb_ID != cpu_to_be32(IDNAME_PARTITION))
-                        continue;
-                if (checksum_block((__be32 *)pb, be32_to_cpu(pb->pb_SummedLongs) & 0x7F) != 0 )
-                        continue;
-
-                /* Tell Kernel about it */
-
-                nr_sects = (be32_to_cpu(pb->pb_Environment[10]) + 1 -
-                            be32_to_cpu(pb->pb_Environment[9])) *
-                           be32_to_cpu(pb->pb_Environment[3]) *
-                           be32_to_cpu(pb->pb_Environment[5]) *
-                           blksize;
-                if (!nr_sects)
-                        continue;
-                start_sect = be32_to_cpu(pb->pb_Environment[9]) *
-                             be32_to_cpu(pb->pb_Environment[3]) *
-                             be32_to_cpu(pb->pb_Environment[5]) *
-                             blksize;
-                put_partition(state,slot++,start_sect,nr_sects);
-                {
-                        /* Be even more informative to aid mounting */
-                        char dostype[4];
-                        char tmp[42];
-
-                        __be32 *dt = (__be32 *)dostype;
-                        *dt = pb->pb_Environment[16];
-                        if (dostype[3] < ' ')
-                                snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)",
-                                        dostype[0], dostype[1],
-                                        dostype[2], dostype[3] + '@' );
-                        else
-                                snprintf(tmp, sizeof(tmp), " (%c%c%c%c)",
-                                        dostype[0], dostype[1],
-                                        dostype[2], dostype[3]);
-                        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                        snprintf(tmp, sizeof(tmp), "(res %d spb %d)",
-                                be32_to_cpu(pb->pb_Environment[6]),
-                                be32_to_cpu(pb->pb_Environment[4]));
-                        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                }
-                res = 1;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-
-rdb_done:
-        return res;
-}
diff --git a/fs/partitions/amiga.h b/fs/partitions/amiga.h
deleted file mode 100644
index d094585cadaa..000000000000
--- a/fs/partitions/amiga.h
+++ /dev/null
@@ -1,6 +0,0 @@
-/*
- *  fs/partitions/amiga.h
- */
-
-int amiga_partition(struct parsed_partitions *state);
-
diff --git a/fs/partitions/atari.c b/fs/partitions/atari.c
deleted file mode 100644
index 9875b05e80a2..000000000000
--- a/fs/partitions/atari.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *  fs/partitions/atari.c
- *
- *  Code extracted from drivers/block/genhd.c
- *
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- */
-
-#include <linux/ctype.h>
-#include "check.h"
-#include "atari.h"
-
-/* ++guenther: this should be settable by the user ("make config")?.
- */
-#define ICD_PARTS
-
-/* check if a partition entry looks valid -- Atari format is assumed if at
-   least one of the primary entries is ok this way */
-#define VALID_PARTITION(pi,hdsiz)                                            \
-    (((pi)->flg & 1) &&                                                      \
-     isalnum((pi)->id[0]) && isalnum((pi)->id[1]) && isalnum((pi)->id[2]) && \
-     be32_to_cpu((pi)->st) <= (hdsiz) &&                                     \
-     be32_to_cpu((pi)->st) + be32_to_cpu((pi)->siz) <= (hdsiz))
-
-static inline int OK_id(char *s)
-{
-        return  memcmp (s, "GEM", 3) == 0 || memcmp (s, "BGM", 3) == 0 ||
-                memcmp (s, "LNX", 3) == 0 || memcmp (s, "SWP", 3) == 0 ||
-                memcmp (s, "RAW", 3) == 0 ;
-}
-
-int atari_partition(struct parsed_partitions *state)
-{
-        Sector sect;
-        struct rootsector *rs;
-        struct partition_info *pi;
-        u32 extensect;
-        u32 hd_size;
-        int slot;
-#ifdef ICD_PARTS
-        int part_fmt = 0; /* 0:unknown, 1:AHDI, 2:ICD/Supra */
-#endif
-
-        rs = read_part_sector(state, 0, &sect);
-        if (!rs)
-                return -1;
-
-        /* Verify this is an Atari rootsector: */
-        hd_size = state->bdev->bd_inode->i_size >> 9;
-        if (!VALID_PARTITION(&rs->part[0], hd_size) &&
-            !VALID_PARTITION(&rs->part[1], hd_size) &&
-            !VALID_PARTITION(&rs->part[2], hd_size) &&
-            !VALID_PARTITION(&rs->part[3], hd_size)) {
-                /*
-                 * if there's no valid primary partition, assume that no Atari
-                 * format partition table (there's no reliable magic or the like
-                 * :-()
-                 */
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        pi = &rs->part[0];
-        strlcat(state->pp_buf, " AHDI", PAGE_SIZE);
-        for (slot = 1; pi < &rs->part[4] && slot < state->limit; slot++, pi++) {
-                struct rootsector *xrs;
-                Sector sect2;
-                ulong partsect;
-
-                if ( !(pi->flg & 1) )
-                        continue;
-                /* active partition */
-                if (memcmp (pi->id, "XGM", 3) != 0) {
-                        /* we don't care about other id's */
-                        put_partition (state, slot, be32_to_cpu(pi->st),
-                                        be32_to_cpu(pi->siz));
-                        continue;
-                }
-                /* extension partition */
-#ifdef ICD_PARTS
-                part_fmt = 1;
-#endif
-                strlcat(state->pp_buf, " XGM<", PAGE_SIZE);
-                partsect = extensect = be32_to_cpu(pi->st);
-                while (1) {
-                        xrs = read_part_sector(state, partsect, &sect2);
-                        if (!xrs) {
-                                printk (" block %ld read failed\n", partsect);
-                                put_dev_sector(sect);
-                                return -1;
-                        }
-
-                        /* ++roman: sanity check: bit 0 of flg field must be set */
-                        if (!(xrs->part[0].flg & 1)) {
-                                printk( "\nFirst sub-partition in extended partition is not valid!\n" );
-                                put_dev_sector(sect2);
-                                break;
-                        }
-
-                        put_partition(state, slot,
-                                   partsect + be32_to_cpu(xrs->part[0].st),
-                                   be32_to_cpu(xrs->part[0].siz));
-
-                        if (!(xrs->part[1].flg & 1)) {
-                                /* end of linked partition list */
-                                put_dev_sector(sect2);
-                                break;
-                        }
-                        if (memcmp( xrs->part[1].id, "XGM", 3 ) != 0) {
-                                printk("\nID of extended partition is not XGM!\n");
-                                put_dev_sector(sect2);
-                                break;
-                        }
-
-                        partsect = be32_to_cpu(xrs->part[1].st) + extensect;
-                        put_dev_sector(sect2);
-                        if (++slot == state->limit) {
-                                printk( "\nMaximum number of partitions reached!\n" );
-                                break;
-                        }
-                }
-                strlcat(state->pp_buf, " >", PAGE_SIZE);
-        }
-#ifdef ICD_PARTS
-        if ( part_fmt!=1 ) { /* no extended partitions -> test ICD-format */
-                pi = &rs->icdpart[0];
-                /* sanity check: no ICD format if first partition invalid */
-                if (OK_id(pi->id)) {
-                        strlcat(state->pp_buf, " ICD<", PAGE_SIZE);
-                        for (; pi < &rs->icdpart[8] && slot < state->limit; slot++, pi++) {
-                                /* accept only GEM,BGM,RAW,LNX,SWP partitions */
-                                if (!((pi->flg & 1) && OK_id(pi->id)))
-                                        continue;
-                                part_fmt = 2;
-                                put_partition (state, slot,
-                                                be32_to_cpu(pi->st),
-                                                be32_to_cpu(pi->siz));
-                        }
-                        strlcat(state->pp_buf, " >", PAGE_SIZE);
-                }
-        }
-#endif
-        put_dev_sector(sect);
-
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-
-        return 1;
-}
diff --git a/fs/partitions/atari.h b/fs/partitions/atari.h
deleted file mode 100644
index fe2d32a89f36..000000000000
--- a/fs/partitions/atari.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- *  fs/partitions/atari.h
- *  Moved by Russell King from:
- *
- * linux/include/linux/atari_rootsec.h
- * definitions for Atari Rootsector layout
- * by Andreas Schwab (schwab@ls5.informatik.uni-dortmund.de)
- *
- * modified for ICD/Supra partitioning scheme restricted to at most 12
- * partitions
- * by Guenther Kelleter (guenther@pool.informatik.rwth-aachen.de)
- */
-
-struct partition_info
-{
-  u8 flg;                       /* bit 0: active; bit 7: bootable */
-  char id[3];                   /* "GEM", "BGM", "XGM", or other */
-  __be32 st;                    /* start of partition */
-  __be32 siz;                   /* length of partition */
-};
-
-struct rootsector
-{
-  char unused[0x156];           /* room for boot code */
-  struct partition_info icdpart[8];     /* info for ICD-partitions 5..12 */
-  char unused2[0xc];
-  u32 hd_siz;                   /* size of disk in blocks */
-  struct partition_info part[4];
-  u32 bsl_st;                   /* start of bad sector list */
-  u32 bsl_cnt;                  /* length of bad sector list */
-  u16 checksum;                 /* checksum for bootable disks */
-} __attribute__((__packed__));
-
-int atari_partition(struct parsed_partitions *state);
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
deleted file mode 100644
index e3c63d1c5e13..000000000000
--- a/fs/partitions/check.c
+++ /dev/null
@@ -1,687 +0,0 @@
-/*
- *  fs/partitions/check.c
- *
- *  Code extracted from drivers/block/genhd.c
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- *
- *  We now have independent partition support from the
- *  block drivers, which allows all the partition code to
- *  be grouped in one location, and it to be mostly self
- *  contained.
- *
- *  Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/kmod.h>
-#include <linux/ctype.h>
-#include <linux/genhd.h>
-#include <linux/blktrace_api.h>
-
-#include "check.h"
-
-#include "acorn.h"
-#include "amiga.h"
-#include "atari.h"
-#include "ldm.h"
-#include "mac.h"
-#include "msdos.h"
-#include "osf.h"
-#include "sgi.h"
-#include "sun.h"
-#include "ibm.h"
-#include "ultrix.h"
-#include "efi.h"
-#include "karma.h"
-#include "sysv68.h"
-
-#ifdef CONFIG_BLK_DEV_MD
-extern void md_autodetect_dev(dev_t dev);
-#endif
-
-int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/
-
-static int (*check_part[])(struct parsed_partitions *) = {
-        /*
-         * Probe partition formats with tables at disk address 0
-         * that also have an ADFS boot block at 0xdc0.
-         */
-#ifdef CONFIG_ACORN_PARTITION_ICS
-        adfspart_check_ICS,
-#endif
-#ifdef CONFIG_ACORN_PARTITION_POWERTEC
-        adfspart_check_POWERTEC,
-#endif
-#ifdef CONFIG_ACORN_PARTITION_EESOX
-        adfspart_check_EESOX,
-#endif
-
-        /*
-         * Now move on to formats that only have partition info at
-         * disk address 0xdc0.  Since these may also have stale
-         * PC/BIOS partition tables, they need to come before
-         * the msdos entry.
-         */
-#ifdef CONFIG_ACORN_PARTITION_CUMANA
-        adfspart_check_CUMANA,
-#endif
-#ifdef CONFIG_ACORN_PARTITION_ADFS
-        adfspart_check_ADFS,
-#endif
-
-#ifdef CONFIG_EFI_PARTITION
-        efi_partition,          /* this must come before msdos */
-#endif
-#ifdef CONFIG_SGI_PARTITION
-        sgi_partition,
-#endif
-#ifdef CONFIG_LDM_PARTITION
-        ldm_partition,          /* this must come before msdos */
-#endif
-#ifdef CONFIG_MSDOS_PARTITION
-        msdos_partition,
-#endif
-#ifdef CONFIG_OSF_PARTITION
-        osf_partition,
-#endif
-#ifdef CONFIG_SUN_PARTITION
-        sun_partition,
-#endif
-#ifdef CONFIG_AMIGA_PARTITION
-        amiga_partition,
-#endif
-#ifdef CONFIG_ATARI_PARTITION
-        atari_partition,
-#endif
-#ifdef CONFIG_MAC_PARTITION
-        mac_partition,
-#endif
-#ifdef CONFIG_ULTRIX_PARTITION
-        ultrix_partition,
-#endif
-#ifdef CONFIG_IBM_PARTITION
-        ibm_partition,
-#endif
-#ifdef CONFIG_KARMA_PARTITION
-        karma_partition,
-#endif
-#ifdef CONFIG_SYSV68_PARTITION
-        sysv68_partition,
-#endif
-        NULL
-};
- 
-/*
- * disk_name() is used by partition check code and the genhd driver.
- * It formats the devicename of the indicated disk into
- * the supplied buffer (of size at least 32), and returns
- * a pointer to that same buffer (for convenience).
- */
-
-char *disk_name(struct gendisk *hd, int partno, char *buf)
-{
-        if (!partno)
-                snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
-        else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
-                snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
-        else
-                snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
-
-        return buf;
-}
-
-const char *bdevname(struct block_device *bdev, char *buf)
-{
-        return disk_name(bdev->bd_disk, bdev->bd_part->partno, buf);
-}
-
-EXPORT_SYMBOL(bdevname);
-
-/*
- * There's very little reason to use this, you should really
- * have a struct block_device just about everywhere and use
- * bdevname() instead.
- */
-const char *__bdevname(dev_t dev, char *buffer)
-{
-        scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)",
-                                MAJOR(dev), MINOR(dev));
-        return buffer;
-}
-
-EXPORT_SYMBOL(__bdevname);
-
-static struct parsed_partitions *
-check_partition(struct gendisk *hd, struct block_device *bdev)
-{
-        struct parsed_partitions *state;
-        int i, res, err;
-
-        state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
-        if (!state)
-                return NULL;
-        state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
-        if (!state->pp_buf) {
-                kfree(state);
-                return NULL;
-        }
-        state->pp_buf[0] = '\0';
-
-        state->bdev = bdev;
-        disk_name(hd, 0, state->name);
-        snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
-        if (isdigit(state->name[strlen(state->name)-1]))
-                sprintf(state->name, "p");
-
-        state->limit = disk_max_parts(hd);
-        i = res = err = 0;
-        while (!res && check_part[i]) {
-                memset(&state->parts, 0, sizeof(state->parts));
-                res = check_part[i++](state);
-                if (res < 0) {
-                        /* We have hit an I/O error which we don't report now.
-                        * But record it, and let the others do their job.
-                        */
-                        err = res;
-                        res = 0;
-                }
-
-        }
-        if (res > 0) {
-                printk(KERN_INFO "%s", state->pp_buf);
-
-                free_page((unsigned long)state->pp_buf);
-                return state;
-        }
-        if (state->access_beyond_eod)
-                err = -ENOSPC;
-        if (err)
-        /* The partition is unrecognized. So report I/O errors if there were any */
-                res = err;
-        if (!res)
-                strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
-        else if (warn_no_part)
-                strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);
-
-        printk(KERN_INFO "%s", state->pp_buf);
-
-        free_page((unsigned long)state->pp_buf);
-        kfree(state);
-        return ERR_PTR(res);
-}
-
-static ssize_t part_partition_show(struct device *dev,
-                                   struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-
-        return sprintf(buf, "%d\n", p->partno);
-}
-
-static ssize_t part_start_show(struct device *dev,
-                               struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-
-        return sprintf(buf, "%llu\n",(unsigned long long)p->start_sect);
-}
-
-ssize_t part_size_show(struct device *dev,
-                       struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects);
-}
-
-static ssize_t part_ro_show(struct device *dev,
-                            struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        return sprintf(buf, "%d\n", p->policy ? 1 : 0);
-}
-
-static ssize_t part_alignment_offset_show(struct device *dev,
-                                          struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        return sprintf(buf, "%llu\n", (unsigned long long)p->alignment_offset);
-}
-
-static ssize_t part_discard_alignment_show(struct device *dev,
-                                           struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        return sprintf(buf, "%u\n", p->discard_alignment);
-}
-
-ssize_t part_stat_show(struct device *dev,
-                       struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        int cpu;
-
-        cpu = part_stat_lock();
-        part_round_stats(cpu, p);
-        part_stat_unlock();
-        return sprintf(buf,
-                "%8lu %8lu %8llu %8u "
-                "%8lu %8lu %8llu %8u "
-                "%8u %8u %8u"
-                "\n",
-                part_stat_read(p, ios[READ]),
-                part_stat_read(p, merges[READ]),
-                (unsigned long long)part_stat_read(p, sectors[READ]),
-                jiffies_to_msecs(part_stat_read(p, ticks[READ])),
-                part_stat_read(p, ios[WRITE]),
-                part_stat_read(p, merges[WRITE]),
-                (unsigned long long)part_stat_read(p, sectors[WRITE]),
-                jiffies_to_msecs(part_stat_read(p, ticks[WRITE])),
-                part_in_flight(p),
-                jiffies_to_msecs(part_stat_read(p, io_ticks)),
-                jiffies_to_msecs(part_stat_read(p, time_in_queue)));
-}
-
-ssize_t part_inflight_show(struct device *dev,
-                        struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-
-        return sprintf(buf, "%8u %8u\n", atomic_read(&p->in_flight[0]),
-                atomic_read(&p->in_flight[1]));
-}
-
-#ifdef CONFIG_FAIL_MAKE_REQUEST
-ssize_t part_fail_show(struct device *dev,
-                       struct device_attribute *attr, char *buf)
-{
-        struct hd_struct *p = dev_to_part(dev);
-
-        return sprintf(buf, "%d\n", p->make_it_fail);
-}
-
-ssize_t part_fail_store(struct device *dev,
-                        struct device_attribute *attr,
-                        const char *buf, size_t count)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        int i;
-
-        if (count > 0 && sscanf(buf, "%d", &i) > 0)
-                p->make_it_fail = (i == 0) ? 0 : 1;
-
-        return count;
-}
-#endif
-
-static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL);
-static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL);
-static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
-static DEVICE_ATTR(ro, S_IRUGO, part_ro_show, NULL);
-static DEVICE_ATTR(alignment_offset, S_IRUGO, part_alignment_offset_show, NULL);
-static DEVICE_ATTR(discard_alignment, S_IRUGO, part_discard_alignment_show,
-                   NULL);
-static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
-static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
-#ifdef CONFIG_FAIL_MAKE_REQUEST
-static struct device_attribute dev_attr_fail =
-        __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
-#endif
-
-static struct attribute *part_attrs[] = {
-        &dev_attr_partition.attr,
-        &dev_attr_start.attr,
-        &dev_attr_size.attr,
-        &dev_attr_ro.attr,
-        &dev_attr_alignment_offset.attr,
-        &dev_attr_discard_alignment.attr,
-        &dev_attr_stat.attr,
-        &dev_attr_inflight.attr,
-#ifdef CONFIG_FAIL_MAKE_REQUEST
-        &dev_attr_fail.attr,
-#endif
-        NULL
-};
-
-static struct attribute_group part_attr_group = {
-        .attrs = part_attrs,
-};
-
-static const struct attribute_group *part_attr_groups[] = {
-        &part_attr_group,
-#ifdef CONFIG_BLK_DEV_IO_TRACE
-        &blk_trace_attr_group,
-#endif
-        NULL
-};
-
-static void part_release(struct device *dev)
-{
-        struct hd_struct *p = dev_to_part(dev);
-        free_part_stats(p);
-        free_part_info(p);
-        kfree(p);
-}
-
-struct device_type part_type = {
-        .name           = "partition",
-        .groups         = part_attr_groups,
-        .release        = part_release,
-};
-
-static void delete_partition_rcu_cb(struct rcu_head *head)
-{
-        struct hd_struct *part = container_of(head, struct hd_struct, rcu_head);
-
-        part->start_sect = 0;
-        part->nr_sects = 0;
-        part_stat_set_all(part, 0);
-        put_device(part_to_dev(part));
-}
-
-void __delete_partition(struct hd_struct *part)
-{
-        call_rcu(&part->rcu_head, delete_partition_rcu_cb);
-}
-
-void delete_partition(struct gendisk *disk, int partno)
-{
-        struct disk_part_tbl *ptbl = disk->part_tbl;
-        struct hd_struct *part;
-
-        if (partno >= ptbl->len)
-                return;
-
-        part = ptbl->part[partno];
-        if (!part)
-                return;
-
-        blk_free_devt(part_devt(part));
-        rcu_assign_pointer(ptbl->part[partno], NULL);
-        rcu_assign_pointer(ptbl->last_lookup, NULL);
-        kobject_put(part->holder_dir);
-        device_del(part_to_dev(part));
-
-        hd_struct_put(part);
-}
-
-static ssize_t whole_disk_show(struct device *dev,
-                               struct device_attribute *attr, char *buf)
-{
-        return 0;
-}
-static DEVICE_ATTR(whole_disk, S_IRUSR | S_IRGRP | S_IROTH,
-                   whole_disk_show, NULL);
-
-struct hd_struct *add_partition(struct gendisk *disk, int partno,
-                                sector_t start, sector_t len, int flags,
-                                struct partition_meta_info *info)
-{
-        struct hd_struct *p;
-        dev_t devt = MKDEV(0, 0);
-        struct device *ddev = disk_to_dev(disk);
-        struct device *pdev;
-        struct disk_part_tbl *ptbl;
-        const char *dname;
-        int err;
-
-        err = disk_expand_part_tbl(disk, partno);
-        if (err)
-                return ERR_PTR(err);
-        ptbl = disk->part_tbl;
-
-        if (ptbl->part[partno])
-                return ERR_PTR(-EBUSY);
-
-        p = kzalloc(sizeof(*p), GFP_KERNEL);
-        if (!p)
-                return ERR_PTR(-EBUSY);
-
-        if (!init_part_stats(p)) {
-                err = -ENOMEM;
-                goto out_free;
-        }
-        pdev = part_to_dev(p);
-
-        p->start_sect = start;
-        p->alignment_offset =
-                queue_limit_alignment_offset(&disk->queue->limits, start);
-        p->discard_alignment =
-                queue_limit_discard_alignment(&disk->queue->limits, start);
-        p->nr_sects = len;
-        p->partno = partno;
-        p->policy = get_disk_ro(disk);
-
-        if (info) {
-                struct partition_meta_info *pinfo = alloc_part_info(disk);
-                if (!pinfo)
-                        goto out_free_stats;
-                memcpy(pinfo, info, sizeof(*info));
-                p->info = pinfo;
-        }
-
-        dname = dev_name(ddev);
-        if (isdigit(dname[strlen(dname) - 1]))
-                dev_set_name(pdev, "%sp%d", dname, partno);
-        else
-                dev_set_name(pdev, "%s%d", dname, partno);
-
-        device_initialize(pdev);
-        pdev->class = &block_class;
-        pdev->type = &part_type;
-        pdev->parent = ddev;
-
-        err = blk_alloc_devt(p, &devt);
-        if (err)
-                goto out_free_info;
-        pdev->devt = devt;
-
-        /* delay uevent until 'holders' subdir is created */
-        dev_set_uevent_suppress(pdev, 1);
-        err = device_add(pdev);
-        if (err)
-                goto out_put;
-
-        err = -ENOMEM;
-        p->holder_dir = kobject_create_and_add("holders", &pdev->kobj);
-        if (!p->holder_dir)
-                goto out_del;
-
-        dev_set_uevent_suppress(pdev, 0);
-        if (flags & ADDPART_FLAG_WHOLEDISK) {
-                err = device_create_file(pdev, &dev_attr_whole_disk);
-                if (err)
-                        goto out_del;
-        }
-
-        /* everything is up and running, commence */
-        rcu_assign_pointer(ptbl->part[partno], p);
-
-        /* suppress uevent if the disk suppresses it */
-        if (!dev_get_uevent_suppress(ddev))
-                kobject_uevent(&pdev->kobj, KOBJ_ADD);
-
-        hd_ref_init(p);
-        return p;
-
-out_free_info:
-        free_part_info(p);
-out_free_stats:
-        free_part_stats(p);
-out_free:
-        kfree(p);
-        return ERR_PTR(err);
-out_del:
-        kobject_put(p->holder_dir);
-        device_del(pdev);
-out_put:
-        put_device(pdev);
-        blk_free_devt(devt);
-        return ERR_PTR(err);
-}
-
-static bool disk_unlock_native_capacity(struct gendisk *disk)
-{
-        const struct block_device_operations *bdops = disk->fops;
-
-        if (bdops->unlock_native_capacity &&
-            !(disk->flags & GENHD_FL_NATIVE_CAPACITY)) {
-                printk(KERN_CONT "enabling native capacity\n");
-                bdops->unlock_native_capacity(disk);
-                disk->flags |= GENHD_FL_NATIVE_CAPACITY;
-                return true;
-        } else {
-                printk(KERN_CONT "truncated\n");
-                return false;
-        }
-}
-
-int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
-{
-        struct parsed_partitions *state = NULL;
-        struct disk_part_iter piter;
-        struct hd_struct *part;
-        int p, highest, res;
-rescan:
-        if (state && !IS_ERR(state)) {
-                kfree(state);
-                state = NULL;
-        }
-
-        if (bdev->bd_part_count)
-                return -EBUSY;
-        res = invalidate_partition(disk, 0);
-        if (res)
-                return res;
-
-        disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
-        while ((part = disk_part_iter_next(&piter)))
-                delete_partition(disk, part->partno);
-        disk_part_iter_exit(&piter);
-
-        if (disk->fops->revalidate_disk)
-                disk->fops->revalidate_disk(disk);
-        check_disk_size_change(disk, bdev);
-        bdev->bd_invalidated = 0;
-        if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
-                return 0;
-        if (IS_ERR(state)) {
-                /*
-                 * I/O error reading the partition table.  If any
-                 * partition code tried to read beyond EOD, retry
-                 * after unlocking native capacity.
-                 */
-                if (PTR_ERR(state) == -ENOSPC) {
-                        printk(KERN_WARNING "%s: partition table beyond EOD, ",
-                               disk->disk_name);
-                        if (disk_unlock_native_capacity(disk))
-                                goto rescan;
-                }
-                return -EIO;
-        }
-        /*
-         * If any partition code tried to read beyond EOD, try
-         * unlocking native capacity even if partition table is
-         * successfully read as we could be missing some partitions.
-         */
-        if (state->access_beyond_eod) {
-                printk(KERN_WARNING
-                       "%s: partition table partially beyond EOD, ",
-                       disk->disk_name);
-                if (disk_unlock_native_capacity(disk))
-                        goto rescan;
-        }
-
-        /* tell userspace that the media / partition table may have changed */
-        kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
-
-        /* Detect the highest partition number and preallocate
-         * disk->part_tbl.  This is an optimization and not strictly
-         * necessary.
-         */
-        for (p = 1, highest = 0; p < state->limit; p++)
-                if (state->parts[p].size)
-                        highest = p;
-
-        disk_expand_part_tbl(disk, highest);
-
-        /* add partitions */
-        for (p = 1; p < state->limit; p++) {
-                sector_t size, from;
-                struct partition_meta_info *info = NULL;
-
-                size = state->parts[p].size;
-                if (!size)
-                        continue;
-
-                from = state->parts[p].from;
-                if (from >= get_capacity(disk)) {
-                        printk(KERN_WARNING
-                               "%s: p%d start %llu is beyond EOD, ",
-                               disk->disk_name, p, (unsigned long long) from);
-                        if (disk_unlock_native_capacity(disk))
-                                goto rescan;
-                        continue;
-                }
-
-                if (from + size > get_capacity(disk)) {
-                        printk(KERN_WARNING
-                               "%s: p%d size %llu extends beyond EOD, ",
-                               disk->disk_name, p, (unsigned long long) size);
-
-                        if (disk_unlock_native_capacity(disk)) {
-                                /* free state and restart */
-                                goto rescan;
-                        } else {
-                                /*
-                                 * we can not ignore partitions of broken tables
-                                 * created by for example camera firmware, but
-                                 * we limit them to the end of the disk to avoid
-                                 * creating invalid block devices
-                                 */
-                                size = get_capacity(disk) - from;
-                        }
-                }
-
-                if (state->parts[p].has_info)
-                        info = &state->parts[p].info;
-                part = add_partition(disk, p, from, size,
-                                     state->parts[p].flags,
-                                     &state->parts[p].info);
-                if (IS_ERR(part)) {
-                        printk(KERN_ERR " %s: p%d could not be added: %ld\n",
-                               disk->disk_name, p, -PTR_ERR(part));
-                        continue;
-                }
-#ifdef CONFIG_BLK_DEV_MD
-                if (state->parts[p].flags & ADDPART_FLAG_RAID)
-                        md_autodetect_dev(part_to_dev(part)->devt);
-#endif
-        }
-        kfree(state);
-        return 0;
-}
-
-unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
-{
-        struct address_space *mapping = bdev->bd_inode->i_mapping;
-        struct page *page;
-
-        page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
-                                 NULL);
-        if (!IS_ERR(page)) {
-                if (PageError(page))
-                        goto fail;
-                p->v = page;
-                return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
-fail:
-                page_cache_release(page);
-        }
-        p->v = NULL;
-        return NULL;
-}
-
-EXPORT_SYMBOL(read_dev_sector);
diff --git a/fs/partitions/check.h b/fs/partitions/check.h
deleted file mode 100644
index d68bf4dc3bc2..000000000000
--- a/fs/partitions/check.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#include <linux/pagemap.h>
-#include <linux/blkdev.h>
-#include <linux/genhd.h>
-
-/*
- * add_gd_partition adds a partitions details to the devices partition
- * description.
- */
-struct parsed_partitions {
-        struct block_device *bdev;
-        char name[BDEVNAME_SIZE];
-        struct {
-                sector_t from;
-                sector_t size;
-                int flags;
-                bool has_info;
-                struct partition_meta_info info;
-        } parts[DISK_MAX_PARTS];
-        int next;
-        int limit;
-        bool access_beyond_eod;
-        char *pp_buf;
-};
-
-static inline void *read_part_sector(struct parsed_partitions *state,
-                                     sector_t n, Sector *p)
-{
-        if (n >= get_capacity(state->bdev->bd_disk)) {
-                state->access_beyond_eod = true;
-                return NULL;
-        }
-        return read_dev_sector(state->bdev, n, p);
-}
-
-static inline void
-put_partition(struct parsed_partitions *p, int n, sector_t from, sector_t size)
-{
-        if (n < p->limit) {
-                char tmp[1 + BDEVNAME_SIZE + 10 + 1];
-
-                p->parts[n].from = from;
-                p->parts[n].size = size;
-                snprintf(tmp, sizeof(tmp), " %s%d", p->name, n);
-                strlcat(p->pp_buf, tmp, PAGE_SIZE);
-        }
-}
-
-extern int warn_no_part;
-
diff --git a/fs/partitions/efi.c b/fs/partitions/efi.c
deleted file mode 100644
index 6296b403c67a..000000000000
--- a/fs/partitions/efi.c
+++ /dev/null
@@ -1,675 +0,0 @@
-/************************************************************
- * EFI GUID Partition Table handling
- *
- * http://www.uefi.org/specs/
- * http://www.intel.com/technology/efi/
- *
- * efi.[ch] by Matt Domsch <Matt_Domsch@dell.com>
- *   Copyright 2000,2001,2002,2004 Dell Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- *
- * TODO:
- *
- * Changelog:
- * Mon Nov 09 2004 Matt Domsch <Matt_Domsch@dell.com>
- * - test for valid PMBR and valid PGPT before ever reading
- *   AGPT, allow override with 'gpt' kernel command line option.
- * - check for first/last_usable_lba outside of size of disk
- *
- * Tue  Mar 26 2002 Matt Domsch <Matt_Domsch@dell.com>
- * - Ported to 2.5.7-pre1 and 2.5.7-dj2
- * - Applied patch to avoid fault in alternate header handling
- * - cleaned up find_valid_gpt
- * - On-disk structure and copy in memory is *always* LE now - 
- *   swab fields as needed
- * - remove print_gpt_header()
- * - only use first max_p partition entries, to keep the kernel minor number
- *   and partition numbers tied.
- *
- * Mon  Feb 04 2002 Matt Domsch <Matt_Domsch@dell.com>
- * - Removed __PRIPTR_PREFIX - not being used
- *
- * Mon  Jan 14 2002 Matt Domsch <Matt_Domsch@dell.com>
- * - Ported to 2.5.2-pre11 + library crc32 patch Linus applied
- *
- * Thu Dec 6 2001 Matt Domsch <Matt_Domsch@dell.com>
- * - Added compare_gpts().
- * - moved le_efi_guid_to_cpus() back into this file.  GPT is the only
- *   thing that keeps EFI GUIDs on disk.
- * - Changed gpt structure names and members to be simpler and more Linux-like.
- * 
- * Wed Oct 17 2001 Matt Domsch <Matt_Domsch@dell.com>
- * - Removed CONFIG_DEVFS_VOLUMES_UUID code entirely per Martin Wilck
- *
- * Wed Oct 10 2001 Matt Domsch <Matt_Domsch@dell.com>
- * - Changed function comments to DocBook style per Andreas Dilger suggestion.
- *
- * Mon Oct 08 2001 Matt Domsch <Matt_Domsch@dell.com>
- * - Change read_lba() to use the page cache per Al Viro's work.
- * - print u64s properly on all architectures
- * - fixed debug_printk(), now Dprintk()
- *
- * Mon Oct 01 2001 Matt Domsch <Matt_Domsch@dell.com>
- * - Style cleanups
- * - made most functions static
- * - Endianness addition
- * - remove test for second alternate header, as it's not per spec,
- *   and is unnecessary.  There's now a method to read/write the last
- *   sector of an odd-sized disk from user space.  No tools have ever
- *   been released which used this code, so it's effectively dead.
- * - Per Asit Mallick of Intel, added a test for a valid PMBR.
- * - Added kernel command line option 'gpt' to override valid PMBR test.
- *
- * Wed Jun  6 2001 Martin Wilck <Martin.Wilck@Fujitsu-Siemens.com>
- * - added devfs volume UUID support (/dev/volumes/uuids) for
- *   mounting file systems by the partition GUID. 
- *
- * Tue Dec  5 2000 Matt Domsch <Matt_Domsch@dell.com>
- * - Moved crc32() to linux/lib, added efi_crc32().
- *
- * Thu Nov 30 2000 Matt Domsch <Matt_Domsch@dell.com>
- * - Replaced Intel's CRC32 function with an equivalent
- *   non-license-restricted version.
- *
- * Wed Oct 25 2000 Matt Domsch <Matt_Domsch@dell.com>
- * - Fixed the last_lba() call to return the proper last block
- *
- * Thu Oct 12 2000 Matt Domsch <Matt_Domsch@dell.com>
- * - Thanks to Andries Brouwer for his debugging assistance.
- * - Code works, detects all the partitions.
- *
- ************************************************************/
-#include <linux/crc32.h>
-#include <linux/ctype.h>
-#include <linux/math64.h>
-#include <linux/slab.h>
-#include "check.h"
-#include "efi.h"
-
-/* This allows a kernel command line option 'gpt' to override
- * the test for invalid PMBR.  Not __initdata because reloading
- * the partition tables happens after init too.
- */
-static int force_gpt;
-static int __init
-force_gpt_fn(char *str)
-{
-        force_gpt = 1;
-        return 1;
-}
-__setup("gpt", force_gpt_fn);
-
-
-/**
- * efi_crc32() - EFI version of crc32 function
- * @buf: buffer to calculate crc32 of
- * @len - length of buf
- *
- * Description: Returns EFI-style CRC32 value for @buf
- * 
- * This function uses the little endian Ethernet polynomial
- * but seeds the function with ~0, and xor's with ~0 at the end.
- * Note, the EFI Specification, v1.02, has a reference to
- * Dr. Dobbs Journal, May 1994 (actually it's in May 1992).
- */
-static inline u32
-efi_crc32(const void *buf, unsigned long len)
-{
-        return (crc32(~0L, buf, len) ^ ~0L);
-}
-
-/**
- * last_lba(): return number of last logical block of device
- * @bdev: block device
- * 
- * Description: Returns last LBA value on success, 0 on error.
- * This is stored (by sd and ide-geometry) in
- *  the part[0] entry for this disk, and is the number of
- *  physical sectors available on the disk.
- */
-static u64 last_lba(struct block_device *bdev)
-{
-        if (!bdev || !bdev->bd_inode)
-                return 0;
-        return div_u64(bdev->bd_inode->i_size,
-                       bdev_logical_block_size(bdev)) - 1ULL;
-}
-
-static inline int
-pmbr_part_valid(struct partition *part)
-{
-        if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
-            le32_to_cpu(part->start_sect) == 1UL)
-                return 1;
-        return 0;
-}
-
-/**
- * is_pmbr_valid(): test Protective MBR for validity
- * @mbr: pointer to a legacy mbr structure
- *
- * Description: Returns 1 if PMBR is valid, 0 otherwise.
- * Validity depends on two things:
- *  1) MSDOS signature is in the last two bytes of the MBR
- *  2) One partition of type 0xEE is found
- */
-static int
-is_pmbr_valid(legacy_mbr *mbr)
-{
-        int i;
-        if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
-                return 0;
-        for (i = 0; i < 4; i++)
-                if (pmbr_part_valid(&mbr->partition_record[i]))
-                        return 1;
-        return 0;
-}
-
-/**
- * read_lba(): Read bytes from disk, starting at given LBA
- * @state
- * @lba
- * @buffer
- * @size_t
- *
- * Description: Reads @count bytes from @state->bdev into @buffer.
- * Returns number of bytes read on success, 0 on error.
- */
-static size_t read_lba(struct parsed_partitions *state,
-                       u64 lba, u8 *buffer, size_t count)
-{
-        size_t totalreadcount = 0;
-        struct block_device *bdev = state->bdev;
-        sector_t n = lba * (bdev_logical_block_size(bdev) / 512);
-
-        if (!buffer || lba > last_lba(bdev))
-                return 0;
-
-        while (count) {
-                int copied = 512;
-                Sector sect;
-                unsigned char *data = read_part_sector(state, n++, &sect);
-                if (!data)
-                        break;
-                if (copied > count)
-                        copied = count;
-                memcpy(buffer, data, copied);
-                put_dev_sector(sect);
-                buffer += copied;
-                totalreadcount +=copied;
-                count -= copied;
-        }
-        return totalreadcount;
-}
-
-/**
- * alloc_read_gpt_entries(): reads partition entries from disk
- * @state
- * @gpt - GPT header
- * 
- * Description: Returns ptes on success,  NULL on error.
- * Allocates space for PTEs based on information found in @gpt.
- * Notes: remember to free pte when you're done!
- */
-static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
-                                         gpt_header *gpt)
-{
-        size_t count;
-        gpt_entry *pte;
-
-        if (!gpt)
-                return NULL;
-
-        count = le32_to_cpu(gpt->num_partition_entries) *
-                le32_to_cpu(gpt->sizeof_partition_entry);
-        if (!count)
-                return NULL;
-        pte = kzalloc(count, GFP_KERNEL);
-        if (!pte)
-                return NULL;
-
-        if (read_lba(state, le64_to_cpu(gpt->partition_entry_lba),
-                     (u8 *) pte,
-                     count) < count) {
-                kfree(pte);
-                pte=NULL;
-                return NULL;
-        }
-        return pte;
-}
-
-/**
- * alloc_read_gpt_header(): Allocates GPT header, reads into it from disk
- * @state
- * @lba is the Logical Block Address of the partition table
- * 
- * Description: returns GPT header on success, NULL on error.   Allocates
- * and fills a GPT header starting at @ from @state->bdev.
- * Note: remember to free gpt when finished with it.
- */
-static gpt_header *alloc_read_gpt_header(struct parsed_partitions *state,
-                                         u64 lba)
-{
-        gpt_header *gpt;
-        unsigned ssz = bdev_logical_block_size(state->bdev);
-
-        gpt = kzalloc(ssz, GFP_KERNEL);
-        if (!gpt)
-                return NULL;
-
-        if (read_lba(state, lba, (u8 *) gpt, ssz) < ssz) {
-                kfree(gpt);
-                gpt=NULL;
-                return NULL;
-        }
-
-        return gpt;
-}
-
-/**
- * is_gpt_valid() - tests one GPT header and PTEs for validity
- * @state
- * @lba is the logical block address of the GPT header to test
- * @gpt is a GPT header ptr, filled on return.
- * @ptes is a PTEs ptr, filled on return.
- *
- * Description: returns 1 if valid,  0 on error.
- * If valid, returns pointers to newly allocated GPT header and PTEs.
- */
-static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
-                        gpt_header **gpt, gpt_entry **ptes)
-{
-        u32 crc, origcrc;
-        u64 lastlba;
-
-        if (!ptes)
-                return 0;
-        if (!(*gpt = alloc_read_gpt_header(state, lba)))
-                return 0;
-
-        /* Check the GUID Partition Table signature */
-        if (le64_to_cpu((*gpt)->signature) != GPT_HEADER_SIGNATURE) {
-                pr_debug("GUID Partition Table Header signature is wrong:"
-                         "%lld != %lld\n",
-                         (unsigned long long)le64_to_cpu((*gpt)->signature),
-                         (unsigned long long)GPT_HEADER_SIGNATURE);
-                goto fail;
-        }
-
-        /* Check the GUID Partition Table header size */
-        if (le32_to_cpu((*gpt)->header_size) >
-                        bdev_logical_block_size(state->bdev)) {
-                pr_debug("GUID Partition Table Header size is wrong: %u > %u\n",
-                        le32_to_cpu((*gpt)->header_size),
-                        bdev_logical_block_size(state->bdev));
-                goto fail;
-        }
-
-        /* Check the GUID Partition Table CRC */
-        origcrc = le32_to_cpu((*gpt)->header_crc32);
-        (*gpt)->header_crc32 = 0;
-        crc = efi_crc32((const unsigned char *) (*gpt), le32_to_cpu((*gpt)->header_size));
-
-        if (crc != origcrc) {
-                pr_debug("GUID Partition Table Header CRC is wrong: %x != %x\n",
-                         crc, origcrc);
-                goto fail;
-        }
-        (*gpt)->header_crc32 = cpu_to_le32(origcrc);
-
-        /* Check that the my_lba entry points to the LBA that contains
-         * the GUID Partition Table */
-        if (le64_to_cpu((*gpt)->my_lba) != lba) {
-                pr_debug("GPT my_lba incorrect: %lld != %lld\n",
-                         (unsigned long long)le64_to_cpu((*gpt)->my_lba),
-                         (unsigned long long)lba);
-                goto fail;
-        }
-
-        /* Check the first_usable_lba and last_usable_lba are
-         * within the disk.
-         */
-        lastlba = last_lba(state->bdev);
-        if (le64_to_cpu((*gpt)->first_usable_lba) > lastlba) {
-                pr_debug("GPT: first_usable_lba incorrect: %lld > %lld\n",
-                         (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba),
-                         (unsigned long long)lastlba);
-                goto fail;
-        }
-        if (le64_to_cpu((*gpt)->last_usable_lba) > lastlba) {
-                pr_debug("GPT: last_usable_lba incorrect: %lld > %lld\n",
-                         (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba),
-                         (unsigned long long)lastlba);
-                goto fail;
-        }
-
-        /* Check that sizeof_partition_entry has the correct value */
-        if (le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
-                pr_debug("GUID Partitition Entry Size check failed.\n");
-                goto fail;
-        }
-
-        if (!(*ptes = alloc_read_gpt_entries(state, *gpt)))
-                goto fail;
-
-        /* Check the GUID Partition Entry Array CRC */
-        crc = efi_crc32((const unsigned char *) (*ptes),
-                        le32_to_cpu((*gpt)->num_partition_entries) *
-                        le32_to_cpu((*gpt)->sizeof_partition_entry));
-
-        if (crc != le32_to_cpu((*gpt)->partition_entry_array_crc32)) {
-                pr_debug("GUID Partitition Entry Array CRC check failed.\n");
-                goto fail_ptes;
-        }
-
-        /* We're done, all's well */
-        return 1;
-
- fail_ptes:
-        kfree(*ptes);
-        *ptes = NULL;
- fail:
-        kfree(*gpt);
-        *gpt = NULL;
-        return 0;
-}
-
-/**
- * is_pte_valid() - tests one PTE for validity
- * @pte is the pte to check
- * @lastlba is last lba of the disk
- *
- * Description: returns 1 if valid,  0 on error.
- */
-static inline int
-is_pte_valid(const gpt_entry *pte, const u64 lastlba)
-{
-        if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID)) ||
-            le64_to_cpu(pte->starting_lba) > lastlba         ||
-            le64_to_cpu(pte->ending_lba)   > lastlba)
-                return 0;
-        return 1;
-}
-
-/**
- * compare_gpts() - Search disk for valid GPT headers and PTEs
- * @pgpt is the primary GPT header
- * @agpt is the alternate GPT header
- * @lastlba is the last LBA number
- * Description: Returns nothing.  Sanity checks pgpt and agpt fields
- * and prints warnings on discrepancies.
- * 
- */
-static void
-compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
-{
-        int error_found = 0;
-        if (!pgpt || !agpt)
-                return;
-        if (le64_to_cpu(pgpt->my_lba) != le64_to_cpu(agpt->alternate_lba)) {
-                printk(KERN_WARNING
-                       "GPT:Primary header LBA != Alt. header alternate_lba\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                       (unsigned long long)le64_to_cpu(pgpt->my_lba),
-                       (unsigned long long)le64_to_cpu(agpt->alternate_lba));
-                error_found++;
-        }
-        if (le64_to_cpu(pgpt->alternate_lba) != le64_to_cpu(agpt->my_lba)) {
-                printk(KERN_WARNING
-                       "GPT:Primary header alternate_lba != Alt. header my_lba\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                       (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
-                       (unsigned long long)le64_to_cpu(agpt->my_lba));
-                error_found++;
-        }
-        if (le64_to_cpu(pgpt->first_usable_lba) !=
-            le64_to_cpu(agpt->first_usable_lba)) {
-                printk(KERN_WARNING "GPT:first_usable_lbas don't match.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                       (unsigned long long)le64_to_cpu(pgpt->first_usable_lba),
-                       (unsigned long long)le64_to_cpu(agpt->first_usable_lba));
-                error_found++;
-        }
-        if (le64_to_cpu(pgpt->last_usable_lba) !=
-            le64_to_cpu(agpt->last_usable_lba)) {
-                printk(KERN_WARNING "GPT:last_usable_lbas don't match.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                       (unsigned long long)le64_to_cpu(pgpt->last_usable_lba),
-                       (unsigned long long)le64_to_cpu(agpt->last_usable_lba));
-                error_found++;
-        }
-        if (efi_guidcmp(pgpt->disk_guid, agpt->disk_guid)) {
-                printk(KERN_WARNING "GPT:disk_guids don't match.\n");
-                error_found++;
-        }
-        if (le32_to_cpu(pgpt->num_partition_entries) !=
-            le32_to_cpu(agpt->num_partition_entries)) {
-                printk(KERN_WARNING "GPT:num_partition_entries don't match: "
-                       "0x%x != 0x%x\n",
-                       le32_to_cpu(pgpt->num_partition_entries),
-                       le32_to_cpu(agpt->num_partition_entries));
-                error_found++;
-        }
-        if (le32_to_cpu(pgpt->sizeof_partition_entry) !=
-            le32_to_cpu(agpt->sizeof_partition_entry)) {
-                printk(KERN_WARNING
-                       "GPT:sizeof_partition_entry values don't match: "
-                       "0x%x != 0x%x\n",
-                       le32_to_cpu(pgpt->sizeof_partition_entry),
-                       le32_to_cpu(agpt->sizeof_partition_entry));
-                error_found++;
-        }
-        if (le32_to_cpu(pgpt->partition_entry_array_crc32) !=
-            le32_to_cpu(agpt->partition_entry_array_crc32)) {
-                printk(KERN_WARNING
-                       "GPT:partition_entry_array_crc32 values don't match: "
-                       "0x%x != 0x%x\n",
-                       le32_to_cpu(pgpt->partition_entry_array_crc32),
-                       le32_to_cpu(agpt->partition_entry_array_crc32));
-                error_found++;
-        }
-        if (le64_to_cpu(pgpt->alternate_lba) != lastlba) {
-                printk(KERN_WARNING
-                       "GPT:Primary header thinks Alt. header is not at the end of the disk.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                        (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
-                        (unsigned long long)lastlba);
-                error_found++;
-        }
-
-        if (le64_to_cpu(agpt->my_lba) != lastlba) {
-                printk(KERN_WARNING
-                       "GPT:Alternate GPT header not at the end of the disk.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
-                        (unsigned long long)le64_to_cpu(agpt->my_lba),
-                        (unsigned long long)lastlba);
-                error_found++;
-        }
-
-        if (error_found)
-                printk(KERN_WARNING
-                       "GPT: Use GNU Parted to correct GPT errors.\n");
-        return;
-}
-
-/**
- * find_valid_gpt() - Search disk for valid GPT headers and PTEs
- * @state
- * @gpt is a GPT header ptr, filled on return.
- * @ptes is a PTEs ptr, filled on return.
- * Description: Returns 1 if valid, 0 on error.
- * If valid, returns pointers to newly allocated GPT header and PTEs.
- * Validity depends on PMBR being valid (or being overridden by the
- * 'gpt' kernel command line option) and finding either the Primary
- * GPT header and PTEs valid, or the Alternate GPT header and PTEs
- * valid.  If the Primary GPT header is not valid, the Alternate GPT header
- * is not checked unless the 'gpt' kernel command line option is passed.
- * This protects against devices which misreport their size, and forces
- * the user to decide to use the Alternate GPT.
- */
-static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
-                          gpt_entry **ptes)
-{
-        int good_pgpt = 0, good_agpt = 0, good_pmbr = 0;
-        gpt_header *pgpt = NULL, *agpt = NULL;
-        gpt_entry *pptes = NULL, *aptes = NULL;
-        legacy_mbr *legacymbr;
-        u64 lastlba;
-
-        if (!ptes)
-                return 0;
-
-        lastlba = last_lba(state->bdev);
-        if (!force_gpt) {
-                /* This will be added to the EFI Spec. per Intel after v1.02. */
-                legacymbr = kzalloc(sizeof (*legacymbr), GFP_KERNEL);
-                if (legacymbr) {
-                        read_lba(state, 0, (u8 *) legacymbr,
-                                 sizeof (*legacymbr));
-                        good_pmbr = is_pmbr_valid(legacymbr);
-                        kfree(legacymbr);
-                }
-                if (!good_pmbr)
-                        goto fail;
-        }
-
-        good_pgpt = is_gpt_valid(state, GPT_PRIMARY_PARTITION_TABLE_LBA,
-                                 &pgpt, &pptes);
-        if (good_pgpt)
-                good_agpt = is_gpt_valid(state,
-                                         le64_to_cpu(pgpt->alternate_lba),
-                                         &agpt, &aptes);
-        if (!good_agpt && force_gpt)
-                good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
-
-        /* The obviously unsuccessful case */
-        if (!good_pgpt && !good_agpt)
-                goto fail;
-
-        compare_gpts(pgpt, agpt, lastlba);
-
-        /* The good cases */
-        if (good_pgpt) {
-                *gpt  = pgpt;
-                *ptes = pptes;
-                kfree(agpt);
-                kfree(aptes);
-                if (!good_agpt) {
-                        printk(KERN_WARNING 
-                               "Alternate GPT is invalid, "
-                               "using primary GPT.\n");
-                }
-                return 1;
-        }
-        else if (good_agpt) {
-                *gpt  = agpt;
-                *ptes = aptes;
-                kfree(pgpt);
-                kfree(pptes);
-                printk(KERN_WARNING 
-                       "Primary GPT is invalid, using alternate GPT.\n");
-                return 1;
-        }
-
- fail:
-        kfree(pgpt);
-        kfree(agpt);
-        kfree(pptes);
-        kfree(aptes);
-        *gpt = NULL;
-        *ptes = NULL;
-        return 0;
-}
-
-/**
- * efi_partition(struct parsed_partitions *state)
- * @state
- *
- * Description: called from check.c, if the disk contains GPT
- * partitions, sets up partition entries in the kernel.
- *
- * If the first block on the disk is a legacy MBR,
- * it will get handled by msdos_partition().
- * If it's a Protective MBR, we'll handle it here.
- *
- * We do not create a Linux partition for GPT, but
- * only for the actual data partitions.
- * Returns:
- * -1 if unable to read the partition table
- *  0 if this isn't our partition table
- *  1 if successful
- *
- */
-int efi_partition(struct parsed_partitions *state)
-{
-        gpt_header *gpt = NULL;
-        gpt_entry *ptes = NULL;
-        u32 i;
-        unsigned ssz = bdev_logical_block_size(state->bdev) / 512;
-        u8 unparsed_guid[37];
-
-        if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes) {
-                kfree(gpt);
-                kfree(ptes);
-                return 0;
-        }
-
-        pr_debug("GUID Partition Table is valid!  Yea!\n");
-
-        for (i = 0; i < le32_to_cpu(gpt->num_partition_entries) && i < state->limit-1; i++) {
-                struct partition_meta_info *info;
-                unsigned label_count = 0;
-                unsigned label_max;
-                u64 start = le64_to_cpu(ptes[i].starting_lba);
-                u64 size = le64_to_cpu(ptes[i].ending_lba) -
-                           le64_to_cpu(ptes[i].starting_lba) + 1ULL;
-
-                if (!is_pte_valid(&ptes[i], last_lba(state->bdev)))
-                        continue;
-
-                put_partition(state, i+1, start * ssz, size * ssz);
-
-                /* If this is a RAID volume, tell md */
-                if (!efi_guidcmp(ptes[i].partition_type_guid,
-                                 PARTITION_LINUX_RAID_GUID))
-                        state->parts[i + 1].flags = ADDPART_FLAG_RAID;
-
-                info = &state->parts[i + 1].info;
-                /* Instead of doing a manual swap to big endian, reuse the
-                 * common ASCII hex format as the interim.
-                 */
-                efi_guid_unparse(&ptes[i].unique_partition_guid, unparsed_guid);
-                part_pack_uuid(unparsed_guid, info->uuid);
-
-                /* Naively convert UTF16-LE to 7 bits. */
-                label_max = min(sizeof(info->volname) - 1,
-                                sizeof(ptes[i].partition_name));
-                info->volname[label_max] = 0;
-                while (label_count < label_max) {
-                        u8 c = ptes[i].partition_name[label_count] & 0xff;
-                        if (c && !isprint(c))
-                                c = '!';
-                        info->volname[label_count] = c;
-                        label_count++;
-                }
-                state->parts[i + 1].has_info = true;
-        }
-        kfree(ptes);
-        kfree(gpt);
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        return 1;
-}
diff --git a/fs/partitions/efi.h b/fs/partitions/efi.h
deleted file mode 100644
index b69ab729558f..000000000000
--- a/fs/partitions/efi.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/************************************************************
- * EFI GUID Partition Table
- * Per Intel EFI Specification v1.02
- * http://developer.intel.com/technology/efi/efi.htm
- *
- * By Matt Domsch <Matt_Domsch@dell.com>  Fri Sep 22 22:15:56 CDT 2000  
- *   Copyright 2000,2001 Dell Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- * 
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- * 
- ************************************************************/
-
-#ifndef FS_PART_EFI_H_INCLUDED
-#define FS_PART_EFI_H_INCLUDED
-
-#include <linux/types.h>
-#include <linux/fs.h>
-#include <linux/genhd.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/string.h>
-#include <linux/efi.h>
-
-#define MSDOS_MBR_SIGNATURE 0xaa55
-#define EFI_PMBR_OSTYPE_EFI 0xEF
-#define EFI_PMBR_OSTYPE_EFI_GPT 0xEE
-
-#define GPT_HEADER_SIGNATURE 0x5452415020494645ULL
-#define GPT_HEADER_REVISION_V1 0x00010000
-#define GPT_PRIMARY_PARTITION_TABLE_LBA 1
-
-#define PARTITION_SYSTEM_GUID \
-    EFI_GUID( 0xC12A7328, 0xF81F, 0x11d2, \
-              0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B) 
-#define LEGACY_MBR_PARTITION_GUID \
-    EFI_GUID( 0x024DEE41, 0x33E7, 0x11d3, \
-              0x9D, 0x69, 0x00, 0x08, 0xC7, 0x81, 0xF3, 0x9F)
-#define PARTITION_MSFT_RESERVED_GUID \
-    EFI_GUID( 0xE3C9E316, 0x0B5C, 0x4DB8, \
-              0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE)
-#define PARTITION_BASIC_DATA_GUID \
-    EFI_GUID( 0xEBD0A0A2, 0xB9E5, 0x4433, \
-              0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7)
-#define PARTITION_LINUX_RAID_GUID \
-    EFI_GUID( 0xa19d880f, 0x05fc, 0x4d3b, \
-              0xa0, 0x06, 0x74, 0x3f, 0x0f, 0x84, 0x91, 0x1e)
-#define PARTITION_LINUX_SWAP_GUID \
-    EFI_GUID( 0x0657fd6d, 0xa4ab, 0x43c4, \
-              0x84, 0xe5, 0x09, 0x33, 0xc8, 0x4b, 0x4f, 0x4f)
-#define PARTITION_LINUX_LVM_GUID \
-    EFI_GUID( 0xe6d6d379, 0xf507, 0x44c2, \
-              0xa2, 0x3c, 0x23, 0x8f, 0x2a, 0x3d, 0xf9, 0x28)
-
-typedef struct _gpt_header {
-        __le64 signature;
-        __le32 revision;
-        __le32 header_size;
-        __le32 header_crc32;
-        __le32 reserved1;
-        __le64 my_lba;
-        __le64 alternate_lba;
-        __le64 first_usable_lba;
-        __le64 last_usable_lba;
-        efi_guid_t disk_guid;
-        __le64 partition_entry_lba;
-        __le32 num_partition_entries;
-        __le32 sizeof_partition_entry;
-        __le32 partition_entry_array_crc32;
-
-        /* The rest of the logical block is reserved by UEFI and must be zero.
-         * EFI standard handles this by:
-         *
-         * uint8_t              reserved2[ BlockSize - 92 ];
-         */
-} __attribute__ ((packed)) gpt_header;
-
-typedef struct _gpt_entry_attributes {
-        u64 required_to_function:1;
-        u64 reserved:47;
-        u64 type_guid_specific:16;
-} __attribute__ ((packed)) gpt_entry_attributes;
-
-typedef struct _gpt_entry {
-        efi_guid_t partition_type_guid;
-        efi_guid_t unique_partition_guid;
-        __le64 starting_lba;
-        __le64 ending_lba;
-        gpt_entry_attributes attributes;
-        efi_char16_t partition_name[72 / sizeof (efi_char16_t)];
-} __attribute__ ((packed)) gpt_entry;
-
-typedef struct _legacy_mbr {
-        u8 boot_code[440];
-        __le32 unique_mbr_signature;
-        __le16 unknown;
-        struct partition partition_record[4];
-        __le16 signature;
-} __attribute__ ((packed)) legacy_mbr;
-
-/* Functions */
-extern int efi_partition(struct parsed_partitions *state);
-
-#endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * --------------------------------------------------------------------------
- * Local variables:
- * c-indent-level: 4 
- * c-brace-imaginary-offset: 0
- * c-brace-offset: -4
- * c-argdecl-indent: 4
- * c-label-offset: -4
- * c-continued-statement-offset: 4
- * c-continued-brace-offset: 0
- * indent-tabs-mode: nil
- * tab-width: 8
- * End:
- */
diff --git a/fs/partitions/ibm.c b/fs/partitions/ibm.c
deleted file mode 100644
index d513a07f44bb..000000000000
--- a/fs/partitions/ibm.c
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * File...........: linux/fs/partitions/ibm.c
- * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
- *                  Volker Sameske <sameske@de.ibm.com>
- * Bugreports.to..: <Linux390@de.ibm.com>
- * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000
- */
-
-#include <linux/buffer_head.h>
-#include <linux/hdreg.h>
-#include <linux/slab.h>
-#include <asm/dasd.h>
-#include <asm/ebcdic.h>
-#include <asm/uaccess.h>
-#include <asm/vtoc.h>
-
-#include "check.h"
-#include "ibm.h"
-
-/*
- * compute the block number from a
- * cyl-cyl-head-head structure
- */
-static sector_t
-cchh2blk (struct vtoc_cchh *ptr, struct hd_geometry *geo) {
-
-        sector_t cyl;
-        __u16 head;
-
-        /*decode cylinder and heads for large volumes */
-        cyl = ptr->hh & 0xFFF0;
-        cyl <<= 12;
-        cyl |= ptr->cc;
-        head = ptr->hh & 0x000F;
-        return cyl * geo->heads * geo->sectors +
-               head * geo->sectors;
-}
-
-/*
- * compute the block number from a
- * cyl-cyl-head-head-block structure
- */
-static sector_t
-cchhb2blk (struct vtoc_cchhb *ptr, struct hd_geometry *geo) {
-
-        sector_t cyl;
-        __u16 head;
-
-        /*decode cylinder and heads for large volumes */
-        cyl = ptr->hh & 0xFFF0;
-        cyl <<= 12;
-        cyl |= ptr->cc;
-        head = ptr->hh & 0x000F;
-        return  cyl * geo->heads * geo->sectors +
-                head * geo->sectors +
-                ptr->b;
-}
-
-/*
- */
-int ibm_partition(struct parsed_partitions *state)
-{
-        struct block_device *bdev = state->bdev;
-        int blocksize, res;
-        loff_t i_size, offset, size, fmt_size;
-        dasd_information2_t *info;
-        struct hd_geometry *geo;
-        char type[5] = {0,};
-        char name[7] = {0,};
-        union label_t {
-                struct vtoc_volume_label_cdl vol;
-                struct vtoc_volume_label_ldl lnx;
-                struct vtoc_cms_label cms;
-        } *label;
-        unsigned char *data;
-        Sector sect;
-        sector_t labelsect;
-        char tmp[64];
-
-        res = 0;
-        blocksize = bdev_logical_block_size(bdev);
-        if (blocksize <= 0)
-                goto out_exit;
-        i_size = i_size_read(bdev->bd_inode);
-        if (i_size == 0)
-                goto out_exit;
-
-        info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);
-        if (info == NULL)
-                goto out_exit;
-        geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL);
-        if (geo == NULL)
-                goto out_nogeo;
-        label = kmalloc(sizeof(union label_t), GFP_KERNEL);
-        if (label == NULL)
-                goto out_nolab;
-
-        if (ioctl_by_bdev(bdev, BIODASDINFO2, (unsigned long)info) != 0 ||
-            ioctl_by_bdev(bdev, HDIO_GETGEO, (unsigned long)geo) != 0)
-                goto out_freeall;
-
-        /*
-         * Special case for FBA disks: label sector does not depend on
-         * blocksize.
-         */
-        if ((info->cu_type == 0x6310 && info->dev_type == 0x9336) ||
-            (info->cu_type == 0x3880 && info->dev_type == 0x3370))
-                labelsect = info->label_block;
-        else
-                labelsect = info->label_block * (blocksize >> 9);
-
-        /*
-         * Get volume label, extract name and type.
-         */
-        data = read_part_sector(state, labelsect, &sect);
-        if (data == NULL)
-                goto out_readerr;
-
-        memcpy(label, data, sizeof(union label_t));
-        put_dev_sector(sect);
-
-        if ((!info->FBA_layout) && (!strcmp(info->type, "ECKD"))) {
-                strncpy(type, label->vol.vollbl, 4);
-                strncpy(name, label->vol.volid, 6);
-        } else {
-                strncpy(type, label->lnx.vollbl, 4);
-                strncpy(name, label->lnx.volid, 6);
-        }
-        EBCASC(type, 4);
-        EBCASC(name, 6);
-
-        res = 1;
-
-        /*
-         * Three different formats: LDL, CDL and unformated disk
-         *
-         * identified by info->format
-         *
-         * unformated disks we do not have to care about
-         */
-        if (info->format == DASD_FORMAT_LDL) {
-                if (strncmp(type, "CMS1", 4) == 0) {
-                        /*
-                         * VM style CMS1 labeled disk
-                         */
-                        blocksize = label->cms.block_size;
-                        if (label->cms.disk_offset != 0) {
-                                snprintf(tmp, sizeof(tmp), "CMS1/%8s(MDSK):", name);
-                                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                                /* disk is reserved minidisk */
-                                offset = label->cms.disk_offset;
-                                size = (label->cms.block_count - 1)
-                                        * (blocksize >> 9);
-                        } else {
-                                snprintf(tmp, sizeof(tmp), "CMS1/%8s:", name);
-                                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                                offset = (info->label_block + 1);
-                                size = label->cms.block_count
-                                        * (blocksize >> 9);
-                        }
-                        put_partition(state, 1, offset*(blocksize >> 9),
-                                      size-offset*(blocksize >> 9));
-                } else {
-                        if (strncmp(type, "LNX1", 4) == 0) {
-                                snprintf(tmp, sizeof(tmp), "LNX1/%8s:", name);
-                                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                                if (label->lnx.ldl_version == 0xf2) {
-                                        fmt_size = label->lnx.formatted_blocks
-                                                * (blocksize >> 9);
-                                } else if (!strcmp(info->type, "ECKD")) {
-                                        /* formated w/o large volume support */
-                                        fmt_size = geo->cylinders * geo->heads
-                                              * geo->sectors * (blocksize >> 9);
-                                } else {
-                                        /* old label and no usable disk geometry
-                                         * (e.g. DIAG) */
-                                        fmt_size = i_size >> 9;
-                                }
-                                size = i_size >> 9;
-                                if (fmt_size < size)
-                                        size = fmt_size;
-                                offset = (info->label_block + 1);
-                        } else {
-                                /* unlabeled disk */
-                                strlcat(state->pp_buf, "(nonl)", PAGE_SIZE);
-                                size = i_size >> 9;
-                                offset = (info->label_block + 1);
-                        }
-                        put_partition(state, 1, offset*(blocksize >> 9),
-                                      size-offset*(blocksize >> 9));
-                }
-        } else if (info->format == DASD_FORMAT_CDL) {
-                /*
-                 * New style CDL formatted disk
-                 */
-                sector_t blk;
-                int counter;
-
-                /*
-                 * check if VOL1 label is available
-                 * if not, something is wrong, skipping partition detection
-                 */
-                if (strncmp(type, "VOL1",  4) == 0) {
-                        snprintf(tmp, sizeof(tmp), "VOL1/%8s:", name);
-                        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                        /*
-                         * get block number and read then go through format1
-                         * labels
-                         */
-                        blk = cchhb2blk(&label->vol.vtoc, geo) + 1;
-                        counter = 0;
-                        data = read_part_sector(state, blk * (blocksize/512),
-                                                &sect);
-                        while (data != NULL) {
-                                struct vtoc_format1_label f1;
-
-                                memcpy(&f1, data,
-                                       sizeof(struct vtoc_format1_label));
-                                put_dev_sector(sect);
-
-                                /* skip FMT4 / FMT5 / FMT7 labels */
-                                if (f1.DS1FMTID == _ascebc['4']
-                                    || f1.DS1FMTID == _ascebc['5']
-                                    || f1.DS1FMTID == _ascebc['7']
-                                    || f1.DS1FMTID == _ascebc['9']) {
-                                        blk++;
-                                        data = read_part_sector(state,
-                                                blk * (blocksize/512), &sect);
-                                        continue;
-                                }
-
-                                /* only FMT1 and 8 labels valid at this point */
-                                if (f1.DS1FMTID != _ascebc['1'] &&
-                                    f1.DS1FMTID != _ascebc['8'])
-                                        break;
-
-                                /* OK, we got valid partition data */
-                                offset = cchh2blk(&f1.DS1EXT1.llimit, geo);
-                                size  = cchh2blk(&f1.DS1EXT1.ulimit, geo) -
-                                        offset + geo->sectors;
-                                if (counter >= state->limit)
-                                        break;
-                                put_partition(state, counter + 1,
-                                              offset * (blocksize >> 9),
-                                              size * (blocksize >> 9));
-                                counter++;
-                                blk++;
-                                data = read_part_sector(state,
-                                                blk * (blocksize/512), &sect);
-                        }
-
-                        if (!data)
-                                /* Are we not supposed to report this ? */
-                                goto out_readerr;
-                } else
-                        printk(KERN_WARNING "Warning, expected Label VOL1 not "
-                               "found, treating as CDL formated Disk");
-
-        }
-
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        goto out_freeall;
-
-
-out_readerr:
-        res = -1;
-out_freeall:
-        kfree(label);
-out_nolab:
-        kfree(geo);
-out_nogeo:
-        kfree(info);
-out_exit:
-        return res;
-}
diff --git a/fs/partitions/ibm.h b/fs/partitions/ibm.h
deleted file mode 100644
index 08fb0804a812..000000000000
--- a/fs/partitions/ibm.h
+++ /dev/null
@@ -1 +0,0 @@
-int ibm_partition(struct parsed_partitions *);
diff --git a/fs/partitions/karma.c b/fs/partitions/karma.c
deleted file mode 100644
index 0ea19312706b..000000000000
--- a/fs/partitions/karma.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *  fs/partitions/karma.c
- *  Rio Karma partition info.
- *
- *  Copyright (C) 2006 Bob Copeland (me@bobcopeland.com)
- *  based on osf.c
- */
-
-#include "check.h"
-#include "karma.h"
-
-int karma_partition(struct parsed_partitions *state)
-{
-        int i;
-        int slot = 1;
-        Sector sect;
-        unsigned char *data;
-        struct disklabel {
-                u8 d_reserved[270];
-                struct d_partition {
-                        __le32 p_res;
-                        u8 p_fstype;
-                        u8 p_res2[3];
-                        __le32 p_offset;
-                        __le32 p_size;
-                } d_partitions[2];
-                u8 d_blank[208];
-                __le16 d_magic;
-        } __attribute__((packed)) *label;
-        struct d_partition *p;
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-
-        label = (struct disklabel *)data;
-        if (le16_to_cpu(label->d_magic) != KARMA_LABEL_MAGIC) {
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        p = label->d_partitions;
-        for (i = 0 ; i < 2; i++, p++) {
-                if (slot == state->limit)
-                        break;
-
-                if (p->p_fstype == 0x4d && le32_to_cpu(p->p_size)) {
-                        put_partition(state, slot, le32_to_cpu(p->p_offset),
-                                le32_to_cpu(p->p_size));
-                }
-                slot++;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        put_dev_sector(sect);
-        return 1;
-}
-
diff --git a/fs/partitions/karma.h b/fs/partitions/karma.h
deleted file mode 100644
index c764b2e9df21..000000000000
--- a/fs/partitions/karma.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
- *  fs/partitions/karma.h
- */
-
-#define KARMA_LABEL_MAGIC               0xAB56
-
-int karma_partition(struct parsed_partitions *state);
-
diff --git a/fs/partitions/ldm.c b/fs/partitions/ldm.c
deleted file mode 100644
index bd8ae788f689..000000000000
--- a/fs/partitions/ldm.c
+++ /dev/null
@@ -1,1570 +0,0 @@
-/**
- * ldm - Support for Windows Logical Disk Manager (Dynamic Disks)
- *
- * Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org>
- * Copyright (c) 2001-2007 Anton Altaparmakov
- * Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com>
- *
- * Documentation is available at http://www.linux-ntfs.org/doku.php?id=downloads 
- *
- * This program is free software; you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by the Free Software
- * Foundation; either version 2 of the License, or (at your option) any later
- * version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program (in the main directory of the source in the file COPYING); if
- * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA  02111-1307  USA
- */
-
-#include <linux/slab.h>
-#include <linux/pagemap.h>
-#include <linux/stringify.h>
-#include <linux/kernel.h>
-#include "ldm.h"
-#include "check.h"
-#include "msdos.h"
-
-/**
- * ldm_debug/info/error/crit - Output an error message
- * @f:    A printf format string containing the message
- * @...:  Variables to substitute into @f
- *
- * ldm_debug() writes a DEBUG level message to the syslog but only if the
- * driver was compiled with debug enabled. Otherwise, the call turns into a NOP.
- */
-#ifndef CONFIG_LDM_DEBUG
-#define ldm_debug(...)  do {} while (0)
-#else
-#define ldm_debug(f, a...) _ldm_printk (KERN_DEBUG, __func__, f, ##a)
-#endif
-
-#define ldm_crit(f, a...)  _ldm_printk (KERN_CRIT,  __func__, f, ##a)
-#define ldm_error(f, a...) _ldm_printk (KERN_ERR,   __func__, f, ##a)
-#define ldm_info(f, a...)  _ldm_printk (KERN_INFO,  __func__, f, ##a)
-
-static __printf(3, 4)
-void _ldm_printk(const char *level, const char *function, const char *fmt, ...)
-{
-        struct va_format vaf;
-        va_list args;
-
-        va_start (args, fmt);
-
-        vaf.fmt = fmt;
-        vaf.va = &args;
-
-        printk("%s%s(): %pV\n", level, function, &vaf);
-
-        va_end(args);
-}
-
-/**
- * ldm_parse_hexbyte - Convert a ASCII hex number to a byte
- * @src:  Pointer to at least 2 characters to convert.
- *
- * Convert a two character ASCII hex string to a number.
- *
- * Return:  0-255  Success, the byte was parsed correctly
- *          -1     Error, an invalid character was supplied
- */
-static int ldm_parse_hexbyte (const u8 *src)
-{
-        unsigned int x;         /* For correct wrapping */
-        int h;
-
-        /* high part */
-        x = h = hex_to_bin(src[0]);
-        if (h < 0)
-                return -1;
-
-        /* low part */
-        h = hex_to_bin(src[1]);
-        if (h < 0)
-                return -1;
-
-        return (x << 4) + h;
-}
-
-/**
- * ldm_parse_guid - Convert GUID from ASCII to binary
- * @src:   36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
- * @dest:  Memory block to hold binary GUID (16 bytes)
- *
- * N.B. The GUID need not be NULL terminated.
- *
- * Return:  'true'   @dest contains binary GUID
- *          'false'  @dest contents are undefined
- */
-static bool ldm_parse_guid (const u8 *src, u8 *dest)
-{
-        static const int size[] = { 4, 2, 2, 2, 6 };
-        int i, j, v;
-
-        if (src[8]  != '-' || src[13] != '-' ||
-            src[18] != '-' || src[23] != '-')
-                return false;
-
-        for (j = 0; j < 5; j++, src++)
-                for (i = 0; i < size[j]; i++, src+=2, *dest++ = v)
-                        if ((v = ldm_parse_hexbyte (src)) < 0)
-                                return false;
-
-        return true;
-}
-
-/**
- * ldm_parse_privhead - Read the LDM Database PRIVHEAD structure
- * @data:  Raw database PRIVHEAD structure loaded from the device
- * @ph:    In-memory privhead structure in which to return parsed information
- *
- * This parses the LDM database PRIVHEAD structure supplied in @data and
- * sets up the in-memory privhead structure @ph with the obtained information.
- *
- * Return:  'true'   @ph contains the PRIVHEAD data
- *          'false'  @ph contents are undefined
- */
-static bool ldm_parse_privhead(const u8 *data, struct privhead *ph)
-{
-        bool is_vista = false;
-
-        BUG_ON(!data || !ph);
-        if (MAGIC_PRIVHEAD != get_unaligned_be64(data)) {
-                ldm_error("Cannot find PRIVHEAD structure. LDM database is"
-                        " corrupt. Aborting.");
-                return false;
-        }
-        ph->ver_major = get_unaligned_be16(data + 0x000C);
-        ph->ver_minor = get_unaligned_be16(data + 0x000E);
-        ph->logical_disk_start = get_unaligned_be64(data + 0x011B);
-        ph->logical_disk_size = get_unaligned_be64(data + 0x0123);
-        ph->config_start = get_unaligned_be64(data + 0x012B);
-        ph->config_size = get_unaligned_be64(data + 0x0133);
-        /* Version 2.11 is Win2k/XP and version 2.12 is Vista. */
-        if (ph->ver_major == 2 && ph->ver_minor == 12)
-                is_vista = true;
-        if (!is_vista && (ph->ver_major != 2 || ph->ver_minor != 11)) {
-                ldm_error("Expected PRIVHEAD version 2.11 or 2.12, got %d.%d."
-                        " Aborting.", ph->ver_major, ph->ver_minor);
-                return false;
-        }
-        ldm_debug("PRIVHEAD version %d.%d (Windows %s).", ph->ver_major,
-                        ph->ver_minor, is_vista ? "Vista" : "2000/XP");
-        if (ph->config_size != LDM_DB_SIZE) {   /* 1 MiB in sectors. */
-                /* Warn the user and continue, carefully. */
-                ldm_info("Database is normally %u bytes, it claims to "
-                        "be %llu bytes.", LDM_DB_SIZE,
-                        (unsigned long long)ph->config_size);
-        }
-        if ((ph->logical_disk_size == 0) || (ph->logical_disk_start +
-                        ph->logical_disk_size > ph->config_start)) {
-                ldm_error("PRIVHEAD disk size doesn't match real disk size");
-                return false;
-        }
-        if (!ldm_parse_guid(data + 0x0030, ph->disk_id)) {
-                ldm_error("PRIVHEAD contains an invalid GUID.");
-                return false;
-        }
-        ldm_debug("Parsed PRIVHEAD successfully.");
-        return true;
-}
-
-/**
- * ldm_parse_tocblock - Read the LDM Database TOCBLOCK structure
- * @data:  Raw database TOCBLOCK structure loaded from the device
- * @toc:   In-memory toc structure in which to return parsed information
- *
- * This parses the LDM Database TOCBLOCK (table of contents) structure supplied
- * in @data and sets up the in-memory tocblock structure @toc with the obtained
- * information.
- *
- * N.B.  The *_start and *_size values returned in @toc are not range-checked.
- *
- * Return:  'true'   @toc contains the TOCBLOCK data
- *          'false'  @toc contents are undefined
- */
-static bool ldm_parse_tocblock (const u8 *data, struct tocblock *toc)
-{
-        BUG_ON (!data || !toc);
-
-        if (MAGIC_TOCBLOCK != get_unaligned_be64(data)) {
-                ldm_crit ("Cannot find TOCBLOCK, database may be corrupt.");
-                return false;
-        }
-        strncpy (toc->bitmap1_name, data + 0x24, sizeof (toc->bitmap1_name));
-        toc->bitmap1_name[sizeof (toc->bitmap1_name) - 1] = 0;
-        toc->bitmap1_start = get_unaligned_be64(data + 0x2E);
-        toc->bitmap1_size  = get_unaligned_be64(data + 0x36);
-
-        if (strncmp (toc->bitmap1_name, TOC_BITMAP1,
-                        sizeof (toc->bitmap1_name)) != 0) {
-                ldm_crit ("TOCBLOCK's first bitmap is '%s', should be '%s'.",
-                                TOC_BITMAP1, toc->bitmap1_name);
-                return false;
-        }
-        strncpy (toc->bitmap2_name, data + 0x46, sizeof (toc->bitmap2_name));
-        toc->bitmap2_name[sizeof (toc->bitmap2_name) - 1] = 0;
-        toc->bitmap2_start = get_unaligned_be64(data + 0x50);
-        toc->bitmap2_size  = get_unaligned_be64(data + 0x58);
-        if (strncmp (toc->bitmap2_name, TOC_BITMAP2,
-                        sizeof (toc->bitmap2_name)) != 0) {
-                ldm_crit ("TOCBLOCK's second bitmap is '%s', should be '%s'.",
-                                TOC_BITMAP2, toc->bitmap2_name);
-                return false;
-        }
-        ldm_debug ("Parsed TOCBLOCK successfully.");
-        return true;
-}
-
-/**
- * ldm_parse_vmdb - Read the LDM Database VMDB structure
- * @data:  Raw database VMDB structure loaded from the device
- * @vm:    In-memory vmdb structure in which to return parsed information
- *
- * This parses the LDM Database VMDB structure supplied in @data and sets up
- * the in-memory vmdb structure @vm with the obtained information.
- *
- * N.B.  The *_start, *_size and *_seq values will be range-checked later.
- *
- * Return:  'true'   @vm contains VMDB info
- *          'false'  @vm contents are undefined
- */
-static bool ldm_parse_vmdb (const u8 *data, struct vmdb *vm)
-{
-        BUG_ON (!data || !vm);
-
-        if (MAGIC_VMDB != get_unaligned_be32(data)) {
-                ldm_crit ("Cannot find the VMDB, database may be corrupt.");
-                return false;
-        }
-
-        vm->ver_major = get_unaligned_be16(data + 0x12);
-        vm->ver_minor = get_unaligned_be16(data + 0x14);
-        if ((vm->ver_major != 4) || (vm->ver_minor != 10)) {
-                ldm_error ("Expected VMDB version %d.%d, got %d.%d. "
-                        "Aborting.", 4, 10, vm->ver_major, vm->ver_minor);
-                return false;
-        }
-
-        vm->vblk_size     = get_unaligned_be32(data + 0x08);
-        if (vm->vblk_size == 0) {
-                ldm_error ("Illegal VBLK size");
-                return false;
-        }
-
-        vm->vblk_offset   = get_unaligned_be32(data + 0x0C);
-        vm->last_vblk_seq = get_unaligned_be32(data + 0x04);
-
-        ldm_debug ("Parsed VMDB successfully.");
-        return true;
-}
-
-/**
- * ldm_compare_privheads - Compare two privhead objects
- * @ph1:  First privhead
- * @ph2:  Second privhead
- *
- * This compares the two privhead structures @ph1 and @ph2.
- *
- * Return:  'true'   Identical
- *          'false'  Different
- */
-static bool ldm_compare_privheads (const struct privhead *ph1,
-                                   const struct privhead *ph2)
-{
-        BUG_ON (!ph1 || !ph2);
-
-        return ((ph1->ver_major          == ph2->ver_major)             &&
-                (ph1->ver_minor          == ph2->ver_minor)             &&
-                (ph1->logical_disk_start == ph2->logical_disk_start)    &&
-                (ph1->logical_disk_size  == ph2->logical_disk_size)     &&
-                (ph1->config_start       == ph2->config_start)          &&
-                (ph1->config_size        == ph2->config_size)           &&
-                !memcmp (ph1->disk_id, ph2->disk_id, GUID_SIZE));
-}
-
-/**
- * ldm_compare_tocblocks - Compare two tocblock objects
- * @toc1:  First toc
- * @toc2:  Second toc
- *
- * This compares the two tocblock structures @toc1 and @toc2.
- *
- * Return:  'true'   Identical
- *          'false'  Different
- */
-static bool ldm_compare_tocblocks (const struct tocblock *toc1,
-                                   const struct tocblock *toc2)
-{
-        BUG_ON (!toc1 || !toc2);
-
-        return ((toc1->bitmap1_start == toc2->bitmap1_start)    &&
-                (toc1->bitmap1_size  == toc2->bitmap1_size)     &&
-                (toc1->bitmap2_start == toc2->bitmap2_start)    &&
-                (toc1->bitmap2_size  == toc2->bitmap2_size)     &&
-                !strncmp (toc1->bitmap1_name, toc2->bitmap1_name,
-                        sizeof (toc1->bitmap1_name))            &&
-                !strncmp (toc1->bitmap2_name, toc2->bitmap2_name,
-                        sizeof (toc1->bitmap2_name)));
-}
-
-/**
- * ldm_validate_privheads - Compare the primary privhead with its backups
- * @state: Partition check state including device holding the LDM Database
- * @ph1:   Memory struct to fill with ph contents
- *
- * Read and compare all three privheads from disk.
- *
- * The privheads on disk show the size and location of the main disk area and
- * the configuration area (the database).  The values are range-checked against
- * @hd, which contains the real size of the disk.
- *
- * Return:  'true'   Success
- *          'false'  Error
- */
-static bool ldm_validate_privheads(struct parsed_partitions *state,
-                                   struct privhead *ph1)
-{
-        static const int off[3] = { OFF_PRIV1, OFF_PRIV2, OFF_PRIV3 };
-        struct privhead *ph[3] = { ph1 };
-        Sector sect;
-        u8 *data;
-        bool result = false;
-        long num_sects;
-        int i;
-
-        BUG_ON (!state || !ph1);
-
-        ph[1] = kmalloc (sizeof (*ph[1]), GFP_KERNEL);
-        ph[2] = kmalloc (sizeof (*ph[2]), GFP_KERNEL);
-        if (!ph[1] || !ph[2]) {
-                ldm_crit ("Out of memory.");
-                goto out;
-        }
-
-        /* off[1 & 2] are relative to ph[0]->config_start */
-        ph[0]->config_start = 0;
-
-        /* Read and parse privheads */
-        for (i = 0; i < 3; i++) {
-                data = read_part_sector(state, ph[0]->config_start + off[i],
-                                        &sect);
-                if (!data) {
-                        ldm_crit ("Disk read failed.");
-                        goto out;
-                }
-                result = ldm_parse_privhead (data, ph[i]);
-                put_dev_sector (sect);
-                if (!result) {
-                        ldm_error ("Cannot find PRIVHEAD %d.", i+1); /* Log again */
-                        if (i < 2)
-                                goto out;       /* Already logged */
-                        else
-                                break;  /* FIXME ignore for now, 3rd PH can fail on odd-sized disks */
-                }
-        }
-
-        num_sects = state->bdev->bd_inode->i_size >> 9;
-
-        if ((ph[0]->config_start > num_sects) ||
-           ((ph[0]->config_start + ph[0]->config_size) > num_sects)) {
-                ldm_crit ("Database extends beyond the end of the disk.");
-                goto out;
-        }
-
-        if ((ph[0]->logical_disk_start > ph[0]->config_start) ||
-           ((ph[0]->logical_disk_start + ph[0]->logical_disk_size)
-                    > ph[0]->config_start)) {
-                ldm_crit ("Disk and database overlap.");
-                goto out;
-        }
-
-        if (!ldm_compare_privheads (ph[0], ph[1])) {
-                ldm_crit ("Primary and backup PRIVHEADs don't match.");
-                goto out;
-        }
-        /* FIXME ignore this for now
-        if (!ldm_compare_privheads (ph[0], ph[2])) {
-                ldm_crit ("Primary and backup PRIVHEADs don't match.");
-                goto out;
-        }*/
-        ldm_debug ("Validated PRIVHEADs successfully.");
-        result = true;
-out:
-        kfree (ph[1]);
-        kfree (ph[2]);
-        return result;
-}
-
-/**
- * ldm_validate_tocblocks - Validate the table of contents and its backups
- * @state: Partition check state including device holding the LDM Database
- * @base:  Offset, into @state->bdev, of the database
- * @ldb:   Cache of the database structures
- *
- * Find and compare the four tables of contents of the LDM Database stored on
- * @state->bdev and return the parsed information into @toc1.
- *
- * The offsets and sizes of the configs are range-checked against a privhead.
- *
- * Return:  'true'   @toc1 contains validated TOCBLOCK info
- *          'false'  @toc1 contents are undefined
- */
-static bool ldm_validate_tocblocks(struct parsed_partitions *state,
-                                   unsigned long base, struct ldmdb *ldb)
-{
-        static const int off[4] = { OFF_TOCB1, OFF_TOCB2, OFF_TOCB3, OFF_TOCB4};
-        struct tocblock *tb[4];
-        struct privhead *ph;
-        Sector sect;
-        u8 *data;
-        int i, nr_tbs;
-        bool result = false;
-
-        BUG_ON(!state || !ldb);
-        ph = &ldb->ph;
-        tb[0] = &ldb->toc;
-        tb[1] = kmalloc(sizeof(*tb[1]) * 3, GFP_KERNEL);
-        if (!tb[1]) {
-                ldm_crit("Out of memory.");
-                goto err;
-        }
-        tb[2] = (struct tocblock*)((u8*)tb[1] + sizeof(*tb[1]));
-        tb[3] = (struct tocblock*)((u8*)tb[2] + sizeof(*tb[2]));
-        /*
-         * Try to read and parse all four TOCBLOCKs.
-         *
-         * Windows Vista LDM v2.12 does not always have all four TOCBLOCKs so
-         * skip any that fail as long as we get at least one valid TOCBLOCK.
-         */
-        for (nr_tbs = i = 0; i < 4; i++) {
-                data = read_part_sector(state, base + off[i], &sect);
-                if (!data) {
-                        ldm_error("Disk read failed for TOCBLOCK %d.", i);
-                        continue;
-                }
-                if (ldm_parse_tocblock(data, tb[nr_tbs]))
-                        nr_tbs++;
-                put_dev_sector(sect);
-        }
-        if (!nr_tbs) {
-                ldm_crit("Failed to find a valid TOCBLOCK.");
-                goto err;
-        }
-        /* Range check the TOCBLOCK against a privhead. */
-        if (((tb[0]->bitmap1_start + tb[0]->bitmap1_size) > ph->config_size) ||
-                        ((tb[0]->bitmap2_start + tb[0]->bitmap2_size) >
-                        ph->config_size)) {
-                ldm_crit("The bitmaps are out of range.  Giving up.");
-                goto err;
-        }
-        /* Compare all loaded TOCBLOCKs. */
-        for (i = 1; i < nr_tbs; i++) {
-                if (!ldm_compare_tocblocks(tb[0], tb[i])) {
-                        ldm_crit("TOCBLOCKs 0 and %d do not match.", i);
-                        goto err;
-                }
-        }
-        ldm_debug("Validated %d TOCBLOCKs successfully.", nr_tbs);
-        result = true;
-err:
-        kfree(tb[1]);
-        return result;
-}
-
-/**
- * ldm_validate_vmdb - Read the VMDB and validate it
- * @state: Partition check state including device holding the LDM Database
- * @base:  Offset, into @bdev, of the database
- * @ldb:   Cache of the database structures
- *
- * Find the vmdb of the LDM Database stored on @bdev and return the parsed
- * information in @ldb.
- *
- * Return:  'true'   @ldb contains validated VBDB info
- *          'false'  @ldb contents are undefined
- */
-static bool ldm_validate_vmdb(struct parsed_partitions *state,
-                              unsigned long base, struct ldmdb *ldb)
-{
-        Sector sect;
-        u8 *data;
-        bool result = false;
-        struct vmdb *vm;
-        struct tocblock *toc;
-
-        BUG_ON (!state || !ldb);
-
-        vm  = &ldb->vm;
-        toc = &ldb->toc;
-
-        data = read_part_sector(state, base + OFF_VMDB, &sect);
-        if (!data) {
-                ldm_crit ("Disk read failed.");
-                return false;
-        }
-
-        if (!ldm_parse_vmdb (data, vm))
-                goto out;                               /* Already logged */
-
-        /* Are there uncommitted transactions? */
-        if (get_unaligned_be16(data + 0x10) != 0x01) {
-                ldm_crit ("Database is not in a consistent state.  Aborting.");
-                goto out;
-        }
-
-        if (vm->vblk_offset != 512)
-                ldm_info ("VBLKs start at offset 0x%04x.", vm->vblk_offset);
-
-        /*
-         * The last_vblkd_seq can be before the end of the vmdb, just make sure
-         * it is not out of bounds.
-         */
-        if ((vm->vblk_size * vm->last_vblk_seq) > (toc->bitmap1_size << 9)) {
-                ldm_crit ("VMDB exceeds allowed size specified by TOCBLOCK.  "
-                                "Database is corrupt.  Aborting.");
-                goto out;
-        }
-
-        result = true;
-out:
-        put_dev_sector (sect);
-        return result;
-}
-
-
-/**
- * ldm_validate_partition_table - Determine whether bdev might be a dynamic disk
- * @state: Partition check state including device holding the LDM Database
- *
- * This function provides a weak test to decide whether the device is a dynamic
- * disk or not.  It looks for an MS-DOS-style partition table containing at
- * least one partition of type 0x42 (formerly SFS, now used by Windows for
- * dynamic disks).
- *
- * N.B.  The only possible error can come from the read_part_sector and that is
- *       only likely to happen if the underlying device is strange.  If that IS
- *       the case we should return zero to let someone else try.
- *
- * Return:  'true'   @state->bdev is a dynamic disk
- *          'false'  @state->bdev is not a dynamic disk, or an error occurred
- */
-static bool ldm_validate_partition_table(struct parsed_partitions *state)
-{
-        Sector sect;
-        u8 *data;
-        struct partition *p;
-        int i;
-        bool result = false;
-
-        BUG_ON(!state);
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data) {
-                ldm_info ("Disk read failed.");
-                return false;
-        }
-
-        if (*(__le16*) (data + 0x01FE) != cpu_to_le16 (MSDOS_LABEL_MAGIC))
-                goto out;
-
-        p = (struct partition*)(data + 0x01BE);
-        for (i = 0; i < 4; i++, p++)
-                if (SYS_IND (p) == LDM_PARTITION) {
-                        result = true;
-                        break;
-                }
-
-        if (result)
-                ldm_debug ("Found W2K dynamic disk partition type.");
-
-out:
-        put_dev_sector (sect);
-        return result;
-}
-
-/**
- * ldm_get_disk_objid - Search a linked list of vblk's for a given Disk Id
- * @ldb:  Cache of the database structures
- *
- * The LDM Database contains a list of all partitions on all dynamic disks.
- * The primary PRIVHEAD, at the beginning of the physical disk, tells us
- * the GUID of this disk.  This function searches for the GUID in a linked
- * list of vblk's.
- *
- * Return:  Pointer, A matching vblk was found
- *          NULL,    No match, or an error
- */
-static struct vblk * ldm_get_disk_objid (const struct ldmdb *ldb)
-{
-        struct list_head *item;
-
-        BUG_ON (!ldb);
-
-        list_for_each (item, &ldb->v_disk) {
-                struct vblk *v = list_entry (item, struct vblk, list);
-                if (!memcmp (v->vblk.disk.disk_id, ldb->ph.disk_id, GUID_SIZE))
-                        return v;
-        }
-
-        return NULL;
-}
-
-/**
- * ldm_create_data_partitions - Create data partitions for this device
- * @pp:   List of the partitions parsed so far
- * @ldb:  Cache of the database structures
- *
- * The database contains ALL the partitions for ALL disk groups, so we need to
- * filter out this specific disk. Using the disk's object id, we can find all
- * the partitions in the database that belong to this disk.
- *
- * Add each partition in our database, to the parsed_partitions structure.
- *
- * N.B.  This function creates the partitions in the order it finds partition
- *       objects in the linked list.
- *
- * Return:  'true'   Partition created
- *          'false'  Error, probably a range checking problem
- */
-static bool ldm_create_data_partitions (struct parsed_partitions *pp,
-                                        const struct ldmdb *ldb)
-{
-        struct list_head *item;
-        struct vblk *vb;
-        struct vblk *disk;
-        struct vblk_part *part;
-        int part_num = 1;
-
-        BUG_ON (!pp || !ldb);
-
-        disk = ldm_get_disk_objid (ldb);
-        if (!disk) {
-                ldm_crit ("Can't find the ID of this disk in the database.");
-                return false;
-        }
-
-        strlcat(pp->pp_buf, " [LDM]", PAGE_SIZE);
-
-        /* Create the data partitions */
-        list_for_each (item, &ldb->v_part) {
-                vb = list_entry (item, struct vblk, list);
-                part = &vb->vblk.part;
-
-                if (part->disk_id != disk->obj_id)
-                        continue;
-
-                put_partition (pp, part_num, ldb->ph.logical_disk_start +
-                                part->start, part->size);
-                part_num++;
-        }
-
-        strlcat(pp->pp_buf, "\n", PAGE_SIZE);
-        return true;
-}
-
-
-/**
- * ldm_relative - Calculate the next relative offset
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @base:    Size of the previous fixed width fields
- * @offset:  Cumulative size of the previous variable-width fields
- *
- * Because many of the VBLK fields are variable-width, it's necessary
- * to calculate each offset based on the previous one and the length
- * of the field it pointed to.
- *
- * Return:  -1 Error, the calculated offset exceeded the size of the buffer
- *           n OK, a range-checked offset into buffer
- */
-static int ldm_relative(const u8 *buffer, int buflen, int base, int offset)
-{
-
-        base += offset;
-        if (!buffer || offset < 0 || base > buflen) {
-                if (!buffer)
-                        ldm_error("!buffer");
-                if (offset < 0)
-                        ldm_error("offset (%d) < 0", offset);
-                if (base > buflen)
-                        ldm_error("base (%d) > buflen (%d)", base, buflen);
-                return -1;
-        }
-        if (base + buffer[base] >= buflen) {
-                ldm_error("base (%d) + buffer[base] (%d) >= buflen (%d)", base,
-                                buffer[base], buflen);
-                return -1;
-        }
-        return buffer[base] + offset + 1;
-}
-
-/**
- * ldm_get_vnum - Convert a variable-width, big endian number, into cpu order
- * @block:  Pointer to the variable-width number to convert
- *
- * Large numbers in the LDM Database are often stored in a packed format.  Each
- * number is prefixed by a one byte width marker.  All numbers in the database
- * are stored in big-endian byte order.  This function reads one of these
- * numbers and returns the result
- *
- * N.B.  This function DOES NOT perform any range checking, though the most
- *       it will read is eight bytes.
- *
- * Return:  n A number
- *          0 Zero, or an error occurred
- */
-static u64 ldm_get_vnum (const u8 *block)
-{
-        u64 tmp = 0;
-        u8 length;
-
-        BUG_ON (!block);
-
-        length = *block++;
-
-        if (length && length <= 8)
-                while (length--)
-                        tmp = (tmp << 8) | *block++;
-        else
-                ldm_error ("Illegal length %d.", length);
-
-        return tmp;
-}
-
-/**
- * ldm_get_vstr - Read a length-prefixed string into a buffer
- * @block:   Pointer to the length marker
- * @buffer:  Location to copy string to
- * @buflen:  Size of the output buffer
- *
- * Many of the strings in the LDM Database are not NULL terminated.  Instead
- * they are prefixed by a one byte length marker.  This function copies one of
- * these strings into a buffer.
- *
- * N.B.  This function DOES NOT perform any range checking on the input.
- *       If the buffer is too small, the output will be truncated.
- *
- * Return:  0, Error and @buffer contents are undefined
- *          n, String length in characters (excluding NULL)
- *          buflen-1, String was truncated.
- */
-static int ldm_get_vstr (const u8 *block, u8 *buffer, int buflen)
-{
-        int length;
-
-        BUG_ON (!block || !buffer);
-
-        length = block[0];
-        if (length >= buflen) {
-                ldm_error ("Truncating string %d -> %d.", length, buflen);
-                length = buflen - 1;
-        }
-        memcpy (buffer, block + 1, length);
-        buffer[length] = 0;
-        return length;
-}
-
-
-/**
- * ldm_parse_cmp3 - Read a raw VBLK Component object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Component object (version 3) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Component VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_cmp3 (const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, r_vstate, r_child, r_parent, r_stripe, r_cols, len;
-        struct vblk_comp *comp;
-
-        BUG_ON (!buffer || !vb);
-
-        r_objid  = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name   = ldm_relative (buffer, buflen, 0x18, r_objid);
-        r_vstate = ldm_relative (buffer, buflen, 0x18, r_name);
-        r_child  = ldm_relative (buffer, buflen, 0x1D, r_vstate);
-        r_parent = ldm_relative (buffer, buflen, 0x2D, r_child);
-
-        if (buffer[0x12] & VBLK_FLAG_COMP_STRIPE) {
-                r_stripe = ldm_relative (buffer, buflen, 0x2E, r_parent);
-                r_cols   = ldm_relative (buffer, buflen, 0x2E, r_stripe);
-                len = r_cols;
-        } else {
-                r_stripe = 0;
-                r_cols   = 0;
-                len = r_parent;
-        }
-        if (len < 0)
-                return false;
-
-        len += VBLK_SIZE_CMP3;
-        if (len != get_unaligned_be32(buffer + 0x14))
-                return false;
-
-        comp = &vb->vblk.comp;
-        ldm_get_vstr (buffer + 0x18 + r_name, comp->state,
-                sizeof (comp->state));
-        comp->type      = buffer[0x18 + r_vstate];
-        comp->children  = ldm_get_vnum (buffer + 0x1D + r_vstate);
-        comp->parent_id = ldm_get_vnum (buffer + 0x2D + r_child);
-        comp->chunksize = r_stripe ? ldm_get_vnum (buffer+r_parent+0x2E) : 0;
-
-        return true;
-}
-
-/**
- * ldm_parse_dgr3 - Read a raw VBLK Disk Group object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Disk Group object (version 3) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Disk Group VBLK
- *          'false'  @vb contents are not defined
- */
-static int ldm_parse_dgr3 (const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, r_diskid, r_id1, r_id2, len;
-        struct vblk_dgrp *dgrp;
-
-        BUG_ON (!buffer || !vb);
-
-        r_objid  = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name   = ldm_relative (buffer, buflen, 0x18, r_objid);
-        r_diskid = ldm_relative (buffer, buflen, 0x18, r_name);
-
-        if (buffer[0x12] & VBLK_FLAG_DGR3_IDS) {
-                r_id1 = ldm_relative (buffer, buflen, 0x24, r_diskid);
-                r_id2 = ldm_relative (buffer, buflen, 0x24, r_id1);
-                len = r_id2;
-        } else {
-                r_id1 = 0;
-                r_id2 = 0;
-                len = r_diskid;
-        }
-        if (len < 0)
-                return false;
-
-        len += VBLK_SIZE_DGR3;
-        if (len != get_unaligned_be32(buffer + 0x14))
-                return false;
-
-        dgrp = &vb->vblk.dgrp;
-        ldm_get_vstr (buffer + 0x18 + r_name, dgrp->disk_id,
-                sizeof (dgrp->disk_id));
-        return true;
-}
-
-/**
- * ldm_parse_dgr4 - Read a raw VBLK Disk Group object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Disk Group object (version 4) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Disk Group VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_dgr4 (const u8 *buffer, int buflen, struct vblk *vb)
-{
-        char buf[64];
-        int r_objid, r_name, r_id1, r_id2, len;
-        struct vblk_dgrp *dgrp;
-
-        BUG_ON (!buffer || !vb);
-
-        r_objid  = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name   = ldm_relative (buffer, buflen, 0x18, r_objid);
-
-        if (buffer[0x12] & VBLK_FLAG_DGR4_IDS) {
-                r_id1 = ldm_relative (buffer, buflen, 0x44, r_name);
-                r_id2 = ldm_relative (buffer, buflen, 0x44, r_id1);
-                len = r_id2;
-        } else {
-                r_id1 = 0;
-                r_id2 = 0;
-                len = r_name;
-        }
-        if (len < 0)
-                return false;
-
-        len += VBLK_SIZE_DGR4;
-        if (len != get_unaligned_be32(buffer + 0x14))
-                return false;
-
-        dgrp = &vb->vblk.dgrp;
-
-        ldm_get_vstr (buffer + 0x18 + r_objid, buf, sizeof (buf));
-        return true;
-}
-
-/**
- * ldm_parse_dsk3 - Read a raw VBLK Disk object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Disk object (version 3) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Disk VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_dsk3 (const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, r_diskid, r_altname, len;
-        struct vblk_disk *disk;
-
-        BUG_ON (!buffer || !vb);
-
-        r_objid   = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name    = ldm_relative (buffer, buflen, 0x18, r_objid);
-        r_diskid  = ldm_relative (buffer, buflen, 0x18, r_name);
-        r_altname = ldm_relative (buffer, buflen, 0x18, r_diskid);
-        len = r_altname;
-        if (len < 0)
-                return false;
-
-        len += VBLK_SIZE_DSK3;
-        if (len != get_unaligned_be32(buffer + 0x14))
-                return false;
-
-        disk = &vb->vblk.disk;
-        ldm_get_vstr (buffer + 0x18 + r_diskid, disk->alt_name,
-                sizeof (disk->alt_name));
-        if (!ldm_parse_guid (buffer + 0x19 + r_name, disk->disk_id))
-                return false;
-
-        return true;
-}
-
-/**
- * ldm_parse_dsk4 - Read a raw VBLK Disk object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Disk object (version 4) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Disk VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_dsk4 (const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, len;
-        struct vblk_disk *disk;
-
-        BUG_ON (!buffer || !vb);
-
-        r_objid = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name  = ldm_relative (buffer, buflen, 0x18, r_objid);
-        len     = r_name;
-        if (len < 0)
-                return false;
-
-        len += VBLK_SIZE_DSK4;
-        if (len != get_unaligned_be32(buffer + 0x14))
-                return false;
-
-        disk = &vb->vblk.disk;
-        memcpy (disk->disk_id, buffer + 0x18 + r_name, GUID_SIZE);
-        return true;
-}
-
-/**
- * ldm_parse_prt3 - Read a raw VBLK Partition object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Partition object (version 3) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Partition VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_prt3(const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, r_size, r_parent, r_diskid, r_index, len;
-        struct vblk_part *part;
-
-        BUG_ON(!buffer || !vb);
-        r_objid = ldm_relative(buffer, buflen, 0x18, 0);
-        if (r_objid < 0) {
-                ldm_error("r_objid %d < 0", r_objid);
-                return false;
-        }
-        r_name = ldm_relative(buffer, buflen, 0x18, r_objid);
-        if (r_name < 0) {
-                ldm_error("r_name %d < 0", r_name);
-                return false;
-        }
-        r_size = ldm_relative(buffer, buflen, 0x34, r_name);
-        if (r_size < 0) {
-                ldm_error("r_size %d < 0", r_size);
-                return false;
-        }
-        r_parent = ldm_relative(buffer, buflen, 0x34, r_size);
-        if (r_parent < 0) {
-                ldm_error("r_parent %d < 0", r_parent);
-                return false;
-        }
-        r_diskid = ldm_relative(buffer, buflen, 0x34, r_parent);
-        if (r_diskid < 0) {
-                ldm_error("r_diskid %d < 0", r_diskid);
-                return false;
-        }
-        if (buffer[0x12] & VBLK_FLAG_PART_INDEX) {
-                r_index = ldm_relative(buffer, buflen, 0x34, r_diskid);
-                if (r_index < 0) {
-                        ldm_error("r_index %d < 0", r_index);
-                        return false;
-                }
-                len = r_index;
-        } else {
-                r_index = 0;
-                len = r_diskid;
-        }
-        if (len < 0) {
-                ldm_error("len %d < 0", len);
-                return false;
-        }
-        len += VBLK_SIZE_PRT3;
-        if (len > get_unaligned_be32(buffer + 0x14)) {
-                ldm_error("len %d > BE32(buffer + 0x14) %d", len,
-                                get_unaligned_be32(buffer + 0x14));
-                return false;
-        }
-        part = &vb->vblk.part;
-        part->start = get_unaligned_be64(buffer + 0x24 + r_name);
-        part->volume_offset = get_unaligned_be64(buffer + 0x2C + r_name);
-        part->size = ldm_get_vnum(buffer + 0x34 + r_name);
-        part->parent_id = ldm_get_vnum(buffer + 0x34 + r_size);
-        part->disk_id = ldm_get_vnum(buffer + 0x34 + r_parent);
-        if (vb->flags & VBLK_FLAG_PART_INDEX)
-                part->partnum = buffer[0x35 + r_diskid];
-        else
-                part->partnum = 0;
-        return true;
-}
-
-/**
- * ldm_parse_vol5 - Read a raw VBLK Volume object into a vblk structure
- * @buffer:  Block of data being worked on
- * @buflen:  Size of the block of data
- * @vb:      In-memory vblk in which to return information
- *
- * Read a raw VBLK Volume object (version 5) into a vblk structure.
- *
- * Return:  'true'   @vb contains a Volume VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_vol5(const u8 *buffer, int buflen, struct vblk *vb)
-{
-        int r_objid, r_name, r_vtype, r_disable_drive_letter, r_child, r_size;
-        int r_id1, r_id2, r_size2, r_drive, len;
-        struct vblk_volu *volu;
-
-        BUG_ON(!buffer || !vb);
-        r_objid = ldm_relative(buffer, buflen, 0x18, 0);
-        if (r_objid < 0) {
-                ldm_error("r_objid %d < 0", r_objid);
-                return false;
-        }
-        r_name = ldm_relative(buffer, buflen, 0x18, r_objid);
-        if (r_name < 0) {
-                ldm_error("r_name %d < 0", r_name);
-                return false;
-        }
-        r_vtype = ldm_relative(buffer, buflen, 0x18, r_name);
-        if (r_vtype < 0) {
-                ldm_error("r_vtype %d < 0", r_vtype);
-                return false;
-        }
-        r_disable_drive_letter = ldm_relative(buffer, buflen, 0x18, r_vtype);
-        if (r_disable_drive_letter < 0) {
-                ldm_error("r_disable_drive_letter %d < 0",
-                                r_disable_drive_letter);
-                return false;
-        }
-        r_child = ldm_relative(buffer, buflen, 0x2D, r_disable_drive_letter);
-        if (r_child < 0) {
-                ldm_error("r_child %d < 0", r_child);
-                return false;
-        }
-        r_size = ldm_relative(buffer, buflen, 0x3D, r_child);
-        if (r_size < 0) {
-                ldm_error("r_size %d < 0", r_size);
-                return false;
-        }
-        if (buffer[0x12] & VBLK_FLAG_VOLU_ID1) {
-                r_id1 = ldm_relative(buffer, buflen, 0x52, r_size);
-                if (r_id1 < 0) {
-                        ldm_error("r_id1 %d < 0", r_id1);
-                        return false;
-                }
-        } else
-                r_id1 = r_size;
-        if (buffer[0x12] & VBLK_FLAG_VOLU_ID2) {
-                r_id2 = ldm_relative(buffer, buflen, 0x52, r_id1);
-                if (r_id2 < 0) {
-                        ldm_error("r_id2 %d < 0", r_id2);
-                        return false;
-                }
-        } else
-                r_id2 = r_id1;
-        if (buffer[0x12] & VBLK_FLAG_VOLU_SIZE) {
-                r_size2 = ldm_relative(buffer, buflen, 0x52, r_id2);
-                if (r_size2 < 0) {
-                        ldm_error("r_size2 %d < 0", r_size2);
-                        return false;
-                }
-        } else
-                r_size2 = r_id2;
-        if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) {
-                r_drive = ldm_relative(buffer, buflen, 0x52, r_size2);
-                if (r_drive < 0) {
-                        ldm_error("r_drive %d < 0", r_drive);
-                        return false;
-                }
-        } else
-                r_drive = r_size2;
-        len = r_drive;
-        if (len < 0) {
-                ldm_error("len %d < 0", len);
-                return false;
-        }
-        len += VBLK_SIZE_VOL5;
-        if (len > get_unaligned_be32(buffer + 0x14)) {
-                ldm_error("len %d > BE32(buffer + 0x14) %d", len,
-                                get_unaligned_be32(buffer + 0x14));
-                return false;
-        }
-        volu = &vb->vblk.volu;
-        ldm_get_vstr(buffer + 0x18 + r_name, volu->volume_type,
-                        sizeof(volu->volume_type));
-        memcpy(volu->volume_state, buffer + 0x18 + r_disable_drive_letter,
-                        sizeof(volu->volume_state));
-        volu->size = ldm_get_vnum(buffer + 0x3D + r_child);
-        volu->partition_type = buffer[0x41 + r_size];
-        memcpy(volu->guid, buffer + 0x42 + r_size, sizeof(volu->guid));
-        if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) {
-                ldm_get_vstr(buffer + 0x52 + r_size, volu->drive_hint,
-                                sizeof(volu->drive_hint));
-        }
-        return true;
-}
-
-/**
- * ldm_parse_vblk - Read a raw VBLK object into a vblk structure
- * @buf:  Block of data being worked on
- * @len:  Size of the block of data
- * @vb:   In-memory vblk in which to return information
- *
- * Read a raw VBLK object into a vblk structure.  This function just reads the
- * information common to all VBLK types, then delegates the rest of the work to
- * helper functions: ldm_parse_*.
- *
- * Return:  'true'   @vb contains a VBLK
- *          'false'  @vb contents are not defined
- */
-static bool ldm_parse_vblk (const u8 *buf, int len, struct vblk *vb)
-{
-        bool result = false;
-        int r_objid;
-
-        BUG_ON (!buf || !vb);
-
-        r_objid = ldm_relative (buf, len, 0x18, 0);
-        if (r_objid < 0) {
-                ldm_error ("VBLK header is corrupt.");
-                return false;
-        }
-
-        vb->flags  = buf[0x12];
-        vb->type   = buf[0x13];
-        vb->obj_id = ldm_get_vnum (buf + 0x18);
-        ldm_get_vstr (buf+0x18+r_objid, vb->name, sizeof (vb->name));
-
-        switch (vb->type) {
-                case VBLK_CMP3:  result = ldm_parse_cmp3 (buf, len, vb); break;
-                case VBLK_DSK3:  result = ldm_parse_dsk3 (buf, len, vb); break;
-                case VBLK_DSK4:  result = ldm_parse_dsk4 (buf, len, vb); break;
-                case VBLK_DGR3:  result = ldm_parse_dgr3 (buf, len, vb); break;
-                case VBLK_DGR4:  result = ldm_parse_dgr4 (buf, len, vb); break;
-                case VBLK_PRT3:  result = ldm_parse_prt3 (buf, len, vb); break;
-                case VBLK_VOL5:  result = ldm_parse_vol5 (buf, len, vb); break;
-        }
-
-        if (result)
-                ldm_debug ("Parsed VBLK 0x%llx (type: 0x%02x) ok.",
-                         (unsigned long long) vb->obj_id, vb->type);
-        else
-                ldm_error ("Failed to parse VBLK 0x%llx (type: 0x%02x).",
-                        (unsigned long long) vb->obj_id, vb->type);
-
-        return result;
-}
-
-
-/**
- * ldm_ldmdb_add - Adds a raw VBLK entry to the ldmdb database
- * @data:  Raw VBLK to add to the database
- * @len:   Size of the raw VBLK
- * @ldb:   Cache of the database structures
- *
- * The VBLKs are sorted into categories.  Partitions are also sorted by offset.
- *
- * N.B.  This function does not check the validity of the VBLKs.
- *
- * Return:  'true'   The VBLK was added
- *          'false'  An error occurred
- */
-static bool ldm_ldmdb_add (u8 *data, int len, struct ldmdb *ldb)
-{
-        struct vblk *vb;
-        struct list_head *item;
-
-        BUG_ON (!data || !ldb);
-
-        vb = kmalloc (sizeof (*vb), GFP_KERNEL);
-        if (!vb) {
-                ldm_crit ("Out of memory.");
-                return false;
-        }
-
-        if (!ldm_parse_vblk (data, len, vb)) {
-                kfree(vb);
-                return false;                   /* Already logged */
-        }
-
-        /* Put vblk into the correct list. */
-        switch (vb->type) {
-        case VBLK_DGR3:
-        case VBLK_DGR4:
-                list_add (&vb->list, &ldb->v_dgrp);
-                break;
-        case VBLK_DSK3:
-        case VBLK_DSK4:
-                list_add (&vb->list, &ldb->v_disk);
-                break;
-        case VBLK_VOL5:
-                list_add (&vb->list, &ldb->v_volu);
-                break;
-        case VBLK_CMP3:
-                list_add (&vb->list, &ldb->v_comp);
-                break;
-        case VBLK_PRT3:
-                /* Sort by the partition's start sector. */
-                list_for_each (item, &ldb->v_part) {
-                        struct vblk *v = list_entry (item, struct vblk, list);
-                        if ((v->vblk.part.disk_id == vb->vblk.part.disk_id) &&
-                            (v->vblk.part.start > vb->vblk.part.start)) {
-                                list_add_tail (&vb->list, &v->list);
-                                return true;
-                        }
-                }
-                list_add_tail (&vb->list, &ldb->v_part);
-                break;
-        }
-        return true;
-}
-
-/**
- * ldm_frag_add - Add a VBLK fragment to a list
- * @data:   Raw fragment to be added to the list
- * @size:   Size of the raw fragment
- * @frags:  Linked list of VBLK fragments
- *
- * Fragmented VBLKs may not be consecutive in the database, so they are placed
- * in a list so they can be pieced together later.
- *
- * Return:  'true'   Success, the VBLK was added to the list
- *          'false'  Error, a problem occurred
- */
-static bool ldm_frag_add (const u8 *data, int size, struct list_head *frags)
-{
-        struct frag *f;
-        struct list_head *item;
-        int rec, num, group;
-
-        BUG_ON (!data || !frags);
-
-        if (size < 2 * VBLK_SIZE_HEAD) {
-                ldm_error("Value of size is to small.");
-                return false;
-        }
-
-        group = get_unaligned_be32(data + 0x08);
-        rec   = get_unaligned_be16(data + 0x0C);
-        num   = get_unaligned_be16(data + 0x0E);
-        if ((num < 1) || (num > 4)) {
-                ldm_error ("A VBLK claims to have %d parts.", num);
-                return false;
-        }
-        if (rec >= num) {
-                ldm_error("REC value (%d) exceeds NUM value (%d)", rec, num);
-                return false;
-        }
-
-        list_for_each (item, frags) {
-                f = list_entry (item, struct frag, list);
-                if (f->group == group)
-                        goto found;
-        }
-
-        f = kmalloc (sizeof (*f) + size*num, GFP_KERNEL);
-        if (!f) {
-                ldm_crit ("Out of memory.");
-                return false;
-        }
-
-        f->group = group;
-        f->num   = num;
-        f->rec   = rec;
-        f->map   = 0xFF << num;
-
-        list_add_tail (&f->list, frags);
-found:
-        if (rec >= f->num) {
-                ldm_error("REC value (%d) exceeds NUM value (%d)", rec, f->num);
-                return false;
-        }
-
-        if (f->map & (1 << rec)) {
-                ldm_error ("Duplicate VBLK, part %d.", rec);
-                f->map &= 0x7F;                 /* Mark the group as broken */
-                return false;
-        }
-
-        f->map |= (1 << rec);
-
-        data += VBLK_SIZE_HEAD;
-        size -= VBLK_SIZE_HEAD;
-
-        memcpy (f->data+rec*(size-VBLK_SIZE_HEAD)+VBLK_SIZE_HEAD, data, size);
-
-        return true;
-}
-
-/**
- * ldm_frag_free - Free a linked list of VBLK fragments
- * @list:  Linked list of fragments
- *
- * Free a linked list of VBLK fragments
- *
- * Return:  none
- */
-static void ldm_frag_free (struct list_head *list)
-{
-        struct list_head *item, *tmp;
-
-        BUG_ON (!list);
-
-        list_for_each_safe (item, tmp, list)
-                kfree (list_entry (item, struct frag, list));
-}
-
-/**
- * ldm_frag_commit - Validate fragmented VBLKs and add them to the database
- * @frags:  Linked list of VBLK fragments
- * @ldb:    Cache of the database structures
- *
- * Now that all the fragmented VBLKs have been collected, they must be added to
- * the database for later use.
- *
- * Return:  'true'   All the fragments we added successfully
- *          'false'  One or more of the fragments we invalid
- */
-static bool ldm_frag_commit (struct list_head *frags, struct ldmdb *ldb)
-{
-        struct frag *f;
-        struct list_head *item;
-
-        BUG_ON (!frags || !ldb);
-
-        list_for_each (item, frags) {
-                f = list_entry (item, struct frag, list);
-
-                if (f->map != 0xFF) {
-                        ldm_error ("VBLK group %d is incomplete (0x%02x).",
-                                f->group, f->map);
-                        return false;
-                }
-
-                if (!ldm_ldmdb_add (f->data, f->num*ldb->vm.vblk_size, ldb))
-                        return false;           /* Already logged */
-        }
-        return true;
-}
-
-/**
- * ldm_get_vblks - Read the on-disk database of VBLKs into memory
- * @state: Partition check state including device holding the LDM Database
- * @base:  Offset, into @state->bdev, of the database
- * @ldb:   Cache of the database structures
- *
- * To use the information from the VBLKs, they need to be read from the disk,
- * unpacked and validated.  We cache them in @ldb according to their type.
- *
- * Return:  'true'   All the VBLKs were read successfully
- *          'false'  An error occurred
- */
-static bool ldm_get_vblks(struct parsed_partitions *state, unsigned long base,
-                          struct ldmdb *ldb)
-{
-        int size, perbuf, skip, finish, s, v, recs;
-        u8 *data = NULL;
-        Sector sect;
-        bool result = false;
-        LIST_HEAD (frags);
-
-        BUG_ON(!state || !ldb);
-
-        size   = ldb->vm.vblk_size;
-        perbuf = 512 / size;
-        skip   = ldb->vm.vblk_offset >> 9;              /* Bytes to sectors */
-        finish = (size * ldb->vm.last_vblk_seq) >> 9;
-
-        for (s = skip; s < finish; s++) {               /* For each sector */
-                data = read_part_sector(state, base + OFF_VMDB + s, &sect);
-                if (!data) {
-                        ldm_crit ("Disk read failed.");
-                        goto out;
-                }
-
-                for (v = 0; v < perbuf; v++, data+=size) {  /* For each vblk */
-                        if (MAGIC_VBLK != get_unaligned_be32(data)) {
-                                ldm_error ("Expected to find a VBLK.");
-                                goto out;
-                        }
-
-                        recs = get_unaligned_be16(data + 0x0E); /* Number of records */
-                        if (recs == 1) {
-                                if (!ldm_ldmdb_add (data, size, ldb))
-                                        goto out;       /* Already logged */
-                        } else if (recs > 1) {
-                                if (!ldm_frag_add (data, size, &frags))
-                                        goto out;       /* Already logged */
-                        }
-                        /* else Record is not in use, ignore it. */
-                }
-                put_dev_sector (sect);
-                data = NULL;
-        }
-
-        result = ldm_frag_commit (&frags, ldb); /* Failures, already logged */
-out:
-        if (data)
-                put_dev_sector (sect);
-        ldm_frag_free (&frags);
-
-        return result;
-}
-
-/**
- * ldm_free_vblks - Free a linked list of vblk's
- * @lh:  Head of a linked list of struct vblk
- *
- * Free a list of vblk's and free the memory used to maintain the list.
- *
- * Return:  none
- */
-static void ldm_free_vblks (struct list_head *lh)
-{
-        struct list_head *item, *tmp;
-
-        BUG_ON (!lh);
-
-        list_for_each_safe (item, tmp, lh)
-                kfree (list_entry (item, struct vblk, list));
-}
-
-
-/**
- * ldm_partition - Find out whether a device is a dynamic disk and handle it
- * @state: Partition check state including device holding the LDM Database
- *
- * This determines whether the device @bdev is a dynamic disk and if so creates
- * the partitions necessary in the gendisk structure pointed to by @hd.
- *
- * We create a dummy device 1, which contains the LDM database, and then create
- * each partition described by the LDM database in sequence as devices 2+. For
- * example, if the device is hda, we would have: hda1: LDM database, hda2, hda3,
- * and so on: the actual data containing partitions.
- *
- * Return:  1 Success, @state->bdev is a dynamic disk and we handled it
- *          0 Success, @state->bdev is not a dynamic disk
- *         -1 An error occurred before enough information had been read
- *            Or @state->bdev is a dynamic disk, but it may be corrupted
- */
-int ldm_partition(struct parsed_partitions *state)
-{
-        struct ldmdb  *ldb;
-        unsigned long base;
-        int result = -1;
-
-        BUG_ON(!state);
-
-        /* Look for signs of a Dynamic Disk */
-        if (!ldm_validate_partition_table(state))
-                return 0;
-
-        ldb = kmalloc (sizeof (*ldb), GFP_KERNEL);
-        if (!ldb) {
-                ldm_crit ("Out of memory.");
-                goto out;
-        }
-
-        /* Parse and check privheads. */
-        if (!ldm_validate_privheads(state, &ldb->ph))
-                goto out;               /* Already logged */
-
-        /* All further references are relative to base (database start). */
-        base = ldb->ph.config_start;
-
-        /* Parse and check tocs and vmdb. */
-        if (!ldm_validate_tocblocks(state, base, ldb) ||
-            !ldm_validate_vmdb(state, base, ldb))
-                goto out;               /* Already logged */
-
-        /* Initialize vblk lists in ldmdb struct */
-        INIT_LIST_HEAD (&ldb->v_dgrp);
-        INIT_LIST_HEAD (&ldb->v_disk);
-        INIT_LIST_HEAD (&ldb->v_volu);
-        INIT_LIST_HEAD (&ldb->v_comp);
-        INIT_LIST_HEAD (&ldb->v_part);
-
-        if (!ldm_get_vblks(state, base, ldb)) {
-                ldm_crit ("Failed to read the VBLKs from the database.");
-                goto cleanup;
-        }
-
-        /* Finally, create the data partition devices. */
-        if (ldm_create_data_partitions(state, ldb)) {
-                ldm_debug ("Parsed LDM database successfully.");
-                result = 1;
-        }
-        /* else Already logged */
-
-cleanup:
-        ldm_free_vblks (&ldb->v_dgrp);
-        ldm_free_vblks (&ldb->v_disk);
-        ldm_free_vblks (&ldb->v_volu);
-        ldm_free_vblks (&ldb->v_comp);
-        ldm_free_vblks (&ldb->v_part);
-out:
-        kfree (ldb);
-        return result;
-}
diff --git a/fs/partitions/ldm.h b/fs/partitions/ldm.h
deleted file mode 100644
index 374242c0971a..000000000000
--- a/fs/partitions/ldm.h
+++ /dev/null
@@ -1,215 +0,0 @@
-/**
- * ldm - Part of the Linux-NTFS project.
- *
- * Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org>
- * Copyright (c) 2001-2007 Anton Altaparmakov
- * Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com>
- *
- * Documentation is available at http://www.linux-ntfs.org/doku.php?id=downloads 
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program (in the main directory of the Linux-NTFS source
- * in the file COPYING); if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef _FS_PT_LDM_H_
-#define _FS_PT_LDM_H_
-
-#include <linux/types.h>
-#include <linux/list.h>
-#include <linux/genhd.h>
-#include <linux/fs.h>
-#include <asm/unaligned.h>
-#include <asm/byteorder.h>
-
-struct parsed_partitions;
-
-/* Magic numbers in CPU format. */
-#define MAGIC_VMDB      0x564D4442              /* VMDB */
-#define MAGIC_VBLK      0x56424C4B              /* VBLK */
-#define MAGIC_PRIVHEAD  0x5052495648454144ULL   /* PRIVHEAD */
-#define MAGIC_TOCBLOCK  0x544F43424C4F434BULL   /* TOCBLOCK */
-
-/* The defined vblk types. */
-#define VBLK_VOL5               0x51            /* Volume,     version 5 */
-#define VBLK_CMP3               0x32            /* Component,  version 3 */
-#define VBLK_PRT3               0x33            /* Partition,  version 3 */
-#define VBLK_DSK3               0x34            /* Disk,       version 3 */
-#define VBLK_DSK4               0x44            /* Disk,       version 4 */
-#define VBLK_DGR3               0x35            /* Disk Group, version 3 */
-#define VBLK_DGR4               0x45            /* Disk Group, version 4 */
-
-/* vblk flags indicating extra information will be present */
-#define VBLK_FLAG_COMP_STRIPE   0x10
-#define VBLK_FLAG_PART_INDEX    0x08
-#define VBLK_FLAG_DGR3_IDS      0x08
-#define VBLK_FLAG_DGR4_IDS      0x08
-#define VBLK_FLAG_VOLU_ID1      0x08
-#define VBLK_FLAG_VOLU_ID2      0x20
-#define VBLK_FLAG_VOLU_SIZE     0x80
-#define VBLK_FLAG_VOLU_DRIVE    0x02
-
-/* size of a vblk's static parts */
-#define VBLK_SIZE_HEAD          16
-#define VBLK_SIZE_CMP3          22              /* Name and version */
-#define VBLK_SIZE_DGR3          12
-#define VBLK_SIZE_DGR4          44
-#define VBLK_SIZE_DSK3          12
-#define VBLK_SIZE_DSK4          45
-#define VBLK_SIZE_PRT3          28
-#define VBLK_SIZE_VOL5          58
-
-/* component types */
-#define COMP_STRIPE             0x01            /* Stripe-set */
-#define COMP_BASIC              0x02            /* Basic disk */
-#define COMP_RAID               0x03            /* Raid-set */
-
-/* Other constants. */
-#define LDM_DB_SIZE             2048            /* Size in sectors (= 1MiB). */
-
-#define OFF_PRIV1               6               /* Offset of the first privhead
-                                                   relative to the start of the
-                                                   device in sectors */
-
-/* Offsets to structures within the LDM Database in sectors. */
-#define OFF_PRIV2               1856            /* Backup private headers. */
-#define OFF_PRIV3               2047
-
-#define OFF_TOCB1               1               /* Tables of contents. */
-#define OFF_TOCB2               2
-#define OFF_TOCB3               2045
-#define OFF_TOCB4               2046
-
-#define OFF_VMDB                17              /* List of partitions. */
-
-#define LDM_PARTITION           0x42            /* Formerly SFS (Landis). */
-
-#define TOC_BITMAP1             "config"        /* Names of the two defined */
-#define TOC_BITMAP2             "log"           /* bitmaps in the TOCBLOCK. */
-
-/* Borrowed from msdos.c */
-#define SYS_IND(p)              (get_unaligned(&(p)->sys_ind))
-
-struct frag {                           /* VBLK Fragment handling */
-        struct list_head list;
-        u32             group;
-        u8              num;            /* Total number of records */
-        u8              rec;            /* This is record number n */
-        u8              map;            /* Which portions are in use */
-        u8              data[0];
-};
-
-/* In memory LDM database structures. */
-
-#define GUID_SIZE               16
-
-struct privhead {                       /* Offsets and sizes are in sectors. */
-        u16     ver_major;
-        u16     ver_minor;
-        u64     logical_disk_start;
-        u64     logical_disk_size;
-        u64     config_start;
-        u64     config_size;
-        u8      disk_id[GUID_SIZE];
-};
-
-struct tocblock {                       /* We have exactly two bitmaps. */
-        u8      bitmap1_name[16];
-        u64     bitmap1_start;
-        u64     bitmap1_size;
-        u8      bitmap2_name[16];
-        u64     bitmap2_start;
-        u64     bitmap2_size;
-};
-
-struct vmdb {                           /* VMDB: The database header */
-        u16     ver_major;
-        u16     ver_minor;
-        u32     vblk_size;
-        u32     vblk_offset;
-        u32     last_vblk_seq;
-};
-
-struct vblk_comp {                      /* VBLK Component */
-        u8      state[16];
-        u64     parent_id;
-        u8      type;
-        u8      children;
-        u16     chunksize;
-};
-
-struct vblk_dgrp {                      /* VBLK Disk Group */
-        u8      disk_id[64];
-};
-
-struct vblk_disk {                      /* VBLK Disk */
-        u8      disk_id[GUID_SIZE];
-        u8      alt_name[128];
-};
-
-struct vblk_part {                      /* VBLK Partition */
-        u64     start;
-        u64     size;                   /* start, size and vol_off in sectors */
-        u64     volume_offset;
-        u64     parent_id;
-        u64     disk_id;
-        u8      partnum;
-};
-
-struct vblk_volu {                      /* VBLK Volume */
-        u8      volume_type[16];
-        u8      volume_state[16];
-        u8      guid[16];
-        u8      drive_hint[4];
-        u64     size;
-        u8      partition_type;
-};
-
-struct vblk_head {                      /* VBLK standard header */
-        u32 group;
-        u16 rec;
-        u16 nrec;
-};
-
-struct vblk {                           /* Generalised VBLK */
-        u8      name[64];
-        u64     obj_id;
-        u32     sequence;
-        u8      flags;
-        u8      type;
-        union {
-                struct vblk_comp comp;
-                struct vblk_dgrp dgrp;
-                struct vblk_disk disk;
-                struct vblk_part part;
-                struct vblk_volu volu;
-        } vblk;
-        struct list_head list;
-};
-
-struct ldmdb {                          /* Cache of the database */
-        struct privhead ph;
-        struct tocblock toc;
-        struct vmdb     vm;
-        struct list_head v_dgrp;
-        struct list_head v_disk;
-        struct list_head v_volu;
-        struct list_head v_comp;
-        struct list_head v_part;
-};
-
-int ldm_partition(struct parsed_partitions *state);
-
-#endif /* _FS_PT_LDM_H_ */
-
diff --git a/fs/partitions/mac.c b/fs/partitions/mac.c
deleted file mode 100644
index 11f688bd76c5..000000000000
--- a/fs/partitions/mac.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- *  fs/partitions/mac.c
- *
- *  Code extracted from drivers/block/genhd.c
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- */
-
-#include <linux/ctype.h>
-#include "check.h"
-#include "mac.h"
-
-#ifdef CONFIG_PPC_PMAC
-#include <asm/machdep.h>
-extern void note_bootable_part(dev_t dev, int part, int goodness);
-#endif
-
-/*
- * Code to understand MacOS partition tables.
- */
-
-static inline void mac_fix_string(char *stg, int len)
-{
-        int i;
-
-        for (i = len - 1; i >= 0 && stg[i] == ' '; i--)
-                stg[i] = 0;
-}
-
-int mac_partition(struct parsed_partitions *state)
-{
-        Sector sect;
-        unsigned char *data;
-        int slot, blocks_in_map;
-        unsigned secsize;
-#ifdef CONFIG_PPC_PMAC
-        int found_root = 0;
-        int found_root_goodness = 0;
-#endif
-        struct mac_partition *part;
-        struct mac_driver_desc *md;
-
-        /* Get 0th block and look at the first partition map entry. */
-        md = read_part_sector(state, 0, &sect);
-        if (!md)
-                return -1;
-        if (be16_to_cpu(md->signature) != MAC_DRIVER_MAGIC) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        secsize = be16_to_cpu(md->block_size);
-        put_dev_sector(sect);
-        data = read_part_sector(state, secsize/512, &sect);
-        if (!data)
-                return -1;
-        part = (struct mac_partition *) (data + secsize%512);
-        if (be16_to_cpu(part->signature) != MAC_PARTITION_MAGIC) {
-                put_dev_sector(sect);
-                return 0;               /* not a MacOS disk */
-        }
-        blocks_in_map = be32_to_cpu(part->map_count);
-        if (blocks_in_map < 0 || blocks_in_map >= DISK_MAX_PARTS) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        strlcat(state->pp_buf, " [mac]", PAGE_SIZE);
-        for (slot = 1; slot <= blocks_in_map; ++slot) {
-                int pos = slot * secsize;
-                put_dev_sector(sect);
-                data = read_part_sector(state, pos/512, &sect);
-                if (!data)
-                        return -1;
-                part = (struct mac_partition *) (data + pos%512);
-                if (be16_to_cpu(part->signature) != MAC_PARTITION_MAGIC)
-                        break;
-                put_partition(state, slot,
-                        be32_to_cpu(part->start_block) * (secsize/512),
-                        be32_to_cpu(part->block_count) * (secsize/512));
-
-                if (!strnicmp(part->type, "Linux_RAID", 10))
-                        state->parts[slot].flags = ADDPART_FLAG_RAID;
-#ifdef CONFIG_PPC_PMAC
-                /*
-                 * If this is the first bootable partition, tell the
-                 * setup code, in case it wants to make this the root.
-                 */
-                if (machine_is(powermac)) {
-                        int goodness = 0;
-
-                        mac_fix_string(part->processor, 16);
-                        mac_fix_string(part->name, 32);
-                        mac_fix_string(part->type, 32);                                 
-                    
-                        if ((be32_to_cpu(part->status) & MAC_STATUS_BOOTABLE)
-                            && strcasecmp(part->processor, "powerpc") == 0)
-                                goodness++;
-
-                        if (strcasecmp(part->type, "Apple_UNIX_SVR2") == 0
-                            || (strnicmp(part->type, "Linux", 5) == 0
-                                && strcasecmp(part->type, "Linux_swap") != 0)) {
-                                int i, l;
-
-                                goodness++;
-                                l = strlen(part->name);
-                                if (strcmp(part->name, "/") == 0)
-                                        goodness++;
-                                for (i = 0; i <= l - 4; ++i) {
-                                        if (strnicmp(part->name + i, "root",
-                                                     4) == 0) {
-                                                goodness += 2;
-                                                break;
-                                        }
-                                }
-                                if (strnicmp(part->name, "swap", 4) == 0)
-                                        goodness--;
-                        }
-
-                        if (goodness > found_root_goodness) {
-                                found_root = slot;
-                                found_root_goodness = goodness;
-                        }
-                }
-#endif /* CONFIG_PPC_PMAC */
-        }
-#ifdef CONFIG_PPC_PMAC
-        if (found_root_goodness)
-                note_bootable_part(state->bdev->bd_dev, found_root,
-                                   found_root_goodness);
-#endif
-
-        put_dev_sector(sect);
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        return 1;
-}
diff --git a/fs/partitions/mac.h b/fs/partitions/mac.h
deleted file mode 100644
index 3c7d98436380..000000000000
--- a/fs/partitions/mac.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- *  fs/partitions/mac.h
- */
-
-#define MAC_PARTITION_MAGIC     0x504d
-
-/* type field value for A/UX or other Unix partitions */
-#define APPLE_AUX_TYPE  "Apple_UNIX_SVR2"
-
-struct mac_partition {
-        __be16  signature;      /* expected to be MAC_PARTITION_MAGIC */
-        __be16  res1;
-        __be32  map_count;      /* # blocks in partition map */
-        __be32  start_block;    /* absolute starting block # of partition */
-        __be32  block_count;    /* number of blocks in partition */
-        char    name[32];       /* partition name */
-        char    type[32];       /* string type description */
-        __be32  data_start;     /* rel block # of first data block */
-        __be32  data_count;     /* number of data blocks */
-        __be32  status;         /* partition status bits */
-        __be32  boot_start;
-        __be32  boot_size;
-        __be32  boot_load;
-        __be32  boot_load2;
-        __be32  boot_entry;
-        __be32  boot_entry2;
-        __be32  boot_cksum;
-        char    processor[16];  /* identifies ISA of boot */
-        /* there is more stuff after this that we don't need */
-};
-
-#define MAC_STATUS_BOOTABLE     8       /* partition is bootable */
-
-#define MAC_DRIVER_MAGIC        0x4552
-
-/* Driver descriptor structure, in block 0 */
-struct mac_driver_desc {
-        __be16  signature;      /* expected to be MAC_DRIVER_MAGIC */
-        __be16  block_size;
-        __be32  block_count;
-    /* ... more stuff */
-};
-
-int mac_partition(struct parsed_partitions *state);
diff --git a/fs/partitions/msdos.c b/fs/partitions/msdos.c
deleted file mode 100644
index 5f79a6677c69..000000000000
--- a/fs/partitions/msdos.c
+++ /dev/null
@@ -1,552 +0,0 @@
-/*
- *  fs/partitions/msdos.c
- *
- *  Code extracted from drivers/block/genhd.c
- *  Copyright (C) 1991-1998  Linus Torvalds
- *
- *  Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
- *  in the early extended-partition checks and added DM partitions
- *
- *  Support for DiskManager v6.0x added by Mark Lord,
- *  with information provided by OnTrack.  This now works for linux fdisk
- *  and LILO, as well as loadlin and bootln.  Note that disks other than
- *  /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1).
- *
- *  More flexible handling of extended partitions - aeb, 950831
- *
- *  Check partition table on IDE disks for common CHS translations
- *
- *  Re-organised Feb 1998 Russell King
- */
-#include <linux/msdos_fs.h>
-
-#include "check.h"
-#include "msdos.h"
-#include "efi.h"
-
-/*
- * Many architectures don't like unaligned accesses, while
- * the nr_sects and start_sect partition table entries are
- * at a 2 (mod 4) address.
- */
-#include <asm/unaligned.h>
-
-#define SYS_IND(p)      get_unaligned(&p->sys_ind)
-
-static inline sector_t nr_sects(struct partition *p)
-{
-        return (sector_t)get_unaligned_le32(&p->nr_sects);
-}
-
-static inline sector_t start_sect(struct partition *p)
-{
-        return (sector_t)get_unaligned_le32(&p->start_sect);
-}
-
-static inline int is_extended_partition(struct partition *p)
-{
-        return (SYS_IND(p) == DOS_EXTENDED_PARTITION ||
-                SYS_IND(p) == WIN98_EXTENDED_PARTITION ||
-                SYS_IND(p) == LINUX_EXTENDED_PARTITION);
-}
-
-#define MSDOS_LABEL_MAGIC1      0x55
-#define MSDOS_LABEL_MAGIC2      0xAA
-
-static inline int
-msdos_magic_present(unsigned char *p)
-{
-        return (p[0] == MSDOS_LABEL_MAGIC1 && p[1] == MSDOS_LABEL_MAGIC2);
-}
-
-/* Value is EBCDIC 'IBMA' */
-#define AIX_LABEL_MAGIC1        0xC9
-#define AIX_LABEL_MAGIC2        0xC2
-#define AIX_LABEL_MAGIC3        0xD4
-#define AIX_LABEL_MAGIC4        0xC1
-static int aix_magic_present(struct parsed_partitions *state, unsigned char *p)
-{
-        struct partition *pt = (struct partition *) (p + 0x1be);
-        Sector sect;
-        unsigned char *d;
-        int slot, ret = 0;
-
-        if (!(p[0] == AIX_LABEL_MAGIC1 &&
-                p[1] == AIX_LABEL_MAGIC2 &&
-                p[2] == AIX_LABEL_MAGIC3 &&
-                p[3] == AIX_LABEL_MAGIC4))
-                return 0;
-        /* Assume the partition table is valid if Linux partitions exists */
-        for (slot = 1; slot <= 4; slot++, pt++) {
-                if (pt->sys_ind == LINUX_SWAP_PARTITION ||
-                        pt->sys_ind == LINUX_RAID_PARTITION ||
-                        pt->sys_ind == LINUX_DATA_PARTITION ||
-                        pt->sys_ind == LINUX_LVM_PARTITION ||
-                        is_extended_partition(pt))
-                        return 0;
-        }
-        d = read_part_sector(state, 7, &sect);
-        if (d) {
-                if (d[0] == '_' && d[1] == 'L' && d[2] == 'V' && d[3] == 'M')
-                        ret = 1;
-                put_dev_sector(sect);
-        };
-        return ret;
-}
-
-/*
- * Create devices for each logical partition in an extended partition.
- * The logical partitions form a linked list, with each entry being
- * a partition table with two entries.  The first entry
- * is the real data partition (with a start relative to the partition
- * table start).  The second is a pointer to the next logical partition
- * (with a start relative to the entire extended partition).
- * We do not create a Linux partition for the partition tables, but
- * only for the actual data partitions.
- */
-
-static void parse_extended(struct parsed_partitions *state,
-                           sector_t first_sector, sector_t first_size)
-{
-        struct partition *p;
-        Sector sect;
-        unsigned char *data;
-        sector_t this_sector, this_size;
-        sector_t sector_size = bdev_logical_block_size(state->bdev) / 512;
-        int loopct = 0;         /* number of links followed
-                                   without finding a data partition */
-        int i;
-
-        this_sector = first_sector;
-        this_size = first_size;
-
-        while (1) {
-                if (++loopct > 100)
-                        return;
-                if (state->next == state->limit)
-                        return;
-                data = read_part_sector(state, this_sector, &sect);
-                if (!data)
-                        return;
-
-                if (!msdos_magic_present(data + 510))
-                        goto done; 
-
-                p = (struct partition *) (data + 0x1be);
-
-                /*
-                 * Usually, the first entry is the real data partition,
-                 * the 2nd entry is the next extended partition, or empty,
-                 * and the 3rd and 4th entries are unused.
-                 * However, DRDOS sometimes has the extended partition as
-                 * the first entry (when the data partition is empty),
-                 * and OS/2 seems to use all four entries.
-                 */
-
-                /* 
-                 * First process the data partition(s)
-                 */
-                for (i=0; i<4; i++, p++) {
-                        sector_t offs, size, next;
-                        if (!nr_sects(p) || is_extended_partition(p))
-                                continue;
-
-                        /* Check the 3rd and 4th entries -
-                           these sometimes contain random garbage */
-                        offs = start_sect(p)*sector_size;
-                        size = nr_sects(p)*sector_size;
-                        next = this_sector + offs;
-                        if (i >= 2) {
-                                if (offs + size > this_size)
-                                        continue;
-                                if (next < first_sector)
-                                        continue;
-                                if (next + size > first_sector + first_size)
-                                        continue;
-                        }
-
-                        put_partition(state, state->next, next, size);
-                        if (SYS_IND(p) == LINUX_RAID_PARTITION)
-                                state->parts[state->next].flags = ADDPART_FLAG_RAID;
-                        loopct = 0;
-                        if (++state->next == state->limit)
-                                goto done;
-                }
-                /*
-                 * Next, process the (first) extended partition, if present.
-                 * (So far, there seems to be no reason to make
-                 *  parse_extended()  recursive and allow a tree
-                 *  of extended partitions.)
-                 * It should be a link to the next logical partition.
-                 */
-                p -= 4;
-                for (i=0; i<4; i++, p++)
-                        if (nr_sects(p) && is_extended_partition(p))
-                                break;
-                if (i == 4)
-                        goto done;       /* nothing left to do */
-
-                this_sector = first_sector + start_sect(p) * sector_size;
-                this_size = nr_sects(p) * sector_size;
-                put_dev_sector(sect);
-        }
-done:
-        put_dev_sector(sect);
-}
-
-/* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also
-   indicates linux swap.  Be careful before believing this is Solaris. */
-
-static void parse_solaris_x86(struct parsed_partitions *state,
-                              sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_SOLARIS_X86_PARTITION
-        Sector sect;
-        struct solaris_x86_vtoc *v;
-        int i;
-        short max_nparts;
-
-        v = read_part_sector(state, offset + 1, &sect);
-        if (!v)
-                return;
-        if (le32_to_cpu(v->v_sanity) != SOLARIS_X86_VTOC_SANE) {
-                put_dev_sector(sect);
-                return;
-        }
-        {
-                char tmp[1 + BDEVNAME_SIZE + 10 + 11 + 1];
-
-                snprintf(tmp, sizeof(tmp), " %s%d: <solaris:", state->name, origin);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-        }
-        if (le32_to_cpu(v->v_version) != 1) {
-                char tmp[64];
-
-                snprintf(tmp, sizeof(tmp), "  cannot handle version %d vtoc>\n",
-                         le32_to_cpu(v->v_version));
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                put_dev_sector(sect);
-                return;
-        }
-        /* Ensure we can handle previous case of VTOC with 8 entries gracefully */
-        max_nparts = le16_to_cpu (v->v_nparts) > 8 ? SOLARIS_X86_NUMSLICE : 8;
-        for (i=0; i<max_nparts && state->next<state->limit; i++) {
-                struct solaris_x86_slice *s = &v->v_slice[i];
-                char tmp[3 + 10 + 1 + 1];
-
-                if (s->s_size == 0)
-                        continue;
-                snprintf(tmp, sizeof(tmp), " [s%d]", i);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                /* solaris partitions are relative to current MS-DOS
-                 * one; must add the offset of the current partition */
-                put_partition(state, state->next++,
-                                 le32_to_cpu(s->s_start)+offset,
-                                 le32_to_cpu(s->s_size));
-        }
-        put_dev_sector(sect);
-        strlcat(state->pp_buf, " >\n", PAGE_SIZE);
-#endif
-}
-
-#if defined(CONFIG_BSD_DISKLABEL)
-/* 
- * Create devices for BSD partitions listed in a disklabel, under a
- * dos-like partition. See parse_extended() for more information.
- */
-static void parse_bsd(struct parsed_partitions *state,
-                      sector_t offset, sector_t size, int origin, char *flavour,
-                      int max_partitions)
-{
-        Sector sect;
-        struct bsd_disklabel *l;
-        struct bsd_partition *p;
-        char tmp[64];
-
-        l = read_part_sector(state, offset + 1, &sect);
-        if (!l)
-                return;
-        if (le32_to_cpu(l->d_magic) != BSD_DISKMAGIC) {
-                put_dev_sector(sect);
-                return;
-        }
-
-        snprintf(tmp, sizeof(tmp), " %s%d: <%s:", state->name, origin, flavour);
-        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-
-        if (le16_to_cpu(l->d_npartitions) < max_partitions)
-                max_partitions = le16_to_cpu(l->d_npartitions);
-        for (p = l->d_partitions; p - l->d_partitions < max_partitions; p++) {
-                sector_t bsd_start, bsd_size;
-
-                if (state->next == state->limit)
-                        break;
-                if (p->p_fstype == BSD_FS_UNUSED) 
-                        continue;
-                bsd_start = le32_to_cpu(p->p_offset);
-                bsd_size = le32_to_cpu(p->p_size);
-                if (offset == bsd_start && size == bsd_size)
-                        /* full parent partition, we have it already */
-                        continue;
-                if (offset > bsd_start || offset+size < bsd_start+bsd_size) {
-                        strlcat(state->pp_buf, "bad subpartition - ignored\n", PAGE_SIZE);
-                        continue;
-                }
-                put_partition(state, state->next++, bsd_start, bsd_size);
-        }
-        put_dev_sector(sect);
-        if (le16_to_cpu(l->d_npartitions) > max_partitions) {
-                snprintf(tmp, sizeof(tmp), " (ignored %d more)",
-                         le16_to_cpu(l->d_npartitions) - max_partitions);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-        }
-        strlcat(state->pp_buf, " >\n", PAGE_SIZE);
-}
-#endif
-
-static void parse_freebsd(struct parsed_partitions *state,
-                          sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_BSD_DISKLABEL
-        parse_bsd(state, offset, size, origin, "bsd", BSD_MAXPARTITIONS);
-#endif
-}
-
-static void parse_netbsd(struct parsed_partitions *state,
-                         sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_BSD_DISKLABEL
-        parse_bsd(state, offset, size, origin, "netbsd", BSD_MAXPARTITIONS);
-#endif
-}
-
-static void parse_openbsd(struct parsed_partitions *state,
-                          sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_BSD_DISKLABEL
-        parse_bsd(state, offset, size, origin, "openbsd",
-                  OPENBSD_MAXPARTITIONS);
-#endif
-}
-
-/*
- * Create devices for Unixware partitions listed in a disklabel, under a
- * dos-like partition. See parse_extended() for more information.
- */
-static void parse_unixware(struct parsed_partitions *state,
-                           sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_UNIXWARE_DISKLABEL
-        Sector sect;
-        struct unixware_disklabel *l;
-        struct unixware_slice *p;
-
-        l = read_part_sector(state, offset + 29, &sect);
-        if (!l)
-                return;
-        if (le32_to_cpu(l->d_magic) != UNIXWARE_DISKMAGIC ||
-            le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_DISKMAGIC2) {
-                put_dev_sector(sect);
-                return;
-        }
-        {
-                char tmp[1 + BDEVNAME_SIZE + 10 + 12 + 1];
-
-                snprintf(tmp, sizeof(tmp), " %s%d: <unixware:", state->name, origin);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-        }
-        p = &l->vtoc.v_slice[1];
-        /* I omit the 0th slice as it is the same as whole disk. */
-        while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) {
-                if (state->next == state->limit)
-                        break;
-
-                if (p->s_label != UNIXWARE_FS_UNUSED)
-                        put_partition(state, state->next++,
-                                      le32_to_cpu(p->start_sect),
-                                      le32_to_cpu(p->nr_sects));
-                p++;
-        }
-        put_dev_sector(sect);
-        strlcat(state->pp_buf, " >\n", PAGE_SIZE);
-#endif
-}
-
-/*
- * Minix 2.0.0/2.0.2 subpartition support.
- * Anand Krishnamurthy <anandk@wiproge.med.ge.com>
- * Rajeev V. Pillai    <rajeevvp@yahoo.com>
- */
-static void parse_minix(struct parsed_partitions *state,
-                        sector_t offset, sector_t size, int origin)
-{
-#ifdef CONFIG_MINIX_SUBPARTITION
-        Sector sect;
-        unsigned char *data;
-        struct partition *p;
-        int i;
-
-        data = read_part_sector(state, offset, &sect);
-        if (!data)
-                return;
-
-        p = (struct partition *)(data + 0x1be);
-
-        /* The first sector of a Minix partition can have either
-         * a secondary MBR describing its subpartitions, or
-         * the normal boot sector. */
-        if (msdos_magic_present (data + 510) &&
-            SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */
-                char tmp[1 + BDEVNAME_SIZE + 10 + 9 + 1];
-
-                snprintf(tmp, sizeof(tmp), " %s%d: <minix:", state->name, origin);
-                strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) {
-                        if (state->next == state->limit)
-                                break;
-                        /* add each partition in use */
-                        if (SYS_IND(p) == MINIX_PARTITION)
-                                put_partition(state, state->next++,
-                                              start_sect(p), nr_sects(p));
-                }
-                strlcat(state->pp_buf, " >\n", PAGE_SIZE);
-        }
-        put_dev_sector(sect);
-#endif /* CONFIG_MINIX_SUBPARTITION */
-}
-
-static struct {
-        unsigned char id;
-        void (*parse)(struct parsed_partitions *, sector_t, sector_t, int);
-} subtypes[] = {
-        {FREEBSD_PARTITION, parse_freebsd},
-        {NETBSD_PARTITION, parse_netbsd},
-        {OPENBSD_PARTITION, parse_openbsd},
-        {MINIX_PARTITION, parse_minix},
-        {UNIXWARE_PARTITION, parse_unixware},
-        {SOLARIS_X86_PARTITION, parse_solaris_x86},
-        {NEW_SOLARIS_X86_PARTITION, parse_solaris_x86},
-        {0, NULL},
-};
- 
-int msdos_partition(struct parsed_partitions *state)
-{
-        sector_t sector_size = bdev_logical_block_size(state->bdev) / 512;
-        Sector sect;
-        unsigned char *data;
-        struct partition *p;
-        struct fat_boot_sector *fb;
-        int slot;
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-        if (!msdos_magic_present(data + 510)) {
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        if (aix_magic_present(state, data)) {
-                put_dev_sector(sect);
-                strlcat(state->pp_buf, " [AIX]", PAGE_SIZE);
-                return 0;
-        }
-
-        /*
-         * Now that the 55aa signature is present, this is probably
-         * either the boot sector of a FAT filesystem or a DOS-type
-         * partition table. Reject this in case the boot indicator
-         * is not 0 or 0x80.
-         */
-        p = (struct partition *) (data + 0x1be);
-        for (slot = 1; slot <= 4; slot++, p++) {
-                if (p->boot_ind != 0 && p->boot_ind != 0x80) {
-                        /*
-                         * Even without a valid boot inidicator value
-                         * its still possible this is valid FAT filesystem
-                         * without a partition table.
-                         */
-                        fb = (struct fat_boot_sector *) data;
-                        if (slot == 1 && fb->reserved && fb->fats
-                                && fat_valid_media(fb->media)) {
-                                strlcat(state->pp_buf, "\n", PAGE_SIZE);
-                                put_dev_sector(sect);
-                                return 1;
-                        } else {
-                                put_dev_sector(sect);
-                                return 0;
-                        }
-                }
-        }
-
-#ifdef CONFIG_EFI_PARTITION
-        p = (struct partition *) (data + 0x1be);
-        for (slot = 1 ; slot <= 4 ; slot++, p++) {
-                /* If this is an EFI GPT disk, msdos should ignore it. */
-                if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) {
-                        put_dev_sector(sect);
-                        return 0;
-                }
-        }
-#endif
-        p = (struct partition *) (data + 0x1be);
-
-        /*
-         * Look for partitions in two passes:
-         * First find the primary and DOS-type extended partitions.
-         * On the second pass look inside *BSD, Unixware and Solaris partitions.
-         */
-
-        state->next = 5;
-        for (slot = 1 ; slot <= 4 ; slot++, p++) {
-                sector_t start = start_sect(p)*sector_size;
-                sector_t size = nr_sects(p)*sector_size;
-                if (!size)
-                        continue;
-                if (is_extended_partition(p)) {
-                        /*
-                         * prevent someone doing mkfs or mkswap on an
-                         * extended partition, but leave room for LILO
-                         * FIXME: this uses one logical sector for > 512b
-                         * sector, although it may not be enough/proper.
-                         */
-                        sector_t n = 2;
-                        n = min(size, max(sector_size, n));
-                        put_partition(state, slot, start, n);
-
-                        strlcat(state->pp_buf, " <", PAGE_SIZE);
-                        parse_extended(state, start, size);
-                        strlcat(state->pp_buf, " >", PAGE_SIZE);
-                        continue;
-                }
-                put_partition(state, slot, start, size);
-                if (SYS_IND(p) == LINUX_RAID_PARTITION)
-                        state->parts[slot].flags = ADDPART_FLAG_RAID;
-                if (SYS_IND(p) == DM6_PARTITION)
-                        strlcat(state->pp_buf, "[DM]", PAGE_SIZE);
-                if (SYS_IND(p) == EZD_PARTITION)
-                        strlcat(state->pp_buf, "[EZD]", PAGE_SIZE);
-        }
-
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-
-        /* second pass - output for each on a separate line */
-        p = (struct partition *) (0x1be + data);
-        for (slot = 1 ; slot <= 4 ; slot++, p++) {
-                unsigned char id = SYS_IND(p);
-                int n;
-
-                if (!nr_sects(p))
-                        continue;
-
-                for (n = 0; subtypes[n].parse && id != subtypes[n].id; n++)
-                        ;
-
-                if (!subtypes[n].parse)
-                        continue;
-                subtypes[n].parse(state, start_sect(p) * sector_size,
-                                  nr_sects(p) * sector_size, slot);
-        }
-        put_dev_sector(sect);
-        return 1;
-}
diff --git a/fs/partitions/msdos.h b/fs/partitions/msdos.h
deleted file mode 100644
index 38c781c490b3..000000000000
--- a/fs/partitions/msdos.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
- *  fs/partitions/msdos.h
- */
-
-#define MSDOS_LABEL_MAGIC               0xAA55
-
-int msdos_partition(struct parsed_partitions *state);
-
diff --git a/fs/partitions/osf.c b/fs/partitions/osf.c
deleted file mode 100644
index 764b86a01965..000000000000
--- a/fs/partitions/osf.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- *  fs/partitions/osf.c
- *
- *  Code extracted from drivers/block/genhd.c
- *
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- */
-
-#include "check.h"
-#include "osf.h"
-
-#define MAX_OSF_PARTITIONS 18
-
-int osf_partition(struct parsed_partitions *state)
-{
-        int i;
-        int slot = 1;
-        unsigned int npartitions;
-        Sector sect;
-        unsigned char *data;
-        struct disklabel {
-                __le32 d_magic;
-                __le16 d_type,d_subtype;
-                u8 d_typename[16];
-                u8 d_packname[16];
-                __le32 d_secsize;
-                __le32 d_nsectors;
-                __le32 d_ntracks;
-                __le32 d_ncylinders;
-                __le32 d_secpercyl;
-                __le32 d_secprtunit;
-                __le16 d_sparespertrack;
-                __le16 d_sparespercyl;
-                __le32 d_acylinders;
-                __le16 d_rpm, d_interleave, d_trackskew, d_cylskew;
-                __le32 d_headswitch, d_trkseek, d_flags;
-                __le32 d_drivedata[5];
-                __le32 d_spare[5];
-                __le32 d_magic2;
-                __le16 d_checksum;
-                __le16 d_npartitions;
-                __le32 d_bbsize, d_sbsize;
-                struct d_partition {
-                        __le32 p_size;
-                        __le32 p_offset;
-                        __le32 p_fsize;
-                        u8  p_fstype;
-                        u8  p_frag;
-                        __le16 p_cpg;
-                } d_partitions[MAX_OSF_PARTITIONS];
-        } * label;
-        struct d_partition * partition;
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-
-        label = (struct disklabel *) (data+64);
-        partition = label->d_partitions;
-        if (le32_to_cpu(label->d_magic) != DISKLABELMAGIC) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        if (le32_to_cpu(label->d_magic2) != DISKLABELMAGIC) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        npartitions = le16_to_cpu(label->d_npartitions);
-        if (npartitions > MAX_OSF_PARTITIONS) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        for (i = 0 ; i < npartitions; i++, partition++) {
-                if (slot == state->limit)
-                        break;
-                if (le32_to_cpu(partition->p_size))
-                        put_partition(state, slot,
-                                le32_to_cpu(partition->p_offset),
-                                le32_to_cpu(partition->p_size));
-                slot++;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        put_dev_sector(sect);
-        return 1;
-}
diff --git a/fs/partitions/osf.h b/fs/partitions/osf.h
deleted file mode 100644
index 20ed2315ec16..000000000000
--- a/fs/partitions/osf.h
+++ /dev/null
@@ -1,7 +0,0 @@
-/*
- *  fs/partitions/osf.h
- */
-
-#define DISKLABELMAGIC (0x82564557UL)
-
-int osf_partition(struct parsed_partitions *state);
diff --git a/fs/partitions/sgi.c b/fs/partitions/sgi.c
deleted file mode 100644
index ea8a86dceaf4..000000000000
--- a/fs/partitions/sgi.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- *  fs/partitions/sgi.c
- *
- *  Code extracted from drivers/block/genhd.c
- */
-
-#include "check.h"
-#include "sgi.h"
-
-struct sgi_disklabel {
-        __be32 magic_mushroom;          /* Big fat spliff... */
-        __be16 root_part_num;           /* Root partition number */
-        __be16 swap_part_num;           /* Swap partition number */
-        s8 boot_file[16];               /* Name of boot file for ARCS */
-        u8 _unused0[48];                /* Device parameter useless crapola.. */
-        struct sgi_volume {
-                s8 name[8];             /* Name of volume */
-                __be32 block_num;               /* Logical block number */
-                __be32 num_bytes;               /* How big, in bytes */
-        } volume[15];
-        struct sgi_partition {
-                __be32 num_blocks;              /* Size in logical blocks */
-                __be32 first_block;     /* First logical block */
-                __be32 type;            /* Type of this partition */
-        } partitions[16];
-        __be32 csum;                    /* Disk label checksum */
-        __be32 _unused1;                        /* Padding */
-};
-
-int sgi_partition(struct parsed_partitions *state)
-{
-        int i, csum;
-        __be32 magic;
-        int slot = 1;
-        unsigned int start, blocks;
-        __be32 *ui, cs;
-        Sector sect;
-        struct sgi_disklabel *label;
-        struct sgi_partition *p;
-        char b[BDEVNAME_SIZE];
-
-        label = read_part_sector(state, 0, &sect);
-        if (!label)
-                return -1;
-        p = &label->partitions[0];
-        magic = label->magic_mushroom;
-        if(be32_to_cpu(magic) != SGI_LABEL_MAGIC) {
-                /*printk("Dev %s SGI disklabel: bad magic %08x\n",
-                       bdevname(bdev, b), be32_to_cpu(magic));*/
-                put_dev_sector(sect);
-                return 0;
-        }
-        ui = ((__be32 *) (label + 1)) - 1;
-        for(csum = 0; ui >= ((__be32 *) label);) {
-                cs = *ui--;
-                csum += be32_to_cpu(cs);
-        }
-        if(csum) {
-                printk(KERN_WARNING "Dev %s SGI disklabel: csum bad, label corrupted\n",
-                       bdevname(state->bdev, b));
-                put_dev_sector(sect);
-                return 0;
-        }
-        /* All SGI disk labels have 16 partitions, disks under Linux only
-         * have 15 minor's.  Luckily there are always a few zero length
-         * partitions which we don't care about so we never overflow the
-         * current_minor.
-         */
-        for(i = 0; i < 16; i++, p++) {
-                blocks = be32_to_cpu(p->num_blocks);
-                start  = be32_to_cpu(p->first_block);
-                if (blocks) {
-                        put_partition(state, slot, start, blocks);
-                        if (be32_to_cpu(p->type) == LINUX_RAID_PARTITION)
-                                state->parts[slot].flags = ADDPART_FLAG_RAID;
-                }
-                slot++;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        put_dev_sector(sect);
-        return 1;
-}
diff --git a/fs/partitions/sgi.h b/fs/partitions/sgi.h
deleted file mode 100644
index b9553ebdd5a9..000000000000
--- a/fs/partitions/sgi.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
- *  fs/partitions/sgi.h
- */
-
-extern int sgi_partition(struct parsed_partitions *state);
-
-#define SGI_LABEL_MAGIC 0x0be5a941
-
diff --git a/fs/partitions/sun.c b/fs/partitions/sun.c
deleted file mode 100644
index b5b6fcfb3d36..000000000000
--- a/fs/partitions/sun.c
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- *  fs/partitions/sun.c
- *
- *  Code extracted from drivers/block/genhd.c
- *
- *  Copyright (C) 1991-1998  Linus Torvalds
- *  Re-organised Feb 1998 Russell King
- */
-
-#include "check.h"
-#include "sun.h"
-
-int sun_partition(struct parsed_partitions *state)
-{
-        int i;
-        __be16 csum;
-        int slot = 1;
-        __be16 *ush;
-        Sector sect;
-        struct sun_disklabel {
-                unsigned char info[128];   /* Informative text string */
-                struct sun_vtoc {
-                    __be32 version;     /* Layout version */
-                    char   volume[8];   /* Volume name */
-                    __be16 nparts;      /* Number of partitions */
-                    struct sun_info {           /* Partition hdrs, sec 2 */
-                        __be16 id;
-                        __be16 flags;
-                    } infos[8];
-                    __be16 padding;     /* Alignment padding */
-                    __be32 bootinfo[3];  /* Info needed by mboot */
-                    __be32 sanity;       /* To verify vtoc sanity */
-                    __be32 reserved[10]; /* Free space */
-                    __be32 timestamp[8]; /* Partition timestamp */
-                } vtoc;
-                __be32 write_reinstruct; /* sectors to skip, writes */
-                __be32 read_reinstruct;  /* sectors to skip, reads */
-                unsigned char spare[148]; /* Padding */
-                __be16 rspeed;     /* Disk rotational speed */
-                __be16 pcylcount;  /* Physical cylinder count */
-                __be16 sparecyl;   /* extra sects per cylinder */
-                __be16 obs1;       /* gap1 */
-                __be16 obs2;       /* gap2 */
-                __be16 ilfact;     /* Interleave factor */
-                __be16 ncyl;       /* Data cylinder count */
-                __be16 nacyl;      /* Alt. cylinder count */
-                __be16 ntrks;      /* Tracks per cylinder */
-                __be16 nsect;      /* Sectors per track */
-                __be16 obs3;       /* bhead - Label head offset */
-                __be16 obs4;       /* ppart - Physical Partition */
-                struct sun_partition {
-                        __be32 start_cylinder;
-                        __be32 num_sectors;
-                } partitions[8];
-                __be16 magic;      /* Magic number */
-                __be16 csum;       /* Label xor'd checksum */
-        } * label;
-        struct sun_partition *p;
-        unsigned long spc;
-        char b[BDEVNAME_SIZE];
-        int use_vtoc;
-        int nparts;
-
-        label = read_part_sector(state, 0, &sect);
-        if (!label)
-                return -1;
-
-        p = label->partitions;
-        if (be16_to_cpu(label->magic) != SUN_LABEL_MAGIC) {
-/*              printk(KERN_INFO "Dev %s Sun disklabel: bad magic %04x\n",
-                       bdevname(bdev, b), be16_to_cpu(label->magic)); */
-                put_dev_sector(sect);
-                return 0;
-        }
-        /* Look at the checksum */
-        ush = ((__be16 *) (label+1)) - 1;
-        for (csum = 0; ush >= ((__be16 *) label);)
-                csum ^= *ush--;
-        if (csum) {
-                printk("Dev %s Sun disklabel: Csum bad, label corrupted\n",
-                       bdevname(state->bdev, b));
-                put_dev_sector(sect);
-                return 0;
-        }
-
-        /* Check to see if we can use the VTOC table */
-        use_vtoc = ((be32_to_cpu(label->vtoc.sanity) == SUN_VTOC_SANITY) &&
-                    (be32_to_cpu(label->vtoc.version) == 1) &&
-                    (be16_to_cpu(label->vtoc.nparts) <= 8));
-
-        /* Use 8 partition entries if not specified in validated VTOC */
-        nparts = (use_vtoc) ? be16_to_cpu(label->vtoc.nparts) : 8;
-
-        /*
-         * So that old Linux-Sun partitions continue to work,
-         * alow the VTOC to be used under the additional condition ...
-         */
-        use_vtoc = use_vtoc || !(label->vtoc.sanity ||
-                                 label->vtoc.version || label->vtoc.nparts);
-        spc = be16_to_cpu(label->ntrks) * be16_to_cpu(label->nsect);
-        for (i = 0; i < nparts; i++, p++) {
-                unsigned long st_sector;
-                unsigned int num_sectors;
-
-                st_sector = be32_to_cpu(p->start_cylinder) * spc;
-                num_sectors = be32_to_cpu(p->num_sectors);
-                if (num_sectors) {
-                        put_partition(state, slot, st_sector, num_sectors);
-                        state->parts[slot].flags = 0;
-                        if (use_vtoc) {
-                                if (be16_to_cpu(label->vtoc.infos[i].id) == LINUX_RAID_PARTITION)
-                                        state->parts[slot].flags |= ADDPART_FLAG_RAID;
-                                else if (be16_to_cpu(label->vtoc.infos[i].id) == SUN_WHOLE_DISK)
-                                        state->parts[slot].flags |= ADDPART_FLAG_WHOLEDISK;
-                        }
-                }
-                slot++;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        put_dev_sector(sect);
-        return 1;
-}
diff --git a/fs/partitions/sun.h b/fs/partitions/sun.h
deleted file mode 100644
index 2424baa8319f..000000000000
--- a/fs/partitions/sun.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
- *  fs/partitions/sun.h
- */
-
-#define SUN_LABEL_MAGIC          0xDABE
-#define SUN_VTOC_SANITY          0x600DDEEE
-
-int sun_partition(struct parsed_partitions *state);
diff --git a/fs/partitions/sysv68.c b/fs/partitions/sysv68.c
deleted file mode 100644
index 9627ccffc1c4..000000000000
--- a/fs/partitions/sysv68.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- *  fs/partitions/sysv68.c
- *
- *  Copyright (C) 2007 Philippe De Muyter <phdm@macqel.be>
- */
-
-#include "check.h"
-#include "sysv68.h"
-
-/*
- *      Volume ID structure: on first 256-bytes sector of disk
- */
-
-struct volumeid {
-        u8      vid_unused[248];
-        u8      vid_mac[8];     /* ASCII string "MOTOROLA" */
-};
-
-/*
- *      config block: second 256-bytes sector on disk
- */
-
-struct dkconfig {
-        u8      ios_unused0[128];
-        __be32  ios_slcblk;     /* Slice table block number */
-        __be16  ios_slccnt;     /* Number of entries in slice table */
-        u8      ios_unused1[122];
-};
-
-/*
- *      combined volumeid and dkconfig block
- */
-
-struct dkblk0 {
-        struct volumeid dk_vid;
-        struct dkconfig dk_ios;
-};
-
-/*
- *      Slice Table Structure
- */
-
-struct slice {
-        __be32  nblocks;                /* slice size (in blocks) */
-        __be32  blkoff;                 /* block offset of slice */
-};
-
-
-int sysv68_partition(struct parsed_partitions *state)
-{
-        int i, slices;
-        int slot = 1;
-        Sector sect;
-        unsigned char *data;
-        struct dkblk0 *b;
-        struct slice *slice;
-        char tmp[64];
-
-        data = read_part_sector(state, 0, &sect);
-        if (!data)
-                return -1;
-
-        b = (struct dkblk0 *)data;
-        if (memcmp(b->dk_vid.vid_mac, "MOTOROLA", sizeof(b->dk_vid.vid_mac))) {
-                put_dev_sector(sect);
-                return 0;
-        }
-        slices = be16_to_cpu(b->dk_ios.ios_slccnt);
-        i = be32_to_cpu(b->dk_ios.ios_slcblk);
-        put_dev_sector(sect);
-
-        data = read_part_sector(state, i, &sect);
-        if (!data)
-                return -1;
-
-        slices -= 1; /* last slice is the whole disk */
-        snprintf(tmp, sizeof(tmp), "sysV68: %s(s%u)", state->name, slices);
-        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-        slice = (struct slice *)data;
-        for (i = 0; i < slices; i++, slice++) {
-                if (slot == state->limit)
-                        break;
-                if (be32_to_cpu(slice->nblocks)) {
-                        put_partition(state, slot,
-                                be32_to_cpu(slice->blkoff),
-                                be32_to_cpu(slice->nblocks));
-                        snprintf(tmp, sizeof(tmp), "(s%u)", i);
-                        strlcat(state->pp_buf, tmp, PAGE_SIZE);
-                }
-                slot++;
-        }
-        strlcat(state->pp_buf, "\n", PAGE_SIZE);
-        put_dev_sector(sect);
-        return 1;
-}
diff --git a/fs/partitions/sysv68.h b/fs/partitions/sysv68.h
deleted file mode 100644
index bf2f5ffa97ac..000000000000
--- a/fs/partitions/sysv68.h
+++ /dev/null
@@ -1 +0,0 @@
-extern int sysv68_partition(struct parsed_partitions *state);
diff --git a/fs/partitions/ultrix.c b/fs/partitions/ultrix.c
deleted file mode 100644
index 8dbaf9f77a99..000000000000
--- a/fs/partitions/ultrix.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- *  fs/partitions/ultrix.c
- *
- *  Code extracted from drivers/block/genhd.c
- *
- *  Re-organised Jul 1999 Russell King
- */
-
-#include "check.h"
-#include "ultrix.h"
-
-int ultrix_partition(struct parsed_partitions *state)
-{
-        int i;
-        Sector sect;
-        unsigned char *data;
-        struct ultrix_disklabel {
-                s32     pt_magic;       /* magic no. indicating part. info exits */
-                s32     pt_valid;       /* set by driver if pt is current */
-                struct  pt_info {
-                        s32             pi_nblocks; /* no. of sectors */
-                        u32             pi_blkoff;  /* block offset for start */
-                } pt_part[8];
-        } *label;
-
-#define PT_MAGIC        0x032957        /* Partition magic number */
-#define PT_VALID        1               /* Indicates if struct is valid */
-
-        data = read_part_sector(state, (16384 - sizeof(*label))/512, &sect);
-        if (!data)
-                return -1;
-        
-        label = (struct ultrix_disklabel *)(data + 512 - sizeof(*label));
-
-        if (label->pt_magic == PT_MAGIC && label->pt_valid == PT_VALID) {
-                for (i=0; i<8; i++)
-                        if (label->pt_part[i].pi_nblocks)
-                                put_partition(state, i+1, 
-                                              label->pt_part[i].pi_blkoff,
-                                              label->pt_part[i].pi_nblocks);
-                put_dev_sector(sect);
-                strlcat(state->pp_buf, "\n", PAGE_SIZE);
-                return 1;
-        } else {
-                put_dev_sector(sect);
-                return 0;
-        }
-}
diff --git a/fs/partitions/ultrix.h b/fs/partitions/ultrix.h
deleted file mode 100644
index a3cc00b2bded..000000000000
--- a/fs/partitions/ultrix.h
+++ /dev/null
@@ -1,5 +0,0 @@
-/*
- *  fs/partitions/ultrix.h
- */
-
-int ultrix_partition(struct parsed_partitions *state);
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 07446b55b7cc..a1dddda999f2 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -101,7 +101,7 @@
 struct pid_entry {
         char *name;
         int len;
-        mode_t mode;
+        umode_t mode;
         const struct inode_operations *iop;
         const struct file_operations *fop;
         union proc_op op;
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 10090d9c7ad5..2edf34f2eb61 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -597,7 +597,7 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
 
 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
                                           const char *name,
-                                          mode_t mode,
+                                          umode_t mode,
                                           nlink_t nlink)
 {
         struct proc_dir_entry *ent = NULL;
@@ -659,7 +659,7 @@ struct proc_dir_entry *proc_symlink(const char *name,
 }
 EXPORT_SYMBOL(proc_symlink);
 
-struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
+struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
                 struct proc_dir_entry *parent)
 {
         struct proc_dir_entry *ent;
@@ -699,7 +699,7 @@ struct proc_dir_entry *proc_mkdir(const char *name,
 }
 EXPORT_SYMBOL(proc_mkdir);
 
-struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
+struct proc_dir_entry *create_proc_entry(const char *name, umode_t mode,
                                          struct proc_dir_entry *parent)
 {
         struct proc_dir_entry *ent;
@@ -728,7 +728,7 @@ struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
 }
 EXPORT_SYMBOL(create_proc_entry);
 
-struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
+struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
                                         struct proc_dir_entry *parent,
                                         const struct file_operations *proc_fops,
                                         void *data)
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index f738024ccc8e..06e1cc17caf6 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -179,7 +179,7 @@ const struct file_operations proc_net_operations = {
 
 
 struct proc_dir_entry *proc_net_fops_create(struct net *net,
-        const char *name, mode_t mode, const struct file_operations *fops)
+        const char *name, umode_t mode, const struct file_operations *fops)
 {
         return proc_create(name, mode, net->proc_net, fops);
 }
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index 5b572c89e6c4..5d81e92daf83 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -73,7 +73,6 @@
 #include <linux/security.h>
 #include <linux/kmod.h>
 #include <linux/namei.h>
-#include <linux/buffer_head.h>
 #include <linux/capability.h>
 #include <linux/quotaops.h>
 #include "../internal.h" /* ugh */
diff --git a/fs/quota/quota.c b/fs/quota/quota.c
index 35f4b0ecdeb3..7898cd688a00 100644
--- a/fs/quota/quota.c
+++ b/fs/quota/quota.c
@@ -13,7 +13,6 @@
 #include <linux/kernel.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
-#include <linux/buffer_head.h>
 #include <linux/capability.h>
 #include <linux/quotaops.h>
 #include <linux/types.h>
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index 462ceb38fec6..aec766abe3af 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -52,7 +52,7 @@ static struct backing_dev_info ramfs_backing_dev_info = {
 };
 
 struct inode *ramfs_get_inode(struct super_block *sb,
-                                const struct inode *dir, int mode, dev_t dev)
+                                const struct inode *dir, umode_t mode, dev_t dev)
 {
         struct inode * inode = new_inode(sb);
 
@@ -92,7 +92,7 @@ struct inode *ramfs_get_inode(struct super_block *sb,
  */
 /* SMP-safe */
 static int
-ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+ramfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 {
         struct inode * inode = ramfs_get_inode(dir->i_sb, dir, mode, dev);
         int error = -ENOSPC;
@@ -106,7 +106,7 @@ ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
         return error;
 }
 
-static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
 {
         int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
         if (!retval)
@@ -114,7 +114,7 @@ static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
         return retval;
 }
 
-static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
+static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
 {
         return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 950f13af0951..9e8cd5acd79c 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -1766,7 +1766,7 @@ static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct i
    for the fresh inode.  This can only be done outside a transaction, so
    if we return non-zero, we also end the transaction.  */
 int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
-                       struct inode *dir, int mode, const char *symname,
+                       struct inode *dir, umode_t mode, const char *symname,
                        /* 0 for regular, EMTRY_DIR_SIZE for dirs,
                           strlen (symname) for symlinks) */
                        loff_t i_size, struct dentry *dentry,
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 80058e8ce361..146378865239 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -559,7 +559,7 @@ static int drop_new_inode(struct inode *inode)
 ** outside of a transaction, so we had to pull some bits of
 ** reiserfs_new_inode out into this func.
 */
-static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
+static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
 {
         /* Make inode invalid - just in case we are going to drop it before
          * the initialization happens */
@@ -572,7 +572,7 @@ static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
         return 0;
 }
 
-static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                            struct nameidata *nd)
 {
         int retval;
@@ -643,7 +643,7 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
         return retval;
 }
 
-static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                           dev_t rdev)
 {
         int retval;
@@ -721,7 +721,7 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
         return retval;
 }
 
-static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         int retval;
         struct inode *inode;
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 6bc346c160e7..c24deda8a8bc 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -66,7 +66,7 @@ static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
 }
 #endif
 
-static int xattr_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int xattr_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         BUG_ON(!mutex_is_locked(&dir->i_mutex));
         return dir->i_op->mkdir(dir, dentry, mode);
diff --git a/fs/splice.c b/fs/splice.c
index fa2defa8afcf..1ec0493266b3 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -25,7 +25,6 @@
 #include <linux/mm_inline.h>
 #include <linux/swap.h>
 #include <linux/writeback.h>
-#include <linux/buffer_head.h>
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/uio.h>
diff --git a/fs/sync.c b/fs/sync.c
index 101b8ef901d7..f3501ef39235 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -14,7 +14,6 @@
 #include <linux/linkage.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
-#include <linux/buffer_head.h>
 #include <linux/backing-dev.h>
 #include "internal.h"
 
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index d4e6080b4b20..62f4fb37789e 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -518,7 +518,7 @@ out:
 }
 
 int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
-                        const struct attribute *attr, int type, mode_t amode)
+                        const struct attribute *attr, int type, umode_t amode)
 {
         umode_t mode = (amode & S_IALLUGO) | S_IFREG;
         struct sysfs_addrm_cxt acxt;
@@ -618,7 +618,7 @@ EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
  *
  */
 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
-                     mode_t mode)
+                     umode_t mode)
 {
         struct sysfs_dirent *sd;
         struct iattr newattrs;
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 194414f8298c..dd1701caecc9 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -33,7 +33,7 @@ static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
         int error = 0, i;
 
         for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
-                mode_t mode = 0;
+                umode_t mode = 0;
 
                 /* in update mode, we're changing the permissions or
                  * visibility.  Do this by first removing then
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index c81b22f3ace1..4a802b4a9056 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -187,7 +187,7 @@ out:
         return error;
 }
 
-static inline void set_default_inode_attr(struct inode * inode, mode_t mode)
+static inline void set_default_inode_attr(struct inode * inode, umode_t mode)
 {
         inode->i_mode = mode;
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index ce29e28b766d..7484a36ee678 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -79,7 +79,7 @@ struct sysfs_dirent {
         };
 
         unsigned int            s_flags;
-        unsigned short          s_mode;
+        umode_t                 s_mode;
         ino_t                   s_ino;
         struct sysfs_inode_attrs *s_iattr;
 };
@@ -229,7 +229,7 @@ int sysfs_add_file(struct sysfs_dirent *dir_sd,
                    const struct attribute *attr, int type);
 
 int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
-                        const struct attribute *attr, int type, mode_t amode);
+                        const struct attribute *attr, int type, umode_t amode);
 /*
  * bin.c
  */
diff --git a/fs/sysv/ialloc.c b/fs/sysv/ialloc.c
index 0c96c98bd1db..8233b02eccae 100644
--- a/fs/sysv/ialloc.c
+++ b/fs/sysv/ialloc.c
@@ -132,7 +132,7 @@ void sysv_free_inode(struct inode * inode)
         brelse(bh);
 }
 
-struct inode * sysv_new_inode(const struct inode * dir, mode_t mode)
+struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
 {
         struct super_block *sb = dir->i_sb;
         struct sysv_sb_info *sbi = SYSV_SB(sb);
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index e474fbcf8bde..b217797e621b 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -61,7 +61,7 @@ static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, st
         return NULL;
 }
 
-static int sysv_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev)
+static int sysv_mknod(struct inode * dir, struct dentry * dentry, umode_t mode, dev_t rdev)
 {
         struct inode * inode;
         int err;
@@ -80,7 +80,7 @@ static int sysv_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_
         return err;
 }
 
-static int sysv_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)
+static int sysv_create(struct inode * dir, struct dentry * dentry, umode_t mode, struct nameidata *nd)
 {
         return sysv_mknod(dir, dentry, mode, 0);
 }
@@ -131,7 +131,7 @@ static int sysv_link(struct dentry * old_dentry, struct inode * dir,
         return add_nondir(dentry, inode);
 }
 
-static int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode)
+static int sysv_mkdir(struct inode * dir, struct dentry *dentry, umode_t mode)
 {
         struct inode * inode;
         int err = -EMLINK;
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index bb55cdb394bf..0e4b821c5691 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -125,7 +125,7 @@ static inline void dirty_sb(struct super_block *sb)
 /* ialloc.c */
 extern struct sysv_inode *sysv_raw_inode(struct super_block *, unsigned,
                         struct buffer_head **);
-extern struct inode * sysv_new_inode(const struct inode *, mode_t);
+extern struct inode * sysv_new_inode(const struct inode *, umode_t);
 extern void sysv_free_inode(struct inode *);
 extern unsigned long sysv_count_free_inodes(struct super_block *);
 
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 683492043317..d6fe1c79f18b 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -56,7 +56,7 @@
  *
  * This function returns the inherited flags.
  */
-static int inherit_flags(const struct inode *dir, int mode)
+static int inherit_flags(const struct inode *dir, umode_t mode)
 {
         int flags;
         const struct ubifs_inode *ui = ubifs_inode(dir);
@@ -86,7 +86,7 @@ static int inherit_flags(const struct inode *dir, int mode)
  * case of failure.
  */
 struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
-                              int mode)
+                              umode_t mode)
 {
         struct inode *inode;
         struct ubifs_inode *ui;
@@ -253,7 +253,7 @@ out:
         return ERR_PTR(err);
 }
 
-static int ubifs_create(struct inode *dir, struct dentry *dentry, int mode,
+static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                         struct nameidata *nd)
 {
         struct inode *inode;
@@ -268,7 +268,7 @@ static int ubifs_create(struct inode *dir, struct dentry *dentry, int mode,
          * parent directory inode.
          */
 
-        dbg_gen("dent '%.*s', mode %#x in dir ino %lu",
+        dbg_gen("dent '%.*s', mode %#hx in dir ino %lu",
                 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
 
         err = ubifs_budget_space(c, &req);
@@ -712,7 +712,7 @@ out_cancel:
         return err;
 }
 
-static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
@@ -725,7 +725,7 @@ static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
          * directory inode.
          */
 
-        dbg_gen("dent '%.*s', mode %#x in dir ino %lu",
+        dbg_gen("dent '%.*s', mode %#hx in dir ino %lu",
                 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
 
         err = ubifs_budget_space(c, &req);
@@ -769,7 +769,7 @@ out_budg:
 }
 
 static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
-                       int mode, dev_t rdev)
+                       umode_t mode, dev_t rdev)
 {
         struct inode *inode;
         struct ubifs_inode *ui;
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 27f22551f805..12e94774aa88 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -1734,7 +1734,7 @@ int ubifs_setattr(struct dentry *dentry, struct iattr *attr);
 
 /* dir.c */
 struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
-                              int mode);
+                              umode_t mode);
 int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
                   struct kstat *stat);
 
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index 6fb7e0adcda0..05ab48195be9 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -46,7 +46,7 @@ void udf_free_inode(struct inode *inode)
         udf_free_blocks(sb, NULL, &UDF_I(inode)->i_location, 0, 1);
 }
 
-struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
+struct inode *udf_new_inode(struct inode *dir, umode_t mode, int *err)
 {
         struct super_block *sb = dir->i_sb;
         struct udf_sb_info *sbi = UDF_SB(sb);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 4fd1d809738c..4598904be1bb 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -48,7 +48,7 @@ MODULE_LICENSE("GPL");
 
 #define EXTENT_MERGE_SIZE 5
 
-static mode_t udf_convert_permissions(struct fileEntry *);
+static umode_t udf_convert_permissions(struct fileEntry *);
 static int udf_update_inode(struct inode *, int);
 static void udf_fill_inode(struct inode *, struct buffer_head *);
 static int udf_sync_inode(struct inode *inode);
@@ -1452,9 +1452,9 @@ static int udf_alloc_i_data(struct inode *inode, size_t size)
         return 0;
 }
 
-static mode_t udf_convert_permissions(struct fileEntry *fe)
+static umode_t udf_convert_permissions(struct fileEntry *fe)
 {
-        mode_t mode;
+        umode_t mode;
         uint32_t permissions;
         uint32_t flags;
 
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 4639e137222f..08bf46edf9c4 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -552,7 +552,7 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
         return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
 }
 
-static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
+static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                       struct nameidata *nd)
 {
         struct udf_fileident_bh fibh;
@@ -596,7 +596,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
         return 0;
 }
 
-static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
+static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                      dev_t rdev)
 {
         struct inode *inode;
@@ -640,7 +640,7 @@ out:
         return err;
 }
 
-static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct inode *inode;
         struct udf_fileident_bh fibh;
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 7cbe669e1026..c94fc889a486 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -195,11 +195,11 @@ struct udf_options {
         unsigned int fileset;
         unsigned int rootdir;
         unsigned int flags;
-        mode_t umask;
+        umode_t umask;
         gid_t gid;
         uid_t uid;
-        mode_t fmode;
-        mode_t dmode;
+        umode_t fmode;
+        umode_t dmode;
         struct nls_table *nls_map;
 };
 
@@ -279,11 +279,11 @@ static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt)
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
                 seq_printf(seq, ",gid=%u", sbi->s_gid);
         if (sbi->s_umask != 0)
-                seq_printf(seq, ",umask=%o", sbi->s_umask);
+                seq_printf(seq, ",umask=%ho", sbi->s_umask);
         if (sbi->s_fmode != UDF_INVALID_MODE)
-                seq_printf(seq, ",mode=%o", sbi->s_fmode);
+                seq_printf(seq, ",mode=%ho", sbi->s_fmode);
         if (sbi->s_dmode != UDF_INVALID_MODE)
-                seq_printf(seq, ",dmode=%o", sbi->s_dmode);
+                seq_printf(seq, ",dmode=%ho", sbi->s_dmode);
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
                 seq_printf(seq, ",session=%u", sbi->s_session);
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
index 5142a82e3276..42ad69ac9576 100644
--- a/fs/udf/udf_sb.h
+++ b/fs/udf/udf_sb.h
@@ -50,7 +50,7 @@
 #define UDF_SPARABLE_MAP15              0x1522U
 #define UDF_METADATA_MAP25              0x2511U
 
-#define UDF_INVALID_MODE                ((mode_t)-1)
+#define UDF_INVALID_MODE                ((umode_t)-1)
 
 #pragma pack(1) /* XXX(hch): Why?  This file just defines in-core structures */
 
@@ -127,11 +127,11 @@ struct udf_sb_info {
         struct buffer_head      *s_lvid_bh;
 
         /* Default permissions */
-        mode_t                  s_umask;
+        umode_t                 s_umask;
         gid_t                   s_gid;
         uid_t                   s_uid;
-        mode_t                  s_fmode;
-        mode_t                  s_dmode;
+        umode_t                 s_fmode;
+        umode_t                 s_dmode;
         /* Lock protecting consistency of above permission settings */
         rwlock_t                s_cred_lock;
 
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index f34e6fc0cdaa..ebe10314e512 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -215,7 +215,7 @@ extern int udf_CS0toUTF8(struct ustr *, const struct ustr *);
 
 /* ialloc.c */
 extern void udf_free_inode(struct inode *);
-extern struct inode *udf_new_inode(struct inode *, int, int *);
+extern struct inode *udf_new_inode(struct inode *, umode_t, int *);
 
 /* truncate.c */
 extern void udf_truncate_tail_extent(struct inode *);
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 78a4c70d46b5..4ec5c1085a87 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -170,7 +170,7 @@ static void ufs2_init_inodes_chunk(struct super_block *sb,
  * For other inodes, search forward from the parent directory's block
  * group to find a free inode.
  */
-struct inode * ufs_new_inode(struct inode * dir, int mode)
+struct inode *ufs_new_inode(struct inode *dir, umode_t mode)
 {
         struct super_block * sb;
         struct ufs_sb_info * sbi;
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 879b13436fa4..9094e1d917be 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -583,7 +583,7 @@ static int ufs1_read_inode(struct inode *inode, struct ufs_inode *ufs_inode)
 {
         struct ufs_inode_info *ufsi = UFS_I(inode);
         struct super_block *sb = inode->i_sb;
-        mode_t mode;
+        umode_t mode;
 
         /*
          * Copy data to the in-core inode.
@@ -630,7 +630,7 @@ static int ufs2_read_inode(struct inode *inode, struct ufs2_inode *ufs2_inode)
 {
         struct ufs_inode_info *ufsi = UFS_I(inode);
         struct super_block *sb = inode->i_sb;
-        mode_t mode;
+        umode_t mode;
 
         UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
         /*
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index 639d49162241..38cac199edff 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -70,7 +70,7 @@ static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, stru
  * If the create succeeds, we fill in the inode information
  * with d_instantiate(). 
  */
-static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
+static int ufs_create (struct inode * dir, struct dentry * dentry, umode_t mode,
                 struct nameidata *nd)
 {
         struct inode *inode;
@@ -94,7 +94,7 @@ static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
         return err;
 }
 
-static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
+static int ufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 {
         struct inode *inode;
         int err;
@@ -180,7 +180,7 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
         return error;
 }
 
-static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+static int ufs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
 {
         struct inode * inode;
         int err = -EMLINK;
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index c26f2bcec264..528750b7e701 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -104,7 +104,7 @@ extern const struct address_space_operations ufs_aops;
 
 /* ialloc.c */
 extern void ufs_free_inode (struct inode *inode);
-extern struct inode * ufs_new_inode (struct inode *, int);
+extern struct inode * ufs_new_inode (struct inode *, umode_t);
 
 /* inode.c */
 extern struct inode *ufs_iget(struct super_block *, unsigned long);
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 169380e66057..dad1a31aa4fc 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -447,7 +447,7 @@ STATIC xfs_buf_t *			/* allocation group buffer */
 xfs_ialloc_ag_select(
         xfs_trans_t     *tp,            /* transaction pointer */
         xfs_ino_t       parent,         /* parent directory inode number */
-        mode_t          mode,           /* bits set to indicate file type */
+        umode_t         mode,           /* bits set to indicate file type */
         int             okalloc)        /* ok to allocate more space */
 {
         xfs_buf_t       *agbp;          /* allocation group header buffer */
@@ -640,7 +640,7 @@ int
 xfs_dialloc(
         xfs_trans_t     *tp,            /* transaction pointer */
         xfs_ino_t       parent,         /* parent inode (directory) */
-        mode_t          mode,           /* mode bits for new inode */
+        umode_t         mode,           /* mode bits for new inode */
         int             okalloc,        /* ok to allocate more space */
         xfs_buf_t       **IO_agbp,      /* in/out ag header's buffer */
         boolean_t       *alloc_done,    /* true if we needed to replenish
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/xfs_ialloc.h
index bb5385475e1f..666a037398d6 100644
--- a/fs/xfs/xfs_ialloc.h
+++ b/fs/xfs/xfs_ialloc.h
@@ -81,7 +81,7 @@ int					/* error */
 xfs_dialloc(
         struct xfs_trans *tp,           /* transaction pointer */
         xfs_ino_t       parent,         /* parent inode (directory) */
-        mode_t          mode,           /* mode bits for new inode */
+        umode_t         mode,           /* mode bits for new inode */
         int             okalloc,        /* ok to allocate more space */
         struct xfs_buf  **agbp,         /* buf for a.g. inode header */
         boolean_t       *alloc_done,    /* an allocation was done to replenish
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 755ee8164880..9dda7cc32848 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -961,7 +961,7 @@ int
 xfs_ialloc(
         xfs_trans_t     *tp,
         xfs_inode_t     *pip,
-        mode_t          mode,
+        umode_t         mode,
         xfs_nlink_t     nlink,
         xfs_dev_t       rdev,
         prid_t          prid,
@@ -1002,7 +1002,7 @@ xfs_ialloc(
                 return error;
         ASSERT(ip != NULL);
 
-        ip->i_d.di_mode = (__uint16_t)mode;
+        ip->i_d.di_mode = mode;
         ip->i_d.di_onlink = 0;
         ip->i_d.di_nlink = nlink;
         ASSERT(ip->i_d.di_nlink == nlink);
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index b4cd4739f98e..f0e6b151ba37 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -481,7 +481,7 @@ void		xfs_inode_free(struct xfs_inode *ip);
 /*
  * xfs_inode.c prototypes.
  */
-int             xfs_ialloc(struct xfs_trans *, xfs_inode_t *, mode_t,
+int             xfs_ialloc(struct xfs_trans *, xfs_inode_t *, umode_t,
                            xfs_nlink_t, xfs_dev_t, prid_t, int,
                            struct xfs_buf **, boolean_t *, xfs_inode_t **);
 
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 23ce927973a4..f9babd179223 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -168,7 +168,7 @@ STATIC int
 xfs_vn_mknod(
         struct inode    *dir,
         struct dentry   *dentry,
-        int             mode,
+        umode_t         mode,
         dev_t           rdev)
 {
         struct inode    *inode;
@@ -231,7 +231,7 @@ STATIC int
 xfs_vn_create(
         struct inode    *dir,
         struct dentry   *dentry,
-        int             mode,
+        umode_t         mode,
         struct nameidata *nd)
 {
         return xfs_vn_mknod(dir, dentry, mode, 0);
@@ -241,7 +241,7 @@ STATIC int
 xfs_vn_mkdir(
         struct inode    *dir,
         struct dentry   *dentry,
-        int             mode)
+        umode_t         mode)
 {
         return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
 }
@@ -366,7 +366,7 @@ xfs_vn_symlink(
         struct xfs_inode *cip = NULL;
         struct xfs_name name;
         int             error;
-        mode_t          mode;
+        umode_t         mode;
 
         mode = S_IFLNK |
                 (irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 8b32d1a4c5a1..89dbb4a50872 100644
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -53,7 +53,7 @@ xfs_dir_ialloc(
                                            output: may be a new transaction. */
         xfs_inode_t     *dp,            /* directory within whose allocate
                                            the inode. */
-        mode_t          mode,
+        umode_t         mode,
         xfs_nlink_t     nlink,
         xfs_dev_t       rdev,
         prid_t          prid,           /* project id */
diff --git a/fs/xfs/xfs_utils.h b/fs/xfs/xfs_utils.h
index 456fca314933..5eeab4690cfe 100644
--- a/fs/xfs/xfs_utils.h
+++ b/fs/xfs/xfs_utils.h
@@ -18,7 +18,7 @@
 #ifndef __XFS_UTILS_H__
 #define __XFS_UTILS_H__
 
-extern int xfs_dir_ialloc(xfs_trans_t **, xfs_inode_t *, mode_t, xfs_nlink_t,
+extern int xfs_dir_ialloc(xfs_trans_t **, xfs_inode_t *, umode_t, xfs_nlink_t,
                                 xfs_dev_t, prid_t, int, xfs_inode_t **, int *);
 extern int xfs_droplink(xfs_trans_t *, xfs_inode_t *);
 extern int xfs_bumplink(xfs_trans_t *, xfs_inode_t *);
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index ce9268a2f56b..f2fea868d4db 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -822,7 +822,7 @@ int
 xfs_create(
         xfs_inode_t             *dp,
         struct xfs_name         *name,
-        mode_t                  mode,
+        umode_t                 mode,
         xfs_dev_t               rdev,
         xfs_inode_t             **ipp)
 {
@@ -1481,7 +1481,7 @@ xfs_symlink(
         xfs_inode_t             *dp,
         struct xfs_name         *link_name,
         const char              *target_path,
-        mode_t                  mode,
+        umode_t                 mode,
         xfs_inode_t             **ipp)
 {
         xfs_mount_t             *mp = dp->i_mount;
diff --git a/fs/xfs/xfs_vnodeops.h b/fs/xfs/xfs_vnodeops.h
index 35d3d513e1e9..0c877cbde142 100644
--- a/fs/xfs/xfs_vnodeops.h
+++ b/fs/xfs/xfs_vnodeops.h
@@ -26,7 +26,7 @@ int xfs_release(struct xfs_inode *ip);
 int xfs_inactive(struct xfs_inode *ip);
 int xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
                 struct xfs_inode **ipp, struct xfs_name *ci_name);
-int xfs_create(struct xfs_inode *dp, struct xfs_name *name, mode_t mode,
+int xfs_create(struct xfs_inode *dp, struct xfs_name *name, umode_t mode,
                 xfs_dev_t rdev, struct xfs_inode **ipp);
 int xfs_remove(struct xfs_inode *dp, struct xfs_name *name,
                 struct xfs_inode *ip);
@@ -35,7 +35,7 @@ int xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,
 int xfs_readdir(struct xfs_inode        *dp, void *dirent, size_t bufsize,
                        xfs_off_t *offset, filldir_t filldir);
 int xfs_symlink(struct xfs_inode *dp, struct xfs_name *link_name,
-                const char *target_path, mode_t mode, struct xfs_inode **ipp);
+                const char *target_path, umode_t mode, struct xfs_inode **ipp);
 int xfs_set_dmattrs(struct xfs_inode *ip, u_int evmask, u_int16_t state);
 int xfs_change_file_space(struct xfs_inode *ip, int cmd,
                 xfs_flock64_t *bf, xfs_off_t offset, int attr_flags);