Skip to contentSkip to conversation

lvm2app: Add thin and thin pool lv creation

PATCH Superseded M. Mohan Kumar 3 participants 8 messages Mar 19, 2013 – Apr 25, 2013

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

From: "M. Mohan Kumar" <[email protected]>

Add thin and thin pool lv creation support to lvm library

---
Changes from V3:
* Added paramater to specify metadata size, flags

Changes from V2:
* Specify percentage for low water mark threshold instead of number of blocks

Changes from previous version:
* Add support to specify data block size and low water mark thresold for newly created thin pool.

 lib/metadata/lv_manip.c          |   2 +-
 lib/metadata/metadata-exported.h |   1 +
 liblvm/lvm2app.h                 |  73 +++++++++++++++++++
 liblvm/lvm_lv.c                  | 154 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 229 insertions(+), 1 deletion(-)
lib/metadata/lv_manip.c +1 -1
index c1437eb..4dd5ebf 100644
@@ -4518,7 +4518,7 @@ static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, struct l
 		first_seg(lv)->chunk_size = lp->chunk_size;
 		first_seg(lv)->discards = lp->discards;
 		/* FIXME: use lowwatermark  via lvm.conf global for all thinpools ? */
-		first_seg(lv)->low_water_mark = 0;
+		first_seg(lv)->low_water_mark = lp->low_water_mark;
 	} else if (seg_is_thin_volume(lp)) {
 		pool_lv = first_seg(lv)->pool_lv;
 
lib/metadata/metadata-exported.h +1 -0
index ffec129..40519f5 100644
@@ -617,6 +617,7 @@ struct lvcreate_params {
 	uint64_t voriginsize; /* snapshot */
 	uint32_t poolmetadataextents; /* thin pool */
 	uint64_t poolmetadatasize; /* thin pool */
+	uint64_t low_water_mark;  /* thin_pool */
 	struct dm_list *pvh; /* all */
 
 	uint32_t permission; /* all */
liblvm/lvm2app.h +73 -0

79 lines not on this page · raw message

liblvm/lvm_lv.c +154 -0

157 lines not on this page · raw message

Signature · 1 line
1.7.11.7
#1 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Looked over the patch and have the following comments:

The patch has a warning when building. In the function lvm_lv_thinpool, the variable lwmb is unused and can be removed. The added functions don't verify all the parameters. We can't protect against everything, but I still think it would be good to check for NULL on the pointer arguments and non-zero length on strings?

Thanks,
Tony

Quoted 294 lines · M. Mohan Kumar

From: "M. Mohan Kumar" <[email protected]>

Add thin and thin pool lv creation support to lvm library

---
Changes from V3:
* Added paramater to specify metadata size, flags

Changes from V2:
* Specify percentage for low water mark threshold instead of number of blocks

Changes from previous version:
* Add support to specify data block size and low water mark thresold for newly created thin pool.

 lib/metadata/lv_manip.c          |   2 +-
 lib/metadata/metadata-exported.h |   1 +
 liblvm/lvm2app.h                 |  73 +++++++++++++++++++
 liblvm/lvm_lv.c                  | 154 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 229 insertions(+), 1 deletion(-)
lib/metadata/lv_manip.c +1 -1
index c1437eb..4dd5ebf 100644
@@ -4518,7 +4518,7 @@ static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, struct l
 		first_seg(lv)->chunk_size = lp->chunk_size;
 		first_seg(lv)->discards = lp->discards;
 		/* FIXME: use lowwatermark  via lvm.conf global for all thinpools ? */
-		first_seg(lv)->low_water_mark = 0;
+		first_seg(lv)->low_water_mark = lp->low_water_mark;
 	} else if (seg_is_thin_volume(lp)) {
 		pool_lv = first_seg(lv)->pool_lv;
 
lib/metadata/metadata-exported.h +1 -0
index ffec129..40519f5 100644
@@ -617,6 +617,7 @@ struct lvcreate_params {
 	uint64_t voriginsize; /* snapshot */
 	uint32_t poolmetadataextents; /* thin pool */
 	uint64_t poolmetadatasize; /* thin pool */
+	uint64_t low_water_mark;  /* thin_pool */
 	struct dm_list *pvh; /* all */
 
 	uint32_t permission; /* all */
liblvm/lvm2app.h +73 -0
index 93a78c3..0f8e39c 100644
@@ -1400,6 +1400,79 @@ int lvm_lv_resize(const lv_t lv, uint64_t new_size);
  */
 lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_size);
 
+
+#define THIN_FL_DISCARDS_IGNORE          0x0001
+#define THIN_FL_DISCARDS_NO_PASSDOWN     0x0010
+#define THIN_FL_SKIP_ZERO                0x0100
+
+/**
+ * Create a thinpool in a given VG
+ *
+ * \param   vg
+ * Volume Group handle.
+ *
+ * \param   pool_name
+ * Name of the pool.
+ *
+ * \param   size
+ * size of the pool
+ *
+ * \param   chunk_size
+ * data block size of the pool
+ * Default value is DEFAULT_THIN_POOL_CHUNK_SIZE * 2 when 0 passed as chunk_size
+ * DM_THIN_MIN_DATA_BLOCK_SIZE < chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE
+ *
+ * \param  threshold in percentage
+ * When percentage of free blocks in the pool reaches <= this thresold a dm
+ * event is sent. For example if threshold is specified 25, an dm event will be
+ * generated when the percentage of free blocks goes <= 25%.
+ *
+ * Note: when 0 is passed as threshold, an event will be generated only when all
+ * blocks are consumed in the pool.
+ *
+ * \param meta_size
+ * Size of thin pool's metadata logical volume. Allowed range is 2MB-16GB.
+ * Default value (ie if 0) pool size / pool chunk size * 64
+ *
+ * \param flags
+ * As of now supported flags are
+ * THIN_FL_DISCARDS_IGNORE,
+ * THIN_FL_DISCARDS_NO_PASSDOWN,
+ * THIN_FL_SKIP_ZERO
+ *
+ * If none of Discard related flag passed THIN_DISCARDS_PASSDOWN is enabled.
+ *
+ * \return
+ * Valid lv pointer on success, else NULL on error.
+ *
+ */
+lv_t lvm_lv_thinpool(const vg_t vg, const char *pool_name, uint64_t size,
+		     uint32_t chunk_size, uint64_t meta_size, int threshold,
+		     int flags);
+
+/**
+ * Create a thin LV in a given VG & thin pool
+ *
+ * \param   vg
+ * Volume Group handle.
+ *
+ * \param   pool_name
+ * Name of the pool.
+ *
+ * \param lvname
+ * Name of the LV to create
+ *
+ * \param   size
+ * Size of logical volume
+ *
+ * \return
+ * Valid lv pointer on success, else NULL on error.
+ *
+ */
+
+lv_t lvm_lv_thin(const vg_t vg, const char *pool_name, const char *lvname,
+		uint64_t size);
+
 /************************** physical volume handling ************************/
 
 /**
liblvm/lvm_lv.c +154 -0
index 91948a6..d4645f4 100644
@@ -350,3 +350,157 @@ lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_siz
 		return NULL;
 	return (lv_t) lvl->lv;
 }
+
+/* Set defaults for thin pool specific LV parameters */
+static void _lv_set_pool_params(struct lvcreate_params *lp,
+				vg_t vg, const char *pool,
+				uint64_t extents, uint64_t meta_size)
+{
+	_lv_set_default_params(lp, vg, NULL, extents);
+
+	lp->pool = pool;
+
+	lp->create_thin_pool = 1;
+	lp->segtype = get_segtype_from_string(vg->cmd, "thin-pool");
+	lp->stripes = 1;
+
+	if (!meta_size) {
+		lp->poolmetadatasize = extents * vg->extent_size /
+			(lp->chunk_size * (SECTOR_SIZE / 64));
+		while ((lp->poolmetadatasize >
+			(2 * DEFAULT_THIN_POOL_OPTIMAL_SIZE / SECTOR_SIZE)) &&
+		       lp->chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE) {
+			lp->chunk_size <<= 1;
+			lp->poolmetadatasize >>= 1;
+	         }
+	} else
+		lp->poolmetadatasize = meta_size;
+
+	if (lp->poolmetadatasize % vg->extent_size)
+		lp->poolmetadatasize +=
+			vg->extent_size - lp->poolmetadatasize % vg->extent_size;
+
+	lp->poolmetadataextents =
+		extents_from_size(vg->cmd, lp->poolmetadatasize / SECTOR_SIZE,
+						   vg->extent_size);
+}
+
+lv_t lvm_lv_thinpool(const vg_t vg, const char *pool, uint64_t size,
+		     uint32_t chunk_size, uint64_t meta_size, int threshold,
+		     int flags)
+{
+	struct lvcreate_params lp = { 0 };
+	uint64_t extents = 0;
+	struct lv_list *lvl = NULL;
+	uint64_t lwmb = 0;
+
+	if (meta_size > (2 * DEFAULT_THIN_POOL_MAX_METADATA_SIZE)) {
+		log_error("Invalid metadata size");
+		return NULL;
+	}
+
+	if (meta_size &&
+	    meta_size < (2 * DEFAULT_THIN_POOL_MIN_METADATA_SIZE)) {
+		log_error("Invalid metadata size");
+		return NULL;
+	}
+
+	if (vg_read_error(vg))
+		return NULL;
+
+	if (!vg_check_write_mode(vg))
+		return NULL;
+
+	if (threshold < 0 || threshold > 100) {
+		log_error("Invalid threshold, should be between 0-100");
+		return NULL;
+	}
+	if (!(extents = extents_from_size(vg->cmd, size / SECTOR_SIZE,
+					  vg->extent_size))) {
+		log_error("Unable to create LV thin pool without size.");
+		return NULL;
+	}
+
+	if (flags & THIN_FL_DISCARDS_NO_PASSDOWN)
+		lp.discards = THIN_DISCARDS_NO_PASSDOWN;
+	else if (flags & THIN_FL_DISCARDS_IGNORE)
+		lp.discards = THIN_DISCARDS_IGNORE;
+	else
+		lp.discards = THIN_DISCARDS_PASSDOWN;
+
+	if (chunk_size)
+		lp.chunk_size = chunk_size;
+	else
+		lp.chunk_size = DEFAULT_THIN_POOL_CHUNK_SIZE * 2;
+
+	if (lp.chunk_size < DM_THIN_MIN_DATA_BLOCK_SIZE ||
+	    lp.chunk_size > DM_THIN_MAX_DATA_BLOCK_SIZE) {
+		log_error("Invalid chunk_size");
+		return NULL;
+	}
+
+	_lv_set_pool_params(&lp, vg, pool, extents, meta_size);
+
+	if (flags & THIN_FL_SKIP_ZERO)
+		lp.zero = 0;
+	/*
+	  threshold specified in percentage, convert that into
+	  number of blocks
+	*/
+	lp.low_water_mark = size / (chunk_size * SECTOR_SIZE) * threshold / 100;
+	if (!lp.segtype)
+		return_NULL;
+	if (!lv_create_single(vg, &lp))
+		return_NULL;
+	if (!(lvl = find_lv_in_vg(vg, pool)))
+		return_NULL;
+	return (lv_t) lvl->lv;
+}
+
+/* Set defaults for thin LV specific parameters */
+static void _lv_set_thin_params(struct lvcreate_params *lp,
+				vg_t vg, const char *pool,
+				const char *lvname,
+				uint64_t extents)
+{
+	_lv_set_default_params(lp, vg, lvname, extents);
+
+	lp->thin = 1;
+	lp->pool = pool;
+	lp->segtype = get_segtype_from_string(vg->cmd, "thin");
+
+	lp->voriginsize = extents * vg->extent_size;
+	lp->voriginextents = extents_from_size(vg->cmd, lp->voriginsize,
+						   vg->extent_size);
+
+	lp->stripes = 1;
+}
+
+lv_t lvm_lv_thin(const vg_t vg, const char *pool,
+		 const char *lvname, uint64_t size)
+{
+	struct lvcreate_params lp = { 0 };
+	uint64_t extents = 0;
+	struct lv_list *lvl = NULL;
+
+	if (vg_read_error(vg))
+		return NULL;
+	if (!vg_check_write_mode(vg))
+		return NULL;
+
+	if (!(extents = extents_from_size(vg->cmd, size / SECTOR_SIZE,
+					  vg->extent_size))) {
+		log_error("Unable to create thin LV without size.");
+		return NULL;
+	}
+
+	_lv_set_thin_params(&lp, vg, pool, lvname, extents);
+
+	if (!lp.segtype)
+		return_NULL;
+	if (!lv_create_single(vg, &lp))
+		return_NULL;
+	if (!(lvl = find_lv_in_vg(vg, pool)))
+		return_NULL;
+	return (lv_t) lvl->lv;
+}
#2 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Quoted 8 lines · Tony Asleson

Looked over the patch and have the following comments:

The patch has a warning when building. In the function lvm_lv_thinpool, the variable lwmb is unused and can be removed. The added functions don't verify all the parameters. We can't protect against everything, but I still think it would be good to check for NULL on the pointer arguments and non-zero length on strings?

Thanks Tony for the review. If the lvname parameter is NULL, lvm-library chooses a unique for the new LV. IMHO pool name and vg needs to be checked against NULL.

If Zdenek is ok with this approach, I can send a V5 with this parameter checking and removing unused variable. Zdenek?

Quoted 297 lines · M. Mohan Kumar
Quoted 294 lines

From: "M. Mohan Kumar" <[email protected]>

Add thin and thin pool lv creation support to lvm library

---
Changes from V3:
* Added paramater to specify metadata size, flags

Changes from V2:
* Specify percentage for low water mark threshold instead of number of blocks

Changes from previous version:
* Add support to specify data block size and low water mark thresold for newly created thin pool.

 lib/metadata/lv_manip.c          |   2 +-
 lib/metadata/metadata-exported.h |   1 +
 liblvm/lvm2app.h                 |  73 +++++++++++++++++++
 liblvm/lvm_lv.c                  | 154 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 229 insertions(+), 1 deletion(-)
lib/metadata/lv_manip.c +1 -1
index c1437eb..4dd5ebf 100644
@@ -4518,7 +4518,7 @@ static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, struct l
 		first_seg(lv)->chunk_size = lp->chunk_size;
 		first_seg(lv)->discards = lp->discards;
 		/* FIXME: use lowwatermark  via lvm.conf global for all thinpools ? */
-		first_seg(lv)->low_water_mark = 0;
+		first_seg(lv)->low_water_mark = lp->low_water_mark;
 	} else if (seg_is_thin_volume(lp)) {
 		pool_lv = first_seg(lv)->pool_lv;
 
lib/metadata/metadata-exported.h +1 -0
index ffec129..40519f5 100644
@@ -617,6 +617,7 @@ struct lvcreate_params {
 	uint64_t voriginsize; /* snapshot */
 	uint32_t poolmetadataextents; /* thin pool */
 	uint64_t poolmetadatasize; /* thin pool */
+	uint64_t low_water_mark;  /* thin_pool */
 	struct dm_list *pvh; /* all */
 
 	uint32_t permission; /* all */
liblvm/lvm2app.h +73 -0
index 93a78c3..0f8e39c 100644
@@ -1400,6 +1400,79 @@ int lvm_lv_resize(const lv_t lv, uint64_t new_size);
  */
 lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_size);
 
+
+#define THIN_FL_DISCARDS_IGNORE          0x0001
+#define THIN_FL_DISCARDS_NO_PASSDOWN     0x0010
+#define THIN_FL_SKIP_ZERO                0x0100
+
+/**
+ * Create a thinpool in a given VG
+ *
+ * \param   vg
+ * Volume Group handle.
+ *
+ * \param   pool_name
+ * Name of the pool.
+ *
+ * \param   size
+ * size of the pool
+ *
+ * \param   chunk_size
+ * data block size of the pool
+ * Default value is DEFAULT_THIN_POOL_CHUNK_SIZE * 2 when 0 passed as chunk_size
+ * DM_THIN_MIN_DATA_BLOCK_SIZE < chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE
+ *
+ * \param  threshold in percentage
+ * When percentage of free blocks in the pool reaches <= this thresold a dm
+ * event is sent. For example if threshold is specified 25, an dm event will be
+ * generated when the percentage of free blocks goes <= 25%.
+ *
+ * Note: when 0 is passed as threshold, an event will be generated only when all
+ * blocks are consumed in the pool.
+ *
+ * \param meta_size
+ * Size of thin pool's metadata logical volume. Allowed range is 2MB-16GB.
+ * Default value (ie if 0) pool size / pool chunk size * 64
+ *
+ * \param flags
+ * As of now supported flags are
+ * THIN_FL_DISCARDS_IGNORE,
+ * THIN_FL_DISCARDS_NO_PASSDOWN,
+ * THIN_FL_SKIP_ZERO
+ *
+ * If none of Discard related flag passed THIN_DISCARDS_PASSDOWN is enabled.
+ *
+ * \return
+ * Valid lv pointer on success, else NULL on error.
+ *
+ */
+lv_t lvm_lv_thinpool(const vg_t vg, const char *pool_name, uint64_t size,
+		     uint32_t chunk_size, uint64_t meta_size, int threshold,
+		     int flags);
+
+/**
+ * Create a thin LV in a given VG & thin pool
+ *
+ * \param   vg
+ * Volume Group handle.
+ *
+ * \param   pool_name
+ * Name of the pool.
+ *
+ * \param lvname
+ * Name of the LV to create
+ *
+ * \param   size
+ * Size of logical volume
+ *
+ * \return
+ * Valid lv pointer on success, else NULL on error.
+ *
+ */
+
+lv_t lvm_lv_thin(const vg_t vg, const char *pool_name, const char *lvname,
+		uint64_t size);
+
 /************************** physical volume handling ************************/
 
 /**
liblvm/lvm_lv.c +154 -0
index 91948a6..d4645f4 100644
@@ -350,3 +350,157 @@ lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_siz
 		return NULL;
 	return (lv_t) lvl->lv;
 }
+
+/* Set defaults for thin pool specific LV parameters */
+static void _lv_set_pool_params(struct lvcreate_params *lp,
+				vg_t vg, const char *pool,
+				uint64_t extents, uint64_t meta_size)
+{
+	_lv_set_default_params(lp, vg, NULL, extents);
+
+	lp->pool = pool;
+
+	lp->create_thin_pool = 1;
+	lp->segtype = get_segtype_from_string(vg->cmd, "thin-pool");
+	lp->stripes = 1;
+
+	if (!meta_size) {
+		lp->poolmetadatasize = extents * vg->extent_size /
+			(lp->chunk_size * (SECTOR_SIZE / 64));
+		while ((lp->poolmetadatasize >
+			(2 * DEFAULT_THIN_POOL_OPTIMAL_SIZE / SECTOR_SIZE)) &&
+		       lp->chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE) {
+			lp->chunk_size <<= 1;
+			lp->poolmetadatasize >>= 1;
+	         }
+	} else
+		lp->poolmetadatasize = meta_size;
+
+	if (lp->poolmetadatasize % vg->extent_size)
+		lp->poolmetadatasize +=
+			vg->extent_size - lp->poolmetadatasize % vg->extent_size;
+
+	lp->poolmetadataextents =
+		extents_from_size(vg->cmd, lp->poolmetadatasize / SECTOR_SIZE,
+						   vg->extent_size);
+}
+
+lv_t lvm_lv_thinpool(const vg_t vg, const char *pool, uint64_t size,
+		     uint32_t chunk_size, uint64_t meta_size, int threshold,
+		     int flags)
+{
+	struct lvcreate_params lp = { 0 };
+	uint64_t extents = 0;
+	struct lv_list *lvl = NULL;
+	uint64_t lwmb = 0;
+
+	if (meta_size > (2 * DEFAULT_THIN_POOL_MAX_METADATA_SIZE)) {
+		log_error("Invalid metadata size");
+		return NULL;
+	}
+
+	if (meta_size &&
+	    meta_size < (2 * DEFAULT_THIN_POOL_MIN_METADATA_SIZE)) {
+		log_error("Invalid metadata size");
+		return NULL;
+	}
+
+	if (vg_read_error(vg))
+		return NULL;
+
+	if (!vg_check_write_mode(vg))
+		return NULL;
+
+	if (threshold < 0 || threshold > 100) {
+		log_error("Invalid threshold, should be between 0-100");
+		return NULL;
+	}
+	if (!(extents = extents_from_size(vg->cmd, size / SECTOR_SIZE,
+					  vg->extent_size))) {
+		log_error("Unable to create LV thin pool without size.");
+		return NULL;
+	}
+
+	if (flags & THIN_FL_DISCARDS_NO_PASSDOWN)
+		lp.discards = THIN_DISCARDS_NO_PASSDOWN;
+	else if (flags & THIN_FL_DISCARDS_IGNORE)
+		lp.discards = THIN_DISCARDS_IGNORE;
+	else
+		lp.discards = THIN_DISCARDS_PASSDOWN;
+
+	if (chunk_size)
+		lp.chunk_size = chunk_size;
+	else
+		lp.chunk_size = DEFAULT_THIN_POOL_CHUNK_SIZE * 2;
+
+	if (lp.chunk_size < DM_THIN_MIN_DATA_BLOCK_SIZE ||
+	    lp.chunk_size > DM_THIN_MAX_DATA_BLOCK_SIZE) {
+		log_error("Invalid chunk_size");
+		return NULL;
+	}
+
+	_lv_set_pool_params(&lp, vg, pool, extents, meta_size);
+
+	if (flags & THIN_FL_SKIP_ZERO)
+		lp.zero = 0;
+	/*
+	  threshold specified in percentage, convert that into
+	  number of blocks
+	*/
+	lp.low_water_mark = size / (chunk_size * SECTOR_SIZE) * threshold / 100;
+	if (!lp.segtype)
+		return_NULL;
+	if (!lv_create_single(vg, &lp))
+		return_NULL;
+	if (!(lvl = find_lv_in_vg(vg, pool)))
+		return_NULL;
+	return (lv_t) lvl->lv;
+}
+
+/* Set defaults for thin LV specific parameters */
+static void _lv_set_thin_params(struct lvcreate_params *lp,
+				vg_t vg, const char *pool,
+				const char *lvname,
+				uint64_t extents)
+{
+	_lv_set_default_params(lp, vg, lvname, extents);
+
+	lp->thin = 1;
+	lp->pool = pool;
+	lp->segtype = get_segtype_from_string(vg->cmd, "thin");
+
+	lp->voriginsize = extents * vg->extent_size;
+	lp->voriginextents = extents_from_size(vg->cmd, lp->voriginsize,
+						   vg->extent_size);
+
+	lp->stripes = 1;
+}
+
+lv_t lvm_lv_thin(const vg_t vg, const char *pool,
+		 const char *lvname, uint64_t size)
+{
+	struct lvcreate_params lp = { 0 };
+	uint64_t extents = 0;
+	struct lv_list *lvl = NULL;
+
+	if (vg_read_error(vg))
+		return NULL;
+	if (!vg_check_write_mode(vg))
+		return NULL;
+
+	if (!(extents = extents_from_size(vg->cmd, size / SECTOR_SIZE,
+					  vg->extent_size))) {
+		log_error("Unable to create thin LV without size.");
+		return NULL;
+	}
+
+	_lv_set_thin_params(&lp, vg, pool, lvname, extents);
+
+	if (!lp.segtype)
+		return_NULL;
+	if (!lv_create_single(vg, &lp))
+		return_NULL;
+	if (!(lvl = find_lv_in_vg(vg, pool)))
+		return_NULL;
+	return (lv_t) lvl->lv;
+}
#3 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Dne 12.4.2013 14:25, M. Mohan Kumar napsal(a):

Quoted 10 lines
Quoted 8 lines · Tony Asleson

Looked over the patch and have the following comments:

The patch has a warning when building. In the function lvm_lv_thinpool, the variable lwmb is unused and can be removed. The added functions don't verify all the parameters. We can't protect against everything, but I still think it would be good to check for NULL on the pointer arguments and non-zero length on strings?

Quoted 6 lines

Thanks Tony for the review. If the lvname parameter is NULL, lvm-library chooses a unique for the new LV. IMHO pool name and vg needs to be checked against NULL.

If Zdenek is ok with this approach, I can send a V5 with this parameter checking and removing unused variable. Zdenek?

I'll not agree with anything exposing low_water_mark.

This is currently 'private' code for liblvm with not yet properly defined usage - thus there is no point in exposing this value to lvm2api.

Quoted 49 lines
Quoted 49 lines
Quoted 49 lines

/* FIXME: use lowwatermark via lvm.conf global for all thinpools ? */

lib/metadata/lv_manip.c +1 -1
-		first_seg(lv)->low_water_mark = 0;
+		first_seg(lv)->low_water_mark = lp->low_water_mark;
  	} else if (seg_is_thin_volume(lp)) {
  		pool_lv = first_seg(lv)->pool_lv;
 
 
  	uint32_t permission; /* all */
liblvm/lvm2app.h +31 -0
index 93a78c3..0f8e39c 100644
@@ -1400,6 +1400,79 @@ int lvm_lv_resize(const lv_t lv, uint64_t new_size);
   */
  lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_size);
 
+
+#define THIN_FL_DISCARDS_IGNORE          0x0001
+#define THIN_FL_DISCARDS_NO_PASSDOWN     0x0010
+#define THIN_FL_SKIP_ZERO                0x0100
 
 
+
+/**
+ * Create a thinpool in a given VG
+ *
+ * \param   vg
+ * Volume Group handle.
+ *
+ * \param   pool_name
+ * Name of the pool.
+ *
+ * \param   size
+ * size of the pool
+ *
+ * \param   chunk_size
+ * data block size of the pool
+ * Default value is DEFAULT_THIN_POOL_CHUNK_SIZE * 2 when 0 passed as chunk_size
+ * DM_THIN_MIN_DATA_BLOCK_SIZE < chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE
+ *
+ * \param  threshold in percentage
+ * When percentage of free blocks in the pool reaches <= this thresold a dm
+ * event is sent. For example if threshold is specified 25, an dm event will be
+ * generated when the percentage of free blocks goes <= 25%.
+ *
+ * Note: when 0 is passed as threshold, an event will be generated only when all
+ * blocks are consumed in the pool.
+ *
+ * \param meta_size
Quoted 8 lines
Quoted 8 lines

liblvm/lvm2app.h int lvm_lv_resize(const lv_t lv, uint64_t new_size); · line 1441

Quoted 8 lines
liblvm/lvm2app.h +8 -0
+ * Size of thin pool's metadata logical volume. Allowed range is 2MB-16GB.
+ * Default value (ie if 0) pool size / pool chunk size * 64
+ *
+ * \param flags
+ * As of now supported flags are
+ * THIN_FL_DISCARDS_IGNORE,
+ * THIN_FL_DISCARDS_NO_PASSDOWN,
+ * THIN_FL_SKIP_ZERO

These are unrelated - they should not be passed in as bit flag,

We really need here separate type of object to set all properties for thin. (Since their amount will grow over the time) so you can't solve with any bit field - this is not extensible.

We need to create 'object' with properties, that can be controled in C++ like way - so we may extend it in future easily, without breaking API, and leaving 'old' unusable calls in the library.

Zdenek

#4 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Quoted 1 line · Zdenek Kabelac

We really need here separate type of object to set all properties for

thin.

Quoted 7 lines

(Since their amount will grow over the time) so you can't solve with any bit field - this is not extensible.

We need to create 'object' with properties, that can be controled in C++ like way - so we may extend it in future easily, without breaking API, and leaving
'old' unusable calls in the library.

I will take a swag at something early next week and post for people to review. We need to get something in soon so that people can utilize the new thinp stuff.

-Tony

#5 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Quoted 6 lines · Tony Asleson
Quoted 1 line · Zdenek Kabelac

We really need here separate type of object to set all properties for

thin.

Quoted 3 lines

(Since their amount will grow over the time) so you can't solve with any bit field - this is not extensible.

Quoted 8 lines
Quoted 4 lines

We need to create 'object' with properties, that can be controled in C++ like way - so we may extend it in future easily, without breaking API, and leaving
'old' unusable calls in the library.

I will take a swag at something early next week and post for people to review. We need to get something in soon so that people can utilize the new thinp stuff.

Mohan, I'm having difficultly getting your patch to apply at the moment.
I wanted to use it as the basis of this work. Would you have time to
update your patch against head?

I was going to create a new opaque type, create a base initialize function and then add get/set functions for items you have. This would then become the parameter to feed into the thinp functions. I was going to omit the low water mark for now.

I don't know off hand what all the possible parameters for the thin pool creation vs. the thin lv creation, but from the patch it looks like thus far there are more parameters when creating the thin pool? Do we need opaque parameters for the thin pool creation and the thin logical volume creation?

You are more than welcome to take a pass at this too if you have the bandwidth :-)

Thanks,
Tony

#6 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Quoted 25 lines · Tony Asleson
Quoted 6 lines · Tony Asleson
Quoted 1 line · Zdenek Kabelac

We really need here separate type of object to set all properties for

thin.

Quoted 3 lines

(Since their amount will grow over the time) so you can't solve with any bit field - this is not extensible.

Quoted 8 lines
Quoted 4 lines

We need to create 'object' with properties, that can be controled in C++ like way - so we may extend it in future easily, without breaking API, and leaving
'old' unusable calls in the library.

I will take a swag at something early next week and post for people to review. We need to get something in soon so that people can utilize the new thinp stuff.

Mohan, I'm having difficultly getting your patch to apply at the moment.
I wanted to use it as the basis of this work. Would you have time to
update your patch against head?

I was going to create a new opaque type, create a base initialize function and then add get/set functions for items you have. This would then become the parameter to feed into the thinp functions. I was going to omit the low water mark for now.

Quoted 5 lines

I don't know off hand what all the possible parameters for the thin pool creation vs. the thin lv creation, but from the patch it looks like thus far there are more parameters when creating the thin pool? Do we need opaque parameters for the thin pool creation and the thin logical volume creation?

As per Zdenek, thin LV snapshot can be created from a non thin LV also. Should thin_lv_creation API support this feature also?

Quoted 4 lines

You are more than welcome to take a pass at this too if you have the bandwidth :-)

Tony, here is the rebased patch.

From: "M. Mohan Kumar" <[email protected]>
Date: Thu, 31 Jan 2013 16:36:32 +0530
Subject: [PATCH] lvm2app: Add thin and thin pool lv creation

Add thin and thin pool lv creation support to lvm library

---
Rebased on top of commit 2ccb9eb861c3b65ffc1aac024425e2cc10950077

 lib/metadata/lv_manip.c          |   2 +-
 lib/metadata/metadata-exported.h |   1 +
 liblvm/lvm2app.h                 |  73 +++++++++++++++++++
 liblvm/lvm_lv.c                  | 154 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 229 insertions(+), 1 deletion(-)
lib/metadata/lv_manip.c +1 -1
index fc316e8..b1045b2 100644
@@ -4683,7 +4683,7 @@ static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, struct l
 		first_seg(lv)->chunk_size = lp->chunk_size;
 		first_seg(lv)->discards = lp->discards;
 		/* FIXME: use lowwatermark  via lvm.conf global for all thinpools ? */
-		first_seg(lv)->low_water_mark = 0;
+		first_seg(lv)->low_water_mark = lp->low_water_mark;
 	} else if (seg_is_thin_volume(lp)) {
 		pool_lv = first_seg(lv)->pool_lv;
 		if (!(first_seg(lv)->device_id =
lib/metadata/metadata-exported.h +1 -0
index a4ffe26..cc5b5e8 100644
@@ -640,6 +640,7 @@ struct lvcreate_params {
 	uint64_t voriginsize; /* snapshot */
 	uint32_t poolmetadataextents; /* thin pool */
 	uint64_t poolmetadatasize; /* thin pool */
+	uint64_t low_water_mark;  /* thin_pool */
 	struct dm_list *pvh; /* all */
 
 	uint32_t permission; /* all */
liblvm/lvm2app.h +73 -0

79 lines not on this page · raw message

liblvm/lvm_lv.c +154 -0

157 lines not on this page · raw message

Signature · 1 line
1.7.11.7
#7 lore raw

PATCH v4 1/1 lvm2app: Add thin and thin pool lv creation

Quoted 2 lines · M. Mohan Kumar

As per Zdenek, thin LV snapshot can be created from a non thin LV also. Should thin_lv_creation API support this feature also?

Eventually the API should support everything :-) Lets try to get the thin pool, thin logical volume creation worked out and then we can take a look at this.

Quoted 1 line

Tony, here is the rebased patch.

Thanks!

-Tony