shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-23 21:35:29 +03:00
Code Releases Activity

o Basic support for exporting (but importing not completed yet).

Browse Source 
o When volume group does not have write flag set, prevent changes to it.
o Preparation for partial activation (not completed yet).
This commit is contained in:
Alasdair Kergon 2002-01-29 17:23:33 +00:00
parent f9aa2941cf
commit 6435b49153
32 changed files with 465 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lib/format1/disk-rep.c
View File

@ -257,6 +257,26 @@ static int _read_extents(struct disk_list *data)
return 1;
}
/*
* If exported, remove "PV_EXP" from end of VG name
*/
static void _munge_exported_vg(struct disk_list *data)
{
int l, s;
/* Return if PV not in a VG or VG not exported */
if ((!*data->pvd.vg_name) ||
!(data->vgd.vg_status & VG_EXPORTED))
return;
l = strlen(data->pvd.vg_name);
s = sizeof(EXPORTED_TAG);
if (!strncmp(data->pvd.vg_name + l - s + 1, EXPORTED_TAG, s))
data->pvd.vg_name[l - s + 1] = '\0';
data->pvd.pv_status |= VG_EXPORTED;
}
static struct disk_list *__read_disk(struct device *dev, struct pool *mem,
const char *vg_name)
{
@ -278,21 +298,16 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem,
goto bad;
}
/* Update VG cache with whatever we found */
vgcache_add(data->pvd.vg_name, dev);
/*
* is it an orphan ?
*/
if (!*data->pvd.vg_name) {
log_very_verbose("%s is not a member of any VG", name);
return (vg_name) ? NULL : data;
}
if (vg_name && strcmp(vg_name, data->pvd.vg_name)) {
log_very_verbose("%s is not a member of the VG %s",
name, vg_name);
goto bad;
/* Update VG cache */
vgcache_add(data->pvd.vg_name, dev);
return (vg_name) ? NULL : data;
}
if (!_read_vgd(data)) {
@ -300,6 +315,18 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem,
goto bad;
}
/* If VG is exported, set VG name back to the real name */
_munge_exported_vg(data);
/* Update VG cache with what we found */
vgcache_add(data->pvd.vg_name, dev);
if (vg_name && strcmp(vg_name, data->pvd.vg_name)) {
log_very_verbose("%s is not a member of the VG %s",
name, vg_name);
goto bad;
}
if (!_read_uuids(data)) {
log_error("Failed to read PV uuid list from %s", name);
goto bad;
@ -315,7 +342,9 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem,
goto bad;
}
log_very_verbose("Found %s in VG %s", name, data->pvd.vg_name);
log_very_verbose("Found %s in %sVG %s", name,
(data->vgd.vg_status & VG_EXPORTED) ? "exported " : "",
data->pvd.vg_name);
return data;
@ -515,7 +544,7 @@ static int _write_pvd(struct disk_list *data)
ulong size = data->pvd.pv_on_disk.size;
if(size < sizeof(struct pv_disk)) {
log_err("Invalid PV size.");
log_error("Invalid PV structure size.");
return 0;
}

14
lib/format1/disk-rep.h
View File

@ -55,6 +55,9 @@
#define PV_ACTIVE 0x01 /* pv_status */
#define PV_ALLOCATABLE 0x02 /* pv_allocatable */
#define EXPORTED_TAG "PV_EXP" /* Identifier for exported PV */
#define IMPORTED_TAG "PV_IMP" /* Identifier for imported PV */
struct data_area {
uint32_t base;
@ -197,11 +200,14 @@ int write_disks(struct list *pvds);
* core structures.
*/
int import_pv(struct pool *mem, struct device *dev,
struct volume_group *vg,
struct physical_volume *pv, struct pv_disk *pvd);
int export_pv(struct pv_disk *pvd, struct physical_volume *pv);
int export_pv(struct pool *mem, struct volume_group *vg,
struct pv_disk *pvd, struct physical_volume *pv);
int import_vg(struct pool *mem,
struct volume_group *vg, struct disk_list *dl);
struct volume_group *vg, struct disk_list *dl,
int partial);
int export_vg(struct vg_disk *vgd, struct volume_group *vg);
int import_lv(struct pool *mem, struct logical_volume *lv,
@ -215,8 +221,8 @@ int export_extents(struct disk_list *dl, int lv_num,
struct logical_volume *lv,
struct physical_volume *pv);
int import_pvs(struct pool *mem, struct list *pvds,
struct list *results, int *count);
int import_pvs(struct pool *mem, struct volume_group *vg,
struct list *pvds, struct list *results, int *count);
int import_lvs(struct pool *mem, struct volume_group *vg,
struct list *pvds);

72
lib/format1/format1.c
View File

@ -13,34 +13,69 @@
#include "display.h"
/* VG consistency checks */
static int _check_vgs(struct list *pvs)
static int _check_vgs(struct list *pvs, int *partial)
{
struct list *pvh;
struct list *pvh, *t;
struct disk_list *dl = NULL;
struct disk_list *first = NULL;
int pv_count = 0;
int exported = -1;
/* check all the vg's are the same */
*partial = 0;
/*
* If there are exported and unexported PVs, ignore exported ones.
* This means an active VG won't be affected if disks are inserted
* bearing an exported VG with the same name.
*/
list_iterate(pvh, pvs) {
dl = list_item(pvh, struct disk_list);
if (exported < 0) {
exported = dl->pvd.pv_status & VG_EXPORTED;
continue;
}
if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {
/* Remove exported PVs */
list_iterate_safe(pvh, t, pvs) {
dl = list_item(pvh, struct disk_list);
if (dl->pvd.pv_status & VG_EXPORTED)
list_del(pvh);
}
break;
}
}
/* Remove any PVs with VG structs that differ from the first */
list_iterate_safe(pvh, t, pvs) {
dl = list_item(pvh, struct disk_list);
if (!first)
first = dl;
else if (memcmp(&first->vgd, &dl->vgd, sizeof(first->vgd))) {
log_error("VG data differs between PVs %s and %s",
dev_name(first->dev), dev_name(dl->dev));
list_del(pvh);
if (partial_mode()) {
*partial = 1;
continue;
}
return 0;
}
pv_count++;
}
/* On entry to fn, list known to be non-empty */
if (!(pv_count == dl->vgd.pv_cur)) {
log_error("Only %d out of %d PV(s) found for VG %s",
pv_count, dl->vgd.pv_cur, dl->pvd.vg_name);
if (pv_count != dl->vgd.pv_cur) {
log_error("%d PV(s) found for VG %s: expected %d",
pv_count, dl->pvd.vg_name, dl->vgd.pv_cur);
if (!partial_mode())
return 0;
*partial = 1;
}
return 1;
@ -50,6 +85,7 @@ static struct volume_group *_build_vg(struct pool *mem, struct list *pvs)
{
struct volume_group *vg = pool_alloc(mem, sizeof(*vg));
struct disk_list *dl;
int partial;
if (!vg)
goto bad;
@ -57,20 +93,20 @@ static struct volume_group *_build_vg(struct pool *mem, struct list *pvs)
if (list_empty(pvs))
goto bad;
dl = list_item(pvs->n, struct disk_list);
memset(vg, 0, sizeof(*vg));
list_init(&vg->pvs);
list_init(&vg->lvs);
if (!_check_vgs(pvs))
if (!_check_vgs(pvs, &partial))
goto bad;
if (!import_vg(mem, vg, dl))
dl = list_item(pvs->n, struct disk_list);
if (!import_vg(mem, vg, dl, partial))
goto bad;
if (!import_pvs(mem, pvs, &vg->pvs, &vg->pv_count))
if (!import_pvs(mem, vg, pvs, &vg->pvs, &vg->pv_count))
goto bad;
if (!import_lvs(mem, vg, pvs))
@ -137,7 +173,7 @@ static struct disk_list *_flatten_pv(struct pool *mem, struct volume_group *vg,
list_init(&dl->uuids);
list_init(&dl->lvds);
if (!export_pv(&dl->pvd, pv) ||
if (!export_pv(mem, vg, &dl->pvd, pv) ||
!export_vg(&dl->vgd, vg) ||
!export_uuids(dl, vg) ||
!export_lvs(dl, vg, pv, dev_dir) ||
@ -191,6 +227,12 @@ static int _vg_write(struct format_instance *fi, struct volume_group *vg)
return 0;
}
if (vg->status & PARTIAL_VG) {
log_error("Cannot change metadata for partial volume group %s",
vg->name);
return 0;
}
list_init(&pvds);
r = (_flatten_vg(mem, vg, &pvds, fi->cmd->dev_dir, fi->cmd->filter) &&
@ -229,7 +271,7 @@ static struct physical_volume *_pv_read(struct format_instance *fi,
goto out;
}
if (!import_pv(fi->cmd->mem, dl->dev, pv, &dl->pvd)) {
if (!import_pv(fi->cmd->mem, dl->dev, NULL, pv, &dl->pvd)) {
stack;
pool_free(fi->cmd->mem, pv);
pv = NULL;
@ -265,7 +307,7 @@ static struct list *_get_pvs(struct format_instance *fi)
goto bad;
}
if (!import_pvs(fi->cmd->mem, &pvs, results, &count)) {
if (!import_pvs(fi->cmd->mem, NULL, &pvs, results, &count)) {
stack;
goto bad;
}
@ -396,7 +438,7 @@ static int _pv_write(struct format_instance *fi, struct physical_volume *pv)
dl->mem = mem;
dl->dev = pv->dev;
if (!export_pv(&dl->pvd, pv)) {
if (!export_pv(mem, NULL, &dl->pvd, pv)) {
stack;
goto bad;
}

104
lib/format1/import-export.c
View File

@ -12,6 +12,7 @@
#include "hash.h"
#include "list.h"
#include "log.h"
#include "lvm-string.h"
#include <time.h>
#include <sys/utsname.h>
@ -37,6 +38,7 @@ static char *_create_lv_name(struct pool *mem, const char *full_name)
}
int import_pv(struct pool *mem, struct device *dev,
struct volume_group *vg,
struct physical_volume *pv, struct pv_disk *pvd)
{
memset(pv, 0, sizeof(*pv));
@ -48,6 +50,26 @@ int import_pv(struct pool *mem, struct device *dev,
return 0;
}
/* Store system_id if PV belongs to a VG */
if (vg && !vg->system_id &&
!(vg->system_id = pool_strdup(mem, pvd->system_id))) {
stack;
return 0;
}
if (vg && vg->system_id &&
strncmp(vg->system_id, pvd->system_id, sizeof(pvd->system_id)))
log_very_verbose("System ID %s on %s differs from %s for "
"volume group", pvd->system_id,
dev_name(pv->dev), vg->system_id);
/*
* If exported, we still need to flag in pv->status too because
* we don't always have a struct volume_group when we need this.
*/
if (pvd->pv_status & VG_EXPORTED)
pv->status |= EXPORTED_VG;
if (pvd->pv_allocatable)
pv->status |= ALLOCATABLE_PV;
@ -60,7 +82,7 @@ int import_pv(struct pool *mem, struct device *dev,
return 1;
}
static int _system_id(char *system_id)
int _system_id(char *s, const char *prefix)
{
struct utsname uts;
@ -69,11 +91,17 @@ static int _system_id(char *system_id)
return 0;
}
sprintf(system_id, "%s%lu", uts.nodename, time(NULL));
if (lvm_snprintf(s, NAME_LEN, "%s%s%lu",
prefix, uts.nodename, time(NULL)) < 0) {
log_error("Generated system_id too long");
return 0;
}
return 1;
}
int export_pv(struct pv_disk *pvd, struct physical_volume *pv)
int export_pv(struct pool *mem, struct volume_group *vg,
struct pv_disk *pvd, struct physical_volume *pv)
{
memset(pvd, 0, sizeof(*pvd));
@ -93,6 +121,54 @@ int export_pv(struct pv_disk *pvd, struct physical_volume *pv)
if (pv->vg_name)
strncpy(pvd->vg_name, pv->vg_name, sizeof(pvd->vg_name));
/* Preserve existing system_id if it exists */
if (vg && vg->system_id)
strncpy(pvd->system_id, vg->system_id, sizeof(pvd->system_id));
/* Is VG already exported or being exported? */
if (vg && (vg->status & EXPORTED_VG)) {
/* Does system_id need setting? */
if (!vg->system_id ||
strncmp(vg->system_id, EXPORTED_TAG,
sizeof(EXPORTED_TAG))) {
if (!_system_id(pvd->system_id, EXPORTED_TAG)) {
stack;
return 0;
}
}
if (strlen(pvd->vg_name) + sizeof(EXPORTED_TAG) >
sizeof(pvd->vg_name)) {
log_error("Volume group name %s too long to export",
pvd->vg_name);
return 0;
}
strcat(pvd->vg_name, EXPORTED_TAG);
}
/* Is VG being imported? */
if (vg && !(vg->status & EXPORTED_VG) && vg->system_id &&
!strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG))) {
if (!_system_id(pvd->system_id, IMPORTED_TAG)) {
stack;
return 0;
}
}
/* Generate system_id if PV is in VG */
if (!pvd->system_id || !*pvd->system_id)
if (!_system_id(pvd->system_id, "")) {
stack;
return 0;
}
/* Update internal system_id if we changed it */
if (vg &&
(!vg->system_id ||
strncmp(vg->system_id, pvd->system_id, sizeof(pvd->system_id)))) {
if (!(vg->system_id = pool_strdup(mem, pvd->system_id)))
log_error("System ID update failed");
}
//pvd->pv_major = MAJOR(pv->dev);
if (pv->status & ALLOCATABLE_PV)
@ -105,16 +181,12 @@ int export_pv(struct pv_disk *pvd, struct physical_volume *pv)
pvd->pe_allocated = pv->pe_allocated;
pvd->pe_start = pv->pe_start;
if (!_system_id(pvd->system_id)) {
stack;
return 0;
}
return 1;
}
int import_vg(struct pool *mem,
struct volume_group *vg, struct disk_list *dl)
struct volume_group *vg, struct disk_list *dl,
int partial)
{
struct vg_disk *vgd = &dl->vgd;
memcpy(vg->id.uuid, vgd->vg_uuid, ID_LEN);
@ -135,10 +207,10 @@ int import_vg(struct pool *mem,
if (vgd->vg_status & VG_EXTENDABLE)
vg->status |= RESIZEABLE_VG;
if (vgd->vg_access & VG_READ)
if (partial || (vgd->vg_access & VG_READ))
vg->status |= LVM_READ;
if (vgd->vg_access & VG_WRITE)
if (!partial && (vgd->vg_access & VG_WRITE))
vg->status |= LVM_WRITE;
if (vgd->vg_access & VG_CLUSTERED)
@ -152,6 +224,10 @@ int import_vg(struct pool *mem,
vg->free_count = vgd->pe_total - vgd->pe_allocated;
vg->max_lv = vgd->lv_max;
vg->max_pv = vgd->pv_max;
if (partial)
vg->status |= PARTIAL_VG;
return 1;
}
@ -307,8 +383,8 @@ int export_extents(struct disk_list *dl, int lv_num,
return 1;
}
int import_pvs(struct pool *mem, struct list *pvds,
struct list *results, int *count)
int import_pvs(struct pool *mem, struct volume_group *vg,
struct list *pvds, struct list *results, int *count)
{
struct list *pvdh;
struct disk_list *dl;
@ -325,7 +401,7 @@ int import_pvs(struct pool *mem, struct list *pvds,
return 0;
}
if (!import_pv(mem, dl->dev, pvl->pv, &dl->pvd)) {
if (!import_pv(mem, dl->dev, vg, pvl->pv, &dl->pvd)) {
stack;
return 0;
}

1
lib/format1/import-extents.c
View File

@ -349,6 +349,7 @@ int import_extents(struct pool *mem, struct volume_group *vg, struct list *pvds)
goto out;
}
/* FIXME Support partial activation if (vg->status & PARTIAL_VG) */
if (!_check_maps_are_complete(maps)) {
stack;
goto out;

2
lib/format_text/export.c
View File

@ -201,6 +201,8 @@ static int _print_vg(struct formatter *f, struct volume_group *vg)
}
_out(f, "status = %s", buffer);
if (vg->system_id && *vg->system_id)
_out(f, "system_id = \"%s\"", vg->system_id);
_out_size(f, vg->extent_size, "extent_size = %u", vg->extent_size);
_out(f, "max_lv = %u", vg->max_lv);
_out(f, "max_pv = %u", vg->max_pv);

7
lib/format_text/flags.c
View File

@ -21,6 +21,7 @@ struct flag {
static struct flag _vg_flags[] = {
{EXPORTED_VG, "EXPORTED"},
{RESIZEABLE_VG, "RESIZEABLE"},
{PARTIAL_VG, "PARTIAL"},
{LVM_READ, "READ"},
{LVM_WRITE, "WRITE"},
{CLUSTERED, "CLUSTERED"},
@ -30,6 +31,7 @@ static struct flag _vg_flags[] = {
static struct flag _pv_flags[] = {
{ALLOCATABLE_PV, "ALLOCATABLE"},
{EXPORTED_VG, "EXPORTED"},
{0, NULL}
};
@ -117,9 +119,8 @@ int print_flags(uint32_t status, int type, char *buffer, size_t size)
return 0;
if (status)
/* FIXME: agk is this the correct log level ? */
log_print("Not all flags were successfully exported, "
"possible bug.");
log_error("Metadata inconsistency: Not all flags successfully "
"exported.");
return 1;
}

13
lib/log/log.c
View File

@ -12,6 +12,7 @@ static FILE *_log = 0;
static int _verbose_level = 0;
static int _test = 0;
static int _partial = 0;
static int _debug_level = 0;
static int _syslog = 0;
static int _indent = 1;
@ -48,6 +49,14 @@ void init_test(int level) {
log_print("Test mode. Metadata will NOT be updated.");
}
void init_partial(int level) {
_partial = level;
if (_partial)
log_print("Partial mode. Incomplete volume groups will "
"be activated read-only.");
}
void init_cmd_name(int status) {
_log_cmd_name = status;
}
@ -72,6 +81,10 @@ int test_mode() {
return _test;
}
int partial_mode() {
return _partial;
}
void init_debug(int level) {
_debug_level = level;
}

2
lib/log/log.h
View File

@ -48,6 +48,7 @@ void fin_syslog(void);
void init_verbose(int level);
void init_test(int level);
void init_partial(int level);
void init_debug(int level);
void init_cmd_name(int status);
void init_msg_prefix(const char *prefix);
@ -56,6 +57,7 @@ void init_indent(int indent);
void set_cmd_name(const char *cmd_name);
int test_mode(void);
int partial_mode(void);
int debug_level(void);
void print_log(int level, const char *file, int line, const char *format, ...)

7
lib/metadata/metadata.c
View File

@ -39,9 +39,6 @@ int _add_pv_to_vg(struct format_instance *fi, struct volume_group *vg,
return 0;
}
/* FIXME check this */
pv->exported = NULL;
if (!(pv->vg_name = pool_strdup(mem, vg->name))) {
log_error("vg->name allocation failed for '%s'", pv_name);
return 0;
@ -132,10 +129,12 @@ struct volume_group *vg_create(struct format_instance *fi, const char *vg_name,
}
/* is this vg name already in use ? */
init_partial(1);
if (fi->ops->vg_read(fi, vg_name)) {
log_err("A volume group called '%s' already exists.", vg_name);
goto bad;
}
init_partial(0);
if (!id_create(&vg->id)) {
log_err("Couldn't create uuid for volume group '%s'.",
@ -154,6 +153,7 @@ struct volume_group *vg_create(struct format_instance *fi, const char *vg_name,
}
vg->status = (RESIZEABLE_VG | LVM_READ | LVM_WRITE);
vg->system_id = NULL;
vg->extent_size = extent_size;
vg->extent_count = 0;
@ -213,7 +213,6 @@ struct physical_volume *pv_create(struct format_instance *fi,
}
*pv->vg_name = 0;
pv->exported = NULL;
pv->status = ALLOCATABLE_PV;
if (!dev_get_size(pv->dev, &pv->size)) {

8
lib/metadata/metadata.h
View File

@ -27,8 +27,9 @@
/* Various flags */
/* Note that the bits no longer necessarily correspond to LVM1 disk format */
#define EXPORTED_VG 0x00000002 /* VG */
#define EXPORTED_VG 0x00000002 /* VG PV */
#define RESIZEABLE_VG 0x00000004 /* VG */
#define PARTIAL_VG 0x00000040 /* VG */
/* May any free extents on this PV be used or must they be left free? */
#define ALLOCATABLE_PV 0x00000008 /* PV */
@ -52,14 +53,10 @@
#define SNAPSHOT_ORG 0x00020000 /* LV */
#define EXPORTED_TAG "PV_EXP" /* Identifier of exported PV */
#define IMPORTED_TAG "PV_IMP" /* Identifier of imported PV */
struct physical_volume {
struct id id;
struct device *dev;
char *vg_name;
char *exported;
uint32_t status;
uint64_t size;
@ -78,6 +75,7 @@ struct volume_group {
struct id id;
char *name;
char *system_id;
uint32_t status;

1
tools/Makefile.in
View File

@ -44,6 +44,7 @@ SOURCES=\
vgck.c \
vgcreate.c \
vgdisplay.c \
vgexport.c \
vgextend.c \
vgmerge.c \
vgreduce.c \

1
tools/args.h
View File

@ -51,6 +51,7 @@ arg(nofsck_ARG, 'n', "nofsck", NULL)
arg(novolumegroup_ARG, 'n', "novolumegroup", NULL)
arg(permission_ARG, 'p', "permission", permission_arg)
arg(maxphysicalvolumes_ARG, 'p', "maxphysicalvolumes", int_arg)
arg(partial_ARG, 'P', "partial", NULL)
arg(physicalvolume_ARG, 'P', "physicalvolume", NULL)
arg(readahead_ARG, 'r', "readahead", int_arg)
arg(reset_ARG, 'R', "reset", NULL)

6
tools/commands.h
View File

@ -53,13 +53,14 @@ xx(lvchange,
"\t[-C/--contiguous y/n]\n"
"\t[-d/--debug]\n"
"\t[-h/-?/--help]\n"
"\t[-P/--partial] " "\n"
"\t[-p/--permission r/rw]\n"
"\t[-r/--readahead ReadAheadSectors]\n"
"\t[-t/--test]\n"
"\t[-v/--verbose]\n"
"\tLogicalVolume[Path] [LogicalVolume[Path]...]\n",
autobackup_ARG, available_ARG, contiguous_ARG,
autobackup_ARG, available_ARG, contiguous_ARG, partial_ARG,
permission_ARG, readahead_ARG, test_ARG)
xx(lvcreate,
@ -358,6 +359,7 @@ xx(vgchange,
"Change volume group attributes",
"vgchange" "\n"
"\t[-A|--autobackup {y|n}] " "\n"
"\t[-P|--partial] " "\n"
"\t[-d|--debug] " "\n"
"\t[-h|--help] " "\n"
"\t[-t|--test]" "\n"
@ -368,7 +370,7 @@ xx(vgchange,
"\t -l|--logicalvolume MaxLogicalVolumes}" "\n"
"\t[VolumeGroupName...]\n",
autobackup_ARG, available_ARG, logicalvolume_ARG,
autobackup_ARG, available_ARG, logicalvolume_ARG, partial_ARG,
resizeable_ARG, resizable_ARG, allocation_ARG,
test_ARG)

8
tools/lvchange.c
View File

@ -47,6 +47,14 @@ static int lvchange_single(struct logical_volume *lv)
int doit = 0;
int archived = 0;
if ((lv->vg->status & PARTIAL_VG) &&
(arg_count(contiguous_ARG) || arg_count(permission_ARG) ||
arg_count(readahead_ARG))) {
log_error("Only -a permitted with partial volume group %s",
lv->vg->name);
return EINVALID_CMD_LINE;
}
if (lv->status & SNAPSHOT_ORG) {
log_error("Can't change logical volume %s under snapshot",
lv->name);

10
tools/lvcreate.c
View File

@ -122,6 +122,16 @@ int lvcreate(int argc, char **argv)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
if (lv_name && find_lv_in_vg(vg, lv_name)) {
log_error("Logical volume %s already exists in "
"volume group %s", lv_name, vg_name);

7
tools/lvm.c
View File

@ -132,6 +132,8 @@ int main(int argc, char **argv)
namebase = strdup(argv[0]);
base = basename(namebase);
while (*base == '/')
base++;
if (strcmp(base, "lvm"))
alias = 1;
free(namebase);
@ -611,6 +613,11 @@ static int process_common_commands(struct command *com)
_current_settings.backup = 1;
}
if (arg_count(partial_ARG))
init_partial(1);
else
init_partial(0);
/* Handle synonyms */
if (!merge_synonym(resizable_ARG, resizeable_ARG) ||
!merge_synonym(allocation_ARG, allocatable_ARG) ||

5
tools/lvremove.c
View File

@ -39,6 +39,11 @@ static int lvremove_single(struct logical_volume *lv)
vg = lv->vg;
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg->name);
return ECMD_FAILED;
}
if (lv->status & SNAPSHOT_ORG) {
log_error("Can't remove logical volume %s under snapshot",
lv->name);

10
tools/lvrename.c
View File

@ -90,6 +90,16 @@ int lvrename(int argc, char **argv)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
if (find_lv_in_vg(vg, lv_name_new)) {
log_error("Logical volume %s already exists in "
"volume group %s", lv_name_new, vg_name);

10
tools/lvresize.c
View File

@ -110,6 +110,16 @@ int lvresize(int argc, char **argv)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
/* does LV exist? */
if (!(lvl = find_lv_in_vg(vg, lv_name))) {
log_error("Logical volume %s not found in volume group %s",

14
tools/pvchange.c
View File

@ -88,8 +88,7 @@ int pvchange_single(struct physical_volume *pv)
int allocatable = !strcmp(arg_str_value(allocatable_ARG, "n"), "y");
/* If in a VG, must change using volume group. Pointless. */
/* FIXME: Provide a direct pv_write_pv that *only* touches PV structs*/
/* If in a VG, must change using volume group. */
if (*pv->vg_name) {
log_verbose("Finding volume group of physical volume %s",
pv_name);
@ -97,6 +96,17 @@ int pvchange_single(struct physical_volume *pv)
log_error("Unable to find volume group of %s", pv_name);
return 0;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg->name);
return ECMD_FAILED;
}
if (!(pvl = find_pv_in_vg(vg, pv_name))) {
log_error("Unable to find %s in volume group %s",
pv_name, vg->name);

9
tools/pvscan.c
View File

@ -150,7 +150,8 @@ void pvscan_display_single(struct physical_volume *pv)
/* FIXME As per pv_display! Drop through for now. */
/* pv_show(pv); */
log_print("System Id %s", pv->exported);
/* FIXME - Moved to Volume Group structure */
/* log_print("System Id %s", pv->vg->system_id); */
/* log_print(" "); */
/* return; */
@ -158,7 +159,7 @@ void pvscan_display_single(struct physical_volume *pv)
memset(pv_tmp_name, 0, sizeof (pv_tmp_name));
vg_name_len = strlen(pv->vg_name) - sizeof (EXPORTED_TAG) + 1;
vg_name_len = strlen(pv->vg_name) + 1;
if (arg_count(uuid_ARG)) {
if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
@ -181,9 +182,9 @@ void pvscan_display_single(struct physical_volume *pv)
return;
}
if (strcmp(&pv->vg_name[vg_name_len], EXPORTED_TAG) == 0) {
if (pv->status & EXPORTED_VG) {
strncpy(vg_name_this, pv->vg_name, vg_name_len);
log_print("PV %-*s is in EXPORTED VG %s [%s / %s free]",
log_print("PV %-*s is in exported VG %s [%s / %s free]",
pv_max_name_len, pv_tmp_name,
vg_name_this, (s1 =
display_size(pv->pe_count *

1
tools/stub.h
View File

@ -10,7 +10,6 @@ int lvmsadc(int argc, char **argv) {return 1;}
int lvmsar(int argc, char **argv) {return 1;}
int pvdata(int argc, char **argv) {return 1;}
int pvmove(int argc, char **argv) {return 1;}
int vgexport(int argc, char **argv) {return 1;}
int vgimport(int argc, char **argv) {return 1;}
int vgmknodes(int argc, char **argv) {return 1;}
int vgsplit(int argc, char **argv) {return 1;}

30
tools/toollib.c
View File

@ -15,7 +15,7 @@ int check_dir(const char *dir)
if (!*dir)
return 1;
if (stat(dir, &info) != -1 ) {
if (stat(dir, &info) != -1) {
log_error("%s exists", dir);
return 0;
}
@ -30,9 +30,9 @@ int create_dir(const char *dir)
if (!*dir)
return 1;
if (stat(dir, &info) < 0 ) {
if (stat(dir, &info) < 0) {
log_verbose("Creating directory %s", dir);
if (!mkdir(dir, 0777));
if (!mkdir(dir, 0777))
return 1;
log_sys_error("mkdir", dir);
return 0;
@ -45,7 +45,6 @@ int create_dir(const char *dir)
return 0;
}
int process_each_lv_in_vg(struct volume_group *vg,
int (*process_single) (struct logical_volume *lv))
{
@ -55,11 +54,11 @@ int process_each_lv_in_vg(struct volume_group *vg,
struct list *lvh;
struct logical_volume *lv;
/* FIXME Export-handling */
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
list_iterate(lvh, &vg->lvs) {
lv = list_item(lvh, struct lv_list)->lv;
ret = process_single(lv);
@ -72,7 +71,7 @@ int process_each_lv_in_vg(struct volume_group *vg,
}
int process_each_lv(int argc, char **argv,
int (*process_single) (struct logical_volume * lv))
int (*process_single) (struct logical_volume *lv))
{
int opt = 0;
int ret_max = 0;
@ -107,6 +106,12 @@ int process_each_lv(int argc, char **argv,
continue;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported",
vg->name);
return ECMD_FAILED;
}
if (!(lvl = find_lv_in_vg(vg, lv_name))) {
log_error("Can't find logical volume %s "
"in volume group %s",
@ -179,8 +184,8 @@ int process_each_vg(int argc, char **argv,
}
int process_each_pv_in_vg(struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
struct physical_volume * pv))
int (*process_single) (struct volume_group *vg,
struct physical_volume *pv))
{
int ret_max = 0;
int ret = 0;
@ -198,8 +203,8 @@ int process_each_pv_in_vg(struct volume_group *vg,
}
int process_each_pv(int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
struct physical_volume * pv))
int (*process_single) (struct volume_group *vg,
struct physical_volume *pv))
{
int opt = 0;
int ret_max = 0;
@ -301,8 +306,7 @@ char *default_vgname(struct format_instance *fi)
}
struct list *create_pv_list(struct pool *mem,
struct volume_group *vg,
int argc, char **argv)
struct volume_group *vg, int argc, char **argv)
{
struct list *r;
struct pv_list *pvl, *new_pvl;
@ -338,5 +342,5 @@ struct list *create_pv_list(struct pool *mem,
list_add(r, &new_pvl->list);
}
return list_empty(r) ? NULL: r;
return list_empty(r) ? NULL : r;
}

5
tools/vgchange.c
View File

@ -56,6 +56,11 @@ static int vgchange_single(const char *vg_name)
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE) && !arg_count(available_ARG)) {
log_error("Volume group %s is read-only", vg->name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_name);
return ECMD_FAILED;

68
tools/vgexport.c Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (C) 2001 Sistina Software
*
* LVM 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, or (at your option)
* any later version.
*
* LVM 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 LVM; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
*/
#include "tools.h"
static int vgexport_single(const char *vg_name);
int vgexport(int argc, char **argv)
{
return process_each_vg(argc, argv, &vgexport_single);
}
static int vgexport_single(const char *vg_name)
{
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Unable to find volume group %s", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is already exported", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
if (lvs_in_vg_activated(vg)) {
log_error("Volume group %s has active logical volumes",
vg_name);
return ECMD_FAILED;
}
if (!archive(vg))
return ECMD_FAILED;
vg->status |= EXPORTED_VG;
if (!fid->ops->vg_write(fid,vg))
return ECMD_FAILED;
backup(vg);
log_print("Volume group %s successfully exported", vg->name);
return 0;
}

10
tools/vgextend.c
View File

@ -46,6 +46,16 @@ int vgextend(int argc, char **argv)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group '%s' is not resizeable.", vg_name);
return ECMD_FAILED;

20
tools/vgmerge.c
View File

@ -63,12 +63,32 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
return ECMD_FAILED;
}
if (vg_to->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_to->name);
return ECMD_FAILED;
}
if (!(vg_to->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_to->name);
return ECMD_FAILED;
}
log_verbose("Checking for volume group %s", vg_name_from);
if (!(vg_from = fid->ops->vg_read(fid, vg_name_from))) {
log_error("Volume group %s doesn't exist", vg_name_from);
return ECMD_FAILED;
}
if (vg_from->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_from->name);
return ECMD_FAILED;
}
if (!(vg_from->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_from->name);
return ECMD_FAILED;
}
if ((active = lvs_in_vg_activated(vg_from))) {
log_error("Logical volumes in %s must be inactive",
vg_name_from);

10
tools/vgreduce.c
View File

@ -54,6 +54,16 @@ int vgreduce(int argc, char **argv)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group %s is not reducable", vg_name);
return ECMD_FAILED;

10
tools/vgremove.c
View File

@ -40,6 +40,16 @@ static int vgremove_single(const char *vg_name)
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
return ECMD_FAILED;
}
if (vg->status & PARTIAL_VG) {
log_error("Cannot remove partial volume group %s", vg->name);
return ECMD_FAILED;
}
if (vg->lv_count) {
log_error("Volume group %s still contains %d logical volume(s)",
vg_name, vg->lv_count);

10
tools/vgrename.c
View File

@ -73,6 +73,16 @@ int vgrename(int argc, char **argv)
return ECMD_FAILED;
}
if (vg_old->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_old->name);
return ECMD_FAILED;
}
if (!(vg_old->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_old->name);
return ECMD_FAILED;
}
if (lvs_in_vg_activated(vg_old)) {
log_error("Volume group %s still has active LVs", vg_name_old);
/***** FIXME Handle this with multiple LV renames!

4
tools/vgscan.c
View File

@ -50,7 +50,9 @@ static int vgscan_single(const char *vg_name)
return ECMD_FAILED;
}
log_print("Found volume group %s", vg_name);
log_print("Found %svolume group %s",
(vg->status & EXPORTED_VG) ? "exported " : "",
vg_name);
return 0;
}