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_STATUS_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_STATUS_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_STATUS_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_STATUS_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_STATUS_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_STATUS_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_STATUS_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_STATUS_DNR; 158 } 159 160 /* for fabrics, this value applies to only the I/O Submission Queues */ 161 if (qid && sqsize > mqes) { 162 pr_warn("sqsize %u is larger than MQES supported %u cntlid %d\n", 163 sqsize, mqes, ctrl->cntlid); 164 req->error_loc = offsetof(struct nvmf_connect_command, sqsize); 165 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize); 166 return NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 167 } 168 169 old = cmpxchg(&req->sq->ctrl, NULL, ctrl); 170 if (old) { 171 pr_warn("queue already connected!\n"); 172 req->error_loc = offsetof(struct nvmf_connect_command, opcode); 173 return NVME_SC_CONNECT_CTRL_BUSY | NVME_STATUS_DNR; 174 } 175 176 /* note: convert queue size from 0's-based value to 1's-based value */ 177 nvmet_cq_setup(ctrl, req->cq, qid, sqsize + 1); 178 nvmet_sq_setup(ctrl, req->sq, qid, sqsize + 1); 179 180 if (c->cattr & NVME_CONNECT_DISABLE_SQFLOW) { 181 req->sq->sqhd_disabled = true; 182 req->cqe->sq_head = cpu_to_le16(0xffff); 183 } 184 185 if (ctrl->ops->install_queue) { 186 ret = ctrl->ops->install_queue(req->sq); 187 if (ret) { 188 pr_err("failed to install queue %d cntlid %d ret %x\n", 189 qid, ctrl->cntlid, ret); 190 ctrl->sqs[qid] = NULL; 191 goto err; 192 } 193 } 194 195 return 0; 196 197 err: 198 req->sq->ctrl = NULL; 199 return ret; 200 } 201 202 static u32 nvmet_connect_result(struct nvmet_ctrl *ctrl) 203 { 204 return (u32)ctrl->cntlid | 205 (nvmet_has_auth(ctrl) ? NVME_CONNECT_AUTHREQ_ATR : 0); 206 } 207 208 static void nvmet_execute_admin_connect(struct nvmet_req *req) 209 { 210 struct nvmf_connect_command *c = &req->cmd->connect; 211 struct nvmf_connect_data *d; 212 struct nvmet_ctrl *ctrl = NULL; 213 u16 status; 214 u8 dhchap_status; 215 216 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 217 return; 218 219 d = kmalloc(sizeof(*d), GFP_KERNEL); 220 if (!d) { 221 status = NVME_SC_INTERNAL; 222 goto complete; 223 } 224 225 status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 226 if (status) 227 goto out; 228 229 if (c->recfmt != 0) { 230 pr_warn("invalid connect version (%d).\n", 231 le16_to_cpu(c->recfmt)); 232 req->error_loc = offsetof(struct nvmf_connect_command, recfmt); 233 status = NVME_SC_CONNECT_FORMAT | NVME_STATUS_DNR; 234 goto out; 235 } 236 237 if (unlikely(d->cntlid != cpu_to_le16(0xffff))) { 238 pr_warn("connect attempt for invalid controller ID %#x\n", 239 d->cntlid); 240 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 241 req->cqe->result.u32 = IPO_IATTR_CONNECT_DATA(cntlid); 242 goto out; 243 } 244 245 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 246 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 247 status = nvmet_alloc_ctrl(d->subsysnqn, d->hostnqn, req, 248 le32_to_cpu(c->kato), &ctrl); 249 if (status) 250 goto out; 251 252 uuid_copy(&ctrl->hostid, &d->hostid); 253 254 dhchap_status = nvmet_setup_auth(ctrl); 255 if (dhchap_status) { 256 pr_err("Failed to setup authentication, dhchap status %u\n", 257 dhchap_status); 258 nvmet_ctrl_put(ctrl); 259 if (dhchap_status == NVME_AUTH_DHCHAP_FAILURE_FAILED) 260 status = (NVME_SC_CONNECT_INVALID_HOST | NVME_STATUS_DNR); 261 else 262 status = NVME_SC_INTERNAL; 263 goto out; 264 } 265 266 status = nvmet_install_queue(ctrl, req); 267 if (status) { 268 nvmet_ctrl_put(ctrl); 269 goto out; 270 } 271 272 pr_info("creating %s controller %d for subsystem %s for NQN %s%s%s.\n", 273 nvmet_is_disc_subsys(ctrl->subsys) ? "discovery" : "nvm", 274 ctrl->cntlid, ctrl->subsys->subsysnqn, ctrl->hostnqn, 275 ctrl->pi_support ? " T10-PI is enabled" : "", 276 nvmet_has_auth(ctrl) ? " with DH-HMAC-CHAP" : ""); 277 req->cqe->result.u32 = cpu_to_le32(nvmet_connect_result(ctrl)); 278 out: 279 kfree(d); 280 complete: 281 nvmet_req_complete(req, status); 282 } 283 284 static void nvmet_execute_io_connect(struct nvmet_req *req) 285 { 286 struct nvmf_connect_command *c = &req->cmd->connect; 287 struct nvmf_connect_data *d; 288 struct nvmet_ctrl *ctrl; 289 u16 qid = le16_to_cpu(c->qid); 290 u16 status; 291 292 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 293 return; 294 295 d = kmalloc(sizeof(*d), GFP_KERNEL); 296 if (!d) { 297 status = NVME_SC_INTERNAL; 298 goto complete; 299 } 300 301 status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 302 if (status) 303 goto out; 304 305 if (c->recfmt != 0) { 306 pr_warn("invalid connect version (%d).\n", 307 le16_to_cpu(c->recfmt)); 308 status = NVME_SC_CONNECT_FORMAT | NVME_STATUS_DNR; 309 goto out; 310 } 311 312 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 313 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 314 ctrl = nvmet_ctrl_find_get(d->subsysnqn, d->hostnqn, 315 le16_to_cpu(d->cntlid), req); 316 if (!ctrl) { 317 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 318 goto out; 319 } 320 321 if (unlikely(qid > ctrl->subsys->max_qid)) { 322 pr_warn("invalid queue id (%d)\n", qid); 323 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 324 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(qid); 325 goto out_ctrl_put; 326 } 327 328 status = nvmet_install_queue(ctrl, req); 329 if (status) 330 goto out_ctrl_put; 331 332 pr_debug("adding queue %d to ctrl %d.\n", qid, ctrl->cntlid); 333 req->cqe->result.u32 = cpu_to_le32(nvmet_connect_result(ctrl)); 334 out: 335 kfree(d); 336 complete: 337 nvmet_req_complete(req, status); 338 return; 339 340 out_ctrl_put: 341 nvmet_ctrl_put(ctrl); 342 goto out; 343 } 344 345 u16 nvmet_parse_connect_cmd(struct nvmet_req *req) 346 { 347 struct nvme_command *cmd = req->cmd; 348 349 if (!nvme_is_fabrics(cmd)) { 350 pr_debug("invalid command 0x%x on unconnected queue.\n", 351 cmd->fabrics.opcode); 352 req->error_loc = offsetof(struct nvme_common_command, opcode); 353 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 354 } 355 if (cmd->fabrics.fctype != nvme_fabrics_type_connect) { 356 pr_debug("invalid capsule type 0x%x on unconnected queue.\n", 357 cmd->fabrics.fctype); 358 req->error_loc = offsetof(struct nvmf_common_command, fctype); 359 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 360 } 361 362 if (cmd->connect.qid == 0) 363 req->execute = nvmet_execute_admin_connect; 364 else 365 req->execute = nvmet_execute_io_connect; 366 return 0; 367 } 368