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
4cdb178968
lvm2/lib/metadata/segtype.h

383 lines
18 KiB
C
Raw Normal View History

Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
/*
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
lvconvert: add segment type raid10_near Introducing this alias for "raid10", avoid allocating reshape space when converting between them. Resolves: rhbz1441347
2017-04-12 02:28:22 +03:00
* Copyright (C) 2004-2017 Red Hat, Inc. All rights reserved.
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
Fix inconsistent licence notices: executables are GPLv2; libraries LGPLv2.1.
2007-08-21 00:55:30 +04:00
* of the GNU Lesser General Public License v.2.1.
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
*
Fix inconsistent licence notices: executables are GPLv2; libraries LGPLv2.1.
2007-08-21 00:55:30 +04:00
* You should have received a copy of the GNU Lesser General Public License
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
* along with this program; if not, write to the Free Software Foundation,
doc: change fsf address Hmm rpmlint suggest fsf is using a different address these days, so lets keep it up-to-date
2016-01-21 13:49:46 +03:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
*/
#ifndef _SEGTYPES_H
#define _SEGTYPES_H
build: Don't generate symlinks in include/ dir As we start refactoring the code to break dependencies (see doc/refactoring.txt), I want us to use full paths in the includes (eg, #include "base/data-struct/list.h"). This makes it more obvious when we're breaking abstraction boundaries, eg, including a file in metadata/ from base/
2018-05-14 12:30:20 +03:00
#include "lib/metadata/metadata-exported.h"
Introduce percent_range_t and centralise snapshot full/mirror in-sync checks.
2009-10-01 04:35:29 +04:00
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct segtype_handler;
struct cmd_context;
Move the core of the lib/config/config.c functionality into libdevmapper, leaving behind the LVM-specific parts of the code (convenience wrappers that handle `struct device` and `struct cmd_context`, basically). A number of functions have been renamed (in addition to getting a dm_ prefix) -- namely, all of the config interface now has a dm_config_ prefix.
2011-08-30 18:55:15 +04:00
struct dm_config_tree;
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct lv_segment;
Add lv_activate_opts structure To avoid modification of 'read-only' volume group structure add a new structure to pass local data around the code for LV activation. As origin_only is one such flag - replace this parameter with new struct lv_activate_opts. More parameters might eventually become part of lv_activate_opts.
2011-06-17 18:14:19 +04:00
struct lv_activate_opts;
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct formatter;
Move the core of the lib/config/config.c functionality into libdevmapper, leaving behind the LVM-specific parts of the code (convenience wrappers that handle `struct device` and `struct cmd_context`, basically). A number of functions have been renamed (in addition to getting a dm_ prefix) -- namely, all of the config interface now has a dm_config_ prefix.
2011-08-30 18:55:15 +04:00
struct dm_config_node;
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct dev_manager;
/* Feature flags */
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_CAN_SPLIT (1ULL << 0)
#define SEG_AREAS_STRIPED (1ULL << 1)
#define SEG_AREAS_MIRRORED (1ULL << 2)
#define SEG_SNAPSHOT (1ULL << 3)
Remove lvm1 and pool disk formats There are likely more bits of code that can be removed, e.g. lvm1/pool-specific bits of code that were identified using FMT flags. The vgconvert command can likely be reduced further. The lvm1-specific config settings should probably have some other fields set for proper deprecation.
2018-04-28 00:22:46 +03:00
/* #define SEG_FORMAT1_SUPPORT (1ULL << 4) */
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_VIRTUAL (1ULL << 5)
#define SEG_CANNOT_BE_ZEROED (1ULL << 6)
#define SEG_MONITORED (1ULL << 7)
#define SEG_RAID (1ULL << 10)
#define SEG_THIN_POOL (1ULL << 11)
#define SEG_THIN_VOLUME (1ULL << 12)
#define SEG_CACHE (1ULL << 13)
#define SEG_CACHE_POOL (1ULL << 14)
#define SEG_MIRROR (1ULL << 15)
#define SEG_ONLY_EXCLUSIVE (1ULL << 16) /* In cluster only exlusive activation */
#define SEG_CAN_ERROR_WHEN_FULL (1ULL << 17)
raid: Add a segtype flag for each raid type.
2015-09-24 22:17:57 +03:00
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_RAID0 (1ULL << 18)
#define SEG_RAID0_META (1ULL << 19)
#define SEG_RAID1 (1ULL << 20)
#define SEG_RAID10_NEAR (1ULL << 21)
lvconvert: add conversion from/to raid10 Add: - conversion support from striped/raid0/raid0_meta to/from raid10; raid10 goes by the near format (same as used in creation of raid10 LVs), which groups data copies together with their original blocks (e.g. 3-way striped, 2 data copies resulting in 112233 in the first stripe followed by 445566 in the second etc.) and is limited to even numbers of legs for now - related tests to lvconvert-raid-takeover.sh - typo Related: rhbz1366296
2017-02-10 21:10:05 +03:00
#define SEG_RAID10 SEG_RAID10_NEAR
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_RAID4 (1ULL << 22)
#define SEG_RAID5_N (1ULL << 23)
#define SEG_RAID5_LA (1ULL << 24)
#define SEG_RAID5_LS (1ULL << 25)
#define SEG_RAID5_RA (1ULL << 26)
#define SEG_RAID5_RS (1ULL << 27)
raid: Add a segtype flag for each raid type.
2015-09-24 22:17:57 +03:00
#define SEG_RAID5 SEG_RAID5_LS
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_RAID6_NC (1ULL << 28)
#define SEG_RAID6_NR (1ULL << 29)
#define SEG_RAID6_ZR (1ULL << 30)
#define SEG_RAID6_LA_6 (1ULL << 31)
#define SEG_RAID6_LS_6 (1ULL << 32)
#define SEG_RAID6_RA_6 (1ULL << 33)
#define SEG_RAID6_RS_6 (1ULL << 34)
#define SEG_RAID6_N_6 (1ULL << 35)
raid: Add a segtype flag for each raid type.
2015-09-24 22:17:57 +03:00
#define SEG_RAID6 SEG_RAID6_ZR
Add dm-writecache support dm-writecache is used like dm-cache with a standard LV as the cache. $ lvcreate -n main -L 128M -an foo /dev/loop0 $ lvcreate -n fast -L 32M -an foo /dev/pmem0 $ lvconvert --type writecache --cachepool fast foo/main $ lvs -a foo -o+devices LV VG Attr LSize Origin Devices [fast] foo -wi------- 32.00m /dev/pmem0(0) main foo Cwi------- 128.00m [main_wcorig] main_wcorig(0) [main_wcorig] foo -wi------- 128.00m /dev/loop0(0) $ lvchange -ay foo/main $ dmsetup table foo-main_wcorig: 0 262144 linear 7:0 2048 foo-main: 0 262144 writecache p 253:4 253:3 4096 0 foo-fast: 0 65536 linear 259:0 2048 $ lvchange -an foo/main $ lvconvert --splitcache foo/main $ lvs -a foo -o+devices LV VG Attr LSize Devices fast foo -wi------- 32.00m /dev/pmem0(0) main foo -wi------- 128.00m /dev/loop0(0)
2018-08-27 22:53:09 +03:00
#define SEG_WRITECACHE (1ULL << 36)
Allow dm-integrity to be used for raid images dm-integrity stores checksums of the data written to an LV, and returns an error if data read from the LV does not match the previously saved checksum. When used on raid images, dm-raid will correct the error by reading the block from another image, and the device user sees no error. The integrity metadata (checksums) are stored on an internal LV allocated by lvm for each linear image. The internal LV is allocated on the same PV as the image. Create a raid LV with an integrity layer over each raid image (for raid levels 1,4,5,6,10): lvcreate --type raidN --raidintegrity y [options] Add an integrity layer to images of an existing raid LV: lvconvert --raidintegrity y LV Remove the integrity layer from images of a raid LV: lvconvert --raidintegrity n LV Settings Use --raidintegritymode journal|bitmap (journal is default) to configure the method used by dm-integrity to ensure crash consistency. Initialization When integrity is added to an LV, the kernel needs to initialize the integrity metadata/checksums for all blocks in the LV. The data corruption checking performed by dm-integrity will only operate on areas of the LV that are already initialized. The progress of integrity initialization is reported by the "syncpercent" LV reporting field (and under the Cpy%Sync lvs column.) Example: create a raid1 LV with integrity: $ lvcreate --type raid1 -m1 --raidintegrity y -n rr -L1G foo Creating integrity metadata LV rr_rimage_0_imeta with size 12.00 MiB. Logical volume "rr_rimage_0_imeta" created. Creating integrity metadata LV rr_rimage_1_imeta with size 12.00 MiB. Logical volume "rr_rimage_1_imeta" created. Logical volume "rr" created. $ lvs -a foo LV VG Attr LSize Origin Cpy%Sync rr foo rwi-a-r--- 1.00g 4.93 [rr_rimage_0] foo gwi-aor--- 1.00g [rr_rimage_0_iorig] 41.02 [rr_rimage_0_imeta] foo ewi-ao---- 12.00m [rr_rimage_0_iorig] foo -wi-ao---- 1.00g [rr_rimage_1] foo gwi-aor--- 1.00g [rr_rimage_1_iorig] 39.45 [rr_rimage_1_imeta] foo ewi-ao---- 12.00m [rr_rimage_1_iorig] foo -wi-ao---- 1.00g [rr_rmeta_0] foo ewi-aor--- 4.00m [rr_rmeta_1] foo ewi-aor--- 4.00m
2019-11-21 01:07:27 +03:00
#define SEG_INTEGRITY (1ULL << 37)
raid: Add a segtype flag for each raid type.
2015-09-24 22:17:57 +03:00
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_STRIPED_TARGET (1ULL << 39)
segtype: add linear Add linear segtype addressing FIXME in preparation for linear <-> striped convenience conversion support
2018-05-30 13:44:24 +03:00
#define SEG_LINEAR_TARGET (1ULL << 40)
vdo: introduce segment types and manip functions Core functionality introducing lvm VDO support.
2018-06-29 12:11:14 +03:00
#define SEG_VDO (1ULL << 41)
#define SEG_VDO_POOL (1ULL << 42)
striped: Add precise macros for original segtype. The existing striped macros include raid0 segments.
2016-08-04 03:24:39 +03:00
metadata: cleanup flags definition to be consistent Use shift bitops throughout segtype.h.
2017-03-22 02:29:49 +03:00
#define SEG_UNKNOWN (1ULL << 63)
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
#define SEG_TYPE_NAME_LINEAR "linear"
#define SEG_TYPE_NAME_STRIPED "striped"
#define SEG_TYPE_NAME_MIRROR "mirror"
segtypes: Use SEG_TYPE_NAME_ string constants.
2015-09-22 21:04:12 +03:00
#define SEG_TYPE_NAME_SNAPSHOT "snapshot"
#define SEG_TYPE_NAME_THIN "thin"
#define SEG_TYPE_NAME_THIN_POOL "thin-pool"
#define SEG_TYPE_NAME_CACHE "cache"
#define SEG_TYPE_NAME_CACHE_POOL "cache-pool"
Add dm-writecache support dm-writecache is used like dm-cache with a standard LV as the cache. $ lvcreate -n main -L 128M -an foo /dev/loop0 $ lvcreate -n fast -L 32M -an foo /dev/pmem0 $ lvconvert --type writecache --cachepool fast foo/main $ lvs -a foo -o+devices LV VG Attr LSize Origin Devices [fast] foo -wi------- 32.00m /dev/pmem0(0) main foo Cwi------- 128.00m [main_wcorig] main_wcorig(0) [main_wcorig] foo -wi------- 128.00m /dev/loop0(0) $ lvchange -ay foo/main $ dmsetup table foo-main_wcorig: 0 262144 linear 7:0 2048 foo-main: 0 262144 writecache p 253:4 253:3 4096 0 foo-fast: 0 65536 linear 259:0 2048 $ lvchange -an foo/main $ lvconvert --splitcache foo/main $ lvs -a foo -o+devices LV VG Attr LSize Devices fast foo -wi------- 32.00m /dev/pmem0(0) main foo -wi------- 128.00m /dev/loop0(0)
2018-08-27 22:53:09 +03:00
#define SEG_TYPE_NAME_WRITECACHE "writecache"
Allow dm-integrity to be used for raid images dm-integrity stores checksums of the data written to an LV, and returns an error if data read from the LV does not match the previously saved checksum. When used on raid images, dm-raid will correct the error by reading the block from another image, and the device user sees no error. The integrity metadata (checksums) are stored on an internal LV allocated by lvm for each linear image. The internal LV is allocated on the same PV as the image. Create a raid LV with an integrity layer over each raid image (for raid levels 1,4,5,6,10): lvcreate --type raidN --raidintegrity y [options] Add an integrity layer to images of an existing raid LV: lvconvert --raidintegrity y LV Remove the integrity layer from images of a raid LV: lvconvert --raidintegrity n LV Settings Use --raidintegritymode journal|bitmap (journal is default) to configure the method used by dm-integrity to ensure crash consistency. Initialization When integrity is added to an LV, the kernel needs to initialize the integrity metadata/checksums for all blocks in the LV. The data corruption checking performed by dm-integrity will only operate on areas of the LV that are already initialized. The progress of integrity initialization is reported by the "syncpercent" LV reporting field (and under the Cpy%Sync lvs column.) Example: create a raid1 LV with integrity: $ lvcreate --type raid1 -m1 --raidintegrity y -n rr -L1G foo Creating integrity metadata LV rr_rimage_0_imeta with size 12.00 MiB. Logical volume "rr_rimage_0_imeta" created. Creating integrity metadata LV rr_rimage_1_imeta with size 12.00 MiB. Logical volume "rr_rimage_1_imeta" created. Logical volume "rr" created. $ lvs -a foo LV VG Attr LSize Origin Cpy%Sync rr foo rwi-a-r--- 1.00g 4.93 [rr_rimage_0] foo gwi-aor--- 1.00g [rr_rimage_0_iorig] 41.02 [rr_rimage_0_imeta] foo ewi-ao---- 12.00m [rr_rimage_0_iorig] foo -wi-ao---- 1.00g [rr_rimage_1] foo gwi-aor--- 1.00g [rr_rimage_1_iorig] 39.45 [rr_rimage_1_imeta] foo ewi-ao---- 12.00m [rr_rimage_1_iorig] foo -wi-ao---- 1.00g [rr_rmeta_0] foo ewi-aor--- 4.00m [rr_rmeta_1] foo ewi-aor--- 4.00m
2019-11-21 01:07:27 +03:00
#define SEG_TYPE_NAME_INTEGRITY "integrity"
segtypes: Use SEG_TYPE_NAME_ string constants.
2015-09-22 21:04:12 +03:00
#define SEG_TYPE_NAME_ERROR "error"
#define SEG_TYPE_NAME_FREE "free"
#define SEG_TYPE_NAME_ZERO "zero"
vdo: introduce segment types and manip functions Core functionality introducing lvm VDO support.
2018-06-29 12:11:14 +03:00
#define SEG_TYPE_NAME_VDO "vdo"
#define SEG_TYPE_NAME_VDO_POOL "vdo-pool"
segtypes: Use SEG_TYPE_NAME_ string constants.
2015-09-22 21:04:12 +03:00
#define SEG_TYPE_NAME_RAID "raid"
raid: Detect whether or not kernel supports raid0.
2015-09-24 21:52:22 +03:00
#define SEG_TYPE_NAME_RAID0 "raid0"
raid0: Add raid0_meta segment type.
2016-07-02 00:20:54 +03:00
#define SEG_TYPE_NAME_RAID0_META "raid0_meta"
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
#define SEG_TYPE_NAME_RAID1 "raid1"
#define SEG_TYPE_NAME_RAID10 "raid10"
lvconvert: add segment type raid10_near Introducing this alias for "raid10", avoid allocating reshape space when converting between them. Resolves: rhbz1441347
2017-04-12 02:28:22 +03:00
#define SEG_TYPE_NAME_RAID10_NEAR "raid10_near"
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
#define SEG_TYPE_NAME_RAID4 "raid4"
#define SEG_TYPE_NAME_RAID5 "raid5"
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define SEG_TYPE_NAME_RAID5_N "raid5_n"
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
#define SEG_TYPE_NAME_RAID5_LA "raid5_la"
#define SEG_TYPE_NAME_RAID5_LS "raid5_ls"
#define SEG_TYPE_NAME_RAID5_RA "raid5_ra"
#define SEG_TYPE_NAME_RAID5_RS "raid5_rs"
#define SEG_TYPE_NAME_RAID6 "raid6"
#define SEG_TYPE_NAME_RAID6_NC "raid6_nc"
#define SEG_TYPE_NAME_RAID6_NR "raid6_nr"
#define SEG_TYPE_NAME_RAID6_ZR "raid6_zr"
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define SEG_TYPE_NAME_RAID6_LA_6 "raid6_la_6"
#define SEG_TYPE_NAME_RAID6_LS_6 "raid6_ls_6"
#define SEG_TYPE_NAME_RAID6_RA_6 "raid6_ra_6"
#define SEG_TYPE_NAME_RAID6_RS_6 "raid6_rs_6"
#define SEG_TYPE_NAME_RAID6_N_6 "raid6_n_6"
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
segtype: add linear Add linear segtype addressing FIXME in preparation for linear <-> striped convenience conversion support
2018-05-30 13:44:24 +03:00
#define segtype_is_linear(segtype) (!strcmp((segtype)->name, SEG_TYPE_NAME_LINEAR))
segtypes: macros for error and zero segtypes
2021-03-18 15:13:38 +03:00
#define segtype_is_error(segtype) (!strcmp((segtype)->name, SEG_TYPE_NAME_ERROR))
#define segtype_is_zero(segtype) (!strcmp((segtype)->name, SEG_TYPE_NAME_ZERO))
striped: Add precise macros for original segtype. The existing striped macros include raid0 segments.
2016-08-04 03:24:39 +03:00
#define segtype_is_striped_target(segtype) ((segtype)->flags & SEG_STRIPED_TARGET ? 1 : 0)
cache: New 'cachepool' segment type This patch adds the new cachepool segment type - the first of two necessary to eventually create 'cache' logical volumes. In addition to the new segment type, updates to makefiles, configure files, the lv_segment struct, and some necessary libdevmapper flags. The cachepool is the LV and corresponding segment type that will hold all information pertinent to the cache itself - it's size, cachemode, cache policy, core arguments (like migration_threshold), etc.
2014-01-27 15:27:16 +04:00
#define segtype_is_cache(segtype) ((segtype)->flags & SEG_CACHE ? 1 : 0)
#define segtype_is_cache_pool(segtype) ((segtype)->flags & SEG_CACHE_POOL ? 1 : 0)
Add dm-writecache support dm-writecache is used like dm-cache with a standard LV as the cache. $ lvcreate -n main -L 128M -an foo /dev/loop0 $ lvcreate -n fast -L 32M -an foo /dev/pmem0 $ lvconvert --type writecache --cachepool fast foo/main $ lvs -a foo -o+devices LV VG Attr LSize Origin Devices [fast] foo -wi------- 32.00m /dev/pmem0(0) main foo Cwi------- 128.00m [main_wcorig] main_wcorig(0) [main_wcorig] foo -wi------- 128.00m /dev/loop0(0) $ lvchange -ay foo/main $ dmsetup table foo-main_wcorig: 0 262144 linear 7:0 2048 foo-main: 0 262144 writecache p 253:4 253:3 4096 0 foo-fast: 0 65536 linear 259:0 2048 $ lvchange -an foo/main $ lvconvert --splitcache foo/main $ lvs -a foo -o+devices LV VG Attr LSize Devices fast foo -wi------- 32.00m /dev/pmem0(0) main foo -wi------- 128.00m /dev/loop0(0)
2018-08-27 22:53:09 +03:00
#define segtype_is_writecache(segtype) ((segtype)->flags & SEG_WRITECACHE ? 1 : 0)
Allow dm-integrity to be used for raid images dm-integrity stores checksums of the data written to an LV, and returns an error if data read from the LV does not match the previously saved checksum. When used on raid images, dm-raid will correct the error by reading the block from another image, and the device user sees no error. The integrity metadata (checksums) are stored on an internal LV allocated by lvm for each linear image. The internal LV is allocated on the same PV as the image. Create a raid LV with an integrity layer over each raid image (for raid levels 1,4,5,6,10): lvcreate --type raidN --raidintegrity y [options] Add an integrity layer to images of an existing raid LV: lvconvert --raidintegrity y LV Remove the integrity layer from images of a raid LV: lvconvert --raidintegrity n LV Settings Use --raidintegritymode journal|bitmap (journal is default) to configure the method used by dm-integrity to ensure crash consistency. Initialization When integrity is added to an LV, the kernel needs to initialize the integrity metadata/checksums for all blocks in the LV. The data corruption checking performed by dm-integrity will only operate on areas of the LV that are already initialized. The progress of integrity initialization is reported by the "syncpercent" LV reporting field (and under the Cpy%Sync lvs column.) Example: create a raid1 LV with integrity: $ lvcreate --type raid1 -m1 --raidintegrity y -n rr -L1G foo Creating integrity metadata LV rr_rimage_0_imeta with size 12.00 MiB. Logical volume "rr_rimage_0_imeta" created. Creating integrity metadata LV rr_rimage_1_imeta with size 12.00 MiB. Logical volume "rr_rimage_1_imeta" created. Logical volume "rr" created. $ lvs -a foo LV VG Attr LSize Origin Cpy%Sync rr foo rwi-a-r--- 1.00g 4.93 [rr_rimage_0] foo gwi-aor--- 1.00g [rr_rimage_0_iorig] 41.02 [rr_rimage_0_imeta] foo ewi-ao---- 12.00m [rr_rimage_0_iorig] foo -wi-ao---- 1.00g [rr_rimage_1] foo gwi-aor--- 1.00g [rr_rimage_1_iorig] 39.45 [rr_rimage_1_imeta] foo ewi-ao---- 12.00m [rr_rimage_1_iorig] foo -wi-ao---- 1.00g [rr_rmeta_0] foo ewi-aor--- 4.00m [rr_rmeta_1] foo ewi-aor--- 4.00m
2019-11-21 01:07:27 +03:00
#define segtype_is_integrity(segtype) ((segtype)->flags & SEG_INTEGRITY ? 1 : 0)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define segtype_is_mirrored(segtype) ((segtype)->flags & SEG_AREAS_MIRRORED ? 1 : 0)
mirrors: Fix checks for mirror/raid/pvmove LVs. Try to enforce consistent macro usage along these lines: lv_is_mirror - mirror that uses the original dm-raid1 implementation (segment type "mirror") lv_is_mirror_type - also includes internal mirror image and log LVs lv_is_raid - raid volume that uses the new dm-raid implementation (segment type "raid") lv_is_raid_type - also includes internal raid image / log / metadata LVs lv_is_mirrored - LV is mirrored using either kernel implementation (excludes non-mirror modes like raid5 etc.) lv_is_pvmove - internal pvmove volume
2014-09-16 03:13:46 +04:00
#define segtype_is_mirror(segtype) ((segtype)->flags & SEG_MIRROR ? 1 : 0)
cleanup: add seg_is_pool macro Simplify code querying for pool segtype.
2014-05-23 16:24:28 +04:00
#define segtype_is_pool(segtype) ((segtype)->flags & (SEG_CACHE_POOL | SEG_THIN_POOL) ? 1 : 0)
raid0: Add raid0 segment type. This remains experimental and quite restrictive so should only be used for testing at this stage. (E.g. lvreduce is not supported.)
2016-05-23 18:46:38 +03:00
#define segtype_is_raid0(segtype) ((segtype)->flags & SEG_RAID0 ? 1 : 0)
raid0: Add raid0_meta segment type.
2016-07-02 00:20:54 +03:00
#define segtype_is_raid0_meta(segtype) ((segtype)->flags & SEG_RAID0_META ? 1 : 0)
#define segtype_is_any_raid0(segtype) ((segtype)->flags & (SEG_RAID0 | SEG_RAID0_META) ? 1 : 0)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define segtype_is_raid(segtype) ((segtype)->flags & SEG_RAID ? 1 : 0)
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define segtype_is_raid1(segtype) ((segtype)->flags & SEG_RAID1 ? 1 : 0)
#define segtype_is_raid4(segtype) ((segtype)->flags & SEG_RAID4 ? 1 : 0)
#define segtype_is_any_raid5(segtype) ((segtype)->flags & \
(SEG_RAID5_LS|SEG_RAID5_LA|SEG_RAID5_RS|SEG_RAID5_RA|SEG_RAID5_N) ? 1 : 0)
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define segtype_is_raid5_n(segtype) ((segtype)->flags & SEG_RAID5_N ? 1 : 0)
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define segtype_is_raid5_la(segtype) ((segtype)->flags & SEG_RAID5_LA ? 1 : 0)
#define segtype_is_raid5_ra(segtype) ((segtype)->flags & SEG_RAID5_RA ? 1 : 0)
#define segtype_is_raid5_ls(segtype) ((segtype)->flags & SEG_RAID5_LS ? 1 : 0)
#define segtype_is_raid5_rs(segtype) ((segtype)->flags & SEG_RAID5_RS ? 1 : 0)
#define segtype_is_any_raid6(segtype) ((segtype)->flags & \
(SEG_RAID6_ZR|SEG_RAID6_NC|SEG_RAID6_NR| \
SEG_RAID6_LA_6|SEG_RAID6_LS_6|SEG_RAID6_RA_6|SEG_RAID6_RS_6|SEG_RAID6_N_6) ? 1 : 0)
#define segtype_is_raid6_nc(segtype) ((segtype)->flags & SEG_RAID6_NC ? 1 : 0)
#define segtype_is_raid6_nr(segtype) ((segtype)->flags & SEG_RAID6_NR ? 1 : 0)
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define segtype_is_raid6_n_6(segtype) ((segtype)->flags & SEG_RAID6_N_6 ? 1 : 0)
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define segtype_is_raid6_zr(segtype) ((segtype)->flags & SEG_RAID6_ZR ? 1 : 0)
lvconvert: add segtypes raid6_{ls,rs,la,ra}_6 and conversions to/from it Add: - support for segment types raid6_{ls,rs,la,ra}_6 (striped raid with dedicated last Q-Syndrome SubLVs) - conversion support from raid5_{ls,rs,la,ra} to/from raid6_{ls,rs,la,ra}_6 - setting convenient segtypes on conversions from/to raid4/5/6 - related tests to lvconvert-raid-takeover.sh factoring out _lvcreate,_lvconvert funxtions Related: rhbz1366296
2017-02-05 02:53:36 +03:00
#define segtype_is_raid6_ls_6(segtype) ((segtype)->flags & SEG_RAID6_LS_6 ? 1 : 0)
#define segtype_is_raid6_rs_6(segtype) ((segtype)->flags & SEG_RAID6_RS_6 ? 1 : 0)
#define segtype_is_raid6_la_6(segtype) ((segtype)->flags & SEG_RAID6_LA_6 ? 1 : 0)
#define segtype_is_raid6_ra_6(segtype) ((segtype)->flags & SEG_RAID6_RA_6 ? 1 : 0)
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define segtype_is_raid10(segtype) ((segtype)->flags & SEG_RAID10 ? 1 : 0)
lvconvert: add segment type raid10_near Introducing this alias for "raid10", avoid allocating reshape space when converting between them. Resolves: rhbz1441347
2017-04-12 02:28:22 +03:00
#define segtype_is_raid10_near(segtype) ((segtype)->flags & SEG_RAID10_NEAR ? 1 : 0)
/* FIXME: once raid10_{far,offset} supported */
#define segtype_is_raid10_far(segtype) 0 /* FIXME ((segtype)->flags & SEG_RAID10_FAR ? 1 : 0 */
pre-release Removing some unused new lines and changing some incorrect "can't release until this is fixed" comments. Rename license.txt to make it clear its merely an included file, not itself a licence.
2017-03-28 17:28:53 +03:00
#define segtype_is_raid10_offset(segtype) 0 /* FIXME ((segtype)->flags & SEG_RAID10_OFFSET ? 1 : 0 */
lvconvert: add segment type raid10_near Introducing this alias for "raid10", avoid allocating reshape space when converting between them. Resolves: rhbz1441347
2017-04-12 02:28:22 +03:00
#define segtype_is_any_raid10(segtype) (segtype_is_raid10(segtype) || segtype_is_raid10_near(segtype) || segtype_is_raid10_far(segtype) || segtype_is_raid10_offset(segtype))
raid0: Standardise meta_areas checks before access.
2016-05-24 00:55:13 +03:00
#define segtype_is_raid_with_meta(segtype) (segtype_is_raid(segtype) && !segtype_is_raid0(segtype))
lvconvert: add infrastructure for RaidLV reshaping support In order to support striped raid5/6/10 LV reshaping (change of LV type, stripesize or number of legs), this patch introduces infrastructure prerequisites to be used by raid_manip.c extensions in followup patches. This base is needed for allocation of out-of-place reshape space required by the MD raid personalities to avoid writing over data in-place when reading off the current RAID layout or number of legs and writing out the new layout or to a different number of legs (i.e. restripe) Changes: - add members reshape_len to 'struct lv_segment' to store out-of-place reshape length per component rimage - add member data_copies to struct lv_segment to support more than 2 raid10 data copies - make alloc_lv_segment() aware of both reshape_len and data_copies - adjust all alloc_lv_segment() callers to the new API - add functions to retrieve the current data offset (needed for out-of-place reshaping space allocation) and the devices count from the kernel - make libdm deptree code aware of reshape_len - add LV flags for disk add/remove reshaping - support import/export of the new 'struct lv_segment' members - enhance lv_extend/_lv_reduce to cope with reshape_len - add seg_is_*/segtype_is_* macros related to reshaping - add target version check for reshaping - grow rebuilds/writemostly bitmaps to 246 bit to support kernel maximal - enhance libdm deptree code to support data_offset (out-of-place reshaping) and delta_disk (legs add/remove reshaping) target arguments Related: rhbz834579 Related: rhbz1191935 Related: rhbz1191978
2017-02-24 02:50:00 +03:00
#define segtype_is_striped_raid(segtype) (segtype_is_raid(segtype) && !segtype_is_raid1(segtype))
#define segtype_is_reshapable_raid(segtype) ((segtype_is_striped_raid(segtype) && !segtype_is_any_raid0(segtype)) || segtype_is_raid10_near(segtype) || segtype_is_raid10_offset(segtype))
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define segtype_is_snapshot(segtype) ((segtype)->flags & SEG_SNAPSHOT ? 1 : 0)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define segtype_is_striped(segtype) ((segtype)->flags & SEG_AREAS_STRIPED ? 1 : 0)
#define segtype_is_thin(segtype) ((segtype)->flags & (SEG_THIN_POOL|SEG_THIN_VOLUME) ? 1 : 0)
#define segtype_is_thin_pool(segtype) ((segtype)->flags & SEG_THIN_POOL ? 1 : 0)
#define segtype_is_thin_volume(segtype) ((segtype)->flags & SEG_THIN_VOLUME ? 1 : 0)
vdo: introduce segment types and manip functions Core functionality introducing lvm VDO support.
2018-06-29 12:11:14 +03:00
#define segtype_is_vdo(segtype) ((segtype)->flags & SEG_VDO ? 1 : 0)
#define segtype_is_vdo_pool(segtype) ((segtype)->flags & SEG_VDO_POOL ? 1 : 0)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define segtype_is_virtual(segtype) ((segtype)->flags & SEG_VIRTUAL ? 1 : 0)
segtypes: macro segtype_is_unknown
2014-10-11 00:22:43 +04:00
#define segtype_is_unknown(segtype) ((segtype)->flags & SEG_UNKNOWN ? 1 : 0)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
cleanup: defines
2016-12-25 01:24:37 +03:00
#define segtype_can_split(segtype) ((segtype)->flags & SEG_CAN_SPLIT ? 1 : 0)
#define segtype_cannot_be_zeroed(segtype) ((segtype)->flags & SEG_CANNOT_BE_ZEROED ? 1 : 0)
#define segtype_monitored(segtype) ((segtype)->flags & SEG_MONITORED ? 1 : 0)
#define segtype_only_exclusive(segtype) ((segtype)->flags & SEG_ONLY_EXCLUSIVE ? 1 : 0)
#define segtype_can_error_when_full(segtype) ((segtype)->flags & SEG_CAN_ERROR_WHEN_FULL ? 1 : 0)
tools: Unify stripesize parameter validation. Move it all into get_stripe_params(). Some code paths missed --stripesize checks. E.g. lvcreate --type raid4 -i1
2016-07-30 04:05:50 +03:00
#define segtype_supports_stripe_size(segtype) \
tools: mirror also supports stripesize
2016-07-30 05:52:49 +03:00
((segtype_is_striped(segtype) || segtype_is_mirror(segtype) || \
tools: Also recognise segtype with thin and cache. (--type thin still needs this for lvcreate - more logic should be shared between lvcreate and lvconvert)
2016-07-30 06:12:58 +03:00
segtype_is_cache(segtype) || segtype_is_cache_pool(segtype) || \
segtype_is_thin(segtype) || segtype_is_snapshot(segtype) || \
cleanup: reuse existing macro Use existing macro to detect striped raid segment.
2017-11-27 12:20:24 +03:00
(segtype_is_striped_raid(segtype))) ? 1 : 0)
tools: Unify stripesize parameter validation. Move it all into get_stripe_params(). Some code paths missed --stripesize checks. E.g. lvcreate --type raid4 -i1
2016-07-30 04:05:50 +03:00
striped: Add precise macros for original segtype. The existing striped macros include raid0 segments.
2016-08-04 03:24:39 +03:00
#define seg_is_striped_target(seg) segtype_is_striped_target((seg)->segtype)
cache: New 'cachepool' segment type This patch adds the new cachepool segment type - the first of two necessary to eventually create 'cache' logical volumes. In addition to the new segment type, updates to makefiles, configure files, the lv_segment struct, and some necessary libdevmapper flags. The cachepool is the LV and corresponding segment type that will hold all information pertinent to the cache itself - it's size, cachemode, cache policy, core arguments (like migration_threshold), etc.
2014-01-27 15:27:16 +04:00
#define seg_is_cache(seg) segtype_is_cache((seg)->segtype)
#define seg_is_cache_pool(seg) segtype_is_cache_pool((seg)->segtype)
Add dm-writecache support dm-writecache is used like dm-cache with a standard LV as the cache. $ lvcreate -n main -L 128M -an foo /dev/loop0 $ lvcreate -n fast -L 32M -an foo /dev/pmem0 $ lvconvert --type writecache --cachepool fast foo/main $ lvs -a foo -o+devices LV VG Attr LSize Origin Devices [fast] foo -wi------- 32.00m /dev/pmem0(0) main foo Cwi------- 128.00m [main_wcorig] main_wcorig(0) [main_wcorig] foo -wi------- 128.00m /dev/loop0(0) $ lvchange -ay foo/main $ dmsetup table foo-main_wcorig: 0 262144 linear 7:0 2048 foo-main: 0 262144 writecache p 253:4 253:3 4096 0 foo-fast: 0 65536 linear 259:0 2048 $ lvchange -an foo/main $ lvconvert --splitcache foo/main $ lvs -a foo -o+devices LV VG Attr LSize Devices fast foo -wi------- 32.00m /dev/pmem0(0) main foo -wi------- 128.00m /dev/loop0(0)
2018-08-27 22:53:09 +03:00
#define seg_is_writecache(seg) segtype_is_writecache((seg)->segtype)
Allow dm-integrity to be used for raid images dm-integrity stores checksums of the data written to an LV, and returns an error if data read from the LV does not match the previously saved checksum. When used on raid images, dm-raid will correct the error by reading the block from another image, and the device user sees no error. The integrity metadata (checksums) are stored on an internal LV allocated by lvm for each linear image. The internal LV is allocated on the same PV as the image. Create a raid LV with an integrity layer over each raid image (for raid levels 1,4,5,6,10): lvcreate --type raidN --raidintegrity y [options] Add an integrity layer to images of an existing raid LV: lvconvert --raidintegrity y LV Remove the integrity layer from images of a raid LV: lvconvert --raidintegrity n LV Settings Use --raidintegritymode journal|bitmap (journal is default) to configure the method used by dm-integrity to ensure crash consistency. Initialization When integrity is added to an LV, the kernel needs to initialize the integrity metadata/checksums for all blocks in the LV. The data corruption checking performed by dm-integrity will only operate on areas of the LV that are already initialized. The progress of integrity initialization is reported by the "syncpercent" LV reporting field (and under the Cpy%Sync lvs column.) Example: create a raid1 LV with integrity: $ lvcreate --type raid1 -m1 --raidintegrity y -n rr -L1G foo Creating integrity metadata LV rr_rimage_0_imeta with size 12.00 MiB. Logical volume "rr_rimage_0_imeta" created. Creating integrity metadata LV rr_rimage_1_imeta with size 12.00 MiB. Logical volume "rr_rimage_1_imeta" created. Logical volume "rr" created. $ lvs -a foo LV VG Attr LSize Origin Cpy%Sync rr foo rwi-a-r--- 1.00g 4.93 [rr_rimage_0] foo gwi-aor--- 1.00g [rr_rimage_0_iorig] 41.02 [rr_rimage_0_imeta] foo ewi-ao---- 12.00m [rr_rimage_0_iorig] foo -wi-ao---- 1.00g [rr_rimage_1] foo gwi-aor--- 1.00g [rr_rimage_1_iorig] 39.45 [rr_rimage_1_imeta] foo ewi-ao---- 12.00m [rr_rimage_1_iorig] foo -wi-ao---- 1.00g [rr_rmeta_0] foo ewi-aor--- 4.00m [rr_rmeta_1] foo ewi-aor--- 4.00m
2019-11-21 01:07:27 +03:00
#define seg_is_integrity(seg) segtype_is_integrity((seg)->segtype)
cache: report metadata percentage Reinstantiate reporting of metadata percent usage for cache volumes. Also show the same percentage with hidden cache-pool LV. This regression was caused by optimization for a single-ioctl in 2.02.155.
2016-09-09 15:24:49 +03:00
#define seg_is_used_cache_pool(seg) (seg_is_cache_pool(seg) && (!dm_list_empty(&(seg->lv)->segs_using_this_lv)))
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define seg_is_linear(seg) (seg_is_striped(seg) && ((seg)->area_count == 1))
mirrors: Fix checks for mirror/raid/pvmove LVs. Try to enforce consistent macro usage along these lines: lv_is_mirror - mirror that uses the original dm-raid1 implementation (segment type "mirror") lv_is_mirror_type - also includes internal mirror image and log LVs lv_is_raid - raid volume that uses the new dm-raid implementation (segment type "raid") lv_is_raid_type - also includes internal raid image / log / metadata LVs lv_is_mirrored - LV is mirrored using either kernel implementation (excludes non-mirror modes like raid5 etc.) lv_is_pvmove - internal pvmove volume
2014-09-16 03:13:46 +04:00
#define seg_is_mirror(seg) segtype_is_mirror((seg)->segtype)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define seg_is_mirrored(seg) segtype_is_mirrored((seg)->segtype)
cleanup: add seg_is_pool macro Simplify code querying for pool segtype.
2014-05-23 16:24:28 +04:00
#define seg_is_pool(seg) segtype_is_pool((seg)->segtype)
raid0: Add raid0 segment type. This remains experimental and quite restrictive so should only be used for testing at this stage. (E.g. lvreduce is not supported.)
2016-05-23 18:46:38 +03:00
#define seg_is_raid0(seg) segtype_is_raid0((seg)->segtype)
raid0: Add raid0_meta segment type.
2016-07-02 00:20:54 +03:00
#define seg_is_raid0_meta(seg) segtype_is_raid0_meta((seg)->segtype)
raid0: Add raid0 segment type. This remains experimental and quite restrictive so should only be used for testing at this stage. (E.g. lvreduce is not supported.)
2016-05-23 18:46:38 +03:00
#define seg_is_any_raid0(seg) segtype_is_any_raid0((seg)->segtype)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define seg_is_raid(seg) segtype_is_raid((seg)->segtype)
segtypes: Add and use new segtype macros. Includes fixing an inverted raid10 segtype check in _raid_add_target_line.
2015-09-24 16:59:07 +03:00
#define seg_is_raid1(seg) segtype_is_raid1((seg)->segtype)
#define seg_is_raid4(seg) segtype_is_raid4((seg)->segtype)
#define seg_is_any_raid5(seg) segtype_is_any_raid5((seg)->segtype)
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define seg_is_raid5_n(seg) segtype_is_raid5_n((seg)->segtype)
segtypes: Add and use new segtype macros. Includes fixing an inverted raid10 segtype check in _raid_add_target_line.
2015-09-24 16:59:07 +03:00
#define seg_is_raid5_la(seg) segtype_is_raid5_la((seg)->segtype)
#define seg_is_raid5_ra(seg) segtype_is_raid5_ra((seg)->segtype)
#define seg_is_raid5_ls(seg) segtype_is_raid5_ls((seg)->segtype)
#define seg_is_raid5_rs(seg) segtype_is_raid5_rs((seg)->segtype)
#define seg_is_any_raid6(seg) segtype_is_any_raid6((seg)->segtype)
#define seg_is_raid6_zr(seg) segtype_is_raid6_zr((seg)->segtype)
#define seg_is_raid6_nr(seg) segtype_is_raid6_nr((seg)->segtype)
#define seg_is_raid6_nc(seg) segtype_is_raid6_nc((seg)->segtype)
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define seg_is_raid6_n_6(seg) segtype_is_raid6_n_6((seg)->segtype)
#define seg_is_any_raid10(seg) segtype_is_any_raid10((seg)->segtype)
segtypes: Add and use new segtype macros. Includes fixing an inverted raid10 segtype check in _raid_add_target_line.
2015-09-24 16:59:07 +03:00
#define seg_is_raid10(seg) segtype_is_raid10((seg)->segtype)
segtypes: Further segtype macros.
2016-08-05 16:00:08 +03:00
#define seg_is_raid10_near(seg) segtype_is_raid10_near((seg)->segtype)
raid0: Standardise meta_areas checks before access.
2016-05-24 00:55:13 +03:00
#define seg_is_raid_with_meta(seg) segtype_is_raid_with_meta((seg)->segtype)
lvconvert: add infrastructure for RaidLV reshaping support In order to support striped raid5/6/10 LV reshaping (change of LV type, stripesize or number of legs), this patch introduces infrastructure prerequisites to be used by raid_manip.c extensions in followup patches. This base is needed for allocation of out-of-place reshape space required by the MD raid personalities to avoid writing over data in-place when reading off the current RAID layout or number of legs and writing out the new layout or to a different number of legs (i.e. restripe) Changes: - add members reshape_len to 'struct lv_segment' to store out-of-place reshape length per component rimage - add member data_copies to struct lv_segment to support more than 2 raid10 data copies - make alloc_lv_segment() aware of both reshape_len and data_copies - adjust all alloc_lv_segment() callers to the new API - add functions to retrieve the current data offset (needed for out-of-place reshaping space allocation) and the devices count from the kernel - make libdm deptree code aware of reshape_len - add LV flags for disk add/remove reshaping - support import/export of the new 'struct lv_segment' members - enhance lv_extend/_lv_reduce to cope with reshape_len - add seg_is_*/segtype_is_* macros related to reshaping - add target version check for reshaping - grow rebuilds/writemostly bitmaps to 246 bit to support kernel maximal - enhance libdm deptree code to support data_offset (out-of-place reshaping) and delta_disk (legs add/remove reshaping) target arguments Related: rhbz834579 Related: rhbz1191935 Related: rhbz1191978
2017-02-24 02:50:00 +03:00
#define seg_is_striped_raid(seg) segtype_is_striped_raid((seg)->segtype)
#define seg_is_reshapable_raid(seg) segtype_is_reshapable_raid((seg)->segtype)
segtypes: Use flags in raid segtype macros.
2015-09-24 22:26:33 +03:00
#define seg_is_snapshot(seg) segtype_is_snapshot((seg)->segtype)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define seg_is_striped(seg) segtype_is_striped((seg)->segtype)
#define seg_is_thin(seg) segtype_is_thin((seg)->segtype)
#define seg_is_thin_pool(seg) segtype_is_thin_pool((seg)->segtype)
#define seg_is_thin_volume(seg) segtype_is_thin_volume((seg)->segtype)
vdo: introduce segment types and manip functions Core functionality introducing lvm VDO support.
2018-06-29 12:11:14 +03:00
#define seg_is_vdo(seg) segtype_is_vdo((seg)->segtype)
#define seg_is_vdo_pool(seg) segtype_is_vdo_pool((seg)->segtype)
cleanup: share segtype macros Write query macro just once.
2013-12-10 13:45:21 +04:00
#define seg_is_virtual(seg) segtype_is_virtual((seg)->segtype)
segtypes: macro segtype_is_unknown
2014-10-11 00:22:43 +04:00
#define seg_unknown(seg) segtype_is_unknown((seg)->segtype)
cleanup: defines
2016-12-25 01:24:37 +03:00
#define seg_can_split(seg) segtype_can_split((seg)->segtype)
#define seg_cannot_be_zeroed(seg) segtype_cannot_be_zeroed((seg)->segtype)
#define seg_monitored(seg) segtype_monitored((seg)->segtype)
#define seg_only_exclusive(seg) segtype_only_exclusive((seg)->segtype)
#define seg_can_error_when_full(seg) segtype_can_error_when_full((seg)->segtype)
lv_reduce tidying. Remove some unnecessary parameters. Introduce seg_is macros.
2005-05-09 20:59:01 +04:00
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct segment_type {
Permit several segment types to be registered by a single shared object.
2009-07-08 16:36:01 +04:00
struct dm_list list; /* Internal */
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
segtypes: Extend flags to 64 bits.
2015-09-22 20:03:33 +03:00
uint64_t flags;
raid: Add a segtype flag for each raid type.
2015-09-24 22:17:57 +03:00
uint32_t parity_devs; /* Parity drives required by segtype */
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct segtype_handler *ops;
const char *name;
cleanup: decode dso path just once Build dso plugin name during segtype initialisation and just use the string during command life-time. Also slightlt update message verbosity and make it very_verbose when operation is going to be made and 'verbose' when it's done.
2018-02-10 01:40:37 +03:00
const char *dso;
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
Permit several segment types to be registered by a single shared object.
2009-07-08 16:36:01 +04:00
void *library; /* lvm_register_segtype() sets this. */
void *private; /* For the segtype handler to use. */
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
};
struct segtype_handler {
const char *(*name) (const struct lv_segment * seg);
Add lv_activate_opts structure To avoid modification of 'read-only' volume group structure add a new structure to pass local data around the code for LV activation. As origin_only is one such flag - replace this parameter with new struct lv_activate_opts. More parameters might eventually become part of lv_activate_opts.
2011-06-17 18:14:19 +04:00
const char *(*target_name) (const struct lv_segment *seg,
const struct lv_activate_opts *laopts);
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
void (*display) (const struct lv_segment * seg);
int (*text_export) (const struct lv_segment * seg,
struct formatter * f);
Move the core of the lib/config/config.c functionality into libdevmapper, leaving behind the LVM-specific parts of the code (convenience wrappers that handle `struct device` and `struct cmd_context`, basically). A number of functions have been renamed (in addition to getting a dm_ prefix) -- namely, all of the config interface now has a dm_config_ prefix.
2011-08-30 18:55:15 +04:00
int (*text_import_area_count) (const struct dm_config_node * sn,
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
uint32_t *area_count);
int (*text_import) (struct lv_segment * seg,
Move the core of the lib/config/config.c functionality into libdevmapper, leaving behind the LVM-specific parts of the code (convenience wrappers that handle `struct device` and `struct cmd_context`, basically). A number of functions have been renamed (in addition to getting a dm_ prefix) -- namely, all of the config interface now has a dm_config_ prefix.
2011-08-30 18:55:15 +04:00
const struct dm_config_node * sn,
Use hash, bitset, malloc, pool from libdevmapper.
2005-10-17 03:03:59 +04:00
struct dm_hash_table * pv_hash);
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
int (*merge_segments) (struct lv_segment * seg1,
struct lv_segment * seg2);
Replacement activation code. [Don't use this yet!]
2005-11-09 01:52:26 +03:00
int (*add_target_line) (struct dev_manager *dm, struct dm_pool *mem,
Add lv_activate_opts structure To avoid modification of 'read-only' volume group structure add a new structure to pass local data around the code for LV activation. As origin_only is one such flag - replace this parameter with new struct lv_activate_opts. More parameters might eventually become part of lv_activate_opts.
2011-06-17 18:14:19 +04:00
struct cmd_context *cmd, void **target_state,
struct lv_segment *seg,
const struct lv_activate_opts *laopts,
struct dm_tree_node *node, uint64_t len,
uint32_t *pvmove_mirror_count);
Improve target type compatibility checking in _percent_run(). Add 'target_status_compatible' method to 'struct segtype_handler'.
2010-01-15 19:35:26 +03:00
int (*target_status_compatible) (const char *type);
lib: pass mem pool to check_transient_status check_transient_status() may need to allocate some memory, so pass in already existing mem pool.
2015-11-30 23:24:31 +03:00
int (*check_transient_status) (struct dm_pool *mem,
struct lv_segment *seg, char *params);
Introduce percent_range_t and centralise snapshot full/mirror in-sync checks.
2009-10-01 04:35:29 +04:00
int (*target_percent) (void **target_state,
report: select: refactor: move percent handling code to libdm for reuse
2014-06-09 14:08:27 +04:00
dm_percent_t *percent,
Introduce percent_range_t and centralise snapshot full/mirror in-sync checks.
2009-10-01 04:35:29 +04:00
struct dm_pool * mem,
Add DISTCLEAN_TARGETS to make template for configure.h. More fixes to error paths.
2006-05-17 00:53:13 +04:00
struct cmd_context *cmd,
Fix lvcreate corelog validation. Add --config for overriding most config file settings from cmdline. Quote arguments when printing command line. Remove linefeed from 'initialising logging' message. Add 'Completed' debug message. Don't attempt library exit after reloading config files. Always compile with libdevmapper, even if device-mapper is disabled.
2006-05-16 20:48:31 +04:00
struct lv_segment *seg, char *params,
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
uint64_t *total_numerator,
Cease recognising snapshot-in-use percentages returned by early development kernels.
2008-07-15 04:25:52 +04:00
uint64_t *total_denominator);
Fix last check-ins: seg can be NULL.
2009-02-28 23:04:24 +03:00
int (*target_present) (struct cmd_context *cmd,
const struct lv_segment *seg,
Add detection of clustered mirror log capability. Currently only check for kernel module presence.
2008-04-07 14:23:47 +04:00
unsigned *attributes);
Add LV column to reports listing kernel modules needed for activation.
2006-10-03 21:55:20 +04:00
int (*modules_needed) (struct dm_pool *mem,
const struct lv_segment *seg,
Right, a simple build (without options) is working again.
2008-11-04 01:14:30 +03:00
struct dm_list *modules);
Remove const usage from destroy callbacks As const segment_type or const format_type are never released use their non-const version and remove const downcast from dm_free calls. This change fixes many gcc warnings we were getting from them.
2010-12-20 16:32:49 +03:00
void (*destroy) (struct segment_type * segtype);
activation: separate reporting of error and monitoring status Avoid using same return code for reporting 2 different things and stricly report error code by return value and add new parameter for reporting monitoring status. This makes easier to recognize which error we got from dm_event and continue only with ENOENT.
2018-01-29 18:28:57 +03:00
int (*target_monitored) (struct lv_segment *seg, int *pending, int *monitored);
Add field definitions to report help text. Remove unnecessary cmd arg from target_*monitor_events().
2007-01-24 19:51:24 +03:00
int (*target_monitor_events) (struct lv_segment *seg, int events);
int (*target_unmonitor_events) (struct lv_segment *seg, int events);
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
};
struct segment_type *get_segtype_from_string(struct cmd_context *cmd,
const char *str);
lvconvert: Conversions between striped and raid0.
2016-06-29 01:44:15 +03:00
struct segment_type *get_segtype_from_flag(struct cmd_context *cmd,
uint64_t flag);
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
Permit several segment types to be registered by a single shared object.
2009-07-08 16:36:01 +04:00
struct segtype_library;
int lvm_register_segtype(struct segtype_library *seglib,
struct segment_type *segtype);
segtype: add linear Add linear segtype addressing FIXME in preparation for linear <-> striped convenience conversion support
2018-05-30 13:44:24 +03:00
struct segment_type *init_linear_segtype(struct cmd_context *cmd);
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
struct segment_type *init_striped_segtype(struct cmd_context *cmd);
Add --type to lvcreate/resize. Add virtual segment types, zero and error. A large sparse device can be constructed as a writeable snapshot of a large zero device.
2004-05-11 20:01:58 +04:00
struct segment_type *init_zero_segtype(struct cmd_context *cmd);
struct segment_type *init_error_segtype(struct cmd_context *cmd);
Fix reporting of LV fields alongside unallocated PV segments.
2008-06-25 20:52:27 +04:00
struct segment_type *init_free_segtype(struct cmd_context *cmd);
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
struct segment_type *init_unknown_segtype(struct cmd_context *cmd,
const char *name);
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
#define RAID_FEATURE_RAID10 (1U << 0) /* version 1.3 */
raid: Detect whether or not kernel supports raid0.
2015-09-24 21:52:22 +03:00
#define RAID_FEATURE_RAID0 (1U << 1) /* version 1.7 */
#define RAID_FEATURE_RESHAPING (1U << 2) /* version 1.8 */
lvchange/vgchange/lvconvert: prevent raid4 creation/activation/conversion on non-supporting raid targets Check for dm-raid target version with non-standard raid4 mapping expecting the dedicated parity device in the last rather than the first slot and prohibit to create, activate or convert to such LVs from striped/raid0* or vice-versa in order to avoid data corruption. Add related tests to lvconvert-raid-takeover.sh Resolves: rhbz1388962
2016-10-27 12:38:16 +03:00
#define RAID_FEATURE_RAID4 (1U << 3) /* ! version 1.8 or 1.9.0 */
raid: check target version for shrink support Starting with dm-raid target version 1.9.0 shrinking of mapped devices is supported. Check for support being present in lvresize and lvreduce. Related: rhbz1394048
2017-03-17 18:46:33 +03:00
#define RAID_FEATURE_SHRINK (1U << 4) /* version 1.9.0 */
#define RAID_FEATURE_RESHAPE (1U << 5) /* version 1.10.1 */
lvconvert: linear -> raid1 upconvert should cause "recover" not "resync" Two of the sync actions performed by the kernel (aka MD runtime) are "resync" and "recover". The "resync" refers to when an entirely new array is going through the process of initializing (or resynchronizing after an unexpected shutdown). The "recover" is the process of initializing a new member device to the array. So, a brand new array with all new devices will undergo "resync". An array with replaced or added sub-LVs will undergo "recover". These two states are treated very differently when failures happen. If any device is lost or replaced while "resync", there are no worries. This is because any writes created from the inception of the array have occurred to all the devices and can be safely recovered. Even though non-initialized portions will still be resync'ed with uninitialized data, it is ok. However, if a pre-existing device is lost (aka, the original linear device in a linear -> raid1 convert) during a "recover", data loss can be the result. Thus, writes are errored by the kernel and recovery is halted. The failed device must be restored or removed. This is the correct behavior. Unfortunately, we were treating an up-convert from linear as a "resync" when we should have been treating it as a "recover". This patch removes the special case for linear upconvert. It allows each new image sub-LV to be marked with a rebuild flag and treats the array as 'in-sync'. This has the correct effect of causing the upconvert to be treated as a "recover" rather than a "resync". There is no need to flag these two states differently in LVM metadata, because they are already considered differently by the kernel RAID metadata. (Any activation/deactivation will properly resume the "recover" process and not a "resync" process.) We make this behavior change based on the presense of dm-raid target version 1.9.0+.
2017-06-14 16:33:42 +03:00
/*
* RAID_FEATURE_NEW_DEVICES_ACCEPT_REBUILD
* This signifies a behavioral change in dm-raid. Prior to upstream kernel
* commit 33e53f068, the kernel would refuse to allow 'rebuild' CTR args to
* be submitted when other devices in the array had uninitialized superblocks.
* After the commit, these parameters were allowed.
*
* The most obvious useful case of this new behavior is up-converting a
* linear device to RAID1. A new superblock is allocated for the linear dev
* and it will be uninitialized, while all the new images are specified for
* 'rebuild'. This valid scenario would not have been allowed prior to
* commit 33e53f068.
*
* Commit 33e53f068 did not bump the dm-raid version number. So it exists
* in some, but not all 1.8.1 versions of dm-raid. The only way to be
* certain the new behavior exists is to check for version 1.9.0.
*/
#define RAID_FEATURE_NEW_DEVICES_ACCEPT_REBUILD (1U << 6) /* version 1.9.0 */
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
make: fix compilation for undefined RAID_INTERNAL Reported-by: adamboardman of gemian
2021-09-24 18:36:29 +03:00
bool raid_is_available(const struct logical_volume *lv);
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
#ifdef RAID_INTERNAL
Fix raid shared lib segtype registration (2.02.87).
2011-08-24 17:41:46 +04:00
int init_raid_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
Add basic RAID segment type(s) support. Implementation described in doc/lvm2-raid.txt. Basic support includes: - ability to create RAID 1/4/5/6 arrays - ability to delete RAID arrays - ability to display RAID arrays Notable missing features (not included in this patch): - ability to clean-up/repair failures - ability to convert RAID segment types - ability to monitor RAID segment types
2011-08-03 02:07:20 +04:00
#endif
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
#define THIN_FEATURE_DISCARDS (1U << 0)
#define THIN_FEATURE_EXTERNAL_ORIGIN (1U << 1)
#define THIN_FEATURE_HELD_ROOT (1U << 2)
#define THIN_FEATURE_BLOCK_SIZE (1U << 3)
#define THIN_FEATURE_DISCARDS_NON_POWER_2 (1U << 4)
#define THIN_FEATURE_METADATA_RESIZE (1U << 5)
#define THIN_FEATURE_EXTERNAL_ORIGIN_EXTEND (1U << 6)
thin: errrorwhenfull support Support error_if_no_space feature for thin pools. Report more info about thinpool status: (out_of_data (D), metadata_read_only (M), failed (F) also as health attribute.)
2015-01-13 17:23:03 +03:00
#define THIN_FEATURE_ERROR_IF_NO_SPACE (1U << 7)
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
Add registration of thin_pool segment Register thin and thin_pool segment via multiple_segtypes.
2011-08-25 14:00:09 +04:00
#ifdef THIN_INTERNAL
int init_thin_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
#endif
cache: New 'cachepool' segment type This patch adds the new cachepool segment type - the first of two necessary to eventually create 'cache' logical volumes. In addition to the new segment type, updates to makefiles, configure files, the lv_segment struct, and some necessary libdevmapper flags. The cachepool is the LV and corresponding segment type that will hold all information pertinent to the cache itself - it's size, cachemode, cache policy, core arguments (like migration_threshold), etc.
2014-01-27 15:27:16 +04:00
#ifdef CACHE_INTERNAL
int init_cache_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
#endif
vdo: introduce segment types and manip functions Core functionality introducing lvm VDO support.
2018-06-29 12:11:14 +03:00
#ifdef VDO_INTERNAL
int init_vdo_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
#endif
vdo: support online rename New VDO targets v6.2.3 corrects support for online rename of VDO device. If needed if can be disable via new lvm.conf setting: vdo_disabled_features = [ "online_rename" ]
2021-01-21 23:18:05 +03:00
#define VDO_FEATURE_ONLINE_RENAME (1U << 0) /* version 6.2.3 */
vdo: support v4 kernel target line Check and use new available table line v4, if kernel supports it.
2022-07-09 00:35:06 +03:00
#define VDO_FEATURE_VERSION4 (1U << 1) /* version 8.2.0 */
vdo: support online rename New VDO targets v6.2.3 corrects support for online rename of VDO device. If needed if can be disable via new lvm.conf setting: vdo_disabled_features = [ "online_rename" ]
2021-01-21 23:18:05 +03:00
Add dm-writecache support dm-writecache is used like dm-cache with a standard LV as the cache. $ lvcreate -n main -L 128M -an foo /dev/loop0 $ lvcreate -n fast -L 32M -an foo /dev/pmem0 $ lvconvert --type writecache --cachepool fast foo/main $ lvs -a foo -o+devices LV VG Attr LSize Origin Devices [fast] foo -wi------- 32.00m /dev/pmem0(0) main foo Cwi------- 128.00m [main_wcorig] main_wcorig(0) [main_wcorig] foo -wi------- 128.00m /dev/loop0(0) $ lvchange -ay foo/main $ dmsetup table foo-main_wcorig: 0 262144 linear 7:0 2048 foo-main: 0 262144 writecache p 253:4 253:3 4096 0 foo-fast: 0 65536 linear 259:0 2048 $ lvchange -an foo/main $ lvconvert --splitcache foo/main $ lvs -a foo -o+devices LV VG Attr LSize Devices fast foo -wi------- 32.00m /dev/pmem0(0) main foo -wi------- 128.00m /dev/loop0(0)
2018-08-27 22:53:09 +03:00
int init_writecache_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
Allow dm-integrity to be used for raid images dm-integrity stores checksums of the data written to an LV, and returns an error if data read from the LV does not match the previously saved checksum. When used on raid images, dm-raid will correct the error by reading the block from another image, and the device user sees no error. The integrity metadata (checksums) are stored on an internal LV allocated by lvm for each linear image. The internal LV is allocated on the same PV as the image. Create a raid LV with an integrity layer over each raid image (for raid levels 1,4,5,6,10): lvcreate --type raidN --raidintegrity y [options] Add an integrity layer to images of an existing raid LV: lvconvert --raidintegrity y LV Remove the integrity layer from images of a raid LV: lvconvert --raidintegrity n LV Settings Use --raidintegritymode journal|bitmap (journal is default) to configure the method used by dm-integrity to ensure crash consistency. Initialization When integrity is added to an LV, the kernel needs to initialize the integrity metadata/checksums for all blocks in the LV. The data corruption checking performed by dm-integrity will only operate on areas of the LV that are already initialized. The progress of integrity initialization is reported by the "syncpercent" LV reporting field (and under the Cpy%Sync lvs column.) Example: create a raid1 LV with integrity: $ lvcreate --type raid1 -m1 --raidintegrity y -n rr -L1G foo Creating integrity metadata LV rr_rimage_0_imeta with size 12.00 MiB. Logical volume "rr_rimage_0_imeta" created. Creating integrity metadata LV rr_rimage_1_imeta with size 12.00 MiB. Logical volume "rr_rimage_1_imeta" created. Logical volume "rr" created. $ lvs -a foo LV VG Attr LSize Origin Cpy%Sync rr foo rwi-a-r--- 1.00g 4.93 [rr_rimage_0] foo gwi-aor--- 1.00g [rr_rimage_0_iorig] 41.02 [rr_rimage_0_imeta] foo ewi-ao---- 12.00m [rr_rimage_0_iorig] foo -wi-ao---- 1.00g [rr_rimage_1] foo gwi-aor--- 1.00g [rr_rimage_1_iorig] 39.45 [rr_rimage_1_imeta] foo ewi-ao---- 12.00m [rr_rimage_1_iorig] foo -wi-ao---- 1.00g [rr_rmeta_0] foo ewi-aor--- 4.00m [rr_rmeta_1] foo ewi-aor--- 4.00m
2019-11-21 01:07:27 +03:00
int init_integrity_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
cache: detect smq policy presence Add code to detect available cache features. Support policy_mq & policy_smq features which might be disabled. Introduce global_cache_disabled_features_CFG.
2015-07-23 12:32:09 +03:00
#define CACHE_FEATURE_POLICY_MQ (1U << 0)
#define CACHE_FEATURE_POLICY_SMQ (1U << 1)
cache: introduce allocation/cache_metadata_format Add new profilable configation setting to let user select which metadata format of a created cache pool he wish to use. By default the 'best' available format is autodetected at runtime, but user may enforce format 1 or 2 ATM. Code also detects availability for metadata2 supporting cache target. In case of troubles user may easily Disable usage of this feature by placing 'metadata2' into global/cache_disabled_features list.
2017-02-26 22:19:07 +03:00
#define CACHE_FEATURE_METADATA2 (1U << 2)
cache: detect smq policy presence Add code to detect available cache features. Support policy_mq & policy_smq features which might be disabled. Introduce global_cache_disabled_features_CFG.
2015-07-23 12:32:09 +03:00
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
#define SNAPSHOT_FEATURE_FIXED_LEAK (1U << 0) /* version 1.12 */
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
#ifdef SNAPSHOT_INTERNAL
struct segment_type *init_snapshot_segtype(struct cmd_context *cmd);
#endif
cleanup: relocate segment flags Move flags for segments to segtype header where it seems more closely related as the features are related to segtype and not activation. Use unsigned #define - since it's more common in lvm2 source code for bit flags.
2014-02-27 17:46:11 +04:00
#define MIRROR_LOG_CLUSTERED (1U << 0)
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
#ifdef MIRRORED_INTERNAL
struct segment_type *init_mirrored_segtype(struct cmd_context *cmd);
#endif
Rename old segtypes files to segtype.
2004-09-16 22:40:56 +04:00
#ifdef CRYPT_INTERNAL
struct segment_type *init_crypt_segtype(struct cmd_context *cmd);
#endif
Begin to separate out segment types.
2004-05-05 01:25:57 +04:00
#endif
Copy Permalink