nvme/nvme-cli
1
0
Fork 0
Code Issues Activity

Merging upstream version 2.3.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-16 12:20:48 +01:00
parent 0f232ef15b
commit bf586630f8
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
444 changed files with 5289 additions and 1980 deletions
Download patch file Download diff file Expand all files Collapse all files

537
plugins/fdp/fdp.c Normal file
View file

@ -0,0 +1,537 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <linux/fs.h>
#include <sys/stat.h>
#include "common.h"
#include "nvme.h"
#include "libnvme.h"
#include "nvme-print.h"
#define CREATE_CMD
#include "fdp.h"
static int fdp_configs(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
const char *desc = "Get Flexible Data Placement Configurations";
const char *egid = "Endurance group identifier";
const char *human_readable = "show log in readable format";
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_dev *dev;
struct nvme_fdp_config_log hdr;
void *log = NULL;
int err;
struct config {
__u16 egid;
char *output_format;
bool human_readable;
bool raw_binary;
};
struct config cfg = {
.egid = 0,
.output_format = "normal",
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_UINT("endgrp-id", 'e', &cfg.egid, egid),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto out;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.human_readable)
flags |= VERBOSE;
if (!cfg.egid) {
fprintf(stderr, "endurance group identifier required\n");
err = -EINVAL;
goto out;
}
err = nvme_get_log_fdp_configurations(dev->direct.fd, cfg.egid, 0,
sizeof(hdr), &hdr);
if (err) {
nvme_show_status(errno);
goto out;
}
log = malloc(hdr.size);
if (!log) {
err = -ENOMEM;
goto out;
}
err = nvme_get_log_fdp_configurations(dev->direct.fd, cfg.egid, 0,
hdr.size, log);
if (err) {
nvme_show_status(errno);
goto out;
}
nvme_show_fdp_configs(log, hdr.size, flags);
out:
dev_close(dev);
free(log);
return err;
}
static int fdp_usage(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get Flexible Data Placement Reclaim Unit Handle Usage";
const char *egid = "Endurance group identifier";
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_dev *dev;
struct nvme_fdp_ruhu_log hdr;
size_t len;
void *log = NULL;
int err;
struct config {
__u16 egid;
char *output_format;
bool raw_binary;
};
struct config cfg = {
.egid = 0,
.output_format = "normal",
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_UINT("endgrp-id", 'e', &cfg.egid, egid),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto out;
if (cfg.raw_binary)
flags = BINARY;
err = nvme_get_log_reclaim_unit_handle_usage(dev->direct.fd, cfg.egid,
0, sizeof(hdr), &hdr);
if (err) {
nvme_show_status(err);
goto out;
}
len = sizeof(hdr) + le16_to_cpu(hdr.nruh) * sizeof(struct nvme_fdp_ruhu_desc);
log = malloc(len);
if (!log) {
err = -ENOMEM;
goto out;
}
err = nvme_get_log_reclaim_unit_handle_usage(dev->direct.fd, cfg.egid,
0, len, log);
if (err) {
nvme_show_status(err);
goto out;
}
nvme_show_fdp_usage(log, len, flags);
out:
dev_close(dev);
free(log);
return err;
}
static int fdp_stats(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get Flexible Data Placement Statistics";
const char *egid = "Endurance group identifier";
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_dev *dev;
struct nvme_fdp_stats_log stats;
int err;
struct config {
__u16 egid;
char *output_format;
bool raw_binary;
};
struct config cfg = {
.egid = 0,
.output_format = "normal",
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_UINT("endgrp-id", 'e', &cfg.egid, egid),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto out;
if (cfg.raw_binary)
flags = BINARY;
memset(&stats, 0x0, sizeof(stats));
err = nvme_get_log_fdp_stats(dev->direct.fd, cfg.egid, 0, sizeof(stats), &stats);
if (err) {
nvme_show_status(err);
goto out;
}
nvme_show_fdp_stats(&stats, flags);
out:
dev_close(dev);
return err;
}
static int fdp_events(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get Flexible Data Placement Events";
const char *egid = "Endurance group identifier";
const char *host_events = "Get host events";
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_dev *dev;
struct nvme_fdp_events_log events;
int err;
struct config {
__u16 egid;
bool host_events;
char *output_format;
bool raw_binary;
};
struct config cfg = {
.egid = 0,
.host_events = false,
.output_format = "normal",
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_UINT("endgrp-id", 'e', &cfg.egid, egid),
OPT_FLAG("host-events", 'E', &cfg.host_events, host_events),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto out;
if (cfg.raw_binary)
flags = BINARY;
memset(&events, 0x0, sizeof(events));
err = nvme_get_log_fdp_events(dev->direct.fd, cfg.egid,
cfg.host_events, 0, sizeof(events), &events);
if (err) {
nvme_show_status(err);
goto out;
}
nvme_show_fdp_events(&events, flags);
out:
dev_close(dev);
return err;
}
static int fdp_status(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Reclaim Unit Handle Status";
const char *namespace_id = "Namespace identifier";
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_dev *dev;
struct nvme_fdp_ruh_status hdr;
size_t len;
void *buf = NULL;
int err = -1;
struct config {
__u32 namespace_id;
char *output_format;
bool raw_binary;
};
struct config cfg = {
.output_format = "normal",
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto out;
if (cfg.raw_binary)
flags = BINARY;
if (!cfg.namespace_id) {
err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto out;
}
}
err = nvme_fdp_reclaim_unit_handle_status(dev_fd(dev),
cfg.namespace_id, sizeof(hdr), &hdr);
if (err) {
nvme_show_status(err);
goto out;
}
len = le16_to_cpu(hdr.nruhsd) * sizeof(struct nvme_fdp_ruh_status_desc);
buf = malloc(len);
if (!buf) {
err = -ENOMEM;
goto out;
}
err = nvme_fdp_reclaim_unit_handle_status(dev_fd(dev),
cfg.namespace_id, len, buf);
if (err) {
nvme_show_status(err);
goto out;
}
nvme_show_fdp_ruh_status(buf, len, flags);
out:
free(buf);
dev_close(dev);
return err;
}
static int fdp_update(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Reclaim Unit Handle Update";
const char *namespace_id = "Namespace identifier";
const char *_pids = "Comma-separated list of placement identifiers to update";
struct nvme_dev *dev;
unsigned short pids[256];
__u16 buf[256];
int npids;
int err = -1;
struct config {
__u32 namespace_id;
char *pids;
};
struct config cfg = {
.pids = "",
};
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
OPT_LIST("pids", 'p', &cfg.pids, _pids),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
npids = argconfig_parse_comma_sep_array_short(cfg.pids, pids, ARRAY_SIZE(pids));
if (npids < 0) {
perror("could not parse pids");
err = -EINVAL;
goto out;
} else if (npids == 0) {
fprintf(stderr, "no placement identifiers set\n");
err = -EINVAL;
goto out;
}
if (!cfg.namespace_id) {
err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto out;
}
}
for (unsigned int i = 0; i < npids; i++) {
buf[i] = cpu_to_le16(pids[i]);
}
err = nvme_fdp_reclaim_unit_handle_update(dev_fd(dev), cfg.namespace_id, npids, buf);
if (err) {
nvme_show_status(err);
goto out;
}
printf("update: Success\n");
out:
dev_close(dev);
return err;
}
static int fdp_set_events(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Enable or disable FDP events";
const char *namespace_id = "Namespace identifier";
const char *enable = "Enable/disable event";
const char *event_types = "Comma-separated list of event types";
const char *ph = "Placement Handle";
struct nvme_dev *dev;
int err = -1;
unsigned short evts[255];
int nev;
__u8 buf[255];
struct config {
__u32 namespace_id;
__u16 ph;
char *event_types;
bool enable;
};
struct config cfg = {
.enable = false,
};
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
OPT_SHRT("placement-handle", 'p', &cfg.ph, ph),
OPT_FLAG("enable", 'e', &cfg.enable, enable),
OPT_LIST("event-types", 't', &cfg.event_types, event_types),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
nev = argconfig_parse_comma_sep_array_short(cfg.event_types, evts, ARRAY_SIZE(evts));
if (nev < 0) {
perror("could not parse event types");
err = -EINVAL;
goto out;
} else if (nev == 0) {
fprintf(stderr, "no event types set\n");
err = -EINVAL;
goto out;
} else if (nev > 255) {
fprintf(stderr, "too many event types (max 255)\n");
err = -EINVAL;
goto out;
}
if (!cfg.namespace_id) {
err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
if (errno != ENOTTY) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto out;
}
cfg.namespace_id = NVME_NSID_ALL;
}
}
for (unsigned int i = 0; i < nev; i++) {
buf[i] = (__u8)evts[i];
}
struct nvme_set_features_args args = {
.args_size = sizeof(args),
.fd = dev_fd(dev),
.fid = NVME_FEAT_FID_FDP_EVENTS,
.nsid = cfg.namespace_id,
.cdw11 = (nev << 16) | cfg.ph,
.cdw12 = cfg.enable ? 0x1 : 0x0,
.data_len = sizeof(buf),
.data = buf,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
.result = NULL,
};
err = nvme_set_features(&args);
if (err) {
nvme_show_status(err);
goto out;
}
printf("set-events: Success\n");
out:
dev_close(dev);
return err;
}

24
plugins/fdp/fdp.h Normal file
View file

@ -0,0 +1,24 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
#undef CMD_INC_FILE
#define CMD_INC_FILE plugins/fdp/fdp
#if !defined(FDP_NVME) || defined(CMD_HEADER_MULTI_READ)
#define FDP_NVME
#include "cmd.h"
PLUGIN(NAME("fdp", "Manage Flexible Data Placement enabled devices", NVME_VERSION),
COMMAND_LIST(
ENTRY("configs", "List configurations", fdp_configs)
ENTRY("usage", "Show reclaim unit handle usage", fdp_usage)
ENTRY("stats", "Show statistics", fdp_stats)
ENTRY("events", "List events affecting reclaim units and media usage", fdp_events)
ENTRY("status", "Show reclaim unit handle status", fdp_status)
ENTRY("update", "Update a reclaim unit handle", fdp_update)
ENTRY("set-events", "Enabled or disable events", fdp_set_events)
)
);
#endif
#include "define_cmd.h"