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 case NVME_REG_CRTO: 68 val = NVME_CAP_TIMEOUT(ctrl->csts); 69 break; 70 default: 71 status = NVME_SC_INVALID_FIELD | NVME_STATUS_DNR; 72 break; 73 } 74 } 75 76 if (status && req->cmd->prop_get.attrib & 1) { 77 req->error_loc = 78 offsetof(struct nvmf_property_get_command, offset); 79 } else { 80 req->error_loc = 81 offsetof(struct nvmf_property_get_command, attrib); 82 } 83 84 req->cqe->result.u64 = cpu_to_le64(val); 85 nvmet_req_complete(req, status); 86 } 87 88 u16 nvmet_parse_fabrics_admin_cmd(struct nvmet_req *req) 89 { 90 struct nvme_command *cmd = req->cmd; 91 92 switch (cmd->fabrics.fctype) { 93 case nvme_fabrics_type_property_set: 94 req->execute = nvmet_execute_prop_set; 95 break; 96 case nvme_fabrics_type_property_get: 97 req->execute = nvmet_execute_prop_get; 98 break; 99 #ifdef CONFIG_NVME_TARGET_AUTH 100 case nvme_fabrics_type_auth_send: 101 req->execute = nvmet_execute_auth_send; 102 break; 103 case nvme_fabrics_type_auth_receive: 104 req->execute = nvmet_execute_auth_receive; 105 break; 106 #endif 107 default: 108 pr_debug("received unknown capsule type 0x%x\n", 109 cmd->fabrics.fctype); 110 req->error_loc = offsetof(struct nvmf_common_command, fctype); 111 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 112 } 113 114 return 0; 115 } 116 117 u16 nvmet_parse_fabrics_io_cmd(struct nvmet_req *req) 118 { 119 struct nvme_command *cmd = req->cmd; 120 121 switch (cmd->fabrics.fctype) { 122 #ifdef CONFIG_NVME_TARGET_AUTH 123 case nvme_fabrics_type_auth_send: 124 req->execute = nvmet_execute_auth_send; 125 break; 126 case nvme_fabrics_type_auth_receive: 127 req->execute = nvmet_execute_auth_receive; 128 break; 129 #endif 130 default: 131 pr_debug("received unknown capsule type 0x%x\n", 132 cmd->fabrics.fctype); 133 req->error_loc = offsetof(struct nvmf_common_command, fctype); 134 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 135 } 136 137 return 0; 138 } 139 140 static u16 nvmet_install_queue(struct nvmet_ctrl *ctrl, struct nvmet_req *req) 141 { 142 struct nvmf_connect_command *c = &req->cmd->connect; 143 u16 qid = le16_to_cpu(c->qid); 144 u16 sqsize = le16_to_cpu(c->sqsize); 145 struct nvmet_ctrl *old; 146 u16 mqes = NVME_CAP_MQES(ctrl->cap); 147 u16 ret; 148 149 if (!sqsize) { 150 pr_warn("queue size zero!\n"); 151 req->error_loc = offsetof(struct nvmf_connect_command, sqsize); 152 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize); 153 ret = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 154 goto err; 155 } 156 157 if (ctrl->sqs[qid] != NULL) { 158 pr_warn("qid %u has already been created\n", qid); 159 req->error_loc = offsetof(struct nvmf_connect_command, qid); 160 return NVME_SC_CMD_SEQ_ERROR | NVME_STATUS_DNR; 161 } 162 163 /* for fabrics, this value applies to only the I/O Submission Queues */ 164 if (qid && sqsize > mqes) { 165 pr_warn("sqsize %u is larger than MQES supported %u cntlid %d\n", 166 sqsize, mqes, ctrl->cntlid); 167 req->error_loc = offsetof(struct nvmf_connect_command, sqsize); 168 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize); 169 return NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 170 } 171 172 old = cmpxchg(&req->sq->ctrl, NULL, ctrl); 173 if (old) { 174 pr_warn("queue already connected!\n"); 175 req->error_loc = offsetof(struct nvmf_connect_command, opcode); 176 return NVME_SC_CONNECT_CTRL_BUSY | NVME_STATUS_DNR; 177 } 178 179 /* note: convert queue size from 0's-based value to 1's-based value */ 180 nvmet_cq_setup(ctrl, req->cq, qid, sqsize + 1); 181 nvmet_sq_setup(ctrl, req->sq, qid, sqsize + 1); 182 183 if (c->cattr & NVME_CONNECT_DISABLE_SQFLOW) { 184 req->sq->sqhd_disabled = true; 185 req->cqe->sq_head = cpu_to_le16(0xffff); 186 } 187 188 if (ctrl->ops->install_queue) { 189 ret = ctrl->ops->install_queue(req->sq); 190 if (ret) { 191 pr_err("failed to install queue %d cntlid %d ret %x\n", 192 qid, ctrl->cntlid, ret); 193 ctrl->sqs[qid] = NULL; 194 goto err; 195 } 196 } 197 198 return 0; 199 200 err: 201 req->sq->ctrl = NULL; 202 return ret; 203 } 204 205 static u32 nvmet_connect_result(struct nvmet_ctrl *ctrl) 206 { 207 return (u32)ctrl->cntlid | 208 (nvmet_has_auth(ctrl) ? NVME_CONNECT_AUTHREQ_ATR : 0); 209 } 210 211 static void nvmet_execute_admin_connect(struct nvmet_req *req) 212 { 213 struct nvmf_connect_command *c = &req->cmd->connect; 214 struct nvmf_connect_data *d; 215 struct nvmet_ctrl *ctrl = NULL; 216 u16 status; 217 u8 dhchap_status; 218 219 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 220 return; 221 222 d = kmalloc(sizeof(*d), GFP_KERNEL); 223 if (!d) { 224 status = NVME_SC_INTERNAL; 225 goto complete; 226 } 227 228 status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 229 if (status) 230 goto out; 231 232 if (c->recfmt != 0) { 233 pr_warn("invalid connect version (%d).\n", 234 le16_to_cpu(c->recfmt)); 235 req->error_loc = offsetof(struct nvmf_connect_command, recfmt); 236 status = NVME_SC_CONNECT_FORMAT | NVME_STATUS_DNR; 237 goto out; 238 } 239 240 if (unlikely(d->cntlid != cpu_to_le16(0xffff))) { 241 pr_warn("connect attempt for invalid controller ID %#x\n", 242 d->cntlid); 243 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 244 req->cqe->result.u32 = IPO_IATTR_CONNECT_DATA(cntlid); 245 goto out; 246 } 247 248 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 249 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 250 status = nvmet_alloc_ctrl(d->subsysnqn, d->hostnqn, req, 251 le32_to_cpu(c->kato), &ctrl, &d->hostid); 252 if (status) 253 goto out; 254 255 dhchap_status = nvmet_setup_auth(ctrl); 256 if (dhchap_status) { 257 pr_err("Failed to setup authentication, dhchap status %u\n", 258 dhchap_status); 259 nvmet_ctrl_put(ctrl); 260 if (dhchap_status == NVME_AUTH_DHCHAP_FAILURE_FAILED) 261 status = (NVME_SC_CONNECT_INVALID_HOST | NVME_STATUS_DNR); 262 else 263 status = NVME_SC_INTERNAL; 264 goto out; 265 } 266 267 status = nvmet_install_queue(ctrl, req); 268 if (status) { 269 nvmet_ctrl_put(ctrl); 270 goto out; 271 } 272 273 pr_info("creating %s controller %d for subsystem %s for NQN %s%s%s.\n", 274 nvmet_is_disc_subsys(ctrl->subsys) ? "discovery" : "nvm", 275 ctrl->cntlid, ctrl->subsys->subsysnqn, ctrl->hostnqn, 276 ctrl->pi_support ? " T10-PI is enabled" : "", 277 nvmet_has_auth(ctrl) ? " with DH-HMAC-CHAP" : ""); 278 req->cqe->result.u32 = cpu_to_le32(nvmet_connect_result(ctrl)); 279 out: 280 kfree(d); 281 complete: 282 nvmet_req_complete(req, status); 283 } 284 285 static void nvmet_execute_io_connect(struct nvmet_req *req) 286 { 287 struct nvmf_connect_command *c = &req->cmd->connect; 288 struct nvmf_connect_data *d; 289 struct nvmet_ctrl *ctrl; 290 u16 qid = le16_to_cpu(c->qid); 291 u16 status; 292 293 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 294 return; 295 296 d = kmalloc(sizeof(*d), GFP_KERNEL); 297 if (!d) { 298 status = NVME_SC_INTERNAL; 299 goto complete; 300 } 301 302 status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 303 if (status) 304 goto out; 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_STATUS_DNR; 310 goto out; 311 } 312 313 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 314 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 315 ctrl = nvmet_ctrl_find_get(d->subsysnqn, d->hostnqn, 316 le16_to_cpu(d->cntlid), req); 317 if (!ctrl) { 318 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 319 goto out; 320 } 321 322 if (unlikely(qid > ctrl->subsys->max_qid)) { 323 pr_warn("invalid queue id (%d)\n", qid); 324 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 325 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(qid); 326 goto out_ctrl_put; 327 } 328 329 status = nvmet_install_queue(ctrl, req); 330 if (status) 331 goto out_ctrl_put; 332 333 pr_debug("adding queue %d to ctrl %d.\n", qid, ctrl->cntlid); 334 req->cqe->result.u32 = cpu_to_le32(nvmet_connect_result(ctrl)); 335 out: 336 kfree(d); 337 complete: 338 nvmet_req_complete(req, status); 339 return; 340 341 out_ctrl_put: 342 nvmet_ctrl_put(ctrl); 343 goto out; 344 } 345 346 u16 nvmet_parse_connect_cmd(struct nvmet_req *req) 347 { 348 struct nvme_command *cmd = req->cmd; 349 350 if (!nvme_is_fabrics(cmd)) { 351 pr_debug("invalid command 0x%x on unconnected queue.\n", 352 cmd->fabrics.opcode); 353 req->error_loc = offsetof(struct nvme_common_command, opcode); 354 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 355 } 356 if (cmd->fabrics.fctype != nvme_fabrics_type_connect) { 357 pr_debug("invalid capsule type 0x%x on unconnected queue.\n", 358 cmd->fabrics.fctype); 359 req->error_loc = offsetof(struct nvmf_common_command, fctype); 360 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 361 } 362 363 if (cmd->connect.qid == 0) 364 req->execute = nvmet_execute_admin_connect; 365 else 366 req->execute = nvmet_execute_io_connect; 367 return 0; 368 } 369