1 // SPDX-License-Identifier: GPL-2.0
3 * NVMe over Fabrics common host code.
4 * Copyright (c) 2015-2016 HGST, a Western Digital Company.
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7 #include <linux/init.h>
8 #include <linux/miscdevice.h>
9 #include <linux/module.h>
10 #include <linux/mutex.h>
11 #include <linux/parser.h>
12 #include <linux/seq_file.h>
15 #include <linux/nvme-keyring.h>
17 static LIST_HEAD(nvmf_transports
);
18 static DECLARE_RWSEM(nvmf_transports_rwsem
);
20 static LIST_HEAD(nvmf_hosts
);
21 static DEFINE_MUTEX(nvmf_hosts_mutex
);
23 static struct nvmf_host
*nvmf_default_host
;
25 static struct nvmf_host
*nvmf_host_alloc(const char *hostnqn
, uuid_t
*id
)
27 struct nvmf_host
*host
;
29 host
= kmalloc(sizeof(*host
), GFP_KERNEL
);
33 kref_init(&host
->ref
);
34 uuid_copy(&host
->id
, id
);
35 strscpy(host
->nqn
, hostnqn
, NVMF_NQN_SIZE
);
40 static struct nvmf_host
*nvmf_host_add(const char *hostnqn
, uuid_t
*id
)
42 struct nvmf_host
*host
;
44 mutex_lock(&nvmf_hosts_mutex
);
47 * We have defined a host as how it is perceived by the target.
48 * Therefore, we don't allow different Host NQNs with the same Host ID.
49 * Similarly, we do not allow the usage of the same Host NQN with
50 * different Host IDs. This'll maintain unambiguous host identification.
52 list_for_each_entry(host
, &nvmf_hosts
, list
) {
53 bool same_hostnqn
= !strcmp(host
->nqn
, hostnqn
);
54 bool same_hostid
= uuid_equal(&host
->id
, id
);
56 if (same_hostnqn
&& same_hostid
) {
61 pr_err("found same hostnqn %s but different hostid %pUb\n",
63 host
= ERR_PTR(-EINVAL
);
67 pr_err("found same hostid %pUb but different hostnqn %s\n",
69 host
= ERR_PTR(-EINVAL
);
74 host
= nvmf_host_alloc(hostnqn
, id
);
76 host
= ERR_PTR(-ENOMEM
);
80 list_add_tail(&host
->list
, &nvmf_hosts
);
82 mutex_unlock(&nvmf_hosts_mutex
);
86 static struct nvmf_host
*nvmf_host_default(void)
88 struct nvmf_host
*host
;
89 char nqn
[NVMF_NQN_SIZE
];
93 snprintf(nqn
, NVMF_NQN_SIZE
,
94 "nqn.2014-08.org.nvmexpress:uuid:%pUb", &id
);
96 host
= nvmf_host_alloc(nqn
, &id
);
100 mutex_lock(&nvmf_hosts_mutex
);
101 list_add_tail(&host
->list
, &nvmf_hosts
);
102 mutex_unlock(&nvmf_hosts_mutex
);
107 static void nvmf_host_destroy(struct kref
*ref
)
109 struct nvmf_host
*host
= container_of(ref
, struct nvmf_host
, ref
);
111 mutex_lock(&nvmf_hosts_mutex
);
112 list_del(&host
->list
);
113 mutex_unlock(&nvmf_hosts_mutex
);
118 static void nvmf_host_put(struct nvmf_host
*host
)
121 kref_put(&host
->ref
, nvmf_host_destroy
);
125 * nvmf_get_address() - Get address/port
126 * @ctrl: Host NVMe controller instance which we got the address
127 * @buf: OUTPUT parameter that will contain the address/port
130 int nvmf_get_address(struct nvme_ctrl
*ctrl
, char *buf
, int size
)
134 if (ctrl
->opts
->mask
& NVMF_OPT_TRADDR
)
135 len
+= scnprintf(buf
, size
, "traddr=%s", ctrl
->opts
->traddr
);
136 if (ctrl
->opts
->mask
& NVMF_OPT_TRSVCID
)
137 len
+= scnprintf(buf
+ len
, size
- len
, "%strsvcid=%s",
138 (len
) ? "," : "", ctrl
->opts
->trsvcid
);
139 if (ctrl
->opts
->mask
& NVMF_OPT_HOST_TRADDR
)
140 len
+= scnprintf(buf
+ len
, size
- len
, "%shost_traddr=%s",
141 (len
) ? "," : "", ctrl
->opts
->host_traddr
);
142 if (ctrl
->opts
->mask
& NVMF_OPT_HOST_IFACE
)
143 len
+= scnprintf(buf
+ len
, size
- len
, "%shost_iface=%s",
144 (len
) ? "," : "", ctrl
->opts
->host_iface
);
145 len
+= scnprintf(buf
+ len
, size
- len
, "\n");
149 EXPORT_SYMBOL_GPL(nvmf_get_address
);
152 * nvmf_reg_read32() - NVMe Fabrics "Property Get" API function.
153 * @ctrl: Host NVMe controller instance maintaining the admin
154 * queue used to submit the property read command to
155 * the allocated NVMe controller resource on the target system.
156 * @off: Starting offset value of the targeted property
157 * register (see the fabrics section of the NVMe standard).
158 * @val: OUTPUT parameter that will contain the value of
159 * the property after a successful read.
161 * Used by the host system to retrieve a 32-bit capsule property value
162 * from an NVMe controller on the target system.
164 * ("Capsule property" is an "PCIe register concept" applied to the
165 * NVMe fabrics space.)
169 * > 0: NVMe error status code
170 * < 0: Linux errno error code
172 int nvmf_reg_read32(struct nvme_ctrl
*ctrl
, u32 off
, u32
*val
)
174 struct nvme_command cmd
= { };
175 union nvme_result res
;
178 cmd
.prop_get
.opcode
= nvme_fabrics_command
;
179 cmd
.prop_get
.fctype
= nvme_fabrics_type_property_get
;
180 cmd
.prop_get
.offset
= cpu_to_le32(off
);
182 ret
= __nvme_submit_sync_cmd(ctrl
->fabrics_q
, &cmd
, &res
, NULL
, 0,
186 *val
= le64_to_cpu(res
.u64
);
187 if (unlikely(ret
!= 0))
188 dev_err(ctrl
->device
,
189 "Property Get error: %d, offset %#x\n",
190 ret
> 0 ? ret
& ~NVME_SC_DNR
: ret
, off
);
194 EXPORT_SYMBOL_GPL(nvmf_reg_read32
);
197 * nvmf_reg_read64() - NVMe Fabrics "Property Get" API function.
198 * @ctrl: Host NVMe controller instance maintaining the admin
199 * queue used to submit the property read command to
200 * the allocated controller resource on the target system.
201 * @off: Starting offset value of the targeted property
202 * register (see the fabrics section of the NVMe standard).
203 * @val: OUTPUT parameter that will contain the value of
204 * the property after a successful read.
206 * Used by the host system to retrieve a 64-bit capsule property value
207 * from an NVMe controller on the target system.
209 * ("Capsule property" is an "PCIe register concept" applied to the
210 * NVMe fabrics space.)
214 * > 0: NVMe error status code
215 * < 0: Linux errno error code
217 int nvmf_reg_read64(struct nvme_ctrl
*ctrl
, u32 off
, u64
*val
)
219 struct nvme_command cmd
= { };
220 union nvme_result res
;
223 cmd
.prop_get
.opcode
= nvme_fabrics_command
;
224 cmd
.prop_get
.fctype
= nvme_fabrics_type_property_get
;
225 cmd
.prop_get
.attrib
= 1;
226 cmd
.prop_get
.offset
= cpu_to_le32(off
);
228 ret
= __nvme_submit_sync_cmd(ctrl
->fabrics_q
, &cmd
, &res
, NULL
, 0,
232 *val
= le64_to_cpu(res
.u64
);
233 if (unlikely(ret
!= 0))
234 dev_err(ctrl
->device
,
235 "Property Get error: %d, offset %#x\n",
236 ret
> 0 ? ret
& ~NVME_SC_DNR
: ret
, off
);
239 EXPORT_SYMBOL_GPL(nvmf_reg_read64
);
242 * nvmf_reg_write32() - NVMe Fabrics "Property Write" API function.
243 * @ctrl: Host NVMe controller instance maintaining the admin
244 * queue used to submit the property read command to
245 * the allocated NVMe controller resource on the target system.
246 * @off: Starting offset value of the targeted property
247 * register (see the fabrics section of the NVMe standard).
248 * @val: Input parameter that contains the value to be
249 * written to the property.
251 * Used by the NVMe host system to write a 32-bit capsule property value
252 * to an NVMe controller on the target system.
254 * ("Capsule property" is an "PCIe register concept" applied to the
255 * NVMe fabrics space.)
258 * 0: successful write
259 * > 0: NVMe error status code
260 * < 0: Linux errno error code
262 int nvmf_reg_write32(struct nvme_ctrl
*ctrl
, u32 off
, u32 val
)
264 struct nvme_command cmd
= { };
267 cmd
.prop_set
.opcode
= nvme_fabrics_command
;
268 cmd
.prop_set
.fctype
= nvme_fabrics_type_property_set
;
269 cmd
.prop_set
.attrib
= 0;
270 cmd
.prop_set
.offset
= cpu_to_le32(off
);
271 cmd
.prop_set
.value
= cpu_to_le64(val
);
273 ret
= __nvme_submit_sync_cmd(ctrl
->fabrics_q
, &cmd
, NULL
, NULL
, 0,
276 dev_err(ctrl
->device
,
277 "Property Set error: %d, offset %#x\n",
278 ret
> 0 ? ret
& ~NVME_SC_DNR
: ret
, off
);
281 EXPORT_SYMBOL_GPL(nvmf_reg_write32
);
284 * nvmf_log_connect_error() - Error-parsing-diagnostic print out function for
286 * @ctrl: The specific /dev/nvmeX device that had the error.
287 * @errval: Error code to be decoded in a more human-friendly
289 * @offset: For use with the NVMe error code
290 * NVME_SC_CONNECT_INVALID_PARAM.
291 * @cmd: This is the SQE portion of a submission capsule.
292 * @data: This is the "Data" portion of a submission capsule.
294 static void nvmf_log_connect_error(struct nvme_ctrl
*ctrl
,
295 int errval
, int offset
, struct nvme_command
*cmd
,
296 struct nvmf_connect_data
*data
)
298 int err_sctype
= errval
& ~NVME_SC_DNR
;
301 dev_err(ctrl
->device
,
302 "Connect command failed, errno: %d\n", errval
);
306 switch (err_sctype
) {
307 case NVME_SC_CONNECT_INVALID_PARAM
:
309 char *inv_data
= "Connect Invalid Data Parameter";
311 switch (offset
& 0xffff) {
312 case (offsetof(struct nvmf_connect_data
, cntlid
)):
313 dev_err(ctrl
->device
,
315 inv_data
, data
->cntlid
);
317 case (offsetof(struct nvmf_connect_data
, hostnqn
)):
318 dev_err(ctrl
->device
,
319 "%s, hostnqn \"%s\"\n",
320 inv_data
, data
->hostnqn
);
322 case (offsetof(struct nvmf_connect_data
, subsysnqn
)):
323 dev_err(ctrl
->device
,
324 "%s, subsysnqn \"%s\"\n",
325 inv_data
, data
->subsysnqn
);
328 dev_err(ctrl
->device
,
329 "%s, starting byte offset: %d\n",
330 inv_data
, offset
& 0xffff);
334 char *inv_sqe
= "Connect Invalid SQE Parameter";
337 case (offsetof(struct nvmf_connect_command
, qid
)):
338 dev_err(ctrl
->device
,
340 inv_sqe
, cmd
->connect
.qid
);
343 dev_err(ctrl
->device
,
344 "%s, starting byte offset: %d\n",
349 case NVME_SC_CONNECT_INVALID_HOST
:
350 dev_err(ctrl
->device
,
351 "Connect for subsystem %s is not allowed, hostnqn: %s\n",
352 data
->subsysnqn
, data
->hostnqn
);
354 case NVME_SC_CONNECT_CTRL_BUSY
:
355 dev_err(ctrl
->device
,
356 "Connect command failed: controller is busy or not available\n");
358 case NVME_SC_CONNECT_FORMAT
:
359 dev_err(ctrl
->device
,
360 "Connect incompatible format: %d",
361 cmd
->connect
.recfmt
);
363 case NVME_SC_HOST_PATH_ERROR
:
364 dev_err(ctrl
->device
,
365 "Connect command failed: host path error\n");
367 case NVME_SC_AUTH_REQUIRED
:
368 dev_err(ctrl
->device
,
369 "Connect command failed: authentication required\n");
372 dev_err(ctrl
->device
,
373 "Connect command failed, error wo/DNR bit: %d\n",
379 static struct nvmf_connect_data
*nvmf_connect_data_prep(struct nvme_ctrl
*ctrl
,
382 struct nvmf_connect_data
*data
;
384 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
388 uuid_copy(&data
->hostid
, &ctrl
->opts
->host
->id
);
389 data
->cntlid
= cpu_to_le16(cntlid
);
390 strncpy(data
->subsysnqn
, ctrl
->opts
->subsysnqn
, NVMF_NQN_SIZE
);
391 strncpy(data
->hostnqn
, ctrl
->opts
->host
->nqn
, NVMF_NQN_SIZE
);
396 static void nvmf_connect_cmd_prep(struct nvme_ctrl
*ctrl
, u16 qid
,
397 struct nvme_command
*cmd
)
399 cmd
->connect
.opcode
= nvme_fabrics_command
;
400 cmd
->connect
.fctype
= nvme_fabrics_type_connect
;
401 cmd
->connect
.qid
= cpu_to_le16(qid
);
404 cmd
->connect
.sqsize
= cpu_to_le16(ctrl
->sqsize
);
406 cmd
->connect
.sqsize
= cpu_to_le16(NVME_AQ_DEPTH
- 1);
409 * set keep-alive timeout in seconds granularity (ms * 1000)
411 cmd
->connect
.kato
= cpu_to_le32(ctrl
->kato
* 1000);
414 if (ctrl
->opts
->disable_sqflow
)
415 cmd
->connect
.cattr
|= NVME_CONNECT_DISABLE_SQFLOW
;
419 * nvmf_connect_admin_queue() - NVMe Fabrics Admin Queue "Connect"
421 * @ctrl: Host nvme controller instance used to request
422 * a new NVMe controller allocation on the target
423 * system and establish an NVMe Admin connection to
426 * This function enables an NVMe host device to request a new allocation of
427 * an NVMe controller resource on a target system as well establish a
428 * fabrics-protocol connection of the NVMe Admin queue between the
429 * host system device and the allocated NVMe controller on the
430 * target system via a NVMe Fabrics "Connect" command.
434 * > 0: NVMe error status code
435 * < 0: Linux errno error code
438 int nvmf_connect_admin_queue(struct nvme_ctrl
*ctrl
)
440 struct nvme_command cmd
= { };
441 union nvme_result res
;
442 struct nvmf_connect_data
*data
;
446 nvmf_connect_cmd_prep(ctrl
, 0, &cmd
);
448 data
= nvmf_connect_data_prep(ctrl
, 0xffff);
452 ret
= __nvme_submit_sync_cmd(ctrl
->fabrics_q
, &cmd
, &res
,
453 data
, sizeof(*data
), NVME_QID_ANY
, 1,
454 BLK_MQ_REQ_RESERVED
| BLK_MQ_REQ_NOWAIT
);
456 nvmf_log_connect_error(ctrl
, ret
, le32_to_cpu(res
.u32
),
461 result
= le32_to_cpu(res
.u32
);
462 ctrl
->cntlid
= result
& 0xFFFF;
463 if (result
& (NVME_CONNECT_AUTHREQ_ATR
| NVME_CONNECT_AUTHREQ_ASCR
)) {
464 /* Secure concatenation is not implemented */
465 if (result
& NVME_CONNECT_AUTHREQ_ASCR
) {
466 dev_warn(ctrl
->device
,
467 "qid 0: secure concatenation is not supported\n");
468 ret
= NVME_SC_AUTH_REQUIRED
;
471 /* Authentication required */
472 ret
= nvme_auth_negotiate(ctrl
, 0);
474 dev_warn(ctrl
->device
,
475 "qid 0: authentication setup failed\n");
476 ret
= NVME_SC_AUTH_REQUIRED
;
479 ret
= nvme_auth_wait(ctrl
, 0);
481 dev_warn(ctrl
->device
,
482 "qid 0: authentication failed\n");
484 dev_info(ctrl
->device
,
485 "qid 0: authenticated\n");
491 EXPORT_SYMBOL_GPL(nvmf_connect_admin_queue
);
494 * nvmf_connect_io_queue() - NVMe Fabrics I/O Queue "Connect"
496 * @ctrl: Host nvme controller instance used to establish an
497 * NVMe I/O queue connection to the already allocated NVMe
498 * controller on the target system.
499 * @qid: NVMe I/O queue number for the new I/O connection between
500 * host and target (note qid == 0 is illegal as this is
501 * the Admin queue, per NVMe standard).
503 * This function issues a fabrics-protocol connection
504 * of a NVMe I/O queue (via NVMe Fabrics "Connect" command)
505 * between the host system device and the allocated NVMe controller
506 * on the target system.
510 * > 0: NVMe error status code
511 * < 0: Linux errno error code
513 int nvmf_connect_io_queue(struct nvme_ctrl
*ctrl
, u16 qid
)
515 struct nvme_command cmd
= { };
516 struct nvmf_connect_data
*data
;
517 union nvme_result res
;
521 nvmf_connect_cmd_prep(ctrl
, qid
, &cmd
);
523 data
= nvmf_connect_data_prep(ctrl
, ctrl
->cntlid
);
527 ret
= __nvme_submit_sync_cmd(ctrl
->connect_q
, &cmd
, &res
,
528 data
, sizeof(*data
), qid
, 1,
529 BLK_MQ_REQ_RESERVED
| BLK_MQ_REQ_NOWAIT
);
531 nvmf_log_connect_error(ctrl
, ret
, le32_to_cpu(res
.u32
),
534 result
= le32_to_cpu(res
.u32
);
535 if (result
& (NVME_CONNECT_AUTHREQ_ATR
| NVME_CONNECT_AUTHREQ_ASCR
)) {
536 /* Secure concatenation is not implemented */
537 if (result
& NVME_CONNECT_AUTHREQ_ASCR
) {
538 dev_warn(ctrl
->device
,
539 "qid 0: secure concatenation is not supported\n");
540 ret
= NVME_SC_AUTH_REQUIRED
;
543 /* Authentication required */
544 ret
= nvme_auth_negotiate(ctrl
, qid
);
546 dev_warn(ctrl
->device
,
547 "qid %d: authentication setup failed\n", qid
);
548 ret
= NVME_SC_AUTH_REQUIRED
;
550 ret
= nvme_auth_wait(ctrl
, qid
);
552 dev_warn(ctrl
->device
,
553 "qid %u: authentication failed\n", qid
);
560 EXPORT_SYMBOL_GPL(nvmf_connect_io_queue
);
562 bool nvmf_should_reconnect(struct nvme_ctrl
*ctrl
)
564 if (ctrl
->opts
->max_reconnects
== -1 ||
565 ctrl
->nr_reconnects
< ctrl
->opts
->max_reconnects
)
570 EXPORT_SYMBOL_GPL(nvmf_should_reconnect
);
573 * nvmf_register_transport() - NVMe Fabrics Library registration function.
574 * @ops: Transport ops instance to be registered to the
575 * common fabrics library.
577 * API function that registers the type of specific transport fabric
578 * being implemented to the common NVMe fabrics library. Part of
579 * the overall init sequence of starting up a fabrics driver.
581 int nvmf_register_transport(struct nvmf_transport_ops
*ops
)
583 if (!ops
->create_ctrl
)
586 down_write(&nvmf_transports_rwsem
);
587 list_add_tail(&ops
->entry
, &nvmf_transports
);
588 up_write(&nvmf_transports_rwsem
);
592 EXPORT_SYMBOL_GPL(nvmf_register_transport
);
595 * nvmf_unregister_transport() - NVMe Fabrics Library unregistration function.
596 * @ops: Transport ops instance to be unregistered from the
597 * common fabrics library.
599 * Fabrics API function that unregisters the type of specific transport
600 * fabric being implemented from the common NVMe fabrics library.
601 * Part of the overall exit sequence of unloading the implemented driver.
603 void nvmf_unregister_transport(struct nvmf_transport_ops
*ops
)
605 down_write(&nvmf_transports_rwsem
);
606 list_del(&ops
->entry
);
607 up_write(&nvmf_transports_rwsem
);
609 EXPORT_SYMBOL_GPL(nvmf_unregister_transport
);
611 static struct nvmf_transport_ops
*nvmf_lookup_transport(
612 struct nvmf_ctrl_options
*opts
)
614 struct nvmf_transport_ops
*ops
;
616 lockdep_assert_held(&nvmf_transports_rwsem
);
618 list_for_each_entry(ops
, &nvmf_transports
, entry
) {
619 if (strcmp(ops
->name
, opts
->transport
) == 0)
626 static struct key
*nvmf_parse_key(int key_id
)
630 if (!IS_ENABLED(CONFIG_NVME_TCP_TLS
)) {
631 pr_err("TLS is not supported\n");
632 return ERR_PTR(-EINVAL
);
635 key
= key_lookup(key_id
);
637 pr_err("key id %08x not found\n", key_id
);
639 pr_debug("Using key id %08x\n", key_id
);
643 static const match_table_t opt_tokens
= {
644 { NVMF_OPT_TRANSPORT
, "transport=%s" },
645 { NVMF_OPT_TRADDR
, "traddr=%s" },
646 { NVMF_OPT_TRSVCID
, "trsvcid=%s" },
647 { NVMF_OPT_NQN
, "nqn=%s" },
648 { NVMF_OPT_QUEUE_SIZE
, "queue_size=%d" },
649 { NVMF_OPT_NR_IO_QUEUES
, "nr_io_queues=%d" },
650 { NVMF_OPT_RECONNECT_DELAY
, "reconnect_delay=%d" },
651 { NVMF_OPT_CTRL_LOSS_TMO
, "ctrl_loss_tmo=%d" },
652 { NVMF_OPT_KATO
, "keep_alive_tmo=%d" },
653 { NVMF_OPT_HOSTNQN
, "hostnqn=%s" },
654 { NVMF_OPT_HOST_TRADDR
, "host_traddr=%s" },
655 { NVMF_OPT_HOST_IFACE
, "host_iface=%s" },
656 { NVMF_OPT_HOST_ID
, "hostid=%s" },
657 { NVMF_OPT_DUP_CONNECT
, "duplicate_connect" },
658 { NVMF_OPT_DISABLE_SQFLOW
, "disable_sqflow" },
659 { NVMF_OPT_HDR_DIGEST
, "hdr_digest" },
660 { NVMF_OPT_DATA_DIGEST
, "data_digest" },
661 { NVMF_OPT_NR_WRITE_QUEUES
, "nr_write_queues=%d" },
662 { NVMF_OPT_NR_POLL_QUEUES
, "nr_poll_queues=%d" },
663 { NVMF_OPT_TOS
, "tos=%d" },
664 #ifdef CONFIG_NVME_TCP_TLS
665 { NVMF_OPT_KEYRING
, "keyring=%d" },
666 { NVMF_OPT_TLS_KEY
, "tls_key=%d" },
668 { NVMF_OPT_FAIL_FAST_TMO
, "fast_io_fail_tmo=%d" },
669 { NVMF_OPT_DISCOVERY
, "discovery" },
670 { NVMF_OPT_DHCHAP_SECRET
, "dhchap_secret=%s" },
671 { NVMF_OPT_DHCHAP_CTRL_SECRET
, "dhchap_ctrl_secret=%s" },
672 #ifdef CONFIG_NVME_TCP_TLS
673 { NVMF_OPT_TLS
, "tls" },
675 { NVMF_OPT_ERR
, NULL
}
678 static int nvmf_parse_options(struct nvmf_ctrl_options
*opts
,
681 substring_t args
[MAX_OPT_ARGS
];
682 char *options
, *o
, *p
;
685 int ctrl_loss_tmo
= NVMF_DEF_CTRL_LOSS_TMO
, key_id
;
687 char hostnqn
[NVMF_NQN_SIZE
];
691 opts
->queue_size
= NVMF_DEF_QUEUE_SIZE
;
692 opts
->nr_io_queues
= num_online_cpus();
693 opts
->reconnect_delay
= NVMF_DEF_RECONNECT_DELAY
;
695 opts
->duplicate_connect
= false;
696 opts
->fast_io_fail_tmo
= NVMF_DEF_FAIL_FAST_TMO
;
697 opts
->hdr_digest
= false;
698 opts
->data_digest
= false;
699 opts
->tos
= -1; /* < 0 == use transport default */
701 opts
->tls_key
= NULL
;
702 opts
->keyring
= NULL
;
704 options
= o
= kstrdup(buf
, GFP_KERNEL
);
708 /* use default host if not given by user space */
709 uuid_copy(&hostid
, &nvmf_default_host
->id
);
710 strscpy(hostnqn
, nvmf_default_host
->nqn
, NVMF_NQN_SIZE
);
712 while ((p
= strsep(&o
, ",\n")) != NULL
) {
716 token
= match_token(p
, opt_tokens
, args
);
719 case NVMF_OPT_TRANSPORT
:
720 p
= match_strdup(args
);
725 kfree(opts
->transport
);
729 p
= match_strdup(args
);
734 kfree(opts
->subsysnqn
);
736 nqnlen
= strlen(opts
->subsysnqn
);
737 if (nqnlen
>= NVMF_NQN_SIZE
) {
738 pr_err("%s needs to be < %d bytes\n",
739 opts
->subsysnqn
, NVMF_NQN_SIZE
);
743 opts
->discovery_nqn
=
744 !(strcmp(opts
->subsysnqn
,
745 NVME_DISC_SUBSYS_NAME
));
747 case NVMF_OPT_TRADDR
:
748 p
= match_strdup(args
);
756 case NVMF_OPT_TRSVCID
:
757 p
= match_strdup(args
);
762 kfree(opts
->trsvcid
);
765 case NVMF_OPT_QUEUE_SIZE
:
766 if (match_int(args
, &token
)) {
770 if (token
< NVMF_MIN_QUEUE_SIZE
||
771 token
> NVMF_MAX_QUEUE_SIZE
) {
772 pr_err("Invalid queue_size %d\n", token
);
776 opts
->queue_size
= token
;
778 case NVMF_OPT_NR_IO_QUEUES
:
779 if (match_int(args
, &token
)) {
784 pr_err("Invalid number of IOQs %d\n", token
);
788 if (opts
->discovery_nqn
) {
789 pr_debug("Ignoring nr_io_queues value for discovery controller\n");
793 opts
->nr_io_queues
= min_t(unsigned int,
794 num_online_cpus(), token
);
797 if (match_int(args
, &token
)) {
803 pr_err("Invalid keep_alive_tmo %d\n", token
);
806 } else if (token
== 0 && !opts
->discovery_nqn
) {
807 /* Allowed for debug */
808 pr_warn("keep_alive_tmo 0 won't execute keep alives!!!\n");
812 case NVMF_OPT_CTRL_LOSS_TMO
:
813 if (match_int(args
, &token
)) {
819 pr_warn("ctrl_loss_tmo < 0 will reconnect forever\n");
820 ctrl_loss_tmo
= token
;
822 case NVMF_OPT_FAIL_FAST_TMO
:
823 if (match_int(args
, &token
)) {
829 pr_warn("I/O fail on reconnect controller after %d sec\n",
834 opts
->fast_io_fail_tmo
= token
;
836 case NVMF_OPT_HOSTNQN
:
838 pr_err("hostnqn already user-assigned: %s\n",
843 p
= match_strdup(args
);
849 if (nqnlen
>= NVMF_NQN_SIZE
) {
850 pr_err("%s needs to be < %d bytes\n",
856 strscpy(hostnqn
, p
, NVMF_NQN_SIZE
);
859 case NVMF_OPT_RECONNECT_DELAY
:
860 if (match_int(args
, &token
)) {
865 pr_err("Invalid reconnect_delay %d\n", token
);
869 opts
->reconnect_delay
= token
;
871 case NVMF_OPT_HOST_TRADDR
:
872 p
= match_strdup(args
);
877 kfree(opts
->host_traddr
);
878 opts
->host_traddr
= p
;
880 case NVMF_OPT_HOST_IFACE
:
881 p
= match_strdup(args
);
886 kfree(opts
->host_iface
);
887 opts
->host_iface
= p
;
889 case NVMF_OPT_HOST_ID
:
890 p
= match_strdup(args
);
895 ret
= uuid_parse(p
, &hostid
);
897 pr_err("Invalid hostid %s\n", p
);
904 case NVMF_OPT_DUP_CONNECT
:
905 opts
->duplicate_connect
= true;
907 case NVMF_OPT_DISABLE_SQFLOW
:
908 opts
->disable_sqflow
= true;
910 case NVMF_OPT_HDR_DIGEST
:
911 opts
->hdr_digest
= true;
913 case NVMF_OPT_DATA_DIGEST
:
914 opts
->data_digest
= true;
916 case NVMF_OPT_NR_WRITE_QUEUES
:
917 if (match_int(args
, &token
)) {
922 pr_err("Invalid nr_write_queues %d\n", token
);
926 opts
->nr_write_queues
= token
;
928 case NVMF_OPT_NR_POLL_QUEUES
:
929 if (match_int(args
, &token
)) {
934 pr_err("Invalid nr_poll_queues %d\n", token
);
938 opts
->nr_poll_queues
= token
;
941 if (match_int(args
, &token
)) {
946 pr_err("Invalid type of service %d\n", token
);
951 pr_warn("Clamping type of service to 255\n");
956 case NVMF_OPT_KEYRING
:
957 if (match_int(args
, &key_id
) || key_id
<= 0) {
961 key
= nvmf_parse_key(key_id
);
966 key_put(opts
->keyring
);
969 case NVMF_OPT_TLS_KEY
:
970 if (match_int(args
, &key_id
) || key_id
<= 0) {
974 key
= nvmf_parse_key(key_id
);
979 key_put(opts
->tls_key
);
982 case NVMF_OPT_DISCOVERY
:
983 opts
->discovery_nqn
= true;
985 case NVMF_OPT_DHCHAP_SECRET
:
986 p
= match_strdup(args
);
991 if (strlen(p
) < 11 || strncmp(p
, "DHHC-1:", 7)) {
992 pr_err("Invalid DH-CHAP secret %s\n", p
);
996 kfree(opts
->dhchap_secret
);
997 opts
->dhchap_secret
= p
;
999 case NVMF_OPT_DHCHAP_CTRL_SECRET
:
1000 p
= match_strdup(args
);
1005 if (strlen(p
) < 11 || strncmp(p
, "DHHC-1:", 7)) {
1006 pr_err("Invalid DH-CHAP secret %s\n", p
);
1010 kfree(opts
->dhchap_ctrl_secret
);
1011 opts
->dhchap_ctrl_secret
= p
;
1014 if (!IS_ENABLED(CONFIG_NVME_TCP_TLS
)) {
1015 pr_err("TLS is not supported\n");
1022 pr_warn("unknown parameter or missing value '%s' in ctrl creation request\n",
1029 if (opts
->discovery_nqn
) {
1030 opts
->nr_io_queues
= 0;
1031 opts
->nr_write_queues
= 0;
1032 opts
->nr_poll_queues
= 0;
1033 opts
->duplicate_connect
= true;
1036 opts
->kato
= NVME_DEFAULT_KATO
;
1038 if (ctrl_loss_tmo
< 0) {
1039 opts
->max_reconnects
= -1;
1041 opts
->max_reconnects
= DIV_ROUND_UP(ctrl_loss_tmo
,
1042 opts
->reconnect_delay
);
1043 if (ctrl_loss_tmo
< opts
->fast_io_fail_tmo
)
1044 pr_warn("failfast tmo (%d) larger than controller loss tmo (%d)\n",
1045 opts
->fast_io_fail_tmo
, ctrl_loss_tmo
);
1048 opts
->host
= nvmf_host_add(hostnqn
, &hostid
);
1049 if (IS_ERR(opts
->host
)) {
1050 ret
= PTR_ERR(opts
->host
);
1060 void nvmf_set_io_queues(struct nvmf_ctrl_options
*opts
, u32 nr_io_queues
,
1061 u32 io_queues
[HCTX_MAX_TYPES
])
1063 if (opts
->nr_write_queues
&& opts
->nr_io_queues
< nr_io_queues
) {
1065 * separate read/write queues
1066 * hand out dedicated default queues only after we have
1067 * sufficient read queues.
1069 io_queues
[HCTX_TYPE_READ
] = opts
->nr_io_queues
;
1070 nr_io_queues
-= io_queues
[HCTX_TYPE_READ
];
1071 io_queues
[HCTX_TYPE_DEFAULT
] =
1072 min(opts
->nr_write_queues
, nr_io_queues
);
1073 nr_io_queues
-= io_queues
[HCTX_TYPE_DEFAULT
];
1076 * shared read/write queues
1077 * either no write queues were requested, or we don't have
1078 * sufficient queue count to have dedicated default queues.
1080 io_queues
[HCTX_TYPE_DEFAULT
] =
1081 min(opts
->nr_io_queues
, nr_io_queues
);
1082 nr_io_queues
-= io_queues
[HCTX_TYPE_DEFAULT
];
1085 if (opts
->nr_poll_queues
&& nr_io_queues
) {
1086 /* map dedicated poll queues only if we have queues left */
1087 io_queues
[HCTX_TYPE_POLL
] =
1088 min(opts
->nr_poll_queues
, nr_io_queues
);
1091 EXPORT_SYMBOL_GPL(nvmf_set_io_queues
);
1093 void nvmf_map_queues(struct blk_mq_tag_set
*set
, struct nvme_ctrl
*ctrl
,
1094 u32 io_queues
[HCTX_MAX_TYPES
])
1096 struct nvmf_ctrl_options
*opts
= ctrl
->opts
;
1098 if (opts
->nr_write_queues
&& io_queues
[HCTX_TYPE_READ
]) {
1099 /* separate read/write queues */
1100 set
->map
[HCTX_TYPE_DEFAULT
].nr_queues
=
1101 io_queues
[HCTX_TYPE_DEFAULT
];
1102 set
->map
[HCTX_TYPE_DEFAULT
].queue_offset
= 0;
1103 set
->map
[HCTX_TYPE_READ
].nr_queues
=
1104 io_queues
[HCTX_TYPE_READ
];
1105 set
->map
[HCTX_TYPE_READ
].queue_offset
=
1106 io_queues
[HCTX_TYPE_DEFAULT
];
1108 /* shared read/write queues */
1109 set
->map
[HCTX_TYPE_DEFAULT
].nr_queues
=
1110 io_queues
[HCTX_TYPE_DEFAULT
];
1111 set
->map
[HCTX_TYPE_DEFAULT
].queue_offset
= 0;
1112 set
->map
[HCTX_TYPE_READ
].nr_queues
=
1113 io_queues
[HCTX_TYPE_DEFAULT
];
1114 set
->map
[HCTX_TYPE_READ
].queue_offset
= 0;
1117 blk_mq_map_queues(&set
->map
[HCTX_TYPE_DEFAULT
]);
1118 blk_mq_map_queues(&set
->map
[HCTX_TYPE_READ
]);
1119 if (opts
->nr_poll_queues
&& io_queues
[HCTX_TYPE_POLL
]) {
1120 /* map dedicated poll queues only if we have queues left */
1121 set
->map
[HCTX_TYPE_POLL
].nr_queues
= io_queues
[HCTX_TYPE_POLL
];
1122 set
->map
[HCTX_TYPE_POLL
].queue_offset
=
1123 io_queues
[HCTX_TYPE_DEFAULT
] +
1124 io_queues
[HCTX_TYPE_READ
];
1125 blk_mq_map_queues(&set
->map
[HCTX_TYPE_POLL
]);
1128 dev_info(ctrl
->device
,
1129 "mapped %d/%d/%d default/read/poll queues.\n",
1130 io_queues
[HCTX_TYPE_DEFAULT
],
1131 io_queues
[HCTX_TYPE_READ
],
1132 io_queues
[HCTX_TYPE_POLL
]);
1134 EXPORT_SYMBOL_GPL(nvmf_map_queues
);
1136 static int nvmf_check_required_opts(struct nvmf_ctrl_options
*opts
,
1137 unsigned int required_opts
)
1139 if ((opts
->mask
& required_opts
) != required_opts
) {
1142 for (i
= 0; i
< ARRAY_SIZE(opt_tokens
); i
++) {
1143 if ((opt_tokens
[i
].token
& required_opts
) &&
1144 !(opt_tokens
[i
].token
& opts
->mask
)) {
1145 pr_warn("missing parameter '%s'\n",
1146 opt_tokens
[i
].pattern
);
1156 bool nvmf_ip_options_match(struct nvme_ctrl
*ctrl
,
1157 struct nvmf_ctrl_options
*opts
)
1159 if (!nvmf_ctlr_matches_baseopts(ctrl
, opts
) ||
1160 strcmp(opts
->traddr
, ctrl
->opts
->traddr
) ||
1161 strcmp(opts
->trsvcid
, ctrl
->opts
->trsvcid
))
1165 * Checking the local address or host interfaces is rough.
1167 * In most cases, none is specified and the host port or
1168 * host interface is selected by the stack.
1170 * Assume no match if:
1171 * - local address or host interface is specified and address
1172 * or host interface is not the same
1173 * - local address or host interface is not specified but
1174 * remote is, or vice versa (admin using specific
1175 * host_traddr/host_iface when it matters).
1177 if ((opts
->mask
& NVMF_OPT_HOST_TRADDR
) &&
1178 (ctrl
->opts
->mask
& NVMF_OPT_HOST_TRADDR
)) {
1179 if (strcmp(opts
->host_traddr
, ctrl
->opts
->host_traddr
))
1181 } else if ((opts
->mask
& NVMF_OPT_HOST_TRADDR
) ||
1182 (ctrl
->opts
->mask
& NVMF_OPT_HOST_TRADDR
)) {
1186 if ((opts
->mask
& NVMF_OPT_HOST_IFACE
) &&
1187 (ctrl
->opts
->mask
& NVMF_OPT_HOST_IFACE
)) {
1188 if (strcmp(opts
->host_iface
, ctrl
->opts
->host_iface
))
1190 } else if ((opts
->mask
& NVMF_OPT_HOST_IFACE
) ||
1191 (ctrl
->opts
->mask
& NVMF_OPT_HOST_IFACE
)) {
1197 EXPORT_SYMBOL_GPL(nvmf_ip_options_match
);
1199 static int nvmf_check_allowed_opts(struct nvmf_ctrl_options
*opts
,
1200 unsigned int allowed_opts
)
1202 if (opts
->mask
& ~allowed_opts
) {
1205 for (i
= 0; i
< ARRAY_SIZE(opt_tokens
); i
++) {
1206 if ((opt_tokens
[i
].token
& opts
->mask
) &&
1207 (opt_tokens
[i
].token
& ~allowed_opts
)) {
1208 pr_warn("invalid parameter '%s'\n",
1209 opt_tokens
[i
].pattern
);
1219 void nvmf_free_options(struct nvmf_ctrl_options
*opts
)
1221 nvmf_host_put(opts
->host
);
1222 key_put(opts
->keyring
);
1223 key_put(opts
->tls_key
);
1224 kfree(opts
->transport
);
1225 kfree(opts
->traddr
);
1226 kfree(opts
->trsvcid
);
1227 kfree(opts
->subsysnqn
);
1228 kfree(opts
->host_traddr
);
1229 kfree(opts
->host_iface
);
1230 kfree(opts
->dhchap_secret
);
1231 kfree(opts
->dhchap_ctrl_secret
);
1234 EXPORT_SYMBOL_GPL(nvmf_free_options
);
1236 #define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN)
1237 #define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \
1238 NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \
1239 NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\
1240 NVMF_OPT_DISABLE_SQFLOW | NVMF_OPT_DISCOVERY |\
1241 NVMF_OPT_FAIL_FAST_TMO | NVMF_OPT_DHCHAP_SECRET |\
1242 NVMF_OPT_DHCHAP_CTRL_SECRET)
1244 static struct nvme_ctrl
*
1245 nvmf_create_ctrl(struct device
*dev
, const char *buf
)
1247 struct nvmf_ctrl_options
*opts
;
1248 struct nvmf_transport_ops
*ops
;
1249 struct nvme_ctrl
*ctrl
;
1252 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
1254 return ERR_PTR(-ENOMEM
);
1256 ret
= nvmf_parse_options(opts
, buf
);
1261 request_module("nvme-%s", opts
->transport
);
1264 * Check the generic options first as we need a valid transport for
1265 * the lookup below. Then clear the generic flags so that transport
1266 * drivers don't have to care about them.
1268 ret
= nvmf_check_required_opts(opts
, NVMF_REQUIRED_OPTS
);
1271 opts
->mask
&= ~NVMF_REQUIRED_OPTS
;
1273 down_read(&nvmf_transports_rwsem
);
1274 ops
= nvmf_lookup_transport(opts
);
1276 pr_info("no handler found for transport %s.\n",
1282 if (!try_module_get(ops
->module
)) {
1286 up_read(&nvmf_transports_rwsem
);
1288 ret
= nvmf_check_required_opts(opts
, ops
->required_opts
);
1290 goto out_module_put
;
1291 ret
= nvmf_check_allowed_opts(opts
, NVMF_ALLOWED_OPTS
|
1292 ops
->allowed_opts
| ops
->required_opts
);
1294 goto out_module_put
;
1296 ctrl
= ops
->create_ctrl(dev
, opts
);
1298 ret
= PTR_ERR(ctrl
);
1299 goto out_module_put
;
1302 module_put(ops
->module
);
1306 module_put(ops
->module
);
1309 up_read(&nvmf_transports_rwsem
);
1311 nvmf_free_options(opts
);
1312 return ERR_PTR(ret
);
1315 static struct class *nvmf_class
;
1316 static struct device
*nvmf_device
;
1317 static DEFINE_MUTEX(nvmf_dev_mutex
);
1319 static ssize_t
nvmf_dev_write(struct file
*file
, const char __user
*ubuf
,
1320 size_t count
, loff_t
*pos
)
1322 struct seq_file
*seq_file
= file
->private_data
;
1323 struct nvme_ctrl
*ctrl
;
1327 if (count
> PAGE_SIZE
)
1330 buf
= memdup_user_nul(ubuf
, count
);
1332 return PTR_ERR(buf
);
1334 mutex_lock(&nvmf_dev_mutex
);
1335 if (seq_file
->private) {
1340 ctrl
= nvmf_create_ctrl(nvmf_device
, buf
);
1342 ret
= PTR_ERR(ctrl
);
1346 seq_file
->private = ctrl
;
1349 mutex_unlock(&nvmf_dev_mutex
);
1351 return ret
? ret
: count
;
1354 static void __nvmf_concat_opt_tokens(struct seq_file
*seq_file
)
1356 const struct match_token
*tok
;
1360 * Add dummy entries for instance and cntlid to
1361 * signal an invalid/non-existing controller
1363 seq_puts(seq_file
, "instance=-1,cntlid=-1");
1364 for (idx
= 0; idx
< ARRAY_SIZE(opt_tokens
); idx
++) {
1365 tok
= &opt_tokens
[idx
];
1366 if (tok
->token
== NVMF_OPT_ERR
)
1368 seq_puts(seq_file
, ",");
1369 seq_puts(seq_file
, tok
->pattern
);
1371 seq_puts(seq_file
, "\n");
1374 static int nvmf_dev_show(struct seq_file
*seq_file
, void *private)
1376 struct nvme_ctrl
*ctrl
;
1378 mutex_lock(&nvmf_dev_mutex
);
1379 ctrl
= seq_file
->private;
1381 __nvmf_concat_opt_tokens(seq_file
);
1385 seq_printf(seq_file
, "instance=%d,cntlid=%d\n",
1386 ctrl
->instance
, ctrl
->cntlid
);
1389 mutex_unlock(&nvmf_dev_mutex
);
1393 static int nvmf_dev_open(struct inode
*inode
, struct file
*file
)
1396 * The miscdevice code initializes file->private_data, but doesn't
1397 * make use of it later.
1399 file
->private_data
= NULL
;
1400 return single_open(file
, nvmf_dev_show
, NULL
);
1403 static int nvmf_dev_release(struct inode
*inode
, struct file
*file
)
1405 struct seq_file
*seq_file
= file
->private_data
;
1406 struct nvme_ctrl
*ctrl
= seq_file
->private;
1409 nvme_put_ctrl(ctrl
);
1410 return single_release(inode
, file
);
1413 static const struct file_operations nvmf_dev_fops
= {
1414 .owner
= THIS_MODULE
,
1415 .write
= nvmf_dev_write
,
1417 .open
= nvmf_dev_open
,
1418 .release
= nvmf_dev_release
,
1421 static struct miscdevice nvmf_misc
= {
1422 .minor
= MISC_DYNAMIC_MINOR
,
1423 .name
= "nvme-fabrics",
1424 .fops
= &nvmf_dev_fops
,
1427 static int __init
nvmf_init(void)
1431 nvmf_default_host
= nvmf_host_default();
1432 if (!nvmf_default_host
)
1435 nvmf_class
= class_create("nvme-fabrics");
1436 if (IS_ERR(nvmf_class
)) {
1437 pr_err("couldn't register class nvme-fabrics\n");
1438 ret
= PTR_ERR(nvmf_class
);
1443 device_create(nvmf_class
, NULL
, MKDEV(0, 0), NULL
, "ctl");
1444 if (IS_ERR(nvmf_device
)) {
1445 pr_err("couldn't create nvme-fabrics device!\n");
1446 ret
= PTR_ERR(nvmf_device
);
1447 goto out_destroy_class
;
1450 ret
= misc_register(&nvmf_misc
);
1452 pr_err("couldn't register misc device: %d\n", ret
);
1453 goto out_destroy_device
;
1459 device_destroy(nvmf_class
, MKDEV(0, 0));
1461 class_destroy(nvmf_class
);
1463 nvmf_host_put(nvmf_default_host
);
1467 static void __exit
nvmf_exit(void)
1469 misc_deregister(&nvmf_misc
);
1470 device_destroy(nvmf_class
, MKDEV(0, 0));
1471 class_destroy(nvmf_class
);
1472 nvmf_host_put(nvmf_default_host
);
1474 BUILD_BUG_ON(sizeof(struct nvmf_common_command
) != 64);
1475 BUILD_BUG_ON(sizeof(struct nvmf_connect_command
) != 64);
1476 BUILD_BUG_ON(sizeof(struct nvmf_property_get_command
) != 64);
1477 BUILD_BUG_ON(sizeof(struct nvmf_property_set_command
) != 64);
1478 BUILD_BUG_ON(sizeof(struct nvmf_auth_send_command
) != 64);
1479 BUILD_BUG_ON(sizeof(struct nvmf_auth_receive_command
) != 64);
1480 BUILD_BUG_ON(sizeof(struct nvmf_connect_data
) != 1024);
1481 BUILD_BUG_ON(sizeof(struct nvmf_auth_dhchap_negotiate_data
) != 8);
1482 BUILD_BUG_ON(sizeof(struct nvmf_auth_dhchap_challenge_data
) != 16);
1483 BUILD_BUG_ON(sizeof(struct nvmf_auth_dhchap_reply_data
) != 16);
1484 BUILD_BUG_ON(sizeof(struct nvmf_auth_dhchap_success1_data
) != 16);
1485 BUILD_BUG_ON(sizeof(struct nvmf_auth_dhchap_success2_data
) != 16);
1488 MODULE_LICENSE("GPL v2");
1490 module_init(nvmf_init
);
1491 module_exit(nvmf_exit
);