/* * Normal snapshot or thinly-provisioned snapshot? */ static int _determine_snapshot_type(struct volume_group *vg, struct lvcreate_params *lp) { struct lv_list *lvl; if (!(lvl = find_lv_in_vg(vg, lp->origin))) { log_error("Snapshot origin LV %s not found in Volume group %s.", lp->origin, vg->name); return 0; } if (lv_is_cache(lvl->lv)) { log_error("Snapshot of cache LV is not yet supported."); return 0; } if (!arg_count(vg->cmd, extents_ARG) && !arg_count(vg->cmd, size_ARG)) { if (seg_is_thin(lp)) { if (!(lp->segtype = get_segtype_from_string(vg->cmd, "thin"))) return_0; return 1; } if (!lv_is_thin_volume(lvl->lv)) { log_error("Please specify either size or extents with snapshots."); return 0; } if (!(lp->segtype = get_segtype_from_string(vg->cmd, "thin"))) return_0; lp->pool = first_seg(lvl->lv)->pool_lv->name; } return 1; }
static int _lvcreate_name_params(struct lvcreate_params *lp, struct cmd_context *cmd, int *pargc, char ***pargv) { int argc = *pargc; char **argv = *pargv, *ptr; const char *vg_name; lp->pool = arg_str_value(cmd, thinpool_ARG, NULL); /* If --thinpool contains VG name, extract it. */ if (lp->pool && strchr(lp->pool, '/')) { if (!(lp->vg_name = extract_vgname(cmd, lp->pool))) return 0; /* Strip VG from pool */ if ((ptr = strrchr(lp->pool, (int) '/'))) lp->pool = ptr + 1; } lp->lv_name = arg_str_value(cmd, name_ARG, NULL); /* If --name contains VG name, extract it. */ if (lp->lv_name && strchr(lp->lv_name, '/')) { if (!_set_vg_name(lp, extract_vgname(cmd, lp->lv_name))) return_0; /* Strip VG from lv_name */ if ((ptr = strrchr(lp->lv_name, (int) '/'))) lp->lv_name = ptr + 1; } /* Need an origin? */ if (lp->snapshot && !arg_count(cmd, virtualsize_ARG)) { /* argv[0] might be origin or vg/origin */ if (!argc) { log_error("Please specify a logical volume to act as " "the snapshot origin."); return 0; } lp->origin = skip_dev_dir(cmd, argv[0], NULL); if (strrchr(lp->origin, '/')) { if (!_set_vg_name(lp, extract_vgname(cmd, lp->origin))) return_0; /* Strip the volume group from the origin */ if ((ptr = strrchr(lp->origin, (int) '/'))) lp->origin = ptr + 1; } if (!lp->vg_name && !_set_vg_name(lp, extract_vgname(cmd, NULL))) return_0; if (!lp->vg_name) { log_error("The origin name should include the " "volume group."); return 0; } (*pargv)++, (*pargc)--; } else if (seg_is_thin(lp) && !lp->pool && argc) { /* argv[0] might be vg or vg/Pool */ vg_name = skip_dev_dir(cmd, argv[0], NULL); if (!strrchr(vg_name, '/')) { if (!_set_vg_name(lp, vg_name)) return_0; } else { lp->pool = vg_name; if (!_set_vg_name(lp, extract_vgname(cmd, lp->pool))) return_0; if (!lp->vg_name && !_set_vg_name(lp, extract_vgname(cmd, NULL))) return_0; if (!lp->vg_name) { log_error("The pool name should include the " "volume group."); return 0; } /* Strip the volume group */ if ((ptr = strrchr(lp->pool, (int) '/'))) lp->pool = ptr + 1; } (*pargv)++, (*pargc)--; } else { /* * If VG not on command line, try environment default. */ if (!argc) { if (!lp->vg_name && !(lp->vg_name = extract_vgname(cmd, NULL))) { log_error("Please provide a volume group name"); return 0; } } else { vg_name = skip_dev_dir(cmd, argv[0], NULL); if (strrchr(vg_name, '/')) { log_error("Volume group name expected " "(no slash)"); return 0; } if (!_set_vg_name(lp, vg_name)) return_0; (*pargv)++, (*pargc)--; } } if (!validate_name(lp->vg_name)) { log_error("Volume group name %s has invalid characters", lp->vg_name); return 0; } if (lp->lv_name) { if (!apply_lvname_restrictions(lp->lv_name)) return_0; if (!validate_name(lp->lv_name)) { log_error("Logical volume name \"%s\" is invalid", lp->lv_name); return 0; } } if (lp->pool) { if (!apply_lvname_restrictions(lp->pool)) return_0; if (!validate_name(lp->pool)) { log_error("Logical volume name \"%s\" is invalid", lp->pool); return 0; } if (lp->lv_name && !strcmp(lp->lv_name, lp->pool)) { log_error("Logical volume name %s and pool name %s must be different.", lp->lv_name, lp->pool); return 0; } } return 1; }
static int _read_size_params(struct lvcreate_params *lp, struct lvcreate_cmdline_params *lcp, struct cmd_context *cmd) { if (arg_count(cmd, extents_ARG) && arg_count(cmd, size_ARG)) { log_error("Please specify either size or extents (not both)"); return 0; } if (!lp->thin && !lp->snapshot && !arg_count(cmd, extents_ARG) && !arg_count(cmd, size_ARG)) { log_error("Please specify either size or extents"); return 0; } if (arg_count(cmd, extents_ARG)) { if (arg_sign_value(cmd, extents_ARG, SIGN_NONE) == SIGN_MINUS) { log_error("Negative number of extents is invalid"); return 0; } lp->extents = arg_uint_value(cmd, extents_ARG, 0); lcp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE); } /* Size returned in kilobyte units; held in sectors */ if (arg_count(cmd, size_ARG)) { if (arg_sign_value(cmd, size_ARG, SIGN_NONE) == SIGN_MINUS) { log_error("Negative size is invalid"); return 0; } lcp->size = arg_uint64_value(cmd, size_ARG, UINT64_C(0)); lcp->percent = PERCENT_NONE; } /* If size/extents given with thin, then we are creating a thin pool */ if (seg_is_thin(lp) && (arg_count(cmd, size_ARG) || arg_count(cmd, extents_ARG))) lp->create_pool = 1; if (!lp->create_pool && arg_count(cmd, poolmetadatasize_ARG)) { log_error("--poolmetadatasize may only be specified when allocating the pool."); return 0; } if (arg_count(cmd, virtualsize_ARG)) { if (seg_is_thin_pool(lp)) { log_error("Virtual size in incompatible with thin_pool segment type."); return 0; } if (arg_sign_value(cmd, virtualsize_ARG, SIGN_NONE) == SIGN_MINUS) { log_error("Negative virtual origin size is invalid"); return 0; } /* Size returned in kilobyte units; held in sectors */ lp->voriginsize = arg_uint64_value(cmd, virtualsize_ARG, UINT64_C(0)); if (!lp->voriginsize) { log_error("Virtual origin size may not be zero"); return 0; } } else { /* No virtual size given and no snapshot, so no thin LV to create. */ if (seg_is_thin_volume(lp) && !lp->snapshot && !(lp->segtype = get_segtype_from_string(cmd, "thin-pool"))) return_0; lp->thin = 0; } return 1; }