On 3/25/20 2:47 PM, Hannes Reinecke wrote:
> On 3/25/20 7:29 AM, Damien Le Moal wrote:
>> On 2020/03/24 20:04, Bob Liu wrote:
>>> This patch implemented metadata support for regular device by:
>>> - Emulated zone information for regular device.
>>> - Store metadata at the beginning of regular device.
>>>
>>> | --- zoned device --- | -- regular device ||
>>> ^ ^
>>> | |Metadata
>>> zone 0
>>>
>>> Signed-off-by: Bob Liu <bob....@oracle.com>
>>> ---
>>> drivers/md/dm-zoned-metadata.c | 135
>>> +++++++++++++++++++++++++++++++----------
>>> drivers/md/dm-zoned-target.c | 6 +-
>>> drivers/md/dm-zoned.h | 3 +-
>>> 3 files changed, 108 insertions(+), 36 deletions(-)
>>>
> Having thought about it some more, I think we cannot continue with this
> 'simple' approach.
> The immediate problem is that we lie about the disk size; clearly the
> metadata cannot be used for regular data, yet we expose a target device with
> the full size of the underlying device.
The exposed size is "regular dev size + zoned dev size - metadata size -
reserved seq zone size".
I didn't see why there is a lie?
> Making me wonder if anybody ever tested a disk-full scenario...
> The other problem is that with two devices we need to be able to stitch them
> together in an automated fashion, eg via a systemd service or udev rule.
> But for this we need to be able to identify the devices, which means both
> need to carry metadata, and both need to have unique identifier within the
> metadata. Which the current metadata doesn't allow to.
>
> Hence my plan is to implement a v2 metadata, carrying UUIDs for the dmz set
> _and_ the component device. With that we can update blkid to create links etc
> so that the devices can be identified in the system.
> Additionally I would be updating dmzadm to write the new metadata.
>
> And I will add a new command 'start' to dmzadm which will then create the
> device-mapper device _with the correct size_. It also has the benefit that we
> can create the device-mapper target with the UUID specified in the metadata,
> so the persistent device links will be created automatically.
>
> Bob, can you send me your improvements to dmzadm so that I can include them
> in my changes?
>
Attached, but it's a big patch I haven't split them to smaller one.
The dmz_check/repair can't work neither in current stage.
diff --git a/src/dmz.h b/src/dmz.h
index 57741b1..51b5019 100644
--- a/src/dmz.h
+++ b/src/dmz.h
@@ -153,19 +153,33 @@ enum dmz_op {
DMZ_OP_REPAIR,
};
+struct dmz_raw_dev {
+ char *path;
+ char *name;
+ int fd;
+ size_t zone_nr_sectors;
+ size_t zone_nr_blocks;
+ /* Device info */
+ __u64 capacity;
+ unsigned int nr_zones;
+ struct blk_zone *zones;
+ struct dmz_dev *pdev;
+};
+
/*
* Device descriptor.
*/
struct dmz_dev {
/* Device file path and basename */
- char *path;
- char *name;
+ struct dmz_raw_dev zoned_dev;
+ struct dmz_raw_dev regu_dev;
+
int op;
unsigned int flags;
+ size_t zone_nr_blocks;
+ int has_regular;
- /* Device info */
- __u64 capacity;
unsigned int nr_zones;
unsigned int nr_meta_zones;
@@ -178,11 +192,6 @@ struct dmz_dev {
unsigned int total_nr_meta_zones;
unsigned int nr_rnd_zones;
- struct blk_zone *zones;
-
- size_t zone_nr_sectors;
- size_t zone_nr_blocks;
-
/* First metadata zone */
struct blk_zone *sb_zone;
__u64 sb_block;
@@ -195,10 +204,6 @@ struct dmz_dev {
/* Mapping table */
unsigned int nr_map_blocks;
__u64 map_block;
-
- /* Device file descriptor */
- int fd;
-
};
/*
@@ -317,16 +322,16 @@ dmz_zone_cond_str(struct blk_zone *zone)
extern int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op);
extern void dmz_close_dev(struct dmz_dev *dev);
-extern int dmz_sync_dev(struct dmz_dev *dev);
-extern int dmz_reset_zone(struct dmz_dev *dev, struct blk_zone *zone);
-extern int dmz_reset_zones(struct dmz_dev *dev);
-extern int dmz_write_block(struct dmz_dev *dev, __u64 block, __u8 *buf);
-extern int dmz_read_block(struct dmz_dev *dev, __u64 block, __u8 *buf);
+extern int dmz_sync_dev(struct dmz_raw_dev *dev);
+extern int dmz_reset_zone(struct dmz_raw_dev *dev, struct blk_zone *zone);
+extern int dmz_reset_zones(struct dmz_raw_dev *dev);
+extern int dmz_write_block(struct dmz_raw_dev *dev, __u64 block, __u8 *buf);
+extern int dmz_read_block(struct dmz_raw_dev *dev, __u64 block, __u8 *buf);
extern __u32 dmz_crc32(__u32 crc, const void *address, size_t length);
extern int dmz_locate_metadata(struct dmz_dev *dev);
-extern int dmz_write_super(struct dmz_dev *dev, __u64 gen, __u64 offset);
+extern int dmz_write_super(struct dmz_raw_dev *dev, __u64 gen, __u64 offset);
extern int dmz_format(struct dmz_dev *dev);
extern int dmz_check(struct dmz_dev *dev);
extern int dmz_repair(struct dmz_dev *dev);
diff --git a/src/dmz_check.c b/src/dmz_check.c
index 25ce026..da8c1a5 100644
--- a/src/dmz_check.c
+++ b/src/dmz_check.c
@@ -29,7 +29,7 @@
#include <linux/fs.h>
#include <assert.h>
#include <asm/byteorder.h>
-
+#if 0
/*
* Message macro.
*/
@@ -1245,4 +1245,4 @@ int dmz_repair(struct dmz_dev *dev)
return 0;
}
-
+#endif
diff --git a/src/dmz_dev.c b/src/dmz_dev.c
index e713ae0..a7a57ac 100644
--- a/src/dmz_dev.c
+++ b/src/dmz_dev.c
@@ -36,7 +36,7 @@
/*
* Test if the device is mounted.
*/
-static int dmz_dev_mounted(struct dmz_dev *dev)
+static int dmz_dev_mounted(struct dmz_raw_dev *dev)
{
struct mntent *mnt = NULL;
FILE *file = NULL;
@@ -57,7 +57,7 @@ static int dmz_dev_mounted(struct dmz_dev *dev)
/*
* Test if the device is already used as a target backend.
*/
-static int dmz_dev_busy(struct dmz_dev *dev)
+static int dmz_dev_busy(struct dmz_raw_dev *dev)
{
char path[128];
struct dirent **namelist;
@@ -87,7 +87,7 @@ static int dmz_dev_busy(struct dmz_dev *dev)
/*
* Get a zoned block device model (host-aware or howt-managed).
*/
-static int dmz_get_dev_model(struct dmz_dev *dev)
+static int dmz_get_dev_model(struct dmz_raw_dev *dev)
{
char str[PATH_MAX];
FILE *file;
@@ -122,9 +122,9 @@ static int dmz_get_dev_model(struct dmz_dev *dev)
}
if (strcmp(str, "host-aware") == 0)
- dev->flags |= DMZ_ZONED_HA;
+ dev->pdev->flags |= DMZ_ZONED_HA;
else if (strcmp(str, "host-managed") == 0)
- dev->flags |= DMZ_ZONED_HM;
+ dev->pdev->flags |= DMZ_ZONED_HM;
return 0;
}
@@ -132,7 +132,7 @@ static int dmz_get_dev_model(struct dmz_dev *dev)
/*
* Get device capacity and zone size.
*/
-static int dmz_get_dev_capacity(struct dmz_dev *dev)
+static int dmz_get_dev_capacity(struct dmz_raw_dev *dev, int emulated)
{
char str[128];
FILE *file;
@@ -147,26 +147,30 @@ static int dmz_get_dev_capacity(struct dmz_dev *dev)
}
dev->capacity >>= 9;
- /* Get zone size */
- snprintf(str, sizeof(str),
- "/sys/block/%s/queue/chunk_sectors",
- dev->name);
- file = fopen(str, "r");
- if (!file) {
- fprintf(stderr, "Open %s failed\n", str);
- return -1;
- }
+ if (emulated) {
+ dev->zone_nr_sectors = emulated;
+ } else {
+ /* Get zone size */
+ snprintf(str, sizeof(str),
+ "/sys/block/%s/queue/chunk_sectors",
+ dev->name);
+ file = fopen(str, "r");
+ if (!file) {
+ fprintf(stderr, "Open %s failed\n", str);
+ return -1;
+ }
- memset(str, 0, sizeof(str));
- res = fscanf(file, "%s", str);
- fclose(file);
+ memset(str, 0, sizeof(str));
+ res = fscanf(file, "%s", str);
+ fclose(file);
- if (res != 1) {
- fprintf(stderr, "Invalid file %s format\n", str);
- return -1;
- }
+ if (res != 1) {
+ fprintf(stderr, "Invalid file %s format\n", str);
+ return -1;
+ }
- dev->zone_nr_sectors = atol(str);
+ dev->zone_nr_sectors = atol(str);
+ }
if (!dev->zone_nr_sectors ||
(dev->zone_nr_sectors & DMZ_BLOCK_SECTORS_MASK)) {
fprintf(stderr,
@@ -182,7 +186,7 @@ static int dmz_get_dev_capacity(struct dmz_dev *dev)
/*
* Print a device zone information.
*/
-static void dmz_print_zone(struct dmz_dev *dev,
+static void dmz_print_zone(struct dmz_raw_dev *dev,
struct blk_zone *zone)
{
@@ -230,14 +234,14 @@ static void dmz_print_zone(struct dmz_dev *dev,
/*
* Get a device zone configuration.
*/
-static int dmz_get_dev_zones(struct dmz_dev *dev)
+static int dmz_get_dev_zones(struct dmz_raw_dev *dev, int emulate)
{
struct blk_zone_report *rep = NULL;
unsigned int rep_max_zones;
struct blk_zone *blkz;
unsigned int i, nr_zones;
__u64 sector;
- int ret = -1;
+ int ret = 0;
/* This will ignore an eventual last smaller zone */
nr_zones = dev->capacity / dev->zone_nr_sectors;
@@ -263,17 +267,35 @@ static int dmz_get_dev_zones(struct dmz_dev *dev)
sector = 0;
while (sector < dev->capacity) {
-
/* Get zone information */
memset(rep, 0, DMZ_REPORT_ZONES_BUFSZ);
rep->sector = sector;
rep->nr_zones = rep_max_zones;
- ret = ioctl(dev->fd, BLKREPORTZONE, rep);
- if (ret != 0) {
- fprintf(stderr,
- "%s: Get zone information failed %d (%s)\n",
- dev->name, errno, strerror(errno));
- goto out;
+ if (emulate) {
+ unsigned int f_sector = sector;
+ rep->nr_zones = ((nr_zones < rep_max_zones) ? nr_zones : rep_max_zones);
+ blkz = (struct blk_zone *)(rep + 1);
+ for (i = 0; i < rep->nr_zones && f_sector < dev->capacity; i++) {
+ //set up fake blkz
+ blkz->start = f_sector;
+ blkz->len = dev->zone_nr_sectors;
+ blkz->wp = blkz->start + blkz->len;
+ blkz->type = BLK_ZONE_TYPE_CONVENTIONAL;
+ blkz->cond = BLK_ZONE_COND_NOT_WP;
+
+ f_sector = dmz_zone_sector(blkz) + dmz_zone_length(blkz);
+ if (f_sector > dev->capacity)
+ blkz->len = dev->capacity - dmz_zone_sector(blkz);
+ blkz++;
+ }
+ } else {
+ ret = ioctl(dev->fd, BLKREPORTZONE, rep);
+ if (ret != 0) {
+ fprintf(stderr,
+ "%s: Get zone information failed %d (%s)\n",
+ dev->name, errno, strerror(errno));
+ goto out;
+ }
}
if (!rep->nr_zones)
@@ -282,7 +304,7 @@ static int dmz_get_dev_zones(struct dmz_dev *dev)
blkz = (struct blk_zone *)(rep + 1);
for (i = 0; i < rep->nr_zones && sector < dev->capacity; i++) {
- if (dev->flags & DMZ_VVERBOSE)
+ if (dev->pdev->flags & DMZ_VVERBOSE)
dmz_print_zone(dev, blkz);
/* Check zone size */
@@ -337,22 +359,35 @@ out:
static int dmz_get_dev_info(struct dmz_dev *dev)
{
- if (dmz_get_dev_model(dev) < 0)
+ if (dmz_get_dev_model(&dev->zoned_dev) < 0)
return -1;
if (!dmz_dev_is_zoned(dev)) {
fprintf(stderr,
"%s: Not a zoned block device\n",
- dev->name);
+ dev->zoned_dev.name);
return -1;
}
- if (dmz_get_dev_capacity(dev) < 0)
+ if (dmz_get_dev_capacity(&dev->zoned_dev, 0) < 0)
return -1;
- if (dmz_get_dev_zones(dev) < 0)
+ dev->zone_nr_blocks = dev->zoned_dev.zone_nr_blocks;
+ if (dev->has_regular)
+ if (dmz_get_dev_capacity(&dev->regu_dev, dev->zoned_dev.zone_nr_blocks) < 0)
+ return -1;
+
+ if (dmz_get_dev_zones(&dev->zoned_dev, 0) < 0)
return -1;
+ if (dev->has_regular)
+ if (dmz_get_dev_zones(&dev->regu_dev, 1) < 0)
+ return -1;
+
+ dev->nr_zones = dev->zoned_dev.nr_zones;
+ if (dev->has_regular)
+ dev->nr_zones += dev->regu_dev.nr_zones;
+
return 0;
}
@@ -361,7 +396,7 @@ static int dmz_get_dev_info(struct dmz_dev *dev)
* Return -1 on error, 0 if something valid is detected on the disk
* and 1 if the disk appears to be unused.
*/
-static int dmz_check_overwrite(struct dmz_dev *dev)
+static int dmz_check_overwrite(struct dmz_raw_dev *dev)
{
const char *type;
blkid_probe pr;
@@ -421,10 +456,7 @@ out:
return ret;
}
-/*
- * Open a device.
- */
-int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
+int dmz_open_raw_dev(struct dmz_raw_dev *dev, enum dmz_op op, int flags)
{
struct stat st;
int ret;
@@ -447,7 +479,7 @@ int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
return -1;
}
- if (op == DMZ_OP_FORMAT && (!(dev->flags & DMZ_OVERWRITE))) {
+ if (op == DMZ_OP_FORMAT && (!(flags & DMZ_OVERWRITE))) {
/* Check for existing valid content */
ret = dmz_check_overwrite(dev);
if (ret <= 0)
@@ -455,16 +487,12 @@ int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
}
if (dmz_dev_mounted(dev)) {
- fprintf(stderr,
- "%s is mounted\n",
- dev->path);
+ fprintf(stderr, "%s is mounted\n", dev->path);
return -1;
}
if (dmz_dev_busy(dev)) {
- fprintf(stderr,
- "%s is in use\n",
- dev->path);
+ fprintf(stderr, "%s is in use\n", dev->path);
return -1;
}
@@ -478,6 +506,18 @@ int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
return -1;
}
+ return 0;
+}
+
+/*
+ * Open a device.
+ */
+int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
+{
+ dmz_open_raw_dev(&dev->zoned_dev, op, dev->flags);
+ if (dev->has_regular)
+ dmz_open_raw_dev(&dev->regu_dev, op, dev->flags);
+
/* Get device capacity and zone configuration */
if (dmz_get_dev_info(dev) < 0) {
dmz_close_dev(dev);
@@ -487,10 +527,7 @@ int dmz_open_dev(struct dmz_dev *dev, enum dmz_op op)
return 0;
}
-/*
- * Close an open device.
- */
-void dmz_close_dev(struct dmz_dev *dev)
+void dmz_close_raw_dev(struct dmz_raw_dev *dev)
{
if (dev->fd >= 0) {
close(dev->fd);
@@ -501,10 +538,20 @@ void dmz_close_dev(struct dmz_dev *dev)
dev->zones = NULL;
}
+/*
+ * Close an open device.
+ */
+void dmz_close_dev(struct dmz_dev *dev)
+{
+ dmz_close_raw_dev(&dev->zoned_dev);
+ if (dev->has_regular)
+ dmz_close_raw_dev(&dev->regu_dev);
+}
+
/*
* Read a metadata block.
*/
-int dmz_read_block(struct dmz_dev *dev, __u64 block, __u8 *buf)
+int dmz_read_block(struct dmz_raw_dev *dev, __u64 block, __u8 *buf)
{
ssize_t ret;
@@ -526,7 +573,7 @@ int dmz_read_block(struct dmz_dev *dev, __u64 block, __u8 *buf)
/*
* Write a metadata block.
*/
-int dmz_write_block(struct dmz_dev *dev, __u64 block, __u8 *buf)
+int dmz_write_block(struct dmz_raw_dev *dev, __u64 block, __u8 *buf)
{
ssize_t ret;
@@ -547,7 +594,7 @@ int dmz_write_block(struct dmz_dev *dev, __u64 block, __u8 *buf)
/*
* Write a metadata block.
*/
-int dmz_sync_dev(struct dmz_dev *dev)
+int dmz_sync_dev(struct dmz_raw_dev *dev)
{
printf("Syncing disk\n");
diff --git a/src/dmz_format.c b/src/dmz_format.c
index 62cb03b..30286cb 100644
--- a/src/dmz_format.c
+++ b/src/dmz_format.c
@@ -24,14 +24,14 @@
#include <sys/types.h>
#include <asm/byteorder.h>
-
/*
* Fill and write a super block.
*/
-int dmz_write_super(struct dmz_dev *dev,
+int dmz_write_super(struct dmz_raw_dev *dev,
__u64 gen, __u64 offset)
{
- __u64 sb_block = dev->sb_block + offset;
+ struct dmz_dev *pdev = dev->pdev;
+ __u64 sb_block = pdev->sb_block + offset;
struct dm_zoned_super *sb;
__u32 crc;
__u8 *buf;
@@ -52,12 +52,12 @@ int dmz_write_super(struct dmz_dev *dev,
sb->gen = __cpu_to_le64(gen);
sb->sb_block = __cpu_to_le64(sb_block);
- sb->nr_meta_blocks = __cpu_to_le32(dev->nr_meta_blocks);
- sb->nr_reserved_seq = __cpu_to_le32(dev->nr_reserved_seq);
- sb->nr_chunks = __cpu_to_le32(dev->nr_chunks);
+ sb->nr_meta_blocks = __cpu_to_le32(pdev->nr_meta_blocks);
+ sb->nr_reserved_seq = __cpu_to_le32(pdev->nr_reserved_seq);
+ sb->nr_chunks = __cpu_to_le32(pdev->nr_chunks);
- sb->nr_map_blocks = __cpu_to_le32(dev->nr_map_blocks);
- sb->nr_bitmap_blocks = __cpu_to_le32(dev->nr_bitmap_blocks);
+ sb->nr_map_blocks = __cpu_to_le32(pdev->nr_map_blocks);
+ sb->nr_bitmap_blocks = __cpu_to_le32(pdev->nr_bitmap_blocks);
crc = dmz_crc32(gen, sb, DMZ_BLOCK_SIZE);
sb->crc = __cpu_to_le32(crc);
@@ -77,7 +77,7 @@ int dmz_write_super(struct dmz_dev *dev,
/*
* Write mapping table blocks.
*/
-static int dmz_write_mapping(struct dmz_dev *dev,
+static int dmz_write_mapping(struct dmz_raw_dev *dev,
__u64 offset)
{
__u64 map_block;
@@ -102,8 +102,8 @@ static int dmz_write_mapping(struct dmz_dev *dev,
}
/* Write mapping table */
- map_block = offset + dev->map_block;
- for (i = 0; i < dev->nr_map_blocks; i++) {
+ map_block = offset + dev->pdev->map_block;
+ for (i = 0; i < dev->pdev->nr_map_blocks; i++) {
ret = dmz_write_block(dev, map_block + i, buf);
if (ret < 0) {
fprintf(stderr,
@@ -122,7 +122,7 @@ static int dmz_write_mapping(struct dmz_dev *dev,
/*
* Write zone bitmap blocks.
*/
-static int dmz_write_bitmap(struct dmz_dev *dev,
+static int dmz_write_bitmap(struct dmz_raw_dev *dev,
__u64 offset)
{
__u64 bitmap_block;
@@ -140,8 +140,8 @@ static int dmz_write_bitmap(struct dmz_dev *dev,
memset(buf, 0, DMZ_BLOCK_SIZE);
/* Clear bitmap blocks */
- bitmap_block = offset + dev->bitmap_block;
- for (i = 0; i < dev->nr_bitmap_blocks; i++) {
+ bitmap_block = offset + dev->pdev->bitmap_block;
+ for (i = 0; i < dev->pdev->nr_bitmap_blocks; i++) {
ret = dmz_write_block(dev, bitmap_block + i, buf);
if (ret < 0) {
fprintf(stderr,
@@ -160,7 +160,7 @@ static int dmz_write_bitmap(struct dmz_dev *dev,
/*
* Write formatted metadata blocks.
*/
-static int dmz_write_meta(struct dmz_dev *dev,
+static int dmz_write_meta(struct dmz_raw_dev *dev,
__u64 offset)
{
@@ -180,11 +180,20 @@ static int dmz_write_meta(struct dmz_dev *dev,
return 0;
}
+struct dmz_raw_dev *dmz_metadev(struct dmz_dev *dev)
+{
+ if (dev->has_regular)
+ return &dev->regu_dev;
+ else
+ return &dev->zoned_dev;
+}
+
/*
* Format a device.
*/
int dmz_format(struct dmz_dev *dev)
{
+ struct dmz_raw_dev *mdev = dmz_metadev(dev);
/* calculate location of metadata blocks */
if (dmz_locate_metadata(dev) < 0)
@@ -199,7 +208,7 @@ int dmz_format(struct dmz_dev *dev)
printf(" Primary meta-data set: %u metadata blocks from block %llu (zone %u)\n",
dev->nr_meta_blocks,
dev->sb_block,
- dmz_zone_id(dev, dev->sb_zone));
+ dmz_zone_id(mdev, dev->sb_zone));
printf(" Super block at block %llu and %llu\n",
dev->sb_block,
dev->sb_block + (dev->nr_meta_zones * dev->zone_nr_blocks));
@@ -231,25 +240,27 @@ int dmz_format(struct dmz_dev *dev)
/* Ready to write: first reset all zones */
printf("Resetting sequential zones\n");
- if (dmz_reset_zones(dev) < 0)
+ if (dev->has_regular)
+ if (dmz_reset_zones(&dev->regu_dev) < 0)
+ return -1;
+ if (dmz_reset_zones(&dev->zoned_dev) < 0)
return -1;
/* Write primary metadata set */
printf("Writing primary metadata set\n");
- if (dmz_write_meta(dev, 0) < 0)
+ if (dmz_write_meta(mdev, 0) < 0)
return -1;
/* Write secondary metadata set */
printf("Writing secondary metadata set\n");
- if (dmz_write_meta(dev, dev->zone_nr_blocks * dev->nr_meta_zones) < 0)
+ if (dmz_write_meta(mdev, dev->zone_nr_blocks * dev->nr_meta_zones) < 0)
return -1;
/* Sync */
- if (dmz_sync_dev(dev) < 0)
+ if (dmz_sync_dev(mdev) < 0)
return -1;
printf("Done.\n");
return 0;
}
-
diff --git a/src/dmz_lib.c b/src/dmz_lib.c
index 2df0758..3c1874a 100644
--- a/src/dmz_lib.c
+++ b/src/dmz_lib.c
@@ -44,7 +44,7 @@ __u32 dmz_crc32(__u32 crc, const void *buf, size_t length)
/*
* Reset a zone.
*/
-int dmz_reset_zone(struct dmz_dev *dev,
+int dmz_reset_zone(struct dmz_raw_dev *dev,
struct blk_zone *zone)
{
struct blk_zone_range range;
@@ -73,7 +73,7 @@ int dmz_reset_zone(struct dmz_dev *dev,
/*
* Reset all zones of a device.
*/
-int dmz_reset_zones(struct dmz_dev *dev)
+int dmz_reset_zones(struct dmz_raw_dev *dev)
{
unsigned int i;
@@ -85,21 +85,10 @@ int dmz_reset_zones(struct dmz_dev *dev)
return 0;
}
-/*
- * Determine location and amount of metadata blocks.
- */
-int dmz_locate_metadata(struct dmz_dev *dev)
+static void count_useable_zones(struct dmz_raw_dev *dev)
{
struct blk_zone *zone;
unsigned int i = 0;
- unsigned int nr_meta_blocks, nr_map_blocks;
- unsigned int nr_chunks, nr_meta_zones;
- unsigned int nr_bitmap_zones;
-
- dev->nr_useable_zones = 0;
- dev->max_nr_meta_zones = 0;
- dev->last_meta_zone = 0;
- dev->nr_rnd_zones = 0;
/* Count useable zones */
for (i = 0; i < dev->nr_zones; i++) {
@@ -126,21 +115,43 @@ int dmz_locate_metadata(struct dmz_dev *dev)
dmz_zone_id(dev, zone));
continue;
}
- dev->nr_useable_zones++;
+ dev->pdev->nr_useable_zones++;
if (dmz_zone_rnd(zone)) {
- if (dev->sb_zone == NULL) {
- dev->sb_zone = zone;
- dev->last_meta_zone = i;
- dev->max_nr_meta_zones = 1;
- } else if (dev->last_meta_zone == (i - 1)) {
- dev->last_meta_zone = i;
- dev->max_nr_meta_zones++;
+ if (dev->pdev->sb_zone == NULL) {
+ dev->pdev->sb_zone = zone;
+ dev->pdev->last_meta_zone = i;
+ dev->pdev->max_nr_meta_zones = 1;
+ } else if (dev->pdev->last_meta_zone == (i - 1)) {
+ dev->pdev->last_meta_zone = i;
+ dev->pdev->max_nr_meta_zones++;
}
- dev->nr_rnd_zones++;
+ dev->pdev->nr_rnd_zones++;
}
-
}
+}
+
+/*
+ * Determine location and amount of metadata blocks.
+ */
+int dmz_locate_metadata(struct dmz_dev *dev)
+{
+ unsigned int nr_meta_blocks, nr_map_blocks;
+ unsigned int nr_chunks, nr_meta_zones;
+ unsigned int nr_bitmap_zones;
+
+ dev->nr_useable_zones = 0;
+ dev->max_nr_meta_zones = 0;
+ dev->last_meta_zone = 0;
+ dev->nr_rnd_zones = 0;
+
+ /*
+ * Count regular device first, so that metadata zone will be in
+ * regular device.
+ */
+ if (dev->has_regular)
+ count_useable_zones(&dev->regu_dev);
+ count_useable_zones(&dev->zoned_dev);
/*
* Randomly writeable zones are mandatory: at least 3
@@ -148,8 +159,8 @@ int dmz_locate_metadata(struct dmz_dev *dev)
*/
if (dev->nr_rnd_zones < 3) {
fprintf(stderr,
- "%s: Not enough random zones found\n",
- dev->name);
+ "%s:%s: Not enough random zones found\n",
+ dev->zoned_dev.name, dev->regu_dev.name);
return -1;
}
@@ -161,8 +172,8 @@ int dmz_locate_metadata(struct dmz_dev *dev)
dev->nr_reserved_seq = dev->nr_rnd_zones - 1;
if (dev->nr_reserved_seq >= dev->nr_useable_zones) {
fprintf(stderr,
- "%s: Not enough useable zones found\n",
- dev->name);
+ "%s:%s: Not enough useable zones found\n",
+ dev->zoned_dev.name, dev->regu_dev.name);
return -1;
}
@@ -181,8 +192,8 @@ int dmz_locate_metadata(struct dmz_dev *dev)
if ((nr_bitmap_zones + dev->nr_reserved_seq) > dev->nr_useable_zones) {
fprintf(stderr,
- "%s: Not enough zones\n",
- dev->name);
+ "%s:%s: Not enough zones\n",
+ dev->zoned_dev.name, dev->regu_dev.name);
return -1;
}
@@ -208,9 +219,9 @@ int dmz_locate_metadata(struct dmz_dev *dev)
if (dev->total_nr_meta_zones > dev->nr_rnd_zones) {
fprintf(stderr,
- "%s: Insufficient number of random zones "
+ "%s:%s Insufficient number of random zones "
"(need %u, have %u)\n",
- dev->name,
+ dev->zoned_dev.name, dev->regu_dev.name,
dev->total_nr_meta_zones,
dev->nr_rnd_zones);
return -1;
diff --git a/src/dmzadm.c b/src/dmzadm.c
index 0660d02..ff7e9cc 100644
--- a/src/dmzadm.c
+++ b/src/dmzadm.c
@@ -41,23 +41,55 @@ static void dmzadm_usage(void)
" --force : Force overwrite of existing content\n"
" --seq <num> : Number of sequential zones reserved\n"
" for reclaim. The minimum is 1 and the\n"
- " default is %d\n",
+ " default is %d\n"
+ " --regular <device path>: Use a regular block device\n"
+ " for metadata and buffer writes\n",
DMZ_NR_RESERVED_SEQ);
}
+static void dump_info(struct dmz_raw_dev *dev)
+{
+ unsigned int nr_zones;
+ struct dmz_dev *pdev = dev->pdev;
+
+ printf("%s: %llu 512-byte sectors (%llu GiB)\n",
+ dev->path,
+ dev->capacity,
+ (dev->capacity << 9) / (1024ULL * 1024ULL * 1024ULL));
+ printf(" Host-%s device\n",
+ (pdev->flags & DMZ_ZONED_HM) ? "managed" : "aware");
+ nr_zones = dev->capacity / dev->zone_nr_sectors;
+ printf(" %u zones of %zu 512-byte sectors (%zu MiB)\n",
+ nr_zones,
+ dev->zone_nr_sectors,
+ (dev->zone_nr_sectors << 9) / (1024 * 1024));
+ if (nr_zones < dev->nr_zones) {
+ size_t runt_sectors = dev->capacity & (dev->zone_nr_sectors - 1);
+
+ printf(" 1 runt zone of %zu 512-byte sectors (%zu MiB)\n",
+ runt_sectors,
+ (runt_sectors << 9) / (1024 * 1024));
+ }
+ printf(" %zu 4KB data blocks per zone\n",
+ dev->zone_nr_blocks);
+
+}
+
/*
* Main function.
*/
int main(int argc, char **argv)
{
- unsigned int nr_zones;
struct dmz_dev dev;
- int i, ret;
+ int i, ret = 0;
enum dmz_op op;
/* Initialize */
memset(&dev, 0, sizeof(dev));
- dev.fd = -1;
+ dev.zoned_dev.fd = -1;
+ dev.regu_dev.fd = -1;
+ dev.zoned_dev.pdev = &dev;
+ dev.regu_dev.pdev = &dev;
dev.nr_reserved_seq = DMZ_NR_RESERVED_SEQ;
/* Parse operation */
@@ -90,7 +122,7 @@ int main(int argc, char **argv)
}
/* Get device path */
- dev.path = argv[2];
+ dev.zoned_dev.path = argv[2];
/* Parse arguments */
for (i = 3; i < argc; i++) {
@@ -118,7 +150,15 @@ int main(int argc, char **argv)
"Invalid number of sequential zones\n");
return 1;
}
-
+ } else if (strncmp(argv[i], "--regular=", 10) == 0) {
+ if (op != DMZ_OP_FORMAT) {
+ fprintf(stderr,
+ "--regular option is valid only with the "
+ "format operation\n");
+ return 1;
+ }
+ dev.regu_dev.path = argv[i] + 10;
+ dev.has_regular = 1;
} else if (strcmp(argv[i], "--force") == 0) {
if (op != DMZ_OP_FORMAT) {
@@ -149,26 +189,9 @@ int main(int argc, char **argv)
if (dmz_open_dev(&dev, op) < 0)
return 1;
- printf("%s: %llu 512-byte sectors (%llu GiB)\n",
- dev.path,
- dev.capacity,
- (dev.capacity << 9) / (1024ULL * 1024ULL * 1024ULL));
- printf(" Host-%s device\n",
- (dev.flags & DMZ_ZONED_HM) ? "managed" : "aware");
- nr_zones = dev.capacity / dev.zone_nr_sectors;
- printf(" %u zones of %zu 512-byte sectors (%zu MiB)\n",
- nr_zones,
- dev.zone_nr_sectors,
- (dev.zone_nr_sectors << 9) / (1024 * 1024));
- if (nr_zones < dev.nr_zones) {
- size_t runt_sectors = dev.capacity & (dev.zone_nr_sectors - 1);
-
- printf(" 1 runt zone of %zu 512-byte sectors (%zu MiB)\n",
- runt_sectors,
- (runt_sectors << 9) / (1024 * 1024));
- }
- printf(" %zu 4KB data blocks per zone\n",
- dev.zone_nr_blocks);
+ dump_info(&dev.zoned_dev);
+ if (dev.has_regular)
+ dump_info(&dev.regu_dev);
switch (op) {
@@ -176,6 +199,7 @@ int main(int argc, char **argv)
ret = dmz_format(&dev);
break;
+#if 0
case DMZ_OP_CHECK:
ret = dmz_check(&dev);
break;
@@ -183,6 +207,7 @@ int main(int argc, char **argv)
case DMZ_OP_REPAIR:
ret = dmz_repair(&dev);
break;
+#endif
default:
--
dm-devel mailing list
dm-devel@redhat.com
https://www.redhat.com/mailman/listinfo/dm-devel
