mirrors/libguestfs
1
0
Fork 0
mirror of https://github.com/libguestfs/libguestfs.git synced 2026-03-22 07:03:38 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
9637bddc33d314cf7d9d4a63630de75b4e3b5dfd
libguestfs/daemon/ext2.c
Richard W.M. Jones c4ad2c0ce3 daemon: Fold stdout on stderr when running e2fsck. 
User Phill Bandelow noted that virt-resize fails with an e2fsck error
on a host where the system clock had been accidentally set in the
past.

Unfortunately this was hard to diagnose because guestfsd 'ate' the
stdout of the e2fsck program.  I have verified by code inspection that
e2fsck prints messages on stdout.

Thus this changes the daemon to fold stdout and stderr together so we
get to see all error messages from e2fsck when it fails.
2012-12-16 18:38:41 +00:00

1226 lines
30 KiB
C
Raw Blame History

/* libguestfs - the guestfsd daemon
* Copyright (C) 2009-2012 Red Hat 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., 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 "guestfs_protocol.h"
#include "daemon.h"
#include "c-ctype.h"
#include "actions.h"
#define MAX_ARGS 128
GUESTFSD_EXT_CMD(str_tune2fs, tune2fs);
GUESTFSD_EXT_CMD(str_e2fsck, e2fsck);
GUESTFSD_EXT_CMD(str_resize2fs, resize2fs);
GUESTFSD_EXT_CMD(str_mke2fs, mke2fs);
GUESTFSD_EXT_CMD(str_lsattr, lsattr);
GUESTFSD_EXT_CMD(str_chattr, chattr);
char **
do_tune2fs_l (const char *device)
{
int r;
char *out, *err;
char *p, *pend, *colon;
DECLARE_STRINGSBUF (ret);
r = command (&out, &err, str_tune2fs, "-l", device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
free (out);
return NULL;
}
free (err);
p = out;
/* Discard the first line if it contains "tune2fs ...". */
if (STRPREFIX (p, "tune2fs ") || STRPREFIX (p, "tune4fs ")) {
p = strchr (p, '\n');
if (p) p++;
else {
reply_with_error ("truncated output");
free (out);
return NULL;
}
}
/* Read the lines and split into "key: value". */
while (*p) {
pend = strchrnul (p, '\n');
if (*pend == '\n') {
*pend = '\0';
pend++;
}
if (!*p) continue;
colon = strchr (p, ':');
if (colon) {
*colon = '\0';
do { colon++; } while (*colon && c_isspace (*colon));
if (add_string (&ret, p) == -1) {
free (out);
return NULL;
}
if (STREQ (colon, "<none>") ||
STREQ (colon, "<not available>") ||
STREQ (colon, "(none)")) {
if (add_string (&ret, "") == -1) {
free (out);
return NULL;
}
} else {
if (add_string (&ret, colon) == -1) {
free (out);
return NULL;
}
}
}
else {
if (add_string (&ret, p) == -1) {
free (out);
return NULL;
}
if (add_string (&ret, "") == -1) {
free (out);
return NULL;
}
}
p = pend;
}
free (out);
if (end_stringsbuf (&ret) == -1)
return NULL;
return ret.argv;
}
int
do_set_e2label (const char *device, const char *label)
{
return do_set_label (device, label);
}
char *
do_get_e2label (const char *device)
{
return do_vfs_label (device);
}
int
do_set_e2uuid (const char *device, const char *uuid)
{
int r;
char *err;
r = command (NULL, &err, str_tune2fs, "-U", uuid, device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
char *
do_get_e2uuid (const char *device)
{
return do_vfs_uuid (device);
}
/* If the filesystem is not mounted, run e2fsck -f on it unconditionally. */
static int
if_not_mounted_run_e2fsck (const char *device)
{
char *err;
int r, mounted;
mounted = is_device_mounted (device);
if (mounted == -1)
return -1;
if (!mounted) {
r = commandf (NULL, &err,
COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,
str_e2fsck, "-fy", device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
}
return 0;
}
int
do_resize2fs (const char *device)
{
char *err;
int r;
if (if_not_mounted_run_e2fsck (device) == -1)
return -1;
r = command (NULL, &err, str_resize2fs, device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_resize2fs_size (const char *device, int64_t size)
{
char *err;
int r;
/* 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;
if (if_not_mounted_run_e2fsck (device) == -1)
return -1;
char buf[32];
snprintf (buf, sizeof buf, "%" PRIi64 "K", size);
r = command (NULL, &err, str_resize2fs, device, buf, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_resize2fs_M (const char *device)
{
char *err;
int r;
if (if_not_mounted_run_e2fsck (device) == -1)
return -1;
r = command (NULL, &err, str_resize2fs, "-M", device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
/* Takes optional arguments, consult optargs_bitmask. */
int
do_e2fsck (const char *device,
int correct,
int forceall)
{
const char *argv[MAX_ARGS];
char *err;
size_t i = 0;
int r;
/* Default if not selected. */
if (!(optargs_bitmask & GUESTFS_E2FSCK_CORRECT_BITMASK))
correct = 0;
if (!(optargs_bitmask & GUESTFS_E2FSCK_FORCEALL_BITMASK))
forceall = 0;
if (correct && forceall) {
reply_with_error ("only one of the options 'correct', 'forceall' may be specified");
return -1;
}
ADD_ARG (argv, i, str_e2fsck);
ADD_ARG (argv, i, "-f");
if (correct)
ADD_ARG (argv, i, "-p");
if (forceall)
ADD_ARG (argv, i, "-y");
ADD_ARG (argv, i, device);
ADD_ARG (argv, i, NULL);
r = commandvf (NULL, &err,
COMMAND_FLAG_FOLD_STDOUT_ON_STDERR,
argv);
/* 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.
*/
if (r == -1 || r >= 2) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_e2fsck_f (const char *device)
{
optargs_bitmask = GUESTFS_E2FSCK_CORRECT_BITMASK;
return do_e2fsck (device, 1, 0);
}
int
do_mke2journal (int blocksize, const char *device)
{
char *err;
int r;
char blocksize_s[32];
snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
r = command (NULL, &err,
str_mke2fs, "-F", "-O", "journal_dev", "-b", blocksize_s,
device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_mke2journal_L (int blocksize, const char *label, const char *device)
{
char *err;
int r;
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,
str_mke2fs, "-F", "-O", "journal_dev", "-b", blocksize_s,
"-L", label,
device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_mke2journal_U (int blocksize, const char *uuid, const char *device)
{
char *err;
int r;
char blocksize_s[32];
snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
r = command (NULL, &err,
str_mke2fs, "-F", "-O", "journal_dev", "-b", blocksize_s,
"-U", uuid,
device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_mke2fs_J (const char *fstype, int blocksize, const char *device,
const char *journal)
{
char *err;
int r;
char blocksize_s[32];
snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
size_t len = strlen (journal);
char jdev[len+32];
snprintf (jdev, len+32, "device=%s", journal);
r = command (NULL, &err,
str_mke2fs, "-F", "-t", fstype, "-J", jdev, "-b", blocksize_s,
device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_mke2fs_JL (const char *fstype, int blocksize, const char *device,
const char *label)
{
char *err;
int r;
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);
size_t len = strlen (label);
char jdev[len+32];
snprintf (jdev, len+32, "device=LABEL=%s", label);
r = command (NULL, &err,
str_mke2fs, "-F", "-t", fstype, "-J", jdev, "-b", blocksize_s,
device, NULL);
if (r == -1) {
reply_with_error ("%s", err);
free (err);
return -1;
}
free (err);
return 0;
}
int
do_mke2fs_JU (const char *fstype, int blocksize, const char *device,
const char *uuid)
{
char *err;
int r;
char blocksize_s[32];
snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
size_t len = strlen (uuid);
char jdev[len+32];
snprintf (jdev, len+32, "device=UUID=%s", uuid);
r = command (NULL, &err,
str_mke2fs, "-F", "-t", fstype, "-J", jdev, "-b", blocksize_s,
device, NULL);
if (r == -1) {
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 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];
ADD_ARG (argv, i, str_tune2fs);
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", device, err);
free (err);
return -1;
}
free (err);
return 0;
}
static int
compare_chars (const void *vc1, const void *vc2)
{
char c1 = * (char *) vc1;
char c2 = * (char *) vc2;
return c1 - c2;
}
char *
do_get_e2attrs (const char *filename)
{
int r;
char *buf;
char *out, *err;
size_t i, j;
buf = sysroot_path (filename);
if (!buf) {
reply_with_perror ("malloc");
return NULL;
}
r = command (&out, &err, str_lsattr, "-d", "--", buf, NULL);
free (buf);
if (r == -1) {
reply_with_error ("%s: %s: %s", "lsattr", filename, err);
free (err);
free (out);
return NULL;
}
free (err);
/* Output looks like:
* -------------e- filename
* Remove the dashes and return everything up to the space.
*/
for (i = j = 0; out[j] != ' '; j++) {
if (out[j] != '-')
out[i++] = out[j];
}
out[i] = '\0';
/* Sort the output, mainly to make testing simpler. */
qsort (out, i, sizeof (char), compare_chars);
return out;
}
/* Takes optional arguments, consult optargs_bitmask. */
int
do_set_e2attrs (const char *filename, const char *attrs, int clear)
{
int r;
char *buf;
char *err;
size_t i, j;
int lowers[26], uppers[26];
char attr_arg[26*2+1+1]; /* '+'/'-' + attrs + trailing '\0' */
if (!(optargs_bitmask & GUESTFS_SET_E2ATTRS_CLEAR_BITMASK))
attr_arg[0] = '+';
else if (!clear)
attr_arg[0] = '+';
else
attr_arg[0] = '-';
j = 1;
/* You can't write "chattr - file", so we have to just return if
* the string is empty.
*/
if (STREQ (attrs, ""))
return 0;
/* Valid attrs are all lower or upper case ASCII letters. Check
* this and that there are no duplicates.
*/
memset (lowers, 0, sizeof lowers);
memset (uppers, 0, sizeof uppers);
for (; *attrs; attrs++) {
/* These are reserved by the chattr program for command line flags. */
if (*attrs == 'R' || *attrs == 'V' || *attrs == 'f' || *attrs == 'v') {
reply_with_error ("bad file attribute '%c'", *attrs);
return -1;
}
else if (*attrs >= 'a' && *attrs <= 'z') {
i = *attrs - 'a';
if (lowers[i] > 0)
goto error_duplicate;
lowers[i]++;
attr_arg[j++] = *attrs;
}
else if (*attrs >= 'A' && *attrs <= 'Z') {
i = *attrs - 'A';
if (uppers[i] > 0) {
error_duplicate:
reply_with_error ("duplicate file attribute '%c'", *attrs);
return -1;
}
uppers[i]++;
attr_arg[j++] = *attrs;
}
else {
reply_with_error ("unknown file attribute '%c'", *attrs);
return -1;
}
}
attr_arg[j] = '\0';
buf = sysroot_path (filename);
if (!buf) {
reply_with_perror ("malloc");
return -1;
}
r = command (NULL, &err, str_chattr, attr_arg, "--", buf, NULL);
free (buf);
if (r == -1) {
reply_with_error ("%s: %s: %s", "chattr", filename, err);
free (err);
return -1;
}
free (err);
return 0;
}
int64_t
do_get_e2generation (const char *filename)
{
int r;
char *buf;
char *out, *err;
int64_t ret;
buf = sysroot_path (filename);
if (!buf) {
reply_with_perror ("malloc");
return -1;
}
r = command (&out, &err, str_lsattr, "-dv", "--", buf, NULL);
free (buf);
if (r == -1) {
reply_with_error ("%s: %s: %s", "lsattr", filename, err);
free (err);
free (out);
return -1;
}
free (err);
if (sscanf (out, "%" SCNu64, &ret) != 1) {
reply_with_error ("cannot parse output from '%s' command: %s",
"lsattr", out);
free (out);
return -1;
}
free (out);
return ret;
}
int
do_set_e2generation (const char *filename, int64_t generation)
{
int r;
char *buf;
char *err;
char generation_str[64];
buf = sysroot_path (filename);
if (!buf) {
reply_with_perror ("malloc");
return -1;
}
snprintf (generation_str, sizeof generation_str,
"%" PRIu64, (uint64_t) generation);
r = command (NULL, &err, str_chattr, "-v", generation_str, "--", buf, NULL);
free (buf);
if (r == -1) {
reply_with_error ("%s: %s: %s", "chattr", filename, err);
free (err);
return -1;
}
free (err);
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 = NULL;
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) {
/* OString doesn't do device name translation (RHBZ#876579). We
* have to do it manually here, but note that LABEL=.. and
* UUID=.. are valid strings which do not require translation.
*/
journaldevice_s = malloc (strlen (journaldevice) + 8);
if (!journaldevice_s) {
reply_with_perror ("malloc");
goto error;
}
sprintf (journaldevice_s, "device=%s", journaldevice);
if (STRPREFIX (&journaldevice_s[7], "/dev/"))
RESOLVE_DEVICE (&journaldevice_s[7], , goto error);
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 (journaldevice_s);
free (err);
return 0;
error:
free (journaldevice_s);
free (err);
return -1;
}
int
do_mklost_and_found (const char *mountpoint)
{
char *cmd;
int r;
if (asprintf_nowarn (&cmd, "cd %R && mklost+found", mountpoint) == -1) {
reply_with_perror ("asprintf");
return -1;
}
r = system (cmd);
if (r == -1) {
reply_with_perror ("system");
free (cmd);
return -1;
}
if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
reply_with_error ("%s: command failed", cmd);
free (cmd);
return -1;
}
free (cmd);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink