X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fext2.c;h=79fd35493f40e8351f63807218b1bf74d848f841;hp=3758f4ee5f0e09c821aa9e14cdedbc195695a823;hb=c81a16a4e2e703d0aaa595151602bcf03430f6ab;hpb=9e0b31a2af26b8d58a44dd80993a5e73d4942307 diff --git a/daemon/ext2.c b/daemon/ext2.c index 3758f4e..79fd354 100644 --- a/daemon/ext2.c +++ b/daemon/ext2.c @@ -13,21 +13,27 @@ * * 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 #include #include +#include #include #include -#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. @@ -35,7 +41,7 @@ * We specify e4fsprogs in the package list to ensure it is loaded * if it exists. */ -static int +int e2prog (char *name) { char *p = strstr (name, "e2"); @@ -155,6 +161,12 @@ do_set_e2label (const char *device, const char *label) 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 ("%s", err); @@ -169,29 +181,7 @@ do_set_e2label (const char *device, const char *label) char * do_get_e2label (const char *device) { - int r, len; - char *out, *err; - - char prog[] = "e2label"; - if (e2prog (prog) == -1) - return NULL; - - r = command (&out, &err, prog, device, NULL); - if (r == -1) { - reply_with_error ("%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 @@ -218,69 +208,67 @@ 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[] = "tune2fs"; + char prog[] = "resize2fs"; if (e2prog (prog) == -1) - return NULL; + return -1; - r = command (&out, &err, prog, "-l", device, NULL); + r = command (NULL, &err, prog, device, NULL); if (r == -1) { reply_with_error ("%s", err); - free (out); 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 && c_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 && (c_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; @@ -289,7 +277,7 @@ do_resize2fs (const char *device) if (e2prog (prog) == -1) return -1; - r = command (NULL, &err, prog, device, NULL); + r = command (NULL, &err, prog, "-M" , device, NULL); if (r == -1) { reply_with_error ("%s", err); free (err); @@ -364,6 +352,12 @@ do_mke2journal_L (int blocksize, const char *label, const char *device) 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); @@ -450,6 +444,12 @@ do_mke2fs_JL (const char *fstype, int blocksize, const char *device, 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); @@ -500,3 +500,150 @@ do_mke2fs_JU (const char *fstype, int blocksize, const char *device, 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 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; + } + + free (err); + return 0; +}