mirror of
git://sourceware.org/git/lvm2.git
synced 2025-11-18 12:23:51 +03:00
f4e56b2829
This patch makes the keyword combinations found in "lv_layout" and
"lv_role" much more understandable - there were some ambiguities
for some of the combinations which lead to confusion before.
Now, the scheme used is:
LAYOUTS ("how the LV is laid out"):
===================================
[linear] (all segments have number of stripes = 1)
[striped] (all segments have number of stripes > 1)
[linear,striped] (mixed linear and striped)
raid (raid layout always reported together with raid level, raid layout == image + metadata LVs underneath that make up raid LV)
[raid,raid1]
[raid,raid10]
[raid,raid4]
[raid,raid5] (exact sublayout not specified during creation - default one used - raid5_ls)
[raid,raid5,raid5_ls]
[raid,raid5,raid6_rs]
[raid,raid5,raid5_la]
[raid,raid5,raid5_ra]
[raid6,raid] (exact sublayout not specified during creation - default one used - raid6_zr)
[raid,raid6,raid6_zr]
[raid,raid6,raid6_nc]
[raid,raid6,raid6_ns]
[mirror] (mirror layout == log + image LVs underneath that make up mirror LV)
thin (thin layout always reported together with sublayout)
[thin,sparse] (thin layout == allocated out of thin pool)
[thin,pool] (thin pool layout == data + metadata volumes underneath that make up thin pool LV, not supposed to be used for direct use!!!)
[cache] (cache layout == allocated out of cache pool in conjunction with cache origin)
[cache,pool] (cache pool layout == data + metadata volumes underneath that make up cache pool LV, not supposed to be used for direct use!!!)
[virtual] (virtual layout == not hitting disk underneath, currently this layout denotes only 'zero' device used for origin,thickorigin role)
[unknown] (either error state or missing recognition for such layout)
ROLES ("what's the purpose or use of the LV - what is its role"):
=================================================================
- each LV has either of these two roles at least: [public] (public LV that users may use freely to write their data to)
[public] (public LV that users may use freely to write their data to)
[private] (private LV that LVM maintains; not supposed to be directly used by user to write his data to)
- and then some special-purpose roles in addition to that:
[origin,thickorigin] (origin for thick-style snapshot; "thick" as opposed to "thin")
[origin,multithickorigin] (there are more than 2 thick-style snapshots for this origin)
[origin,thinorigin] (origin for thin snapshot)
[origin,multithinorigin] (there are more than 2 thin snapshots for this origin)
[origin,extorigin] (external origin for thin snapshot)
[origin,multiextoriginl (there are more than 2 thin snapshots using this external origin)
[origin,cacheorigin] (cache origin)
[snapshot,thicksnapshot] (thick-style snapshot; "thick" as opposed to "thin")
[snapshot,thinsnapshot] (thin-style snapshot)
[raid,metadata] (raid metadata LV)
[raid,image] (raid image LV)
[mirror,image] (mirror image LV)
[mirror,log] (mirror log LV)
[pvmove] (pvmove LV)
[thin,pool,data] (thin pool data LV)
[thin,pool,metadata] (thin pool metadata LV)
[cache,pool,data] (cache pool data LV)
[cache,pool,metadata] (cache pool metadata LV)
[pool,spare] (pool spare LV - common role of LV that makes it used for both thin and cache repairs)
146 lines
3.1 KiB
C
146 lines
3.1 KiB
C
/*
|
|
* Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
|
|
* Copyright (C) 2004-2012 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This file is part of LVM2.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU Lesser General Public License v.2.1.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "lib.h"
|
|
#include "str_list.h"
|
|
|
|
struct dm_list *str_list_create(struct dm_pool *mem)
|
|
{
|
|
struct dm_list *sl;
|
|
|
|
if (!(sl = dm_pool_alloc(mem, sizeof(struct dm_list)))) {
|
|
log_errno(ENOMEM, "str_list allocation failed");
|
|
return NULL;
|
|
}
|
|
|
|
dm_list_init(sl);
|
|
|
|
return sl;
|
|
}
|
|
|
|
static int _str_list_add_no_dup_check(struct dm_pool *mem, struct dm_list *sll, const char *str, int as_first)
|
|
{
|
|
struct dm_str_list *sln;
|
|
|
|
if (!str)
|
|
return_0;
|
|
|
|
if (!(sln = dm_pool_alloc(mem, sizeof(*sln))))
|
|
return_0;
|
|
|
|
sln->str = str;
|
|
if (as_first)
|
|
dm_list_add_h(sll, &sln->list);
|
|
else
|
|
dm_list_add(sll, &sln->list);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int str_list_add_no_dup_check(struct dm_pool *mem, struct dm_list *sll, const char *str)
|
|
{
|
|
return _str_list_add_no_dup_check(mem, sll, str, 0);
|
|
}
|
|
|
|
int str_list_add_h_no_dup_check(struct dm_pool *mem, struct dm_list *sll, const char *str)
|
|
{
|
|
return _str_list_add_no_dup_check(mem, sll, str, 1);
|
|
}
|
|
|
|
int str_list_add(struct dm_pool *mem, struct dm_list *sll, const char *str)
|
|
{
|
|
if (!str)
|
|
return_0;
|
|
|
|
/* Already in list? */
|
|
if (str_list_match_item(sll, str))
|
|
return 1;
|
|
|
|
return str_list_add_no_dup_check(mem, sll, str);
|
|
}
|
|
|
|
void str_list_del(struct dm_list *sll, const char *str)
|
|
{
|
|
struct dm_list *slh, *slht;
|
|
|
|
dm_list_iterate_safe(slh, slht, sll)
|
|
if (!strcmp(str, dm_list_item(slh, struct dm_str_list)->str))
|
|
dm_list_del(slh);
|
|
}
|
|
|
|
int str_list_dup(struct dm_pool *mem, struct dm_list *sllnew,
|
|
const struct dm_list *sllold)
|
|
{
|
|
struct dm_str_list *sl;
|
|
|
|
dm_list_init(sllnew);
|
|
|
|
dm_list_iterate_items(sl, sllold) {
|
|
if (!str_list_add(mem, sllnew, dm_pool_strdup(mem, sl->str)))
|
|
return_0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Is item on list?
|
|
*/
|
|
int str_list_match_item(const struct dm_list *sll, const char *str)
|
|
{
|
|
struct dm_str_list *sl;
|
|
|
|
dm_list_iterate_items(sl, sll)
|
|
if (!strcmp(str, sl->str))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Is at least one item on both lists?
|
|
* If tag_matched is non-NULL, it is set to the tag that matched.
|
|
*/
|
|
int str_list_match_list(const struct dm_list *sll, const struct dm_list *sll2, const char **tag_matched)
|
|
{
|
|
struct dm_str_list *sl;
|
|
|
|
dm_list_iterate_items(sl, sll)
|
|
if (str_list_match_item(sll2, sl->str)) {
|
|
if (tag_matched)
|
|
*tag_matched = sl->str;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Do both lists contain the same set of items?
|
|
*/
|
|
int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2)
|
|
{
|
|
struct dm_str_list *sl;
|
|
|
|
if (dm_list_size(sll) != dm_list_size(sll2))
|
|
return 0;
|
|
|
|
dm_list_iterate_items(sl, sll)
|
|
if (!str_list_match_item(sll2, sl->str))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|