mirror of
https://github.com/libguestfs/libguestfs.git
synced 2026-03-22 07:03:38 +00:00
a41629deb9
Also various fixes: - remove fixed-size buffer - change if (err) free (err) -> free (err).
1222 lines
30 KiB
C
1222 lines
30 KiB
C
/* 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 = command (NULL, &err, 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 = commandv (NULL, &err, 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;
|
|
}
|