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 u32 nvmet_fabrics_admin_cmd_data_len(struct nvmet_req *req) 89 { 90 struct nvme_command *cmd = req->cmd; 91 92 switch (cmd->fabrics.fctype) { 93 #ifdef CONFIG_NVME_TARGET_AUTH 94 case nvme_fabrics_type_auth_send: 95 return nvmet_auth_send_data_len(req); 96 case nvme_fabrics_type_auth_receive: 97 return nvmet_auth_receive_data_len(req); 98 #endif 99 default: 100 return 0; 101 } 102 } 103 104 u16 nvmet_parse_fabrics_admin_cmd(struct nvmet_req *req) 105 { 106 struct nvme_command *cmd = req->cmd; 107 108 switch (cmd->fabrics.fctype) { 109 case nvme_fabrics_type_property_set: 110 req->execute = nvmet_execute_prop_set; 111 break; 112 case nvme_fabrics_type_property_get: 113 req->execute = nvmet_execute_prop_get; 114 break; 115 #ifdef CONFIG_NVME_TARGET_AUTH 116 case nvme_fabrics_type_auth_send: 117 req->execute = nvmet_execute_auth_send; 118 break; 119 case nvme_fabrics_type_auth_receive: 120 req->execute = nvmet_execute_auth_receive; 121 break; 122 #endif 123 default: 124 pr_debug("received unknown capsule type 0x%x\n", 125 cmd->fabrics.fctype); 126 req->error_loc = offsetof(struct nvmf_common_command, fctype); 127 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 128 } 129 130 return 0; 131 } 132 133 u32 nvmet_fabrics_io_cmd_data_len(struct nvmet_req *req) 134 { 135 struct nvme_command *cmd = req->cmd; 136 137 switch (cmd->fabrics.fctype) { 138 #ifdef CONFIG_NVME_TARGET_AUTH 139 case nvme_fabrics_type_auth_send: 140 return nvmet_auth_send_data_len(req); 141 case nvme_fabrics_type_auth_receive: 142 return nvmet_auth_receive_data_len(req); 143 #endif 144 default: 145 return 0; 146 } 147 } 148 149 u16 nvmet_parse_fabrics_io_cmd(struct nvmet_req *req) 150 { 151 struct nvme_command *cmd = req->cmd; 152 153 switch (cmd->fabrics.fctype) { 154 #ifdef CONFIG_NVME_TARGET_AUTH 155 case nvme_fabrics_type_auth_send: 156 req->execute = nvmet_execute_auth_send; 157 break; 158 case nvme_fabrics_type_auth_receive: 159 req->execute = nvmet_execute_auth_receive; 160 break; 161 #endif 162 default: 163 pr_debug("received unknown capsule type 0x%x\n", 164 cmd->fabrics.fctype); 165 req->error_loc = offsetof(struct nvmf_common_command, fctype); 166 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 167 } 168 169 return 0; 170 } 171 172 static u16 nvmet_install_queue(struct nvmet_ctrl *ctrl, struct nvmet_req *req) 173 { 174 struct nvmf_connect_command *c = &req->cmd->connect; 175 u16 qid = le16_to_cpu(c->qid); 176 u16 sqsize = le16_to_cpu(c->sqsize); 177 struct nvmet_ctrl *old; 178 u16 mqes = NVME_CAP_MQES(ctrl->cap); 179 u16 ret; 180 181 if (!sqsize) { 182 pr_warn("queue size zero!\n"); 183 req->error_loc = offsetof(struct nvmf_connect_command, sqsize); 184 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize); 185 ret = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 186 goto err; 187 } 188 189 if (ctrl->sqs[qid] != NULL) { 190 pr_warn("qid %u has already been created\n", qid); 191 req->error_loc = offsetof(struct nvmf_connect_command, qid); 192 return NVME_SC_CMD_SEQ_ERROR | NVME_STATUS_DNR; 193 } 194 195 /* for fabrics, this value applies to only the I/O Submission Queues */ 196 if (qid && sqsize > mqes) { 197 pr_warn("sqsize %u is larger than MQES supported %u cntlid %d\n", 198 sqsize, mqes, ctrl->cntlid); 199 req->error_loc = offsetof(struct nvmf_connect_command, sqsize); 200 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(sqsize); 201 return NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 202 } 203 204 old = cmpxchg(&req->sq->ctrl, NULL, ctrl); 205 if (old) { 206 pr_warn("queue already connected!\n"); 207 req->error_loc = offsetof(struct nvmf_connect_command, opcode); 208 return NVME_SC_CONNECT_CTRL_BUSY | NVME_STATUS_DNR; 209 } 210 211 kref_get(&ctrl->ref); 212 old = cmpxchg(&req->cq->ctrl, NULL, ctrl); 213 if (old) { 214 pr_warn("queue already connected!\n"); 215 req->error_loc = offsetof(struct nvmf_connect_command, opcode); 216 return NVME_SC_CONNECT_CTRL_BUSY | NVME_STATUS_DNR; 217 } 218 219 /* note: convert queue size from 0's-based value to 1's-based value */ 220 nvmet_cq_setup(ctrl, req->cq, qid, sqsize + 1); 221 nvmet_sq_setup(ctrl, req->sq, qid, sqsize + 1); 222 223 if (c->cattr & NVME_CONNECT_DISABLE_SQFLOW) { 224 req->sq->sqhd_disabled = true; 225 req->cqe->sq_head = cpu_to_le16(0xffff); 226 } 227 228 if (ctrl->ops->install_queue) { 229 ret = ctrl->ops->install_queue(req->sq); 230 if (ret) { 231 pr_err("failed to install queue %d cntlid %d ret %x\n", 232 qid, ctrl->cntlid, ret); 233 ctrl->sqs[qid] = NULL; 234 goto err; 235 } 236 } 237 238 return 0; 239 240 err: 241 req->sq->ctrl = NULL; 242 return ret; 243 } 244 245 static u32 nvmet_connect_result(struct nvmet_ctrl *ctrl, struct nvmet_sq *sq) 246 { 247 bool needs_auth = nvmet_has_auth(ctrl, sq); 248 key_serial_t keyid = nvmet_queue_tls_keyid(sq); 249 250 /* Do not authenticate I/O queues */ 251 if (sq->qid) 252 needs_auth = false; 253 254 if (keyid) 255 pr_debug("%s: ctrl %d qid %d should %sauthenticate, tls psk %08x\n", 256 __func__, ctrl->cntlid, sq->qid, 257 needs_auth ? "" : "not ", keyid); 258 else 259 pr_debug("%s: ctrl %d qid %d should %sauthenticate%s\n", 260 __func__, ctrl->cntlid, sq->qid, 261 needs_auth ? "" : "not ", 262 ctrl->concat ? ", secure concatenation" : ""); 263 return (u32)ctrl->cntlid | 264 (needs_auth ? NVME_CONNECT_AUTHREQ_ATR : 0); 265 } 266 267 static void nvmet_execute_admin_connect(struct nvmet_req *req) 268 { 269 struct nvmf_connect_command *c = &req->cmd->connect; 270 struct nvmf_connect_data *d; 271 struct nvmet_ctrl *ctrl = NULL; 272 struct nvmet_alloc_ctrl_args args = { 273 .port = req->port, 274 .sq = req->sq, 275 .ops = req->ops, 276 .p2p_client = req->p2p_client, 277 .kato = le32_to_cpu(c->kato), 278 }; 279 280 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 281 return; 282 283 d = kmalloc(sizeof(*d), GFP_KERNEL); 284 if (!d) { 285 args.status = NVME_SC_INTERNAL; 286 goto complete; 287 } 288 289 args.status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 290 if (args.status) 291 goto out; 292 293 if (c->recfmt != 0) { 294 pr_warn("invalid connect version (%d).\n", 295 le16_to_cpu(c->recfmt)); 296 args.error_loc = offsetof(struct nvmf_connect_command, recfmt); 297 args.status = NVME_SC_CONNECT_FORMAT | NVME_STATUS_DNR; 298 goto out; 299 } 300 301 if (unlikely(d->cntlid != cpu_to_le16(0xffff))) { 302 pr_warn("connect attempt for invalid controller ID %#x\n", 303 d->cntlid); 304 args.status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 305 args.result = IPO_IATTR_CONNECT_DATA(cntlid); 306 goto out; 307 } 308 309 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 310 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 311 312 args.subsysnqn = d->subsysnqn; 313 args.hostnqn = d->hostnqn; 314 args.hostid = &d->hostid; 315 args.kato = le32_to_cpu(c->kato); 316 317 ctrl = nvmet_alloc_ctrl(&args); 318 if (!ctrl) 319 goto out; 320 321 args.status = nvmet_install_queue(ctrl, req); 322 if (args.status) { 323 nvmet_ctrl_put(ctrl); 324 goto out; 325 } 326 327 args.result = cpu_to_le32(nvmet_connect_result(ctrl, req->sq)); 328 out: 329 kfree(d); 330 complete: 331 req->error_loc = args.error_loc; 332 req->cqe->result.u32 = args.result; 333 nvmet_req_complete(req, args.status); 334 } 335 336 static void nvmet_execute_io_connect(struct nvmet_req *req) 337 { 338 struct nvmf_connect_command *c = &req->cmd->connect; 339 struct nvmf_connect_data *d; 340 struct nvmet_ctrl *ctrl; 341 u16 qid = le16_to_cpu(c->qid); 342 u16 status; 343 344 if (!nvmet_check_transfer_len(req, sizeof(struct nvmf_connect_data))) 345 return; 346 347 d = kmalloc(sizeof(*d), GFP_KERNEL); 348 if (!d) { 349 status = NVME_SC_INTERNAL; 350 goto complete; 351 } 352 353 status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d)); 354 if (status) 355 goto out; 356 357 if (c->recfmt != 0) { 358 pr_warn("invalid connect version (%d).\n", 359 le16_to_cpu(c->recfmt)); 360 status = NVME_SC_CONNECT_FORMAT | NVME_STATUS_DNR; 361 goto out; 362 } 363 364 d->subsysnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 365 d->hostnqn[NVMF_NQN_FIELD_LEN - 1] = '\0'; 366 ctrl = nvmet_ctrl_find_get(d->subsysnqn, d->hostnqn, 367 le16_to_cpu(d->cntlid), req); 368 if (!ctrl) { 369 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 370 goto out; 371 } 372 373 if (unlikely(qid > ctrl->subsys->max_qid)) { 374 pr_warn("invalid queue id (%d)\n", qid); 375 status = NVME_SC_CONNECT_INVALID_PARAM | NVME_STATUS_DNR; 376 req->cqe->result.u32 = IPO_IATTR_CONNECT_SQE(qid); 377 goto out_ctrl_put; 378 } 379 380 status = nvmet_install_queue(ctrl, req); 381 if (status) 382 goto out_ctrl_put; 383 384 pr_debug("adding queue %d to ctrl %d.\n", qid, ctrl->cntlid); 385 req->cqe->result.u32 = cpu_to_le32(nvmet_connect_result(ctrl, req->sq)); 386 out: 387 kfree(d); 388 complete: 389 nvmet_req_complete(req, status); 390 return; 391 392 out_ctrl_put: 393 nvmet_ctrl_put(ctrl); 394 goto out; 395 } 396 397 u32 nvmet_connect_cmd_data_len(struct nvmet_req *req) 398 { 399 struct nvme_command *cmd = req->cmd; 400 401 if (!nvme_is_fabrics(cmd) || 402 cmd->fabrics.fctype != nvme_fabrics_type_connect) 403 return 0; 404 405 return sizeof(struct nvmf_connect_data); 406 } 407 408 u16 nvmet_parse_connect_cmd(struct nvmet_req *req) 409 { 410 struct nvme_command *cmd = req->cmd; 411 412 if (!nvme_is_fabrics(cmd)) { 413 pr_debug("invalid command 0x%x on unconnected queue.\n", 414 cmd->fabrics.opcode); 415 req->error_loc = offsetof(struct nvme_common_command, opcode); 416 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 417 } 418 if (cmd->fabrics.fctype != nvme_fabrics_type_connect) { 419 pr_debug("invalid capsule type 0x%x on unconnected queue.\n", 420 cmd->fabrics.fctype); 421 req->error_loc = offsetof(struct nvmf_common_command, fctype); 422 return NVME_SC_INVALID_OPCODE | NVME_STATUS_DNR; 423 } 424 425 if (cmd->connect.qid == 0) 426 req->execute = nvmet_execute_admin_connect; 427 else 428 req->execute = nvmet_execute_io_connect; 429 return 0; 430 } 431