7ae732a77fe8fac8818bc3482f6b5ddece95c732
[sfrench/cifs-2.6.git] / drivers / nvme / host / fabrics.c
1 /*
2  * NVMe over Fabrics common host code.
3  * Copyright (c) 2015-2016 HGST, a Western Digital Company.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  */
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/init.h>
16 #include <linux/miscdevice.h>
17 #include <linux/module.h>
18 #include <linux/mutex.h>
19 #include <linux/parser.h>
20 #include <linux/seq_file.h>
21 #include "nvme.h"
22 #include "fabrics.h"
23
24 static LIST_HEAD(nvmf_transports);
25 static DECLARE_RWSEM(nvmf_transports_rwsem);
26
27 static LIST_HEAD(nvmf_hosts);
28 static DEFINE_MUTEX(nvmf_hosts_mutex);
29
30 static struct nvmf_host *nvmf_default_host;
31
32 static struct nvmf_host *__nvmf_host_find(const char *hostnqn)
33 {
34         struct nvmf_host *host;
35
36         list_for_each_entry(host, &nvmf_hosts, list) {
37                 if (!strcmp(host->nqn, hostnqn))
38                         return host;
39         }
40
41         return NULL;
42 }
43
44 static struct nvmf_host *nvmf_host_add(const char *hostnqn)
45 {
46         struct nvmf_host *host;
47
48         mutex_lock(&nvmf_hosts_mutex);
49         host = __nvmf_host_find(hostnqn);
50         if (host) {
51                 kref_get(&host->ref);
52                 goto out_unlock;
53         }
54
55         host = kmalloc(sizeof(*host), GFP_KERNEL);
56         if (!host)
57                 goto out_unlock;
58
59         kref_init(&host->ref);
60         memcpy(host->nqn, hostnqn, NVMF_NQN_SIZE);
61
62         list_add_tail(&host->list, &nvmf_hosts);
63 out_unlock:
64         mutex_unlock(&nvmf_hosts_mutex);
65         return host;
66 }
67
68 static struct nvmf_host *nvmf_host_default(void)
69 {
70         struct nvmf_host *host;
71
72         host = kmalloc(sizeof(*host), GFP_KERNEL);
73         if (!host)
74                 return NULL;
75
76         kref_init(&host->ref);
77         uuid_gen(&host->id);
78         snprintf(host->nqn, NVMF_NQN_SIZE,
79                 "nqn.2014-08.org.nvmexpress:uuid:%pUb", &host->id);
80
81         mutex_lock(&nvmf_hosts_mutex);
82         list_add_tail(&host->list, &nvmf_hosts);
83         mutex_unlock(&nvmf_hosts_mutex);
84
85         return host;
86 }
87
88 static void nvmf_host_destroy(struct kref *ref)
89 {
90         struct nvmf_host *host = container_of(ref, struct nvmf_host, ref);
91
92         mutex_lock(&nvmf_hosts_mutex);
93         list_del(&host->list);
94         mutex_unlock(&nvmf_hosts_mutex);
95
96         kfree(host);
97 }
98
99 static void nvmf_host_put(struct nvmf_host *host)
100 {
101         if (host)
102                 kref_put(&host->ref, nvmf_host_destroy);
103 }
104
105 /**
106  * nvmf_get_address() -  Get address/port
107  * @ctrl:       Host NVMe controller instance which we got the address
108  * @buf:        OUTPUT parameter that will contain the address/port
109  * @size:       buffer size
110  */
111 int nvmf_get_address(struct nvme_ctrl *ctrl, char *buf, int size)
112 {
113         int len = 0;
114
115         if (ctrl->opts->mask & NVMF_OPT_TRADDR)
116                 len += snprintf(buf, size, "traddr=%s", ctrl->opts->traddr);
117         if (ctrl->opts->mask & NVMF_OPT_TRSVCID)
118                 len += snprintf(buf + len, size - len, "%strsvcid=%s",
119                                 (len) ? "," : "", ctrl->opts->trsvcid);
120         if (ctrl->opts->mask & NVMF_OPT_HOST_TRADDR)
121                 len += snprintf(buf + len, size - len, "%shost_traddr=%s",
122                                 (len) ? "," : "", ctrl->opts->host_traddr);
123         len += snprintf(buf + len, size - len, "\n");
124
125         return len;
126 }
127 EXPORT_SYMBOL_GPL(nvmf_get_address);
128
129 /**
130  * nvmf_reg_read32() -  NVMe Fabrics "Property Get" API function.
131  * @ctrl:       Host NVMe controller instance maintaining the admin
132  *              queue used to submit the property read command to
133  *              the allocated NVMe controller resource on the target system.
134  * @off:        Starting offset value of the targeted property
135  *              register (see the fabrics section of the NVMe standard).
136  * @val:        OUTPUT parameter that will contain the value of
137  *              the property after a successful read.
138  *
139  * Used by the host system to retrieve a 32-bit capsule property value
140  * from an NVMe controller on the target system.
141  *
142  * ("Capsule property" is an "PCIe register concept" applied to the
143  * NVMe fabrics space.)
144  *
145  * Return:
146  *      0: successful read
147  *      > 0: NVMe error status code
148  *      < 0: Linux errno error code
149  */
150 int nvmf_reg_read32(struct nvme_ctrl *ctrl, u32 off, u32 *val)
151 {
152         struct nvme_command cmd;
153         union nvme_result res;
154         int ret;
155
156         memset(&cmd, 0, sizeof(cmd));
157         cmd.prop_get.opcode = nvme_fabrics_command;
158         cmd.prop_get.fctype = nvme_fabrics_type_property_get;
159         cmd.prop_get.offset = cpu_to_le32(off);
160
161         ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res, NULL, 0, 0,
162                         NVME_QID_ANY, 0, 0);
163
164         if (ret >= 0)
165                 *val = le64_to_cpu(res.u64);
166         if (unlikely(ret != 0))
167                 dev_err(ctrl->device,
168                         "Property Get error: %d, offset %#x\n",
169                         ret > 0 ? ret & ~NVME_SC_DNR : ret, off);
170
171         return ret;
172 }
173 EXPORT_SYMBOL_GPL(nvmf_reg_read32);
174
175 /**
176  * nvmf_reg_read64() -  NVMe Fabrics "Property Get" API function.
177  * @ctrl:       Host NVMe controller instance maintaining the admin
178  *              queue used to submit the property read command to
179  *              the allocated controller resource on the target system.
180  * @off:        Starting offset value of the targeted property
181  *              register (see the fabrics section of the NVMe standard).
182  * @val:        OUTPUT parameter that will contain the value of
183  *              the property after a successful read.
184  *
185  * Used by the host system to retrieve a 64-bit capsule property value
186  * from an NVMe controller on the target system.
187  *
188  * ("Capsule property" is an "PCIe register concept" applied to the
189  * NVMe fabrics space.)
190  *
191  * Return:
192  *      0: successful read
193  *      > 0: NVMe error status code
194  *      < 0: Linux errno error code
195  */
196 int nvmf_reg_read64(struct nvme_ctrl *ctrl, u32 off, u64 *val)
197 {
198         struct nvme_command cmd;
199         union nvme_result res;
200         int ret;
201
202         memset(&cmd, 0, sizeof(cmd));
203         cmd.prop_get.opcode = nvme_fabrics_command;
204         cmd.prop_get.fctype = nvme_fabrics_type_property_get;
205         cmd.prop_get.attrib = 1;
206         cmd.prop_get.offset = cpu_to_le32(off);
207
208         ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res, NULL, 0, 0,
209                         NVME_QID_ANY, 0, 0);
210
211         if (ret >= 0)
212                 *val = le64_to_cpu(res.u64);
213         if (unlikely(ret != 0))
214                 dev_err(ctrl->device,
215                         "Property Get error: %d, offset %#x\n",
216                         ret > 0 ? ret & ~NVME_SC_DNR : ret, off);
217         return ret;
218 }
219 EXPORT_SYMBOL_GPL(nvmf_reg_read64);
220
221 /**
222  * nvmf_reg_write32() -  NVMe Fabrics "Property Write" API function.
223  * @ctrl:       Host NVMe controller instance maintaining the admin
224  *              queue used to submit the property read command to
225  *              the allocated NVMe controller resource on the target system.
226  * @off:        Starting offset value of the targeted property
227  *              register (see the fabrics section of the NVMe standard).
228  * @val:        Input parameter that contains the value to be
229  *              written to the property.
230  *
231  * Used by the NVMe host system to write a 32-bit capsule property value
232  * to an NVMe controller on the target system.
233  *
234  * ("Capsule property" is an "PCIe register concept" applied to the
235  * NVMe fabrics space.)
236  *
237  * Return:
238  *      0: successful write
239  *      > 0: NVMe error status code
240  *      < 0: Linux errno error code
241  */
242 int nvmf_reg_write32(struct nvme_ctrl *ctrl, u32 off, u32 val)
243 {
244         struct nvme_command cmd;
245         int ret;
246
247         memset(&cmd, 0, sizeof(cmd));
248         cmd.prop_set.opcode = nvme_fabrics_command;
249         cmd.prop_set.fctype = nvme_fabrics_type_property_set;
250         cmd.prop_set.attrib = 0;
251         cmd.prop_set.offset = cpu_to_le32(off);
252         cmd.prop_set.value = cpu_to_le64(val);
253
254         ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, NULL, NULL, 0, 0,
255                         NVME_QID_ANY, 0, 0);
256         if (unlikely(ret))
257                 dev_err(ctrl->device,
258                         "Property Set error: %d, offset %#x\n",
259                         ret > 0 ? ret & ~NVME_SC_DNR : ret, off);
260         return ret;
261 }
262 EXPORT_SYMBOL_GPL(nvmf_reg_write32);
263
264 /**
265  * nvmf_log_connect_error() - Error-parsing-diagnostic print
266  * out function for connect() errors.
267  *
268  * @ctrl: the specific /dev/nvmeX device that had the error.
269  *
270  * @errval: Error code to be decoded in a more human-friendly
271  *          printout.
272  *
273  * @offset: For use with the NVMe error code NVME_SC_CONNECT_INVALID_PARAM.
274  *
275  * @cmd: This is the SQE portion of a submission capsule.
276  *
277  * @data: This is the "Data" portion of a submission capsule.
278  */
279 static void nvmf_log_connect_error(struct nvme_ctrl *ctrl,
280                 int errval, int offset, struct nvme_command *cmd,
281                 struct nvmf_connect_data *data)
282 {
283         int err_sctype = errval & (~NVME_SC_DNR);
284
285         switch (err_sctype) {
286
287         case (NVME_SC_CONNECT_INVALID_PARAM):
288                 if (offset >> 16) {
289                         char *inv_data = "Connect Invalid Data Parameter";
290
291                         switch (offset & 0xffff) {
292                         case (offsetof(struct nvmf_connect_data, cntlid)):
293                                 dev_err(ctrl->device,
294                                         "%s, cntlid: %d\n",
295                                         inv_data, data->cntlid);
296                                 break;
297                         case (offsetof(struct nvmf_connect_data, hostnqn)):
298                                 dev_err(ctrl->device,
299                                         "%s, hostnqn \"%s\"\n",
300                                         inv_data, data->hostnqn);
301                                 break;
302                         case (offsetof(struct nvmf_connect_data, subsysnqn)):
303                                 dev_err(ctrl->device,
304                                         "%s, subsysnqn \"%s\"\n",
305                                         inv_data, data->subsysnqn);
306                                 break;
307                         default:
308                                 dev_err(ctrl->device,
309                                         "%s, starting byte offset: %d\n",
310                                        inv_data, offset & 0xffff);
311                                 break;
312                         }
313                 } else {
314                         char *inv_sqe = "Connect Invalid SQE Parameter";
315
316                         switch (offset) {
317                         case (offsetof(struct nvmf_connect_command, qid)):
318                                 dev_err(ctrl->device,
319                                        "%s, qid %d\n",
320                                         inv_sqe, cmd->connect.qid);
321                                 break;
322                         default:
323                                 dev_err(ctrl->device,
324                                         "%s, starting byte offset: %d\n",
325                                         inv_sqe, offset);
326                         }
327                 }
328                 break;
329
330         case NVME_SC_CONNECT_INVALID_HOST:
331                 dev_err(ctrl->device,
332                         "Connect for subsystem %s is not allowed, hostnqn: %s\n",
333                         data->subsysnqn, data->hostnqn);
334                 break;
335
336         case NVME_SC_CONNECT_CTRL_BUSY:
337                 dev_err(ctrl->device,
338                         "Connect command failed: controller is busy or not available\n");
339                 break;
340
341         case NVME_SC_CONNECT_FORMAT:
342                 dev_err(ctrl->device,
343                         "Connect incompatible format: %d",
344                         cmd->connect.recfmt);
345                 break;
346
347         default:
348                 dev_err(ctrl->device,
349                         "Connect command failed, error wo/DNR bit: %d\n",
350                         err_sctype);
351                 break;
352         } /* switch (err_sctype) */
353 }
354
355 /**
356  * nvmf_connect_admin_queue() - NVMe Fabrics Admin Queue "Connect"
357  *                              API function.
358  * @ctrl:       Host nvme controller instance used to request
359  *              a new NVMe controller allocation on the target
360  *              system and  establish an NVMe Admin connection to
361  *              that controller.
362  *
363  * This function enables an NVMe host device to request a new allocation of
364  * an NVMe controller resource on a target system as well establish a
365  * fabrics-protocol connection of the NVMe Admin queue between the
366  * host system device and the allocated NVMe controller on the
367  * target system via a NVMe Fabrics "Connect" command.
368  *
369  * Return:
370  *      0: success
371  *      > 0: NVMe error status code
372  *      < 0: Linux errno error code
373  *
374  */
375 int nvmf_connect_admin_queue(struct nvme_ctrl *ctrl)
376 {
377         struct nvme_command cmd;
378         union nvme_result res;
379         struct nvmf_connect_data *data;
380         int ret;
381
382         memset(&cmd, 0, sizeof(cmd));
383         cmd.connect.opcode = nvme_fabrics_command;
384         cmd.connect.fctype = nvme_fabrics_type_connect;
385         cmd.connect.qid = 0;
386         cmd.connect.sqsize = cpu_to_le16(NVME_AQ_DEPTH - 1);
387
388         /*
389          * Set keep-alive timeout in seconds granularity (ms * 1000)
390          * and add a grace period for controller kato enforcement
391          */
392         cmd.connect.kato = ctrl->opts->discovery_nqn ? 0 :
393                 cpu_to_le32((ctrl->kato + NVME_KATO_GRACE) * 1000);
394
395         data = kzalloc(sizeof(*data), GFP_KERNEL);
396         if (!data)
397                 return -ENOMEM;
398
399         uuid_copy(&data->hostid, &ctrl->opts->host->id);
400         data->cntlid = cpu_to_le16(0xffff);
401         strncpy(data->subsysnqn, ctrl->opts->subsysnqn, NVMF_NQN_SIZE);
402         strncpy(data->hostnqn, ctrl->opts->host->nqn, NVMF_NQN_SIZE);
403
404         ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res,
405                         data, sizeof(*data), 0, NVME_QID_ANY, 1,
406                         BLK_MQ_REQ_RESERVED | BLK_MQ_REQ_NOWAIT);
407         if (ret) {
408                 nvmf_log_connect_error(ctrl, ret, le32_to_cpu(res.u32),
409                                        &cmd, data);
410                 goto out_free_data;
411         }
412
413         ctrl->cntlid = le16_to_cpu(res.u16);
414
415 out_free_data:
416         kfree(data);
417         return ret;
418 }
419 EXPORT_SYMBOL_GPL(nvmf_connect_admin_queue);
420
421 /**
422  * nvmf_connect_io_queue() - NVMe Fabrics I/O Queue "Connect"
423  *                           API function.
424  * @ctrl:       Host nvme controller instance used to establish an
425  *              NVMe I/O queue connection to the already allocated NVMe
426  *              controller on the target system.
427  * @qid:        NVMe I/O queue number for the new I/O connection between
428  *              host and target (note qid == 0 is illegal as this is
429  *              the Admin queue, per NVMe standard).
430  *
431  * This function issues a fabrics-protocol connection
432  * of a NVMe I/O queue (via NVMe Fabrics "Connect" command)
433  * between the host system device and the allocated NVMe controller
434  * on the target system.
435  *
436  * Return:
437  *      0: success
438  *      > 0: NVMe error status code
439  *      < 0: Linux errno error code
440  */
441 int nvmf_connect_io_queue(struct nvme_ctrl *ctrl, u16 qid)
442 {
443         struct nvme_command cmd;
444         struct nvmf_connect_data *data;
445         union nvme_result res;
446         int ret;
447
448         memset(&cmd, 0, sizeof(cmd));
449         cmd.connect.opcode = nvme_fabrics_command;
450         cmd.connect.fctype = nvme_fabrics_type_connect;
451         cmd.connect.qid = cpu_to_le16(qid);
452         cmd.connect.sqsize = cpu_to_le16(ctrl->sqsize);
453
454         data = kzalloc(sizeof(*data), GFP_KERNEL);
455         if (!data)
456                 return -ENOMEM;
457
458         uuid_copy(&data->hostid, &ctrl->opts->host->id);
459         data->cntlid = cpu_to_le16(ctrl->cntlid);
460         strncpy(data->subsysnqn, ctrl->opts->subsysnqn, NVMF_NQN_SIZE);
461         strncpy(data->hostnqn, ctrl->opts->host->nqn, NVMF_NQN_SIZE);
462
463         ret = __nvme_submit_sync_cmd(ctrl->connect_q, &cmd, &res,
464                         data, sizeof(*data), 0, qid, 1,
465                         BLK_MQ_REQ_RESERVED | BLK_MQ_REQ_NOWAIT);
466         if (ret) {
467                 nvmf_log_connect_error(ctrl, ret, le32_to_cpu(res.u32),
468                                        &cmd, data);
469         }
470         kfree(data);
471         return ret;
472 }
473 EXPORT_SYMBOL_GPL(nvmf_connect_io_queue);
474
475 bool nvmf_should_reconnect(struct nvme_ctrl *ctrl)
476 {
477         if (ctrl->opts->max_reconnects != -1 &&
478             ctrl->nr_reconnects < ctrl->opts->max_reconnects)
479                 return true;
480
481         return false;
482 }
483 EXPORT_SYMBOL_GPL(nvmf_should_reconnect);
484
485 /**
486  * nvmf_register_transport() - NVMe Fabrics Library registration function.
487  * @ops:        Transport ops instance to be registered to the
488  *              common fabrics library.
489  *
490  * API function that registers the type of specific transport fabric
491  * being implemented to the common NVMe fabrics library. Part of
492  * the overall init sequence of starting up a fabrics driver.
493  */
494 int nvmf_register_transport(struct nvmf_transport_ops *ops)
495 {
496         if (!ops->create_ctrl)
497                 return -EINVAL;
498
499         down_write(&nvmf_transports_rwsem);
500         list_add_tail(&ops->entry, &nvmf_transports);
501         up_write(&nvmf_transports_rwsem);
502
503         return 0;
504 }
505 EXPORT_SYMBOL_GPL(nvmf_register_transport);
506
507 /**
508  * nvmf_unregister_transport() - NVMe Fabrics Library unregistration function.
509  * @ops:        Transport ops instance to be unregistered from the
510  *              common fabrics library.
511  *
512  * Fabrics API function that unregisters the type of specific transport
513  * fabric being implemented from the common NVMe fabrics library.
514  * Part of the overall exit sequence of unloading the implemented driver.
515  */
516 void nvmf_unregister_transport(struct nvmf_transport_ops *ops)
517 {
518         down_write(&nvmf_transports_rwsem);
519         list_del(&ops->entry);
520         up_write(&nvmf_transports_rwsem);
521 }
522 EXPORT_SYMBOL_GPL(nvmf_unregister_transport);
523
524 static struct nvmf_transport_ops *nvmf_lookup_transport(
525                 struct nvmf_ctrl_options *opts)
526 {
527         struct nvmf_transport_ops *ops;
528
529         lockdep_assert_held(&nvmf_transports_rwsem);
530
531         list_for_each_entry(ops, &nvmf_transports, entry) {
532                 if (strcmp(ops->name, opts->transport) == 0)
533                         return ops;
534         }
535
536         return NULL;
537 }
538
539 blk_status_t nvmf_check_if_ready(struct nvme_ctrl *ctrl, struct request *rq,
540                 bool queue_live, bool is_connected)
541 {
542         struct nvme_command *cmd = nvme_req(rq)->cmd;
543
544         if (likely(ctrl->state == NVME_CTRL_LIVE && is_connected))
545                 return BLK_STS_OK;
546
547         switch (ctrl->state) {
548         case NVME_CTRL_DELETING:
549                 goto reject_io;
550
551         case NVME_CTRL_NEW:
552         case NVME_CTRL_CONNECTING:
553                 if (!is_connected)
554                         /*
555                          * This is the case of starting a new
556                          * association but connectivity was lost
557                          * before it was fully created. We need to
558                          * error the commands used to initialize the
559                          * controller so the reconnect can go into a
560                          * retry attempt. The commands should all be
561                          * marked REQ_FAILFAST_DRIVER, which will hit
562                          * the reject path below. Anything else will
563                          * be queued while the state settles.
564                          */
565                         goto reject_or_queue_io;
566
567                 if ((queue_live &&
568                      !(nvme_req(rq)->flags & NVME_REQ_USERCMD)) ||
569                     (!queue_live && blk_rq_is_passthrough(rq) &&
570                      cmd->common.opcode == nvme_fabrics_command &&
571                      cmd->fabrics.fctype == nvme_fabrics_type_connect))
572                         /*
573                          * If queue is live, allow only commands that
574                          * are internally generated pass through. These
575                          * are commands on the admin queue to initialize
576                          * the controller. This will reject any ioctl
577                          * admin cmds received while initializing.
578                          *
579                          * If the queue is not live, allow only a
580                          * connect command. This will reject any ioctl
581                          * admin cmd as well as initialization commands
582                          * if the controller reverted the queue to non-live.
583                          */
584                         return BLK_STS_OK;
585
586                 /*
587                  * fall-thru to the reject_or_queue_io clause
588                  */
589                 break;
590
591         /* these cases fall-thru
592          * case NVME_CTRL_LIVE:
593          * case NVME_CTRL_RESETTING:
594          */
595         default:
596                 break;
597         }
598
599 reject_or_queue_io:
600         /*
601          * Any other new io is something we're not in a state to send
602          * to the device. Default action is to busy it and retry it
603          * after the controller state is recovered. However, anything
604          * marked for failfast or nvme multipath is immediately failed.
605          * Note: commands used to initialize the controller will be
606          *  marked for failfast.
607          * Note: nvme cli/ioctl commands are marked for failfast.
608          */
609         if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
610                 return BLK_STS_RESOURCE;
611
612 reject_io:
613         nvme_req(rq)->status = NVME_SC_ABORT_REQ;
614         return BLK_STS_IOERR;
615 }
616 EXPORT_SYMBOL_GPL(nvmf_check_if_ready);
617
618 static const match_table_t opt_tokens = {
619         { NVMF_OPT_TRANSPORT,           "transport=%s"          },
620         { NVMF_OPT_TRADDR,              "traddr=%s"             },
621         { NVMF_OPT_TRSVCID,             "trsvcid=%s"            },
622         { NVMF_OPT_NQN,                 "nqn=%s"                },
623         { NVMF_OPT_QUEUE_SIZE,          "queue_size=%d"         },
624         { NVMF_OPT_NR_IO_QUEUES,        "nr_io_queues=%d"       },
625         { NVMF_OPT_RECONNECT_DELAY,     "reconnect_delay=%d"    },
626         { NVMF_OPT_CTRL_LOSS_TMO,       "ctrl_loss_tmo=%d"      },
627         { NVMF_OPT_KATO,                "keep_alive_tmo=%d"     },
628         { NVMF_OPT_HOSTNQN,             "hostnqn=%s"            },
629         { NVMF_OPT_HOST_TRADDR,         "host_traddr=%s"        },
630         { NVMF_OPT_HOST_ID,             "hostid=%s"             },
631         { NVMF_OPT_DUP_CONNECT,         "duplicate_connect"     },
632         { NVMF_OPT_ERR,                 NULL                    }
633 };
634
635 static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
636                 const char *buf)
637 {
638         substring_t args[MAX_OPT_ARGS];
639         char *options, *o, *p;
640         int token, ret = 0;
641         size_t nqnlen  = 0;
642         int ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO;
643         uuid_t hostid;
644
645         /* Set defaults */
646         opts->queue_size = NVMF_DEF_QUEUE_SIZE;
647         opts->nr_io_queues = num_online_cpus();
648         opts->reconnect_delay = NVMF_DEF_RECONNECT_DELAY;
649         opts->kato = NVME_DEFAULT_KATO;
650         opts->duplicate_connect = false;
651
652         options = o = kstrdup(buf, GFP_KERNEL);
653         if (!options)
654                 return -ENOMEM;
655
656         uuid_gen(&hostid);
657
658         while ((p = strsep(&o, ",\n")) != NULL) {
659                 if (!*p)
660                         continue;
661
662                 token = match_token(p, opt_tokens, args);
663                 opts->mask |= token;
664                 switch (token) {
665                 case NVMF_OPT_TRANSPORT:
666                         p = match_strdup(args);
667                         if (!p) {
668                                 ret = -ENOMEM;
669                                 goto out;
670                         }
671                         kfree(opts->transport);
672                         opts->transport = p;
673                         break;
674                 case NVMF_OPT_NQN:
675                         p = match_strdup(args);
676                         if (!p) {
677                                 ret = -ENOMEM;
678                                 goto out;
679                         }
680                         kfree(opts->subsysnqn);
681                         opts->subsysnqn = p;
682                         nqnlen = strlen(opts->subsysnqn);
683                         if (nqnlen >= NVMF_NQN_SIZE) {
684                                 pr_err("%s needs to be < %d bytes\n",
685                                         opts->subsysnqn, NVMF_NQN_SIZE);
686                                 ret = -EINVAL;
687                                 goto out;
688                         }
689                         opts->discovery_nqn =
690                                 !(strcmp(opts->subsysnqn,
691                                          NVME_DISC_SUBSYS_NAME));
692                         if (opts->discovery_nqn) {
693                                 opts->kato = 0;
694                                 opts->nr_io_queues = 0;
695                         }
696                         break;
697                 case NVMF_OPT_TRADDR:
698                         p = match_strdup(args);
699                         if (!p) {
700                                 ret = -ENOMEM;
701                                 goto out;
702                         }
703                         kfree(opts->traddr);
704                         opts->traddr = p;
705                         break;
706                 case NVMF_OPT_TRSVCID:
707                         p = match_strdup(args);
708                         if (!p) {
709                                 ret = -ENOMEM;
710                                 goto out;
711                         }
712                         kfree(opts->trsvcid);
713                         opts->trsvcid = p;
714                         break;
715                 case NVMF_OPT_QUEUE_SIZE:
716                         if (match_int(args, &token)) {
717                                 ret = -EINVAL;
718                                 goto out;
719                         }
720                         if (token < NVMF_MIN_QUEUE_SIZE ||
721                             token > NVMF_MAX_QUEUE_SIZE) {
722                                 pr_err("Invalid queue_size %d\n", token);
723                                 ret = -EINVAL;
724                                 goto out;
725                         }
726                         opts->queue_size = token;
727                         break;
728                 case NVMF_OPT_NR_IO_QUEUES:
729                         if (match_int(args, &token)) {
730                                 ret = -EINVAL;
731                                 goto out;
732                         }
733                         if (token <= 0) {
734                                 pr_err("Invalid number of IOQs %d\n", token);
735                                 ret = -EINVAL;
736                                 goto out;
737                         }
738                         if (opts->discovery_nqn) {
739                                 pr_debug("Ignoring nr_io_queues value for discovery controller\n");
740                                 break;
741                         }
742
743                         opts->nr_io_queues = min_t(unsigned int,
744                                         num_online_cpus(), token);
745                         break;
746                 case NVMF_OPT_KATO:
747                         if (match_int(args, &token)) {
748                                 ret = -EINVAL;
749                                 goto out;
750                         }
751
752                         if (token < 0) {
753                                 pr_err("Invalid keep_alive_tmo %d\n", token);
754                                 ret = -EINVAL;
755                                 goto out;
756                         } else if (token == 0 && !opts->discovery_nqn) {
757                                 /* Allowed for debug */
758                                 pr_warn("keep_alive_tmo 0 won't execute keep alives!!!\n");
759                         }
760                         opts->kato = token;
761
762                         if (opts->discovery_nqn && opts->kato) {
763                                 pr_err("Discovery controllers cannot accept KATO != 0\n");
764                                 ret = -EINVAL;
765                                 goto out;
766                         }
767
768                         break;
769                 case NVMF_OPT_CTRL_LOSS_TMO:
770                         if (match_int(args, &token)) {
771                                 ret = -EINVAL;
772                                 goto out;
773                         }
774
775                         if (token < 0)
776                                 pr_warn("ctrl_loss_tmo < 0 will reconnect forever\n");
777                         ctrl_loss_tmo = token;
778                         break;
779                 case NVMF_OPT_HOSTNQN:
780                         if (opts->host) {
781                                 pr_err("hostnqn already user-assigned: %s\n",
782                                        opts->host->nqn);
783                                 ret = -EADDRINUSE;
784                                 goto out;
785                         }
786                         p = match_strdup(args);
787                         if (!p) {
788                                 ret = -ENOMEM;
789                                 goto out;
790                         }
791                         nqnlen = strlen(p);
792                         if (nqnlen >= NVMF_NQN_SIZE) {
793                                 pr_err("%s needs to be < %d bytes\n",
794                                         p, NVMF_NQN_SIZE);
795                                 kfree(p);
796                                 ret = -EINVAL;
797                                 goto out;
798                         }
799                         nvmf_host_put(opts->host);
800                         opts->host = nvmf_host_add(p);
801                         kfree(p);
802                         if (!opts->host) {
803                                 ret = -ENOMEM;
804                                 goto out;
805                         }
806                         break;
807                 case NVMF_OPT_RECONNECT_DELAY:
808                         if (match_int(args, &token)) {
809                                 ret = -EINVAL;
810                                 goto out;
811                         }
812                         if (token <= 0) {
813                                 pr_err("Invalid reconnect_delay %d\n", token);
814                                 ret = -EINVAL;
815                                 goto out;
816                         }
817                         opts->reconnect_delay = token;
818                         break;
819                 case NVMF_OPT_HOST_TRADDR:
820                         p = match_strdup(args);
821                         if (!p) {
822                                 ret = -ENOMEM;
823                                 goto out;
824                         }
825                         kfree(opts->host_traddr);
826                         opts->host_traddr = p;
827                         break;
828                 case NVMF_OPT_HOST_ID:
829                         p = match_strdup(args);
830                         if (!p) {
831                                 ret = -ENOMEM;
832                                 goto out;
833                         }
834                         ret = uuid_parse(p, &hostid);
835                         if (ret) {
836                                 pr_err("Invalid hostid %s\n", p);
837                                 ret = -EINVAL;
838                                 kfree(p);
839                                 goto out;
840                         }
841                         kfree(p);
842                         break;
843                 case NVMF_OPT_DUP_CONNECT:
844                         opts->duplicate_connect = true;
845                         break;
846                 default:
847                         pr_warn("unknown parameter or missing value '%s' in ctrl creation request\n",
848                                 p);
849                         ret = -EINVAL;
850                         goto out;
851                 }
852         }
853
854         if (ctrl_loss_tmo < 0)
855                 opts->max_reconnects = -1;
856         else
857                 opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,
858                                                 opts->reconnect_delay);
859
860         if (!opts->host) {
861                 kref_get(&nvmf_default_host->ref);
862                 opts->host = nvmf_default_host;
863         }
864
865         uuid_copy(&opts->host->id, &hostid);
866
867 out:
868         kfree(options);
869         return ret;
870 }
871
872 static int nvmf_check_required_opts(struct nvmf_ctrl_options *opts,
873                 unsigned int required_opts)
874 {
875         if ((opts->mask & required_opts) != required_opts) {
876                 int i;
877
878                 for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {
879                         if ((opt_tokens[i].token & required_opts) &&
880                             !(opt_tokens[i].token & opts->mask)) {
881                                 pr_warn("missing parameter '%s'\n",
882                                         opt_tokens[i].pattern);
883                         }
884                 }
885
886                 return -EINVAL;
887         }
888
889         return 0;
890 }
891
892 static int nvmf_check_allowed_opts(struct nvmf_ctrl_options *opts,
893                 unsigned int allowed_opts)
894 {
895         if (opts->mask & ~allowed_opts) {
896                 int i;
897
898                 for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {
899                         if ((opt_tokens[i].token & opts->mask) &&
900                             (opt_tokens[i].token & ~allowed_opts)) {
901                                 pr_warn("invalid parameter '%s'\n",
902                                         opt_tokens[i].pattern);
903                         }
904                 }
905
906                 return -EINVAL;
907         }
908
909         return 0;
910 }
911
912 void nvmf_free_options(struct nvmf_ctrl_options *opts)
913 {
914         nvmf_host_put(opts->host);
915         kfree(opts->transport);
916         kfree(opts->traddr);
917         kfree(opts->trsvcid);
918         kfree(opts->subsysnqn);
919         kfree(opts->host_traddr);
920         kfree(opts);
921 }
922 EXPORT_SYMBOL_GPL(nvmf_free_options);
923
924 #define NVMF_REQUIRED_OPTS      (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN)
925 #define NVMF_ALLOWED_OPTS       (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \
926                                  NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \
927                                  NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT)
928
929 static struct nvme_ctrl *
930 nvmf_create_ctrl(struct device *dev, const char *buf, size_t count)
931 {
932         struct nvmf_ctrl_options *opts;
933         struct nvmf_transport_ops *ops;
934         struct nvme_ctrl *ctrl;
935         int ret;
936
937         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
938         if (!opts)
939                 return ERR_PTR(-ENOMEM);
940
941         ret = nvmf_parse_options(opts, buf);
942         if (ret)
943                 goto out_free_opts;
944
945
946         request_module("nvme-%s", opts->transport);
947
948         /*
949          * Check the generic options first as we need a valid transport for
950          * the lookup below.  Then clear the generic flags so that transport
951          * drivers don't have to care about them.
952          */
953         ret = nvmf_check_required_opts(opts, NVMF_REQUIRED_OPTS);
954         if (ret)
955                 goto out_free_opts;
956         opts->mask &= ~NVMF_REQUIRED_OPTS;
957
958         down_read(&nvmf_transports_rwsem);
959         ops = nvmf_lookup_transport(opts);
960         if (!ops) {
961                 pr_info("no handler found for transport %s.\n",
962                         opts->transport);
963                 ret = -EINVAL;
964                 goto out_unlock;
965         }
966
967         if (!try_module_get(ops->module)) {
968                 ret = -EBUSY;
969                 goto out_unlock;
970         }
971
972         ret = nvmf_check_required_opts(opts, ops->required_opts);
973         if (ret)
974                 goto out_module_put;
975         ret = nvmf_check_allowed_opts(opts, NVMF_ALLOWED_OPTS |
976                                 ops->allowed_opts | ops->required_opts);
977         if (ret)
978                 goto out_module_put;
979
980         ctrl = ops->create_ctrl(dev, opts);
981         if (IS_ERR(ctrl)) {
982                 ret = PTR_ERR(ctrl);
983                 goto out_module_put;
984         }
985
986         if (strcmp(ctrl->subsys->subnqn, opts->subsysnqn)) {
987                 dev_warn(ctrl->device,
988                         "controller returned incorrect NQN: \"%s\".\n",
989                         ctrl->subsys->subnqn);
990                 module_put(ops->module);
991                 up_read(&nvmf_transports_rwsem);
992                 nvme_delete_ctrl_sync(ctrl);
993                 return ERR_PTR(-EINVAL);
994         }
995
996         module_put(ops->module);
997         up_read(&nvmf_transports_rwsem);
998         return ctrl;
999
1000 out_module_put:
1001         module_put(ops->module);
1002 out_unlock:
1003         up_read(&nvmf_transports_rwsem);
1004 out_free_opts:
1005         nvmf_free_options(opts);
1006         return ERR_PTR(ret);
1007 }
1008
1009 static struct class *nvmf_class;
1010 static struct device *nvmf_device;
1011 static DEFINE_MUTEX(nvmf_dev_mutex);
1012
1013 static ssize_t nvmf_dev_write(struct file *file, const char __user *ubuf,
1014                 size_t count, loff_t *pos)
1015 {
1016         struct seq_file *seq_file = file->private_data;
1017         struct nvme_ctrl *ctrl;
1018         const char *buf;
1019         int ret = 0;
1020
1021         if (count > PAGE_SIZE)
1022                 return -ENOMEM;
1023
1024         buf = memdup_user_nul(ubuf, count);
1025         if (IS_ERR(buf))
1026                 return PTR_ERR(buf);
1027
1028         mutex_lock(&nvmf_dev_mutex);
1029         if (seq_file->private) {
1030                 ret = -EINVAL;
1031                 goto out_unlock;
1032         }
1033
1034         ctrl = nvmf_create_ctrl(nvmf_device, buf, count);
1035         if (IS_ERR(ctrl)) {
1036                 ret = PTR_ERR(ctrl);
1037                 goto out_unlock;
1038         }
1039
1040         seq_file->private = ctrl;
1041
1042 out_unlock:
1043         mutex_unlock(&nvmf_dev_mutex);
1044         kfree(buf);
1045         return ret ? ret : count;
1046 }
1047
1048 static int nvmf_dev_show(struct seq_file *seq_file, void *private)
1049 {
1050         struct nvme_ctrl *ctrl;
1051         int ret = 0;
1052
1053         mutex_lock(&nvmf_dev_mutex);
1054         ctrl = seq_file->private;
1055         if (!ctrl) {
1056                 ret = -EINVAL;
1057                 goto out_unlock;
1058         }
1059
1060         seq_printf(seq_file, "instance=%d,cntlid=%d\n",
1061                         ctrl->instance, ctrl->cntlid);
1062
1063 out_unlock:
1064         mutex_unlock(&nvmf_dev_mutex);
1065         return ret;
1066 }
1067
1068 static int nvmf_dev_open(struct inode *inode, struct file *file)
1069 {
1070         /*
1071          * The miscdevice code initializes file->private_data, but doesn't
1072          * make use of it later.
1073          */
1074         file->private_data = NULL;
1075         return single_open(file, nvmf_dev_show, NULL);
1076 }
1077
1078 static int nvmf_dev_release(struct inode *inode, struct file *file)
1079 {
1080         struct seq_file *seq_file = file->private_data;
1081         struct nvme_ctrl *ctrl = seq_file->private;
1082
1083         if (ctrl)
1084                 nvme_put_ctrl(ctrl);
1085         return single_release(inode, file);
1086 }
1087
1088 static const struct file_operations nvmf_dev_fops = {
1089         .owner          = THIS_MODULE,
1090         .write          = nvmf_dev_write,
1091         .read           = seq_read,
1092         .open           = nvmf_dev_open,
1093         .release        = nvmf_dev_release,
1094 };
1095
1096 static struct miscdevice nvmf_misc = {
1097         .minor          = MISC_DYNAMIC_MINOR,
1098         .name           = "nvme-fabrics",
1099         .fops           = &nvmf_dev_fops,
1100 };
1101
1102 static int __init nvmf_init(void)
1103 {
1104         int ret;
1105
1106         nvmf_default_host = nvmf_host_default();
1107         if (!nvmf_default_host)
1108                 return -ENOMEM;
1109
1110         nvmf_class = class_create(THIS_MODULE, "nvme-fabrics");
1111         if (IS_ERR(nvmf_class)) {
1112                 pr_err("couldn't register class nvme-fabrics\n");
1113                 ret = PTR_ERR(nvmf_class);
1114                 goto out_free_host;
1115         }
1116
1117         nvmf_device =
1118                 device_create(nvmf_class, NULL, MKDEV(0, 0), NULL, "ctl");
1119         if (IS_ERR(nvmf_device)) {
1120                 pr_err("couldn't create nvme-fabris device!\n");
1121                 ret = PTR_ERR(nvmf_device);
1122                 goto out_destroy_class;
1123         }
1124
1125         ret = misc_register(&nvmf_misc);
1126         if (ret) {
1127                 pr_err("couldn't register misc device: %d\n", ret);
1128                 goto out_destroy_device;
1129         }
1130
1131         return 0;
1132
1133 out_destroy_device:
1134         device_destroy(nvmf_class, MKDEV(0, 0));
1135 out_destroy_class:
1136         class_destroy(nvmf_class);
1137 out_free_host:
1138         nvmf_host_put(nvmf_default_host);
1139         return ret;
1140 }
1141
1142 static void __exit nvmf_exit(void)
1143 {
1144         misc_deregister(&nvmf_misc);
1145         device_destroy(nvmf_class, MKDEV(0, 0));
1146         class_destroy(nvmf_class);
1147         nvmf_host_put(nvmf_default_host);
1148
1149         BUILD_BUG_ON(sizeof(struct nvmf_connect_command) != 64);
1150         BUILD_BUG_ON(sizeof(struct nvmf_property_get_command) != 64);
1151         BUILD_BUG_ON(sizeof(struct nvmf_property_set_command) != 64);
1152         BUILD_BUG_ON(sizeof(struct nvmf_connect_data) != 1024);
1153 }
1154
1155 MODULE_LICENSE("GPL v2");
1156
1157 module_init(nvmf_init);
1158 module_exit(nvmf_exit);