int ploop_discard(struct ploop_disk_images_data *di,
struct ploop_discard_param *param)
{
int ret;
char dev[PATH_MAX];
char mnt[PATH_MAX];
int mounted = 0;
if (ploop_lock_dd(di))
return SYSEXIT_LOCK;
ret = ploop_find_dev(di->runtime->component_name,
di->images[0]->file, dev, sizeof(dev));
if (ret == -1) {
ploop_unlock_dd(di);
return SYSEXIT_LOCK;
} else if (ret == 0) {
if (ploop_get_mnt_by_dev(dev, mnt, sizeof(mnt))) {
ploop_err(0, "Unable to find mount point for %s", dev);
ploop_unlock_dd(di);
return SYSEXIT_PARAM;
}
} else {
struct ploop_mount_param mount_param = {};
if (!param->automount) {
ploop_err(0, "Unable to discard: image is not mounted");
ploop_unlock_dd(di);
return SYSEXIT_PARAM;
}
ret = auto_mount_image(di, &mount_param);
if (ret) {
ploop_unlock_dd(di);
return ret;
}
mounted = 1;
snprintf(dev, sizeof(dev), "%s", mount_param.device);
snprintf(mnt, sizeof(mnt), "%s", mount_param.target);
free_mount_param(&mount_param);
}
ploop_unlock_dd(di);
ret = do_ploop_discard(di, dev, mnt, param->minlen_b,
param->to_free, param->stop);
if (mounted && ploop_lock_dd(di) == 0) {
ploop_umount(dev, di);
ploop_unlock_dd(di);
}
return ret;
}
static int fill_opts(void)
{
static char _device[PATH_MAX];
static char _mount_point[PATH_MAX];
if (device && mount_point)
return 0;
if (disk_descriptor) {
int ret;
struct ploop_disk_images_data *di;
ret = read_dd(&di, disk_descriptor);
if (ret)
return ret;
ret = ploop_get_dev(di, _device, sizeof(_device));
ploop_free_diskdescriptor(di);
if (ret < 0)
return SYSEXIT_PARAM;
if (ret == 1) {
fprintf(stderr, "The image is not mounted\n");
return SYSEXIT_PARAM;
}
device = _device;
}
if (!device && mount_point) {
if (ploop_get_dev_by_mnt(mount_point, _device, sizeof(_device))) {
fprintf(stderr, "Unable to find ploop device by %s\n", mount_point);
return SYSEXIT_PARAM;
}
device = _device;
return 0;
}
if (!mount_point && device) {
if (ploop_get_mnt_by_dev(device, _mount_point, sizeof(_mount_point))) {
fprintf(stderr, "Unable to find mount point for %s\n", device);
return SYSEXIT_PARAM;
}
mount_point = _mount_point;
return 0;
}
fprintf(stderr, "Error: one of -d, -m or DiskDescriptor.xml argument is required\n");
return 1;
}
static int open_mount_point(const char *device)
{
int fd;
char mnt[PATH_MAX];
if (ploop_get_mnt_by_dev(device, mnt, sizeof(mnt))) {
ploop_err(0, "Can't find mount point for %s", device);
return -1;
}
fd = open(mnt, O_RDONLY);
if (fd < 0) {
ploop_err(errno, "Can't open %s", mnt);
return -1;
}
return fd;
}
static int ploop_get_dev_and_mnt(struct ploop_disk_images_data *di,
char *dev, int dev_len, char *mnt, int mnt_len)
{
if (ploop_lock_dd(di))
return SYSEXIT_LOCK;
if (ploop_find_dev(di->runtime->component_name,
di->images[0]->file, dev, dev_len))
{
ploop_unlock_dd(di);
return SYSEXIT_PARAM;
}
if (ploop_get_mnt_by_dev(dev, mnt, mnt_len)) {
ploop_err(0, "Unable to find mount point for %s", dev);
ploop_unlock_dd(di);
return SYSEXIT_PARAM;
}
ploop_unlock_dd(di);
return 0;
}
int ploop_copy_init(struct ploop_disk_images_data *di,
struct ploop_copy_param *param,
struct ploop_copy_handle **h)
{
int ret, err;
int blocksize;
char *image = NULL;
char *format = NULL;
char device[64];
char partdev[64];
struct ploop_copy_handle *_h = NULL;
int is_remote;
char mnt[PATH_MAX] = "";
is_remote = is_fd_socket(param->ofd);
if (is_remote < 0) {
ploop_err(0, "Invalid output fd %d: must be a file, "
"a pipe or a socket", param->ofd);
return SYSEXIT_PARAM;
}
if (param->ofd == STDOUT_FILENO)
ploop_set_verbose_level(PLOOP_LOG_NOSTDOUT);
else if (param->ofd == STDERR_FILENO)
ploop_set_verbose_level(PLOOP_LOG_NOCONSOLE);
if (ploop_lock_dd(di))
return SYSEXIT_LOCK;
if (ploop_find_dev_by_dd(di, device, sizeof(device))) {
ploop_err(0, "Can't find running ploop device");
ret = SYSEXIT_SYS;
goto err;
}
ret = get_image_info(device, &image, &format, &blocksize);
if (ret)
goto err;
_h = alloc_ploop_copy_handle(S2B(blocksize));
if (_h == NULL) {
ploop_err(0, "alloc_ploop_copy_handle");
ret = SYSEXIT_MALLOC;
goto err;
}
_h->raw = strcmp(format, "raw") == 0;
_h->ofd = param->ofd;
_h->is_remote = is_remote;
_h->async = param->async;
_h->devfd = open(device, O_RDONLY|O_CLOEXEC);
if (_h->devfd == -1) {
ploop_err(errno, "Can't open device %s", device);
ret = SYSEXIT_DEVICE;
goto err;
}
ret = get_partition_device_name(device, partdev, sizeof(partdev));
if (ret)
goto err;
_h->partfd = open(partdev, O_RDONLY|O_CLOEXEC);
if (_h->partfd == -1) {
ploop_err(errno, "Can't open device %s", partdev);
ret = SYSEXIT_DEVICE;
goto err;
}
ret = SYSEXIT_OPEN;
err = ploop_get_mnt_by_dev(device, mnt, sizeof(mnt));
if (err == -1)
goto err;
else if (err == 0) {
_h->mntfd = open(mnt, O_RDONLY|O_NONBLOCK|O_DIRECTORY);
if (_h->mntfd < 0) {
ploop_err(errno, "Can't open %s", mnt);
goto err;
}
}
ploop_log(0, "Send image %s dev=%s mnt=%s fmt=%s blocksize=%d local=%d",
image, device, mnt, format, blocksize, !is_remote);
if (open_delta(&_h->idelta, image, O_RDONLY|O_DIRECT, OD_ALLOW_DIRTY)) {
ret = SYSEXIT_OPEN;
goto err;
}
ret = complete_running_operation(di, device);
if (ret)
goto err;
_h->cl = register_cleanup_hook(cancel_sender, _h);
pthread_mutex_lock(&_h->sd.wait_mutex);
err:
if (ret) {
ploop_copy_release(_h);
free_ploop_copy_handle(_h);
} else
*h = _h;
free(image);
ploop_unlock_dd(di);
return ret;
}
int ploop_create_temporary_snapshot(struct ploop_disk_images_data *di,
struct ploop_tsnapshot_param *param, int *holder_fd)
{
int ret;
struct ploop_mount_param mount_param = { .ro = 1, };
char component_name[PLOOP_COOKIE_SIZE];
if (di == NULL || param == NULL)
return SYSEXIT_PARAM;
if (param->guid == NULL) {
ploop_err(0, "Snapshot guid is not specified");
return SYSEXIT_PARAM;
}
if (param->component_name == NULL) {
ploop_err(0, "Component name is not specified");
return SYSEXIT_PARAM;
}
if (ploop_lock_dd(di))
return SYSEXIT_LOCK;
ret = do_create_snapshot(di, param->guid, param->snap_dir, 1);
if (ret)
goto err_unlock;
/* FIXME: should be processed from 'struct ploop_mount_param' only ?? */
char *t = di->runtime->component_name;
snprintf(component_name, sizeof(component_name), "%s%s",
holder_fd == NULL ? TSNAPSHOT_MOUNT_LOCK_MARK : "",
param->component_name);
di->runtime->component_name = component_name;
mount_param.guid = param->guid;
mount_param.target = param->target;
ret = mount_image(di, &mount_param);
di->runtime->component_name = t;
if (ret)
goto err_merge;
strncpy(param->device, mount_param.device, sizeof(param->device));
param->device[sizeof(param->device) - 1] = '\0';
if (holder_fd != NULL) {
ret = open_snap_holder(param->device, holder_fd);
if (ret)
goto err;
}
ploop_unlock_dd(di);
return 0;
err:
ploop_umount(mount_param.device, di);
err_merge:
ploop_merge_snapshot_by_guid(di, di->top_guid, NULL);
err_unlock:
ploop_unlock_dd(di);
return ret;
}
int is_device_inuse(const char *dev)
{
int count;
char fname[PATH_MAX];
char cookie[PLOOP_COOKIE_SIZE] = "";
if (ploop_get_attr(dev, "open_count", &count))
return 1;
/* detect if snapshot locked by ploop mount */
snprintf(fname, sizeof(fname), "/sys/block/%s/pstate/cookie",
memcmp(dev, "/dev/", 5) == 0 ? dev + 5 : dev);
if (read_line_quiet(fname, cookie, sizeof(cookie)))
return 1;
if (!strncmp(cookie, TSNAPSHOT_MOUNT_LOCK_MARK,
sizeof(TSNAPSHOT_MOUNT_LOCK_MARK)-1))
return 1;
/* snap holder + mount */
if (count >= 2)
return 1;
/* if there single reference we should detect is holder is alive */
if (count == 1 && ploop_get_mnt_by_dev(dev, fname, sizeof(fname)) != 0)
return 1;
return 0;
}
static int plooptool_list(int argc, char **argv)
{
char fname[PATH_MAX];
char image[PATH_MAX];
char mnt[PATH_MAX] = "";
char dev[64];
DIR *dp;
struct dirent *de;
char cookie[PLOOP_COOKIE_SIZE];
int all = 0;
int i;
while ((i = getopt(argc, argv, "a")) != EOF) {
switch (i) {
case 'a':
all = 1;
break;
default:
usage_list();
return SYSEXIT_PARAM;
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
usage_list();
return SYSEXIT_PARAM;
}
snprintf(fname, sizeof(fname) - 1, "/sys/block/");
dp = opendir(fname);
if (dp == NULL) {
fprintf(stderr, "Can't opendir %s: %m", fname);
return 1;
}
while ((de = readdir(dp)) != NULL) {
if (strncmp("ploop", de->d_name, 5))
continue;
snprintf(fname, sizeof(fname), "/sys/block/%s/pdelta/0/image",
de->d_name);
if (access(fname, F_OK))
continue;
if (read_line(fname, image, sizeof(image)))
continue;
snprintf(fname, sizeof(fname), "/sys/block/%s/pstate/cookie",
de->d_name);
if (access(fname, F_OK) == 0) {
if (read_line(fname, cookie, sizeof(cookie)))
continue;
}
if (all) {
mnt[0] = '\0';
snprintf(dev, sizeof(dev), "/dev/%s", de->d_name);
ploop_get_mnt_by_dev(dev, mnt, sizeof(mnt));
}
printf("%-12s %s %s %s\n", de->d_name, image, mnt, cookie);
}
closedir(dp);
return 0;
}
