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
8c9a4bc84f9727236d9a61405cab8e2bd1ef9041
libguestfs/cat/filesystems.c
Richard W.M. Jones 8c9a4bc84f common/options: Change drv struct to store drive index instead of device name. 
The device name is only used by guestfish (when using the -N option to
prepare drives).  We constructed the device name very naively,
basically ‘sprintf ("/dev/sd%c", next_drive)’.

This stores the device index instead, and only constructs the device
name in guestfish.  Also the device name is constructed properly using
guestfs_int_drive_name so it can cope with #drives > 26.

As a side effect of this change we can remove the extra parameter of
the add_drives macro.

Thanks: Pino Toscano
2017-05-03 19:32:37 +01:00

1076 lines
28 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* virt-filesystems
* Copyright (C) 2010-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 <stdint.h>
#include <inttypes.h>
#include <unistd.h>
#include <getopt.h>
#include <errno.h>
#include <error.h>
#include <locale.h>
#include <assert.h>
#include <string.h>
#include <libintl.h>
#include "c-ctype.h"
#include "human.h"
#include "intprops.h"
#include "getprogname.h"
#include "guestfs.h"
#include "options.h"
#include "display-options.h"
/* These globals are shared with options.c. */
guestfs_h *g;
int read_only = 1;
int live = 0;
int verbose = 0;
int keys_from_stdin = 0;
int echo_keys = 0;
const char *libvirt_uri = NULL;
int inspector = 0;
int in_guestfish = 0;
int in_virt_rescue = 0;
static int csv = 0; /* --csv */
static int human = 0; /* --human-readable|-h */
/* What is selected for output. */
#define OUTPUT_FILESYSTEMS 1
#define OUTPUT_FILESYSTEMS_EXTRA 2
#define OUTPUT_PARTITIONS 4
#define OUTPUT_BLOCKDEVS 8
#define OUTPUT_LVS 16
#define OUTPUT_VGS 32
#define OUTPUT_PVS 64
#define OUTPUT_ALL INT_MAX
static int output = 0;
/* What columns to output. This is in display order. */
#define COLUMN_NAME 1 /* always shown */
#define COLUMN_TYPE 2
#define COLUMN_VFS_TYPE 4 /* if --filesystems */
#define COLUMN_VFS_LABEL 8 /* if --filesystems */
#define COLUMN_MBR 16
#define COLUMN_SIZE 32 /* bytes, or human-readable if -h */
#define COLUMN_PARENTS 64
#define COLUMN_UUID 128 /* if --uuid */
#define NR_COLUMNS 8
static int columns;
static void do_output_title (void);
static void do_output (void);
static void do_output_end (void);
static struct guestfs_lvm_pv_list *get_pvs (void);
static void free_pvs (void);
static void __attribute__((noreturn))
usage (int status)
{
if (status != EXIT_SUCCESS)
fprintf (stderr, _("Try ‘%s --help’ for more information.\n"),
getprogname ());
else {
printf (_("%s: list filesystems, partitions, block devices, LVM in a VM\n"
"Copyright (C) 2010 Red Hat Inc.\n"
"Usage:\n"
" %s [--options] -d domname\n"
" %s [--options] -a disk.img [-a disk.img ...]\n"
"Options:\n"
" -a|--add image Add image\n"
" --all Display everything\n"
" --blkdevs|--block-devices\n"
" Display block devices\n"
" -c|--connect uri Specify libvirt URI for -d option\n"
" --csv Output as Comma-Separated Values\n"
" -d|--domain guest Add disks from libvirt guest\n"
" --echo-keys Don't turn off echo for passphrases\n"
" --extra Display swap and data filesystems\n"
" --filesystems Display mountable filesystems\n"
" --format[=raw|..] Force disk format for -a option\n"
" -h|--human-readable Human-readable sizes in --long output\n"
" --help Display brief help\n"
" --keys-from-stdin Read passphrases from stdin\n"
" -l|--long Long output\n"
" --lvs|--logvols|--logical-volumes\n"
" Display LVM logical volumes\n"
" --no-title No title in --long output\n"
" --parts|--partitions Display partitions\n"
" --pvs|--physvols|--physical-volumes\n"
" Display LVM physical volumes\n"
" --uuid|--uuids Add UUIDs to --long output\n"
" -v|--verbose Verbose messages\n"
" -V|--version Display version and exit\n"
" --vgs|--volgroups|--volume-groups\n"
" Display LVM volume groups\n"
" -x Trace libguestfs API calls\n"
"For more information, see the manpage %s(1).\n"),
getprogname (), getprogname (),
getprogname (), getprogname ());
}
exit (status);
}
int
main (int argc, char *argv[])
{
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEBASEDIR);
textdomain (PACKAGE);
enum { HELP_OPTION = CHAR_MAX + 1 };
static const char options[] = "a:c:d:hlvVx";
static const struct option long_options[] = {
{ "add", 1, 0, 'a' },
{ "all", 0, 0, 0 },
{ "blkdevs", 0, 0, 0 },
{ "block-devices", 0, 0, 0 },
{ "connect", 1, 0, 'c' },
{ "csv", 0, 0, 0 },
{ "domain", 1, 0, 'd' },
{ "echo-keys", 0, 0, 0 },
{ "extra", 0, 0, 0 },
{ "filesystems", 0, 0, 0 },
{ "format", 2, 0, 0 },
{ "help", 0, 0, HELP_OPTION },
{ "human-readable", 0, 0, 'h' },
{ "keys-from-stdin", 0, 0, 0 },
{ "logical-volumes", 0, 0, 0 },
{ "logvols", 0, 0, 0 },
{ "long", 0, 0, 'l' },
{ "long-options", 0, 0, 0 },
{ "lvs", 0, 0, 0 },
{ "no-title", 0, 0, 0 },
{ "parts", 0, 0, 0 },
{ "partitions", 0, 0, 0 },
{ "physical-volumes", 0, 0, 0 },
{ "physvols", 0, 0, 0 },
{ "pvs", 0, 0, 0 },
{ "short-options", 0, 0, 0 },
{ "uuid", 0, 0, 0 },
{ "uuids", 0, 0, 0 },
{ "verbose", 0, 0, 'v' },
{ "version", 0, 0, 'V' },
{ "vgs", 0, 0, 0 },
{ "volgroups", 0, 0, 0 },
{ "volume-groups", 0, 0, 0 },
{ 0, 0, 0, 0 }
};
struct drv *drvs = NULL;
const char *format = NULL;
bool format_consumed = true;
int c;
int option_index;
int no_title = 0; /* --no-title */
int long_mode = 0; /* --long|-l */
int uuid = 0; /* --uuid */
int title;
g = guestfs_create ();
if (g == NULL)
error (EXIT_FAILURE, errno, "guestfs_create");
for (;;) {
c = getopt_long (argc, argv, options, long_options, &option_index);
if (c == -1) break;
switch (c) {
case 0: /* options which are long only */
if (STREQ (long_options[option_index].name, "long-options"))
display_long_options (long_options);
else if (STREQ (long_options[option_index].name, "short-options"))
display_short_options (options);
else if (STREQ (long_options[option_index].name, "keys-from-stdin")) {
keys_from_stdin = 1;
} else if (STREQ (long_options[option_index].name, "echo-keys")) {
echo_keys = 1;
} else if (STREQ (long_options[option_index].name, "format")) {
OPTION_format;
} else if (STREQ (long_options[option_index].name, "all")) {
output = OUTPUT_ALL;
} else if (STREQ (long_options[option_index].name, "blkdevs") ||
STREQ (long_options[option_index].name, "block-devices")) {
output |= OUTPUT_BLOCKDEVS;
} else if (STREQ (long_options[option_index].name, "csv")) {
csv = 1;
} else if (STREQ (long_options[option_index].name, "extra")) {
output |= OUTPUT_FILESYSTEMS;
output |= OUTPUT_FILESYSTEMS_EXTRA;
} else if (STREQ (long_options[option_index].name, "filesystems")) {
output |= OUTPUT_FILESYSTEMS;
} else if (STREQ (long_options[option_index].name, "logical-volumes") ||
STREQ (long_options[option_index].name, "logvols") ||
STREQ (long_options[option_index].name, "lvs")) {
output |= OUTPUT_LVS;
} else if (STREQ (long_options[option_index].name, "no-title")) {
no_title = 1;
} else if (STREQ (long_options[option_index].name, "parts") ||
STREQ (long_options[option_index].name, "partitions")) {
output |= OUTPUT_PARTITIONS;
} else if (STREQ (long_options[option_index].name, "physical-volumes") ||
STREQ (long_options[option_index].name, "physvols") ||
STREQ (long_options[option_index].name, "pvs")) {
output |= OUTPUT_PVS;
} else if (STREQ (long_options[option_index].name, "uuid") ||
STREQ (long_options[option_index].name, "uuids")) {
uuid = 1;
} else if (STREQ (long_options[option_index].name, "vgs") ||
STREQ (long_options[option_index].name, "volgroups") ||
STREQ (long_options[option_index].name, "volume-groups")) {
output |= OUTPUT_VGS;
} else
error (EXIT_FAILURE, 0,
_("unknown long option: %s (%d)"),
long_options[option_index].name, option_index);
break;
case 'a':
OPTION_a;
break;
case 'c':
OPTION_c;
break;
case 'd':
OPTION_d;
break;
case 'h':
human = 1;
break;
case 'l':
long_mode = 1;
break;
case 'v':
OPTION_v;
break;
case 'V':
OPTION_V;
break;
case 'x':
OPTION_x;
break;
case HELP_OPTION:
usage (EXIT_SUCCESS);
default:
usage (EXIT_FAILURE);
}
}
/* These are really constants, but they have to be variables for the
* options parsing code. Assert here that they have known-good
* values.
*/
assert (read_only == 1);
assert (inspector == 0);
assert (live == 0);
/* Must be no extra arguments on the command line. */
if (optind != argc) {
fprintf (stderr, _("%s: error: extra argument ‘%s’ on command line.\n"
"Make sure to specify the argument for --format "
"like '--format=%s'.\n"),
getprogname (), argv[optind], argv[optind]);
usage (EXIT_FAILURE);
}
CHECK_OPTION_format_consumed;
/* -h and --csv doesn't make sense. Spreadsheets will corrupt these
* fields. (RHBZ#600977).
*/
if (human && csv)
error (EXIT_FAILURE, 0,
_("you cannot use -h and --csv options together."));
/* Nothing selected for output, means --filesystems is implied. */
if (output == 0)
output = OUTPUT_FILESYSTEMS;
/* What columns will be displayed? */
columns = COLUMN_NAME;
if (long_mode) {
columns |= COLUMN_TYPE;
columns |= COLUMN_SIZE;
if ((output & OUTPUT_FILESYSTEMS)) {
columns |= COLUMN_VFS_TYPE;
columns |= COLUMN_VFS_LABEL;
}
columns |= COLUMN_PARENTS;
if ((output & OUTPUT_PARTITIONS))
columns |= COLUMN_MBR;
if (uuid)
columns |= COLUMN_UUID;
}
/* Display title by default only in long mode. */
title = long_mode;
if (no_title)
title = 0;
/* User must have specified some drives. */
if (drvs == NULL) {
fprintf (stderr, _("%s: error: you must specify at least one -a or -d option.\n"),
getprogname ());
usage (EXIT_FAILURE);
}
/* Add drives. */
add_drives (drvs);
if (guestfs_launch (g) == -1)
exit (EXIT_FAILURE);
/* Free up data structures, no longer needed after this point. */
free_drives (drvs);
if (title)
do_output_title ();
do_output ();
do_output_end ();
free_pvs ();
guestfs_close (g);
exit (EXIT_SUCCESS);
}
static void do_output_filesystems (void);
static void do_output_lvs (void);
static void do_output_vgs (void);
static void do_output_pvs (void);
static void do_output_partitions (void);
static void do_output_blockdevs (void);
static void write_row (const char *name, const char *type, const char *vfs_type, const char *vfs_label, int mbr_id, int64_t size, char **parents, const char *uuid);
static void write_row_strings (char **strings, size_t len);
static char **no_parents (void);
static int is_md (char *device);
static char **parents_of_md (char *device);
static char **parents_of_vg (char *vg);
static void
do_output_title (void)
{
const char *headings[NR_COLUMNS];
size_t len = 0;
/* NB. These strings are not localized and must not contain spaces. */
if ((columns & COLUMN_NAME))
headings[len++] = "Name";
if ((columns & COLUMN_TYPE))
headings[len++] = "Type";
if ((columns & COLUMN_VFS_TYPE))
headings[len++] = "VFS";
if ((columns & COLUMN_VFS_LABEL))
headings[len++] = "Label";
if ((columns & COLUMN_MBR))
headings[len++] = "MBR";
if ((columns & COLUMN_SIZE))
headings[len++] = "Size";
if ((columns & COLUMN_PARENTS))
headings[len++] = "Parent";
if ((columns & COLUMN_UUID))
headings[len++] = "UUID";
assert (len <= NR_COLUMNS);
write_row_strings ((char **) headings, len);
}
static void
do_output (void)
{
/* The ordering here is trying to be most specific -> least specific,
* although that is not required or guaranteed.
*/
if ((output & OUTPUT_FILESYSTEMS))
do_output_filesystems ();
if ((output & OUTPUT_LVS))
do_output_lvs ();
if ((output & OUTPUT_VGS))
do_output_vgs ();
if ((output & OUTPUT_PVS))
do_output_pvs ();
if ((output & OUTPUT_PARTITIONS))
do_output_partitions ();
if ((output & OUTPUT_BLOCKDEVS))
do_output_blockdevs ();
}
static void
do_output_filesystems (void)
{
size_t i;
CLEANUP_FREE_STRING_LIST char **fses = guestfs_list_filesystems (g);
if (fses == NULL)
exit (EXIT_FAILURE);
for (i = 0; fses[i] != NULL; i += 2) {
CLEANUP_FREE char *dev = NULL, *vfs_label = NULL, *vfs_uuid = NULL;
CLEANUP_FREE_STRING_LIST char **parents = NULL;
int64_t size = -1;
/* Skip swap and unknown, unless --extra flag was given. */
if (!(output & OUTPUT_FILESYSTEMS_EXTRA) &&
(STREQ (fses[i+1], "swap") || STREQ (fses[i+1], "unknown")))
continue;
dev = guestfs_canonical_device_name (g, fses[i]);
if (dev == NULL)
exit (EXIT_FAILURE);
/* Only bother to look these up if we will be displaying them,
* otherwise pass them as NULL.
*/
if ((columns & COLUMN_VFS_LABEL)) {
guestfs_push_error_handler (g, NULL, NULL);
vfs_label = guestfs_vfs_label (g, fses[i]);
guestfs_pop_error_handler (g);
if (vfs_label == NULL) {
vfs_label = strdup ("");
if (!vfs_label)
error (EXIT_FAILURE, errno, "strdup");
}
}
if ((columns & COLUMN_UUID)) {
guestfs_push_error_handler (g, NULL, NULL);
vfs_uuid = guestfs_vfs_uuid (g, fses[i]);
guestfs_pop_error_handler (g);
if (vfs_uuid == NULL) {
vfs_uuid = strdup ("");
if (!vfs_uuid)
error (EXIT_FAILURE, errno, "strdup");
}
}
if ((columns & COLUMN_SIZE)) {
CLEANUP_FREE char *device = guestfs_mountable_device (g, fses[i]);
CLEANUP_FREE char *subvolume = NULL;
guestfs_push_error_handler (g, NULL, NULL);
subvolume = guestfs_mountable_subvolume (g, fses[i]);
if (subvolume == NULL && guestfs_last_errno (g) != EINVAL) {
fprintf (stderr,
_("%s: cannot determine the subvolume for %s: %s: %s\n"),
getprogname (), fses[i],
guestfs_last_error (g),
strerror (guestfs_last_errno (g)));
exit (EXIT_FAILURE);
}
guestfs_pop_error_handler (g);
if (!device || !subvolume) {
size = guestfs_blockdev_getsize64 (g, fses[i]);
if (size == -1)
exit (EXIT_FAILURE);
}
}
if (is_md (fses[i]))
parents = parents_of_md (fses[i]);
else
parents = no_parents ();
write_row (dev, "filesystem",
fses[i+1], vfs_label, -1, size, parents, vfs_uuid);
}
}
static void
do_output_lvs (void)
{
size_t i;
CLEANUP_FREE_STRING_LIST char **lvs = guestfs_lvs (g);
if (lvs == NULL)
exit (EXIT_FAILURE);
for (i = 0; lvs[i] != NULL; ++i) {
CLEANUP_FREE char *uuid = NULL, *parent_name = NULL;
const char *parents[2];
int64_t size = -1;
if ((columns & COLUMN_SIZE)) {
size = guestfs_blockdev_getsize64 (g, lvs[i]);
if (size == -1)
exit (EXIT_FAILURE);
}
if ((columns & COLUMN_UUID)) {
uuid = guestfs_lvuuid (g, lvs[i]);
if (uuid == NULL)
exit (EXIT_FAILURE);
}
if ((columns & COLUMN_PARENTS)) {
parent_name = strdup (lvs[i]);
if (parent_name == NULL)
error (EXIT_FAILURE, errno, "strdup");
char *p = strrchr (parent_name, '/');
if (p)
*p = '\0';
parents[0] = parent_name;
parents[1] = NULL;
}
write_row (lvs[i], "lv",
NULL, NULL, -1, size, (char **) parents, uuid);
}
}
static void
do_output_vgs (void)
{
size_t i;
CLEANUP_FREE_LVM_VG_LIST struct guestfs_lvm_vg_list *vgs =
guestfs_vgs_full (g);
if (vgs == NULL)
exit (EXIT_FAILURE);
for (i = 0; i < vgs->len; ++i) {
CLEANUP_FREE char *name = NULL;
char uuid[33];
CLEANUP_FREE_STRING_LIST char **parents = NULL;
if (asprintf (&name, "/dev/%s", vgs->val[i].vg_name) == -1)
error (EXIT_FAILURE, errno, "asprintf");
memcpy (uuid, vgs->val[i].vg_uuid, 32);
uuid[32] = '\0';
parents = parents_of_vg (vgs->val[i].vg_name);
write_row (name, "vg",
NULL, NULL, -1, (int64_t) vgs->val[i].vg_size, parents, uuid);
}
}
/* Cache the output of guestfs_pvs_full, since we use it in a few places. */
static struct guestfs_lvm_pv_list *pvs_ = NULL;
static struct guestfs_lvm_pv_list *
get_pvs (void)
{
if (pvs_)
return pvs_;
pvs_ = guestfs_pvs_full (g);
if (pvs_ == NULL)
exit (EXIT_FAILURE);
return pvs_;
}
static void
free_pvs (void)
{
if (pvs_)
guestfs_free_lvm_pv_list (pvs_);
pvs_ = NULL;
}
static void
do_output_pvs (void)
{
size_t i;
struct guestfs_lvm_pv_list *pvs = get_pvs ();
for (i = 0; i < pvs->len; ++i) {
char uuid[33];
const char *parents[1] = { NULL };
CLEANUP_FREE char *dev =
guestfs_canonical_device_name (g, pvs->val[i].pv_name);
if (!dev)
exit (EXIT_FAILURE);
memcpy (uuid, pvs->val[i].pv_uuid, 32);
uuid[32] = '\0';
write_row (dev, "pv",
NULL, NULL, -1, (int64_t) pvs->val[i].pv_size,
(char **) parents, uuid);
}
}
static int
get_mbr_id (const char *dev, const char *parent_name)
{
CLEANUP_FREE char *parttype = NULL;
int mbr_id = -1, partnum;
guestfs_push_error_handler (g, NULL, NULL);
parttype = guestfs_part_get_parttype (g, parent_name);
if (parttype && STREQ (parttype, "msdos")) {
partnum = guestfs_part_to_partnum (g, dev);
if (partnum >= 0)
mbr_id = guestfs_part_get_mbr_id (g, parent_name, partnum);
}
guestfs_pop_error_handler (g);
return mbr_id;
}
static void
do_output_partitions (void)
{
size_t i;
CLEANUP_FREE_STRING_LIST char **parts = guestfs_list_partitions (g);
if (parts == NULL)
exit (EXIT_FAILURE);
for (i = 0; parts[i] != NULL; ++i) {
CLEANUP_FREE char *dev = NULL, *parent_name = NULL, *canonical_name = NULL;
const char *parents[2];
int64_t size = -1;
int mbr_id = -1;
dev = guestfs_canonical_device_name (g, parts[i]);
if (!dev)
exit (EXIT_FAILURE);
if ((columns & COLUMN_SIZE)) {
size = guestfs_blockdev_getsize64 (g, parts[i]);
if (size == -1)
exit (EXIT_FAILURE);
}
if ((columns & COLUMN_PARENTS)) {
parent_name = guestfs_part_to_dev (g, parts[i]);
if (parent_name == NULL)
exit (EXIT_FAILURE);
if ((columns & COLUMN_MBR))
mbr_id = get_mbr_id (parts[i], parent_name);
canonical_name = guestfs_canonical_device_name (g, parent_name);
if (!canonical_name)
exit (EXIT_FAILURE);
parents[0] = canonical_name;
parents[1] = NULL;
}
write_row (dev, "partition",
NULL, NULL, mbr_id, size, (char **) parents, NULL);
}
}
static void
do_output_blockdevs (void)
{
size_t i;
CLEANUP_FREE_STRING_LIST char **devices = guestfs_list_devices (g);
if (devices == NULL)
exit (EXIT_FAILURE);
for (i = 0; devices[i] != NULL; ++i) {
int64_t size = -1;
CLEANUP_FREE_STRING_LIST char **parents = NULL;
CLEANUP_FREE char *dev = NULL;
dev = guestfs_canonical_device_name (g, devices[i]);
if (!dev)
exit (EXIT_FAILURE);
if ((columns & COLUMN_SIZE)) {
size = guestfs_blockdev_getsize64 (g, devices[i]);
if (size == -1)
exit (EXIT_FAILURE);
}
if (is_md (devices[i]))
parents = parents_of_md (devices[i]);
else
parents = no_parents ();
write_row (dev, "device",
NULL, NULL, -1, size, parents, NULL);
}
}
/* Returns an empty list of parents. Note this must be freed. */
static char **
no_parents (void)
{
char **ret;
ret = malloc (sizeof (char *));
if (!ret)
error (EXIT_FAILURE, errno, "malloc");
ret[0] = NULL;
return ret;
}
/* XXX Should be a better test than this. */
static int
is_md (char *device)
{
char *p;
if (!STRPREFIX (device, "/dev/md"))
return 0;
p = device + 7;
while (*p) {
if (!c_isdigit (*p))
return 0;
p++;
}
return 1;
}
static char **
parents_of_md (char *device)
{
char **ret;
size_t i;
CLEANUP_FREE_MDSTAT_LIST struct guestfs_mdstat_list *stats =
guestfs_md_stat (g, device);
if (!stats)
exit (EXIT_FAILURE);
ret = malloc ((stats->len + 1) * sizeof (char *));
if (!ret)
error (EXIT_FAILURE, errno, "malloc");
for (i = 0; i < stats->len; ++i) {
ret[i] = guestfs_canonical_device_name (g, stats->val[i].mdstat_device);
if (!ret[i])
exit (EXIT_FAILURE);
}
ret[stats->len] = NULL;
return ret;
}
/* Specialized PV UUID comparison function.
* pvuuid1: from vgpvuuids, this may contain '-' characters which
* should be ignored.
* pvuuid2: from pvs-full, this is 32 characters long and NOT
* terminated by \0
*/
static int
compare_pvuuids (const char *pvuuid1, const char *pvuuid2)
{
size_t i;
const char *p = pvuuid1;
for (i = 0; i < 32; ++i) {
while (*p && !c_isalnum (*p))
p++;
if (!*p)
return 0;
if (*p != pvuuid2[i])
return 0;
}
return 1;
}
static char **
parents_of_vg (char *vg)
{
struct guestfs_lvm_pv_list *pvs = get_pvs ();
char **ret;
size_t n, i, j;
CLEANUP_FREE_STRING_LIST char **pvuuids = guestfs_vgpvuuids (g, vg);
if (!pvuuids)
exit (EXIT_FAILURE);
n = guestfs_int_count_strings (pvuuids);
ret = malloc ((n + 1) * sizeof (char *));
if (!ret)
error (EXIT_FAILURE, errno, "malloc");
/* Resolve each PV UUID back to a PV. */
for (i = 0; i < n; ++i) {
for (j = 0; j < pvs->len; ++j) {
if (compare_pvuuids (pvuuids[i], pvs->val[j].pv_uuid) == 0)
break;
}
if (j < pvs->len) {
ret[i] = guestfs_canonical_device_name (g, pvs->val[j].pv_name);
if (!ret[i])
exit (EXIT_FAILURE);
}
else {
fprintf (stderr, "%s: warning: unknown PV UUID ignored\n", __func__);
ret[i] = strndup (pvuuids[i], 32);
if (!ret[i])
error (EXIT_FAILURE, errno, "strndup");
}
}
ret[i] = NULL;
return ret;
}
static void
write_row (const char *name, const char *type,
const char *vfs_type, const char *vfs_label, int mbr_id,
int64_t size, char **parents, const char *uuid)
{
const char *strings[NR_COLUMNS];
CLEANUP_FREE char *parents_str = NULL;
size_t len = 0;
char hum[LONGEST_HUMAN_READABLE];
char num[256];
char mbr_id_str[INT_BUFSIZE_BOUND (mbr_id)];
if ((columns & COLUMN_NAME))
strings[len++] = name;
if ((columns & COLUMN_TYPE))
strings[len++] = type;
if ((columns & COLUMN_VFS_TYPE))
strings[len++] = vfs_type;
if ((columns & COLUMN_VFS_LABEL))
strings[len++] = vfs_label;
if ((columns & COLUMN_MBR)) {
if (mbr_id >= 0) {
snprintf (mbr_id_str, sizeof mbr_id_str, "%02x", (unsigned) mbr_id);
strings[len++] = mbr_id_str;
} else
strings[len++] = NULL;
}
if ((columns & COLUMN_SIZE)) {
if (size >= 0) {
if (human) {
strings[len++] =
human_readable ((uintmax_t) size, hum,
human_round_to_nearest|human_autoscale|
human_base_1024|human_SI,
1, 1);
}
else {
snprintf (num, sizeof num, "%" PRIi64, size);
strings[len++] = num;
}
}
else
strings[len++] = NULL;
}
if ((columns & COLUMN_PARENTS)) {
/* Internally comma-separated field. */
parents_str = guestfs_int_join_strings (",", parents);
strings[len++] = parents_str;
}
if ((columns & COLUMN_UUID))
strings[len++] = uuid;
assert (len <= NR_COLUMNS);
write_row_strings ((char **) strings, len);
}
static void add_row (char **strings, size_t len);
static void write_csv_field (const char *field);
static void
write_row_strings (char **strings, size_t len)
{
if (!csv) {
/* Text mode. Because we want the columns to line up, we can't
* output directly, but instead need to save up the rows and
* output them at the end.
*/
add_row (strings, len);
}
else { /* CSV mode: output it directly, quoted */
size_t i;
for (i = 0; i < len; ++i) {
if (i > 0)
putchar (',');
if (strings[i] != NULL)
write_csv_field (strings[i]);
}
putchar ('\n');
}
}
/* Function to quote CSV fields on output without requiring an
* external module.
*/
static void
write_csv_field (const char *field)
{
size_t i, len;
int needs_quoting = 0;
len = strlen (field);
for (i = 0; i < len; ++i) {
if (field[i] == ' ' || field[i] == '"' ||
field[i] == '\n' || field[i] == ',') {
needs_quoting = 1;
break;
}
}
if (!needs_quoting) {
printf ("%s", field);
return;
}
/* Quoting for CSV fields. */
putchar ('"');
for (i = 0; i < len; ++i) {
if (field[i] == '"') {
putchar ('"');
putchar ('"');
} else
putchar (field[i]);
}
putchar ('"');
}
/* This code is only used in text mode (non-CSV output). */
static char ***rows = NULL;
static size_t nr_rows = 0;
static size_t max_width[NR_COLUMNS];
static void
add_row (char **strings, size_t len)
{
size_t i, slen;
char **row;
assert (len <= NR_COLUMNS);
row = malloc (sizeof (char *) * len);
if (row == NULL)
error (EXIT_FAILURE, errno, "malloc");
for (i = 0; i < len; ++i) {
if (strings[i]) {
row[i] = strdup (strings[i]);
if (row[i] == NULL)
error (EXIT_FAILURE, errno, "strdup");
/* Keep a running total of the max width of each column. */
slen = strlen (strings[i]);
if (slen == 0)
slen = 1; /* because "" is printed as "-" */
if (slen > max_width[i])
max_width[i] = slen;
}
else
row[i] = NULL;
}
rows = realloc (rows, sizeof (char **) * (nr_rows + 1));
if (rows == NULL)
error (EXIT_FAILURE, errno, "realloc");
rows[nr_rows] = row;
nr_rows++;
}
/* In text mode we saved up all the output so that we can print the
* columns aligned.
*/
static void
do_output_end (void)
{
size_t i, j, k, len, space_btwn;
if (csv)
return;
/* How much space between columns? Try 2 spaces between columns, but
* if that just pushes us over 72 columns, use 1 space.
*/
space_btwn = 2;
i = 0;
for (j = 0; j < NR_COLUMNS; ++j)
i += max_width[j] + space_btwn;
if (i > 72)
space_btwn = 1;
for (i = 0; i < nr_rows; ++i) {
char **row = rows[i];
k = 0;
for (j = 0; j < NR_COLUMNS; ++j) {
/* Ignore columns which are completely empty. This also deals
* with the fact that we didn't remember the length of each row
* in add_row above.
*/
if (max_width[j] == 0)
continue;
while (k) {
putchar (' ');
k--;
}
if (row[j] == NULL || STREQ (row[j], "")) {
printf ("-");
len = 1;
} else {
printf ("%s", row[j]);
len = strlen (row[j]);
}
free (row[j]);
assert (len <= max_width[j]);
k = max_width[j] - len + space_btwn;
}
putchar ('\n');
free (row);
}
free (rows);
}
Reference in New Issue View Git Blame Copy Permalink