static void _thin_pool_display(const struct lv_segment *seg) { log_print(" Chunk size\t\t%s", display_size(seg->lv->vg->cmd, seg->chunk_size)); log_print(" Discards\t\t%s", get_pool_discards_name(seg->discards)); log_print(" Thin count\t\t%u", dm_list_size(&seg->lv->segs_using_this_lv)); log_print(" Transaction ID\t%" PRIu64, seg->transaction_id); log_print(" Zero new blocks\t%s", seg->zero_new_blocks ? "yes" : "no"); log_print(" "); }
static PyObject *_liblvm_lvm_list_vg_names(void) { struct dm_list *vgnames; struct lvm_str_list *strl; PyObject * pytuple; int i = 0; LVM_VALID(NULL); if (!(vgnames = lvm_list_vg_names(_libh))) { PyErr_SetObject(_LibLVMError, _liblvm_get_last_error()); return NULL; } if (!(pytuple = PyTuple_New(dm_list_size(vgnames)))) return NULL; dm_list_iterate_items(strl, vgnames) { PyTuple_SET_ITEM(pytuple, i, PYSTRTYPE_FROMSTRING(strl->str)); i++; }
static PyObject * liblvm_lvm_list_vg_names(void) { struct dm_list *vgnames; struct lvm_str_list *strl; PyObject * pytuple; int i = 0; LVM_VALID(); vgnames = lvm_list_vg_names(libh); if (!vgnames) { PyErr_SetObject(LibLVMError, liblvm_get_last_error()); return NULL; } pytuple = PyTuple_New(dm_list_size(vgnames)); if (!pytuple) return NULL; dm_list_iterate_items(strl, vgnames) { PyTuple_SET_ITEM(pytuple, i, PyString_FromString(strl->str)); i++; }
static int _pv_resize_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv, const uint64_t new_size) { struct pv_list *pvl; uint64_t size = 0; uint32_t new_pe_count = 0; int r = 0; struct dm_list mdas; const char *pv_name = pv_dev_name(pv); const char *vg_name; struct lvmcache_info *info; int mda_count = 0; struct volume_group *old_vg = vg; dm_list_init(&mdas); if (is_orphan_vg(pv_vg_name(pv))) { vg_name = VG_ORPHANS; if (!lock_vol(cmd, vg_name, LCK_VG_WRITE)) { log_error("Can't get lock for orphans"); return 0; } if (!(pv = pv_read(cmd, pv_name, &mdas, NULL, 1, 0))) { unlock_vg(cmd, vg_name); log_error("Unable to read PV \"%s\"", pv_name); return 0; } mda_count = dm_list_size(&mdas); } else { vg_name = pv_vg_name(pv); vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) goto bad; if (!(pvl = find_pv_in_vg(vg, pv_name))) { log_error("Unable to find \"%s\" in volume group \"%s\"", pv_name, vg->name); goto bad; } pv = pvl->pv; if (!(info = info_from_pvid(pv->dev->pvid, 0))) { log_error("Can't get info for PV %s in volume group %s", pv_name, vg->name); goto bad; } mda_count = dm_list_size(&info->mdas); if (!archive(vg)) goto bad; } /* FIXME Create function to test compatibility properly */ if (mda_count > 1) { log_error("%s: too many metadata areas for pvresize", pv_name); goto bad; } if (!(pv->fmt->features & FMT_RESIZE_PV)) { log_error("Physical volume %s format does not support resizing.", pv_name); goto bad; } /* Get new size */ if (!dev_get_size(pv_dev(pv), &size)) { log_error("%s: Couldn't get size.", pv_name); goto bad; } if (new_size) { if (new_size > size) log_warn("WARNING: %s: Overriding real size. " "You could lose data.", pv_name); log_verbose("%s: Pretending size is %" PRIu64 " not %" PRIu64 " sectors.", pv_name, new_size, pv_size(pv)); size = new_size; } if (size < PV_MIN_SIZE) { log_error("%s: Size must exceed minimum of %ld sectors.", pv_name, PV_MIN_SIZE); goto bad; } if (size < pv_pe_start(pv)) { log_error("%s: Size must exceed physical extent start of " "%" PRIu64 " sectors.", pv_name, pv_pe_start(pv)); goto bad; } pv->size = size; if (vg) { pv->size -= pv_pe_start(pv); new_pe_count = pv_size(pv) / vg->extent_size; if (!new_pe_count) { log_error("%s: Size must leave space for at " "least one physical extent of " "%" PRIu32 " sectors.", pv_name, pv_pe_size(pv)); goto bad; } if (!pv_resize(pv, vg, new_pe_count)) goto_bad; } log_verbose("Resizing volume \"%s\" to %" PRIu64 " sectors.", pv_name, pv_size(pv)); log_verbose("Updating physical volume \"%s\"", pv_name); if (!is_orphan_vg(pv_vg_name(pv))) { if (!vg_write(vg) || !vg_commit(vg)) { log_error("Failed to store physical volume \"%s\" in " "volume group \"%s\"", pv_name, vg->name); goto bad; } backup(vg); } else if (!(pv_write(cmd, pv, NULL, INT64_C(-1)))) { log_error("Failed to store physical volume \"%s\"", pv_name); goto bad;; } log_print("Physical volume \"%s\" changed", pv_name); r = 1; bad: unlock_vg(cmd, vg_name); if (!old_vg) vg_release(vg); return r; }
#define _lv_major_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_minor, lv->minor) #define _lv_when_full_get prop_not_implemented_get #define _lv_when_full_set prop_not_implemented_set #define _lv_minor_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_read_ahead, lv->read_ahead * SECTOR_SIZE) #define _lv_read_ahead_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_major, lv_kernel_major(lv)) #define _lv_kernel_major_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_minor, lv_kernel_minor(lv)) #define _lv_kernel_minor_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_read_ahead, lv_kernel_read_ahead(lv) * SECTOR_SIZE) #define _lv_kernel_read_ahead_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_size, lv->size * SECTOR_SIZE) #define _lv_size_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(seg_count, dm_list_size(&lv->segments)) #define _seg_count_set prop_not_implemented_set GET_LV_STR_PROPERTY_FN(origin, lv_origin_dup(lv->vg->vgmem, lv)) #define _origin_set prop_not_implemented_set GET_LV_STR_PROPERTY_FN(origin_uuid, lv_origin_uuid_dup(lv->vg->vgmem, lv)) #define _origin_uuid_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(origin_size, (SECTOR_SIZE * lv_origin_size(lv))) #define _origin_size_set prop_not_implemented_set #define _lv_ancestors_set prop_not_implemented_set #define _lv_ancestors_get prop_not_implemented_get #define _lv_descendants_set prop_not_implemented_set #define _lv_descendants_get prop_not_implemented_get GET_LV_NUM_PROPERTY_FN(snap_percent, _snap_percent(lv)) #define _snap_percent_set prop_not_implemented_set GET_LV_NUM_PROPERTY_FN(copy_percent, _copy_percent(lv)) #define _copy_percent_set prop_not_implemented_set
/* * Decide whether it is "safe" to wipe the labels on this device. * 0 indicates we may not. */ static int pvremove_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; struct dm_list mdas; dm_list_init(&mdas); /* FIXME Check partition type is LVM unless --force is given */ /* Is there a pv here already? */ /* If not, this is an error unless you used -f. */ if (!(pv = pv_read(cmd, name, &mdas, NULL, 1, 0))) { if (arg_count(cmd, force_ARG)) return 1; log_error("Physical Volume %s not found", name); return 0; } /* * If a PV has no MDAs it may appear to be an * orphan until the metadata is read off * another PV in the same VG. Detecting this * means checking every VG by scanning every * PV on the system. */ if (is_orphan(pv) && !dm_list_size(&mdas)) { if (!scan_vgs_for_pvs(cmd)) { log_error("Rescan for PVs without metadata areas " "failed."); return 0; } if (!(pv = pv_read(cmd, name, NULL, NULL, 1, 0))) { log_error("Failed to read physical volume %s", name); return 0; } } /* orphan ? */ if (is_orphan(pv)) return 1; /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ if (arg_count(cmd, force_ARG) < 2) { log_error("Can't pvremove physical volume \"%s\" of " "volume group \"%s\" without -ff", name, pv_vg_name(pv)); return 0; } /* prompt */ if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_wipe, name, pv_vg_name(pv)) == 'n') { log_error("%s: physical volume label not removed", name); return 0; } if (arg_count(cmd, force_ARG)) { log_warn("WARNING: Wiping physical volume label from " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } return 1; }
/* * Decide whether it is "safe" to wipe the labels on this device. * 0 indicates we may not. */ static int pvremove_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; /* FIXME Check partition type is LVM unless --force is given */ /* Is there a pv here already? */ /* If not, this is an error unless you used -f. */ if (!(pv = pv_read(cmd, name, 1, 0))) { if (arg_count(cmd, force_ARG)) return 1; log_error("Physical Volume %s not found", name); return 0; } /* * If a PV has no MDAs it may appear to be an * orphan until the metadata is read off * another PV in the same VG. Detecting this * means checking every VG by scanning every * PV on the system. */ if (is_orphan(pv) && !dm_list_size(&pv->fid->metadata_areas_in_use) && !dm_list_size(&pv->fid->metadata_areas_ignored)) { if (!scan_vgs_for_pvs(cmd, 0)) { log_error("Rescan for PVs without metadata areas " "failed."); goto bad; } free_pv_fid(pv); if (!(pv = pv_read(cmd, name, 1, 0))) { log_error("Failed to read physical volume %s", name); goto bad; } } /* orphan ? */ if (is_orphan(pv)) { free_pv_fid(pv); return 1; } /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ if (arg_count(cmd, force_ARG) < 2) { log_error("PV %s belongs to Volume Group %s so please use vgreduce first.", name, pv_vg_name(pv)); log_error("(If you are certain you need pvremove, then confirm by using --force twice.)"); goto bad; } /* prompt */ if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_wipe, name, pv_vg_name(pv)) == 'n') { log_error("%s: physical volume label not removed", name); goto bad; } if (arg_count(cmd, force_ARG)) { log_warn("WARNING: Wiping physical volume label from " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } free_pv_fid(pv); return 1; bad: free_pv_fid(pv); return 0; }
#define _lv_attr_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_major, lv->major) #define _lv_major_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_minor, lv->minor) #define _lv_minor_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_read_ahead, lv->read_ahead * SECTOR_SIZE) #define _lv_read_ahead_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_major, lv_kernel_major(lv)) #define _lv_kernel_major_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_minor, lv_kernel_minor(lv)) #define _lv_kernel_minor_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_kernel_read_ahead, lv_kernel_read_ahead(lv) * SECTOR_SIZE) #define _lv_kernel_read_ahead_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(lv_size, lv->size * SECTOR_SIZE) #define _lv_size_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(seg_count, dm_list_size(&lv->segments)) #define _seg_count_set _not_implemented_set GET_LV_STR_PROPERTY_FN(origin, lv_origin_dup(lv->vg->vgmem, lv)) #define _origin_set _not_implemented_set GET_LV_NUM_PROPERTY_FN(origin_size, lv_origin_size(lv)) #define _origin_size_set _not_implemented_set #define _snap_percent_get _not_implemented_get #define _snap_percent_set _not_implemented_set #define _copy_percent_get _not_implemented_get #define _copy_percent_set _not_implemented_set GET_LV_STR_PROPERTY_FN(move_pv, lv_move_pv_dup(lv->vg->vgmem, lv)) #define _move_pv_set _not_implemented_set GET_LV_STR_PROPERTY_FN(convert_lv, lv_convert_lv_dup(lv->vg->vgmem, lv)) #define _convert_lv_set _not_implemented_set GET_LV_STR_PROPERTY_FN(lv_tags, lv_tags_dup(lv)) #define _lv_tags_set _not_implemented_set