WHATS_NEW                      |  4 ++++

 WHATS_NEW_DM                   |  4 ++++

 device_mapper/all.h            |  1 +

 device_mapper/libdm-deptree.c  | 16 ++++++++-----

 device_mapper/vdo/target.h     | 15 ++++++------

 device_mapper/vdo/vdo_limits.h |  7 ++++--

 device_mapper/vdo/vdo_target.c | 20 +++++++++++-----

 lib/config/config_settings.h   | 54 ++++++++++++++++++++++++------------------

 lib/config/defaults.h          |  8 +++----

 lib/metadata/vdo_manip.c       | 16 ++++++-------

 lib/vdo/vdo.c                  | 44 +++++++++++++++++-----------------

 11 files changed, 110 insertions(+), 79 deletions(-)

diff --git a/WHATS_NEW b/WHATS_NEW

index 9cdc70e..4f752fa 100644

--- a/WHATS_NEW

+++ b/WHATS_NEW

@@ -1,3 +1,7 @@

+Version 2.03.03 - 

+====================================

+  Move VDO support towards V2 target (6.2) support.

+

 Version 2.03.02 - 18th December 2018

 ====================================

   Fix missing proper initialization of pv_list struct when adding pv.

diff --git a/WHATS_NEW_DM b/WHATS_NEW_DM

index 8fe5010..24148d8 100644

--- a/WHATS_NEW_DM

+++ b/WHATS_NEW_DM

@@ -1,3 +1,7 @@

+Version 1.02.157 - 

+=====================================

+  Fix compilation of vdo status parsing in dmeventd.

+

 Version 1.02.155 - 18th December 2018

 =====================================

   Include correct internal header inside libdm list.c.

diff --git a/device_mapper/all.h b/device_mapper/all.h

index 2c452ab..b9a7a90 100644

--- a/device_mapper/all.h

+++ b/device_mapper/all.h

@@ -924,6 +924,7 @@ int dm_tree_node_add_cache_target(struct dm_tree_node *node,

 int dm_tree_node_add_vdo_target(struct dm_tree_node *node,

 				uint64_t size,

 				const char *data_uuid,

+				uint64_t data_size,

 				const struct dm_vdo_target_params *param);

 /*

diff --git a/device_mapper/libdm-deptree.c b/device_mapper/libdm-deptree.c

index d3a5c27..ed96378 100644

--- a/device_mapper/libdm-deptree.c

+++ b/device_mapper/libdm-deptree.c

@@ -207,6 +207,7 @@ struct load_segment {

 	struct dm_tree_node *vdo_data;  /* VDO */

 	struct dm_vdo_target_params vdo_params; /* VDO */

 	const char *vdo_name;           /* VDO - device name is ALSO passed as table arg */

+	uint64_t vdo_data_size;		/* VDO - size of data storage device */

 };

 /* Per-device properties */

@@ -2647,17 +2648,18 @@ static int _vdo_emit_segment_line(struct dm_task *dmt,

 		return 0;

 	}

-	EMIT_PARAMS(pos, "%s %u %s " FMTu64 " " FMTu64 " %u on %s %s "

-		    "ack=%u,bio=%u,bioRotationInterval=%u,cpu=%u,hash=%u,logical=%u,physical=%u",

+	EMIT_PARAMS(pos, "V2 %s " FMTu64 " %u " FMTu64 " %u %s %s %s "

+		    "maxDiscard %u ack %u bio %u bioRotationInterval %u cpu %u hash %u logical %u physical %u",

 		    data_dev,

-		    (seg->vdo_params.emulate_512_sectors == 0) ? 4096 : 512,

-		    seg->vdo_params.use_read_cache ? "enabled" : "disabled",

-		    seg->vdo_params.read_cache_size_mb * UINT64_C(256),		// 1MiB -> 4KiB units

+		    seg->vdo_data_size / 8, // this parameter is in 4K units

+		    seg->vdo_params.minimum_io_size,

 		    seg->vdo_params.block_map_cache_size_mb * UINT64_C(256),	// 1MiB -> 4KiB units

-		    seg->vdo_params.block_map_period,

+		    seg->vdo_params.block_map_era_length,

+		    seg->vdo_params.use_metadata_hints ? "on" : "off" ,

 		    (seg->vdo_params.write_policy == DM_VDO_WRITE_POLICY_SYNC) ? "sync" :

 			(seg->vdo_params.write_policy == DM_VDO_WRITE_POLICY_ASYNC) ? "async" : "auto", // policy

 		    seg->vdo_name,

+		    seg->vdo_params.max_discard,

 		    seg->vdo_params.ack_threads,

 		    seg->vdo_params.bio_threads,

 		    seg->vdo_params.bio_rotation,

@@ -4034,6 +4036,7 @@ int dm_tree_node_add_cache_target_base(struct dm_tree_node *node,

 int dm_tree_node_add_vdo_target(struct dm_tree_node *node,

 				uint64_t size,

 				const char *data_uuid,

+				uint64_t data_size,

 				const struct dm_vdo_target_params *vtp)

 {

 	struct load_segment *seg;

@@ -4054,6 +4057,7 @@ int dm_tree_node_add_vdo_target(struct dm_tree_node *node,

 	seg->vdo_params = *vtp;

 	seg->vdo_name = node->name;

+	seg->vdo_data_size = data_size;

 	node->props.send_messages = 2;

diff --git a/device_mapper/vdo/target.h b/device_mapper/vdo/target.h

index c597491..f83cffd 100644

--- a/device_mapper/vdo/target.h

+++ b/device_mapper/vdo/target.h

@@ -74,16 +74,16 @@ enum dm_vdo_write_policy {

 // FIXME: review whether we should use the createParams from the userlib

 struct dm_vdo_target_params {

+	uint32_t minimum_io_size;

 	uint32_t block_map_cache_size_mb;

-	uint32_t block_map_period;

+	uint32_t block_map_era_length;	// format period

 	uint32_t check_point_frequency;

-	uint32_t index_memory_size_mb;

+	uint32_t index_memory_size_mb;  // format

-	uint32_t read_cache_size_mb;

-

-	uint32_t slab_size_mb;

+	uint32_t slab_size_mb;          // format

+	uint32_t max_discard;

 	// threads

 	uint32_t ack_threads;

 	uint32_t bio_threads;

@@ -95,9 +95,8 @@ struct dm_vdo_target_params {

 	bool use_compression;

 	bool use_deduplication;

-	bool emulate_512_sectors;

-	bool use_sparse_index;

-	bool use_read_cache;

+	bool use_metadata_hints;

+	bool use_sparse_index;          // format

 	// write policy

 	enum dm_vdo_write_policy write_policy;

diff --git a/device_mapper/vdo/vdo_limits.h b/device_mapper/vdo/vdo_limits.h

index 40cf204..e145100 100644

--- a/device_mapper/vdo/vdo_limits.h

+++ b/device_mapper/vdo/vdo_limits.h

@@ -21,8 +21,8 @@

 #define DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB	(16 * 1024 * 1024 - 1)	// 16TiB - 1

 #define DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_PER_LOGICAL_THREAD  (4096 * DM_VDO_BLOCK_SIZE_KB)

-#define DM_VDO_BLOCK_MAP_PERIOD_MINIMUM		1

-#define DM_VDO_BLOCK_MAP_PERIOD_MAXIMUM		(16380)

+#define DM_VDO_BLOCK_MAP_ERA_LENGTH_MINIMUM	(1)

+#define DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM	(16380)

 #define DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB	(256)			// 0.25 GiB

 #define DM_VDO_INDEX_MEMORY_SIZE_MAXIMUM_MB	(1024 * 1024 * 1024)	// 1TiB

@@ -57,4 +57,7 @@

 //#define DM_VDO_PHYSICAL_THREADS_MINIMUM	(0)

 #define DM_VDO_PHYSICAL_THREADS_MAXIMUM		(16)

+#define DM_VDO_MAX_DISCARD_MINIMUM		(1)

+#define DM_VDO_MAX_DISCARD_MAXIMUM		(UINT32_MAX / 4096)

+

 #endif // DEVICE_MAPPER_VDO_LIMITS_H

diff --git a/device_mapper/vdo/vdo_target.c b/device_mapper/vdo/vdo_target.c

index c488023..976d71a 100644

--- a/device_mapper/vdo/vdo_target.c

+++ b/device_mapper/vdo/vdo_target.c

@@ -23,6 +23,13 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,

 {

 	bool valid = true;

+	if ((vtp->minimum_io_size != 512) &&

+	    (vtp->minimum_io_size != 4096)) {

+		log_error("VDO minimum io size %u is unsupported.",

+			  vtp->minimum_io_size);

+		valid = false;

+	}

+

 	if ((vtp->block_map_cache_size_mb < DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB) ||

 	    (vtp->block_map_cache_size_mb > DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB)) {

 		log_error("VDO block map cache size %u out of range.",

@@ -37,12 +44,6 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,

 		valid = false;

 	}

-	if (vtp->read_cache_size_mb > DM_VDO_READ_CACHE_SIZE_MAXIMUM_MB) {

-		log_error("VDO read cache size %u out of range.",

-			  vtp->read_cache_size_mb);

-		valid = false;

-	}

-

 	if ((vtp->slab_size_mb < DM_VDO_SLAB_SIZE_MINIMUM_MB) ||

 	    (vtp->slab_size_mb > DM_VDO_SLAB_SIZE_MAXIMUM_MB)) {

 		log_error("VDO slab size %u out of range.",

@@ -50,6 +51,13 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,

 		valid = false;

 	}

+	if ((vtp->max_discard < DM_VDO_MAX_DISCARD_MINIMUM) ||

+	    (vtp->max_discard > DM_VDO_MAX_DISCARD_MAXIMUM)) {

+		log_error("VDO max discard %u out of range.",

+			  vtp->max_discard);

+		valid = false;

+	}

+

 	if (vtp->ack_threads > DM_VDO_ACK_THREADS_MAXIMUM) {

 		log_error("VDO ack threads %u out of range.", vtp->ack_threads);

 		valid = false;

diff --git a/lib/config/config_settings.h b/lib/config/config_settings.h

index 689a9e4..b725343 100644

--- a/lib/config/config_settings.h

+++ b/lib/config/config_settings.h

@@ -618,10 +618,17 @@ cfg(allocation_vdo_use_compression_CFG, "vdo_use_compression", allocation_CFG_SE

 cfg(allocation_vdo_use_deduplication_CFG, "vdo_use_deduplication", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_DEDUPLICATION, VDO_1ST_VSN, NULL, 0, NULL,

 	"Enables or disables deduplication when creating a VDO volume.\n"

 	"Deduplication may be disabled in instances where data is not expected\n"

-	"to have good deduplication rates but compression is still desired.")

+	"to have good deduplication rates but compression is still desired.\n")

-cfg(allocation_vdo_emulate_512_sectors_CFG, "vdo_emulate_512_sectors", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_EMULATE_512_SECTORS, VDO_1ST_VSN, NULL, 0, NULL,

-	"Specifies that the VDO volume is to emulate a 512 byte block device.\n")

+cfg(allocation_vdo_use_metadata_hints_CFG, "vdo_use_metadata_hints", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_METADATA_HINTS, VDO_1ST_VSN, NULL, 0, NULL,

+	"Enables or disables whether VDO volume should tag its latency-critical\n"

+	"writes with the REQ_SYNC flag. Some device mapper targets such as dm-raid5\n"

+	"process writes with this flag at a higher priority.\n"

+	"Default is enabled.\n")

+

+cfg(allocation_vdo_minimum_io_size_CFG, "vdo_minimum_io_size", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_MINIMUM_IO_SIZE, VDO_1ST_VSN, NULL, 0, NULL,

+	"The minimum IO size for VDO volume to accept, in bytes.\n"

+	"Valid values are 512 or 4096. The recommended and default value is 4096.\n")

 cfg(allocation_vdo_block_map_cache_size_mb_CFG, "vdo_block_map_cache_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_CACHE_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,

 	"Specifies the amount of memory in MiB allocated for caching block map\n"

@@ -629,41 +636,32 @@ cfg(allocation_vdo_block_map_cache_size_mb_CFG, "vdo_block_map_cache_size_mb", a

 	"at least 128MiB and less than 16TiB. The cache must be at least 16MiB\n"

 	"per logical thread. Note that there is a memory overhead of 15%.\n")

-cfg(allocation_vdo_block_map_period_CFG, "vdo_block_map_period", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_PERIOD, VDO_1ST_VSN, NULL, 0, NULL,

-	"Tunes the quantity of block map updates that can accumulate\n"

-	"before cache pages are flushed to disk. The value must be\n"

-	"at least 1 and less then 16380.\n"

-	"A lower value means shorter recovery time but lower performance.\n")

+// vdo format --blockMapPeriod

+cfg(allocation_vdo_block_map_era_length_CFG, "vdo_block_map_period", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_ERA_LENGTH, VDO_1ST_VSN, NULL, 0, NULL,

+	"The speed with which the block map cache writes out modified block map pages.\n"

+	"A smaller era length is likely to reduce the amount time spent rebuilding,\n"

+	"at the cost of increased block map writes during normal operation.\n"

+	"The maximum and recommended value is 16380; the minimum value is 1.\n")

 cfg(allocation_vdo_check_point_frequency_CFG, "vdo_check_point_frequency", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_CHECK_POINT_FREQUENCY, VDO_1ST_VSN, NULL, 0, NULL,

 	"The default check point frequency for VDO volume.\n")

+// vdo format

 cfg(allocation_vdo_use_sparse_index_CFG, "vdo_use_sparse_index", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_SPARSE_INDEX, VDO_1ST_VSN, NULL, 0, NULL,

 	"Enables sparse indexing for VDO volume.\n")

+// vdo format

 cfg(allocation_vdo_index_memory_size_mb_CFG, "vdo_index_memory_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_INDEX_MEMORY_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,

 	"Specifies the amount of index memory in MiB for VDO volume.\n"

-	"The value must be at least 256MiB and at most 1TiB.\n")

-

-cfg(allocation_vdo_use_read_cache_CFG, "vdo_use_read_cache", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_READ_CACHE, VDO_1ST_VSN, NULL, 0, NULL,

-	"Enables or disables the read cache within the VDO volume.\n"

-	"The cache should be enabled if write workloads are expected\n"

-	"to have high levels of deduplication, or for read intensive\n"

-	"workloads of highly compressible data.\n")

-

-cfg(allocation_vdo_read_cache_size_mb_CFG, "vdo_read_cache_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_READ_CACHE_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,

-	"Specifies the extra VDO volume read cache size in MiB.\n"

-	"This space is in addition to a system-defined minimum.\n"

-	"The value must be less then 16TiB and 1.12 MiB of memory\n"

-	"will be used per MiB of read cache specified, per bio thread.\n")

+	"The value must be at least 256MiB and at most 1TiB.")

 cfg(allocation_vdo_slab_size_mb_CFG, "vdo_slab_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_SLAB_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,

 	"Specifies the size in MiB of the increment by which a VDO is grown.\n"

 	"Using a smaller size constrains the total maximum physical size\n"

-	"that can be accommodated. Must be a power of two between 128MiB and 32GiB.\n")

+	"that can be accommodated. Must be a power of two between 128MiB and 32GiB.")

 cfg(allocation_vdo_ack_threads_CFG, "vdo_ack_threads", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_ACK_THREADS, VDO_1ST_VSN, NULL, 0, NULL,

-	"Specifies the number of threads to use for acknowledging\n"

+	"Specifies the number of threads   to use for acknowledging\n"

 	"completion of requested VDO I/O operations.\n"

 	"The value must be at in range [0..100].\n")

@@ -715,6 +713,16 @@ cfg(allocation_vdo_write_policy_CFG, "vdo_write_policy", allocation_CFG_SECTION,

 	"async - Writes are acknowledged after data has been cached for writing to stable storage.\n"

 	"        Data which has not been flushed is not guaranteed to persist in this mode.\n")

+cfg(allocation_vdo_max_discard_CFG, "vdo_max_discard", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_MAX_DISCARD, VDO_1ST_VSN, NULL, 0, NULL,

+	"Specified te maximum size of discard bio accepted, in 4096 byte blocks.\n"

+	"I/O requests to a VDO volume are normally split into 4096-byte blocks,\n"

+	"and processed up to 2048 at a time. However, discard requests to a VDO volume\n"

+	"can be automatically split to a larger size, up to <max discard> 4096-byte blocks\n"

+	"in a single bio, and are limited to 1500 at a time.\n"

+	"Increasing this value may provide better overall performance, at the cost of\n"

+	"increased latency for the individual discard requests.\n"

+	"The default and minimum is 1. The maximum is UINT_MAX / 4096.\n")

+

 cfg(log_report_command_log_CFG, "report_command_log", log_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_BOOL, DEFAULT_COMMAND_LOG_REPORT, vsn(2, 2, 158), NULL, 0, NULL,

 	"Enable or disable LVM log reporting.\n"

 	"If enabled, LVM will collect a log of operations, messages,\n"

diff --git a/lib/config/defaults.h b/lib/config/defaults.h

index f3fcb09..3da29f0 100644

--- a/lib/config/defaults.h

+++ b/lib/config/defaults.h

@@ -143,14 +143,13 @@

 /* VDO defaults */

 #define DEFAULT_VDO_USE_COMPRESSION	(true)

 #define DEFAULT_VDO_USE_DEDUPLICATION	(true)

-#define DEFAULT_VDO_EMULATE_512_SECTORS	(false)

+#define DEFAULT_VDO_USE_METADATA_HINTS	(true)

+#define DEFAULT_VDO_MINIMUM_IO_SIZE	(4096)

 #define DEFAULT_VDO_BLOCK_MAP_CACHE_SIZE_MB	(DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB)

-#define DEFAULT_VDO_BLOCK_MAP_PERIOD	(DM_VDO_BLOCK_MAP_PERIOD_MAXIMUM)

+#define DEFAULT_VDO_BLOCK_MAP_ERA_LENGTH (DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM)

 #define DEFAULT_VDO_USE_SPARSE_INDEX	(false)

 #define DEFAULT_VDO_CHECK_POINT_FREQUENCY	(0)

 #define DEFAULT_VDO_INDEX_MEMORY_SIZE_MB	(DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB)

-#define DEFAULT_VDO_USE_READ_CACHE	(false)

-#define DEFAULT_VDO_READ_CACHE_SIZE_MB	(0)

 #define DEFAULT_VDO_SLAB_SIZE_MB	(2 * 1024)  // 2GiB ... 19 slabbits

 #define DEFAULT_VDO_ACK_THREADS		(1)

 #define DEFAULT_VDO_BIO_THREADS		(1)

@@ -160,6 +159,7 @@

 #define DEFAULT_VDO_LOGICAL_THREADS	(1)

 #define DEFAULT_VDO_PHYSICAL_THREADS	(1)

 #define DEFAULT_VDO_WRITE_POLICY	"auto"

+#define DEFAULT_VDO_MAX_DISCARD		(DM_VDO_MAX_DISCARD_MINIMUM)

 #define DEFAULT_VDO_FORMAT_OPTIONS_CONFIG "#S" ""

 /*

diff --git a/lib/metadata/vdo_manip.c b/lib/metadata/vdo_manip.c

index b5bbbe2..04ab1ab 100644

--- a/lib/metadata/vdo_manip.c

+++ b/lib/metadata/vdo_manip.c

@@ -416,22 +416,20 @@ int fill_vdo_target_params(struct cmd_context *cmd,

 		find_config_tree_int(cmd, allocation_vdo_use_compression_CFG, profile);

 	vtp->use_deduplication =

 		find_config_tree_int(cmd, allocation_vdo_use_deduplication_CFG, profile);

-	vtp->emulate_512_sectors =

-		find_config_tree_int(cmd, allocation_vdo_emulate_512_sectors_CFG, profile);

+	vtp->use_metadata_hints =

+		find_config_tree_int(cmd, allocation_vdo_use_metadata_hints_CFG, profile);

+	vtp->minimum_io_size =

+		find_config_tree_int(cmd, allocation_vdo_minimum_io_size_CFG, profile);

 	vtp->block_map_cache_size_mb =

 		find_config_tree_int64(cmd, allocation_vdo_block_map_cache_size_mb_CFG, profile);

-	vtp->block_map_period =

-		find_config_tree_int(cmd, allocation_vdo_block_map_period_CFG, profile);

+	vtp->block_map_era_length =

+		find_config_tree_int(cmd, allocation_vdo_block_map_era_length_CFG, profile);

 	vtp->check_point_frequency =

 		find_config_tree_int(cmd, allocation_vdo_check_point_frequency_CFG, profile);

 	vtp->use_sparse_index =

 		find_config_tree_int(cmd, allocation_vdo_use_sparse_index_CFG, profile);

 	vtp->index_memory_size_mb =

 		find_config_tree_int64(cmd, allocation_vdo_index_memory_size_mb_CFG, profile);

-	vtp->use_read_cache =

-		find_config_tree_int(cmd, allocation_vdo_use_read_cache_CFG, profile);

-	vtp->read_cache_size_mb =

-		find_config_tree_int64(cmd, allocation_vdo_read_cache_size_mb_CFG, profile);

 	vtp->slab_size_mb =

 		find_config_tree_int(cmd, allocation_vdo_slab_size_mb_CFG, profile);

 	vtp->ack_threads =

@@ -448,6 +446,8 @@ int fill_vdo_target_params(struct cmd_context *cmd,

 		find_config_tree_int(cmd, allocation_vdo_logical_threads_CFG, profile);

 	vtp->physical_threads =

 		find_config_tree_int(cmd, allocation_vdo_physical_threads_CFG, profile);

+	vtp->max_discard =

+		find_config_tree_int(cmd, allocation_vdo_max_discard_CFG, profile);

 	policy = find_config_tree_str(cmd, allocation_vdo_write_policy_CFG, profile);

 	if (!get_vdo_write_policy(&vtp->write_policy, policy))

diff --git a/lib/vdo/vdo.c b/lib/vdo/vdo.c

index 455ce5b..c34eb93 100644

--- a/lib/vdo/vdo.c

+++ b/lib/vdo/vdo.c

@@ -165,21 +165,19 @@ static void _vdo_pool_display(const struct lv_segment *seg)

 	_print_yes_no("Compression\t", vtp->use_compression);

 	_print_yes_no("Deduplication", vtp->use_deduplication);

-	_print_yes_no("Emulate 512 sectors", vtp->emulate_512_sectors);

+	_print_yes_no("Metadata hints", vtp->use_metadata_hints);

+	log_print("  Minimum IO size\t%s",

+		  display_size(cmd, vtp->minimum_io_size));

 	log_print("  Block map cache sz\t%s",

 		  display_size(cmd, vtp->block_map_cache_size_mb * UINT64_C(2 * 1024)));

-	log_print("  Block map period\t%u", vtp->block_map_period);

+	log_print("  Block map era length\t%u", vtp->block_map_era_length);

 	_print_yes_no("Sparse index", vtp->use_sparse_index);

 	log_print("  Index memory size\t%s",

 		  display_size(cmd, vtp->index_memory_size_mb * UINT64_C(2 * 1024)));

-	_print_yes_no("Using read cache", vtp->use_read_cache);

-

-	log_print("  Read cache size\t%s",

-		  display_size(cmd, vtp->read_cache_size_mb * UINT64_C(2 * 1024)));

 	log_print("  Slab size\t\t%s",

 		  display_size(cmd, vtp->slab_size_mb * UINT64_C(2 * 1024)));

@@ -190,6 +188,7 @@ static void _vdo_pool_display(const struct lv_segment *seg)

 	log_print("  # Hash zone threads\t%u", (unsigned) vtp->hash_zone_threads);

 	log_print("  # Logical threads\t%u", (unsigned) vtp->logical_threads);

 	log_print("  # Physical threads\t%u", (unsigned) vtp->physical_threads);

+	log_print("  Max discard\t%u", (unsigned) vtp->max_discard);

 }

 /* reused as _vdo_text_import_area_count */

@@ -235,14 +234,17 @@ static int _vdo_pool_text_import(struct lv_segment *seg,

 	if (!_import_bool(n, "use_deduplication", &vtp->use_deduplication))

 		return_0;

-	if (!_import_bool(n, "emulate_512_sectors", &vtp->emulate_512_sectors))

+	if (!_import_bool(n, "use_metadata_hints", &vtp->use_metadata_hints))

 		return_0;

+	if (!dm_config_get_uint32(n, "minimum_io_size", &vtp->minimum_io_size))

+		return _bad_field("minimum_io_size");

+

 	if (!dm_config_get_uint32(n, "block_map_cache_size_mb", &vtp->block_map_cache_size_mb))

 		return _bad_field("block_map_cache_size_mb");

-	if (!dm_config_get_uint32(n, "block_map_period", &vtp->block_map_period))

-		return _bad_field("block_map_period");

+	if (!dm_config_get_uint32(n, "block_map_era_length", &vtp->block_map_era_length))

+		return _bad_field("block_map_era_length");

 	if (!_import_bool(n, "use_sparse_index", &vtp->use_sparse_index))

 		return_0;

@@ -250,11 +252,8 @@ static int _vdo_pool_text_import(struct lv_segment *seg,

 	if (!dm_config_get_uint32(n, "index_memory_size_mb", &vtp->index_memory_size_mb))

 		return _bad_field("index_memory_size_mb");

-	if (!_import_bool(n, "use_read_cache", &vtp->use_read_cache))

-		return_0;

-

-	if (!dm_config_get_uint32(n, "read_cache_size_mb", &vtp->read_cache_size_mb))

-		return _bad_field("read_cache_size_mb");

+	if (!dm_config_get_uint32(n, "max_discard", &vtp->max_discard))

+		return _bad_field("max_discard");

 	if (!dm_config_get_uint32(n, "slab_size_mb", &vtp->slab_size_mb))

 		return _bad_field("slab_size_mb");

@@ -306,12 +305,14 @@ static int _vdo_pool_text_export(const struct lv_segment *seg, struct formatter

 		outf(f, "use_compression = 1");

 	if (vtp->use_deduplication)

 		outf(f, "use_deduplication = 1");

-	if (vtp->emulate_512_sectors)

-		outf(f, "emulate_512_sectors = 1");

+	if (vtp->use_metadata_hints)

+		outf(f, "use_metadata_hints = 1");

+

+	outsize(f, vtp->minimum_io_size, "minimum_io_size = %u", vtp->minimum_io_size);

 	outsize(f, vtp->block_map_cache_size_mb * UINT64_C(2 * 1024),

 		"block_map_cache_size_mb = %u", vtp->block_map_cache_size_mb);

-	outf(f, "block_map_period = %u", vtp->block_map_period);

+	outf(f, "block_map_era_length = %u", vtp->block_map_era_length);

 	if (vtp->use_sparse_index)

 		outf(f, "use_sparse_index = 1");

@@ -319,11 +320,9 @@ static int _vdo_pool_text_export(const struct lv_segment *seg, struct formatter

 	outsize(f, vtp->index_memory_size_mb * UINT64_C(2 * 1024),

 		"index_memory_size_mb = %u", vtp->index_memory_size_mb);

-	if (vtp->use_read_cache)

-		outf(f, "use_read_cache = 1");

+	outf(f, "max_discard = %u", vtp->max_discard);

+

 	// TODO - conditionally

-	outsize(f, vtp->read_cache_size_mb * UINT64_C(2 * 1024),

-		"read_cache_size_mb = %u", vtp->read_cache_size_mb);

 	outsize(f, vtp->slab_size_mb * UINT64_C(2 * 1024),

 		"slab_size_mb = %u", vtp->slab_size_mb);

 	outf(f, "ack_threads = %u", (unsigned) vtp->ack_threads);

@@ -364,7 +363,8 @@ static int _vdo_pool_add_target_line(struct dev_manager *dm,

 	/* VDO uses virtual size instead of its physical size */

 	if (!dm_tree_node_add_vdo_target(node, get_vdo_pool_virtual_size(seg),

-					 data_uuid, &seg->vdo_params))

+					 data_uuid, seg_lv(seg, 0)->size,

+					 &seg->vdo_params))

 		return_0;

 	return 1;