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

Preparation for an LVM2 liblvm - pass cmd_context into each tool and

Browse Source 
link some globals that the tools need into that structure.
This commit is contained in:
Alasdair Kergon 2002-02-11 20:50:53 +00:00
parent 8d6a8717bb
commit 60274aba6e
51 changed files with 514 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/.symlinks
View File

@ -1,4 +1,6 @@
../lib/activate/activate.h
../lib/commands/errors.h
../lib/commands/toolcontext.h
../lib/config/config.h
../lib/config/defaults.h
../lib/datastruct/bitset.h

9
lib/activate/fs.c
View File

@ -4,6 +4,11 @@
* This file is released under the LGPL.
*/
#include "fs.h"
#include "log.h"
#include "names.h"
#include "toolcontext.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
@ -12,10 +17,6 @@
#include <stdio.h>
#include <string.h>
#include "fs.h"
#include "log.h"
#include "names.h"
#include <libdevmapper.h>

16
lib/commands/errors.h Normal file
View File

@ -0,0 +1,16 @@
/*
* Copyright (C) 2001 Sistina Software (UK) Limited.
*
* This file is released under the LGPL.
*/
#ifndef _LVM_ERRORS_H
#define _LVM_ERRORS_H
#define EINVALID_CMD_LINE 1
#define ENO_SUCH_CMD 3
#define ECMD_PROCESSED 4
#define ECMD_FAILED 5
#endif

33
lib/commands/toolcontext.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (C) 2001 Sistina Software (UK) Limited.
*
* This file is released under the LGPL.
*
*/
#ifndef _LVM_TOOLCONTEXT_H
#define _LVM_TOOLCONTEXT_H
#include "dev-cache.h"
#include "config.h"
#include "pool.h"
#include "metadata.h"
/* command-instance-related variables needed by library */
struct cmd_context {
/* format handler allocates all objects from here */
struct pool *mem;
struct format_instance *fid;
char *cmd_line;
char *dev_dir;
struct dev_filter *filter;
struct config_file *cf;
struct command *command;
struct uuid_map *um;
struct arg *args;
};
#endif

5
lib/display/display.c
View File

@ -24,6 +24,7 @@
#include "display.h"
#include "activate.h"
#include "uuid.h"
#include "toolcontext.h"
#include <sys/types.h>
#include <string.h>
@ -155,7 +156,7 @@ void pvdisplay_full(struct physical_volume *pv)
return;
}
int pvdisplay_short(struct volume_group *vg, struct physical_volume *pv)
int pvdisplay_short(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv)
{
if (!pv)
return 0;
@ -195,7 +196,7 @@ void lvdisplay_colons(struct logical_volume *lv)
return;
}
int lvdisplay_full(struct logical_volume *lv)
int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv)
{
char *size;
uint32_t alloc;

4
lib/display/display.h
View File

@ -33,11 +33,11 @@ char *display_uuid(char *uuidstr);
void pvdisplay_colons(struct physical_volume *pv);
void pvdisplay_full(struct physical_volume *pv);
int pvdisplay_short(struct volume_group *vg, struct physical_volume *pv);
int pvdisplay_short(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv);
void lvdisplay_colons(struct logical_volume *lv);
int lvdisplay_segments(struct logical_volume *lv);
int lvdisplay_full(struct logical_volume *lv);
int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv);
void vgdisplay_extents(struct volume_group *vg);
void vgdisplay_full(struct volume_group *vg);

1
lib/format1/format1.c
View File

@ -11,6 +11,7 @@
#include "list.h"
#include "log.h"
#include "display.h"
#include "toolcontext.h"
/* VG consistency checks */
static int _check_vgs(struct list *pvs, int *partial)

1
lib/format_text/archive.c
View File

@ -13,6 +13,7 @@
#include "import-export.h"
#include "lvm-string.h"
#include "lvm-file.h"
#include "toolcontext.h"
#include <dirent.h>
#include <unistd.h>

1
lib/format_text/format-text.c
View File

@ -13,6 +13,7 @@
#include "config.h"
#include "hash.h"
#include "dbg_malloc.h"
#include "toolcontext.h"
#include <unistd.h>
#include <sys/types.h>

1
lib/format_text/import.c
View File

@ -10,6 +10,7 @@
#include "log.h"
#include "uuid.h"
#include "hash.h"
#include "toolcontext.h"
typedef int (*section_fn)(struct pool *mem,

1
lib/metadata/lv_manip.c
View File

@ -9,6 +9,7 @@
#include "log.h"
#include "dbg_malloc.h"
#include "lvm-string.h"
#include "toolcontext.h"
#include <assert.h>

1
lib/metadata/metadata.c
View File

@ -9,6 +9,7 @@
#include "device.h"
#include "dev-cache.h"
#include "metadata.h"
#include "toolcontext.h"
#include <string.h>

11
lib/metadata/metadata.h
View File

@ -143,17 +143,6 @@ struct lv_list {
struct logical_volume *lv;
};
struct cmd_context {
/* format handler allocates all objects from here */
struct pool *mem;
/* misc. vars needed by format handler */
char *cmd_line;
char *dev_dir;
struct dev_filter *filter;
struct config_file *cf;
};
struct format_instance {
struct cmd_context *cmd;
struct format_handler *ops;

19
tools/archive.c
View File

@ -113,9 +113,9 @@ int archive(struct volume_group *vg)
return 1;
}
int archive_display(const char *vg_name)
int archive_display(struct cmd_context *cmd, const char *vg_name)
{
return archive_list(fid->cmd, the_um, _archive_params.dir, vg_name);
return archive_list(cmd, cmd->um, _archive_params.dir, vg_name);
}
@ -176,7 +176,7 @@ static int __backup(struct volume_group *vg)
log_verbose("Creating volume group backup \"%s\"", name);
if (!(tf = text_format_create(vg->cmd, name, the_um, desc))) {
if (!(tf = text_format_create(vg->cmd, name, vg->cmd->um, desc))) {
stack;
return 0;
}
@ -232,7 +232,8 @@ static struct volume_group *_read_vg(struct cmd_context *cmd,
struct volume_group *vg;
struct format_instance *tf;
if (!(tf = text_format_create(cmd, file, the_um, cmd->cmd_line))) {
if (!(tf = text_format_create(cmd, file, cmd->um,
cmd->cmd_line))) {
log_error("Couldn't create text format object.");
return NULL;
}
@ -244,14 +245,14 @@ static struct volume_group *_read_vg(struct cmd_context *cmd,
return vg;
}
int backup_restore_from_file(const char *vg_name, const char *file)
int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, const char *file)
{
struct volume_group *vg;
/*
* Read in the volume group.
*/
if (!(vg = _read_vg(fid->cmd, vg_name, file))) {
if (!(vg = _read_vg(cmd, vg_name, file))) {
stack;
return 0;
}
@ -267,7 +268,7 @@ int backup_restore_from_file(const char *vg_name, const char *file)
/*
* Write the vg.
*/
if (!fid->ops->vg_write(fid, vg)) {
if (!cmd->fid->ops->vg_write(cmd->fid, vg)) {
stack;
return 0;
}
@ -275,7 +276,7 @@ int backup_restore_from_file(const char *vg_name, const char *file)
return 1;
}
int backup_restore(const char *vg_name)
int backup_restore(struct cmd_context *cmd, const char *vg_name)
{
char path[PATH_MAX];
@ -285,5 +286,5 @@ int backup_restore(const char *vg_name)
return 0;
}
return backup_restore_from_file(vg_name, path);
return backup_restore_from_file(cmd, vg_name, path);
}

6
tools/archive.h
View File

@ -33,7 +33,7 @@ void archive_exit(void);
void archive_enable(int flag);
int archive(struct volume_group *vg);
int archive_display(const char *vg_name);
int archive_display(struct cmd_context *cmd, const char *vg_name);
int backup_init(const char *dir);
void backup_exit(void);
@ -42,7 +42,7 @@ void backup_enable(int flag);
int backup(struct volume_group *vg);
int backup_remove(const char *vg_name);
int backup_restore_from_file(const char *vg_name, const char *file);
int backup_restore(const char *vg_name);
int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, const char *file);
int backup_restore(struct cmd_context *cmd, const char *vg_name);
#endif

2
tools/args.h
View File

@ -1,7 +1,7 @@
/*
* Copyright (C) 2001 Sistina Software (UK) Limited.
*
* This file is released under the GPL.
* This file is released under the LGPL.
*/
/*

30
tools/errors.h
View File

@ -1,30 +0,0 @@
/*
* 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.
*
*/
#ifndef _LVM_ERRORS_H
#define _LVM_ERRORS_H
#define EINVALID_CMD_LINE 1
#define ENO_SUCH_CMD 3
#define ECMD_PROCESSED 4
#define ECMD_FAILED 5
#endif

86
tools/lvchange.c
View File

@ -20,18 +20,18 @@
#include "tools.h"
static int lvchange_single(struct logical_volume *lv);
static int lvchange_permission(struct logical_volume *lv);
static int lvchange_availability(struct logical_volume *lv);
static int lvchange_contiguous(struct logical_volume *lv);
static int lvchange_readahead(struct logical_volume *lv);
static int lvchange_persistent(struct logical_volume *lv);
static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv);
static int lvchange_permission(struct cmd_context *cmd, struct logical_volume *lv);
static int lvchange_availability(struct cmd_context *cmd, struct logical_volume *lv);
static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *lv);
static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv);
static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *lv);
int lvchange(int argc, char **argv)
int lvchange(struct cmd_context *cmd, int argc, char **argv)
{
if (!arg_count(available_ARG) && !arg_count(contiguous_ARG)
&& !arg_count(permission_ARG) && !arg_count(readahead_ARG)
&& !arg_count(minor_ARG) && !arg_count(persistent_ARG)) {
if (!arg_count(cmd,available_ARG) && !arg_count(cmd,contiguous_ARG)
&& !arg_count(cmd,permission_ARG) && !arg_count(cmd,readahead_ARG)
&& !arg_count(cmd,minor_ARG) && !arg_count(cmd,persistent_ARG)) {
log_error("One or more of -a, -C, -m, -M, -p or -r required");
return EINVALID_CMD_LINE;
}
@ -41,22 +41,22 @@ int lvchange(int argc, char **argv)
return EINVALID_CMD_LINE;
}
if (arg_count(minor_ARG) && argc != 1) {
if (arg_count(cmd,minor_ARG) && argc != 1) {
log_error("Only give one logical volume when specifying minor");
return EINVALID_CMD_LINE;
}
return process_each_lv(argc, argv, &lvchange_single);
return process_each_lv(cmd, argc, argv, &lvchange_single);
}
static int lvchange_single(struct logical_volume *lv)
static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv)
{
int doit = 0;
int archived = 0;
if (!(lv->vg->status & LVM_WRITE) &&
(arg_count(contiguous_ARG) || arg_count(permission_ARG) ||
arg_count(readahead_ARG) || arg_count(persistent_ARG))) {
(arg_count(cmd,contiguous_ARG) || arg_count(cmd,permission_ARG) ||
arg_count(cmd,readahead_ARG) || arg_count(cmd,persistent_ARG))) {
log_error("Only -a permitted with read-only volume "
"group \"%s\"", lv->vg->name);
return EINVALID_CMD_LINE;
@ -75,53 +75,53 @@ static int lvchange_single(struct logical_volume *lv)
}
/* access permission change */
if (arg_count(permission_ARG)) {
if (arg_count(cmd,permission_ARG)) {
if (!archive(lv->vg))
return ECMD_FAILED;
archived = 1;
doit += lvchange_permission(lv);
doit += lvchange_permission(cmd, lv);
}
/* allocation policy change */
if (arg_count(contiguous_ARG)) {
if (arg_count(cmd,contiguous_ARG)) {
if (!archived && !archive(lv->vg))
return ECMD_FAILED;
archived = 1;
doit += lvchange_contiguous(lv);
doit += lvchange_contiguous(cmd, lv);
}
/* read ahead sector change */
if (arg_count(readahead_ARG)) {
if (arg_count(cmd,readahead_ARG)) {
if (!archived && !archive(lv->vg))
return ECMD_FAILED;
archived = 1;
doit += lvchange_readahead(lv);
doit += lvchange_readahead(cmd, lv);
}
/* read ahead sector change */
if (arg_count(persistent_ARG)) {
if (arg_count(cmd,persistent_ARG)) {
if (!archived && !archive(lv->vg))
return ECMD_FAILED;
archived = 1;
doit += lvchange_persistent(lv);
doit += lvchange_persistent(cmd, lv);
}
if (doit)
log_print("Logical volume \"%s\" changed", lv->name);
/* availability change */
if (arg_count(available_ARG))
if (!lvchange_availability(lv))
if (arg_count(cmd,available_ARG))
if (!lvchange_availability(cmd, lv))
return ECMD_FAILED;
return 0;
}
static int lvchange_permission(struct logical_volume *lv)
static int lvchange_permission(struct cmd_context *cmd, struct logical_volume *lv)
{
int lv_access;
lv_access = arg_int_value(permission_ARG, 0);
lv_access = arg_int_value(cmd,permission_ARG, 0);
if ((lv_access & LVM_WRITE) && (lv->status & LVM_WRITE)) {
log_error("Logical volume \"%s\" is already writable", lv->name);
@ -143,7 +143,7 @@ static int lvchange_permission(struct logical_volume *lv)
log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg))
return 0;
backup(lv->vg);
@ -155,16 +155,16 @@ static int lvchange_permission(struct logical_volume *lv)
return 1;
}
static int lvchange_availability(struct logical_volume *lv)
static int lvchange_availability(struct cmd_context *cmd, struct logical_volume *lv)
{
int activate = 0;
int active;
if (strcmp(arg_str_value(available_ARG, "n"), "n"))
if (strcmp(arg_str_value(cmd,available_ARG, "n"), "n"))
activate = 1;
if (arg_count(minor_ARG)) {
lv->minor = arg_int_value(minor_ARG, -1);
if (arg_count(cmd,minor_ARG)) {
lv->minor = arg_int_value(cmd,minor_ARG, -1);
}
if ((active = lv_active(lv)) < 0) {
@ -204,11 +204,11 @@ static int lvchange_availability(struct logical_volume *lv)
return 1;
}
static int lvchange_contiguous(struct logical_volume *lv)
static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *lv)
{
int lv_allocation = 0;
if (strcmp(arg_str_value(contiguous_ARG, "n"), "n"))
if (strcmp(arg_str_value(cmd,contiguous_ARG, "n"), "n"))
lv_allocation |= ALLOC_CONTIGUOUS;
if ((lv_allocation & ALLOC_CONTIGUOUS) &&
@ -244,7 +244,7 @@ static int lvchange_contiguous(struct logical_volume *lv)
log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg))
return 0;
backup(lv->vg);
@ -252,11 +252,11 @@ static int lvchange_contiguous(struct logical_volume *lv)
return 1;
}
static int lvchange_readahead(struct logical_volume *lv)
static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv)
{
int read_ahead = 0;
read_ahead = arg_int_value(readahead_ARG, 0);
read_ahead = arg_int_value(cmd,readahead_ARG, 0);
/******* FIXME Ranges?
if (read_ahead < LVM_MIN_READ_AHEAD || read_ahead > LVM_MAX_READ_AHEAD) {
@ -276,7 +276,7 @@ static int lvchange_readahead(struct logical_volume *lv)
log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg))
return 0;
backup(lv->vg);
@ -284,9 +284,9 @@ static int lvchange_readahead(struct logical_volume *lv)
return 1;
}
static int lvchange_persistent(struct logical_volume *lv)
static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *lv)
{
if (!strcmp(arg_str_value(persistent_ARG, "n"), "n")) {
if (!strcmp(arg_str_value(cmd,persistent_ARG, "n"), "n")) {
if (!(lv->status & FIXED_MINOR)) {
log_error("Minor number is already not persistent "
"for \"%s\"", lv->name);
@ -300,19 +300,19 @@ static int lvchange_persistent(struct logical_volume *lv)
log_error("Cannot change minor number when active");
return 0;
}
if (!arg_count(minor_ARG)) {
if (!arg_count(cmd,minor_ARG)) {
log_error("Minor number must be specified with -My");
return 0;
}
lv->status |= FIXED_MINOR;
lv->minor = arg_int_value(minor_ARG, -1);
lv->minor = arg_int_value(cmd,minor_ARG, -1);
log_verbose("Setting persistent minor number to %d for \"%s\"",
lv->minor, lv->name);
}
log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg))
return 0;
backup(lv->vg);

70
tools/lvcreate.c
View File

@ -9,7 +9,7 @@
#include <fcntl.h>
int lvcreate(int argc, char **argv)
int lvcreate(struct cmd_context *cmd, int argc, char **argv)
{
int zero;
uint32_t read_ahead = 0;
@ -28,38 +28,38 @@ int lvcreate(int argc, char **argv)
char *vg_name;
char *st;
if (arg_count(snapshot_ARG) || arg_count(chunksize_ARG)) {
if (arg_count(cmd,snapshot_ARG) || arg_count(cmd,chunksize_ARG)) {
log_error("Snapshots are not yet supported in LVM2.");
return EINVALID_CMD_LINE;
}
/* mutually exclusive */
if ((arg_count(zero_ARG) && arg_count(snapshot_ARG)) ||
(arg_count(extents_ARG) && arg_count(size_ARG))) {
if ((arg_count(cmd,zero_ARG) && arg_count(cmd,snapshot_ARG)) ||
(arg_count(cmd,extents_ARG) && arg_count(cmd,size_ARG))) {
log_error("Invalid combination of arguments");
return EINVALID_CMD_LINE;
}
if (arg_count(size_ARG) + arg_count(extents_ARG) == 0) {
if (arg_count(cmd,size_ARG) + arg_count(cmd,extents_ARG) == 0) {
log_error("Please indicate size using option -l or -L");
return EINVALID_CMD_LINE;
}
if (strcmp(arg_str_value(contiguous_ARG, "n"), "n"))
if (strcmp(arg_str_value(cmd,contiguous_ARG, "n"), "n"))
status |= ALLOC_CONTIGUOUS;
else
status |= ALLOC_SIMPLE;
zero = strcmp(arg_str_value(zero_ARG, "y"), "n");
zero = strcmp(arg_str_value(cmd,zero_ARG, "y"), "n");
if (arg_count(stripes_ARG)) {
stripes = arg_int_value(stripes_ARG, 1);
if (arg_count(cmd,stripes_ARG)) {
stripes = arg_int_value(cmd,stripes_ARG, 1);
if (stripes == 1)
log_print("Redundant stripes argument: default is 1");
}
if (arg_count(stripesize_ARG))
stripesize = 2 * arg_int_value(stripesize_ARG, 0);
if (arg_count(cmd,stripesize_ARG))
stripesize = 2 * arg_int_value(cmd,stripesize_ARG, 0);
if (stripes == 1 && stripesize) {
log_print("Ignoring stripesize argument with single stripe");
@ -71,27 +71,27 @@ int lvcreate(int argc, char **argv)
log_print("Using default stripesize %dKB", stripesize / 2);
}
if (arg_count(permission_ARG))
status |= arg_int_value(permission_ARG, 0);
if (arg_count(cmd,permission_ARG))
status |= arg_int_value(cmd,permission_ARG, 0);
else
status |= LVM_READ | LVM_WRITE;
if (arg_count(readahead_ARG))
read_ahead = arg_int_value(readahead_ARG, 0);
if (arg_count(cmd,readahead_ARG))
read_ahead = arg_int_value(cmd,readahead_ARG, 0);
if (arg_count(extents_ARG))
extents = arg_int_value(extents_ARG, 0);
if (arg_count(cmd,extents_ARG))
extents = arg_int_value(cmd,extents_ARG, 0);
/* Size returned in kilobyte units; held in sectors */
if (arg_count(size_ARG))
size = arg_int_value(size_ARG, 0);
if (arg_count(cmd,size_ARG))
size = arg_int_value(cmd,size_ARG, 0);
if (arg_count(name_ARG))
lv_name = arg_value(name_ARG);
if (arg_count(cmd,name_ARG))
lv_name = arg_value(cmd,name_ARG);
/* If VG not on command line, try -n arg and then environment */
if (!argc) {
if (!(vg_name = extract_vgname(fid, lv_name))) {
if (!(vg_name = extract_vgname(cmd->fid, lv_name))) {
log_error("Please provide a volume group name");
return EINVALID_CMD_LINE;
}
@ -99,7 +99,7 @@ int lvcreate(int argc, char **argv)
} else {
/* Ensure lv_name doesn't contain a different VG! */
if (lv_name && strchr(lv_name, '/')) {
if (!(vg_name = extract_vgname(fid, lv_name)))
if (!(vg_name = extract_vgname(cmd->fid, lv_name)))
return EINVALID_CMD_LINE;
if (strcmp(vg_name, argv[0])) {
log_error("Inconsistent volume group names "
@ -124,7 +124,7 @@ int lvcreate(int argc, char **argv)
return ECMD_FAILED;
}
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist", vg_name);
goto error;
}
@ -150,7 +150,7 @@ int lvcreate(int argc, char **argv)
pvh = &vg->pvs;
else {
if (!(pvh = create_pv_list(fid->cmd->mem, vg,
if (!(pvh = create_pv_list(cmd->mem, vg,
argc - opt, argv + opt))) {
stack;
goto error;
@ -209,27 +209,27 @@ int lvcreate(int argc, char **argv)
if (!archive(vg))
goto error;
if (!(lv = lv_create(fid, lv_name, status,
if (!(lv = lv_create(cmd->fid, lv_name, status,
stripes, stripesize, extents,
vg, pvh)))
goto error;
if (arg_count(readahead_ARG)) {
if (arg_count(cmd,readahead_ARG)) {
log_verbose("Setting read ahead sectors");
lv->read_ahead = read_ahead;
}
if (arg_count(minor_ARG)) {
if (arg_count(cmd,minor_ARG)) {
lv->status |= FIXED_MINOR;
lv->minor = arg_int_value(minor_ARG, -1);
lv->minor = arg_int_value(cmd,minor_ARG, -1);
log_verbose("Setting minor number to %d", lv->minor);
}
if (arg_count(persistent_ARG)) {
if (!strcmp(arg_str_value(persistent_ARG, "n"), "n"))
if (arg_count(cmd,persistent_ARG)) {
if (!strcmp(arg_str_value(cmd,persistent_ARG, "n"), "n"))
lv->status &= ~FIXED_MINOR;
else
if (!arg_count(minor_ARG)) {
if (!arg_count(cmd,minor_ARG)) {
log_error("Please specify minor number with "
"--minor when using -My");
goto error;
@ -238,7 +238,7 @@ int lvcreate(int argc, char **argv)
}
/* store vg on disk(s) */
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
goto error;
backup(vg);
@ -252,12 +252,12 @@ int lvcreate(int argc, char **argv)
struct device *dev;
char *name;
if (!(name = pool_alloc(fid->cmd->mem, PATH_MAX))) {
if (!(name = pool_alloc(cmd->mem, PATH_MAX))) {
log_error("Name allocation failed - device not zeroed");
goto error;
}
if (lvm_snprintf(name, PATH_MAX, "%s%s/%s", fid->cmd->dev_dir,
if (lvm_snprintf(name, PATH_MAX, "%s%s/%s", cmd->dev_dir,
lv->vg->name, lv->name) < 0) {
log_error("Name too long - device not zeroed (%s)",
lv->name);

33
tools/lvdisplay.c
View File

@ -20,27 +20,28 @@
#include "tools.h"
int lvdisplay(int argc, char **argv)
int lvdisplay_single(struct cmd_context *cmd, struct logical_volume *lv)
{
/* FIXME Allow VG args via process_each */
if (arg_count(colon_ARG) && arg_count(verbose_ARG)) {
log_error("Options -v and -c are incompatible");
return EINVALID_CMD_LINE;
}
return process_each_lv(argc, argv, &lvdisplay_single);
}
int lvdisplay_single(struct logical_volume *lv)
{
if (arg_count(colon_ARG))
if (arg_count(cmd,colon_ARG))
lvdisplay_colons(lv);
else {
lvdisplay_full(lv);
if (arg_count(maps_ARG))
lvdisplay_full(cmd, lv);
if (arg_count(cmd,maps_ARG))
lvdisplay_segments(lv);
}
return 0;
}
int lvdisplay(struct cmd_context *cmd, int argc, char **argv)
{
/* FIXME Allow VG args via process_each */
if (arg_count(cmd,colon_ARG) && arg_count(cmd,verbose_ARG)) {
log_error("Options -v and -c are incompatible");
return EINVALID_CMD_LINE;
}
return process_each_lv(cmd, argc, argv, &lvdisplay_single);
}

4
tools/lvextend.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int lvextend(int argc, char **argv)
int lvextend(struct cmd_context *cmd, int argc, char **argv)
{
return lvresize(argc, argv);
return lvresize(cmd, argc, argv);
}

77
tools/lvm.c
View File

@ -31,7 +31,9 @@
#endif
#endif
/* define exported table of valid switches */
/*
* Exported table of valid switches
*/
struct arg the_args[ARG_COUNT + 1] = {
#define arg(a, b, c, d) {b, "--" c, d, 0, NULL},
@ -40,19 +42,10 @@ struct arg the_args[ARG_COUNT + 1] = {
};
static int _array_size;
static int _num_commands;
static struct command *_commands;
/* Exported LVM1 disk format */
struct format_instance *fid;
/* Map of uuid -> device */
struct uuid_map *the_um;
/* Export command being processed */
struct command *the_command;
struct cmd_context *cmd;
/* Whether or not to dump persistent filter state */
@ -558,14 +551,14 @@ static int merge_synonym(int oldarg, int newarg)
{
struct arg *old, *new;
if (arg_count(oldarg) && arg_count(newarg)) {
if (arg_count(cmd,oldarg) && arg_count(cmd,newarg)) {
log_error("%s and %s are synonyms. Please only supply one.",
the_args[oldarg].long_arg,
the_args[newarg].long_arg);
return 0;
}
if (!arg_count(oldarg))
if (!arg_count(cmd,oldarg))
return 1;
old = the_args + oldarg;
@ -579,7 +572,7 @@ static int merge_synonym(int oldarg, int newarg)
return 1;
}
int version(int argc, char **argv)
int version(struct cmd_context *cmd, int argc, char **argv)
{
char version[80];
@ -596,39 +589,39 @@ static int process_common_commands(struct command *com)
{
_current_settings = _default_settings;
if (arg_count(suspend_ARG))
if (arg_count(cmd,suspend_ARG))
kill(getpid(), SIGSTOP);
if (arg_count(debug_ARG))
if (arg_count(cmd,debug_ARG))
_current_settings.debug = _LOG_FATAL +
(arg_count(debug_ARG) - 1);
(arg_count(cmd,debug_ARG) - 1);
if (arg_count(verbose_ARG))
_current_settings.verbose = arg_count(verbose_ARG);
if (arg_count(cmd,verbose_ARG))
_current_settings.verbose = arg_count(cmd,verbose_ARG);
if (arg_count(quiet_ARG)) {
if (arg_count(cmd,quiet_ARG)) {
_current_settings.debug = 0;
_current_settings.verbose = 0;
}
if (arg_count(test_ARG))
_current_settings.test = arg_count(test_ARG);
if (arg_count(cmd,test_ARG))
_current_settings.test = arg_count(cmd,test_ARG);
if (arg_count(help_ARG)) {
if (arg_count(cmd,help_ARG)) {
usage(com->name);
return ECMD_PROCESSED;
}
if (arg_count(version_ARG)) {
return version(0, (char **)NULL);
if (arg_count(cmd,version_ARG)) {
return version(cmd, 0, (char **)NULL);
}
if (arg_count(autobackup_ARG)) {
if (arg_count(cmd,autobackup_ARG)) {
_current_settings.archive = 1;
_current_settings.backup = 1;
}
if (arg_count(partial_ARG)) {
if (arg_count(cmd,partial_ARG)) {
init_partial(1);
log_print("Partial mode. Incomplete volume groups will "
"be activated read-only.");
@ -646,7 +639,7 @@ static int process_common_commands(struct command *com)
return 0;
}
int help(int argc, char **argv)
int help(struct cmd_context *cmd, int argc, char **argv)
{
if (!argc)
display_help();
@ -725,17 +718,17 @@ static int run_command(int argc, char **argv)
if (!(cmd->cmd_line = _copy_command_line(cmd->mem, argc, argv)))
return ECMD_FAILED;
if (!(the_command = find_command(argv[0])))
if (!(cmd->command = find_command(argv[0])))
return ENO_SUCH_CMD;
if (!process_command_line(the_command, &argc, &argv)) {
if (!process_command_line(cmd->command, &argc, &argv)) {
log_error("Error during parsing of command line.");
return EINVALID_CMD_LINE;
}
set_cmd_name(the_command->name);
set_cmd_name(cmd->command->name);
if ((ret = process_common_commands(the_command)))
if ((ret = process_common_commands(cmd->command)))
return ret;
_use_settings(&_current_settings);
@ -748,7 +741,7 @@ static int run_command(int argc, char **argv)
return 0;
}
ret = the_command->fn(argc, argv);
ret = cmd->command->fn(cmd, argc, argv);
fin_locking();
@ -766,7 +759,7 @@ static int run_command(int argc, char **argv)
pool_empty(cmd->mem);
if (ret == EINVALID_CMD_LINE && !_interactive)
usage(the_command->name);
usage(cmd->command->name);
return ret;
@ -1018,7 +1011,7 @@ static struct dev_filter *filter_setup(struct config_file *cf)
return f4;
}
static int _init_uuid_map(struct dev_filter *filter)
static struct uuid_map *_init_uuid_map(struct dev_filter *filter)
{
label_init();
@ -1033,12 +1026,12 @@ static int _init_uuid_map(struct dev_filter *filter)
return 0;
}
return (the_um = uuid_map_create(filter)) ? 1 : 0;
return uuid_map_create(filter);
}
static void _exit_uuid_map(void)
{
uuid_map_destroy(the_um);
uuid_map_destroy(cmd->um);
label_exit();
_lvm1_label->ops->destroy(_lvm1_label);
_lvm1_label = NULL;
@ -1078,6 +1071,8 @@ static int init(void)
return 0;
}
cmd->args = &the_args[0];
if (!(cmd->cf = create_config_file())) {
stack;
return 0;
@ -1144,7 +1139,7 @@ static int init(void)
}
/* the uuid map uses the filter */
if (!_init_uuid_map(cmd->filter)) {
if (!(cmd->um = _init_uuid_map(cmd->filter))) {
log_err("Failed to set up the uuid map.");
return 0;
}
@ -1154,7 +1149,7 @@ static int init(void)
return 0;
}
if (!(fid = create_lvm1_format(cmd)))
if (!(cmd->fid = create_lvm1_format(cmd)))
return 0;
_use_settings(&_default_settings);
@ -1176,16 +1171,16 @@ static void fin(void)
if (_dump_filter)
persistent_filter_dump(cmd->filter);
fid->ops->destroy(fid);
cmd->fid->ops->destroy(cmd->fid);
cmd->filter->destroy(cmd->filter);
pool_destroy(cmd->mem);
vgcache_destroy();
dev_cache_exit();
destroy_config_file(cmd->cf);
dbg_free(cmd);
archive_exit();
backup_exit();
_exit_uuid_map();
dbg_free(cmd);
__fin_commands();
dump_memory();

2
tools/lvmchange.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int lvmchange(int argc, char **argv)
int lvmchange(struct cmd_context *cmd, int argc, char **argv)
{
log_print("With the device mapper, this program is obsolete.");
return 0;

20
tools/lvmdiskscan.c
View File

@ -13,7 +13,7 @@
#include "tools.h"
int _get_max_dev_name_len(void);
int _get_max_dev_name_len(struct dev_filter *filter);
void _count(struct device*, int*, int*);
void _print(struct device*, uint64_t, char*);
int _check_device(struct device*);
@ -24,19 +24,19 @@ int pv_disks_found = 0;
int pv_parts_found = 0;
int max_len;
int lvmdiskscan(int argc, char **argv)
int lvmdiskscan(struct cmd_context *cmd, int argc, char **argv)
{
uint64_t size;
struct dev_iter *iter;
struct device *dev;
struct physical_volume *pv;
if (arg_count(lvmpartition_ARG))
if (arg_count(cmd,lvmpartition_ARG))
log_print("WARNING: only considering LVM devices");
max_len = _get_max_dev_name_len();
max_len = _get_max_dev_name_len(cmd->filter);
if (!(iter = dev_iter_create(fid->cmd->filter))) {
if (!(iter = dev_iter_create(cmd->filter))) {
log_error("dev_iter_create failed");
return 0;
}
@ -44,7 +44,7 @@ int lvmdiskscan(int argc, char **argv)
/* Do scan */
for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) {
/* Try if it is a PV first */
if((pv = fid->ops->pv_read(fid, dev_name(dev)))) {
if((pv = cmd->fid->ops->pv_read(cmd->fid, dev_name(dev)))) {
if(!dev_get_size(dev, &size)) {
log_error("Couldn't get size of \"%s\"",
dev_name(dev));
@ -55,7 +55,7 @@ int lvmdiskscan(int argc, char **argv)
continue;
}
/* If user just wants PVs we are done */
if (arg_count(lvmpartition_ARG)) continue;
if (arg_count(cmd,lvmpartition_ARG)) continue;
/* What other device is it? */
if(!_check_device(dev)) continue;
@ -63,7 +63,7 @@ int lvmdiskscan(int argc, char **argv)
dev_iter_destroy(iter);
/* Display totals */
if (!arg_count(lvmpartition_ARG)) {
if (!arg_count(cmd,lvmpartition_ARG)) {
log_print("%d disk%s",
disks_found, disks_found == 1 ? "" : "s");
log_print("%d partition%s",
@ -103,13 +103,13 @@ int _check_device(struct device *dev) {
}
int _get_max_dev_name_len(void) {
int _get_max_dev_name_len(struct dev_filter *filter) {
int len = 0;
int max_len = 0;
struct dev_iter *iter;
struct device *dev;
if (!(iter = dev_iter_create(fid->cmd->filter))) {
if (!(iter = dev_iter_create(filter))) {
log_error("dev_iter_create failed");
return 0;
}

4
tools/lvreduce.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int lvreduce(int argc, char **argv)
int lvreduce(struct cmd_context *cmd, int argc, char **argv)
{
return lvresize(argc, argv);
return lvresize(cmd, argc, argv);
}

12
tools/lvremove.c
View File

@ -20,19 +20,19 @@
#include "tools.h"
static int lvremove_single(struct logical_volume *lv);
static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv);
int lvremove(int argc, char **argv)
int lvremove(struct cmd_context *cmd, int argc, char **argv)
{
if (!argc) {
log_error("Please enter one or more logical volume paths");
return EINVALID_CMD_LINE;
}
return process_each_lv(argc, argv, &lvremove_single);
return process_each_lv(cmd, argc, argv, &lvremove_single);
}
static int lvremove_single(struct logical_volume *lv)
static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv)
{
struct volume_group *vg;
int active;
@ -57,7 +57,7 @@ static int lvremove_single(struct logical_volume *lv)
active = lv_active(lv);
if (active && !arg_count(force_ARG)) {
if (active && !arg_count(cmd,force_ARG)) {
if (yes_no_prompt
("Do you really want to remove active logical volume \"%s\"? "
"[y/n]: ", lv->name) == 'n') {
@ -80,7 +80,7 @@ static int lvremove_single(struct logical_volume *lv)
}
/* store it on disks */
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
return ECMD_FAILED;
backup(vg);

14
tools/lvrename.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int lvrename(int argc, char **argv)
int lvrename(struct cmd_context *cmd, int argc, char **argv)
{
int maxlen;
int active;
@ -40,13 +40,13 @@ int lvrename(int argc, char **argv)
lv_name_old = argv[0];
lv_name_new = argv[1];
if (!(vg_name = extract_vgname(fid, lv_name_old))) {
if (!(vg_name = extract_vgname(cmd->fid, lv_name_old))) {
log_error("Please provide a volume group name");
return EINVALID_CMD_LINE;
}
if (strchr(lv_name_new, '/') &&
(vg_name_new = extract_vgname(fid, lv_name_new)) &&
(vg_name_new = extract_vgname(cmd->fid, lv_name_new)) &&
strcmp(vg_name, vg_name_new)) {
log_error("Logical volume names must "
"have the same volume group (\"%s\" or \"%s\")",
@ -61,7 +61,7 @@ int lvrename(int argc, char **argv)
lv_name_new = st + 1;
/* Check sanity of new name */
maxlen = NAME_LEN - strlen(vg_name) - strlen(fid->cmd->dev_dir) - 3;
maxlen = NAME_LEN - strlen(vg_name) - strlen(cmd->dev_dir) - 3;
if (strlen(lv_name_new) > maxlen) {
log_error("New logical volume path exceeds maximum length "
"of %d!", maxlen);
@ -91,7 +91,7 @@ int lvrename(int argc, char **argv)
return ECMD_FAILED;
}
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist", vg_name);
goto error;
}
@ -133,14 +133,14 @@ int lvrename(int argc, char **argv)
goto error;
}
if (!(lv->name = pool_strdup(fid->cmd->mem, lv_name_new))) {
if (!(lv->name = pool_strdup(cmd->mem, lv_name_new))) {
log_error("Failed to allocate space for new name");
goto error;
}
/* store it on disks */
log_verbose("Writing out updated volume group");
if (!(fid->ops->vg_write(fid, vg))) {
if (!(cmd->fid->ops->vg_write(cmd->fid, vg))) {
goto error;
}

40
tools/lvresize.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int lvresize(int argc, char **argv)
int lvresize(struct cmd_context *cmd, int argc, char **argv)
{
struct volume_group *vg;
struct logical_volume *lv;
@ -45,25 +45,25 @@ int lvresize(int argc, char **argv)
LV_EXTEND = 2
} resize = LV_ANY;
cmd_name = command_name();
cmd_name = command_name(cmd);
if (!strcmp(cmd_name, "lvreduce"))
resize = LV_REDUCE;
if (!strcmp(cmd_name, "lvextend"))
resize = LV_EXTEND;
if (arg_count(extents_ARG) + arg_count(size_ARG) != 1) {
if (arg_count(cmd,extents_ARG) + arg_count(cmd,size_ARG) != 1) {
log_error("Please specify either size or extents (not both)");
return EINVALID_CMD_LINE;
}
if (arg_count(extents_ARG)) {
extents = arg_int_value(extents_ARG, 0);
sign = arg_sign_value(extents_ARG, SIGN_NONE);
if (arg_count(cmd,extents_ARG)) {
extents = arg_int_value(cmd,extents_ARG, 0);
sign = arg_sign_value(cmd,extents_ARG, SIGN_NONE);
}
if (arg_count(size_ARG)) {
size = arg_int_value(size_ARG, 0);
sign = arg_sign_value(size_ARG, SIGN_NONE);
if (arg_count(cmd,size_ARG)) {
size = arg_int_value(cmd,size_ARG, 0);
sign = arg_sign_value(cmd,size_ARG, SIGN_NONE);
}
if (resize == LV_EXTEND && sign == SIGN_MINUS) {
@ -76,14 +76,14 @@ int lvresize(int argc, char **argv)
return EINVALID_CMD_LINE;
}
if (arg_count(stripes_ARG)) {
if (arg_count(cmd,stripes_ARG)) {
log_print("Varied striping not yet supported. Ignoring.");
/* FUTURE stripes = arg_int_value(stripes_ARG, 1); */
/* FUTURE stripes = arg_int_value(cmd,stripes_ARG, 1); */
}
if (arg_count(stripesize_ARG)) {
if (arg_count(cmd,stripesize_ARG)) {
log_print("Varied stripesize not yet supported. Ignoring.");
/* FUTURE stripesize = 2 * arg_int_value(stripesize_ARG, 0); */
/* FUTURE stripesize = 2 * arg_int_value(cmd,stripesize_ARG, 0); */
}
if (!argc) {
@ -95,7 +95,7 @@ int lvresize(int argc, char **argv)
argv++;
argc--;
if (!(vg_name = extract_vgname(fid, lv_name))) {
if (!(vg_name = extract_vgname(cmd->fid, lv_name))) {
log_error("Please provide a volume group name");
return EINVALID_CMD_LINE;
}
@ -110,7 +110,7 @@ int lvresize(int argc, char **argv)
return ECMD_FAILED;
}
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
goto error;
}
@ -290,7 +290,7 @@ int lvresize(int argc, char **argv)
dbg_free(dummy);
}
if (!arg_count(force_ARG)) {
if (!arg_count(cmd,force_ARG)) {
if (yes_no_prompt("Do you really want to reduce %s?"
" [y/n]: ", lv_name) == 'n') {
log_print("Logical volume %s NOT reduced",
@ -302,12 +302,12 @@ int lvresize(int argc, char **argv)
if (!archive(vg))
goto error;
if (!lv_reduce(fid, lv, lv->le_count - extents))
if (!lv_reduce(cmd->fid, lv, lv->le_count - extents))
goto error;
}
if ((resize == LV_EXTEND && argc) &&
!(pvh = create_pv_list(fid->cmd->mem, vg,
!(pvh = create_pv_list(cmd->mem, vg,
argc - opt, argv + opt))) {
stack;
goto error;
@ -325,7 +325,7 @@ int lvresize(int argc, char **argv)
log_print("Extending logical volume %s to %s", lv_name, dummy);
dbg_free(dummy);
if (!lv_extend(fid, lv, stripes, stripesize,
if (!lv_extend(cmd->fid, lv, stripes, stripesize,
extents - lv->le_count, pvh))
goto error;
}
@ -336,7 +336,7 @@ int lvresize(int argc, char **argv)
/********* FIXME Suspend lv ***********/
/* store vg on disk(s) */
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
goto error;
backup(vg);

12
tools/lvscan.c
View File

@ -20,16 +20,16 @@
#include "tools.h"
static int lvscan_single(struct logical_volume *lv);
static int lvscan_single(struct cmd_context *cmd, struct logical_volume *lv);
int lvscan(int argc, char **argv)
int lvscan(struct cmd_context *cmd, int argc, char **argv)
{
if (argc) {
log_error("No additional command line arguments allowed");
return EINVALID_CMD_LINE;
}
return process_each_lv(argc, argv, &lvscan_single);
return process_each_lv(cmd, argc, argv, &lvscan_single);
/*********** FIXME Count! Add private struct to process_each*
if (!lv_total)
@ -54,7 +54,7 @@ int lvscan(int argc, char **argv)
}
static int lvscan_single(struct logical_volume *lv)
static int lvscan_single(struct cmd_context *cmd, struct logical_volume *lv)
{
int active = 0;
int lv_total = 0;
@ -88,7 +88,7 @@ static int lvscan_single(struct logical_volume *lv)
dummy = display_size(lv->size / 2, SIZE_SHORT);
log_print("%s%s '%s%s/%s' [%s]%s%s", active_str, snapshot_str,
fid->cmd->dev_dir, lv->vg->name, lv->name, dummy,
cmd->dev_dir, lv->vg->name, lv->name, dummy,
(lv->status & ALLOC_STRICT) ? " strict" : "",
(lv->status & ALLOC_CONTIGUOUS) ? " contiguous" : "");
@ -102,7 +102,7 @@ static int lvscan_single(struct logical_volume *lv)
****************/
/******** FIXME Device number display & Snapshot
if (arg_count(blockdevice_ARG))
if (arg_count(cmd,blockdevice_ARG))
printf(" %d:%d",
MAJOR(lv->lv_dev),
MINOR(lv->lv_dev));

28
tools/pvchange.c
View File

@ -20,9 +20,9 @@
#include "tools.h"
int pvchange_single(struct physical_volume *pv);
int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv);
int pvchange(int argc, char **argv)
int pvchange(struct cmd_context *cmd, int argc, char **argv)
{
int opt = 0;
int done = 0;
@ -33,17 +33,17 @@ int pvchange(int argc, char **argv)
struct list *pvh, *pvs;
if (arg_count(allocatable_ARG) == 0) {
if (arg_count(cmd,allocatable_ARG) == 0) {
log_error("Please give the x option");
return EINVALID_CMD_LINE;
}
if (!(arg_count(all_ARG)) && !argc) {
if (!(arg_count(cmd,all_ARG)) && !argc) {
log_error("Please give a physical volume path");
return EINVALID_CMD_LINE;
}
if (arg_count(all_ARG) && argc) {
if (arg_count(cmd,all_ARG) && argc) {
log_error("Option a and PhysicalVolumePath are exclusive");
return EINVALID_CMD_LINE;
}
@ -52,23 +52,23 @@ int pvchange(int argc, char **argv)
log_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) {
pv_name = argv[opt];
if (!(pv = fid->ops->pv_read(fid, pv_name))) {
if (!(pv = cmd->fid->ops->pv_read(cmd->fid, pv_name))) {
log_error("Failed to read physical volume \"%s\"",
pv_name);
continue;
}
total++;
done += pvchange_single(pv);
done += pvchange_single(cmd, pv);
}
} else {
log_verbose("Scanning for physical volume names");
if (!(pvs = fid->ops->get_pvs(fid))) {
if (!(pvs = cmd->fid->ops->get_pvs(cmd->fid))) {
return ECMD_FAILED;
}
list_iterate(pvh, pvs) {
total++;
done += pvchange_single(
done += pvchange_single(cmd,
list_item(pvh, struct pv_list)->pv);
}
}
@ -81,14 +81,14 @@ int pvchange(int argc, char **argv)
return 0;
}
int pvchange_single(struct physical_volume *pv)
int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv)
{
struct volume_group *vg = NULL;
struct pv_list *pvl;
const char *pv_name = dev_name(pv->dev);
int allocatable = !strcmp(arg_str_value(allocatable_ARG, "n"), "y");
int allocatable = !strcmp(arg_str_value(cmd,allocatable_ARG, "n"), "y");
/* If in a VG, must change using volume group. */
if (*pv->vg_name) {
@ -100,7 +100,7 @@ int pvchange_single(struct physical_volume *pv)
return ECMD_FAILED;
}
if (!(vg = fid->ops->vg_read(fid, pv->vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, pv->vg_name))) {
lock_vol(pv->vg_name, LCK_VG | LCK_NONE);
log_error("Unable to find volume group of \"%s\"",
pv_name);
@ -157,7 +157,7 @@ int pvchange_single(struct physical_volume *pv)
log_verbose("Updating physical volume \"%s\"", pv_name);
if (*pv->vg_name) {
if (!(fid->ops->vg_write(fid,vg))) {
if (!(cmd->fid->ops->vg_write(cmd->fid,vg))) {
lock_vol(pv->vg_name, LCK_VG | LCK_NONE);
log_error("Failed to store physical volume \"%s\" in "
"volume group \"%s\"", pv_name, vg->name);
@ -166,7 +166,7 @@ int pvchange_single(struct physical_volume *pv)
backup(vg);
lock_vol(pv->vg_name, LCK_VG | LCK_NONE);
} else {
if (!(fid->ops->pv_write(fid, pv))) {
if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) {
log_error("Failed to store physical volume \"%s\"",
pv_name);
return 0;

36
tools/pvcreate.c
View File

@ -27,16 +27,16 @@ const char _really_init[] =
* See if we may pvcreate on this device.
* 0 indicates we may not.
*/
static int pvcreate_check(const char *name)
static int pvcreate_check(struct cmd_context *cmd, const char *name)
{
struct physical_volume *pv;
/* is the partition type set correctly ? */
if ((arg_count(force_ARG) < 1) && !is_lvm_partition(name))
if ((arg_count(cmd,force_ARG) < 1) && !is_lvm_partition(name))
return 0;
/* is there a pv here already */
if (!(pv = fid->ops->pv_read(fid, name)))
if (!(pv = cmd->fid->ops->pv_read(cmd->fid, name)))
return 1;
/* orphan ? */
@ -45,20 +45,20 @@ static int pvcreate_check(const char *name)
/* Allow partial & exported VGs to be destroyed. */
/* we must have -ff to overwrite a non orphan */
if (arg_count(force_ARG) < 2) {
if (arg_count(cmd,force_ARG) < 2) {
log_error("Can't initialize physical volume \"%s\" of "
"volume group \"%s\" without -ff", name, pv->vg_name);
return 0;
}
/* prompt */
if (!arg_count(yes_ARG) &&
if (!arg_count(cmd,yes_ARG) &&
yes_no_prompt(_really_init, name, pv->vg_name) == 'n') {
log_print("Physical volume \"%s\" not initialized", name);
return 0;
}
if (arg_count(force_ARG)) {
if (arg_count(cmd,force_ARG)) {
log_print("WARNING: Forcing physical volume creation on "
"%s%s%s%s", name,
pv->vg_name[0] ? " of volume group \"" : "",
@ -69,18 +69,18 @@ static int pvcreate_check(const char *name)
return 1;
}
static void pvcreate_single(const char *pv_name)
static void pvcreate_single(struct cmd_context *cmd, const char *pv_name)
{
struct physical_volume *pv;
struct id id, *idp = NULL;
char *uuid;
struct device *dev;
if (arg_count(uuidstr_ARG)) {
uuid = arg_str_value(uuidstr_ARG,"");
if (arg_count(cmd,uuidstr_ARG)) {
uuid = arg_str_value(cmd,uuidstr_ARG,"");
if (!id_read_format(&id, uuid))
return;
if ((dev = uuid_map_lookup(the_um, &id))) {
if ((dev = uuid_map_lookup(cmd->um, &id))) {
log_error("uuid %s already in use on \"%s\"", uuid,
dev_name(dev));
return;
@ -88,10 +88,10 @@ static void pvcreate_single(const char *pv_name)
idp = &id;
}
if (!pvcreate_check(pv_name))
if (!pvcreate_check(cmd, pv_name))
return;
if (!(pv = pv_create(fid, pv_name, idp))) {
if (!(pv = pv_create(cmd->fid, pv_name, idp))) {
log_err("Failed to setup physical volume \"%s\"", pv_name);
return;
}
@ -101,7 +101,7 @@ static void pvcreate_single(const char *pv_name)
pv_name, pv->size);
log_verbose("Writing physical volume data to disk \"%s\"", pv_name);
if (!(fid->ops->pv_write(fid, pv))) {
if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) {
log_error("Failed to write physical volume \"%s\"", pv_name);
return;
}
@ -109,7 +109,7 @@ static void pvcreate_single(const char *pv_name)
log_print("Physical volume \"%s\" successfully created", pv_name);
}
int pvcreate(int argc, char **argv)
int pvcreate(struct cmd_context *cmd, int argc, char **argv)
{
int i;
@ -118,19 +118,19 @@ int pvcreate(int argc, char **argv)
return EINVALID_CMD_LINE;
}
if (arg_count(uuidstr_ARG) && argc != 1) {
if (arg_count(cmd,uuidstr_ARG) && argc != 1) {
log_error("Can only set uuid on one volume at once");
return EINVALID_CMD_LINE;
}
if (arg_count(yes_ARG) && !arg_count(force_ARG)) {
if (arg_count(cmd,yes_ARG) && !arg_count(cmd,force_ARG)) {
log_error("Option y can only be given with option f");
return EINVALID_CMD_LINE;
}
for (i = 0; i < argc; i++) {
pvcreate_single(argv[i]);
pool_empty(fid->cmd->mem);
pvcreate_single(cmd, argv[i]);
pool_empty(cmd->mem);
}
return 0;

22
tools/pvdisplay.c
View File

@ -20,16 +20,16 @@
#include "tools.h"
void pvdisplay_single(struct physical_volume *pv);
void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv);
int pvdisplay(int argc, char **argv)
int pvdisplay(struct cmd_context *cmd, int argc, char **argv)
{
int opt=0;
struct list *pvh, *pvs;
struct physical_volume *pv;
if (arg_count(colon_ARG) && arg_count(maps_ARG)) {
if (arg_count(cmd,colon_ARG) && arg_count(cmd,maps_ARG)) {
log_error("Option -v not allowed with option -c");
return EINVALID_CMD_LINE;
}
@ -38,27 +38,27 @@ int pvdisplay(int argc, char **argv)
log_very_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) {
if (!(pv = fid->ops->pv_read(fid, argv[opt]))) {
if (!(pv = cmd->fid->ops->pv_read(cmd->fid, argv[opt]))) {
log_error("Failed to read physical "
"volume \"%s\"",
argv[opt]);
continue;
}
pvdisplay_single(pv);
pvdisplay_single(cmd, pv);
}
} else {
log_verbose("Scanning for physical volume names");
if (!(pvs = fid->ops->get_pvs(fid)))
if (!(pvs = cmd->fid->ops->get_pvs(cmd->fid)))
return ECMD_FAILED;
list_iterate(pvh, pvs)
pvdisplay_single(list_item(pvh, struct pv_list)->pv);
pvdisplay_single(cmd, list_item(pvh, struct pv_list)->pv);
}
return 0;
}
void pvdisplay_single(struct physical_volume *pv)
void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv)
{
char *sz;
uint64_t size;
@ -70,7 +70,7 @@ void pvdisplay_single(struct physical_volume *pv)
else
size = (pv->pe_count - pv->pe_allocated) * pv->pe_size;
if (arg_count(short_ARG)) {
if (arg_count(cmd,short_ARG)) {
sz = display_size(size / 2, SIZE_SHORT);
log_print("Device \"%s\" has a capacity of %s", pv_name, sz);
dbg_free(sz);
@ -103,14 +103,14 @@ void pvdisplay_single(struct physical_volume *pv)
ret = pv_check_consistency (pv)
*/
if (arg_count(colon_ARG)) {
if (arg_count(cmd,colon_ARG)) {
pvdisplay_colons(pv);
return;
}
pvdisplay_full(pv);
if (!arg_count(maps_ARG))
if (!arg_count(cmd,maps_ARG))
return;
/******* FIXME

28
tools/pvscan.c
View File

@ -20,12 +20,12 @@
#include "tools.h"
void pvscan_display_single(struct physical_volume *pv);
void pvscan_display_single(struct cmd_context *cmd, struct physical_volume *pv);
int pv_max_name_len = 0;
int vg_max_name_len = 0;
int pvscan(int argc, char **argv)
int pvscan(struct cmd_context *cmd, int argc, char **argv)
{
int new_pvs_found = 0;
int pvs_found = 0;
@ -43,21 +43,21 @@ int pvscan(int argc, char **argv)
pv_max_name_len = 0;
vg_max_name_len = 0;
if (arg_count(novolumegroup_ARG) && arg_count(exported_ARG)) {
if (arg_count(cmd,novolumegroup_ARG) && arg_count(cmd,exported_ARG)) {
log_error("Options -e and -n are incompatible");
return EINVALID_CMD_LINE;
}
if (arg_count(exported_ARG) || arg_count(novolumegroup_ARG))
if (arg_count(cmd,exported_ARG) || arg_count(cmd,novolumegroup_ARG))
log_print("WARNING: only considering physical volumes %s",
arg_count(exported_ARG) ?
arg_count(cmd,exported_ARG) ?
"of exported volume group(s)" : "in no volume group");
log_verbose("Wiping cache of LVM-capable devices");
persistent_filter_wipe(fid->cmd->filter);
persistent_filter_wipe(cmd->filter);
log_verbose("Walking through all physical volumes");
if (!(pvs = fid->ops->get_pvs(fid)))
if (!(pvs = cmd->fid->ops->get_pvs(cmd->fid)))
return ECMD_FAILED;
/* eliminate exported/new if required */
@ -65,8 +65,8 @@ int pvscan(int argc, char **argv)
pvl = list_item(pvh, struct pv_list);
pv = pvl->pv;
if ((arg_count(exported_ARG) && !(pv->status & EXPORTED_VG))
|| (arg_count(novolumegroup_ARG) && (*pv->vg_name))) {
if ((arg_count(cmd,exported_ARG) && !(pv->status & EXPORTED_VG))
|| (arg_count(cmd,novolumegroup_ARG) && (*pv->vg_name))) {
list_del(&pvl->list);
continue;
}
@ -108,7 +108,7 @@ int pvscan(int argc, char **argv)
vg_max_name_len += 2;
list_iterate(pvh, pvs)
pvscan_display_single(list_item(pvh, struct pv_list)->pv);
pvscan_display_single(cmd, list_item(pvh, struct pv_list)->pv);
if (!pvs_found) {
log_print("No matching physical volumes found");
@ -129,7 +129,7 @@ int pvscan(int argc, char **argv)
return 0;
}
void pvscan_display_single(struct physical_volume *pv)
void pvscan_display_single(struct cmd_context *cmd, struct physical_volume *pv)
{
char uuid[64];
int vg_name_len = 0;
@ -141,12 +141,12 @@ void pvscan_display_single(struct physical_volume *pv)
char vg_name_this[NAME_LEN] = { 0, };
/* short listing? */
if (arg_count(short_ARG) > 0) {
if (arg_count(cmd,short_ARG) > 0) {
log_print("%s", dev_name(pv->dev));
return;
}
if (arg_count(verbose_ARG) > 1) {
if (arg_count(cmd,verbose_ARG) > 1) {
/* FIXME As per pv_display! Drop through for now. */
/* pv_show(pv); */
@ -161,7 +161,7 @@ void pvscan_display_single(struct physical_volume *pv)
vg_name_len = strlen(pv->vg_name) + 1;
if (arg_count(uuid_ARG)) {
if (arg_count(cmd,uuid_ARG)) {
if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
stack;
return;

14
tools/stub.h
View File

@ -6,11 +6,11 @@
#define unimplemented \
{ log_error("Command not implemented yet."); return ECMD_FAILED;}
int e2fsadm(int argc, char **argv) unimplemented
int lvmsadc(int argc, char **argv) unimplemented
int lvmsar(int argc, char **argv) unimplemented
int pvdata(int argc, char **argv) unimplemented
int pvmove(int argc, char **argv) unimplemented
int vgmknodes(int argc, char **argv) unimplemented
int vgsplit(int argc, char **argv) unimplemented
int e2fsadm(struct cmd_context *cmd, int argc, char **argv) unimplemented
int lvmsadc(struct cmd_context *cmd, int argc, char **argv) unimplemented
int lvmsar(struct cmd_context *cmd, int argc, char **argv) unimplemented
int pvdata(struct cmd_context *cmd, int argc, char **argv) unimplemented
int pvmove(struct cmd_context *cmd, int argc, char **argv) unimplemented
int vgmknodes(struct cmd_context *cmd, int argc, char **argv) unimplemented
int vgsplit(struct cmd_context *cmd, int argc, char **argv) unimplemented

52
tools/toollib.c
View File

@ -8,8 +8,8 @@
#include <sys/stat.h>
int process_each_lv_in_vg(struct volume_group *vg,
int (*process_single) (struct logical_volume *lv))
int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct logical_volume *lv))
{
int ret_max = 0;
int ret = 0;
@ -24,7 +24,7 @@ int process_each_lv_in_vg(struct volume_group *vg,
list_iterate(lvh, &vg->lvs) {
lv = list_item(lvh, struct lv_list)->lv;
ret = process_single(lv);
ret = process_single(cmd, lv);
if (ret > ret_max)
ret_max = ret;
}
@ -33,8 +33,8 @@ 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_each_lv(struct cmd_context *cmd, int argc, char **argv,
int (*process_single) (struct cmd_context *cmd, struct logical_volume *lv))
{
int opt = 0;
int ret_max = 0;
@ -54,14 +54,14 @@ int process_each_lv(int argc, char **argv,
char *lv_name = argv[opt];
/* does VG exist? */
if (!(vg_name = extract_vgname(fid, lv_name))) {
if (!(vg_name = extract_vgname(cmd->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))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist",
vg_name);
if (ret_max < ECMD_FAILED)
@ -86,25 +86,25 @@ int process_each_lv(int argc, char **argv,
lv = lvl->lv;
if ((ret = process_single(lv)) > ret_max)
if ((ret = process_single(cmd, lv)) > ret_max)
ret_max = ret;
}
} else {
log_verbose("Finding all logical volumes");
if (!(vgs = fid->ops->get_vgs(fid))) {
if (!(vgs = cmd->fid->ops->get_vgs(cmd->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))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" not found",
vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
}
ret = process_each_lv_in_vg(vg, process_single);
ret = process_each_lv_in_vg(cmd, vg, process_single);
if (ret > ret_max)
ret_max = ret;
vg_count++;
@ -114,8 +114,8 @@ int process_each_lv(int argc, char **argv,
return ret_max;
}
int process_each_vg(int argc, char **argv, int lock_type,
int (*process_single) (const char *vg_name))
int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_type,
int (*process_single) (struct cmd_context *cmd, const char *vg_name))
{
int opt = 0;
int ret_max = 0;
@ -134,13 +134,13 @@ int process_each_vg(int argc, char **argv, int lock_type,
log_error("Can't lock %s: skipping", vg_name);
continue;
}
if ((ret = process_single(vg_name)) > ret_max)
if ((ret = process_single(cmd, vg_name)) > ret_max)
ret_max = ret;
lock_vol((void *)vg_name, LCK_VG | LCK_NONE);
}
} else {
log_verbose("Finding all volume groups");
if (!(vgs = fid->ops->get_vgs(fid))) {
if (!(vgs = cmd->fid->ops->get_vgs(cmd->fid))) {
log_error("No volume groups found");
return ECMD_FAILED;
}
@ -150,7 +150,7 @@ int process_each_vg(int argc, char **argv, int lock_type,
log_error("Can't lock %s: skipping", vg_name);
continue;
}
ret = process_single(vg_name);
ret = process_single(cmd, vg_name);
if (ret > ret_max)
ret_max = ret;
@ -161,8 +161,8 @@ int process_each_vg(int argc, char **argv, int lock_type,
return ret_max;
}
int process_each_pv_in_vg(struct volume_group *vg,
int (*process_single) (struct volume_group *vg,
int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct volume_group *vg,
struct physical_volume *pv))
{
int ret_max = 0;
@ -173,15 +173,15 @@ int process_each_pv_in_vg(struct volume_group *vg,
list_iterate(pvh, &vg->pvs) {
pv = list_item(pvh, struct pv_list)->pv;
if ((ret = process_single(vg, pv)) > ret_max)
if ((ret = process_single(cmd, vg, pv)) > ret_max)
ret_max = ret;
}
return ret_max;
}
int process_each_pv(int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct volume_group *vg,
int process_each_pv(struct cmd_context *cmd, int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct volume_group *vg,
struct physical_volume *pv))
{
int opt = 0;
@ -199,13 +199,13 @@ int process_each_pv(int argc, char **argv, struct volume_group *vg,
vg->name);
continue;
}
ret = process_single(vg, pvl->pv);
ret = process_single(cmd, vg, pvl->pv);
if (ret > ret_max)
ret_max = ret;
}
} else {
log_verbose("Using all physical volume(s) in volume group");
process_each_pv_in_vg(vg, process_single);
process_each_pv_in_vg(cmd, vg, process_single);
}
return ret_max;
@ -240,7 +240,7 @@ char *extract_vgname(struct format_instance *fi, char *lv_name)
return 0;
}
vg_name = pool_strdup(fid->cmd->mem, vg_name);
vg_name = pool_strdup(fi->cmd->mem, vg_name);
if (!vg_name) {
log_error("Allocation of vg_name failed");
return 0;
@ -250,7 +250,7 @@ char *extract_vgname(struct format_instance *fi, char *lv_name)
return vg_name;
}
if (!(vg_name = default_vgname(fid))) {
if (!(vg_name = default_vgname(fi))) {
if (lv_name)
log_error("Path required for Logical Volume \"%s\"",
lv_name);
@ -280,7 +280,7 @@ char *default_vgname(struct format_instance *fi)
return 0;
}
return pool_strdup(fid->cmd->mem, vg_path);
return pool_strdup(fi->cmd->mem, vg_path);
}
struct list *create_pv_list(struct pool *mem,

23
tools/toollib.h
View File

@ -21,26 +21,29 @@
#ifndef _LVM_TOOLLIB_H
#define _LVM_TOOLLIB_H
#include "metadata.h"
#include "pool.h"
int autobackup_set(void);
int autobackup_init(const char *backup_dir, int keep_days, int keep_number,
int autobackup);
int autobackup(struct volume_group *vg);
int process_each_vg(int argc, char **argv, int lock_type,
int (*process_single) (const char *vg_name));
int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_type,
int (*process_single) (struct cmd_context *cmd, const char *vg_name));
int process_each_pv(int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
int process_each_pv(struct cmd_context *cmd, int argc, char **argv, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct volume_group * vg,
struct physical_volume * pv));
int process_each_lv(int argc, char **argv,
int (*process_single) (struct logical_volume * lv));
int process_each_lv(struct cmd_context *cmd, int argc, char **argv,
int (*process_single) (struct cmd_context *cmd, struct logical_volume * lv));
int process_each_pv_in_vg(struct volume_group *vg,
int (*process_single) (struct volume_group * vg,
int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct volume_group * vg,
struct physical_volume * pv));
int process_each_lv_in_vg(struct volume_group *vg,
int (*process_single) (struct logical_volume * lv));
int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
int (*process_single) (struct cmd_context *cmd, struct logical_volume * lv));
int is_valid_chars(char *n);

59
tools/tools.h
View File

@ -1,20 +1,7 @@
/*
* Copyright (C) 2001 Sistina Software
* Copyright (C) 2001 Sistina Software (UK) Limited.
*
* 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 GNU CC; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
* This file is released under the LGPL.
*/
#ifndef _LVM_LVM_H
@ -43,6 +30,7 @@
#include "activate.h"
#include "archive.h"
#include "locking.h"
#include "toolcontext.h"
#include <stdio.h>
#include <stdarg.h>
@ -57,9 +45,9 @@
#define MAX_ARGS 64
/* command functions */
typedef int (*command_fn)(int argc, char **argv);
typedef int (*command_fn)(struct cmd_context *cmd, int argc, char **argv);
#define xx(a, b...) int a(int argc, char **argv);
#define xx(a, b...) int a(struct cmd_context *cmd, int argc, char **argv);
#include "commands.h"
#undef xx
@ -88,8 +76,6 @@ struct arg {
sign_t sign;
};
extern struct arg the_args[ARG_COUNT + 1];
/* a register of the lvm commands */
struct command {
const char *name;
@ -101,9 +87,6 @@ struct command {
int *valid_args;
};
extern struct command *the_command;
extern struct uuid_map *the_um;
void usage(const char *name);
/* the argument verify/normalise functions */
@ -118,41 +101,37 @@ int permission_arg(struct arg *a);
char yes_no_prompt(const char *prompt, ...);
/* we use the enums to access the switches */
static inline int arg_count(int a) {
return the_args[a].count;
static inline int arg_count(struct cmd_context *cmd, int a) {
return cmd->args[a].count;
}
static inline char *arg_value(int a) {
return the_args[a].value;
static inline char *arg_value(struct cmd_context *cmd, int a) {
return cmd->args[a].value;
}
static inline char *arg_str_value(int a, char *def)
static inline char *arg_str_value(struct cmd_context *cmd, int a, char *def)
{
return arg_count(a) ? the_args[a].value : def;
return arg_count(cmd, a) ? cmd->args[a].value : def;
}
static inline uint32_t arg_int_value(int a, uint32_t def)
static inline uint32_t arg_int_value(struct cmd_context *cmd, int a, uint32_t def)
{
return arg_count(a) ? the_args[a].i_value : def;
return arg_count(cmd, a) ? cmd->args[a].i_value : def;
}
static inline sign_t arg_sign_value(int a, sign_t def)
static inline sign_t arg_sign_value(struct cmd_context *cmd, int a, sign_t def)
{
return arg_count(a) ? the_args[a].sign : def;
return arg_count(cmd, a) ? cmd->args[a].sign : def;
}
static inline int arg_count_increment(int a)
static inline int arg_count_increment(struct cmd_context *cmd, int a)
{
return the_args[a].count++;
return cmd->args[a].count++;
}
static inline const char *command_name(void)
static inline const char *command_name(struct cmd_context *cmd)
{
return the_command->name;
return cmd->command->name;
}
extern struct format_instance *fid;
extern int lvdisplay_single(struct logical_volume *lv);
#endif

14
tools/vgcfgbackup.c
View File

@ -13,7 +13,7 @@ static int _backup_to_file(const char *file, struct volume_group *vg)
int r;
struct format_instance *tf;
if (!(tf = text_format_create(vg->cmd, file, the_um,
if (!(tf = text_format_create(vg->cmd, file, vg->cmd->um,
vg->cmd->cmd_line))) {
log_error("Couldn't create backup object.");
return 0;
@ -26,18 +26,18 @@ static int _backup_to_file(const char *file, struct volume_group *vg)
return r;
}
static int vg_backup_single(const char *vg_name)
static int vg_backup_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}
if (arg_count(file_ARG)) {
_backup_to_file(arg_value(file_ARG), vg);
if (arg_count(cmd,file_ARG)) {
_backup_to_file(arg_value(cmd,file_ARG), vg);
} else {
/* just use the normal backup code */
@ -52,8 +52,8 @@ static int vg_backup_single(const char *vg_name)
return 0;
}
int vgcfgbackup(int argc, char **argv)
int vgcfgbackup(struct cmd_context *cmd, int argc, char **argv)
{
return process_each_vg(argc, argv, LCK_READ, &vg_backup_single);
return process_each_vg(cmd, argc, argv, LCK_READ, &vg_backup_single);
}

15
tools/vgcfgrestore.c
View File

@ -6,9 +6,7 @@
#include "tools.h"
#include <stdio.h>
int vgcfgrestore(int argc, char **argv)
int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
{
if (argc != 1) {
log_err("Please specify a *single* volume group to restore.");
@ -19,16 +17,17 @@ int vgcfgrestore(int argc, char **argv)
* FIXME: overloading the -l arg for now to display a
* list of archive files for a particular vg
*/
if (arg_count(list_ARG)) {
if (!archive_display(argv[0]))
if (arg_count(cmd,list_ARG)) {
if (!archive_display(cmd, argv[0]))
return ECMD_FAILED;
return 0;
}
if (!(arg_count(file_ARG) ?
backup_restore_from_file(argv[0], arg_str_value(file_ARG, "")) :
backup_restore(argv[0]))) {
if (!(arg_count(cmd,file_ARG) ?
backup_restore_from_file(cmd, argv[0],
arg_str_value(cmd,file_ARG, "")) :
backup_restore(cmd, argv[0]))) {
log_err("Restore failed.");
return ECMD_FAILED;
}

58
tools/vgchange.c
View File

@ -20,46 +20,46 @@
#include "tools.h"
static int vgchange_single(const char *vg_name);
void vgchange_available(struct volume_group *vg);
void vgchange_resizeable(struct volume_group *vg);
void vgchange_logicalvolume(struct volume_group *vg);
static int vgchange_single(struct cmd_context *cmd, const char *vg_name);
void vgchange_available(struct cmd_context *cmd, struct volume_group *vg);
void vgchange_resizeable(struct cmd_context *cmd, struct volume_group *vg);
void vgchange_logicalvolume(struct cmd_context *cmd, struct volume_group *vg);
int vgchange(int argc, char **argv)
int vgchange(struct cmd_context *cmd, int argc, char **argv)
{
if (!(arg_count(available_ARG) + arg_count(logicalvolume_ARG) +
arg_count(resizeable_ARG))) {
if (!(arg_count(cmd,available_ARG) + arg_count(cmd,logicalvolume_ARG) +
arg_count(cmd,resizeable_ARG))) {
log_error("One of -a, -l or -x options required");
return EINVALID_CMD_LINE;
}
if (arg_count(available_ARG) + arg_count(logicalvolume_ARG) +
arg_count(resizeable_ARG) > 1) {
if (arg_count(cmd,available_ARG) + arg_count(cmd,logicalvolume_ARG) +
arg_count(cmd,resizeable_ARG) > 1) {
log_error("Only one of -a, -l or -x options allowed");
return EINVALID_CMD_LINE;
}
if (arg_count(available_ARG) == 1 && arg_count(autobackup_ARG)) {
if (arg_count(cmd,available_ARG) == 1 && arg_count(cmd,autobackup_ARG)) {
log_error("-A option not necessary with -a option");
return EINVALID_CMD_LINE;
}
return process_each_vg(argc, argv,
(arg_count(available_ARG)) ?
return process_each_vg(cmd, argc, argv,
(arg_count(cmd,available_ARG)) ?
LCK_READ : LCK_WRITE,
&vgchange_single);
}
static int vgchange_single(const char *vg_name)
static int vgchange_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Unable to find volume group \"%s\"", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE) && !arg_count(available_ARG)) {
if (!(vg->status & LVM_WRITE) && !arg_count(cmd,available_ARG)) {
log_error("Volume group \"%s\" is read-only", vg->name);
return ECMD_FAILED;
}
@ -69,22 +69,22 @@ static int vgchange_single(const char *vg_name)
return ECMD_FAILED;
}
if (arg_count(available_ARG))
vgchange_available(vg);
if (arg_count(cmd,available_ARG))
vgchange_available(cmd, vg);
if (arg_count(resizeable_ARG))
vgchange_resizeable(vg);
if (arg_count(cmd,resizeable_ARG))
vgchange_resizeable(cmd, vg);
if (arg_count(logicalvolume_ARG))
vgchange_logicalvolume(vg);
if (arg_count(cmd,logicalvolume_ARG))
vgchange_logicalvolume(cmd, vg);
return 0;
}
void vgchange_available(struct volume_group *vg)
void vgchange_available(struct cmd_context *cmd, struct volume_group *vg)
{
int lv_open, lv_active;
int available = !strcmp(arg_str_value(available_ARG, "n"), "y");
int available = !strcmp(arg_str_value(cmd,available_ARG, "n"), "y");
/* FIXME: Force argument to deactivate them? */
if (!available && (lv_open = lvs_in_vg_opened(vg))) {
@ -110,9 +110,9 @@ void vgchange_available(struct volume_group *vg)
return;
}
void vgchange_resizeable(struct volume_group *vg)
void vgchange_resizeable(struct cmd_context *cmd, struct volume_group *vg)
{
int resizeable = !strcmp(arg_str_value(resizeable_ARG, "n"), "y");
int resizeable = !strcmp(arg_str_value(cmd,resizeable_ARG, "n"), "y");
if (resizeable && (vg->status & RESIZEABLE_VG)) {
log_error("Volume group \"%s\" is already resizeable", vg->name);
@ -133,7 +133,7 @@ void vgchange_resizeable(struct volume_group *vg)
else
vg->status &= ~RESIZEABLE_VG;
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
return;
backup(vg);
@ -143,9 +143,9 @@ void vgchange_resizeable(struct volume_group *vg)
return;
}
void vgchange_logicalvolume(struct volume_group *vg)
void vgchange_logicalvolume(struct cmd_context *cmd, struct volume_group *vg)
{
int max_lv = arg_int_value(logicalvolume_ARG, 0);
int max_lv = arg_int_value(cmd,logicalvolume_ARG, 0);
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group \"%s\" must be resizeable "
@ -182,7 +182,7 @@ void vgchange_logicalvolume(struct volume_group *vg)
vg->max_lv = max_lv;
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
return;
backup(vg);

10
tools/vgck.c
View File

@ -20,20 +20,20 @@
#include "tools.h"
static int vgck_single(const char *vg_name);
static int vgck_single(struct cmd_context *cmd, const char *vg_name);
int vgck(int argc, char **argv)
int vgck(struct cmd_context *cmd, int argc, char **argv)
{
return process_each_vg(argc, argv, LCK_READ, &vgck_single);
return process_each_vg(cmd, argc, argv, LCK_READ, &vgck_single);
}
static int vgck_single(const char *vg_name)
static int vgck_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}

18
tools/vgcreate.c
View File

@ -26,7 +26,7 @@
#define DEFAULT_EXTENT 4096 /* In KB */
int vgcreate(int argc, char **argv)
int vgcreate(struct cmd_context *cmd, int argc, char **argv)
{
int max_lv, max_pv;
uint32_t extent_size;
@ -46,11 +46,11 @@ int vgcreate(int argc, char **argv)
}
vg_name = argv[0];
max_lv = arg_int_value(maxlogicalvolumes_ARG, DEFAULT_LV);
max_pv = arg_int_value(maxphysicalvolumes_ARG, DEFAULT_PV);
max_lv = arg_int_value(cmd,maxlogicalvolumes_ARG, DEFAULT_LV);
max_pv = arg_int_value(cmd,maxphysicalvolumes_ARG, DEFAULT_PV);
/* Units of 512-byte sectors */
extent_size = arg_int_value(physicalextentsize_ARG, DEFAULT_EXTENT) * 2;
extent_size = arg_int_value(cmd,physicalextentsize_ARG, DEFAULT_EXTENT) * 2;
if (max_lv < 1) {
log_error("maxlogicalvolumes too low");
@ -63,10 +63,10 @@ int vgcreate(int argc, char **argv)
}
/* Strip dev_dir if present */
if (!strncmp(vg_name, fid->cmd->dev_dir, strlen(fid->cmd->dev_dir)))
vg_name += strlen(fid->cmd->dev_dir);
if (!strncmp(vg_name, cmd->dev_dir, strlen(cmd->dev_dir)))
vg_name += strlen(cmd->dev_dir);
snprintf(vg_path, PATH_MAX, "%s%s", fid->cmd->dev_dir, vg_name);
snprintf(vg_path, PATH_MAX, "%s%s", cmd->dev_dir, vg_name);
if (path_exists(vg_path)) {
log_error("%s: already exists in filesystem", vg_path);
return ECMD_FAILED;
@ -79,7 +79,7 @@ int vgcreate(int argc, char **argv)
}
/* Create the new VG */
if (!(vg = vg_create(fid, vg_name, extent_size, max_pv, max_lv,
if (!(vg = vg_create(cmd->fid, vg_name, extent_size, max_pv, max_lv,
argc - 1, argv + 1)))
return ECMD_FAILED;
@ -109,7 +109,7 @@ int vgcreate(int argc, char **argv)
}
/* Store VG on disk(s) */
if (!fid->ops->vg_write(fid, vg)) {
if (!cmd->fid->ops->vg_write(cmd->fid, vg)) {
lock_vol(vg_name, LCK_VG | LCK_NONE);
lock_vol("", LCK_VG | LCK_NONE);
return ECMD_FAILED;

28
tools/vgdisplay.c
View File

@ -20,16 +20,16 @@
#include "tools.h"
static int vgdisplay_single(const char *vg_name);
static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name);
int vgdisplay(int argc, char **argv)
int vgdisplay(struct cmd_context *cmd, int argc, char **argv)
{
if (arg_count(colon_ARG) && arg_count(short_ARG)) {
if (arg_count(cmd,colon_ARG) && arg_count(cmd,short_ARG)) {
log_error("Option -c is not allowed with option -s");
return EINVALID_CMD_LINE;
}
if (argc && arg_count(activevolumegroups_ARG)) {
if (argc && arg_count(cmd,activevolumegroups_ARG)) {
log_error("Option -A is not allowed with volume group names");
return EINVALID_CMD_LINE;
}
@ -45,14 +45,14 @@ int vgdisplay(int argc, char **argv)
}
**********/
process_each_vg(argc, argv, LCK_READ, &vgdisplay_single);
process_each_vg(cmd, argc, argv, LCK_READ, &vgdisplay_single);
/******** FIXME Need to count number processed
Add this to process_each_vg if arg_count(activevolumegroups_ARG) ?
Add this to process_each_vg if arg_count(cmd,activevolumegroups_ARG) ?
if (opt == argc) {
log_print("no ");
if (arg_count(activevolumegroups_ARG))
if (arg_count(cmd,activevolumegroups_ARG))
printf("active ");
printf("volume groups found\n\n");
return LVM_E_NO_VG;
@ -62,7 +62,7 @@ int vgdisplay(int argc, char **argv)
return 0;
}
static int vgdisplay_single(const char *vg_name)
static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
@ -70,7 +70,7 @@ static int vgdisplay_single(const char *vg_name)
/* FIXME Do the active check here if activevolumegroups_ARG ? */
log_very_verbose("Finding volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
@ -78,25 +78,25 @@ static int vgdisplay_single(const char *vg_name)
if (vg->status & EXPORTED_VG)
log_print("WARNING: volume group \"%s\" is exported", vg_name);
if (arg_count(colon_ARG)) {
if (arg_count(cmd,colon_ARG)) {
vgdisplay_colons(vg);
return 0;
}
if (arg_count(short_ARG)) {
if (arg_count(cmd,short_ARG)) {
vgdisplay_short(vg);
return 0;
}
vgdisplay_full(vg); /* was vg_show */
if (arg_count(verbose_ARG)) {
if (arg_count(cmd,verbose_ARG)) {
vgdisplay_extents(vg);
process_each_lv_in_vg(vg, &lvdisplay_full);
process_each_lv_in_vg(cmd, vg, &lvdisplay_full);
log_print("--- Physical volumes ---");
process_each_pv_in_vg(vg, &pvdisplay_short);
process_each_pv_in_vg(cmd, vg, &pvdisplay_short);
}
return 0;

16
tools/vgexport.c
View File

@ -20,28 +20,28 @@
#include "tools.h"
static int vgexport_single(const char *vg_name);
static int vgexport_single(struct cmd_context *cmd, const char *vg_name);
int vgexport(int argc, char **argv)
int vgexport(struct cmd_context *cmd, int argc, char **argv)
{
if (!argc && !arg_count(all_ARG)) {
if (!argc && !arg_count(cmd,all_ARG)) {
log_error("Please supply volume groups or use -a for all.");
return ECMD_FAILED;
}
if (argc && arg_count(all_ARG)) {
if (argc && arg_count(cmd,all_ARG)) {
log_error("No arguments permitted when using -a for all.");
return ECMD_FAILED;
}
return process_each_vg(argc, argv, LCK_READ, &vgexport_single);
return process_each_vg(cmd, argc, argv, LCK_READ, &vgexport_single);
}
static int vgexport_single(const char *vg_name)
static int vgexport_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Unable to find volume group \"%s\"", vg_name);
goto error;
}
@ -67,7 +67,7 @@ static int vgexport_single(const char *vg_name)
vg->status |= EXPORTED_VG;
if (!fid->ops->vg_write(fid,vg))
if (!cmd->fid->ops->vg_write(cmd->fid,vg))
goto error;
backup(vg);

8
tools/vgextend.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int vgextend(int argc, char **argv)
int vgextend(struct cmd_context *cmd, int argc, char **argv)
{
char *vg_name;
struct volume_group *vg = NULL;
@ -52,7 +52,7 @@ int vgextend(int argc, char **argv)
goto error;
}
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" not found.", vg_name);
goto error;
}
@ -83,7 +83,7 @@ int vgextend(int argc, char **argv)
goto error;
/* extend vg */
if (!vg_extend(fid, vg, argc, argv))
if (!vg_extend(cmd->fid, vg, argc, argv))
goto error;
/* ret > 0 */
@ -91,7 +91,7 @@ int vgextend(int argc, char **argv)
"physical volumes", vg_name, argc);
/* store vg on disk(s) */
if (!fid->ops->vg_write(fid, vg))
if (!cmd->fid->ops->vg_write(cmd->fid, vg))
goto error;
backup(vg);

16
tools/vgimport.c
View File

@ -20,28 +20,28 @@
#include "tools.h"
static int vgimport_single(const char *vg_name);
static int vgimport_single(struct cmd_context *cmd, const char *vg_name);
int vgimport(int argc, char **argv)
int vgimport(struct cmd_context *cmd, int argc, char **argv)
{
if (!argc && !arg_count(all_ARG)) {
if (!argc && !arg_count(cmd,all_ARG)) {
log_error("Please supply volume groups or use -a for all.");
return ECMD_FAILED;
}
if (argc && arg_count(all_ARG)) {
if (argc && arg_count(cmd,all_ARG)) {
log_error("No arguments permitted when using -a for all.");
return ECMD_FAILED;
}
return process_each_vg(argc, argv, LCK_WRITE, &vgimport_single);
return process_each_vg(cmd, argc, argv, LCK_WRITE, &vgimport_single);
}
static int vgimport_single(const char *vg_name)
static int vgimport_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Unable to find exported volume group \"%s\"",
vg_name);
goto error;
@ -62,7 +62,7 @@ static int vgimport_single(const char *vg_name)
vg->status &= ~EXPORTED_VG;
if (!fid->ops->vg_write(fid,vg))
if (!cmd->fid->ops->vg_write(cmd->fid,vg))
goto error;
backup(vg);

16
tools/vgmerge.c
View File

@ -20,9 +20,9 @@
#include "tools.h"
int vgmerge_single(const char *vg_name_to, const char *vg_name_from);
int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char *vg_name_from);
int vgmerge(int argc, char **argv)
int vgmerge(struct cmd_context *cmd, int argc, char **argv)
{
char *vg_name_to;
int opt = 0;
@ -38,7 +38,7 @@ int vgmerge(int argc, char **argv)
argv++;
for (; opt < argc; opt++) {
ret = vgmerge_single(vg_name_to, argv[opt]);
ret = vgmerge_single(cmd, vg_name_to, argv[opt]);
if (ret > ret_max)
ret_max = ret;
}
@ -46,7 +46,7 @@ int vgmerge(int argc, char **argv)
return ret_max;
}
int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char *vg_name_from)
{
struct volume_group *vg_to, *vg_from;
struct list *lvh1, *lvh2;
@ -63,7 +63,7 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
return ECMD_FAILED;
}
if (!(vg_to = fid->ops->vg_read(fid, vg_name_to))) {
if (!(vg_to = cmd->fid->ops->vg_read(cmd->fid, vg_name_to))) {
log_error("Volume group \"%s\" doesn't exist", vg_name_to);
lock_vol(vg_name_to, LCK_VG | LCK_NONE);
return ECMD_FAILED;
@ -88,7 +88,7 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
return ECMD_FAILED;
}
if (!(vg_from = fid->ops->vg_read(fid, vg_name_from))) {
if (!(vg_from = cmd->fid->ops->vg_read(cmd->fid, vg_name_from))) {
log_error("Volume group \"%s\" doesn't exist", vg_name_from);
goto error;
}
@ -164,7 +164,7 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
list_add(&vg_to->pvs, pvh);
pv = list_item(pvh, struct pv_list)->pv;
pv->vg_name = pool_strdup(fid->cmd->mem, vg_to->name);
pv->vg_name = pool_strdup(cmd->mem, vg_to->name);
}
vg_to->pv_count += vg_from->pv_count;
@ -181,7 +181,7 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
/* store it on disks */
log_verbose("Writing out updated volume group");
if (!(fid->ops->vg_write(fid, vg_to))) {
if (!(cmd->fid->ops->vg_write(cmd->fid, vg_to))) {
goto error;
}

18
tools/vgreduce.c
View File

@ -20,9 +20,9 @@
#include "tools.h"
static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv);
static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv);
int vgreduce(int argc, char **argv)
int vgreduce(struct cmd_context *cmd, int argc, char **argv)
{
struct volume_group *vg;
char *vg_name;
@ -34,12 +34,12 @@ int vgreduce(int argc, char **argv)
return EINVALID_CMD_LINE;
}
if (argc == 1 && !arg_count(all_ARG)) {
if (argc == 1 && !arg_count(cmd,all_ARG)) {
log_error("Please enter physical volume paths or option -a");
return EINVALID_CMD_LINE;
}
if (argc > 1 && arg_count(all_ARG)) {
if (argc > 1 && arg_count(cmd,all_ARG)) {
log_error("Option -a and physical volume paths mutually "
"exclusive");
return EINVALID_CMD_LINE;
@ -55,7 +55,7 @@ int vgreduce(int argc, char **argv)
return ECMD_FAILED;
}
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist", vg_name);
lock_vol(vg_name, LCK_VG | LCK_NONE);
return ECMD_FAILED;
@ -81,7 +81,7 @@ int vgreduce(int argc, char **argv)
/* FIXME: Pass private structure through to all these functions */
/* and update in batch here? */
ret = process_each_pv(argc, argv, vg, vgreduce_single);
ret = process_each_pv(cmd, argc, argv, vg, vgreduce_single);
lock_vol(vg_name, LCK_VG | LCK_NONE);
@ -105,7 +105,7 @@ int vgreduce(int argc, char **argv)
}
/* Or take pv_name instead? */
static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv)
{
struct pv_list *pvl;
const char *name = dev_name(pv->dev);
@ -142,14 +142,14 @@ static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
vg->free_count -= pv->pe_count - pv->pe_allocated;
vg->extent_count -= pv->pe_count;
if (!(fid->ops->vg_write(fid, vg))) {
if (!(cmd->fid->ops->vg_write(cmd->fid, vg))) {
log_error("Removal of physical volume \"%s\" from "
"\"%s\" failed",
name, vg->name);
return ECMD_FAILED;
}
if (!fid->ops->pv_write(fid, pv)) {
if (!cmd->fid->ops->pv_write(cmd->fid, pv)) {
log_error("Failed to clear metadata from physical "
"volume \"%s\" "
"after removal from \"%s\"", name, vg->name);

12
tools/vgremove.c
View File

@ -20,9 +20,9 @@
#include "tools.h"
static int vgremove_single(const char *vg_name);
static int vgremove_single(struct cmd_context *cmd, const char *vg_name);
int vgremove(int argc, char **argv)
int vgremove(struct cmd_context *cmd, int argc, char **argv)
{
int ret;
@ -31,7 +31,7 @@ int vgremove(int argc, char **argv)
return ECMD_FAILED;
}
ret = process_each_vg(argc, argv, LCK_WRITE | LCK_NONBLOCK,
ret = process_each_vg(cmd, argc, argv, LCK_WRITE | LCK_NONBLOCK,
&vgremove_single);
lock_vol("", LCK_VG | LCK_NONE);
@ -39,7 +39,7 @@ int vgremove(int argc, char **argv)
return ret;
}
static int vgremove_single(const char *vg_name)
static int vgremove_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
struct physical_volume *pv;
@ -47,7 +47,7 @@ static int vgremove_single(const char *vg_name)
int ret = 0;
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
@ -87,7 +87,7 @@ static int vgremove_single(const char *vg_name)
"volume group \"%s\"",
dev_name(pv->dev), vg_name);
*pv->vg_name = '\0';
if (!(fid->ops->pv_write(fid, pv))) {
if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) {
log_error("Failed to remove physical volume \"%s\""
" from volume group \"%s\"",
dev_name(pv->dev), vg_name);

12
tools/vgrename.c
View File

@ -20,7 +20,7 @@
#include "tools.h"
int vgrename(int argc, char **argv)
int vgrename(struct cmd_context *cmd, int argc, char **argv)
{
char *dev_dir;
int length;
@ -40,7 +40,7 @@ int vgrename(int argc, char **argv)
vg_name_old = argv[0];
vg_name_new = argv[1];
dev_dir = fid->cmd->dev_dir;
dev_dir = cmd->dev_dir;
length = strlen(dev_dir);
/* If present, strip dev_dir */
@ -74,7 +74,7 @@ int vgrename(int argc, char **argv)
return ECMD_FAILED;
}
if (!(vg_old = fid->ops->vg_read(fid, vg_name_old))) {
if (!(vg_old = cmd->fid->ops->vg_read(cmd->fid, vg_name_old))) {
log_error("Volume group \"%s\" doesn't exist", vg_name_old);
lock_vol(vg_name_old, LCK_VG | LCK_NONE);
return ECMD_FAILED;
@ -112,7 +112,7 @@ int vgrename(int argc, char **argv)
return ECMD_FAILED;
}
if ((vg_new = fid->ops->vg_read(fid, vg_name_new))) {
if ((vg_new = cmd->fid->ops->vg_read(cmd->fid, vg_name_new))) {
log_error("New volume group \"%s\" already exists",
vg_name_new);
goto error;
@ -150,7 +150,7 @@ int vgrename(int argc, char **argv)
/* store it on disks */
log_verbose("Writing out updated volume group");
if (!(fid->ops->vg_write(fid, vg_old))) {
if (!(cmd->fid->ops->vg_write(cmd->fid, vg_old))) {
goto error;
}
@ -182,7 +182,7 @@ char *lv_change_vgname(char *vg_name, char *lv_name)
** check if lv_name includes a path
if ((lv_name_ptr = strrchr(lv_name, '/'))) {
lv_name_ptr++;
sprintf(lv_name_buf, "%s%s/%s%c", fid->cmd->dev_dir, vg_name,
sprintf(lv_name_buf, "%s%s/%s%c", cmd->dev_dir, vg_name,
lv_name_ptr, 0);}
else
strncpy(lv_name_buf, lv_name, NAME_LEN - 1); return lv_name_buf;}

12
tools/vgscan.c
View File

@ -20,9 +20,9 @@
#include "tools.h"
static int vgscan_single(const char *vg_name);
static int vgscan_single(struct cmd_context *cmd, const char *vg_name);
int vgscan(int argc, char **argv)
int vgscan(struct cmd_context *cmd, int argc, char **argv)
{
if (argc) {
log_error("Too many parameters on command line");
@ -30,23 +30,23 @@ int vgscan(int argc, char **argv)
}
log_verbose("Wiping cache of LVM-capable devices");
persistent_filter_wipe(fid->cmd->filter);
persistent_filter_wipe(cmd->filter);
log_verbose("Wiping internal cache of PVs in VGs");
vgcache_destroy();
log_print("Reading all physical volumes. This may take a while...");
return process_each_vg(argc, argv, LCK_READ, &vgscan_single);
return process_each_vg(cmd, argc, argv, LCK_READ, &vgscan_single);
}
static int vgscan_single(const char *vg_name)
static int vgscan_single(struct cmd_context *cmd, const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}