2012-09-17 21:26:55 +00:00
|
|
|
/*-
|
2023-05-10 15:40:58 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2017-11-27 15:37:16 +00:00
|
|
|
*
|
2013-06-26 22:50:49 +00:00
|
|
|
* Copyright (C) 2012-2013 Intel Corporation
|
2012-09-17 21:26:55 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/ioccom.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
|
|
#include <ctype.h>
|
2018-12-06 22:58:26 +00:00
|
|
|
#include <dlfcn.h>
|
2013-07-09 21:14:15 +00:00
|
|
|
#include <err.h>
|
2013-07-09 21:31:21 +00:00
|
|
|
#include <errno.h>
|
2012-09-17 21:26:55 +00:00
|
|
|
#include <fcntl.h>
|
2020-11-18 20:00:55 +00:00
|
|
|
#include <libutil.h>
|
2013-07-18 23:25:57 +00:00
|
|
|
#include <paths.h>
|
2012-09-17 21:26:55 +00:00
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2020-11-13 02:05:45 +00:00
|
|
|
#include <sysexits.h>
|
2012-09-17 21:26:55 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
|
2013-06-26 22:58:59 +00:00
|
|
|
#include "nvmecontrol.h"
|
2013-03-26 19:50:46 +00:00
|
|
|
|
2013-06-26 23:46:31 +00:00
|
|
|
static void
|
|
|
|
print_bytes(void *data, uint32_t length)
|
|
|
|
{
|
|
|
|
uint32_t i, j;
|
|
|
|
uint8_t *p, *end;
|
|
|
|
|
|
|
|
end = (uint8_t *)data + length;
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
p = (uint8_t *)data + (i*16);
|
|
|
|
printf("%03x: ", i*16);
|
|
|
|
for (j = 0; j < 16 && p < end; j++)
|
|
|
|
printf("%02x ", *p++);
|
|
|
|
if (p >= end)
|
|
|
|
break;
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
print_dwords(void *data, uint32_t length)
|
|
|
|
{
|
|
|
|
uint32_t *p;
|
|
|
|
uint32_t i, j;
|
|
|
|
|
|
|
|
p = (uint32_t *)data;
|
|
|
|
length /= sizeof(uint32_t);
|
|
|
|
|
|
|
|
for (i = 0; i < length; i+=8) {
|
|
|
|
printf("%03x: ", i*4);
|
|
|
|
for (j = 0; j < 8; j++)
|
|
|
|
printf("%08x ", p[i+j]);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
print_hex(void *data, uint32_t length)
|
|
|
|
{
|
|
|
|
if (length >= sizeof(uint32_t) || length % sizeof(uint32_t) == 0)
|
|
|
|
print_dwords(data, length);
|
|
|
|
else
|
|
|
|
print_bytes(data, length);
|
|
|
|
}
|
|
|
|
|
2020-11-13 02:05:45 +00:00
|
|
|
int
|
2013-04-12 17:56:47 +00:00
|
|
|
read_controller_data(int fd, struct nvme_controller_data *cdata)
|
|
|
|
{
|
|
|
|
struct nvme_pt_command pt;
|
|
|
|
|
|
|
|
memset(&pt, 0, sizeof(pt));
|
2018-08-22 04:29:24 +00:00
|
|
|
pt.cmd.opc = NVME_OPC_IDENTIFY;
|
2018-02-22 13:32:31 +00:00
|
|
|
pt.cmd.cdw10 = htole32(1);
|
2013-04-12 17:56:47 +00:00
|
|
|
pt.buf = cdata;
|
|
|
|
pt.len = sizeof(*cdata);
|
|
|
|
pt.is_read = 1;
|
|
|
|
|
2013-07-09 21:14:15 +00:00
|
|
|
if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
|
2020-11-13 02:05:45 +00:00
|
|
|
return (errno);
|
2013-04-12 17:56:47 +00:00
|
|
|
|
2018-02-22 13:32:31 +00:00
|
|
|
/* Convert data to host endian */
|
|
|
|
nvme_controller_data_swapbytes(cdata);
|
|
|
|
|
2013-07-09 21:14:15 +00:00
|
|
|
if (nvme_completion_is_error(&pt.cpl))
|
2020-11-13 02:05:45 +00:00
|
|
|
return (EIO);
|
|
|
|
return (0);
|
2013-04-12 17:56:47 +00:00
|
|
|
}
|
|
|
|
|
2020-11-13 02:05:45 +00:00
|
|
|
int
|
2018-03-13 03:02:09 +00:00
|
|
|
read_namespace_data(int fd, uint32_t nsid, struct nvme_namespace_data *nsdata)
|
2013-04-12 17:56:47 +00:00
|
|
|
{
|
|
|
|
struct nvme_pt_command pt;
|
|
|
|
|
|
|
|
memset(&pt, 0, sizeof(pt));
|
2018-08-22 04:29:24 +00:00
|
|
|
pt.cmd.opc = NVME_OPC_IDENTIFY;
|
2018-02-22 13:32:31 +00:00
|
|
|
pt.cmd.nsid = htole32(nsid);
|
2019-07-31 18:44:20 +00:00
|
|
|
pt.cmd.cdw10 = htole32(0);
|
2013-04-12 17:56:47 +00:00
|
|
|
pt.buf = nsdata;
|
|
|
|
pt.len = sizeof(*nsdata);
|
|
|
|
pt.is_read = 1;
|
|
|
|
|
2013-07-09 21:14:15 +00:00
|
|
|
if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
|
2020-11-13 02:05:45 +00:00
|
|
|
return (errno);
|
2013-04-12 17:56:47 +00:00
|
|
|
|
2018-02-22 13:32:31 +00:00
|
|
|
/* Convert data to host endian */
|
|
|
|
nvme_namespace_data_swapbytes(nsdata);
|
|
|
|
|
2013-07-09 21:14:15 +00:00
|
|
|
if (nvme_completion_is_error(&pt.cpl))
|
2020-11-13 02:05:45 +00:00
|
|
|
return (EIO);
|
|
|
|
return (0);
|
2013-04-12 17:56:47 +00:00
|
|
|
}
|
2012-09-17 21:26:55 +00:00
|
|
|
|
2013-06-26 22:58:59 +00:00
|
|
|
int
|
2020-04-20 13:47:07 +00:00
|
|
|
open_dev(const char *str, int *fd, int write, int exit_on_error)
|
2013-06-26 22:50:49 +00:00
|
|
|
{
|
2024-04-28 17:01:24 +00:00
|
|
|
char full_path[MAXPATHLEN];
|
2013-06-26 22:50:49 +00:00
|
|
|
|
2024-04-28 17:01:24 +00:00
|
|
|
if (str[0] == '/') /* Full path */
|
|
|
|
strlcpy(full_path, str, sizeof(full_path));
|
|
|
|
else /* Add /dev/ */
|
|
|
|
snprintf(full_path, sizeof(full_path), _PATH_DEV"%s", str);
|
2020-04-20 13:47:07 +00:00
|
|
|
*fd = open(full_path, write ? O_RDWR : O_RDONLY);
|
2013-06-26 22:50:49 +00:00
|
|
|
if (*fd < 0) {
|
2020-04-20 13:47:07 +00:00
|
|
|
if (exit_on_error) {
|
2020-11-13 02:05:45 +00:00
|
|
|
err(EX_OSFILE, "could not open %s%s", full_path,
|
2020-04-20 13:47:07 +00:00
|
|
|
write ? " for write" : "");
|
|
|
|
} else
|
2013-07-18 23:12:44 +00:00
|
|
|
return (errno);
|
2013-06-26 22:50:49 +00:00
|
|
|
}
|
|
|
|
|
2013-07-09 21:14:15 +00:00
|
|
|
return (0);
|
2013-06-26 22:50:49 +00:00
|
|
|
}
|
|
|
|
|
2013-07-09 21:31:21 +00:00
|
|
|
void
|
2019-08-01 21:44:07 +00:00
|
|
|
get_nsid(int fd, char **ctrlr_str, uint32_t *nsid)
|
2013-07-09 21:31:21 +00:00
|
|
|
{
|
2019-08-01 21:44:07 +00:00
|
|
|
struct nvme_get_nsid gnsid;
|
|
|
|
|
|
|
|
if (ioctl(fd, NVME_GET_NSID, &gnsid) < 0)
|
2020-11-13 02:05:45 +00:00
|
|
|
err(EX_OSERR, "NVME_GET_NSID ioctl failed");
|
2019-08-01 21:44:07 +00:00
|
|
|
if (ctrlr_str != NULL)
|
|
|
|
*ctrlr_str = strndup(gnsid.cdev, sizeof(gnsid.cdev));
|
|
|
|
if (nsid != NULL)
|
|
|
|
*nsid = gnsid.nsid;
|
2013-07-09 21:31:21 +00:00
|
|
|
}
|
|
|
|
|
2012-09-17 21:26:55 +00:00
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
2020-11-18 20:00:55 +00:00
|
|
|
static char dir[MAXPATHLEN];
|
2012-09-17 21:26:55 +00:00
|
|
|
|
2019-07-16 17:24:03 +00:00
|
|
|
cmd_init();
|
2018-12-06 22:58:26 +00:00
|
|
|
|
2020-11-15 20:24:59 +00:00
|
|
|
cmd_load_dir("/lib/nvmecontrol", NULL, NULL);
|
2020-11-18 20:00:55 +00:00
|
|
|
snprintf(dir, MAXPATHLEN, "%s/lib/nvmecontrol", getlocalbase());
|
|
|
|
cmd_load_dir(dir, NULL, NULL);
|
2012-09-17 21:26:55 +00:00
|
|
|
|
2019-07-16 17:24:03 +00:00
|
|
|
cmd_dispatch(argc, argv, NULL);
|
2012-09-17 21:26:55 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|