1
0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-22 17:35:59 +03:00
lvm2/lib/format_text/flags.c

183 lines
4.0 KiB
C
Raw Normal View History

/*
2008-01-30 17:00:02 +03:00
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
2004-03-30 23:35:44 +04:00
*
* You should have received a copy of the GNU Lesser General Public License
2004-03-30 23:35:44 +04:00
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
2002-11-18 17:04:08 +03:00
#include "lib.h"
#include "metadata.h"
#include "import-export.h"
2001-12-20 14:52:54 +03:00
#include "lvm-string.h"
/*
* Bitsets held in the 'status' flags get
* converted into arrays of strings.
*/
struct flag {
const int mask;
const char *description;
int kind;
};
static struct flag _vg_flags[] = {
{EXPORTED_VG, "EXPORTED", STATUS_FLAG},
{RESIZEABLE_VG, "RESIZEABLE", STATUS_FLAG},
{PVMOVE, "PVMOVE", STATUS_FLAG},
{LVM_READ, "READ", STATUS_FLAG},
{LVM_WRITE, "WRITE", STATUS_FLAG},
{CLUSTERED, "CLUSTERED", STATUS_FLAG},
{SHARED, "SHARED", STATUS_FLAG},
{PARTIAL_VG, NULL, 0},
{PRECOMMITTED, NULL, 0},
{0, NULL, 0}
};
static struct flag _pv_flags[] = {
{ALLOCATABLE_PV, "ALLOCATABLE", STATUS_FLAG},
{EXPORTED_VG, "EXPORTED", STATUS_FLAG},
{MISSING_PV, "MISSING", COMPATIBLE_FLAG},
{0, NULL, 0}
};
static struct flag _lv_flags[] = {
{LVM_READ, "READ", STATUS_FLAG},
{LVM_WRITE, "WRITE", STATUS_FLAG},
{FIXED_MINOR, "FIXED_MINOR", STATUS_FLAG},
{VISIBLE_LV, "VISIBLE", STATUS_FLAG},
{PVMOVE, "PVMOVE", STATUS_FLAG},
{LOCKED, "LOCKED", STATUS_FLAG},
{MIRROR_NOTSYNCED, "NOTSYNCED", STATUS_FLAG},
{MIRROR_IMAGE, NULL, 0},
{MIRROR_LOG, NULL, 0},
{MIRRORED, NULL, 0},
{VIRTUAL, NULL, 0},
{SNAPSHOT, NULL, 0},
{ACTIVATE_EXCL, NULL, 0},
{CONVERTING, NULL, 0},
{PARTIAL_LV, NULL, 0},
{POSTORDER_FLAG, NULL, 0},
{VIRTUAL_ORIGIN, NULL, 0},
{0, NULL, 0}
};
2001-12-20 14:52:54 +03:00
static struct flag *_get_flags(int type)
{
switch (type & ~STATUS_FLAG) {
case VG_FLAGS:
return _vg_flags;
case PV_FLAGS:
return _pv_flags;
case LV_FLAGS:
return _lv_flags;
}
log_error("Unknown flag set requested.");
return NULL;
}
/*
* Converts a bitset to an array of string values,
* using one of the tables defined at the top of
* the file.
*/
int print_flags(uint32_t status, int type, char *buffer, size_t size)
{
2001-12-31 18:14:44 +03:00
int f, first = 1;
struct flag *flags;
2008-01-30 16:19:47 +03:00
if (!(flags = _get_flags(type)))
return_0;
2003-09-18 00:35:57 +04:00
if (!emit_to_buffer(&buffer, &size, "["))
return 0;
for (f = 0; flags[f].mask; f++) {
if (status & flags[f].mask) {
2004-05-05 22:15:47 +04:00
status &= ~flags[f].mask;
if ((type & STATUS_FLAG) != flags[f].kind)
continue;
2004-05-05 22:15:47 +04:00
/* Internal-only flag? */
if (!flags[f].description)
continue;
2001-12-20 14:52:54 +03:00
if (!first) {
2003-09-18 00:35:57 +04:00
if (!emit_to_buffer(&buffer, &size, ", "))
2001-12-20 14:52:54 +03:00
return 0;
} else
first = 0;
2004-05-05 22:15:47 +04:00
if (!emit_to_buffer(&buffer, &size, "\"%s\"",
flags[f].description))
return 0;
}
}
2003-09-18 00:35:57 +04:00
if (!emit_to_buffer(&buffer, &size, "]"))
return 0;
if (status)
log_error("Metadata inconsistency: Not all flags successfully "
"exported.");
return 1;
}
2002-11-18 17:04:08 +03:00
int read_flags(uint32_t *status, int type, struct config_value *cv)
{
int f;
uint32_t s = 0;
struct flag *flags;
2008-01-30 16:19:47 +03:00
if (!(flags = _get_flags(type)))
return_0;
2002-11-18 17:04:08 +03:00
if (cv->type == CFG_EMPTY_ARRAY)
goto out;
2002-11-18 17:04:08 +03:00
while (cv) {
if (cv->type != CFG_STRING) {
log_error("Status value is not a string.");
2002-11-18 17:04:08 +03:00
return 0;
}
2002-11-18 17:04:08 +03:00
for (f = 0; flags[f].description; f++)
if (!strcmp(flags[f].description, cv->v.str)) {
s |= flags[f].mask;
break;
}
if (type == VG_FLAGS && !strcmp(cv->v.str, "PARTIAL")) {
/*
* Exception: We no longer write this flag out, but it
* might be encountered in old backup files, so restore
* it in that case. It is never part of live metadata
* though, so only vgcfgrestore needs to be concerned
* by this case.
*/
s |= PARTIAL_VG;
} else if (!flags[f].description && (type & STATUS_FLAG)) {
log_error("Unknown status flag '%s'.", cv->v.str);
2002-11-18 17:04:08 +03:00
return 0;
}
2002-11-18 17:04:08 +03:00
cv = cv->next;
}
2002-11-18 17:04:08 +03:00
out:
*status |= s;
return 1;
}