Adding upstream version 1.12.
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
3b95ae912c
commit
ac60c09ef6
GPG key ID:
FBB4F0E80A80222F
457 changed files with 159628 additions and 0 deletions
608
nvme-topology.c
Normal file
608
nvme-topology.c
Normal file
|
|
@ -0,0 +1,608 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include "nvme.h"
|
||||
#include "nvme-ioctl.h"
|
||||
|
||||
static const char *dev = "/dev/";
|
||||
static const char *subsys_dir = "/sys/class/nvme-subsystem/";
|
||||
|
||||
char *get_nvme_subsnqn(char *path)
|
||||
{
|
||||
char sspath[320], *subsysnqn;
|
||||
int fd, ret;
|
||||
|
||||
snprintf(sspath, sizeof(sspath), "%s/subsysnqn", path);
|
||||
|
||||
fd = open(sspath, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n",
|
||||
sspath, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
subsysnqn = calloc(1, 256);
|
||||
if (!subsysnqn)
|
||||
goto close_fd;
|
||||
|
||||
ret = read(fd, subsysnqn, 256);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Failed to read %s: %s\n", sspath,
|
||||
strerror(errno));
|
||||
free(subsysnqn);
|
||||
subsysnqn = NULL;
|
||||
} else if (subsysnqn[strlen(subsysnqn) - 1] == '\n') {
|
||||
subsysnqn[strlen(subsysnqn) - 1] = '\0';
|
||||
}
|
||||
|
||||
close_fd:
|
||||
close(fd);
|
||||
return subsysnqn;
|
||||
}
|
||||
|
||||
char *nvme_get_ctrl_attr(char *path, const char *attr)
|
||||
{
|
||||
char *attrpath, *value;
|
||||
ssize_t ret;
|
||||
int fd, i;
|
||||
|
||||
ret = asprintf(&attrpath, "%s/%s", path, attr);
|
||||
if (ret < 0)
|
||||
return NULL;
|
||||
|
||||
value = calloc(1, 1024);
|
||||
if (!value)
|
||||
goto err_free_path;
|
||||
|
||||
fd = open(attrpath, O_RDONLY);
|
||||
if (fd < 0)
|
||||
goto err_free_value;
|
||||
|
||||
ret = read(fd, value, 1024);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "read :%s :%s\n", attrpath, strerror(errno));
|
||||
goto err_close_fd;
|
||||
}
|
||||
|
||||
if (value[strlen(value) - 1] == '\n')
|
||||
value[strlen(value) - 1] = '\0';
|
||||
|
||||
for (i = 0; i < strlen(value); i++) {
|
||||
if (value[i] == ',' )
|
||||
value[i] = ' ';
|
||||
}
|
||||
|
||||
close(fd);
|
||||
free(attrpath);
|
||||
return value;
|
||||
err_close_fd:
|
||||
close(fd);
|
||||
err_free_value:
|
||||
free(value);
|
||||
err_free_path:
|
||||
free(attrpath);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static char *path_trim_last(char *path, char needle)
|
||||
{
|
||||
int i;
|
||||
i = strlen(path);
|
||||
if (i>0 && path[i-1] == needle) // remove trailing slash
|
||||
path[--i] = 0;
|
||||
for (; i>0; i--)
|
||||
if (path[i] == needle) {
|
||||
path[i] = 0;
|
||||
return path+i+1;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void legacy_get_pci_bdf(char *node, char *bdf)
|
||||
{
|
||||
int ret;
|
||||
char path[264], nodetmp[264];
|
||||
struct stat st;
|
||||
char *p, *__path = path;
|
||||
|
||||
bdf[0] = 0;
|
||||
strcpy(nodetmp, node);
|
||||
p = path_trim_last(nodetmp, '/');
|
||||
sprintf(path, "/sys/block/%s/device", p);
|
||||
ret = readlink(path, nodetmp, sizeof(nodetmp));
|
||||
if (ret <= 0)
|
||||
return;
|
||||
nodetmp[ret] = 0;
|
||||
/* The link value is either "device -> ../../../0000:86:00.0" or "device -> ../../nvme0" */
|
||||
(void) path_trim_last(path, '/');
|
||||
sprintf(path+strlen(path), "/%s/device", nodetmp);
|
||||
ret = stat(path, &st);
|
||||
if (ret < 0)
|
||||
return;
|
||||
if ((st.st_mode & S_IFLNK) == 0) {
|
||||
/* follow the second link to get the PCI address */
|
||||
ret = readlink(path, __path, sizeof(path));
|
||||
if (ret <= 0)
|
||||
return;
|
||||
path[ret] = 0;
|
||||
}
|
||||
else
|
||||
(void) path_trim_last(path, '/');
|
||||
|
||||
p = path_trim_last(path, '/');
|
||||
if (p && strlen(p) == 12)
|
||||
strcpy(bdf, p);
|
||||
}
|
||||
|
||||
static int scan_namespace(struct nvme_namespace *n)
|
||||
{
|
||||
int ret, fd;
|
||||
char *path;
|
||||
|
||||
ret = asprintf(&path, "%s%s", dev, n->name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
fd = open(path, O_RDONLY);
|
||||
if (fd < 0)
|
||||
goto free;
|
||||
|
||||
n->nsid = nvme_get_nsid(fd);
|
||||
if (n->nsid < 0)
|
||||
goto close_fd;
|
||||
|
||||
ret = nvme_identify_ns(fd, n->nsid, 0, &n->ns);
|
||||
if (ret < 0)
|
||||
goto close_fd;
|
||||
close_fd:
|
||||
close(fd);
|
||||
free:
|
||||
free(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char *get_nvme_ctrl_path_ana_state(char *path, int nsid)
|
||||
{
|
||||
struct dirent **paths;
|
||||
char *ana_state;
|
||||
int i, n;
|
||||
|
||||
ana_state = calloc(1, 16);
|
||||
if (!ana_state)
|
||||
return NULL;
|
||||
|
||||
n = scandir(path, &paths, scan_ctrl_paths_filter, alphasort);
|
||||
if (n <= 0) {
|
||||
free(ana_state);
|
||||
return NULL;
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
int id, cntlid, ns, fd;
|
||||
char *ctrl_path;
|
||||
ssize_t ret;
|
||||
|
||||
if (sscanf(paths[i]->d_name, "nvme%dc%dn%d",
|
||||
&id, &cntlid, &ns) != 3) {
|
||||
if (sscanf(paths[i]->d_name, "nvme%dn%d",
|
||||
&id, &ns) != 2) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (ns != nsid)
|
||||
continue;
|
||||
|
||||
ret = asprintf(&ctrl_path, "%s/%s/ana_state",
|
||||
path, paths[i]->d_name);
|
||||
if (ret < 0) {
|
||||
free(ana_state);
|
||||
ana_state = NULL;
|
||||
break;
|
||||
}
|
||||
fd = open(ctrl_path, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
free(ctrl_path);
|
||||
free(ana_state);
|
||||
ana_state = NULL;
|
||||
break;
|
||||
}
|
||||
ret = read(fd, ana_state, 16);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Failed to read ANA state from %s\n",
|
||||
ctrl_path);
|
||||
free(ana_state);
|
||||
ana_state = NULL;
|
||||
} else if (ana_state[strlen(ana_state) - 1] == '\n')
|
||||
ana_state[strlen(ana_state) - 1] = '\0';
|
||||
close(fd);
|
||||
free(ctrl_path);
|
||||
break;
|
||||
}
|
||||
for (i = 0; i < n; i++)
|
||||
free(paths[i]);
|
||||
free(paths);
|
||||
return ana_state;
|
||||
}
|
||||
|
||||
static int scan_ctrl(struct nvme_ctrl *c, char *p, __u32 ns_instance)
|
||||
{
|
||||
struct nvme_namespace *n;
|
||||
struct dirent **ns;
|
||||
char *path;
|
||||
int i, fd, ret;
|
||||
|
||||
ret = asprintf(&path, "%s/%s", p, c->name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
c->address = nvme_get_ctrl_attr(path, "address");
|
||||
c->transport = nvme_get_ctrl_attr(path, "transport");
|
||||
c->state = nvme_get_ctrl_attr(path, "state");
|
||||
c->hostnqn = nvme_get_ctrl_attr(path, "hostnqn");
|
||||
c->hostid = nvme_get_ctrl_attr(path, "hostid");
|
||||
|
||||
if (ns_instance)
|
||||
c->ana_state = get_nvme_ctrl_path_ana_state(path, ns_instance);
|
||||
|
||||
ret = scandir(path, &ns, scan_namespace_filter, alphasort);
|
||||
if (ret == -1) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
|
||||
return errno;
|
||||
}
|
||||
|
||||
c->nr_namespaces = ret;
|
||||
c->namespaces = calloc(c->nr_namespaces, sizeof(*n));
|
||||
for (i = 0; i < c->nr_namespaces; i++) {
|
||||
n = &c->namespaces[i];
|
||||
n->name = strdup(ns[i]->d_name);
|
||||
n->ctrl = c;
|
||||
scan_namespace(n);
|
||||
}
|
||||
|
||||
while (i--)
|
||||
free(ns[i]);
|
||||
free(ns);
|
||||
free(path);
|
||||
|
||||
ret = asprintf(&path, "%s%s", dev, c->name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
fd = open(path, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "Failed to open %s\n", path);
|
||||
goto free;
|
||||
}
|
||||
|
||||
ret = nvme_identify_ctrl(fd, &c->id);
|
||||
if (ret < 0)
|
||||
goto close_fd;
|
||||
close_fd:
|
||||
close(fd);
|
||||
free:
|
||||
free(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int scan_subsystem(struct nvme_subsystem *s, __u32 ns_instance)
|
||||
{
|
||||
struct dirent **ctrls, **ns;
|
||||
struct nvme_namespace *n;
|
||||
struct nvme_ctrl *c;
|
||||
int i, ret;
|
||||
char *path;
|
||||
|
||||
ret = asprintf(&path, "%s%s", subsys_dir, s->name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
s->subsysnqn = get_nvme_subsnqn(path);
|
||||
ret = scandir(path, &ctrls, scan_ctrls_filter, alphasort);
|
||||
if (ret == -1) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
|
||||
return errno;
|
||||
}
|
||||
s->nr_ctrls = ret;
|
||||
s->ctrls = calloc(s->nr_ctrls, sizeof(*c));
|
||||
for (i = 0; i < s->nr_ctrls; i++) {
|
||||
c = &s->ctrls[i];
|
||||
c->name = strdup(ctrls[i]->d_name);
|
||||
c->subsys = s;
|
||||
scan_ctrl(c, path, ns_instance);
|
||||
}
|
||||
|
||||
while (i--)
|
||||
free(ctrls[i]);
|
||||
free(ctrls);
|
||||
|
||||
ret = scandir(path, &ns, scan_namespace_filter, alphasort);
|
||||
if (ret == -1) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
|
||||
return errno;
|
||||
}
|
||||
|
||||
s->nr_namespaces = ret;
|
||||
s->namespaces = calloc(s->nr_namespaces, sizeof(*n));
|
||||
for (i = 0; i < s->nr_namespaces; i++) {
|
||||
n = &s->namespaces[i];
|
||||
n->name = strdup(ns[i]->d_name);
|
||||
n->ctrl = &s->ctrls[0];
|
||||
scan_namespace(n);
|
||||
}
|
||||
|
||||
while (i--)
|
||||
free(ns[i]);
|
||||
free(ns);
|
||||
|
||||
free(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int verify_legacy_ns(struct nvme_namespace *n)
|
||||
{
|
||||
struct nvme_ctrl *c = n->ctrl;
|
||||
struct nvme_id_ctrl id;
|
||||
char *path;
|
||||
int ret, fd;
|
||||
|
||||
ret = asprintf(&path, "%s%s", dev, n->name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (!n->ctrl->transport && !n->ctrl->address) {
|
||||
char tmp_address[64] = "";
|
||||
legacy_get_pci_bdf(path, tmp_address);
|
||||
if (tmp_address[0]) {
|
||||
if (asprintf(&n->ctrl->transport, "pcie") < 0)
|
||||
return -1;
|
||||
if (asprintf(&n->ctrl->address, "%s", tmp_address) < 0)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
fd = open(path, O_RDONLY);
|
||||
free (path);
|
||||
|
||||
if (fd < 0)
|
||||
return fd;
|
||||
|
||||
ret = nvme_identify_ctrl(fd, &id);
|
||||
close(fd);
|
||||
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (memcmp(id.mn, c->id.mn, sizeof(id.mn)) ||
|
||||
memcmp(id.sn, c->id.sn, sizeof(id.sn)))
|
||||
return -ENODEV;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* For pre-subsystem enabled kernel. Topology information is limited, but we can
|
||||
* assume controller names are always a prefix to their namespaces, i.e. nvme0
|
||||
* is the controller to nvme0n1 for such older kernels. We will also assume
|
||||
* every controller is its own subsystem.
|
||||
*/
|
||||
static int legacy_list(struct nvme_topology *t)
|
||||
{
|
||||
struct nvme_ctrl *c;
|
||||
struct nvme_subsystem *s;
|
||||
struct nvme_namespace *n;
|
||||
struct dirent **devices, **namespaces;
|
||||
int ret = 0, fd, i;
|
||||
char *path;
|
||||
|
||||
t->nr_subsystems = scandir(dev, &devices, scan_ctrls_filter, alphasort);
|
||||
if (t->nr_subsystems < 0) {
|
||||
fprintf(stderr, "no NVMe device(s) detected.\n");
|
||||
return t->nr_subsystems;
|
||||
}
|
||||
|
||||
t->subsystems = calloc(t->nr_subsystems, sizeof(*s));
|
||||
for (i = 0; i < t->nr_subsystems; i++) {
|
||||
int j;
|
||||
|
||||
s = &t->subsystems[i];
|
||||
s->nr_ctrls = 1;
|
||||
s->ctrls = calloc(s->nr_ctrls, sizeof(*c));
|
||||
s->name = strdup(devices[i]->d_name);
|
||||
s->subsysnqn = strdup(s->name);
|
||||
s->nr_namespaces = 0;
|
||||
|
||||
c = s->ctrls;
|
||||
c->name = strdup(s->name);
|
||||
sscanf(c->name, "nvme%d", ¤t_index);
|
||||
c->nr_namespaces = scandir(dev, &namespaces, scan_dev_filter,
|
||||
alphasort);
|
||||
c->namespaces = calloc(c->nr_namespaces, sizeof(*n));
|
||||
|
||||
ret = asprintf(&path, "%s%s", dev, c->name);
|
||||
if (ret < 0)
|
||||
continue;
|
||||
ret = 0;
|
||||
|
||||
fd = open(path, O_RDONLY);
|
||||
if (fd > 0) {
|
||||
nvme_identify_ctrl(fd, &c->id);
|
||||
close(fd);
|
||||
}
|
||||
free(path);
|
||||
|
||||
for (j = 0; j < c->nr_namespaces; j++) {
|
||||
n = &c->namespaces[j];
|
||||
n->name = strdup(namespaces[j]->d_name);
|
||||
n->ctrl = c;
|
||||
scan_namespace(n);
|
||||
ret = verify_legacy_ns(n);
|
||||
if (ret)
|
||||
goto free;
|
||||
}
|
||||
while (j--)
|
||||
free(namespaces[j]);
|
||||
free(namespaces);
|
||||
}
|
||||
|
||||
free:
|
||||
while (i--)
|
||||
free(devices[i]);
|
||||
free(devices);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void free_ctrl(struct nvme_ctrl *c)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < c->nr_namespaces; i++) {
|
||||
struct nvme_namespace *n = &c->namespaces[i];
|
||||
free(n->name);
|
||||
}
|
||||
free(c->name);
|
||||
free(c->transport);
|
||||
free(c->address);
|
||||
free(c->state);
|
||||
free(c->hostnqn);
|
||||
free(c->hostid);
|
||||
free(c->ana_state);
|
||||
free(c->namespaces);
|
||||
}
|
||||
|
||||
static void free_subsystem(struct nvme_subsystem *s)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < s->nr_ctrls; i++)
|
||||
free_ctrl(&s->ctrls[i]);
|
||||
for (i = 0; i < s->nr_namespaces; i++) {
|
||||
struct nvme_namespace *n = &s->namespaces[i];
|
||||
free(n->name);
|
||||
}
|
||||
free(s->name);
|
||||
free(s->subsysnqn);
|
||||
free(s->ctrls);
|
||||
free(s->namespaces);
|
||||
}
|
||||
|
||||
int scan_subsystems(struct nvme_topology *t, const char *subsysnqn,
|
||||
__u32 ns_instance)
|
||||
{
|
||||
struct nvme_subsystem *s;
|
||||
struct dirent **subsys;
|
||||
int i, j = 0;
|
||||
|
||||
t->nr_subsystems = scandir(subsys_dir, &subsys, scan_subsys_filter,
|
||||
alphasort);
|
||||
if (t->nr_subsystems < 0)
|
||||
return legacy_list(t);
|
||||
|
||||
t->subsystems = calloc(t->nr_subsystems, sizeof(*s));
|
||||
for (i = 0; i < t->nr_subsystems; i++) {
|
||||
s = &t->subsystems[j];
|
||||
s->name = strdup(subsys[i]->d_name);
|
||||
scan_subsystem(s, ns_instance);
|
||||
|
||||
if (!subsysnqn || !strcmp(s->subsysnqn, subsysnqn))
|
||||
j++;
|
||||
else
|
||||
free_subsystem(s);
|
||||
}
|
||||
t->nr_subsystems = j;
|
||||
|
||||
while (i--)
|
||||
free(subsys[i]);
|
||||
free(subsys);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void free_topology(struct nvme_topology *t)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < t->nr_subsystems; i++)
|
||||
free_subsystem(&t->subsystems[i]);
|
||||
free(t->subsystems);
|
||||
}
|
||||
|
||||
char *nvme_char_from_block(char *dev)
|
||||
{
|
||||
char *path = NULL;
|
||||
char buf[256] = {0};
|
||||
int ret, id, nsid;
|
||||
|
||||
ret = sscanf(dev, "nvme%dn%d", &id, &nsid);
|
||||
switch (ret) {
|
||||
case 1:
|
||||
return strdup(dev);
|
||||
break;
|
||||
case 2:
|
||||
if (asprintf(&path, "/sys/block/%s/device", dev) < 0)
|
||||
path = NULL;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s is not an nvme device\n", dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!path)
|
||||
return NULL;
|
||||
|
||||
ret = readlink(path, buf, sizeof(buf));
|
||||
if (ret > 0) {
|
||||
char *r = strdup(basename(buf));
|
||||
|
||||
free(path);
|
||||
if (sscanf(r, "nvme%d", &id) != 1) {
|
||||
fprintf(stderr, "%s is not a physical nvme controller\n", r);
|
||||
free(r);
|
||||
r = NULL;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
free(path);
|
||||
ret = asprintf(&path, "nvme%d", id);
|
||||
if (ret < 0)
|
||||
return NULL;
|
||||
return path;
|
||||
}
|
||||
|
||||
void *mmap_registers(const char *dev)
|
||||
{
|
||||
int fd;
|
||||
char *base, path[512];
|
||||
void *membase;
|
||||
|
||||
base = nvme_char_from_block((char *)dev);
|
||||
if (!base)
|
||||
return NULL;
|
||||
|
||||
sprintf(path, "/sys/class/nvme/%s/device/resource0", base);
|
||||
fd = open(path, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
sprintf(path, "/sys/class/misc/%s/device/resource0", base);
|
||||
fd = open(path, O_RDONLY);
|
||||
}
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "%s did not find a pci resource, open failed %s\n",
|
||||
base, strerror(errno));
|
||||
free(base);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
membase = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd, 0);
|
||||
if (membase == MAP_FAILED) {
|
||||
fprintf(stderr, "%s failed to map. ", base);
|
||||
fprintf(stderr, "Did your kernel enable CONFIG_IO_STRICT_DEVMEM?\n");
|
||||
membase = NULL;
|
||||
}
|
||||
|
||||
free(base);
|
||||
close(fd);
|
||||
return membase;
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue