drivers/nvme/target/fabrics-cmd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NVMe Fabrics command implementation.
   4  * Copyright (c) 2015-2016 HGST, a Western Digital Company.
   5  */
   6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7 #include <linux/blkdev.h>
   8 #include "nvmet.h"
   9
  10 static void nvmet_execute_prop_set(struct nvmet_req *req)
  11 {
  12         u64 val = le64_to_cpu(req->cmd->prop_set.value);
  13         u16 status = 0;
  14
  15         if (!nvmet_check_transfer_len(req, 0))
  16                 return;
  17
  18         if (req->cmd->prop_set.attrib & 1) {
  19                 req->error_loc =
  20                         offsetof(struct nvmf_property_set_command, attrib);
  21                 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
  22                 goto out;
  23         }
  24
  25         switch (le32_to_cpu(req->cmd->prop_set.offset)) {
  26         case NVME_REG_CC:
  27                 nvmet_update_cc(req->sq->ctrl, val);
  28                 break;
  29         default:
  30                 req->error_loc =
  31                         offsetof(struct nvmf_property_set_command, offset);
  32                 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
  33         }
  34 out:
  35         nvmet_req_complete(req, status);
  36 }
  37
  38 static void nvmet_execute_prop_get(struct nvmet_req *req)
  39 {
  40         struct nvmet_ctrl *ctrl = req->sq->ctrl;
  41         u16 status = 0;
  42         u64 val = 0;
  43
  44         if (!nvmet_check_transfer_len(req, 0))
  45                 return;
  46
  47         if (req->cmd->prop_get.attrib & 1) {
  48                 switch (le32_to_cpu(req->cmd->prop_get.offset)) {
  49                 case NVME_REG_CAP:
  50                         val = ctrl->cap;
  51                         break;
  52                 default:
  53                         status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
  54                         break;
  55                 }
  56         } else {
  57                 switch (le32_to_cpu(req->cmd->prop_get.offset)) {
  58                 case NVME_REG_VS:
  59                         val = ctrl->subsys->ver;
  60                         break;
  61                 case NVME_REG_CC:
  62                         val = ctrl->cc;
  63                         break;
  64                 case NVME_REG_CSTS:
  65                         val = ctrl->csts;
  66                         break;
  67                 default:
  68                         status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
  69                         break;
  70                 }
  71         }
  72
  73         if (status && req->cmd->prop_get.attrib & 1) {
  74                 req->error_loc =
  75                         offsetof(struct nvmf_property_get_command, offset);
  76         } else {
  77                 req->error_loc =
  78                         offsetof(struct nvmf_property_get_command, attrib);
  79         }
  80
  81         req->cqe->result.u64 = cpu_to_le64(val);
  82         nvmet_req_complete(req, status);
  83 }
  84
  85 u16 nvmet_parse_fabrics_admin_cmd(struct nvmet_req *req)
  86 {
  87         struct nvme_command *cmd = req->cmd;
  88
  89         switch (cmd->fabrics.fctype) {
  90         case nvme_fabrics_type_property_set:
  91                 req->execute = nvmet_execute_prop_set;
  92                 break;
  93         case nvme_fabrics_type_property_get:
  94                 req->execute = nvmet_execute_prop_get;
  95                 break;
  96 #ifdef CONFIG_NVME_TARGET_AUTH
  97         case nvme_fabrics_type_auth_send:
  98                 req->execute = nvmet_execute_auth_send;
  99                 break;
 100         case nvme_fabrics_type_auth_receive:
 101                 req->execute = nvmet_execute_auth_receive;
 102                 break;
 103 #endif
 104         default:
 105                 pr_debug("received unknown capsule type 0x%x\n",
 106                         cmd->fabrics.fctype);
 107                 req->error_loc = offsetof(struct nvmf_common_command, fctype);
 108                 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
 109         }
 110
 111         return 0;
 112 }
 113
 114 u16 nvmet_parse_fabrics_io_cmd(struct nvmet_req *req)
 115 {
 116         struct nvme_command *cmd = req->cmd;
 117
 118         switch (cmd->fabrics.fctype) {
 119 #ifdef CONFIG_NVME_TARGET_AUTH
 120         case nvme_fabrics_type_auth_send:
 121                 req->execute = nvmet_execute_auth_send;
 122                 break;
 123         case nvme_fabrics_type_auth_receive:
 124                 req->execute = nvmet_execute_auth_receive;
 125                 break;
 126 #endif
 127         default:
 128                 pr_debug("received unknown capsule type 0x%x\n",
 129                         cmd->fabrics.fctype);
 130                 req->error_loc = offsetof(struct nvmf_common_command, fctype);
 131                 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static u16 nvmet_install_queue(struct nvmet_ctrl *ctrl, struct nvmet_req *req)
 138 {
 139         struct nvmf_connect_command *c = &req->cmd->connect;
 140         u16 qid = le16_to_cpu(c->qid);
 141         u16 sqsize = le16_to_cpu(c->sqsize);
 142         struct nvmet_ctrl *old;
 143         u16 mqes = NVME_CAP_MQES(ctrl->cap);
 144         u16 ret;
 145
 146         if (!sqsize) {
 147                 pr_warn("queue size zero!\n");
 148                 req->error_loc = offsetof(struct nvmf_connect_command, sqsize);
 149                 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize);
 150                 ret = NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
 151                 goto err;
 152         }
 153
 154         if (ctrl->sqs[qid] != NULL) {
 155                 pr_warn("qid %u has already been created\n", qid);
 156                 req->error_loc = offsetof(struct nvmf_connect_command, qid);
 157                 return NVME_SC_CMD_SEQ_ERROR | NVME_SC_DNR;
 158         }
 159
 160         if (sqsize > mqes) {
 161                 pr_warn("sqsize %u is larger than MQES supported %u cntlid %d\n",
 162                                 sqsize, mqes, ctrl->cntlid);
 163                 req->error_loc = offsetof(struct nvmf_connect_command, sqsize);
 164                 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize);
 165                 return NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
 166         }
 167
 168         old = cmpxchg(&req->sq->ctrl, NULL, ctrl);
 169         if (old) {
 170                 pr_warn("queue already connected!\n");
 171                 req->error_loc = offsetof(struct nvmf_connect_command, opcode);
 172                 return NVME_SC_CONNECT_CTRL_BUSY | NVME_SC_DNR;
 173         }
 174
 175         /* note: convert queue size from 0's-based value to 1's-based value */
 176         nvmet_cq_setup(ctrl, req->cq, qid, sqsize + 1);
 177         nvmet_sq_setup(ctrl, req->sq, qid, sqsize + 1);
 178
 179         if (c->cattr & NVME_CONNECT_DISABLE_SQFLOW) {
 180                 req->sq->sqhd_disabled = true;
 181                 req->cqe->sq_head = cpu_to_le16(0xffff);
 182         }
 183
 184         if (ctrl->ops->install_queue) {
 185                 ret = ctrl->ops->install_queue(req->sq);
 186                 if (ret) {
 187                         pr_err("failed to install queue %d cntlid %d ret %x\n",
 188                                 qid, ctrl->cntlid, ret);
 189                         ctrl->sqs[qid] = NULL;
 190                         goto err;
 191                 }
 192         }
 193
 194         return 0;
 195
 196 err:
 197         req->sq->ctrl = NULL;
 198         return ret;
 199 }
 200
 201 static void nvmet_execute_admin_connect(struct nvmet_req *req)
 202 {
 203         struct nvmf_connect_command *c = &req->cmd->connect;
 204         struct nvmf_connect_data *d;
 205         struct nvmet_ctrl *ctrl = NULL;
 206         u16 status = 0;
 207         int ret;
 208
 209         if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data)))
 210                 return;
 211
 212         d = kmalloc(sizeof(*d), GFP_KERNEL);
 213         if (!d) {
 214                 status = NVME_SC_INTERNAL;
 215                 goto complete;
 216         }
 217
 218         status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
 219         if (status)
 220                 goto out;
 221
 222         /* zero out initial completion result, assign values as needed */
 223         req->cqe->result.u32 = 0;
 224
 225         if (c->recfmt != 0) {
 226                 pr_warn("invalid connect version (%d).\n",
 227                         le16_to_cpu(c->recfmt));
 228                 req->error_loc = offsetof(struct nvmf_connect_command, recfmt);
 229                 status = NVME_SC_CONNECT_FORMAT | NVME_SC_DNR;
 230                 goto out;
 231         }
 232
 233         if (unlikely(d->cntlid != cpu_to_le16(0xffff))) {
 234                 pr_warn("connect attempt for invalid controller ID %#x\n",
 235                         d->cntlid);
 236                 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
 237                 req->cqe->result.u32 = IPO_IATTR_CONNECT_DATA(cntlid);
 238                 goto out;
 239         }
 240
 241         status = nvmet_alloc_ctrl(d->subsysnqn, d->hostnqn, req,
 242                                   le32_to_cpu(c->kato), &ctrl);
 243         if (status)
 244                 goto out;
 245
 246         ctrl->pi_support = ctrl->port->pi_enable && ctrl->subsys->pi_support;
 247
 248         uuid_copy(&ctrl->hostid, &d->hostid);
 249
 250         ret = nvmet_setup_auth(ctrl);
 251         if (ret < 0) {
 252                 pr_err("Failed to setup authentication, error %d\n", ret);
 253                 nvmet_ctrl_put(ctrl);
 254                 if (ret == -EPERM)
 255                         status = (NVME_SC_CONNECT_INVALID_HOST | NVME_SC_DNR);
 256                 else
 257                         status = NVME_SC_INTERNAL;
 258                 goto out;
 259         }
 260
 261         status = nvmet_install_queue(ctrl, req);
 262         if (status) {
 263                 nvmet_ctrl_put(ctrl);
 264                 goto out;
 265         }
 266
 267         pr_info("creating %s controller %d for subsystem %s for NQN %s%s%s.\n",
 268                 nvmet_is_disc_subsys(ctrl->subsys) ? "discovery" : "nvm",
 269                 ctrl->cntlid, ctrl->subsys->subsysnqn, ctrl->hostnqn,
 270                 ctrl->pi_support ? " T10-PI is enabled" : "",
 271                 nvmet_has_auth(ctrl) ? " with DH-HMAC-CHAP" : "");
 272         req->cqe->result.u16 = cpu_to_le16(ctrl->cntlid);
 273
 274         if (nvmet_has_auth(ctrl))
 275                 nvmet_init_auth(ctrl, req);
 276 out:
 277         kfree(d);
 278 complete:
 279         nvmet_req_complete(req, status);
 280 }
 281
 282 static void nvmet_execute_io_connect(struct nvmet_req *req)
 283 {
 284         struct nvmf_connect_command *c = &req->cmd->connect;
 285         struct nvmf_connect_data *d;
 286         struct nvmet_ctrl *ctrl;
 287         u16 qid = le16_to_cpu(c->qid);
 288         u16 status = 0;
 289
 290         if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data)))
 291                 return;
 292
 293         d = kmalloc(sizeof(*d), GFP_KERNEL);
 294         if (!d) {
 295                 status = NVME_SC_INTERNAL;
 296                 goto complete;
 297         }
 298
 299         status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
 300         if (status)
 301                 goto out;
 302
 303         /* zero out initial completion result, assign values as needed */
 304         req->cqe->result.u32 = 0;
 305
 306         if (c->recfmt != 0) {
 307                 pr_warn("invalid connect version (%d).\n",
 308                         le16_to_cpu(c->recfmt));
 309                 status = NVME_SC_CONNECT_FORMAT | NVME_SC_DNR;
 310                 goto out;
 311         }
 312
 313         ctrl = nvmet_ctrl_find_get(d->subsysnqn, d->hostnqn,
 314                                    le16_to_cpu(d->cntlid), req);
 315         if (!ctrl) {
 316                 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
 317                 goto out;
 318         }
 319
 320         if (unlikely(qid > ctrl->subsys->max_qid)) {
 321                 pr_warn("invalid queue id (%d)\n", qid);
 322                 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_SC_DNR;
 323                 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(qid);
 324                 goto out_ctrl_put;
 325         }
 326
 327         status = nvmet_install_queue(ctrl, req);
 328         if (status)
 329                 goto out_ctrl_put;
 330
 331         /* pass back cntlid for successful completion */
 332         req->cqe->result.u16 = cpu_to_le16(ctrl->cntlid);
 333
 334         pr_debug("adding queue %d to ctrl %d.\n", qid, ctrl->cntlid);
 335         req->cqe->result.u16 = cpu_to_le16(ctrl->cntlid);
 336         if (nvmet_has_auth(ctrl))
 337                 nvmet_init_auth(ctrl, req);
 338
 339 out:
 340         kfree(d);
 341 complete:
 342         nvmet_req_complete(req, status);
 343         return;
 344
 345 out_ctrl_put:
 346         nvmet_ctrl_put(ctrl);
 347         goto out;
 348 }
 349
 350 u16 nvmet_parse_connect_cmd(struct nvmet_req *req)
 351 {
 352         struct nvme_command *cmd = req->cmd;
 353
 354         if (!nvme_is_fabrics(cmd)) {
 355                 pr_debug("invalid command 0x%x on unconnected queue.\n",
 356                         cmd->fabrics.opcode);
 357                 req->error_loc = offsetof(struct nvme_common_command, opcode);
 358                 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
 359         }
 360         if (cmd->fabrics.fctype != nvme_fabrics_type_connect) {
 361                 pr_debug("invalid capsule type 0x%x on unconnected queue.\n",
 362                         cmd->fabrics.fctype);
 363                 req->error_loc = offsetof(struct nvmf_common_command, fctype);
 364                 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
 365         }
 366
 367         if (cmd->connect.qid == 0)
 368                 req->execute = nvmet_execute_admin_connect;
 369         else
 370                 req->execute = nvmet_execute_io_connect;
 371         return 0;
 372 }