static int plooptool_convert(int argc, char **argv)
{
int i, ret;
struct ploop_disk_images_data *di;
int mode = -1;
int version = -1;
while ((i = getopt(argc, argv, "f:v:")) != EOF) {
switch (i) {
case 'f':
mode = parse_format_opt(optarg);
break;
case 'v':
version = parse_version_opt(optarg);
if (version < 0) {
usage_convert();
return SYSEXIT_PARAM;
}
break;
default:
usage_convert();
return SYSEXIT_PARAM;
}
}
argc -= optind;
argv += optind;
if (argc == 0 ||
(mode == -1 && version == -1) ||
(mode != -1 && version != -1))
{
usage_convert();
return SYSEXIT_PARAM;
}
ret = ploop_open_dd(&di, argv[0]);
if (ret)
return ret;
if (mode != -1)
ret = ploop_convert_image(di, mode, 0);
else if (version != -1)
ret = ploop_change_fmt_version(di, version, 0);
ploop_close_dd(di);
return ret;
}
int plooptool_grow(int argc, char **argv)
{
int i, f;
off_t new_size = 0; /* in sectors */
int raw = 0;
char *device = NULL;
while ((i = getopt(argc, argv, "f:d:s:")) != EOF) {
switch (i) {
case 'f':
f = parse_format_opt(optarg);
if (f < 0) {
usage();
return SYSEXIT_PARAM;
}
raw = (f == PLOOP_RAW_MODE);
break;
case 'd':
device = optarg;
break;
case 's':
if (parse_size(optarg, &new_size, "-s")) {
usage();
return SYSEXIT_PARAM;
}
break;
default:
usage();
return SYSEXIT_PARAM;
}
}
argc -= optind;
argv += optind;
if (((argc != 0 || !device) && (argc != 1 || device)) ||
(raw && device) || (new_size == 0)) {
usage();
return SYSEXIT_PARAM;
}
if (argc == 1 && is_xml_fname(argv[0]))
{
int ret;
struct ploop_disk_images_data *di;
ret = read_dd(&di, argv[0]);
if (ret)
return ret;
ret = ploop_grow_image(di, new_size);
ploop_free_diskdescriptor(di);
return ret;
}
else if (device)
return ploop_grow_device(device, new_size);
else if (raw)
return ploop_grow_raw_delta_offline(argv[0], new_size);
else
return ploop_grow_delta_offline(argv[0], new_size);
}
static int plooptool_init(int argc, char **argv)
{
int i, f, ret;
off_t size_sec = 0;
char * endptr;
struct ploop_create_param param = {
.fstype = "ext4",
.mode = PLOOP_EXPANDED_MODE,
.fmt_version = PLOOP_FMT_UNDEFINED,
};
while ((i = getopt(argc, argv, "s:b:B:f:t:v:")) != EOF) {
switch (i) {
case 's':
if (parse_size(optarg, &size_sec, "-s")) {
usage_init();
return SYSEXIT_PARAM;
}
break;
case 'b':
param.blocksize = strtoul(optarg, &endptr, 0);
if (*endptr != '\0') {
usage_init();
return SYSEXIT_PARAM;
}
break;
case 'B' :
param.fsblocksize = strtoul(optarg, &endptr, 0);
if (*endptr != '\0') {
usage_init();
return SYSEXIT_PARAM;
}
break;
case 'f':
f = parse_format_opt(optarg);
if (f < 0) {
usage_init();
return SYSEXIT_PARAM;
}
param.mode = f;
break;
case 't':
if (!strcmp(optarg, "none"))
param.fstype = NULL;
else if (!strcmp(optarg, "ext4") ||
!strcmp(optarg, "ext3")) {
param.fstype = strdup(optarg);
} else {
fprintf(stderr, "Incorrect file system type "
"specified: %s\n", optarg);
return SYSEXIT_PARAM;
}
break;
case 'v':
f = parse_version_opt(optarg);
if (f < 0) {
usage_init();
return SYSEXIT_PARAM;
}
param.fmt_version = f;
break;
default:
usage_init();
return SYSEXIT_PARAM;
}
}
argc -= optind;
argv += optind;
if (argc != 1 || size_sec == 0) {
usage_init();
return SYSEXIT_PARAM;
}
param.size = (__u64) size_sec;
param.image = argv[0];
ret = ploop_create_image(¶m);
if (ret)
return ret;
return 0;
}
static void usage_mount(void)
{
fprintf(stderr, "Usage: ploop mount [-r] [-f FORMAT] [-b BLOCKSIZE] [-d DEVICE]\n"
" [-m MOUNT_POINT] [-t FSTYPE] [-o MOUNT_OPTS]\n"
" BASE_DELTA [ ... TOP_DELTA ]\n"
" ploop mount [-r] [-m MOUNT_POINT] [-u UUID] DiskDescriptor.xml\n"
" FORMAT := { raw | ploop1 }\n"
" BLOCKSIZE := block size (for raw image format)\n"
" DEVICE := ploop device, e.g. /dev/ploop0\n"
" MOUNT_POINT := directory to mount in-image filesystem to\n"
" FSTYPE := in-image filesystem type (ext4 by default)\n"
" MOUNT_OPTS := additional mount options, comma-separated\n"
" *DELTA := path to image file\n"
" -r - mount images read-only\n"
" -F - run fsck on inner filesystem before mounting it\n"
);
}
static int plooptool_mount(int argc, char **argv)
{
int i, f, ret = 0;
int raw = 0;
struct ploop_mount_param mountopts = {};
const char *component_name = NULL;
while ((i = getopt(argc, argv, "rFf:d:m:t:u:o:b:c:")) != EOF) {
switch (i) {
case 'd':
strncpy(mountopts.device, optarg, sizeof(mountopts.device)-1);
break;
case 'r':
mountopts.ro = 1;
break;
case 'F':
mountopts.fsck = 1;
break;
case 'f':
f = parse_format_opt(optarg);
if (f < 0) {
usage_mount();
return SYSEXIT_PARAM;
}
raw = (f == PLOOP_RAW_MODE);
break;
case 'm':
mountopts.target = strdup(optarg);
break;
case 't':
mountopts.fstype = strdup(optarg);
break;
case 'u':
mountopts.guid = parse_uuid(optarg);
if (!mountopts.guid)
return SYSEXIT_PARAM;
break;
case 'o':
mountopts.mount_data = strdup(optarg);
break;
case 'b': {
char * endptr;
mountopts.blocksize = strtoul(optarg, &endptr, 0);
if (*endptr != '\0') {
usage_mount();
return SYSEXIT_PARAM;
}
break;
case 'c':
component_name = optarg;
break;
}
default:
usage_mount();
return SYSEXIT_PARAM;
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage_mount();
return SYSEXIT_PARAM;
}
if (argc == 1 && is_xml_fname(argv[0]))
{
struct ploop_disk_images_data *di;
ret = ploop_open_dd(&di, argv[0]);
if (ret)
return ret;
if (component_name != NULL)
ploop_set_component_name(di, component_name);
ret = ploop_mount_image(di, &mountopts);
ploop_close_dd(di);
}
else
ret = ploop_mount(NULL, argv, &mountopts, raw);
return ret;
}
