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

371 lines
7.8 KiB
C
Raw Normal View History

2001-09-25 16:49:28 +04:00
/*
2001-12-20 14:52:54 +03:00
* Copyright (C) 2001 Sistina Software (UK) Limited.
2001-09-25 16:49:28 +04:00
*
2001-12-20 14:52:54 +03:00
* This file is released under the GPL.
2001-09-25 16:49:28 +04:00
*/
2001-10-06 01:39:30 +04:00
#include "tools.h"
2001-12-20 14:52:54 +03:00
#include "format-text.h"
#include "metadata.h"
2001-09-25 16:49:28 +04:00
2001-10-08 22:44:22 +04:00
#include <ctype.h>
2001-12-20 14:52:54 +03:00
#include <limits.h>
2001-10-08 22:44:22 +04:00
2001-09-25 16:49:28 +04:00
static int _autobackup = 1;
2001-12-20 14:52:54 +03:00
static char _backup_dir[PATH_MAX];
static int _period = 7; /* backups will be kept for at least 7 days */
static int _min_backups = 10; /* always have at least ten backups, even
* if they're old than the period */
2001-09-25 16:49:28 +04:00
2001-12-20 14:52:54 +03:00
/*
* Work out by looking at command line, config
* file and environment variable whether we should
* do an autobackup.
*/
int autobackup_init(const char *dir)
2001-09-25 16:49:28 +04:00
{
2001-10-02 21:09:05 +04:00
char *lvm_autobackup;
2001-09-25 16:49:28 +04:00
2001-12-20 14:52:54 +03:00
if (strlen(dir) > sizeof(_backup_dir) - 1) {
log_err("Backup directory (%s) too long.", dir);
return 0;
}
2001-12-20 14:52:54 +03:00
strcpy(_backup_dir, dir);
if (arg_count(autobackup_ARG)) {
_autobackup = !strcmp(arg_str_value(autobackup_ARG, "y"), "y");
return 1;
}
_autobackup = 1; /* default */
lvm_autobackup = getenv("LVM_AUTOBACKUP");
if (!lvm_autobackup)
2001-12-20 14:52:54 +03:00
return 1;
2001-09-25 16:49:28 +04:00
log_print("using environment variable LVM_AUTOBACKUP "
"to set option A");
if (!strcasecmp(lvm_autobackup, "no"))
_autobackup = 0;
2001-12-20 14:52:54 +03:00
else if (strcasecmp(lvm_autobackup, "yes")) {
log_error("environment variable LVM_AUTOBACKUP has "
"invalid value \"%s\"!", lvm_autobackup);
2001-12-20 14:52:54 +03:00
return 0;
2001-09-25 16:49:28 +04:00
}
2001-12-20 14:52:54 +03:00
return 1;
2001-09-25 16:49:28 +04:00
}
2001-12-20 14:52:54 +03:00
static int __autobackup(struct volume_group *vg)
2001-09-25 16:49:28 +04:00
{
2001-12-20 14:52:54 +03:00
int r;
struct pool *old;
struct format_instance *backer;
old = vg->cmd->mem;
/*
* Create a temprary pool for this, I
* doubt it's used but the backup code has
* the right to expect it.
*/
if (!(vg->cmd->mem = pool_create(1024))) {
stack;
vg->cmd->mem = old;
return 0;
2001-10-02 21:09:05 +04:00
}
2001-09-25 16:49:28 +04:00
2001-12-20 14:52:54 +03:00
if (!(backer = backup_format_create(vg->cmd, _backup_dir,
_period, _min_backups))) {
log_err("Couldn't create backup object.");
2001-10-02 21:09:05 +04:00
return 0;
}
2001-09-25 16:49:28 +04:00
2001-12-20 14:52:54 +03:00
if (!(r = backer->ops->vg_write(backer, vg)))
stack;
pool_destroy(vg->cmd->mem);
vg->cmd->mem = old;
return r;
}
int autobackup(struct volume_group *vg)
{
if (!__autobackup) {
log_print("WARNING: You don't have an automatic backup of %s",
vg->name);
return 1;
}
log_print("Creating automatic backup of volume group \"%s\" ...",
vg->name);
if (!__autobackup(vg)) {
log_err("Autobackup failed.");
return 0;
2001-10-02 21:09:05 +04:00
}
2001-09-25 16:49:28 +04:00
2001-12-20 14:52:54 +03:00
log_err("Autobackup not implemented yet.");
return 1;
2001-09-25 16:49:28 +04:00
}
2001-10-06 01:39:30 +04:00
2001-12-20 14:52:54 +03:00
2001-11-19 18:20:50 +03:00
int process_each_lv_in_vg(struct volume_group *vg,
int (*process_single) (struct logical_volume *lv))
{
int ret_max = 0;
int ret = 0;
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);
if (ret > ret_max)
ret_max = ret;
}
return ret_max;
}
int process_each_lv(int argc, char **argv,
2001-11-19 18:20:50 +03:00
int (*process_single) (struct logical_volume * lv))
{
int opt = 0;
int ret_max = 0;
int ret = 0;
int vg_count = 0;
struct list *lvh;
struct list *vgh, *vgs;
struct volume_group *vg;
struct logical_volume *lv;
char *vg_name;
if (argc) {
log_verbose("Using logical volume(s) on command line");
for (; opt < argc; opt++) {
char *lv_name = argv[opt];
/* does VG exist? */
if (!(vg_name = extract_vgname(fid, lv_name))) {
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
}
log_verbose("Finding volume group %s", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist",
vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
}
if (!(lvh = find_lv_in_vg(vg, lv_name))) {
log_error("Can't find logical volume %s "
"in volume group %s",
lv_name, vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
}
lv = &list_item(lvh, struct lv_list)->lv;
2001-11-19 18:20:50 +03:00
if ((ret = process_single(lv)) > ret_max)
ret_max = ret;
}
} else {
log_verbose("Finding all logical volume(s)");
if (!(vgs = fid->ops->get_vgs(fid))) {
log_error("No volume groups found");
return ECMD_FAILED;
}
list_iterate(vgh, vgs) {
vg_name = list_item(vgh, struct name_list)->name;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s not found", vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
}
2001-11-19 18:20:50 +03:00
ret = process_each_lv_in_vg(vg, process_single);
if (ret > ret_max)
ret_max = ret;
vg_count++;
}
}
return ret_max;
}
2001-10-06 01:39:30 +04:00
int process_each_vg(int argc, char **argv,
int (*process_single) (const char *vg_name))
{
int opt = 0;
int ret_max = 0;
int ret = 0;
2001-10-31 15:47:01 +03:00
struct list *vgh;
struct list *vgs;
2001-10-06 01:39:30 +04:00
if (argc) {
log_verbose("Using volume group(s) on command line");
for (; opt < argc; opt++)
if ((ret = process_single(argv[opt])) > ret_max)
ret_max = ret;
} else {
log_verbose("Finding all volume group(s)");
if (!(vgs = fid->ops->get_vgs(fid))) {
2001-10-06 01:39:30 +04:00
log_error("No volume groups found");
return ECMD_FAILED;
}
list_iterate(vgh, vgs) {
ret =
2001-11-19 18:20:50 +03:00
process_single(list_item
(vgh, struct name_list)->name);
2001-10-06 01:39:30 +04:00
if (ret > ret_max)
ret_max = ret;
}
}
return ret_max;
}
2001-10-08 22:44:22 +04:00
2001-11-19 18:20:50 +03:00
int process_each_pv_in_vg(struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
struct physical_volume * pv))
{
int ret_max = 0;
int ret = 0;
struct list *pvh;
list_iterate(pvh, &vg->pvs) {
ret = process_single(vg,
&list_item(pvh,
struct pv_list)->pv);
if (ret > ret_max)
ret_max = ret;
}
return ret_max;
}
2001-10-12 01:35:55 +04:00
int process_each_pv(int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
struct physical_volume * pv))
{
int opt = 0;
int ret_max = 0;
int ret = 0;
2001-10-31 15:47:01 +03:00
struct list *pvh;
2001-10-12 01:35:55 +04:00
if (argc) {
log_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) {
if (!(pvh = find_pv_in_vg(vg, argv[opt]))) {
log_error("Physical Volume %s not found in "
"Volume Group %s", argv[opt],
vg->name);
continue;
}
ret = process_single(vg,
&list_item(pvh,
struct pv_list)->pv);
2001-10-12 01:35:55 +04:00
if (ret > ret_max)
ret_max = ret;
}
} else {
log_verbose("Using all physical volume(s) in volume group");
2001-11-19 18:20:50 +03:00
process_each_pv_in_vg(vg, process_single);
2001-10-12 01:35:55 +04:00
}
return ret_max;
}
2001-10-08 22:44:22 +04:00
int is_valid_chars(char *n)
{
register char c;
while ((c = *n++))
2001-10-12 01:35:55 +04:00
if (!isalnum(c) && c != '.' && c != '_' && c != '-' && c != '+')
2001-10-08 22:44:22 +04:00
return 0;
return 1;
}
2001-11-12 18:10:01 +03:00
char *extract_vgname(struct format_instance *fi, char *lv_name)
{
2001-10-29 16:52:23 +03:00
char *vg_name = lv_name;
2001-11-06 22:02:26 +03:00
char *st;
2001-11-12 18:10:01 +03:00
char *dev_dir = fi->cmd->dev_dir;
2001-10-29 16:52:23 +03:00
/* Path supplied? */
2001-11-06 22:02:26 +03:00
if (vg_name && strchr(vg_name, '/')) {
2001-11-15 20:27:45 +03:00
/* Strip dev_dir (optional) */
2001-11-12 18:10:01 +03:00
if (!strncmp(vg_name, dev_dir, strlen(dev_dir)))
vg_name += strlen(dev_dir);
2001-10-29 16:52:23 +03:00
/* Require exactly one slash */
2001-10-29 21:23:35 +03:00
/* FIXME But allow for consecutive slashes */
2001-10-29 16:52:23 +03:00
if (!(st = strchr(vg_name, '/')) || (strchr(st + 1, '/'))) {
log_error("%s: Invalid path for Logical Volume",
lv_name);
2001-10-29 16:52:23 +03:00
return 0;
}
2001-11-12 18:10:01 +03:00
vg_name = pool_strdup(fid->cmd->mem, vg_name);
2001-10-29 16:52:23 +03:00
if (!vg_name) {
log_error("Allocation of vg_name failed");
return 0;
}
*strchr(vg_name, '/') = '\0';
return vg_name;
}
2001-11-06 22:02:26 +03:00
2001-11-12 18:10:01 +03:00
if (!(vg_name = default_vgname(fid))) {
2001-11-06 22:02:26 +03:00
if (lv_name)
log_error("Path required for Logical Volume %s",
lv_name);
2001-11-06 22:02:26 +03:00
return 0;
}
2001-11-06 22:02:26 +03:00
return vg_name;
}
2001-11-12 18:10:01 +03:00
char *default_vgname(struct format_instance *fi)
2001-11-06 22:02:26 +03:00
{
char *vg_path;
2001-11-12 18:10:01 +03:00
char *dev_dir = fi->cmd->dev_dir;
2001-11-06 22:02:26 +03:00
2001-10-29 16:52:23 +03:00
/* Take default VG from environment? */
vg_path = getenv("LVM_VG_NAME");
2001-11-06 22:02:26 +03:00
if (!vg_path)
2001-10-29 16:52:23 +03:00
return 0;
2001-11-15 20:27:45 +03:00
/* Strip dev_dir (optional) */
2001-11-12 18:10:01 +03:00
if (!strncmp(vg_path, dev_dir, strlen(dev_dir)))
vg_path += strlen(dev_dir);
2001-10-29 16:52:23 +03:00
if (strchr(vg_path, '/')) {
log_error("Environment Volume Group in LVM_VG_NAME invalid: %s",
2001-10-29 16:52:23 +03:00
vg_path);
return 0;
}
2001-11-12 18:10:01 +03:00
return pool_strdup(fid->cmd->mem, vg_path);
2001-10-29 16:52:23 +03:00
}