LU-2155 utils: Enable ldiskfs mmp on tunefs failover add

[fs/lustre-release.git] / lustre / utils / mount_utils_ldiskfs.c

diff --git a/lustre/utils/mount_utils_ldiskfs.c b/lustre/utils/mount_utils_ldiskfs.c
index b1edf54..2620238 100644 (file)
--- a/lustre/utils/mount_utils_ldiskfs.c
+++ b/lustre/utils/mount_utils_ldiskfs.c
@@ -66,8 +66,8 @@
 #ifndef BLKGETSIZE64
 #include <linux/fs.h> /* for BLKGETSIZE64 */
 #endif
+#include <linux/types.h>
 #include <linux/version.h>
-#include <lustre_disk.h>
 #include <lustre_param.h>
 #include <lnet/lnetctl.h>
 #include <lustre_ver.h>
@@ -94,6 +94,8 @@ extern char *progname;
 
 static void append_unique(char *buf, char *prefix, char *key, char *val,
                          size_t maxbuflen);
+static int is_e2fsprogs_feature_supp(const char *feature);
+static void disp_old_e2fsprogs_msg(const char *feature, int make_backfs);
 
 /*
  * Concatenate context of the temporary mount point if selinux is enabled
@@ -264,6 +266,23 @@ int ldiskfs_write_ldd(struct mkfs_opts *mop)
        if (mop->mo_flags & MO_IS_LOOP)
                dev = mop->mo_loopdev;
 
+       /* Multiple mount protection enabled if failover node specified */
+       if (mop->mo_flags & MO_FAILOVER &&
+           !is_feature_enabled("mmp", dev)) {
+               if (is_e2fsprogs_feature_supp("-O mmp") == 0) {
+                       char *command = filepnm;
+
+                       snprintf(command, sizeof(filepnm),
+                                TUNE2FS" -O mmp '%s' >/dev/null 2>&1", dev);
+                       ret = run_command(command, sizeof(filepnm));
+                       if (ret)
+                               fprintf(stderr,
+                                       "%s: Unable to set 'mmp' on %s: %d\n",
+                                       progname, dev, ret);
+               } else
+                       disp_old_e2fsprogs_msg("mmp", 1);
+       }
+
        ret = mount(dev, mntpt, MT_STR(&mop->mo_ldd), 0,
                (mop->mo_mountopts == NULL) ?
                "errors=remount-ro" : mop->mo_mountopts);
@@ -389,6 +408,15 @@ int ldiskfs_read_ldd(char *dev, struct lustre_disk_data *mo_ldd)
        return ret;
 }
 
+int ldiskfs_erase_ldd(struct mkfs_opts *mop, char *param)
+{
+       return 0;
+}
+
+void ldiskfs_print_ldd_params(struct mkfs_opts *mop)
+{
+       printf("Parameters:%s\n", mop->mo_ldd.ldd_params);
+}
 
 /* Display the need for the latest e2fsprogs to be installed. make_backfs
  * indicates if the caller is make_lustre_backfs() or not. */
@@ -747,11 +775,17 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop)
                        }
                }
 
-               /* Inode size includes:
+               /*
+                * The inode size is constituted by following elements
+                * (assuming all files are in composite layout and has
+                * 3 components):
+                *
                 *   ldiskfs inode size: 156
                 *   extended attributes size, including:
                 *      ext4_xattr_header: 32
-                *      LOV EA size: 32(lov_mds_md) +
+                *      LOV EA size: 32(lov_comp_md_v1) +
+                *                   3 * 40(lov_comp_md_entry_v1) +
+                *                   3 * 32(lov_mds_md) +
                 *                   stripes * 24(lov_ost_data) +
                 *                   16(xattr_entry) + 3(lov)
                 *      LMA EA size: 24(lustre_mdt_attrs) +
@@ -762,24 +796,22 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop)
                 *
                 * If we say the average filename length is about 32 bytes,
                 * the calculation looks like:
-                * 156 + 32 + (32+24*N+19) + (24+19) + (24+18+~32+20) + other <=
-                * 512*2^m, {m=0,1,2,3}
+                * 156 + 32 + (32+3*(40 + 32)+24*N+19) + (24+19) +
+                * (24+18+~32+20) + other <= 512*2^m, {m=0,1,2,3}
                 */
                if (strstr(mop->mo_mkfsopts, "-I") == NULL) {
                        if (IS_MDT(&mop->mo_ldd)) {
-                               if (mop->mo_stripe_count > 69)
+                               if (mop->mo_stripe_count > 59)
                                        inode_size = 512; /* bz 7241 */
                                /* see also "-i" below for EA blocks */
-                               else if (mop->mo_stripe_count > 26)
+                               else if (mop->mo_stripe_count > 16)
                                        inode_size = 2048;
-                               else if (mop->mo_stripe_count > 5)
-                                       inode_size = 1024;
                                else
-                                       inode_size = 512;
+                                       inode_size = 1024;
                        } else if (IS_OST(&mop->mo_ldd)) {
-                               /* We store MDS FID and OST objid in EA on OST
-                                * we need to make inode bigger as well. */
-                               inode_size = 256;
+                               /* We store MDS FID and necessary composite
+                                * layout information in the OST object EA. */
+                               inode_size = 512;
                        }
 
                        if (inode_size > 0) {
@@ -802,7 +834,7 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop)
                        if (IS_MDT(&mop->mo_ldd)) {
                                bytes_per_inode = inode_size + 1536;
 
-                               if (mop->mo_stripe_count > 69) {
+                               if (mop->mo_stripe_count > 59) {
                                        int extra = mop->mo_stripe_count * 24;
                                        extra = ((extra - 1) | 4095) + 1;
                                        bytes_per_inode += extra;