../src/nvme-cmds-io.c

Bug Summary

File:	.build-ci/../src/nvme-cmds-io.c
Warning:	line 1224, column 11 Potential leak of memory pointed to by 'mbuffer'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name nvme-cmds-io.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -fcoverage-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -resource-dir /usr/bin/../lib/clang/22 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I nvme.p -I . -I .. -I src -I ../src -I ccan -I ../ccan -I libnvme/src -I ../libnvme/src -I /usr/include/json-c -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/bin/../lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/16/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu11 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-opt-analyze-headers -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-10-24-125112-639-1 -x c ../src/nvme-cmds-io.c
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
* NVM-Express command line utility.
*
* Copyright (c) 2014-2015, Intel Corporation.
*
* Written by Keith Busch <kbusch@kernel.org>
*/

10/**
* This program uses NVMe IOCTLs to run native nvme commands to a device.
*/
13#include <dirent.h>
14#include <errno(*__errno_location ()).h>
15#include <fcntl.h>
16#include <inttypes.h>
17#include <libgen.h>
18#include <locale.h>
19#include <math.h>
20#include <signal.h>
21#include <stdint.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <unistd.h>

27#include <sys/stat.h>
28#include <sys/types.h>

30#include <libnvme-mi.h>
31#include <libnvme.h>

33#include <ccan/array_size/array_size.h>
34#include <ccan/endian/endian.h>
35#include <ccan/minmax/minmax.h>
36#include <shared/compiler-attributes-util.h>
37#include <shared/fs-util.h>
38#include <shared/mmio-util.h>
39#include <shared/parse-util.h>
40#include <shared/sig-util.h>
41#include <shared/suffix-util.h>
42#include <shared/time-util.h>

44#include "argconfig.h"
45#include "cleanup.h"
46#include "global-ctx.h"
47#include "nvme-errno.h"
48#include "nvme-print.h"
49#include "plugin.h"

51static const char *app_tag = "app tag for end-to-end PI";
52static const char *app_tag_mask = "app tag mask for end-to-end PI";
53static const char *block_count = "number of blocks (zeroes based) on device to access";
54static const char *dspec_w_dtype = "directive specification associated with directive type";
55static const char *dtype = "directive type";
56static const char *force_unit_access = "force device to commit data before command completes";
57static const char *latency = "output latency statistics";
58static const char *limited_retry = "limit media access attempts";
59static const char *namespace_desired = "desired namespace";
60static const char *prinfo = "PI and check field";
61static const char *ref_tag = "reference tag for end-to-end PI";
62static const char *start_block = "64-bit LBA of first block to access";
63static const char *storage_tag = "storage tag for end-to-end PI";
64static const char *storage_tag_check = "This bit specifies if the Storage Tag field shall be checked as\n"
"part of end-to-end data protection processing";
66static const char *ish = "Ignore Shutdown (for NVMe-MI command)";

68static int open_fallback_chardev(struct libnvme_global_ctx *ctx,
		 __u32 nsid,
		 struct libnvme_transport_handle **phdl)
71{
struct libnvme_transport_handle *hdl = *phdl;
int err;

if (libnvme_transport_handle_is_ctrl(hdl)) {
__cleanup_free__attribute__((cleanup(shr_freep))) char *cdev = NULL((void*)0);

if (!nsid) {
	nvme_show_error("controller device not supported without --namespace-id")nvme_show_message(1, "controller device not supported without --namespace-id"
);
	return -EINVAL22;
}

if (asprintf(&cdev, "/dev/%sn%d",
	     libnvme_transport_handle_get_name(hdl), nsid) < 0)
	return -ENOMEM12;

libnvme_close(hdl);

err = libnvme_open(ctx, cdev, O_RDONLY00, &hdl);
if (err) {
	*phdl = NULL((void*)0);

	nvme_show_error("could not open %s", cdev)nvme_show_message(1, "could not open %s", cdev);
	return err;
}

*phdl = hdl;
}

return 0;
101}

103static int write_uncor(int argc, char **argv, struct command *acmd, struct plugin *plugin)
104{
const char *desc =
   "The Write Uncorrectable command is used to set a range of logical blocks to invalid.";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
int err;

struct config {
__u32	namespace_id;
__u64	start_block;
__u16	block_count;
__u8	dtype;
__u16	dspec;
};

struct config cfg = {
.namespace_id	= 0,
.start_block	= 0,
.block_count	= 0,
.dtype			= 0,
.dspec			= 0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_desired, 0, nvme_nsid_values}
	 namespace_desired, nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_desired, 0, nvme_nsid_values},
OPT_SUFFIX("start-block", 's', &cfg.start_block, start_block){"start-block", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.start_block, uint64_t * : (&cfg.start_block), default
 : _Generic(&cfg.start_block, unsigned long long * : (&
cfg.start_block), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, start_block, 0, },
OPT_SHRT("block-count",   'c', &cfg.block_count, block_count){"block-count", 'c', "NUM", CFG_SHORT, _Generic(&cfg.block_count
, uint16_t * : (&cfg.block_count)), ARGCONFIG_ARG_REQUIRED
, block_count, 0, },
OPT_BYTE("dir-type",      'T', &cfg.dtype,       dtype){"dir-type", 'T', "NUM", CFG_BYTE, _Generic(&cfg.dtype, uint8_t
 * : (&cfg.dtype)), ARGCONFIG_ARG_REQUIRED, dtype, 0, },
OPT_SHRT("dir-spec",      'S', &cfg.dspec,       dspec_w_dtype){"dir-spec", 'S', "NUM", CFG_SHORT, _Generic(&cfg.dspec, uint16_t
 * : (&cfg.dspec)), ARGCONFIG_ARG_REQUIRED, dspec_w_dtype
, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

if (!cfg.namespace_id) {
err = libnvme_get_nsid(hdl, &cfg.namespace_id);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

if (cfg.dtype > 0xf) {
nvme_show_error("Invalid directive type, %x",	cfg.dtype)nvme_show_message(1, "Invalid directive type, %x", cfg.dtype);
return -EINVAL22;
}

nvme_init_write_uncorrectable(&cmd, cfg.namespace_id, cfg.start_block,
cfg.block_count, cfg.dtype << 4, cfg.dspec);
err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "write uncorrectable");
return err;
}

nvme_show_verbose_result("NVME Write Uncorrectable Success")nvme_show_verbose_message("NVME Write Uncorrectable Success");

return err;
167}

169static int invalid_tags(__u64 storage_tag, __u64 ref_tag, __u8 sts, __u8 pif)
170{
if (sts < 64 && storage_tag >= (1ULL << sts)) {
nvme_show_error("Storage tag larger than the STS-defined %u-bit width", sts)nvme_show_message(1, "Storage tag larger than the STS-defined %u-bit width"
, sts);
return -ECLI_INVALID_TAGS;
}

switch (pif) {
case NVME_NVM_PIF_16B_GUARD:
if (sts > 32) {
	nvme_show_error("Storage tag size (STS=%u) larger than the 32-bit maximum allowed by 16b Guard PIF",nvme_show_message(1, "Storage tag size (STS=%u) larger than the 32-bit maximum allowed by 16b Guard PIF"
, sts)
			sts)nvme_show_message(1, "Storage tag size (STS=%u) larger than the 32-bit maximum allowed by 16b Guard PIF"
, sts);
	return -ECLI_INVALID_TAGS;
}
if (ref_tag >= (1ULL << (32 - sts))) {
	nvme_show_error("Reference tag larger than the %u-bit width allowed by 16b Guard PIF (STS=%u)",nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 16b Guard PIF (STS=%u)"
, 32 - sts, sts)
			32 - sts, sts)nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 16b Guard PIF (STS=%u)"
, 32 - sts, sts);
	return -ECLI_INVALID_TAGS;
}
break;
case NVME_NVM_PIF_32B_GUARD:
if (sts < 16 || sts > 64) {
	nvme_show_error("Storage tag size (STS=%u) outside the 16-64 range allowed by 32b Guard PIF",nvme_show_message(1, "Storage tag size (STS=%u) outside the 16-64 range allowed by 32b Guard PIF"
, sts)
			sts)nvme_show_message(1, "Storage tag size (STS=%u) outside the 16-64 range allowed by 32b Guard PIF"
, sts);
	return -ECLI_INVALID_TAGS;
}
if (sts > 16 && ref_tag >= (1ULL << (80 - sts))) {
	nvme_show_error("Reference tag larger than the %u-bit width allowed by 32b Guard PIF (STS=%u)",nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 32b Guard PIF (STS=%u)"
, 80 - sts, sts)
			80 - sts, sts)nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 32b Guard PIF (STS=%u)"
, 80 - sts, sts);
	return -ECLI_INVALID_TAGS;
}
break;
case NVME_NVM_PIF_64B_GUARD:
if (sts > 48) {
	nvme_show_error("Storage tag size (STS=%u) larger than the 48-bit maximum allowed by 64b Guard PIF",nvme_show_message(1, "Storage tag size (STS=%u) larger than the 48-bit maximum allowed by 64b Guard PIF"
, sts)
			sts)nvme_show_message(1, "Storage tag size (STS=%u) larger than the 48-bit maximum allowed by 64b Guard PIF"
, sts);
	return -ECLI_INVALID_TAGS;
}
if (sts > 0 && ref_tag >= (1ULL << (48 - sts))) {
	nvme_show_error("Reference tag larger than the %u-bit width allowed by 64b Guard PIF (STS=%u)",nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 64b Guard PIF (STS=%u)"
, 48 - sts, sts)
			48 - sts, sts)nvme_show_message(1, "Reference tag larger than the %u-bit width allowed by 64b Guard PIF (STS=%u)"
, 48 - sts, sts);
	return -ECLI_INVALID_TAGS;
}
break;
default:
nvme_show_error("Invalid PIF value: %u", pif)nvme_show_message(1, "Invalid PIF value: %u", pif);
return -ECLI_INVALID_TAGS;
}

return 0;
219}

221static int check_lbstm_byte_granularity(__u64 lbstm, __u8 sts)
222{
__u8 nr_full_bytes = sts / 8;
__u8 nr_rem_bits = sts % 8;
__u8 rem_mask, byte;
__u8 i;

if (sts > 64)
return -EINVAL22;

if (sts < 64)
lbstm &= (1ULL << sts) - 1;

for (i = 0; i < nr_full_bytes; i++) {
byte = (lbstm >> (i * 8)) & 0xff;
if (byte != 0x00 && byte != 0xff)
	return -EINVAL22;
}

if (nr_rem_bits) {
rem_mask = (1u << nr_rem_bits) - 1;
byte = (lbstm >> (nr_full_bytes * 8)) & rem_mask;
if (byte != 0x00 && byte != rem_mask)
	return -EINVAL22;
}

return 0;
248}

250static int check_lbstm_masking_not_supported(__u64 lbstm, __u8 sts)
251{
__u64 stm_mask;

if (sts > 64)
return -EINVAL22;

stm_mask = (sts < 64) ? ((1ULL << sts) - 1) : ~0ULL;
if ((lbstm & stm_mask) != stm_mask)
return -EINVAL22;

return 0;
262}

264static int get_pif_sts_via_qpif(struct nvme_nvm_id_ns *nvm_ns, __u32 elbaf,
__u8 sts, __u8 *pif)
266{
__u64 lbstm;
int err = 0;

*pif = NVME_NVM_ELBAF_QPIF(elbaf)(((elbaf) >> NVME_NVM_ELBAF_QPIF_SHIFT) & NVME_NVM_ELBAF_QPIF_MASK
);

lbstm = le64_to_cpu(nvm_ns->lbstm);
switch (NVME_NVM_PIFA_STMLA(nvm_ns->pifa)(((nvm_ns->pifa) >> NVME_NVM_PIFA_STMLA_SHIFT) &
 NVME_NVM_PIFA_STMLA_MASK)) {
case NVME_NVM_PIFA_BIT_GRANULARITY_MASKING:
break;
case NVME_NVM_PIFA_BYTE_GRANULARITY_MASKING:
err = check_lbstm_byte_granularity(lbstm, sts);
break;
case NVME_NVM_PIFA_MASKING_NOT_SUPPORTED:
err = check_lbstm_masking_not_supported(lbstm, sts);
break;
default:
err = -EINVAL22;
break;
}

if (!err)
return 0;

nvme_show_error("Logical Block Storage Tag Mask is inconsistent with the Storage Tag Masking Level Attribute")nvme_show_message(1, "Logical Block Storage Tag Mask is inconsistent with the Storage Tag Masking Level Attribute"
);

return -ECLI_INVALID_PI_FORMAT;
293}

295static int get_pif_sts(struct nvme_id_ns *ns, struct nvme_nvm_id_ns *nvm_ns,
__u8 *pif, __u8 *sts)
297{
__u8 lba_index;
__u32 elbaf;

nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &lba_index);
elbaf = le32_to_cpu(nvm_ns->elbaf[lba_index]);
*sts = NVME_NVM_ELBAF_STS(elbaf)(((elbaf) >> NVME_NVM_ELBAF_STS_SHIFT) & NVME_NVM_ELBAF_STS_MASK
);
*pif = NVME_NVM_ELBAF_PIF(elbaf)(((elbaf) >> NVME_NVM_ELBAF_PIF_SHIFT) & NVME_NVM_ELBAF_PIF_MASK
);

if (*pif == NVME_NVM_PIF_QTYPE && NVME_NVM_PIC_QPIFS(nvm_ns->pic)(((nvm_ns->pic) >> NVME_NVM_PIC_QPIFS_SHIFT) & NVME_NVM_PIC_QPIFS_MASK
))
return get_pif_sts_via_qpif(nvm_ns, elbaf, *sts, pif);

return 0;
310}

312static int get_pi_info(struct libnvme_transport_handle *hdl,
__u32 nsid, __u8 prinfo, __u64 ilbrt, __u64 lbst,
unsigned int *logical_block_size, __u16 *metadata_size)
315{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_nvm_id_ns *nvm_ns = NULL((void*)0);
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ns *ns = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
__u8 sts = 0, pif = 0;
unsigned int lbs = 0;
__u8 lba_index;
int pi_size;
__u16 ms;
int err;

ns = libnvme_alloc(sizeof(*ns));
if (!ns)
return -ENOMEM12;

nvme_init_identify_ns(&cmd, nsid, ns);
err = libnvme_exec_admin_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "identify namespace");
return -ECLI_IDENTIFY_NS_FAILED;
}

nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &lba_index);
if (ns->lbaf[lba_index].ds >= 32) {
nvme_show_error("invalid LBA data size %u",nvme_show_message(1, "invalid LBA data size %u", ns->lbaf[
lba_index].ds)
		ns->lbaf[lba_index].ds)nvme_show_message(1, "invalid LBA data size %u", ns->lbaf[
lba_index].ds);
return -ECLI_INVALID_LBA_FORMAT;
}
lbs = 1U << ns->lbaf[lba_index].ds;
ms = le16_to_cpu(ns->lbaf[lba_index].ms);
/*
* Conservative fallback: if Identify NVM CS NS below fails for any
* reason other than Invalid Field, we return early with PI simply
* unavailable, and this is the size submit_io() will use. For an
* extended-LBA namespace the metadata is always part of the
* transfer, so publish the full size now; the PRACT exception below
* can only shrink it once PI info actually comes back.
*/
*logical_block_size = lbs + (NVME_FLBAS_META_EXT(ns->flbas)(((ns->flbas) >> NVME_FLBAS_META_EXT_SHIFT) & NVME_FLBAS_META_EXT_MASK
) ? ms : 0);
*metadata_size = ms;

nvm_ns = libnvme_alloc(sizeof(*nvm_ns));
if (!nvm_ns)
return -ENOMEM12;

nvme_init_identify_csi_ns(&cmd, nsid, NVME_CSI_NVM, 0, nvm_ns);
err = libnvme_exec_admin_passthru(hdl, &cmd);
if (!err) {
err = get_pif_sts(ns, nvm_ns, &pif, &sts);
if (err)
	return err;
} else if (!nvme_status_equals(err, NVME_STATUS_TYPE_NVME,
		       NVME_SC_INVALID_FIELD)) {
return err;
}

pi_size = (pif == NVME_NVM_PIF_16B_GUARD) ? 8 : 16;
if (NVME_FLBAS_META_EXT(ns->flbas)(((ns->flbas) >> NVME_FLBAS_META_EXT_SHIFT) & NVME_FLBAS_META_EXT_MASK
)) {
/*
 * No meta data is transferred for PRACT=1 and MD=PI size:
 *   5.2.2.1 Protection Information and Write Commands
 *   5.2.2.2 Protection Information and Read Commands
 */
if (!((prinfo & 0x8) != 0 && ms == pi_size))
	lbs += ms;
}

err = invalid_tags(lbst, ilbrt, sts, pif);
if (err)
return err;

*logical_block_size = lbs;
*metadata_size = ms;

return 0;
390}

392static int init_pi_tags(struct libnvme_transport_handle *hdl,
struct libnvme_passthru_cmd *cmd, __u32 nsid, __u64 ilbrt, __u64 lbst,
__u16 lbat, __u16 lbatm)
395{
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_nvm_id_ns *nvm_ns = NULL((void*)0);
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_id_ns *ns = NULL((void*)0);
struct libnvme_passthru_cmd id_cmd;
__u8 sts = 0, pif = 0;
int err = 0;

ns = libnvme_alloc(sizeof(*ns));
if (!ns)
return -ENOMEM12;

nvme_init_identify_ns(&id_cmd, nsid, ns);
err = libnvme_exec_admin_passthru(hdl, &id_cmd);
if (err) {
nvme_show_err(err, "identify namespace");
return err;
}

nvm_ns = libnvme_alloc(sizeof(*nvm_ns));
if (!nvm_ns)
return -ENOMEM12;

nvme_init_identify_csi_ns(&id_cmd, nsid, NVME_CSI_NVM, 0, nvm_ns);
err = libnvme_exec_admin_passthru(hdl, &id_cmd);
if (!err) {
err = get_pif_sts(ns, nvm_ns, &pif, &sts);
if (err)
	return err;
} else if (nvme_status_get_type(err) != NVME_STATUS_TYPE_NVME ||
   nvme_status_code(nvme_status_get_value(err)) != NVME_SC_INVALID_FIELD) {
return err;
}

err = invalid_tags(lbst, ilbrt, sts, pif);
if (err)
return err;

nvme_init_var_size_tags(cmd, pif, sts, ilbrt, lbst);
nvme_init_app_tag(cmd, lbat, lbatm);

return 0;
436}

438static int write_zeroes(int argc, char **argv,
struct command *acmd, struct plugin *plugin)
440{
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
__u16 control = 0;
int err;

const char *desc =
   "The Write Zeroes command is used to set a range of logical blocks to zero.";
const char *deac =
   "Set DEAC bit, requesting controller to deallocate specified logical blocks";
const char *nsz = "Clear all logical blocks to zero in the entire namespace";

struct config {
__u32	nsid;
__u64	start_block;
__u16	block_count;
__u8	dtype;
bool_Bool	deac;
bool_Bool	limited_retry;
bool_Bool	force_unit_access;
__u8	prinfo;
__u64	ilbrt;
__u16	lbatm;
__u16	lbat;
__u64	lbst;
bool_Bool	stc;
__u16	dspec;
bool_Bool	nsz;
};

struct config cfg = {
.nsid				= 0,
.start_block		= 0,
.block_count		= 0,
.dtype				= 0,
.deac				= false0,
.limited_retry		= false0,
.force_unit_access	= false0,
.prinfo				= 0,
.ilbrt				= 0,
.lbatm				= 0,
.lbat				= 0,
.lbst				= 0,
.stc				= false0,
.dspec				= 0,
.nsz				= false0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.nsid, namespace_desired,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_desired
, 0, nvme_nsid_values}
	 nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_desired
, 0, nvme_nsid_values},
OPT_SUFFIX("start-block", 's', &cfg.start_block, start_block){"start-block", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.start_block, uint64_t * : (&cfg.start_block), default
 : _Generic(&cfg.start_block, unsigned long long * : (&
cfg.start_block), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, start_block, 0, },
OPT_SHRT("block-count",   'c', &cfg.block_count, block_count){"block-count", 'c', "NUM", CFG_SHORT, _Generic(&cfg.block_count
, uint16_t * : (&cfg.block_count)), ARGCONFIG_ARG_REQUIRED
, block_count, 0, },
OPT_BYTE("dir-type",      'T', &cfg.dtype,       dtype){"dir-type", 'T', "NUM", CFG_BYTE, _Generic(&cfg.dtype, uint8_t
 * : (&cfg.dtype)), ARGCONFIG_ARG_REQUIRED, dtype, 0, },
OPT_FLAG("deac",          'd', &cfg.deac,        deac){"deac", 'd', ((void*)0), CFG_FLAG, _Generic(&cfg.deac, _Bool
 * : (&cfg.deac)), ARGCONFIG_ARG_NONE, deac, 0, },
OPT_FLAG("limited-retry", 'l', &cfg.limited_retry,{"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry, 0, }
	 limited_retry){"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry, 0, },
OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access,{"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access, 0, }
	 force_unit_access){"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access, 0, },
OPT_BYTE("prinfo",        'p', &cfg.prinfo,      prinfo){"prinfo", 'p', "NUM", CFG_BYTE, _Generic(&cfg.prinfo, uint8_t
 * : (&cfg.prinfo)), ARGCONFIG_ARG_REQUIRED, prinfo, 0, },
OPT_SUFFIX("ref-tag",     'r', &cfg.ilbrt,       ref_tag){"ref-tag", 'r', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg.
ilbrt, uint64_t * : (&cfg.ilbrt), default : _Generic(&
cfg.ilbrt, unsigned long long * : (&cfg.ilbrt), default :
 (void)0)), ARGCONFIG_ARG_REQUIRED, ref_tag, 0, },
OPT_SHRT("app-tag-mask",  'm', &cfg.lbatm,       app_tag_mask){"app-tag-mask", 'm', "NUM", CFG_SHORT, _Generic(&cfg.lbatm
, uint16_t * : (&cfg.lbatm)), ARGCONFIG_ARG_REQUIRED, app_tag_mask
, 0, },
OPT_SHRT("app-tag",       'a', &cfg.lbat,        app_tag){"app-tag", 'a', "NUM", CFG_SHORT, _Generic(&cfg.lbat, uint16_t
 * : (&cfg.lbat)), ARGCONFIG_ARG_REQUIRED, app_tag, 0, },
OPT_SUFFIX("storage-tag", 'S', &cfg.lbst,        storage_tag){"storage-tag", 'S', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.lbst, uint64_t * : (&cfg.lbst), default : _Generic(&
cfg.lbst, unsigned long long * : (&cfg.lbst), default : (
void)0)), ARGCONFIG_ARG_REQUIRED, storage_tag, 0, },
OPT_FLAG("storage-tag-check", 'C', &cfg.stc, storage_tag_check){"storage-tag-check", 'C', ((void*)0), CFG_FLAG, _Generic(&
cfg.stc, _Bool * : (&cfg.stc)), ARGCONFIG_ARG_NONE, storage_tag_check
, 0, },
OPT_SHRT("dir-spec",      'D', &cfg.dspec,       dspec_w_dtype){"dir-spec", 'D', "NUM", CFG_SHORT, _Generic(&cfg.dspec, uint16_t
 * : (&cfg.dspec)), ARGCONFIG_ARG_REQUIRED, dspec_w_dtype
, 0, },
OPT_FLAG("namespace-zeroes", 'Z', &cfg.nsz, nsz){"namespace-zeroes", 'Z', ((void*)0), CFG_FLAG, _Generic(&
cfg.nsz, _Bool * : (&cfg.nsz)), ARGCONFIG_ARG_NONE, nsz, 0
, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

if (cfg.prinfo > 0xf)
return -EINVAL22;

if (cfg.dtype > 0x7) {
nvme_show_error("Invalid directive type, %x", cfg.dtype)nvme_show_message(1, "Invalid directive type, %x", cfg.dtype);
return -EINVAL22;
}

control |= (cfg.prinfo << 10);
if (cfg.limited_retry)
control |= NVME_IO_LR;
if (cfg.force_unit_access)
control |= NVME_IO_FUA;
if (cfg.deac)
control |= NVME_IO_DEAC;
if (cfg.stc)
control |= NVME_IO_STC;
if (cfg.nsz)
control |= NVME_IO_NSZ;
control |= (cfg.dtype << 4);
if (!cfg.nsid) {
err = libnvme_get_nsid(hdl, &cfg.nsid);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

nvme_init_write_zeros(&cmd, cfg.nsid, cfg.start_block, cfg.block_count,
	      control, cfg.dspec, 0, 0);

err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst, cfg.lbat,
	   cfg.lbatm);
if (err)
return err;

err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "write-zeroes");
return err;
}

nvme_show_verbose_result("NVME Write Zeroes Success")nvme_show_verbose_message("NVME Write Zeroes Success");

if (!cfg.nsz || !nvme_args.verbose)
return err;

if (cmd.result & 0x1)
nvme_show_result(nvme_show_message(0, "All logical blocks in the entire namespace cleared to zero"
)
    "All logical blocks in the entire namespace cleared to zero")nvme_show_message(0, "All logical blocks in the entire namespace cleared to zero"
);
else
nvme_show_result("%d logical blocks cleared to zero", cfg.block_count)nvme_show_message(0, "%d logical blocks cleared to zero", cfg
.block_count);

return err;
569}

571static int dsm(int argc, char **argv, struct command *acmd, struct plugin *plugin)
572{
const char *desc = "The Dataset Management command is used by the host to\n"
"indicate attributes for ranges of logical blocks. This includes attributes\n"
"for discarding unused blocks, data read and write frequency, access size, and other\n"
"information that may be used to optimize performance and reliability.";
const char *blocks = "Comma separated list of the number of blocks in each range";
const char *starting_blocks = "Comma separated list of the starting block in each range";
const char *context_attrs = "Comma separated list of the context attributes in each range";
const char *ad = "Attribute Deallocate";
const char *idw = "Attribute Integral Dataset for Write";
const char *idr = "Attribute Integral Dataset for Read";
const char *cdw11 = "All the command DWORD 11 attributes. Use instead of specifying individual attributes";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) struct nvme_dsm_range *dsm = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
__u32 ctx_attrs[NVME_DSM_MAX_RANGES] = {0,};
__u32 nlbs[NVME_DSM_MAX_RANGES] = {0,};
__u64 slbas[NVME_DSM_MAX_RANGES] = {0,};
uint16_t nc, nb, ns;
int err;

struct config {
__u32	namespace_id;
char	*ctx_attrs;
char	*blocks;
char	*slbas;
bool_Bool	ad;
bool_Bool	idw;
bool_Bool	idr;
__u32	cdw11;
};

struct config cfg = {
.namespace_id	= 0,
.ctx_attrs	= "",
.blocks		= "",
.slbas		= "",
.ad		= false0,
.idw		= false0,
.idr		= false0,
.cdw11		= 0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_id_desired, 0, nvme_nsid_values}
	 namespace_id_desired, nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_id_desired, 0, nvme_nsid_values},
OPT_LIST("ctx-attrs", 'a', &cfg.ctx_attrs, context_attrs){"ctx-attrs", 'a', "LIST", CFG_STRING, _Generic(&cfg.ctx_attrs
, char ** : (&cfg.ctx_attrs), const char ** : (&cfg.ctx_attrs
)), ARGCONFIG_ARG_REQUIRED, context_attrs, 0, },
OPT_LIST("blocks",    'b', &cfg.blocks,    blocks){"blocks", 'b', "LIST", CFG_STRING, _Generic(&cfg.blocks,
 char ** : (&cfg.blocks), const char ** : (&cfg.blocks
)), ARGCONFIG_ARG_REQUIRED, blocks, 0, },
OPT_LIST("slbs",      's', &cfg.slbas,     starting_blocks){"slbs", 's', "LIST", CFG_STRING, _Generic(&cfg.slbas, char
 ** : (&cfg.slbas), const char ** : (&cfg.slbas)), ARGCONFIG_ARG_REQUIRED
, starting_blocks, 0, },
OPT_FLAG("ad",        'd', &cfg.ad,        ad){"ad", 'd', ((void*)0), CFG_FLAG, _Generic(&cfg.ad, _Bool
 * : (&cfg.ad)), ARGCONFIG_ARG_NONE, ad, 0, },
OPT_FLAG("idw",       'w', &cfg.idw,       idw){"idw", 'w', ((void*)0), CFG_FLAG, _Generic(&cfg.idw, _Bool
 * : (&cfg.idw)), ARGCONFIG_ARG_NONE, idw, 0, },
OPT_FLAG("idr",       'r', &cfg.idr,       idr){"idr", 'r', ((void*)0), CFG_FLAG, _Generic(&cfg.idr, _Bool
 * : (&cfg.idr)), ARGCONFIG_ARG_NONE, idr, 0, },
OPT_UINT("cdw11",     'c', &cfg.cdw11,     cdw11){"cdw11", 'c', "NUM", CFG_POSITIVE, _Generic(&cfg.cdw11, uint32_t
 * : (&cfg.cdw11)), ARGCONFIG_ARG_REQUIRED, cdw11, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

err = open_fallback_chardev(ctx, cfg.namespace_id, &hdl);
if (err)
return err;

nc = shr_parse_csv_u32(cfg.ctx_attrs, ctx_attrs, ARRAY_SIZE(ctx_attrs))shr_parse_csv_uint(cfg.ctx_attrs, (unsigned int *)(ctx_attrs)
 + (sizeof(char [1 - 2*!(sizeof(*(ctx_attrs)) == sizeof(unsigned
 int))]) - 1), (sizeof(ctx_attrs) / sizeof((ctx_attrs)[0]) + 0
));
nb = shr_parse_csv_u32(cfg.blocks, nlbs, ARRAY_SIZE(nlbs))shr_parse_csv_uint(cfg.blocks, (unsigned int *)(nlbs) + (sizeof
(char [1 - 2*!(sizeof(*(nlbs)) == sizeof(unsigned int))]) - 1
), (sizeof(nlbs) / sizeof((nlbs)[0]) + 0));
ns = shr_parse_csv_u64(cfg.slbas, slbas, ARRAY_SIZE(slbas))shr_parse_csv_ulonglong(cfg.slbas, (unsigned long long *)(slbas
) + (sizeof(char [1 - 2*!(sizeof(*(slbas)) == sizeof(unsigned
 long long))]) - 1), (sizeof(slbas) / sizeof((slbas)[0]) + 0)
);
if ((nb != ns) ||
   (argconfig_given(opts, &cfg.ctx_attrs) && nb != nc)) {
nvme_show_error("No valid range definition provided")nvme_show_message(1, "No valid range definition provided");
return -EINVAL22;
}
if (!nb || nb > NVME_DSM_MAX_RANGES) {
nvme_show_error("No range definition provided")nvme_show_message(1, "No range definition provided");
return -EINVAL22;
}

if (!cfg.namespace_id) {
err = libnvme_get_nsid(hdl, &cfg.namespace_id);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}
if (cfg.cdw11) {
cfg.ad = NVME_GET(cfg.cdw11, DSM_CDW11_AD)(((cfg.cdw11) >> NVME_DSM_CDW11_AD_SHIFT) & NVME_DSM_CDW11_AD_MASK
);
cfg.idw = NVME_GET(cfg.cdw11, DSM_CDW11_IDW)(((cfg.cdw11) >> NVME_DSM_CDW11_IDW_SHIFT) & NVME_DSM_CDW11_IDW_MASK
);
cfg.idr = NVME_GET(cfg.cdw11, DSM_CDW11_IDR)(((cfg.cdw11) >> NVME_DSM_CDW11_IDR_SHIFT) & NVME_DSM_CDW11_IDR_MASK
);
}

dsm = libnvme_alloc(sizeof(*dsm) * nb);
if (!dsm)
return -ENOMEM12;

nvme_init_dsm_range(dsm, ctx_attrs, nlbs, slbas, nb);
nvme_init_dsm(&cmd, cfg.namespace_id, nb, cfg.idr, cfg.idw, cfg.ad, dsm,
      sizeof(*dsm) * nb);
err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "data-set management");
return err;
}

nvme_show_verbose_result("NVMe DSM: success")nvme_show_verbose_message("NVMe DSM: success");

return err;
680}

682static int copy_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
683{
const char *desc = "The Copy command is used by the host to copy data\n"
"from one or more source logical block ranges to a\n"
"single consecutive destination logical block range.";
const char *d_sdlba = "64-bit addr of first destination logical block";
const char *d_slbas = "64-bit addr of first block per range (comma-separated list)";
const char *d_nlbs = "number of blocks per range (comma-separated list, zeroes-based values)";
const char *d_snsids = "source namespace identifier per range (comma-separated list)";
const char *d_sopts = "source options per range (comma-separated list)";
const char *d_lr = "limited retry";
const char *d_fua = "force unit access";
const char *d_prinfor = "protection information and check field (read part)";
const char *d_prinfow = "protection information and check field (write part)";
const char *d_ilbrt = "initial lba reference tag (write part)";
const char *d_eilbrts = "expected lba reference tags (read part, comma-separated list)";
const char *d_lbat = "lba application tag (write part)";
const char *d_elbats = "expected lba application tags (read part, comma-separated list)";
const char *d_lbatm = "lba application tag mask (write part)";
const char *d_elbatms = "expected lba application tag masks (read part, comma-separated list)";
const char *d_dtype = "directive type (write part)";
const char *d_dspec = "directive specific (write part)";
const char *d_format = "source range entry format";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
__u16 nr, nb, ns, nrts, natms, nats, nids;
struct libnvme_passthru_cmd cmd;
__u16 nlbs[256] = { 0 };
__u64 slbas[256] = { 0 };
__u32 snsids[256] = { 0 };
__u16 sopts[256] = { 0 };
int err;

union {
__u32 short_pi[256];
__u64 long_pi[256];
} eilbrts;

__u16 elbatms[256] = { 0 };
__u16 elbats[256] = { 0 };

__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) union {
struct nvme_copy_range_f0 f0[256];
struct nvme_copy_range_f1 f1[256];
struct nvme_copy_range_f2 f2[256];
struct nvme_copy_range_f3 f3[256];
} *copy = NULL((void*)0);

struct config {
__u32	nsid;
__u64	sdlba;
char	*slbas;
char	*nlbs;
char	*snsids;
char	*sopts;
bool_Bool	lr;
bool_Bool	fua;
__u8	prinfow;
__u8	prinfor;
__u64	ilbrt;
char	*eilbrts;
__u16	lbat;
char	*elbats;
__u16	lbatm;
char	*elbatms;
__u8	dtype;
__u16	dspec;
__u8	format;
__u64	lbst;
bool_Bool	stc;
};

struct config cfg = {
.nsid		= 0,
.sdlba		= 0,
.slbas		= "",
.nlbs		= "",
.snsids		= "",
.sopts		= "",
.lr			= false0,
.fua		= false0,
.prinfow	= 0,
.prinfor	= 0,
.ilbrt		= 0,
.eilbrts	= "",
.lbat		= 0,
.elbats		= "",
.lbatm		= 0,
.elbatms	= "",
.dtype		= 0,
.dspec		= 0,
.format		= 0,
.lbst		= 0,
.stc		= false0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.nsid, namespace_id_desired,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_id_desired
, 0, nvme_nsid_values}
	 nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_id_desired
, 0, nvme_nsid_values},
OPT_SUFFIX("sdlba",           'd', &cfg.sdlba,   d_sdlba){"sdlba", 'd', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg.sdlba
, uint64_t * : (&cfg.sdlba), default : _Generic(&cfg.
sdlba, unsigned long long * : (&cfg.sdlba), default : (void
)0)), ARGCONFIG_ARG_REQUIRED, d_sdlba, 0, },
OPT_LIST("slbs",              's', &cfg.slbas,   d_slbas){"slbs", 's', "LIST", CFG_STRING, _Generic(&cfg.slbas, char
 ** : (&cfg.slbas), const char ** : (&cfg.slbas)), ARGCONFIG_ARG_REQUIRED
, d_slbas, 0, },
OPT_LIST("blocks",            'b', &cfg.nlbs,    d_nlbs){"blocks", 'b', "LIST", CFG_STRING, _Generic(&cfg.nlbs, char
 ** : (&cfg.nlbs), const char ** : (&cfg.nlbs)), ARGCONFIG_ARG_REQUIRED
, d_nlbs, 0, },
OPT_LIST("snsids",            'N', &cfg.snsids,  d_snsids){"snsids", 'N', "LIST", CFG_STRING, _Generic(&cfg.snsids,
 char ** : (&cfg.snsids), const char ** : (&cfg.snsids
)), ARGCONFIG_ARG_REQUIRED, d_snsids, 0, },
OPT_LIST("sopts",             'O', &cfg.sopts,   d_sopts){"sopts", 'O', "LIST", CFG_STRING, _Generic(&cfg.sopts, char
 ** : (&cfg.sopts), const char ** : (&cfg.sopts)), ARGCONFIG_ARG_REQUIRED
, d_sopts, 0, },
OPT_FLAG("limited-retry",     'l', &cfg.lr,      d_lr){"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.lr, _Bool * : (&cfg.lr)), ARGCONFIG_ARG_NONE, d_lr, 0, },
OPT_FLAG("force-unit-access", 'f', &cfg.fua,     d_fua){"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.fua, _Bool * : (&cfg.fua)), ARGCONFIG_ARG_NONE, d_fua
, 0, },
OPT_BYTE("prinfow",           'p', &cfg.prinfow, d_prinfow){"prinfow", 'p', "NUM", CFG_BYTE, _Generic(&cfg.prinfow, uint8_t
 * : (&cfg.prinfow)), ARGCONFIG_ARG_REQUIRED, d_prinfow, 0
, },
OPT_BYTE("prinfor",           'P', &cfg.prinfor, d_prinfor){"prinfor", 'P', "NUM", CFG_BYTE, _Generic(&cfg.prinfor, uint8_t
 * : (&cfg.prinfor)), ARGCONFIG_ARG_REQUIRED, d_prinfor, 0
, },
OPT_SUFFIX("ref-tag",         'r', &cfg.ilbrt,   d_ilbrt){"ref-tag", 'r', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg.
ilbrt, uint64_t * : (&cfg.ilbrt), default : _Generic(&
cfg.ilbrt, unsigned long long * : (&cfg.ilbrt), default :
 (void)0)), ARGCONFIG_ARG_REQUIRED, d_ilbrt, 0, },
OPT_LIST("expected-ref-tags", 'R', &cfg.eilbrts, d_eilbrts){"expected-ref-tags", 'R', "LIST", CFG_STRING, _Generic(&
cfg.eilbrts, char ** : (&cfg.eilbrts), const char ** : (&
cfg.eilbrts)), ARGCONFIG_ARG_REQUIRED, d_eilbrts, 0, },
OPT_SHRT("app-tag",           'a', &cfg.lbat,    d_lbat){"app-tag", 'a', "NUM", CFG_SHORT, _Generic(&cfg.lbat, uint16_t
 * : (&cfg.lbat)), ARGCONFIG_ARG_REQUIRED, d_lbat, 0, },
OPT_LIST("expected-app-tags", 'A', &cfg.elbats,  d_elbats){"expected-app-tags", 'A', "LIST", CFG_STRING, _Generic(&
cfg.elbats, char ** : (&cfg.elbats), const char ** : (&
cfg.elbats)), ARGCONFIG_ARG_REQUIRED, d_elbats, 0, },
OPT_SHRT("app-tag-mask",      'm', &cfg.lbatm,   d_lbatm){"app-tag-mask", 'm', "NUM", CFG_SHORT, _Generic(&cfg.lbatm
, uint16_t * : (&cfg.lbatm)), ARGCONFIG_ARG_REQUIRED, d_lbatm
, 0, },
OPT_LIST("expected-app-tag-masks", 'M', &cfg.elbatms,{"expected-app-tag-masks", 'M', "LIST", CFG_STRING, _Generic(
&cfg.elbatms, char ** : (&cfg.elbatms), const char **
 : (&cfg.elbatms)), ARGCONFIG_ARG_REQUIRED, d_elbatms, 0,
 }
	 d_elbatms){"expected-app-tag-masks", 'M', "LIST", CFG_STRING, _Generic(
&cfg.elbatms, char ** : (&cfg.elbatms), const char **
 : (&cfg.elbatms)), ARGCONFIG_ARG_REQUIRED, d_elbatms, 0,
 },
OPT_BYTE("dir-type",          'T', &cfg.dtype,   d_dtype){"dir-type", 'T', "NUM", CFG_BYTE, _Generic(&cfg.dtype, uint8_t
 * : (&cfg.dtype)), ARGCONFIG_ARG_REQUIRED, d_dtype, 0, },
OPT_SHRT("dir-spec",          'S', &cfg.dspec,   d_dspec){"dir-spec", 'S', "NUM", CFG_SHORT, _Generic(&cfg.dspec, uint16_t
 * : (&cfg.dspec)), ARGCONFIG_ARG_REQUIRED, d_dspec, 0, },
OPT_BYTE("format",            'F', &cfg.format,  d_format){"format", 'F', "NUM", CFG_BYTE, _Generic(&cfg.format, uint8_t
 * : (&cfg.format)), ARGCONFIG_ARG_REQUIRED, d_format, 0,
 },
OPT_SUFFIX("storage-tag",     't', &cfg.lbst,    storage_tag){"storage-tag", 't', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.lbst, uint64_t * : (&cfg.lbst), default : _Generic(&
cfg.lbst, unsigned long long * : (&cfg.lbst), default : (
void)0)), ARGCONFIG_ARG_REQUIRED, storage_tag, 0, },
OPT_FLAG("storage-tag-check", 'c', &cfg.stc, storage_tag_check){"storage-tag-check", 'c', ((void*)0), CFG_FLAG, _Generic(&
cfg.stc, _Bool * : (&cfg.stc)), ARGCONFIG_ARG_NONE, storage_tag_check
, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

nb = shr_parse_csv_u16(cfg.nlbs, nlbs, ARRAY_SIZE(nlbs))shr_parse_csv_ushort(cfg.nlbs, (unsigned short *)(nlbs) + (sizeof
(char [1 - 2*!(sizeof(*(nlbs)) == sizeof(unsigned short))]) -
 1), (sizeof(nlbs) / sizeof((nlbs)[0]) + 0));
ns = shr_parse_csv_u64(cfg.slbas, slbas, ARRAY_SIZE(slbas))shr_parse_csv_ulonglong(cfg.slbas, (unsigned long long *)(slbas
) + (sizeof(char [1 - 2*!(sizeof(*(slbas)) == sizeof(unsigned
 long long))]) - 1), (sizeof(slbas) / sizeof((slbas)[0]) + 0)
);
nids = shr_parse_csv_u32(cfg.snsids, snsids, ARRAY_SIZE(snsids))shr_parse_csv_uint(cfg.snsids, (unsigned int *)(snsids) + (sizeof
(char [1 - 2*!(sizeof(*(snsids)) == sizeof(unsigned int))]) -
 1), (sizeof(snsids) / sizeof((snsids)[0]) + 0));
shr_parse_csv_u16(cfg.sopts, sopts, ARRAY_SIZE(sopts))shr_parse_csv_ushort(cfg.sopts, (unsigned short *)(sopts) + (
sizeof(char [1 - 2*!(sizeof(*(sopts)) == sizeof(unsigned short
))]) - 1), (sizeof(sopts) / sizeof((sopts)[0]) + 0));

switch (cfg.format) {
case 0:
case 2:
nrts = shr_parse_csv_u32(cfg.eilbrts,shr_parse_csv_uint(cfg.eilbrts, (unsigned int *)(eilbrts.short_pi
) + (sizeof(char [1 - 2*!(sizeof(*(eilbrts.short_pi)) == sizeof
(unsigned int))]) - 1), (sizeof(eilbrts.short_pi) / sizeof((eilbrts
.short_pi)[0]) + 0))
	eilbrts.short_pi, ARRAY_SIZE(eilbrts.short_pi))shr_parse_csv_uint(cfg.eilbrts, (unsigned int *)(eilbrts.short_pi
) + (sizeof(char [1 - 2*!(sizeof(*(eilbrts.short_pi)) == sizeof
(unsigned int))]) - 1), (sizeof(eilbrts.short_pi) / sizeof((eilbrts
.short_pi)[0]) + 0));
break;
case 1:
case 3:
nrts = shr_parse_csv_u64(cfg.eilbrts,shr_parse_csv_ulonglong(cfg.eilbrts, (unsigned long long *)(eilbrts
.long_pi) + (sizeof(char [1 - 2*!(sizeof(*(eilbrts.long_pi)) ==
 sizeof(unsigned long long))]) - 1), (sizeof(eilbrts.long_pi)
 / sizeof((eilbrts.long_pi)[0]) + 0))
	eilbrts.long_pi, ARRAY_SIZE(eilbrts.long_pi))shr_parse_csv_ulonglong(cfg.eilbrts, (unsigned long long *)(eilbrts
.long_pi) + (sizeof(char [1 - 2*!(sizeof(*(eilbrts.long_pi)) ==
 sizeof(unsigned long long))]) - 1), (sizeof(eilbrts.long_pi)
 / sizeof((eilbrts.long_pi)[0]) + 0));
break;
default:
nvme_show_error("invalid format")nvme_show_message(1, "invalid format");
return -EINVAL22;
}

natms = shr_parse_csv_u16(cfg.elbatms, elbatms,shr_parse_csv_ushort(cfg.elbatms, (unsigned short *)(elbatms)
 + (sizeof(char [1 - 2*!(sizeof(*(elbatms)) == sizeof(unsigned
 short))]) - 1), (sizeof(elbatms) / sizeof((elbatms)[0]) + 0)
)
				    ARRAY_SIZE(elbatms))shr_parse_csv_ushort(cfg.elbatms, (unsigned short *)(elbatms)
 + (sizeof(char [1 - 2*!(sizeof(*(elbatms)) == sizeof(unsigned
 short))]) - 1), (sizeof(elbatms) / sizeof((elbatms)[0]) + 0)
);
nats = shr_parse_csv_u16(cfg.elbats, elbats,shr_parse_csv_ushort(cfg.elbats, (unsigned short *)(elbats) +
 (sizeof(char [1 - 2*!(sizeof(*(elbats)) == sizeof(unsigned short
))]) - 1), (sizeof(elbats) / sizeof((elbats)[0]) + 0))
				   ARRAY_SIZE(elbats))shr_parse_csv_ushort(cfg.elbats, (unsigned short *)(elbats) +
 (sizeof(char [1 - 2*!(sizeof(*(elbats)) == sizeof(unsigned short
))]) - 1), (sizeof(elbats) / sizeof((elbats)[0]) + 0));

nr = max(nb, max(ns, max(nrts, max(natms, nats))))({ typeof(nb) _a = (nb); typeof(({ typeof(ns) _a = (ns); typeof
(({ typeof(nrts) _a = (nrts); typeof(({ typeof(natms) _a = (natms
); typeof(nats) _b = (nats); do { } while (0); _a > _b ? _a
 : _b; })) _b = (({ typeof(natms) _a = (natms); typeof(nats) _b
 = (nats); do { } while (0); _a > _b ? _a : _b; })); do { }
 while (0); _a > _b ? _a : _b; })) _b = (({ typeof(nrts) _a
 = (nrts); typeof(({ typeof(natms) _a = (natms); typeof(nats)
 _b = (nats); do { } while (0); _a > _b ? _a : _b; })) _b =
 (({ typeof(natms) _a = (natms); typeof(nats) _b = (nats); do
 { } while (0); _a > _b ? _a : _b; })); do { } while (0); _a
 > _b ? _a : _b; })); do { } while (0); _a > _b ? _a : _b
; })) _b = (({ typeof(ns) _a = (ns); typeof(({ typeof(nrts) _a
 = (nrts); typeof(({ typeof(natms) _a = (natms); typeof(nats)
 _b = (nats); do { } while (0); _a > _b ? _a : _b; })) _b =
 (({ typeof(natms) _a = (natms); typeof(nats) _b = (nats); do
 { } while (0); _a > _b ? _a : _b; })); do { } while (0); _a
 > _b ? _a : _b; })) _b = (({ typeof(nrts) _a = (nrts); typeof
(({ typeof(natms) _a = (natms); typeof(nats) _b = (nats); do {
 } while (0); _a > _b ? _a : _b; })) _b = (({ typeof(natms
) _a = (natms); typeof(nats) _b = (nats); do { } while (0); _a
 > _b ? _a : _b; })); do { } while (0); _a > _b ? _a : _b
; })); do { } while (0); _a > _b ? _a : _b; })); do { } while
 (0); _a > _b ? _a : _b; });
if (cfg.format == 2 || cfg.format == 3) {
if (nr != nids) {
	nvme_show_error("formats 2 and 3 require source namespace ids for each source range")nvme_show_message(1, "formats 2 and 3 require source namespace ids for each source range"
);
	return -EINVAL22;
}
} else if (nids) {
nvme_show_error("formats 0 and 1 do not support cross-namespace copy")nvme_show_message(1, "formats 0 and 1 do not support cross-namespace copy"
);
return -EINVAL22;
}
if (!nr || nr > 256) {
nvme_show_error("invalid range")nvme_show_message(1, "invalid range");
return -EINVAL22;
}

if (!cfg.nsid) {
err = libnvme_get_nsid(hdl, &cfg.nsid);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

copy = libnvme_alloc(sizeof(*copy));
if (!copy)
return -ENOMEM12;

switch (cfg.format) {
case 1:
nvme_init_copy_range_f1(copy->f1, nlbs, slbas, eilbrts.long_pi,
			elbatms, elbats, nr);
break;
case 2:
nvme_init_copy_range_f2(copy->f2, snsids, nlbs, slbas, sopts,
			eilbrts.short_pi, elbatms, elbats, nr);
break;
case 3:
nvme_init_copy_range_f3(copy->f3, snsids, nlbs, slbas, sopts,
			eilbrts.long_pi, elbatms, elbats, nr);
break;
default:
nvme_init_copy_range_f0(copy->f0, nlbs, slbas, eilbrts.short_pi,
			elbatms, elbats, nr);
break;
}

nvme_init_copy(&cmd, cfg.nsid, cfg.sdlba, nr, cfg.format,
       cfg.prinfor, cfg.prinfow, 0, cfg.dtype, cfg.stc, cfg.stc,
       cfg.fua, cfg.lr, 0, cfg.dspec, copy->f0);
err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst, cfg.lbat,
cfg.lbatm);
if (err)
return err;
err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "NVMe Copy");
return err;
}

nvme_show_verbose_result("NVMe Copy: success")nvme_show_verbose_message("NVMe Copy: success");

return err;
898}

900static int flush_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
901{
const char *desc = "Commit data and metadata associated with\n"
"given namespaces to nonvolatile media. Applies to all commands\n"
"finished before the flush was submitted. Additional data may also be\n"
"flushed by the controller, from any namespace, depending on controller and\n"
"associated namespace status.";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
struct libnvme_passthru_cmd cmd = {};
int err;

struct config {
__u32	namespace_id;
};

struct config cfg = {
.namespace_id	= 0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_id_desired, 0, nvme_nsid_values}
	 namespace_id_desired, nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_id_desired, 0, nvme_nsid_values},
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

err = open_fallback_chardev(ctx, cfg.namespace_id, &hdl);
if (err)
return err;

if (!cfg.namespace_id) {
err = libnvme_get_nsid(hdl, &cfg.namespace_id);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

cmd.opcode = nvme_cmd_flush;
cmd.nsid = cfg.namespace_id;

err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "flush");
return err;
}

nvme_show_verbose_result("NVMe Flush: success")nvme_show_verbose_message("NVMe Flush: success");

return err;
955}

957static int submit_io(int opcode, char *command, const char *desc, int argc, char **argv)
958{
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
unsigned long long buffer_size = 0, mbuffer_size = 0;
__cleanup_free__attribute__((cleanup(shr_freep))) struct nvme_nvm_id_ns *nvm_ns = NULL((void*)0);
__cleanup_huge__attribute__((cleanup(libnvme_free_huge))) struct libnvme_mem_huge mh = { 0, };
__cleanup_free__attribute__((cleanup(shr_freep))) struct nvme_id_ns *ns = NULL((void*)0);
unsigned int logical_block_size = 0;
struct timeval start_time, end_time;
__cleanup_free__attribute__((cleanup(shr_freep))) void *mbuffer = NULL((void*)0);
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int dfd = -1, mfd = -1;
__u16 control = 0, nblocks = 0;
struct libnvme_passthru_cmd cmd;
__u8 sts = 0, pif = 0;
bool_Bool pi_available;
__u32 dsmgmt = 0;
int mode = 0644;
void *buffer;
__u16 ms = 0;
int err = 0;
int flags;

const char *start_block_addr = "64-bit addr of first block to access";
const char *block_size = "if specified, logical block size in bytes;\n"
"discovered by identify namespace otherwise";
const char *data_size = "size of data in bytes";
const char *metadata_size = "size of metadata in bytes";
const char *data = "data file";
const char *metadata = "metadata file";
const char *limited_retry_num = "limit num. media access attempts";
const char *show = "show command before sending";
const char *dtype_for_write = "directive type (for write-only)";
const char *dspec = "directive specific (for write-only)";
const char *dsm = "dataset management attributes (lower 8 bits)";
const char *force = "The \"I know what I'm doing\" flag, do not enforce exclusive access for write";

struct config {
__u32	nsid;
__u64	start_block;
__u16	block_count;
__u16	block_size;
__u64	data_size;
__u64	metadata_size;
__u64	ilbrt;
char	*data;
char	*metadata;
__u8	prinfo;
__u16	lbatm;
__u16	lbat;
__u64	lbst;
bool_Bool	limited_retry;
bool_Bool	force_unit_access;
bool_Bool	stc;
__u8	dtype;
__u16	dspec;
__u8	dsmgmt;
bool_Bool	show;
bool_Bool	latency;
bool_Bool	force;
};

struct config cfg = {
.nsid				= 0,
.start_block		= 0,
.block_count		= 0,
.block_size			= 0,
.data_size			= 0,
.metadata_size		= 0,
.ilbrt				= 0,
.data				= "",
.metadata			= "",
.prinfo				= 0,
.lbatm				= 0,
.lbat				= 0,
.lbst				= 0,
.limited_retry		= false0,
.force_unit_access	= false0,
.stc				= false0,
.dtype				= 0,
.dspec				= 0,
.dsmgmt				= 0,
.show				= false0,
.latency			= false0,
.force				= false0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.nsid, namespace_id_desired,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_id_desired
, 0, nvme_nsid_values}
	 nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_id_desired
, 0, nvme_nsid_values},
OPT_SUFFIX("start-block", 's', &cfg.start_block,{"start-block", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.start_block, uint64_t * : (&cfg.start_block), default
 : _Generic(&cfg.start_block, unsigned long long * : (&
cfg.start_block), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, start_block_addr, 0, }
	   start_block_addr){"start-block", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.start_block, uint64_t * : (&cfg.start_block), default
 : _Generic(&cfg.start_block, unsigned long long * : (&
cfg.start_block), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, start_block_addr, 0, },
OPT_SHRT("block-count",   'c', &cfg.block_count, block_count){"block-count", 'c', "NUM", CFG_SHORT, _Generic(&cfg.block_count
, uint16_t * : (&cfg.block_count)), ARGCONFIG_ARG_REQUIRED
, block_count, 0, },
OPT_SHRT("block-size",    'b', &cfg.block_size,  block_size){"block-size", 'b', "NUM", CFG_SHORT, _Generic(&cfg.block_size
, uint16_t * : (&cfg.block_size)), ARGCONFIG_ARG_REQUIRED
, block_size, 0, },
OPT_SUFFIX("data-size",   'z', &cfg.data_size,   data_size){"data-size", 'z', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg
.data_size, uint64_t * : (&cfg.data_size), default : _Generic
(&cfg.data_size, unsigned long long * : (&cfg.data_size
), default : (void)0)), ARGCONFIG_ARG_REQUIRED, data_size, 0,
 },
OPT_SUFFIX("metadata-size", 'y', &cfg.metadata_size,{"metadata-size", 'y', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.metadata_size, uint64_t * : (&cfg.metadata_size), default
 : _Generic(&cfg.metadata_size, unsigned long long * : (&
cfg.metadata_size), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, metadata_size, 0, }
	   metadata_size){"metadata-size", 'y', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.metadata_size, uint64_t * : (&cfg.metadata_size), default
 : _Generic(&cfg.metadata_size, unsigned long long * : (&
cfg.metadata_size), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, metadata_size, 0, },
OPT_SUFFIX("ref-tag",     'r', &cfg.ilbrt,       ref_tag){"ref-tag", 'r', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg.
ilbrt, uint64_t * : (&cfg.ilbrt), default : _Generic(&
cfg.ilbrt, unsigned long long * : (&cfg.ilbrt), default :
 (void)0)), ARGCONFIG_ARG_REQUIRED, ref_tag, 0, },
OPT_FILE("data",          'd', &cfg.data,        data){"data", 'd', "FILE", CFG_FILE, _Generic(&cfg.data, char *
* : (&cfg.data), const char ** : (&cfg.data)), ARGCONFIG_ARG_REQUIRED
, data, 0, },
OPT_FILE("metadata",      'M', &cfg.metadata,    metadata){"metadata", 'M', "FILE", CFG_FILE, _Generic(&cfg.metadata
, char ** : (&cfg.metadata), const char ** : (&cfg.metadata
)), ARGCONFIG_ARG_REQUIRED, metadata, 0, },
OPT_BYTE("prinfo",        'p', &cfg.prinfo,      prinfo){"prinfo", 'p', "NUM", CFG_BYTE, _Generic(&cfg.prinfo, uint8_t
 * : (&cfg.prinfo)), ARGCONFIG_ARG_REQUIRED, prinfo, 0, },
OPT_SHRT("app-tag-mask",  'm', &cfg.lbatm,       app_tag_mask){"app-tag-mask", 'm', "NUM", CFG_SHORT, _Generic(&cfg.lbatm
, uint16_t * : (&cfg.lbatm)), ARGCONFIG_ARG_REQUIRED, app_tag_mask
, 0, },
OPT_SHRT("app-tag",       'a', &cfg.lbat,        app_tag){"app-tag", 'a', "NUM", CFG_SHORT, _Generic(&cfg.lbat, uint16_t
 * : (&cfg.lbat)), ARGCONFIG_ARG_REQUIRED, app_tag, 0, },
OPT_SUFFIX("storage-tag", 'g', &cfg.lbst,        storage_tag){"storage-tag", 'g', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.lbst, uint64_t * : (&cfg.lbst), default : _Generic(&
cfg.lbst, unsigned long long * : (&cfg.lbst), default : (
void)0)), ARGCONFIG_ARG_REQUIRED, storage_tag, 0, },
OPT_FLAG("limited-retry", 'l', &cfg.limited_retry,{"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry_num, 0, }
	 limited_retry_num){"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry_num, 0, },
OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access,{"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access, 0, }
	 force_unit_access){"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access, 0, },
OPT_FLAG("storage-tag-check", 'C', &cfg.stc, storage_tag_check){"storage-tag-check", 'C', ((void*)0), CFG_FLAG, _Generic(&
cfg.stc, _Bool * : (&cfg.stc)), ARGCONFIG_ARG_NONE, storage_tag_check
, 0, },
OPT_BYTE("dir-type", 'T', &cfg.dtype, dtype_for_write){"dir-type", 'T', "NUM", CFG_BYTE, _Generic(&cfg.dtype, uint8_t
 * : (&cfg.dtype)), ARGCONFIG_ARG_REQUIRED, dtype_for_write
, 0, },
OPT_SHRT("dir-spec",      'S', &cfg.dspec,       dspec){"dir-spec", 'S', "NUM", CFG_SHORT, _Generic(&cfg.dspec, uint16_t
 * : (&cfg.dspec)), ARGCONFIG_ARG_REQUIRED, dspec, 0, },
OPT_BYTE("dsm",           'D', &cfg.dsmgmt,      dsm){"dsm", 'D', "NUM", CFG_BYTE, _Generic(&cfg.dsmgmt, uint8_t
 * : (&cfg.dsmgmt)), ARGCONFIG_ARG_REQUIRED, dsm, 0, },
OPT_FLAG("show-command",  'V', &cfg.show,        show){"show-command", 'V', ((void*)0), CFG_FLAG, _Generic(&cfg
.show, _Bool * : (&cfg.show)), ARGCONFIG_ARG_NONE, show, 0
, },
OPT_FLAG("latency",       't', &cfg.latency,     latency){"latency", 't', ((void*)0), CFG_FLAG, _Generic(&cfg.latency
, _Bool * : (&cfg.latency)), ARGCONFIG_ARG_NONE, latency,
 0, },
OPT_FLAG("force",         0,   &cfg.force,       force){"force", 0, ((void*)0), CFG_FLAG, _Generic(&cfg.force, _Bool
 * : (&cfg.force)), ARGCONFIG_ARG_NONE, force, 0, },
OPT_END(){ ((void*)0) }
};

if (opcode1.1
'opcode' is not equal to nvme_cmd_write
 != nvme_cmd_write) {
2
←
Taking true branch→
err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
3
←
Assuming 'err' is 0→
4
←
Taking false branch→
	return err;
} else {
err = parse_args(argc, argv, desc, opts);
if (err)
	return err;
err = open_exclusive(&ctx, &hdl, argc, argv, cfg.force, opts);
if (err) {
	if (err == -EBUSY16) {
		nvme_show_error("Failed to open %s.",nvme_show_message(1, "Failed to open %s.", __xpg_basename(nvme_args
.device))
				basename(nvme_args.device))nvme_show_message(1, "Failed to open %s.", __xpg_basename(nvme_args
.device));
		nvme_show_error("Namespace is currently busy.")nvme_show_message(1, "Namespace is currently busy.");
		if (!cfg.force)
			nvme_show_error(nvme_show_message(1, "Use the force [--force] option to ignore that."
)
				"Use the force [--force] option to ignore that.")nvme_show_message(1, "Use the force [--force] option to ignore that."
);
	}
	return err;
}
}

if (!cfg.nsid) {
5
←
Assuming field 'nsid' is not equal to 0→
6
←
Taking false branch→
err = libnvme_get_nsid(hdl, &cfg.nsid);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

if (cfg.prinfo > 0xf)
7
←
Assuming field 'prinfo' is <= 15→
8
←
Taking false branch→
return -EINVAL22;

dsmgmt = cfg.dsmgmt;
control |= (cfg.prinfo << 10);
if (cfg.limited_retry)
9
←
Assuming field 'limited_retry' is false→
10
←
Taking false branch→
control |= NVME_IO_LR;
if (cfg.force_unit_access)
11
←
Assuming field 'force_unit_access' is false→
12
←
Taking false branch→
control |= NVME_IO_FUA;
if (cfg.stc)
13
←
Assuming field 'stc' is false→
14
←
Taking false branch→
control |= NVME_IO_STC;
if (cfg.dtype) {
15
←
Assuming field 'dtype' is 0→
16
←
Taking false branch→
if (cfg.dtype > 0xf) {
	nvme_show_error("Invalid directive type, %x", cfg.dtype)nvme_show_message(1, "Invalid directive type, %x", cfg.dtype);
	return -EINVAL22;
}
control |= cfg.dtype << 4;
dsmgmt |= ((__u32)cfg.dspec) << 16;
}

if (opcode & 1) {
17
←
Taking true branch→
dfd = mfd = STDIN_FILENO0;
flags = O_RDONLY00;
} else {
dfd = mfd = STDOUT_FILENO1;
flags = O_WRONLY01 | O_CREAT0100 | O_TRUNC01000;
}

if (strlen(cfg.data)) {
18
←
Assuming the condition is false→
19
←
Taking false branch→
dfd = shr_open_rawdata(cfg.data, flags, mode)open((cfg.data), (flags), mode);
if (dfd < 0) {
	nvme_show_perror(cfg.data);
	return -EINVAL22;
}
}

if (strlen(cfg.metadata)) {
20
←
Assuming the condition is false→
21
←
Taking false branch→
mfd = shr_open_rawdata(cfg.metadata, flags, mode)open((cfg.metadata), (flags), mode);
if (mfd < 0) {
	nvme_show_perror(cfg.metadata);
	return -EINVAL22;
}
}

if (!cfg.data_size) {
22
←
Assuming field 'data_size' is not equal to 0→
23
←
Taking false branch→
nvme_show_error("data size not provided")nvme_show_message(1, "data size not provided");
return -EINVAL22;
}

if (cfg.block_size) {
24
←
Assuming field 'block_size' is not equal to 0→
25
←
Taking true branch→
logical_block_size = cfg.block_size;
ms = cfg.metadata_size;
pi_available = true1;
} else {
err = get_pi_info(hdl, cfg.nsid, cfg.prinfo,
	cfg.ilbrt, cfg.lbst, &logical_block_size, &ms);
switch (err) {
case 0:
	pi_available = true1;
	break;
case -ENOMEM12:
	/* Could not even allocate the Identify buffer. */
case -ECLI_IDENTIFY_NS_FAILED:
	/* Base Identify Namespace failed: no logical block size. */
case -ECLI_INVALID_LBA_FORMAT:
	/* LBA data size too large: no logical block size. */
case -ECLI_INVALID_TAGS:
	/* Reference/storage tag is invalid for this PI format. */
case -ECLI_INVALID_PI_FORMAT:
	/* Namespace's reported PI format is self-inconsistent. */
	return err;
default:
	/* Identify NVM CS NS failed/unsupported: PI unavailable. */
	nvme_show_err(err, "identify NVM CS NS: continuing without protection information");
	pi_available = false0;
	break;
}
}

buffer_size = ((long long)cfg.block_count + 1) * logical_block_size;
if (cfg.data_size < buffer_size)
26
←
Assuming 'buffer_size' is <= field 'data_size'→
27
←
Taking false branch→
nvme_show_error("Rounding data size to fit block count (%lld bytes)", buffer_size)nvme_show_message(1, "Rounding data size to fit block count (%lld bytes)"
, buffer_size);
else
buffer_size = cfg.data_size;

if (argconfig_given(opts, &cfg.block_count)) {
28
←
Assuming the condition is true→
29
←
Taking true branch→
/* Use the value provided */
nblocks = cfg.block_count;
} else {
/* Get the required block count. Note this is a zeroes based value. */
nblocks = ((buffer_size + (logical_block_size - 1)) / logical_block_size) - 1;

/* Update the data size based on the required block count */
buffer_size = ((unsigned long long)nblocks + 1) * logical_block_size;
}

buffer = libnvme_alloc_huge(buffer_size, &mh);
if (!buffer) {
30
←
Assuming 'buffer' is non-null→
31
←
Taking false branch→
nvme_show_error("failed to allocate huge memory")nvme_show_message(1, "failed to allocate huge memory");
return -ENOMEM12;
}

if (cfg.metadata_size) {
32
←
Assuming field 'metadata_size' is not equal to 0→
33
←
Taking true branch→
mbuffer_size = ((unsigned long long)cfg.block_count + 1) * ms;
if (ms33.1
'ms' is not equal to 0
 && cfg.metadata_size < mbuffer_size)
34
←
Assuming 'mbuffer_size' is > field 'metadata_size'→
35
←
Taking true branch→
	nvme_show_error("Rounding metadata size to fit block count (%lld bytes)",nvme_show_message(1, "Rounding metadata size to fit block count (%lld bytes)"
, mbuffer_size)
			mbuffer_size)nvme_show_message(1, "Rounding metadata size to fit block count (%lld bytes)"
, mbuffer_size);
else
	mbuffer_size = cfg.metadata_size;

mbuffer = malloc(mbuffer_size);
36
←
Memory is allocated→
if (!mbuffer)
37
←
Assuming 'mbuffer' is non-null→
38
←
Taking false branch→
	return -ENOMEM12;
memset(mbuffer, 0, mbuffer_size);
}

if (opcode & 1) {
39
←
Taking true branch→
err = read(dfd, (void *)buffer, cfg.data_size);
if (err < 0) {
40
←
Assuming 'err' is < 0→
41
←
Taking true branch→
	err = -errno(*__errno_location ());
42
←
Potential leak of memory pointed to by 'mbuffer'
	nvme_show_error("failed to read data buffer from input file %s", libnvme_strerror(errno))nvme_show_message(1, "failed to read data buffer from input file %s"
, libnvme_strerror((*__errno_location ())));
	return err;
}
}

if ((opcode & 1) && cfg.metadata_size) {
err = read(mfd, (void *)mbuffer, mbuffer_size);
if (err < 0) {
	err = -errno(*__errno_location ());
	nvme_show_error("failed to read meta-data buffer from input file %s", libnvme_strerror(errno))nvme_show_message(1, "failed to read meta-data buffer from input file %s"
, libnvme_strerror((*__errno_location ())));
	return err;
}
}

if (cfg.show || nvme_args.dry_run) {
nvme_show_result("opcode       : %02x", opcode)nvme_show_message(0, "opcode       : %02x", opcode);
nvme_show_result("nsid         : %02x", cfg.nsid)nvme_show_message(0, "nsid         : %02x", cfg.nsid);
nvme_show_result("flags        : %02x", 0)nvme_show_message(0, "flags        : %02x", 0);
nvme_show_result("control      : %04x", control)nvme_show_message(0, "control      : %04x", control);
nvme_show_result("nblocks      : %04x", nblocks)nvme_show_message(0, "nblocks      : %04x", nblocks);
nvme_show_result("metadata     : %"PRIx64, (uint64_t)(uintptr_t)mbuffer)nvme_show_message(0, "metadata     : %""l" "x", (uint64_t)(uintptr_t
)mbuffer);
nvme_show_result("addr         : %"PRIx64, (uint64_t)(uintptr_t)buffer)nvme_show_message(0, "addr         : %""l" "x", (uint64_t)(uintptr_t
)buffer);
nvme_show_result("slba         : %"PRIx64, (uint64_t)cfg.start_block)nvme_show_message(0, "slba         : %""l" "x", (uint64_t)cfg
.start_block);
nvme_show_result("dsmgmt       : %08x", dsmgmt)nvme_show_message(0, "dsmgmt       : %08x", dsmgmt);
nvme_show_result("reftag       : %"PRIx64, (uint64_t)cfg.ilbrt)nvme_show_message(0, "reftag       : %""l" "x", (uint64_t)cfg
.ilbrt);
nvme_show_result("apptag       : %04x", cfg.lbat)nvme_show_message(0, "apptag       : %04x", cfg.lbat);
nvme_show_result("appmask      : %04x", cfg.lbatm)nvme_show_message(0, "appmask      : %04x", cfg.lbatm);
nvme_show_result("storagetagcheck : %04x", cfg.stc)nvme_show_message(0, "storagetagcheck : %04x", cfg.stc);
nvme_show_result("storagetag      : %"PRIx64, (uint64_t)cfg.lbst)nvme_show_message(0, "storagetag      : %""l" "x", (uint64_t)
cfg.lbst);
nvme_show_result("pif             : %02x", pif)nvme_show_message(0, "pif             : %02x", pif);
nvme_show_result("sts             : %02x", sts)nvme_show_message(0, "sts             : %02x", sts);
}
if (nvme_args.dry_run)
return 0;

nvme_init_io(&cmd, opcode, cfg.nsid, cfg.start_block, buffer,
     buffer_size, mbuffer, mbuffer_size);
cmd.cdw12 = NVME_FIELD_ENCODE(nblocks,(((__u32)(nblocks) & (NVME_IOCS_COMMON_CDW12_NLB_MASK)) <<
 (NVME_IOCS_COMMON_CDW12_NLB_SHIFT))
	NVME_IOCS_COMMON_CDW12_NLB_SHIFT,(((__u32)(nblocks) & (NVME_IOCS_COMMON_CDW12_NLB_MASK)) <<
 (NVME_IOCS_COMMON_CDW12_NLB_SHIFT))
	NVME_IOCS_COMMON_CDW12_NLB_MASK)(((__u32)(nblocks) & (NVME_IOCS_COMMON_CDW12_NLB_MASK)) <<
 (NVME_IOCS_COMMON_CDW12_NLB_SHIFT)) |
    NVME_FIELD_ENCODE(control,(((__u32)(control) & (NVME_IOCS_COMMON_CDW12_CONTROL_MASK
)) << (NVME_IOCS_COMMON_CDW12_CONTROL_SHIFT))
	NVME_IOCS_COMMON_CDW12_CONTROL_SHIFT,(((__u32)(control) & (NVME_IOCS_COMMON_CDW12_CONTROL_MASK
)) << (NVME_IOCS_COMMON_CDW12_CONTROL_SHIFT))
	NVME_IOCS_COMMON_CDW12_CONTROL_MASK)(((__u32)(control) & (NVME_IOCS_COMMON_CDW12_CONTROL_MASK
)) << (NVME_IOCS_COMMON_CDW12_CONTROL_SHIFT));
cmd.cdw13 = NVME_FIELD_ENCODE(cfg.dspec,(((__u32)(cfg.dspec) & (NVME_IOCS_COMMON_CDW13_DSPEC_MASK
)) << (NVME_IOCS_COMMON_CDW13_DSPEC_SHIFT))
	NVME_IOCS_COMMON_CDW13_DSPEC_SHIFT,(((__u32)(cfg.dspec) & (NVME_IOCS_COMMON_CDW13_DSPEC_MASK
)) << (NVME_IOCS_COMMON_CDW13_DSPEC_SHIFT))
	NVME_IOCS_COMMON_CDW13_DSPEC_MASK)(((__u32)(cfg.dspec) & (NVME_IOCS_COMMON_CDW13_DSPEC_MASK
)) << (NVME_IOCS_COMMON_CDW13_DSPEC_SHIFT)) |
    NVME_FIELD_ENCODE(cfg.dsmgmt,(((__u32)(cfg.dsmgmt) & (NVME_IOCS_COMMON_CDW13_DSM_MASK)
) << (NVME_IOCS_COMMON_CDW13_DSM_SHIFT))
	NVME_IOCS_COMMON_CDW13_DSM_SHIFT,(((__u32)(cfg.dsmgmt) & (NVME_IOCS_COMMON_CDW13_DSM_MASK)
) << (NVME_IOCS_COMMON_CDW13_DSM_SHIFT))
	NVME_IOCS_COMMON_CDW13_DSM_MASK)(((__u32)(cfg.dsmgmt) & (NVME_IOCS_COMMON_CDW13_DSM_MASK)
) << (NVME_IOCS_COMMON_CDW13_DSM_SHIFT));
if (pi_available) {
err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst,
	cfg.lbat, cfg.lbatm);
if (err)
	return err;
}
gettimeofday(&start_time, NULL((void*)0));
err = libnvme_exec_io_passthru(hdl, &cmd);
gettimeofday(&end_time, NULL((void*)0));
if (cfg.latency)
nvme_show_result(" latency: %s: %llu us", command, shr_elapsed_utime(start_time, end_time))nvme_show_message(0, " latency: %s: %llu us", command, shr_elapsed_utime
(start_time, end_time));
if (err) {
nvme_show_err(err, "submit-io");
return err;
}

if (!(opcode & 1) && write(dfd, (void *)buffer, buffer_size) < 0) {
nvme_show_error(nvme_show_message(1, "write: %s: failed to write buffer to output file"
, libnvme_strerror((*__errno_location ())))
    "write: %s: failed to write buffer to output file",nvme_show_message(1, "write: %s: failed to write buffer to output file"
, libnvme_strerror((*__errno_location ())))
    libnvme_strerror(errno))nvme_show_message(1, "write: %s: failed to write buffer to output file"
, libnvme_strerror((*__errno_location ())));
err = -EINVAL22;
} else if (!(opcode & 1) && cfg.metadata_size &&
   write(mfd, (void *)mbuffer, mbuffer_size) < 0) {
nvme_show_error(nvme_show_message(1, "write: %s: failed to write meta-data buffer to output file"
, libnvme_strerror((*__errno_location ())))
    "write: %s: failed to write meta-data buffer to output file",nvme_show_message(1, "write: %s: failed to write meta-data buffer to output file"
, libnvme_strerror((*__errno_location ())))
    libnvme_strerror(errno))nvme_show_message(1, "write: %s: failed to write meta-data buffer to output file"
, libnvme_strerror((*__errno_location ())));
err = -EINVAL22;
} else {
nvme_show_verbose_result("%s: Success", command)nvme_show_verbose_message("%s: Success", command);
}

return err;
1306}

1308static int compare(int argc, char **argv, struct command *acmd, struct plugin *plugin)
1309{
const char *desc = "Compare specified logical blocks on\n"
"device with specified data buffer; return failure if buffer\n"
"and block(s) are dissimilar";

return submit_io(nvme_cmd_compare, "compare", desc, argc, argv);
1
Calling 'submit_io'→
1315}

1317static int read_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
1318{
const char *desc = "Copy specified logical blocks on the given\n"
"device to specified data buffer (default buffer is stdout).";

return submit_io(nvme_cmd_read, "read", desc, argc, argv);
1323}

1325static int write_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
1326{
const char *desc = "Copy from provided data buffer (default\n"
"buffer is stdin) to specified logical blocks on the given device.";

return submit_io(nvme_cmd_write, "write", desc, argc, argv);
1331}

1333static int verify_cmd(int argc, char **argv, struct command *acmd, struct plugin *plugin)
1334{
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
__u16 control = 0;
int err;

const char *desc = "Verify specified logical blocks on the given device.";
const char *force_unit_access_verify =
   "force device to commit cached data before performing the verify operation";
const char *storage_tag_check =
   "This bit specifies the Storage Tag field shall be checked as part of Verify operation";

struct config {
__u32	nsid;
__u64	start_block;
__u16	block_count;
bool_Bool	limited_retry;
bool_Bool	force_unit_access;
__u8	prinfo;
__u64	ilbrt;
__u16	lbat;
__u16	lbatm;
__u64	lbst;
bool_Bool	stc;
};

struct config cfg = {
.nsid				= 0,
.start_block		= 0,
.block_count		= 0,
.limited_retry		= false0,
.force_unit_access	= false0,
.prinfo				= 0,
.ilbrt				= 0,
.lbat				= 0,
.lbatm				= 0,
.lbst				= 0,
.stc				= false0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_UINT("namespace-id", 'n', &cfg.nsid, namespace_desired,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_desired
, 0, nvme_nsid_values}
	 nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
nsid, uint32_t * : (&cfg.nsid)), ARGCONFIG_ARG_REQUIRED, namespace_desired
, 0, nvme_nsid_values},
OPT_SUFFIX("start-block", 's', &cfg.start_block, start_block){"start-block", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.start_block, uint64_t * : (&cfg.start_block), default
 : _Generic(&cfg.start_block, unsigned long long * : (&
cfg.start_block), default : (void)0)), ARGCONFIG_ARG_REQUIRED
, start_block, 0, },
OPT_SHRT("block-count",   'c', &cfg.block_count, block_count){"block-count", 'c', "NUM", CFG_SHORT, _Generic(&cfg.block_count
, uint16_t * : (&cfg.block_count)), ARGCONFIG_ARG_REQUIRED
, block_count, 0, },
OPT_FLAG("limited-retry", 'l', &cfg.limited_retry,{"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry, 0, }
	 limited_retry){"limited-retry", 'l', ((void*)0), CFG_FLAG, _Generic(&cfg
.limited_retry, _Bool * : (&cfg.limited_retry)), ARGCONFIG_ARG_NONE
, limited_retry, 0, },
OPT_FLAG("force-unit-access", 'f', &cfg.force_unit_access,{"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access_verify, 0, }
	 force_unit_access_verify){"force-unit-access", 'f', ((void*)0), CFG_FLAG, _Generic(&
cfg.force_unit_access, _Bool * : (&cfg.force_unit_access)
), ARGCONFIG_ARG_NONE, force_unit_access_verify, 0, },
OPT_BYTE("prinfo",        'p', &cfg.prinfo,      prinfo){"prinfo", 'p', "NUM", CFG_BYTE, _Generic(&cfg.prinfo, uint8_t
 * : (&cfg.prinfo)), ARGCONFIG_ARG_REQUIRED, prinfo, 0, },
OPT_SUFFIX("ref-tag",     'r', &cfg.ilbrt,       ref_tag){"ref-tag", 'r', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg.
ilbrt, uint64_t * : (&cfg.ilbrt), default : _Generic(&
cfg.ilbrt, unsigned long long * : (&cfg.ilbrt), default :
 (void)0)), ARGCONFIG_ARG_REQUIRED, ref_tag, 0, },
OPT_SHRT("app-tag",       'a', &cfg.lbat,        app_tag){"app-tag", 'a', "NUM", CFG_SHORT, _Generic(&cfg.lbat, uint16_t
 * : (&cfg.lbat)), ARGCONFIG_ARG_REQUIRED, app_tag, 0, },
OPT_SHRT("app-tag-mask",  'm', &cfg.lbatm,       app_tag_mask){"app-tag-mask", 'm', "NUM", CFG_SHORT, _Generic(&cfg.lbatm
, uint16_t * : (&cfg.lbatm)), ARGCONFIG_ARG_REQUIRED, app_tag_mask
, 0, },
OPT_SUFFIX("storage-tag", 'S', &cfg.lbst,        storage_tag){"storage-tag", 'S', "IONUM", CFG_LONG_SUFFIX, _Generic(&
cfg.lbst, uint64_t * : (&cfg.lbst), default : _Generic(&
cfg.lbst, unsigned long long * : (&cfg.lbst), default : (
void)0)), ARGCONFIG_ARG_REQUIRED, storage_tag, 0, },
OPT_FLAG("storage-tag-check", 'C', &cfg.stc, storage_tag_check){"storage-tag-check", 'C', ((void*)0), CFG_FLAG, _Generic(&
cfg.stc, _Bool * : (&cfg.stc)), ARGCONFIG_ARG_NONE, storage_tag_check
, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

err = open_fallback_chardev(ctx, cfg.nsid, &hdl);
if (err)
return err;

if (cfg.prinfo > 0xf)
return -EINVAL22;

control |= (cfg.prinfo << 10);
if (cfg.limited_retry)
control |= NVME_IO_LR;
if (cfg.force_unit_access)
control |= NVME_IO_FUA;
if (cfg.stc)
control |= NVME_IO_STC;

if (!cfg.nsid) {
err = libnvme_get_nsid(hdl, &cfg.nsid);
if (err < 0) {
	nvme_show_error("get-namespace-id: %s", libnvme_strerror(-err))nvme_show_message(1, "get-namespace-id: %s", libnvme_strerror
(-err));
	return err;
}
}

nvme_init_verify(&cmd, cfg.nsid, cfg.start_block,
cfg.block_count, control, 0, NULL((void*)0), 0, NULL((void*)0), 0);
err = init_pi_tags(hdl, &cmd, cfg.nsid, cfg.ilbrt, cfg.lbst,
cfg.lbat, cfg.lbatm);
if (err)
return err;
err = libnvme_exec_io_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "verify");
return err;
}

nvme_show_verbose_result("NVME Verify Success")nvme_show_verbose_message("NVME Verify Success");

return err;
1435}

1437static int get_lba_status(int argc, char **argv, struct command *acmd,
struct plugin *plugin)
1439{
const char *desc = "Information about potentially unrecoverable LBAs.";
const char *slba =
   "Starting LBA(SLBA) in 64-bit address of the first logical block addressed by this command";
const char *mndw =
   "Maximum Number of Dwords(MNDW) specifies maximum number of dwords to return";
const char *atype = "Action Type(ATYPE) specifies the mechanism\n"
"the controller uses in determining the LBA Status Descriptors to return.";
const char *rl =
   "Range Length(RL) specifies the length of the range of contiguous LBAs beginning at SLBA";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
__cleanup_libnvme_free__attribute__((cleanup(libnvme_freep))) void *buf = NULL((void*)0);
nvme_print_flags_t flags;
unsigned long buf_len;
int err;

struct config {
bool_Bool	ish;
__u32	namespace_id;
__u64	slba;
__u32	mndw;
__u8	atype;
__u16	rl;
};

struct config cfg = {
.ish		= false0,
.namespace_id	= 0,
.slba		= 0,
.mndw		= 0,
.atype		= 0,
.rl		= 0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_FLAG("ish",          'I', &cfg.ish,          ish){"ish", 'I', ((void*)0), CFG_FLAG, _Generic(&cfg.ish, _Bool
 * : (&cfg.ish)), ARGCONFIG_ARG_NONE, ish, 0, },
OPT_UINT("namespace-id", 'n', &cfg.namespace_id,{"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_desired, 0, nvme_nsid_values}
	 namespace_desired, nvme_nsid_values){"namespace-id", 'n', "NUM", CFG_POSITIVE, _Generic(&cfg.
namespace_id, uint32_t * : (&cfg.namespace_id)), ARGCONFIG_ARG_REQUIRED
, namespace_desired, 0, nvme_nsid_values},
OPT_SUFFIX("start-lba",  's', &cfg.slba,         slba){"start-lba", 's', "IONUM", CFG_LONG_SUFFIX, _Generic(&cfg
.slba, uint64_t * : (&cfg.slba), default : _Generic(&
cfg.slba, unsigned long long * : (&cfg.slba), default : (
void)0)), ARGCONFIG_ARG_REQUIRED, slba, 0, },
OPT_UINT("max-dw",       'm', &cfg.mndw,         mndw){"max-dw", 'm', "NUM", CFG_POSITIVE, _Generic(&cfg.mndw, uint32_t
 * : (&cfg.mndw)), ARGCONFIG_ARG_REQUIRED, mndw, 0, },
OPT_BYTE("action",       'a', &cfg.atype,        atype){"action", 'a', "NUM", CFG_BYTE, _Generic(&cfg.atype, uint8_t
 * : (&cfg.atype)), ARGCONFIG_ARG_REQUIRED, atype, 0, },
OPT_SHRT("range-len",    'l', &cfg.rl,           rl){"range-len", 'l', "NUM", CFG_SHORT, _Generic(&cfg.rl, uint16_t
 * : (&cfg.rl)), ARGCONFIG_ARG_REQUIRED, rl, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

flags = nvme_args.output_flags;

if (!cfg.atype) {
nvme_show_error("action type (--action) has to be given")nvme_show_message(1, "action type (--action) has to be given"
);
return -EINVAL22;
}

buf_len = (cfg.mndw + 1) * 4;
buf = libnvme_alloc(buf_len);
if (!buf)
return -ENOMEM12;

nvme_init_get_lba_status(&cmd, cfg.namespace_id, cfg.slba, cfg.mndw,
		 cfg.atype, cfg.rl, buf);
if (cfg.ish) {
if (libnvme_transport_handle_is_mi(hdl))
	nvme_init_mi_cmd_flags(&cmd, ish);
else
	nvme_show_error("ISH is supported only for NVMe-MI")nvme_show_message(1, "ISH is supported only for NVMe-MI");
}
err = libnvme_exec_admin_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "get lba status");
return err;
}

nvme_show_lba_status(buf, buf_len, flags);

return err;
1520}

1522static int capacity_mgmt(int argc, char **argv, struct command *acmd, struct plugin *plugin)
1523{
const char *desc = "Host software uses the Capacity Management command to\n"
"configure Endurance Groups and NVM Sets in an NVM subsystem by either\n"
"selecting one of a set of supported configurations or by specifying the\n"
"capacity of the Endurance Group or NVM Set to be created";
const char *operation = "Operation to be performed by the controller";
const char *element_id = "Value specific to the value of the Operation field.";
const char *cap_lower =
   "Least significant 32 bits of the capacity in bytes of the Endurance Group or NVM Set to be created";
const char *cap_upper =
   "Most significant 32 bits of the capacity in bytes of the Endurance Group or NVM Set to be created";

__cleanup_nvme_global_ctx__attribute__((cleanup(cleanup_nvme_global_ctx))) struct libnvme_global_ctx *ctx = NULL((void*)0);
__cleanup_nvme_transport_handle__attribute__((cleanup(cleanup_nvme_transport_handle))) struct libnvme_transport_handle *hdl = NULL((void*)0);
struct libnvme_passthru_cmd cmd;
int err = -1;

struct config {
bool_Bool	ish;
__u8	operation;
__u16	element_id;
__u32	dw11;
__u32	dw12;
};

struct config cfg = {
.ish		= false0,
.operation	= 0xff,
.element_id	= 0xffff,
.dw11		= 0,
.dw12		= 0,
};

OPT_ARGS(opts)struct argconfig_commandline_options opts[] = {
OPT_FLAG("ish",        'I', &cfg.ish,        ish){"ish", 'I', ((void*)0), CFG_FLAG, _Generic(&cfg.ish, _Bool
 * : (&cfg.ish)), ARGCONFIG_ARG_NONE, ish, 0, },
OPT_BYTE("operation",  'O', &cfg.operation,  operation){"operation", 'O', "NUM", CFG_BYTE, _Generic(&cfg.operation
, uint8_t * : (&cfg.operation)), ARGCONFIG_ARG_REQUIRED, operation
, 0, },
OPT_SHRT("element-id", 'i', &cfg.element_id, element_id){"element-id", 'i', "NUM", CFG_SHORT, _Generic(&cfg.element_id
, uint16_t * : (&cfg.element_id)), ARGCONFIG_ARG_REQUIRED
, element_id, 0, },
OPT_UINT("cap-lower",  'l', &cfg.dw11,       cap_lower){"cap-lower", 'l', "NUM", CFG_POSITIVE, _Generic(&cfg.dw11
, uint32_t * : (&cfg.dw11)), ARGCONFIG_ARG_REQUIRED, cap_lower
, 0, },
OPT_UINT("cap-upper",  'u', &cfg.dw12,       cap_upper){"cap-upper", 'u', "NUM", CFG_POSITIVE, _Generic(&cfg.dw12
, uint32_t * : (&cfg.dw12)), ARGCONFIG_ARG_REQUIRED, cap_upper
, 0, },
OPT_END(){ ((void*)0) }
};

err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
if (err)
return err;

if (cfg.operation > 0xf) {
nvme_show_error("invalid operation field: %u", cfg.operation)nvme_show_message(1, "invalid operation field: %u", cfg.operation
);
return -1;
}

nvme_init_capacity_mgmt(&cmd, cfg.operation, cfg.element_id,
(__u64)cfg.dw12 << 32 | cfg.dw11);
if (cfg.ish) {
if (libnvme_transport_handle_is_mi(hdl))
	nvme_init_mi_cmd_flags(&cmd, ish);
else
	nvme_show_error("ISH is supported only for NVMe-MI")nvme_show_message(1, "ISH is supported only for NVMe-MI");
}
err = libnvme_exec_admin_passthru(hdl, &cmd);
if (err) {
nvme_show_err(err, "capacity management");
return err;
}

nvme_show_verbose_result("Capacity Management Command is Success")nvme_show_verbose_message("Capacity Management Command is Success"
);

if (cfg.operation == 1)
nvme_show_result("Created Element Identifier for Endurance Group is: %"nvme_show_message(0, "Created Element Identifier for Endurance Group is: %"
 "l" "u", (uint64_t)cmd.result)
                 PRIu64, (uint64_t)cmd.result)nvme_show_message(0, "Created Element Identifier for Endurance Group is: %"
 "l" "u", (uint64_t)cmd.result);
else if (cfg.operation == 3)
nvme_show_result("Created Element Identifier for NVM Set is: %"nvme_show_message(0, "Created Element Identifier for NVM Set is: %"
 "l" "u", (uint64_t)cmd.result)
                 PRIu64, (uint64_t)cmd.result)nvme_show_message(0, "Created Element Identifier for NVM Set is: %"
 "l" "u", (uint64_t)cmd.result);

return err;
1598}

1600static struct command dsm_cmd = {
.name = "dsm",
.help = "Submit a Data Set Management command, return results",
.fn = dsm,
1604};

1606static struct command copy_cmd_cmd = {
.name = "copy",
.help = "Submit a Simple Copy command, return results",
.fn = copy_cmd,
1610};

1612static struct command flush_cmd_cmd = {
.name = "flush",
.help = "Submit a Flush command, return results",
.fn = flush_cmd,
1616};

1618static struct command compare_cmd = {
.name = "compare",
.help = "Submit a Compare command, return results",
.fn = compare,
1622};

1624static struct command read_cmd_cmd = {
.name = "read",
.help = "Submit a read command, return results",
.fn = read_cmd,
1628};

1630static struct command write_cmd_cmd = {
.name = "write",
.help = "Submit a write command, return results",
.fn = write_cmd,
1634};

1636static struct command write_zeroes_cmd = {
.name = "write-zeroes",
.help = "Submit a write zeroes command, return results",
.fn = write_zeroes,
1640};

1642static struct command write_uncor_cmd = {
.name = "write-uncor",
.help = "Submit a write uncorrectable command, return results",
.fn = write_uncor,
1646};

1648static struct command verify_cmd_cmd = {
.name = "verify",
.help = "Submit a verify command, return results",
.fn = verify_cmd,
1652};

1654static struct command get_lba_status_cmd = {
.name = "get-lba-status",
.help = "Submit a Get LBA Status command, return results",
.fn = get_lba_status,
1658};

1660static struct command capacity_mgmt_cmd = {
.name = "capacity-mgmt",
.help = "Submit Capacity Management Command, return results",
.fn = capacity_mgmt,
1664};

1666static struct command *commands[] = {
&dsm_cmd,
&copy_cmd_cmd,
&flush_cmd_cmd,
&compare_cmd,
&read_cmd_cmd,
&write_cmd_cmd,
&write_zeroes_cmd,
&write_uncor_cmd,
&verify_cmd_cmd,
&get_lba_status_cmd,
&capacity_mgmt_cmd,
NULL((void*)0),
1679};

1681static void __shr_constructor__attribute__((constructor)) register_group(void)
1682{
plugin_add_group(&builtin, "I/O Commands", commands);
1684}