ioctl: add hooks into submission path

Don't expose the nvme_submit_passthru completely. Instead just provide
hooks for printing or deciding if a command needs to be retried. This is
similiar to the MI interface.

Signed-off-by: Daniel Wagner <[email protected]>

Author: igaw

libnvme/src/libnvme.map

@@ -64,6 +64,7 @@ LIBNVME_2_0 {
 		nvme_ctrl_set_tls_key_identity;
 		nvme_ctrl_set_unique_discovery_ctrl;
 		nvme_ctrls_filter;
+		nvme_decide_retry;
 		nvme_default_host;
 		nvme_describe_key_serial;
 		nvme_disconnect_ctrl;
@@ -240,13 +241,16 @@ LIBNVME_2_0 {
 		nvme_scan_topology;
 		nvme_set_application;
 		nvme_set_debug;
+		nvme_set_dry_run;
 		nvme_set_keyring;
 		nvme_set_property;
 		nvme_set_root;
 		nvme_skip_namespaces;
 		nvme_status_to_errno;
 		nvme_status_to_string;
 		nvme_submit_admin_passthru;
+		nvme_submit_entry;
+		nvme_submit_exit;
 		nvme_submit_io_passthru;
 		nvme_subsys_filter;
 		nvme_subsystem_first_ctrl;

libnvme/src/nvme/ioctl.c

@@ -27,8 +27,6 @@
 #include <ccan/endian/endian.h>
 
 #include "ioctl.h"
-#include "util.h"
-#include "log.h"
 #include "private.h"
 
 static int nvme_verify_chr(struct nvme_transport_handle *hdl)
@@ -100,17 +98,23 @@ int nvme_get_nsid(struct nvme_transport_handle *hdl, __u32 *nsid)
 }
 
 __attribute__((weak))
-int nvme_submit_passthru(struct nvme_transport_handle *hdl,
-		unsigned long ioctl_cmd, struct nvme_passthru_cmd *cmd,
-		__u64 *result)
+void *nvme_submit_entry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
 {
-	int err = ioctl(hdl->fd, ioctl_cmd, cmd);
+	return NULL;
+}
 
-	if (err >= 0 && result)
-		*result = cmd->result;
-	if (err < 0)
-		return -errno;
-	return err;
+__attribute__((weak))
+void nvme_submit_exit(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err, void *user_data)
+{
+}
+
+__attribute__((weak))
+bool nvme_decide_retry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err)
+{
+	return false;
 }
 
 /*
@@ -122,17 +126,29 @@ static int nvme_submit_passthru32(struct nvme_transport_handle *hdl,
 		__u64 *result)
 {
 	struct linux_passthru_cmd32 cmd32;
-	int err;
+	void *user_data;
+	int err = 0;
+
+	user_data = nvme_submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
 
 	memcpy(&cmd32, cmd, offsetof(struct linux_passthru_cmd32, result));
 	cmd32.result = 0;
 
-	err = ioctl(hdl->fd, ioctl_cmd, &cmd32);
+	do {
+		err = ioctl(hdl->fd, ioctl_cmd, &cmd32);
+		if (err >= 0)
+			break;
+		err = -errno;
+	} while (nvme_decide_retry(hdl, cmd, err));
+
+out:
 	cmd->result = cmd32.result;
 	if (err >= 0 && result)
 		*result = cmd->result;
-	if (err < 0)
-		return -errno;
+
+	nvme_submit_exit(hdl, cmd, err, user_data);
 	return err;
 }
 
@@ -144,13 +160,29 @@ static int nvme_submit_passthru64(struct nvme_transport_handle *hdl,
 		unsigned long ioctl_cmd, struct nvme_passthru_cmd *cmd,
 		__u64 *result)
 {
-	int err;
+	void *user_data;
+	int err = 0;
+
+	user_data = nvme_submit_entry(hdl, cmd);
+	if (hdl->ctx->dry_run)
+		goto out;
 
-	err = ioctl(hdl->fd, ioctl_cmd, cmd);
+	do {
+		/*
+		 * struct nvme_passtrhu_cmd is identically to struct
+                 * linux_passthru_cmd64, thus just pass it in directly.
+                 */
+		err = ioctl(hdl->fd, ioctl_cmd, cmd);
+		if (err >= 0)
+			break;
+		err = -errno;
+	} while (nvme_decide_retry(hdl, cmd, err));
+
+out:
 	if (err >= 0 && result)
 		*result = cmd->result;
-	if (err < 0)
-		return -errno;
+
+	nvme_submit_exit(hdl, cmd, err, user_data);
 	return err;
 }
 

libnvme/src/nvme/ioctl.h

@@ -448,6 +448,18 @@ enum nvme_cmd_dword_fields {
 #define NVME_FIELD_DECODE(value, shift, mask) \
 	(((value) >> (shift)) & (mask))
 
+__attribute__((weak))
+void *nvme_submit_entry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd);
+
+__attribute__((weak))
+void nvme_submit_exit(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err, void *user_data);
+
+__attribute__((weak))
+bool nvme_decide_retry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err);
+
 /**
  * nvme_submit_admin_passthru() - Submit an nvme passthrough admin command
  * @hdl:	Transport handle

libnvme/src/nvme/linux.c

@@ -41,6 +41,11 @@
 #include "base64.h"
 #include "crc32.h"
 
+void nvme_set_dry_run(struct nvme_global_ctx *ctx, bool enable)
+{
+	ctx->dry_run = enable;
+}
+
 static int __nvme_transport_handle_open_direct(struct nvme_transport_handle *hdl, const char *devname)
 {
 	_cleanup_free_ char *path = NULL;

libnvme/src/nvme/linux.h

@@ -636,22 +636,7 @@ int nvme_import_tls_key_versioned(const char *encoded_key,
 				  unsigned char *hmac,
 				  size_t *key_len,
 				  unsigned char **key);
-/**
- * nvme_submit_passthru - Low level ioctl wrapper for passthru commands
- * @hdl:	Transport handle
- * @ioctl_cmd:	IOCTL command id
- * @cmd:	Passhtru command
- * @result:	Optional field to return the result
- *
- * This is a low level library function which should not be used directly. It is
- * exposed as weak symbol so that the user application is able to provide their own
- * implementation of this function with additional debugging or logging code.
- *
- * Return: The value from the ioctl system call (see ioctl documentation) or
- * a negative error code otherwise.
- */
-__attribute__((weak))
-int nvme_submit_passthru(struct nvme_transport_handle *hdl, unsigned long ioctl_cmd,
-			 struct nvme_passthru_cmd *cmd, __u64 *result);
+
+void nvme_set_dry_run(struct nvme_global_ctx *ctx, bool enable);
 
 #endif /* _LIBNVME_LINUX_H */

libnvme/src/nvme/private.h

@@ -260,6 +260,7 @@ struct nvme_global_ctx {
 	bool modified;
 	bool mi_probe_enabled;
 	bool create_only;
+	bool dry_run;
 	struct nvme_fabric_options *options;
 };
 

logging.c

@@ -100,38 +100,41 @@ static void nvme_log_retry(int errnum)
 	printf("passthru command returned '%s'\n", strerror(errnum));
 }
 
-int nvme_submit_passthru(struct nvme_transport_handle *hdl,
-		unsigned long ioctl_cmd, struct nvme_passthru_cmd *cmd,
-		__u64 *result)
+void *nvme_submit_entry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd)
 {
-	struct timeval start;
-	struct timeval end;
-	int err = 0;
+	memset(&sb, 0, sizeof(sb));
 
 	if (log_level >= LOG_DEBUG)
-		gettimeofday(&start, NULL);
-
-	if (!nvme_cfg.dry_run) {
-retry:
-		err = ioctl(nvme_transport_handle_get_fd(hdl), ioctl_cmd, cmd);
-		if ((err && (errno == EAGAIN ||
-			     (errno == EINTR && !nvme_sigint_received))) &&
-		    !nvme_cfg.no_retries) {
-			nvme_log_retry(errno);
-			goto retry;
-		}
-	}
+		gettimeofday(&sb.start, NULL);
+
+	return &sb;
+}
+
+void nvme_submit_exit(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err, void *user_data)
+{
+	struct submit_data *sb = user_data;
 
 	if (log_level >= LOG_DEBUG) {
-		gettimeofday(&end, NULL);
+		gettimeofday(&sb->end, NULL);
 		nvme_show_command(cmd, err);
-		nvme_show_latency(start, end);
+		nvme_show_latency(sb->start, sb->end);
 	}
+}
+
+bool nvme_decide_retry(struct nvme_transport_handle *hdl,
+		struct nvme_passthru_cmd *cmd, int err)
+{
+	if (!nvme_cfg.no_retries)
+		return false;
 
-	if (err >= 0 && result)
-		*result = cmd->result;
+	if (err != -EAGAIN ||
+	    !(err == -EINTR && !nvme_sigint_received))
+		return false;
 
-	return err;
+	nvme_log_retry(errno);
+	return true;
 }
 
 static void nvme_show_req_admin(const struct nvme_mi_admin_req_hdr *hdr, size_t hdr_len,

nvme.c

@@ -406,6 +406,8 @@ int parse_and_open(struct nvme_global_ctx **ctx,
 		return -ENXIO;
 	}
 
+	nvme_set_dry_run(ctx_new, argconfig_parse_seen(opts, "dry_run"));
+
 	*ctx = ctx_new;
 	*hdl = hdl_new;
 	return 0;