NEW API:ext:mke2fs

New api mke2fs for full configuration of filesystem.

Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>

RWMJ:
 - Update description.
 - Run and fix the tests.
 - Remove bogus filename from po/POTFILES.

1 files changed, 368 insertions, 1 deletions

diff --git a/daemon/ext2.c b/daemon/ext2.c
index 40b36d29..7fc1172d 100644
--- a/daemon/ext2.c
+++ b/daemon/ext2.c
@@ -29,7 +29,7 @@
 #include "c-ctype.h"
 #include "actions.h"
 
-#define MAX_ARGS 64
+#define MAX_ARGS 128
 
 GUESTFSD_EXT_CMD(str_tune2fs, tune2fs);
 GUESTFSD_EXT_CMD(str_e2fsck, e2fsck);
@@ -811,3 +811,370 @@ do_set_e2generation (const char *filename, int64_t generation)
 
   return 0;
 }
+
+int
+do_mke2fs (const char *device,               /* 0 */
+           int64_t blockscount,
+           int64_t blocksize,
+           int64_t fragsize,
+           int64_t blockspergroup,
+           int64_t numberofgroups,           /* 5 */
+           int64_t bytesperinode,
+           int64_t inodesize,
+           int64_t journalsize,
+           int64_t numberofinodes,
+           int64_t stridesize,               /* 10 */
+           int64_t stripewidth,
+           int64_t maxonlineresize,
+           int reservedblockspercentage,
+           int mmpupdateinterval,
+           const char *journaldevice,        /* 15 */
+           const char *label,
+           const char *lastmounteddir,
+           const char *creatoros,
+           const char *fstype,
+           const char *usagetype,            /* 20 */
+           const char *uuid,
+           int forcecreate,
+           int writesbandgrouponly,
+           int lazyitableinit,
+           int lazyjournalinit,              /* 25 */
+           int testfs,
+           int discard,
+           int quotatype,
+           int extent,
+           int filetype,                     /* 30 */
+           int flexbg,
+           int hasjournal,
+           int journaldev,
+           int largefile,
+           int quota,                        /* 35 */
+           int resizeinode,
+           int sparsesuper,
+           int uninitbg)
+{
+  int r;
+  char *err = NULL;
+  const char *argv[MAX_ARGS];
+  char blockscount_s[64];
+  char blocksize_s[64];
+  char fragsize_s[64];
+  char blockspergroup_s[64];
+  char numberofgroups_s[64];
+  char bytesperinode_s[64];
+  char inodesize_s[64];
+  char journalsize_s[64];
+  char journaldevice_s[256];
+  char reservedblockspercentage_s[64];
+  char numberofinodes_s[64];
+  char mmpupdateinterval_s[84];
+  char stridesize_s[74];
+  char stripewidth_s[84];
+  char maxonlineresize_s[74];
+  size_t i = 0;
+
+  ADD_ARG (argv, i, str_mke2fs);
+
+  if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSIZE_BITMASK) {
+    if (blocksize < 0) {
+      reply_with_error ("blocksize must be >= 0");
+      goto error;
+    }
+    snprintf (blocksize_s, sizeof blocksize_s, "%" PRIi64, blocksize);
+    ADD_ARG (argv, i, "-b");
+    ADD_ARG (argv, i, blocksize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_FRAGSIZE_BITMASK) {
+    if (fragsize < 0) {
+      reply_with_error ("fragsize must be >= 0");
+      goto error;
+    }
+    snprintf (fragsize_s, sizeof fragsize_s, "%" PRIi64, fragsize);
+    ADD_ARG (argv, i, "-f");
+    ADD_ARG (argv, i, fragsize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_FORCECREATE_BITMASK) {
+    if (forcecreate)
+      ADD_ARG (argv, i, "-F");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSPERGROUP_BITMASK) {
+    if (blockspergroup < 0) {
+      reply_with_error ("blockspergroup must be >= 0");
+      goto error;
+    }
+    snprintf (blockspergroup_s, sizeof blockspergroup_s,
+              "%" PRIi64, blockspergroup);
+    ADD_ARG (argv, i, "-g");
+    ADD_ARG (argv, i, blockspergroup_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_NUMBEROFGROUPS_BITMASK) {
+    if (numberofgroups < 0) {
+      reply_with_error ("numberofgroups must be >= 0");
+      goto error;
+    }
+    snprintf (numberofgroups_s, sizeof numberofgroups_s,
+              "%" PRIi64, numberofgroups);
+    ADD_ARG (argv, i, "-G");
+    ADD_ARG (argv, i, numberofgroups_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_BYTESPERINODE_BITMASK) {
+    if (bytesperinode < 0) {
+      reply_with_error ("bytesperinode must be >= 0");
+      goto error;
+    }
+    snprintf (bytesperinode_s, sizeof bytesperinode_s, "%" PRIi64, bytesperinode);
+    ADD_ARG (argv, i, "-i");
+    ADD_ARG (argv, i, bytesperinode_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_INODESIZE_BITMASK) {
+    if (inodesize < 0) {
+      reply_with_error ("inodesize must be >= 0");
+      goto error;
+    }
+    snprintf (inodesize_s, sizeof inodesize_s, "%" PRIi64, inodesize);
+    ADD_ARG (argv, i, "-I");
+    ADD_ARG (argv, i, inodesize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALSIZE_BITMASK) {
+    if (journalsize < 0) {
+      reply_with_error ("journalsize must be >= 0");
+      goto error;
+    }
+    snprintf (journalsize_s, sizeof journalsize_s,
+              "size=" "%" PRIi64, journalsize);
+    ADD_ARG (argv, i, "-J");
+    ADD_ARG (argv, i, journalsize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALDEVICE_BITMASK) {
+    if (journaldevice) {
+      snprintf (journaldevice_s, sizeof journaldevice_s,
+                "device=%s", journaldevice);
+      ADD_ARG (argv, i, "-J");
+      ADD_ARG (argv, i, journaldevice_s);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_LABEL_BITMASK) {
+    if (label) {
+      ADD_ARG (argv, i, "-L");
+      ADD_ARG (argv, i, label);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_RESERVEDBLOCKSPERCENTAGE_BITMASK) {
+    if (reservedblockspercentage < 0) {
+      reply_with_error ("reservedblockspercentage must be >= 0");
+      goto error;
+    }
+    snprintf (reservedblockspercentage_s, sizeof reservedblockspercentage_s,
+              "%" PRIi32, reservedblockspercentage);
+    ADD_ARG (argv, i, "-m");
+    ADD_ARG (argv, i, reservedblockspercentage_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_LASTMOUNTEDDIR_BITMASK) {
+    if (lastmounteddir) {
+      ADD_ARG (argv, i, "-M");
+      ADD_ARG (argv, i, lastmounteddir);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_NUMBEROFINODES_BITMASK) {
+    if (numberofinodes < 0) {
+      reply_with_error ("numberofinodes must be >= 0");
+      goto error;
+    }
+    snprintf (numberofinodes_s, sizeof numberofinodes_s,
+              "%" PRIi64, numberofinodes);
+    ADD_ARG (argv, i, "-N");
+    ADD_ARG (argv, i, numberofinodes_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_CREATOROS_BITMASK) {
+    if (creatoros) {
+      ADD_ARG (argv, i, "-o");
+      ADD_ARG (argv, i, creatoros);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_WRITESBANDGROUPONLY_BITMASK) {
+    if (writesbandgrouponly)
+      ADD_ARG (argv, i, "-S");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_FSTYPE_BITMASK) {
+    if (fstype) {
+      ADD_ARG (argv, i, "-t");
+      ADD_ARG (argv, i, fstype);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_USAGETYPE_BITMASK) {
+    if (usagetype) {
+      ADD_ARG (argv, i, "-T");
+      ADD_ARG (argv, i, usagetype);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_UUID_BITMASK) {
+    if (uuid) {
+      ADD_ARG (argv, i, "-U");
+      ADD_ARG (argv, i, uuid);
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_MMPUPDATEINTERVAL_BITMASK) {
+    if (mmpupdateinterval < 0) {
+      reply_with_error ("mmpupdateinterval must be >= 0");
+      goto error;
+    }
+    snprintf (mmpupdateinterval_s, sizeof mmpupdateinterval_s,
+              "mmp_update_interval=" "%" PRIi32, mmpupdateinterval);
+    ADD_ARG (argv, i, "-E");
+    ADD_ARG (argv, i, mmpupdateinterval_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_STRIDESIZE_BITMASK) {
+    if (stridesize < 0) {
+      reply_with_error ("stridesize must be >= 0");
+      goto error;
+    }
+    snprintf (stridesize_s, sizeof stridesize_s,
+              "stride=" "%" PRIi64, stridesize);
+    ADD_ARG (argv, i, "-E");
+    ADD_ARG (argv, i, stridesize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_STRIPEWIDTH_BITMASK) {
+    if (stripewidth< 0) {
+      reply_with_error ("stripewidth must be >= 0");
+      goto error;
+    }
+    snprintf (stripewidth_s, sizeof stripewidth_s,
+              "stripe_width=" "%" PRIi64, stripewidth);
+    ADD_ARG (argv, i, "-E");
+    ADD_ARG (argv, i, stripewidth_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_MAXONLINERESIZE_BITMASK) {
+    if (maxonlineresize < 0) {
+      reply_with_error ("maxonlineresize must be >= 0");
+      goto error;
+    }
+    snprintf (maxonlineresize_s, sizeof maxonlineresize_s,
+              "resize=" "%" PRIi64, maxonlineresize);
+    ADD_ARG (argv, i, "-E");
+    ADD_ARG (argv, i, maxonlineresize_s);
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_LAZYITABLEINIT_BITMASK) {
+    ADD_ARG (argv, i, "-E");
+    if (lazyitableinit)
+      ADD_ARG (argv, i, "lazy_itable_init=1");
+    else
+      ADD_ARG (argv, i, "lazy_itable_init=0");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_LAZYJOURNALINIT_BITMASK) {
+    ADD_ARG (argv, i, "-E");
+    if (lazyjournalinit)
+      ADD_ARG (argv, i, "lazy_journal_init=1");
+    else
+      ADD_ARG (argv, i, "lazy_journal_init=0");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_TESTFS_BITMASK) {
+    if (testfs) {
+      ADD_ARG (argv, i, "-E");
+      ADD_ARG (argv, i, "test_fs");
+    }
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_DISCARD_BITMASK) {
+    ADD_ARG (argv, i, "-E");
+    if (discard)
+      ADD_ARG (argv, i, "discard");
+    else
+      ADD_ARG (argv, i, "nodiscard");
+  }
+
+  if (optargs_bitmask & GUESTFS_MKE2FS_EXTENT_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (extent)
+      ADD_ARG (argv, i, "extent");
+    else
+      ADD_ARG (argv, i, "^extent");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_FILETYPE_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (filetype)
+      ADD_ARG (argv, i, "filetype");
+    else
+      ADD_ARG (argv, i, "^filetype");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_FLEXBG_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (flexbg)
+      ADD_ARG (argv, i, "flexbg");
+    else
+      ADD_ARG (argv, i, "^flexbg");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_HASJOURNAL_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (hasjournal)
+      ADD_ARG (argv, i, "has_journal");
+    else
+      ADD_ARG (argv, i, "^has_journal");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALDEV_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (journaldev)
+      ADD_ARG (argv, i, "journal_dev");
+    else
+      ADD_ARG (argv, i, "^journal_dev");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_LARGEFILE_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (largefile)
+      ADD_ARG (argv, i, "large_file");
+    else
+      ADD_ARG (argv, i, "^large_file");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_QUOTA_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (quota)
+      ADD_ARG (argv, i, "quota");
+    else
+      ADD_ARG (argv, i, "^quota");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_RESIZEINODE_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (resizeinode)
+      ADD_ARG (argv, i, "resize_inode");
+    else
+      ADD_ARG (argv, i, "^resize_inode");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_SPARSESUPER_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (sparsesuper)
+      ADD_ARG (argv, i, "sparse_super");
+    else
+      ADD_ARG (argv, i, "^sparse_super");
+  }
+  if (optargs_bitmask & GUESTFS_MKE2FS_UNINITBG_BITMASK) {
+    ADD_ARG (argv, i, "-O");
+    if (uninitbg)
+      ADD_ARG (argv, i, "uninit_bg");
+    else
+      ADD_ARG (argv, i, "^uninit_bg");
+  }
+
+  ADD_ARG (argv, i, device);
+
+  if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSCOUNT_BITMASK) {
+    if (blockscount < 0) {
+      reply_with_error ("blockscount must be >= 0");
+      goto error;
+    }
+    snprintf (blockscount_s, sizeof blockscount_s, "%" PRIi64, blockscount);
+    ADD_ARG (argv, i, blockscount_s);
+  }
+
+  ADD_ARG (argv, i, NULL);
+
+  r = commandv (NULL, &err, argv);
+  if (r == -1) {
+    reply_with_error ("%s: %s", device, err);
+    goto error;
+  }
+
+  free (err);
+  return 0;
+
+error:
+  if (err) free (err);
+  return -1;
+}