nvme-fabrics: fix and refine state checks in __nvmf_check_ready
[muen/linux.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         strlcpy(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 /*
540  * For something we're not in a state to send to the device the default action
541  * is to busy it and retry it after the controller state is recovered.  However,
542  * anything marked for failfast or nvme multipath is immediately failed.
543  *
544  * Note: commands used to initialize the controller will be marked for failfast.
545  * Note: nvme cli/ioctl commands are marked for failfast.
546  */
547 blk_status_t nvmf_fail_nonready_command(struct request *rq)
548 {
549         if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
550                 return BLK_STS_RESOURCE;
551         nvme_req(rq)->status = NVME_SC_ABORT_REQ;
552         return BLK_STS_IOERR;
553 }
554 EXPORT_SYMBOL_GPL(nvmf_fail_nonready_command);
555
556 bool __nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,
557                 bool queue_live)
558 {
559         struct nvme_request *req = nvme_req(rq);
560
561         /*
562          * If we are in some state of setup or teardown only allow
563          * internally generated commands.
564          */
565         if (!blk_rq_is_passthrough(rq) || (req->flags & NVME_REQ_USERCMD))
566                 return false;
567
568         /*
569          * Only allow commands on a live queue, except for the connect command,
570          * which is require to set the queue live in the appropinquate states.
571          */
572         switch (ctrl->state) {
573         case NVME_CTRL_NEW:
574         case NVME_CTRL_CONNECTING:
575                 if (req->cmd->common.opcode == nvme_fabrics_command &&
576                     req->cmd->fabrics.fctype == nvme_fabrics_type_connect)
577                         return true;
578                 break;
579         default:
580                 break;
581         case NVME_CTRL_DEAD:
582                 return false;
583         }
584
585         return queue_live;
586 }
587 EXPORT_SYMBOL_GPL(__nvmf_check_ready);
588
589 static const match_table_t opt_tokens = {
590         { NVMF_OPT_TRANSPORT,           "transport=%s"          },
591         { NVMF_OPT_TRADDR,              "traddr=%s"             },
592         { NVMF_OPT_TRSVCID,             "trsvcid=%s"            },
593         { NVMF_OPT_NQN,                 "nqn=%s"                },
594         { NVMF_OPT_QUEUE_SIZE,          "queue_size=%d"         },
595         { NVMF_OPT_NR_IO_QUEUES,        "nr_io_queues=%d"       },
596         { NVMF_OPT_RECONNECT_DELAY,     "reconnect_delay=%d"    },
597         { NVMF_OPT_CTRL_LOSS_TMO,       "ctrl_loss_tmo=%d"      },
598         { NVMF_OPT_KATO,                "keep_alive_tmo=%d"     },
599         { NVMF_OPT_HOSTNQN,             "hostnqn=%s"            },
600         { NVMF_OPT_HOST_TRADDR,         "host_traddr=%s"        },
601         { NVMF_OPT_HOST_ID,             "hostid=%s"             },
602         { NVMF_OPT_DUP_CONNECT,         "duplicate_connect"     },
603         { NVMF_OPT_ERR,                 NULL                    }
604 };
605
606 static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
607                 const char *buf)
608 {
609         substring_t args[MAX_OPT_ARGS];
610         char *options, *o, *p;
611         int token, ret = 0;
612         size_t nqnlen  = 0;
613         int ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO;
614         uuid_t hostid;
615
616         /* Set defaults */
617         opts->queue_size = NVMF_DEF_QUEUE_SIZE;
618         opts->nr_io_queues = num_online_cpus();
619         opts->reconnect_delay = NVMF_DEF_RECONNECT_DELAY;
620         opts->kato = NVME_DEFAULT_KATO;
621         opts->duplicate_connect = false;
622
623         options = o = kstrdup(buf, GFP_KERNEL);
624         if (!options)
625                 return -ENOMEM;
626
627         uuid_gen(&hostid);
628
629         while ((p = strsep(&o, ",\n")) != NULL) {
630                 if (!*p)
631                         continue;
632
633                 token = match_token(p, opt_tokens, args);
634                 opts->mask |= token;
635                 switch (token) {
636                 case NVMF_OPT_TRANSPORT:
637                         p = match_strdup(args);
638                         if (!p) {
639                                 ret = -ENOMEM;
640                                 goto out;
641                         }
642                         kfree(opts->transport);
643                         opts->transport = p;
644                         break;
645                 case NVMF_OPT_NQN:
646                         p = match_strdup(args);
647                         if (!p) {
648                                 ret = -ENOMEM;
649                                 goto out;
650                         }
651                         kfree(opts->subsysnqn);
652                         opts->subsysnqn = p;
653                         nqnlen = strlen(opts->subsysnqn);
654                         if (nqnlen >= NVMF_NQN_SIZE) {
655                                 pr_err("%s needs to be < %d bytes\n",
656                                         opts->subsysnqn, NVMF_NQN_SIZE);
657                                 ret = -EINVAL;
658                                 goto out;
659                         }
660                         opts->discovery_nqn =
661                                 !(strcmp(opts->subsysnqn,
662                                          NVME_DISC_SUBSYS_NAME));
663                         break;
664                 case NVMF_OPT_TRADDR:
665                         p = match_strdup(args);
666                         if (!p) {
667                                 ret = -ENOMEM;
668                                 goto out;
669                         }
670                         kfree(opts->traddr);
671                         opts->traddr = p;
672                         break;
673                 case NVMF_OPT_TRSVCID:
674                         p = match_strdup(args);
675                         if (!p) {
676                                 ret = -ENOMEM;
677                                 goto out;
678                         }
679                         kfree(opts->trsvcid);
680                         opts->trsvcid = p;
681                         break;
682                 case NVMF_OPT_QUEUE_SIZE:
683                         if (match_int(args, &token)) {
684                                 ret = -EINVAL;
685                                 goto out;
686                         }
687                         if (token < NVMF_MIN_QUEUE_SIZE ||
688                             token > NVMF_MAX_QUEUE_SIZE) {
689                                 pr_err("Invalid queue_size %d\n", token);
690                                 ret = -EINVAL;
691                                 goto out;
692                         }
693                         opts->queue_size = token;
694                         break;
695                 case NVMF_OPT_NR_IO_QUEUES:
696                         if (match_int(args, &token)) {
697                                 ret = -EINVAL;
698                                 goto out;
699                         }
700                         if (token <= 0) {
701                                 pr_err("Invalid number of IOQs %d\n", token);
702                                 ret = -EINVAL;
703                                 goto out;
704                         }
705                         if (opts->discovery_nqn) {
706                                 pr_debug("Ignoring nr_io_queues value for discovery controller\n");
707                                 break;
708                         }
709
710                         opts->nr_io_queues = min_t(unsigned int,
711                                         num_online_cpus(), token);
712                         break;
713                 case NVMF_OPT_KATO:
714                         if (match_int(args, &token)) {
715                                 ret = -EINVAL;
716                                 goto out;
717                         }
718
719                         if (token < 0) {
720                                 pr_err("Invalid keep_alive_tmo %d\n", token);
721                                 ret = -EINVAL;
722                                 goto out;
723                         } else if (token == 0 && !opts->discovery_nqn) {
724                                 /* Allowed for debug */
725                                 pr_warn("keep_alive_tmo 0 won't execute keep alives!!!\n");
726                         }
727                         opts->kato = token;
728
729                         if (opts->discovery_nqn && opts->kato) {
730                                 pr_err("Discovery controllers cannot accept KATO != 0\n");
731                                 ret = -EINVAL;
732                                 goto out;
733                         }
734
735                         break;
736                 case NVMF_OPT_CTRL_LOSS_TMO:
737                         if (match_int(args, &token)) {
738                                 ret = -EINVAL;
739                                 goto out;
740                         }
741
742                         if (token < 0)
743                                 pr_warn("ctrl_loss_tmo < 0 will reconnect forever\n");
744                         ctrl_loss_tmo = token;
745                         break;
746                 case NVMF_OPT_HOSTNQN:
747                         if (opts->host) {
748                                 pr_err("hostnqn already user-assigned: %s\n",
749                                        opts->host->nqn);
750                                 ret = -EADDRINUSE;
751                                 goto out;
752                         }
753                         p = match_strdup(args);
754                         if (!p) {
755                                 ret = -ENOMEM;
756                                 goto out;
757                         }
758                         nqnlen = strlen(p);
759                         if (nqnlen >= NVMF_NQN_SIZE) {
760                                 pr_err("%s needs to be < %d bytes\n",
761                                         p, NVMF_NQN_SIZE);
762                                 kfree(p);
763                                 ret = -EINVAL;
764                                 goto out;
765                         }
766                         nvmf_host_put(opts->host);
767                         opts->host = nvmf_host_add(p);
768                         kfree(p);
769                         if (!opts->host) {
770                                 ret = -ENOMEM;
771                                 goto out;
772                         }
773                         break;
774                 case NVMF_OPT_RECONNECT_DELAY:
775                         if (match_int(args, &token)) {
776                                 ret = -EINVAL;
777                                 goto out;
778                         }
779                         if (token <= 0) {
780                                 pr_err("Invalid reconnect_delay %d\n", token);
781                                 ret = -EINVAL;
782                                 goto out;
783                         }
784                         opts->reconnect_delay = token;
785                         break;
786                 case NVMF_OPT_HOST_TRADDR:
787                         p = match_strdup(args);
788                         if (!p) {
789                                 ret = -ENOMEM;
790                                 goto out;
791                         }
792                         kfree(opts->host_traddr);
793                         opts->host_traddr = p;
794                         break;
795                 case NVMF_OPT_HOST_ID:
796                         p = match_strdup(args);
797                         if (!p) {
798                                 ret = -ENOMEM;
799                                 goto out;
800                         }
801                         ret = uuid_parse(p, &hostid);
802                         if (ret) {
803                                 pr_err("Invalid hostid %s\n", p);
804                                 ret = -EINVAL;
805                                 kfree(p);
806                                 goto out;
807                         }
808                         kfree(p);
809                         break;
810                 case NVMF_OPT_DUP_CONNECT:
811                         opts->duplicate_connect = true;
812                         break;
813                 default:
814                         pr_warn("unknown parameter or missing value '%s' in ctrl creation request\n",
815                                 p);
816                         ret = -EINVAL;
817                         goto out;
818                 }
819         }
820
821         if (opts->discovery_nqn) {
822                 opts->kato = 0;
823                 opts->nr_io_queues = 0;
824                 opts->duplicate_connect = true;
825         }
826         if (ctrl_loss_tmo < 0)
827                 opts->max_reconnects = -1;
828         else
829                 opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,
830                                                 opts->reconnect_delay);
831
832         if (!opts->host) {
833                 kref_get(&nvmf_default_host->ref);
834                 opts->host = nvmf_default_host;
835         }
836
837         uuid_copy(&opts->host->id, &hostid);
838
839 out:
840         kfree(options);
841         return ret;
842 }
843
844 static int nvmf_check_required_opts(struct nvmf_ctrl_options *opts,
845                 unsigned int required_opts)
846 {
847         if ((opts->mask & required_opts) != required_opts) {
848                 int i;
849
850                 for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {
851                         if ((opt_tokens[i].token & required_opts) &&
852                             !(opt_tokens[i].token & opts->mask)) {
853                                 pr_warn("missing parameter '%s'\n",
854                                         opt_tokens[i].pattern);
855                         }
856                 }
857
858                 return -EINVAL;
859         }
860
861         return 0;
862 }
863
864 static int nvmf_check_allowed_opts(struct nvmf_ctrl_options *opts,
865                 unsigned int allowed_opts)
866 {
867         if (opts->mask & ~allowed_opts) {
868                 int i;
869
870                 for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {
871                         if ((opt_tokens[i].token & opts->mask) &&
872                             (opt_tokens[i].token & ~allowed_opts)) {
873                                 pr_warn("invalid parameter '%s'\n",
874                                         opt_tokens[i].pattern);
875                         }
876                 }
877
878                 return -EINVAL;
879         }
880
881         return 0;
882 }
883
884 void nvmf_free_options(struct nvmf_ctrl_options *opts)
885 {
886         nvmf_host_put(opts->host);
887         kfree(opts->transport);
888         kfree(opts->traddr);
889         kfree(opts->trsvcid);
890         kfree(opts->subsysnqn);
891         kfree(opts->host_traddr);
892         kfree(opts);
893 }
894 EXPORT_SYMBOL_GPL(nvmf_free_options);
895
896 #define NVMF_REQUIRED_OPTS      (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN)
897 #define NVMF_ALLOWED_OPTS       (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \
898                                  NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \
899                                  NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT)
900
901 static struct nvme_ctrl *
902 nvmf_create_ctrl(struct device *dev, const char *buf, size_t count)
903 {
904         struct nvmf_ctrl_options *opts;
905         struct nvmf_transport_ops *ops;
906         struct nvme_ctrl *ctrl;
907         int ret;
908
909         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
910         if (!opts)
911                 return ERR_PTR(-ENOMEM);
912
913         ret = nvmf_parse_options(opts, buf);
914         if (ret)
915                 goto out_free_opts;
916
917
918         request_module("nvme-%s", opts->transport);
919
920         /*
921          * Check the generic options first as we need a valid transport for
922          * the lookup below.  Then clear the generic flags so that transport
923          * drivers don't have to care about them.
924          */
925         ret = nvmf_check_required_opts(opts, NVMF_REQUIRED_OPTS);
926         if (ret)
927                 goto out_free_opts;
928         opts->mask &= ~NVMF_REQUIRED_OPTS;
929
930         down_read(&nvmf_transports_rwsem);
931         ops = nvmf_lookup_transport(opts);
932         if (!ops) {
933                 pr_info("no handler found for transport %s.\n",
934                         opts->transport);
935                 ret = -EINVAL;
936                 goto out_unlock;
937         }
938
939         if (!try_module_get(ops->module)) {
940                 ret = -EBUSY;
941                 goto out_unlock;
942         }
943         up_read(&nvmf_transports_rwsem);
944
945         ret = nvmf_check_required_opts(opts, ops->required_opts);
946         if (ret)
947                 goto out_module_put;
948         ret = nvmf_check_allowed_opts(opts, NVMF_ALLOWED_OPTS |
949                                 ops->allowed_opts | ops->required_opts);
950         if (ret)
951                 goto out_module_put;
952
953         ctrl = ops->create_ctrl(dev, opts);
954         if (IS_ERR(ctrl)) {
955                 ret = PTR_ERR(ctrl);
956                 goto out_module_put;
957         }
958
959         module_put(ops->module);
960         return ctrl;
961
962 out_module_put:
963         module_put(ops->module);
964         goto out_free_opts;
965 out_unlock:
966         up_read(&nvmf_transports_rwsem);
967 out_free_opts:
968         nvmf_free_options(opts);
969         return ERR_PTR(ret);
970 }
971
972 static struct class *nvmf_class;
973 static struct device *nvmf_device;
974 static DEFINE_MUTEX(nvmf_dev_mutex);
975
976 static ssize_t nvmf_dev_write(struct file *file, const char __user *ubuf,
977                 size_t count, loff_t *pos)
978 {
979         struct seq_file *seq_file = file->private_data;
980         struct nvme_ctrl *ctrl;
981         const char *buf;
982         int ret = 0;
983
984         if (count > PAGE_SIZE)
985                 return -ENOMEM;
986
987         buf = memdup_user_nul(ubuf, count);
988         if (IS_ERR(buf))
989                 return PTR_ERR(buf);
990
991         mutex_lock(&nvmf_dev_mutex);
992         if (seq_file->private) {
993                 ret = -EINVAL;
994                 goto out_unlock;
995         }
996
997         ctrl = nvmf_create_ctrl(nvmf_device, buf, count);
998         if (IS_ERR(ctrl)) {
999                 ret = PTR_ERR(ctrl);
1000                 goto out_unlock;
1001         }
1002
1003         seq_file->private = ctrl;
1004
1005 out_unlock:
1006         mutex_unlock(&nvmf_dev_mutex);
1007         kfree(buf);
1008         return ret ? ret : count;
1009 }
1010
1011 static int nvmf_dev_show(struct seq_file *seq_file, void *private)
1012 {
1013         struct nvme_ctrl *ctrl;
1014         int ret = 0;
1015
1016         mutex_lock(&nvmf_dev_mutex);
1017         ctrl = seq_file->private;
1018         if (!ctrl) {
1019                 ret = -EINVAL;
1020                 goto out_unlock;
1021         }
1022
1023         seq_printf(seq_file, "instance=%d,cntlid=%d\n",
1024                         ctrl->instance, ctrl->cntlid);
1025
1026 out_unlock:
1027         mutex_unlock(&nvmf_dev_mutex);
1028         return ret;
1029 }
1030
1031 static int nvmf_dev_open(struct inode *inode, struct file *file)
1032 {
1033         /*
1034          * The miscdevice code initializes file->private_data, but doesn't
1035          * make use of it later.
1036          */
1037         file->private_data = NULL;
1038         return single_open(file, nvmf_dev_show, NULL);
1039 }
1040
1041 static int nvmf_dev_release(struct inode *inode, struct file *file)
1042 {
1043         struct seq_file *seq_file = file->private_data;
1044         struct nvme_ctrl *ctrl = seq_file->private;
1045
1046         if (ctrl)
1047                 nvme_put_ctrl(ctrl);
1048         return single_release(inode, file);
1049 }
1050
1051 static const struct file_operations nvmf_dev_fops = {
1052         .owner          = THIS_MODULE,
1053         .write          = nvmf_dev_write,
1054         .read           = seq_read,
1055         .open           = nvmf_dev_open,
1056         .release        = nvmf_dev_release,
1057 };
1058
1059 static struct miscdevice nvmf_misc = {
1060         .minor          = MISC_DYNAMIC_MINOR,
1061         .name           = "nvme-fabrics",
1062         .fops           = &nvmf_dev_fops,
1063 };
1064
1065 static int __init nvmf_init(void)
1066 {
1067         int ret;
1068
1069         nvmf_default_host = nvmf_host_default();
1070         if (!nvmf_default_host)
1071                 return -ENOMEM;
1072
1073         nvmf_class = class_create(THIS_MODULE, "nvme-fabrics");
1074         if (IS_ERR(nvmf_class)) {
1075                 pr_err("couldn't register class nvme-fabrics\n");
1076                 ret = PTR_ERR(nvmf_class);
1077                 goto out_free_host;
1078         }
1079
1080         nvmf_device =
1081                 device_create(nvmf_class, NULL, MKDEV(0, 0), NULL, "ctl");
1082         if (IS_ERR(nvmf_device)) {
1083                 pr_err("couldn't create nvme-fabris device!\n");
1084                 ret = PTR_ERR(nvmf_device);
1085                 goto out_destroy_class;
1086         }
1087
1088         ret = misc_register(&nvmf_misc);
1089         if (ret) {
1090                 pr_err("couldn't register misc device: %d\n", ret);
1091                 goto out_destroy_device;
1092         }
1093
1094         return 0;
1095
1096 out_destroy_device:
1097         device_destroy(nvmf_class, MKDEV(0, 0));
1098 out_destroy_class:
1099         class_destroy(nvmf_class);
1100 out_free_host:
1101         nvmf_host_put(nvmf_default_host);
1102         return ret;
1103 }
1104
1105 static void __exit nvmf_exit(void)
1106 {
1107         misc_deregister(&nvmf_misc);
1108         device_destroy(nvmf_class, MKDEV(0, 0));
1109         class_destroy(nvmf_class);
1110         nvmf_host_put(nvmf_default_host);
1111
1112         BUILD_BUG_ON(sizeof(struct nvmf_connect_command) != 64);
1113         BUILD_BUG_ON(sizeof(struct nvmf_property_get_command) != 64);
1114         BUILD_BUG_ON(sizeof(struct nvmf_property_set_command) != 64);
1115         BUILD_BUG_ON(sizeof(struct nvmf_connect_data) != 1024);
1116 }
1117
1118 MODULE_LICENSE("GPL v2");
1119
1120 module_init(nvmf_init);
1121 module_exit(nvmf_exit);