X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fext2.c;h=79fd35493f40e8351f63807218b1bf74d848f841;hp=956c71936687282dfdb8c415ce2d760d75ad3a74;hb=c81a16a4e2e703d0aaa595151602bcf03430f6ab;hpb=9b41eeb91733ee681a6a804464b6930d42ed8fd1

diff --git a/daemon/ext2.c b/daemon/ext2.c
index 956c719..79fd354 100644
--- a/daemon/ext2.c
+++ b/daemon/ext2.c
@@ -13,20 +13,53 @@
  *
  * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #include <config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
 #include <unistd.h>
-#include <ctype.h>
 
-#include "../src/guestfs_protocol.h"
+#include "guestfs_protocol.h"
 #include "daemon.h"
+#include "c-ctype.h"
 #include "actions.h"
 
+/* Confirmed this is true up to ext4 from the Linux sources. */
+#define EXT2_LABEL_MAX 16
+
+#define MAX_ARGS 64
+
+/* Choose which tools like mke2fs to use.  For RHEL 5 (only) there
+ * is a special set of tools which support ext2/3/4.  eg. On RHEL 5,
+ * mke2fs only supports ext2/3, but mke4fs supports ext2/3/4.
+ *
+ * We specify e4fsprogs in the package list to ensure it is loaded
+ * if it exists.
+ */
+int
+e2prog (char *name)
+{
+  char *p = strstr (name, "e2");
+  if (!p) return 0;
+  p++;
+
+  *p = '4';
+  if (prog_exists (name))
+    return 0;
+
+  *p = '2';
+  if (prog_exists (name))
+    return 0;
+
+  reply_with_error ("cannot find required program %s", name);
+  return -1;
+}
+
 char **
 do_tune2fs_l (const char *device)
 {
@@ -36,9 +69,13 @@ do_tune2fs_l (const char *device)
   char **ret = NULL;
   int size = 0, alloc = 0;
 
-  r = command (&out, &err, "/sbin/tune2fs", "-l", device, NULL);
+  char prog[] = "tune2fs";
+  if (e2prog (prog) == -1)
+    return NULL;
+
+  r = command (&out, &err, prog, "-l", device, NULL);
   if (r == -1) {
-    reply_with_error ("tune2fs: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     free (out);
     return NULL;
@@ -48,11 +85,11 @@ do_tune2fs_l (const char *device)
   p = out;
 
   /* Discard the first line if it contains "tune2fs ...". */
-  if (strncmp (p, "tune2fs ", 8) == 0) {
+  if (STRPREFIX (p, "tune2fs ") || STRPREFIX (p, "tune4fs ")) {
     p = strchr (p, '\n');
     if (p) p++;
     else {
-      reply_with_error ("tune2fs: truncated output");
+      reply_with_error ("truncated output");
       free (out);
       return NULL;
     }
@@ -72,15 +109,15 @@ do_tune2fs_l (const char *device)
     if (colon) {
       *colon = '\0';
 
-      do { colon++; } while (*colon && isspace (*colon));
+      do { colon++; } while (*colon && c_isspace (*colon));
 
       if (add_string (&ret, &size, &alloc, p) == -1) {
         free (out);
         return NULL;
       }
-      if (strcmp (colon, "<none>") == 0 ||
-          strcmp (colon, "<not available>") == 0 ||
-          strcmp (colon, "(none)") == 0) {
+      if (STREQ (colon, "<none>") ||
+          STREQ (colon, "<not available>") ||
+          STREQ (colon, "(none)")) {
         if (add_string (&ret, &size, &alloc, "") == -1) {
           free (out);
           return NULL;
@@ -120,9 +157,19 @@ do_set_e2label (const char *device, const char *label)
   int r;
   char *err;
 
-  r = command (NULL, &err, "/sbin/e2label", device, label, NULL);
+  char prog[] = "e2label";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  if (strlen (label) > EXT2_LABEL_MAX) {
+    reply_with_error ("%s: ext2 labels are limited to %d bytes",
+                      label, EXT2_LABEL_MAX);
+    return -1;
+  }
+
+  r = command (NULL, &err, prog, device, label, NULL);
   if (r == -1) {
-    reply_with_error ("e2label: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -134,25 +181,7 @@ do_set_e2label (const char *device, const char *label)
 char *
 do_get_e2label (const char *device)
 {
-  int r, len;
-  char *out, *err;
-
-  r = command (&out, &err, "/sbin/e2label", device, NULL);
-  if (r == -1) {
-    reply_with_error ("e2label: %s", err);
-    free (out);
-    free (err);
-    return NULL;
-  }
-
-  free (err);
-
-  /* Remove any trailing \n from the label. */
-  len = strlen (out);
-  if (len > 0 && out[len-1] == '\n')
-    out[len-1] = '\0';
-
-  return out;			/* caller frees */
+  return do_vfs_label (device);
 }
 
 int
@@ -161,9 +190,13 @@ do_set_e2uuid (const char *device, const char *uuid)
   int r;
   char *err;
 
-  r = command (NULL, &err, "/sbin/tune2fs", "-U", uuid, device, NULL);
+  char prog[] = "tune2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  r = command (NULL, &err, prog, "-U", uuid, device, NULL);
   if (r == -1) {
-    reply_with_error ("tune2fs -U: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -175,73 +208,78 @@ do_set_e2uuid (const char *device, const char *uuid)
 char *
 do_get_e2uuid (const char *device)
 {
+  return do_vfs_uuid (device);
+}
+
+int
+do_resize2fs (const char *device)
+{
+  char *err;
   int r;
-  char *out, *err, *p, *q;
 
-  /* It's not so straightforward to get the volume UUID.  We have
-   * to use tune2fs -l and then look for a particular string in
-   * the output.
-   */
+  char prog[] = "resize2fs";
+  if (e2prog (prog) == -1)
+    return -1;
 
-  r = command (&out, &err, "/sbin/tune2fs", "-l", device, NULL);
+  r = command (NULL, &err, prog, device, NULL);
   if (r == -1) {
-    reply_with_error ("tune2fs -l: %s", err);
-    free (out);
+    reply_with_error ("%s", err);
     free (err);
-    return NULL;
+    return -1;
   }
 
   free (err);
+  return 0;
+}
 
-  /* Look for /\nFilesystem UUID:\s+/ in the output. */
-  p = strstr (out, "\nFilesystem UUID:");
-  if (p == NULL) {
-    reply_with_error ("no Filesystem UUID in the output of tune2fs -l");
-    free (out);
-    return NULL;
-  }
+int
+do_resize2fs_size (const char *device, int64_t size)
+{
+  char *err;
+  int r;
 
-  p += 17;
-  while (*p && isspace (*p))
-    p++;
-  if (!*p) {
-    reply_with_error ("malformed Filesystem UUID in the output of tune2fs -l");
-    free (out);
-    return NULL;
-  }
+  char prog[] = "resize2fs";
+  if (e2prog (prog) == -1)
+    return -1;
 
-  /* Now 'p' hopefully points to the start of the UUID. */
-  q = p;
-  while (*q && (isxdigit (*q) || *q == '-'))
-    q++;
-  if (!*q) {
-    reply_with_error ("malformed Filesystem UUID in the output of tune2fs -l");
-    free (out);
-    return NULL;
+  /* resize2fs itself may impose additional limits.  Since we are
+   * going to use the 'K' suffix however we can only work with whole
+   * kilobytes.
+   */
+  if (size & 1023) {
+    reply_with_error ("%" PRIi64 ": size must be a round number of kilobytes",
+                      size);
+    return -1;
   }
+  size /= 1024;
 
-  *q = '\0';
+  char buf[32];
+  snprintf (buf, sizeof buf, "%" PRIi64 "K", size);
 
-  p = strdup (p);
-  if (!p) {
-    reply_with_perror ("strdup");
-    free (out);
-    return NULL;
+  r = command (NULL, &err, prog, device, buf, NULL);
+  if (r == -1) {
+    reply_with_error ("%s", err);
+    free (err);
+    return -1;
   }
 
-  free (out);
-  return p;			/* caller frees */
+  free (err);
+  return 0;
 }
 
 int
-do_resize2fs (const char *device)
+do_resize2fs_M (const char *device)
 {
   char *err;
   int r;
 
-  r = command (NULL, &err, "/sbin/resize2fs", device, NULL);
+  char prog[] = "resize2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  r = command (NULL, &err, prog, "-M" , device, NULL);
   if (r == -1) {
-    reply_with_error ("resize2fs: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -256,9 +294,20 @@ do_e2fsck_f (const char *device)
   char *err;
   int r;
 
-  r = command (NULL, &err, "/sbin/e2fsck", "-p", "-f", device, NULL);
-  if (r == -1) {
-    reply_with_error ("e2fsck: %s", err);
+  char prog[] = "e2fsck";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  /* 0 = no errors, 1 = errors corrected.
+   *
+   * >= 4 means uncorrected or other errors.
+   *
+   * 2, 3 means errors were corrected and we require a reboot.  This is
+   * a difficult corner case.
+   */
+  r = commandr (NULL, &err, prog, "-p", "-f", device, NULL);
+  if (r == -1 || r >= 2) {
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -273,14 +322,18 @@ do_mke2journal (int blocksize, const char *device)
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-O", "journal_dev", "-b", blocksize_s,
+               prog, "-O", "journal_dev", "-b", blocksize_s,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2journal: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -295,15 +348,25 @@ do_mke2journal_L (int blocksize, const char *label, const char *device)
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  if (strlen (label) > EXT2_LABEL_MAX) {
+    reply_with_error ("%s: ext2 labels are limited to %d bytes",
+                      label, EXT2_LABEL_MAX);
+    return -1;
+  }
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-O", "journal_dev", "-b", blocksize_s,
+               prog, "-O", "journal_dev", "-b", blocksize_s,
                "-L", label,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2journal_L: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -318,15 +381,19 @@ do_mke2journal_U (int blocksize, const char *uuid, const char *device)
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-O", "journal_dev", "-b", blocksize_s,
+               prog, "-O", "journal_dev", "-b", blocksize_s,
                "-U", uuid,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2journal_U: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -342,6 +409,10 @@ do_mke2fs_J (const char *fstype, int blocksize, const char *device,
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
@@ -350,10 +421,10 @@ do_mke2fs_J (const char *fstype, int blocksize, const char *device,
   snprintf (jdev, len+32, "device=%s", journal);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-t", fstype, "-J", jdev, "-b", blocksize_s,
+               prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2fs_J: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -369,6 +440,16 @@ do_mke2fs_JL (const char *fstype, int blocksize, const char *device,
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
+  if (strlen (label) > EXT2_LABEL_MAX) {
+    reply_with_error ("%s: ext2 labels are limited to %d bytes",
+                      label, EXT2_LABEL_MAX);
+    return -1;
+  }
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
@@ -377,10 +458,10 @@ do_mke2fs_JL (const char *fstype, int blocksize, const char *device,
   snprintf (jdev, len+32, "device=LABEL=%s", label);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-t", fstype, "-J", jdev, "-b", blocksize_s,
+               prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2fs_JL: %s", err);
+    reply_with_error ("%s", err);
     free (err);
     return -1;
   }
@@ -396,6 +477,10 @@ do_mke2fs_JU (const char *fstype, int blocksize, const char *device,
   char *err;
   int r;
 
+  char prog[] = "mke2fs";
+  if (e2prog (prog) == -1)
+    return -1;
+
   char blocksize_s[32];
   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
 
@@ -404,10 +489,157 @@ do_mke2fs_JU (const char *fstype, int blocksize, const char *device,
   snprintf (jdev, len+32, "device=UUID=%s", uuid);
 
   r = command (NULL, &err,
-               "/sbin/mke2fs", "-t", fstype, "-J", jdev, "-b", blocksize_s,
+               prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
                device, NULL);
   if (r == -1) {
-    reply_with_error ("mke2fs_JU: %s", err);
+    reply_with_error ("%s", err);
+    free (err);
+    return -1;
+  }
+
+  free (err);
+  return 0;
+}
+
+/* Takes optional arguments, consult optargs_bitmask. */
+int
+do_tune2fs (const char *device, /* only required parameter */
+            int force,
+            int maxmountcount,
+            int mountcount,
+            const char *errorbehavior,
+            int64_t group,
+            int intervalbetweenchecks,
+            int reservedblockspercentage,
+            const char *lastmounteddirectory,
+            int64_t reservedblockscount,
+            int64_t user)
+{
+  const char *argv[MAX_ARGS];
+  size_t i = 0;
+  int r;
+  char *err;
+  char prog[] = "tune2fs";
+  char maxmountcount_s[64];
+  char mountcount_s[64];
+  char group_s[64];
+  char intervalbetweenchecks_s[64];
+  char reservedblockspercentage_s[64];
+  char reservedblockscount_s[64];
+  char user_s[64];
+
+  if (e2prog (prog) == -1)
+    return -1;
+
+  ADD_ARG (argv, i, prog);
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_FORCE_BITMASK) {
+    if (force)
+      ADD_ARG (argv, i, "-f");
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_MAXMOUNTCOUNT_BITMASK) {
+    if (maxmountcount < 0) {
+      reply_with_error ("maxmountcount cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-c");
+    snprintf (maxmountcount_s, sizeof maxmountcount_s, "%d", maxmountcount);
+    ADD_ARG (argv, i, maxmountcount_s);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_MOUNTCOUNT_BITMASK) {
+    if (mountcount < 0) {
+      reply_with_error ("mountcount cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-C");
+    snprintf (mountcount_s, sizeof mountcount_s, "%d", mountcount);
+    ADD_ARG (argv, i, mountcount_s);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_ERRORBEHAVIOR_BITMASK) {
+    if (STRNEQ (errorbehavior, "continue") &&
+        STRNEQ (errorbehavior, "remount-ro") &&
+        STRNEQ (errorbehavior, "panic")) {
+      reply_with_error ("invalid errorbehavior parameter: %s", errorbehavior);
+      return -1;
+    }
+    ADD_ARG (argv, i, "-e");
+    ADD_ARG (argv, i, errorbehavior);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_GROUP_BITMASK) {
+    if (group < 0) {
+      reply_with_error ("group cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-g");
+    snprintf (group_s, sizeof group_s, "%" PRIi64, group);
+    ADD_ARG (argv, i, group_s);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_INTERVALBETWEENCHECKS_BITMASK) {
+    if (intervalbetweenchecks < 0) {
+      reply_with_error ("intervalbetweenchecks cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-i");
+    if (intervalbetweenchecks > 0) {
+      /* -i <NN>s is not documented in the man page, but has been
+       * supported in tune2fs for several years.
+       */
+      snprintf (intervalbetweenchecks_s, sizeof intervalbetweenchecks_s,
+                "%ds", intervalbetweenchecks);
+      ADD_ARG (argv, i, intervalbetweenchecks_s);
+    }
+    else
+      ADD_ARG (argv, i, "0");
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_RESERVEDBLOCKSPERCENTAGE_BITMASK) {
+    if (reservedblockspercentage < 0) {
+      reply_with_error ("reservedblockspercentage cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-m");
+    snprintf (reservedblockspercentage_s, sizeof reservedblockspercentage_s,
+              "%d", reservedblockspercentage);
+    ADD_ARG (argv, i, reservedblockspercentage_s);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_LASTMOUNTEDDIRECTORY_BITMASK) {
+    ADD_ARG (argv, i, "-M");
+    ADD_ARG (argv, i, lastmounteddirectory);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_RESERVEDBLOCKSCOUNT_BITMASK) {
+    if (reservedblockscount < 0) {
+      reply_with_error ("reservedblockscount cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-r");
+    snprintf (reservedblockscount_s, sizeof reservedblockscount_s,
+              "%" PRIi64, reservedblockscount);
+    ADD_ARG (argv, i, reservedblockscount_s);
+  }
+
+  if (optargs_bitmask & GUESTFS_TUNE2FS_USER_BITMASK) {
+    if (user < 0) {
+      reply_with_error ("user cannot be negative");
+      return -1;
+    }
+    ADD_ARG (argv, i, "-u");
+    snprintf (user_s, sizeof user_s, "%" PRIi64, user);
+    ADD_ARG (argv, i, user_s);
+  }
+
+  ADD_ARG (argv, i, device);
+  ADD_ARG (argv, i, NULL);
+
+  r = commandv (NULL, &err, argv);
+  if (r == -1) {
+    reply_with_error ("%s: %s: %s", prog, device, err);
     free (err);
     return -1;
   }