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

lvcreate

Browse Source
This commit is contained in:
Alasdair Kergon 2001-11-06 19:02:26 +00:00
parent c84cc3847c
commit 642c2e964b
11 changed files with 329 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/activate/activate.c
View File

@ -54,6 +54,8 @@ static int _emit_target(struct dm_task *dmt, struct logical_volume *lv,
return 1;
}
/* FIXME: Always display error msg */
/* FIXME: Create dev entry if required */
int lv_activate(struct logical_volume *lv)
{
int r = 0;

39
lib/metadata/lv_manip.c
View File

@ -48,7 +48,7 @@ static int _alloc_striped(struct logical_volume *lv,
struct list *pvms, uint32_t allocated)
{
/* FIXME: finish */
log_err("striped allocation not implemented yet.");
log_error("Striped allocation not implemented yet in LVM2.");
return 0;
}
@ -84,8 +84,9 @@ static int _alloc_contiguous(struct logical_volume *lv,
}
if (allocated != lv->le_count) {
log_err("insufficient free extents to "
"allocate logical volume");
log_error("Insufficient free extents to "
"allocate logical volume %s: %u required",
lv->name, lv->le_count);
return 0;
}
@ -119,8 +120,9 @@ static int _alloc_simple(struct logical_volume *lv,
}
if (allocated != lv->le_count) {
log_err("insufficient free extents to "
"allocate logical volume");
log_error("Insufficient free logical extents to "
"allocate logical volume %s: %u required",
lv->name, lv->le_count);
return 0;
}
@ -147,7 +149,6 @@ static int _allocate(struct volume_group *vg, struct logical_volume *lv,
* the pv's.
*/
if (!(pvms = create_pv_maps(scratch, vg, acceptable_pvs))) {
log_err("couldn't create extent mappings");
goto out;
}
@ -183,19 +184,21 @@ struct logical_volume *lv_create(struct io_space *ios,
struct logical_volume *lv;
if (!extents) {
log_err("Attempt to create an lv with zero extents");
log_error("Unable to create logical volume %s with no extents",
name);
return NULL;
}
if (vg->free_count < extents) {
log_err("Insufficient free extents in volume group");
goto bad;
log_error("Insufficient free extents (%u) in volume group %s: "
"%u required", vg->free_count, vg->name, extents);
return NULL;
}
if (vg->max_lv == vg->lv_count) {
log_err("Maximum logical volumes already reached "
"for this volume group.");
goto bad;
log_error("Maximum number of logical volumes (%u) reached "
"in volume group %s", vg->max_lv, vg->name);
return NULL;
}
if (!(ll = pool_zalloc(ios->mem, sizeof(*ll)))) {
@ -203,6 +206,8 @@ struct logical_volume *lv_create(struct io_space *ios,
return NULL;
}
list_init(&ll->list);
lv = &ll->lv;
strcpy(lv->id.uuid, "");
@ -229,7 +234,7 @@ struct logical_volume *lv_create(struct io_space *ios,
goto bad;
}
list_add(&ll->list, &vg->lvs);
list_add(&vg->lvs, &ll->list);
return lv;
bad:
@ -243,14 +248,14 @@ int lv_reduce(struct io_space *ios,
struct logical_volume *lv, uint32_t extents)
{
if (extents % lv->stripes) {
log_err("For a striped volume you must reduce by a "
"multiple of the number of stripes");
log_error("For a striped volume you must reduce by a "
"multiple of the number of stripes");
return 0;
}
if (lv->le_count <= extents) {
log_err("Attempt to reduce by too many extents, "
"there would be nothing left of the logical volume.");
log_error("Attempt to reduce by so many extents there would "
"be nothing left of the logical volume.");
return 0;
}

4
lib/metadata/metadata.c
View File

@ -93,6 +93,8 @@ int _add_pv_to_vg(struct io_space *ios, struct volume_group *vg,
list_add(&vg->pvs, &pvl->list);
vg->pv_count++;
vg->extent_count += pv->pe_count;
vg->free_count += pv->pe_count;
return 1;
}
@ -114,7 +116,7 @@ int vg_extend(struct io_space *ios, struct volume_group *vg, int pv_count,
}
struct volume_group *vg_create(struct io_space *ios, const char *vg_name,
uint64_t extent_size, int max_pv, int max_lv,
uint32_t extent_size, int max_pv, int max_lv,
int pv_count, char **pv_names)
{
struct volume_group *vg;

17
lib/metadata/metadata.h
View File

@ -33,7 +33,7 @@
#define CLUSTERED 0x00000400 /* VG */
#define SHARED 0x00000800 /* VG */
#define ALLOC_STRICT 0x00001000 /* LV */
#define ALLOC_STRICT 0x00001000 /* LV */
#define ALLOC_CONTIGUOUS 0x00002000 /* LV */
#define SNAPSHOT 0x00004000 /* LV */
#define SNAPSHOT_ORG 0x00008000 /* LV */
@ -70,7 +70,7 @@ struct volume_group {
uint32_t status;
uint64_t extent_size;
uint32_t extent_size;
uint32_t extent_count;
uint32_t free_count;
@ -204,13 +204,13 @@ struct io_space {
* Utility functions
*/
struct volume_group *vg_create(struct io_space *ios, const char *name,
uint64_t extent_size, int max_pv, int max_lv,
uint32_t extent_size, int max_pv, int max_lv,
int pv_count, char **pv_names);
struct physical_volume *pv_create(struct io_space *ios, const char *name);
/*
* This will insert the new lv into the
* volume_group.
* Create a new LV within a given volume group.
*
*/
struct logical_volume *lv_create(struct io_space *ios,
const char *name,
@ -228,8 +228,9 @@ int lv_reduce(struct io_space *ios,
int lv_extend(struct io_space *ios, struct logical_volume *lv,
uint32_t extents, struct list *allocatable_pvs);
int vg_extend(struct io_space *ios, struct volume_group *vg, int pv_count,
char **pv_names);
char **pv_names);
@ -250,10 +251,6 @@ int pv_remove(struct volume_group *vg, struct physical_volume *pv);
struct physical_volume *pv_find(struct volume_group *vg,
const char *pv_name);
/* Add an LV to a given VG */
int lv_add(struct io_space *ios, struct volume_group *vg,
struct logical_volume *lv);
/* Remove an LV from a given VG */
int lv_remove(struct volume_group *vg, struct list *lvh);

10
lib/metadata/pv_map.c
View File

@ -97,6 +97,7 @@ static int _create_single_area(struct pool *mem, struct pv_map *pvm,
return 0;
}
list_init(&pvm->areas);
pva->start = b;
pva->count = e - b;
list_add(&pvm->areas, &pva->list);
@ -148,17 +149,19 @@ struct list *create_pv_maps(struct pool *mem, struct volume_group *vg,
list_init(maps);
if (!_create_maps(mem, pvs, maps)) {
log_err("couldn't create pv maps.");
log_error("Couldn't create physical volume maps in %s",
vg->name);
goto bad;
}
if (!_fill_bitsets(vg, maps)) {
log_err("couldn't fill extent allocation bitmaps.");
log_error("Couldn't fill extent allocation bitmaps in %s",
vg->name);
goto bad;
}
if (!_create_all_areas(mem, maps)) {
log_err("couldn't create area maps.");
log_error("Couldn't create area maps in %s", vg->name);
goto bad;
}
@ -168,3 +171,4 @@ struct list *create_pv_maps(struct pool *mem, struct volume_group *vg,
pool_free(mem, maps);
return NULL;
}

1
tools/Makefile.in
View File

@ -22,6 +22,7 @@ VPATH = @srcdir@
SOURCES=\
lvchange.c \
lvcreate.c \
lvm.c \
lvmchange.c \
lvremove.c \

266
tools/lvcreate.c Normal file
View File

@ -0,0 +1,266 @@
/*
* Copyright (C) 2001 Sistina Software
*
* This file is released under the GPL.
*
*/
#include "tools.h"
int lvcreate(int argc, char **argv)
{
int zero;
int size_rest = 0;
uint32_t read_ahead = 0;
int stripes = 1;
int stripesize = 0;
int opt = 0;
uint32_t status = 0;
uint32_t size = 0;
uint32_t extents = 0;
struct volume_group *vg;
struct logical_volume *lv;
struct list *lvh, *pvh, *pvl;
char *lv_name = NULL;
char *vg_name;
char *st;
if (arg_count(snapshot_ARG) || arg_count(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))) {
log_error("Invalid combination of arguments");
return EINVALID_CMD_LINE;
}
if (arg_count(size_ARG) + arg_count(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"))
status |= ALLOC_CONTIGUOUS;
zero = strcmp(arg_str_value(zero_ARG, "y"), "n");
if (arg_count(stripes_ARG)) {
log_print("Stripes not yet implemented in LVM2. Ignoring.");
stripes = arg_int_value(stripes_ARG, 1);
if (stripes == 1)
log_print("Redundant stripes argument: default is 1");
}
if (arg_count(stripesize_ARG))
stripesize = arg_int_value(stripesize_ARG, 0);
if (stripes == 1 && stripesize) {
log_print("Ignoring stripesize argument with single stripe");
stripesize = 0;
}
if (arg_count(permission_ARG))
status |= arg_int_value(permission_ARG, 0);
if (arg_count(readahead_ARG))
read_ahead = arg_int_value(readahead_ARG, 0);
if (arg_count(extents_ARG))
extents = arg_int_value(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(name_ARG))
lv_name = arg_value(name_ARG);
else {
log_error("LVM2 currently requires you to give a name "
"using -n");
return EINVALID_CMD_LINE;
}
/* If VG not on command line, try -n arg and then environment */
if (!argc) {
if (!(vg_name = extract_vgname(ios, lv_name))) {
log_error("Please provide a volume group name");
return EINVALID_CMD_LINE;
}
} else {
/* Ensure lv_name doesn't contain a different VG! */
if (strchr(lv_name, '/')) {
if (!(vg_name = extract_vgname(ios, lv_name)))
return EINVALID_CMD_LINE;
if (strcmp(vg_name, argv[0])) {
log_error("Inconsistent volume group names "
"given: %s and %s", vg_name, argv[0]);
return EINVALID_CMD_LINE;
}
}
vg_name = argv[0];
argv++;
argc--;
}
if ((st = strrchr(lv_name, '/')))
lv_name = st + 1;
/* does VG exist? */
log_verbose("Finding volume group %s", vg_name);
if (!(vg = ios->vg_read(ios, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & ACTIVE)) {
log_error("Volume group %s must be active before changing a "
"logical volume", vg_name);
return ECMD_FAILED;
}
if (lv_name && (lvh = find_lv_in_vg(vg, lv_name))) {
log_error("Logical volume %s already exists in volume group %s",
lv_name, vg_name);
return ECMD_FAILED;
}
if (argc) {
/* Build up list of PVs */
if (!(pvh = pool_alloc(ios->mem, sizeof (struct list)))) {
log_error("pvh list allocation failed");
return ECMD_FAILED;
}
list_init(pvh);
for (; opt < argc; opt++) {
if (!(pvl = find_pv_in_vg(vg, argv[opt]))) {
log_error("Physical Volume %s not found in "
"Volume Group %s", argv[opt],
vg->name);
return EINVALID_CMD_LINE;
}
if (list_item(pvl, struct pv_list)->pv.pe_count ==
list_item(pvl, struct pv_list)->pv.pe_allocated)
log_error("No free extents on physical volume"
" %s", argv[opt]);
list_add(pvh, pvl);
}
} else {
/* Use full list from VG */
pvh = &vg->pvs;
}
/********* FIXME Move default choice (0) into format1
log_print("Using default stripe size of %lu KB",
LVM_DEFAULT_STRIPE_SIZE);
***********/
if (argc && argc != stripes) {
log_error("Incorrect number of physical volumes on "
"command line for %d-way striping", stripes);
return EINVALID_CMD_LINE;
}
/******** FIXME Inside lv_create stripes
log_verbose("checking stripe count");
if (stripes < 1 || stripes > LVM_MAX_STRIPES) {
log_error("Invalid number of stripes: %d", stripes);
log_error("must be between %d and %d", 1, LVM_MAX_STRIPES);
return EINVALID_CMD_LINE;
}
log_verbose("checking stripe size");
if (stripesize > 0 && lv_check_stripesize(stripesize) < 0) {
log_error("invalid stripe size %d", stripesize);
return EINVALID_CMD_LINE;
}
*********/
stripesize *= 2;
/******** FIXME Stripes
log_verbose
("checking stripe size against volume group physical extent size");
if (stripesize > vg_core->pe_size) {
log_error
("setting stripe size %d KB to physical extent size %u KB",
stripesize / 2, vg_core->pe_size / 2);
stripesize = vg_core->pe_size;
}
**********/
if (size) {
/* No of 512-byte sectors */
extents = size * 2;
if (extents % vg->extent_size) {
char *s1;
extents += vg->extent_size - extents % vg->extent_size;
log_print("Rounding up size to full physical extent %s",
(s1 = display_size(extents / 2, SIZE_SHORT)));
dbg_free(s1);
}
extents /= vg->extent_size;
}
/******* FIXME Stripes
size_rest = size % (stripes * vg_core->pe_size);
if (size_rest != 0) {
log_print("rounding %d KB to stripe boundary size ",
size / 2);
size = size - size_rest + stripes * vg_core->pe_size;
printf("%d KB / %u PE\n", size / 2,
size / vg_core->pe_size);
}
*************/
log_verbose("Creating logical volume %s", lv_name);
if (!(lv = lv_create(ios, lv_name, status, stripes, stripesize,
extents, vg, pvh)))
return ECMD_FAILED;
if (arg_count(readahead_ARG)) {
log_verbose("Setting read ahead sectors");
lv->read_ahead = read_ahead;
}
/* store vg on disk(s) */
if (!ios->vg_write(ios, vg))
return ECMD_FAILED;
if (!lv_activate(lv))
return ECMD_FAILED;
if (zero) {
struct device *dev;
/* FIXME 2 blocks */
char buf[4096];
memset(buf, 0, sizeof (buf));
log_verbose("Zeroing start of logical volume %s", lv_name);
/* FIXME get dev = dev_cache_get(lv_name, ios->filter); */
/* FIXME Add fsync! */
if (!(dev_write(dev, 0, sizeof (buf), &buf) == sizeof (buf))) {
log_error("Initialisation of %s failed", dev_name(dev));
return ECMD_FAILED;
}
} else
log_print("WARNING: %s not zeroed", lv_name);
/******** FIXME backup
if ((ret = do_autobackup(vg_name, vg)))
return ret;
***********/
log_print("Logical volume %s created", lv_name);
return 0;
}

1
tools/stub.h
View File

@ -19,7 +19,6 @@
*/
int e2fsadm(int argc, char **argv) {return 1;}
int lvcreate(int argc, char **argv) {return 1;}
int lvdisplay(int argc, char **argv) {return 1;}
int lvextend(int argc, char **argv) {return 1;}
int lvmdiskscan(int argc, char **argv) {return 1;}

26
tools/toollib.c
View File

@ -168,10 +168,10 @@ int is_valid_chars(char *n)
char *extract_vgname(struct io_space *ios, char *lv_name)
{
char *vg_name = lv_name;
char *vg_path, *st;
char *st;
/* Path supplied? */
if (strchr(vg_name, '/')) {
if (vg_name && strchr(vg_name, '/')) {
/* Strip prefix (optional) */
if (!strncmp(vg_name, ios->prefix, strlen(ios->prefix)))
vg_name += strlen(ios->prefix);
@ -192,13 +192,24 @@ char *extract_vgname(struct io_space *ios, char *lv_name)
*strchr(vg_name, '/') = '\0';
return vg_name;
}
/* Take default VG from environment? */
vg_path = getenv("LVM_VG_NAME");
if (!vg_path) {
log_error("Path required for Logical Volume %s", lv_name);
if (!(vg_name = default_vgname(ios))) {
if (lv_name)
log_error("Path required for Logical Volume %s", lv_name);
return 0;
}
return vg_name;
}
char *default_vgname(struct io_space *ios)
{
char *vg_path;
/* Take default VG from environment? */
vg_path = getenv("LVM_VG_NAME");
if (!vg_path)
return 0;
/* Strip prefix (optional) */
if (!strncmp(vg_path, ios->prefix, strlen(ios->prefix)))
@ -211,6 +222,5 @@ char *extract_vgname(struct io_space *ios, char *lv_name)
}
return pool_strdup(ios->mem, vg_path);
}

1
tools/toollib.h
View File

@ -34,6 +34,7 @@ int process_each_pv(int argc, char **argv, struct volume_group *vg,
int is_valid_chars(char *n);
char *default_vgname(struct io_space *ios);
char *extract_vgname(struct io_space *ios, char *lv_name);
#endif

3
tools/vgcreate.c
View File

@ -14,7 +14,8 @@
int vgcreate(int argc, char **argv)
{
int max_lv, max_pv, extent_size;
int max_lv, max_pv;
uint32_t extent_size;
char *vg_name;
struct volume_group *vg;