1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/opal.h" 35 #include "spdk/bdev_module.h" 36 #include "vbdev_opal.h" 37 #include "spdk_internal/log.h" 38 #include "spdk/string.h" 39 40 /* OPAL locking range only supports operations on nsid=1 for now */ 41 #define NSID_SUPPORTED 1 42 43 struct spdk_vbdev_opal_config { 44 char *nvme_ctrlr_name; 45 uint8_t locking_range_id; 46 uint64_t range_start; 47 uint64_t range_length; 48 SPDK_BDEV_PART_TAILQ *part_tailq; 49 struct vbdev_opal_part_base *opal_base; 50 }; 51 52 struct opal_vbdev { 53 char *name; 54 struct nvme_bdev_ctrlr *nvme_ctrlr; 55 struct spdk_opal_dev *opal_dev; 56 struct spdk_bdev_part *bdev_part; 57 struct spdk_vbdev_opal_config cfg; 58 59 TAILQ_ENTRY(opal_vbdev) tailq; 60 }; 61 62 static TAILQ_HEAD(, opal_vbdev) g_opal_vbdev = 63 TAILQ_HEAD_INITIALIZER(g_opal_vbdev); 64 65 struct vbdev_opal_bdev_io { 66 struct spdk_io_channel *ch; 67 struct spdk_bdev_io *bdev_io; 68 struct spdk_bdev_io_wait_entry bdev_io_wait; 69 }; 70 71 struct vbdev_opal_channel { 72 struct spdk_bdev_part_channel part_ch; 73 }; 74 75 struct vbdev_opal_part_base { 76 char *nvme_ctrlr_name; 77 struct spdk_bdev_part_base *part_base; 78 int num_of_part; 79 TAILQ_ENTRY(vbdev_opal_part_base) tailq; 80 }; 81 82 static TAILQ_HEAD(, vbdev_opal_part_base) g_opal_base = TAILQ_HEAD_INITIALIZER(g_opal_base); 83 84 static void _vbdev_opal_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io); 85 86 static void vbdev_opal_examine(struct spdk_bdev *bdev); 87 88 static void 89 vbdev_opal_delete(struct opal_vbdev *opal_bdev) 90 { 91 TAILQ_REMOVE(&g_opal_vbdev, opal_bdev, tailq); 92 free(opal_bdev->name); 93 free(opal_bdev->cfg.nvme_ctrlr_name); 94 free(opal_bdev); 95 opal_bdev = NULL; 96 } 97 98 static void 99 vbdev_opal_clear(void) 100 { 101 struct opal_vbdev *opal_bdev, *tmp; 102 103 TAILQ_FOREACH_SAFE(opal_bdev, &g_opal_vbdev, tailq, tmp) { 104 vbdev_opal_delete(opal_bdev); 105 } 106 } 107 108 static int 109 vbdev_opal_init(void) 110 { 111 /* TODO */ 112 return 0; 113 } 114 115 static void 116 vbdev_opal_fini(void) 117 { 118 vbdev_opal_clear(); 119 } 120 121 static int 122 vbdev_opal_get_ctx_size(void) 123 { 124 return sizeof(struct vbdev_opal_bdev_io); 125 } 126 127 /* delete all the config of the same base bdev */ 128 static void 129 vbdev_opal_delete_all_base_config(struct vbdev_opal_part_base *base) 130 { 131 char *nvme_ctrlr_name = base->nvme_ctrlr_name; 132 struct opal_vbdev *bdev, *tmp_bdev; 133 134 TAILQ_FOREACH_SAFE(bdev, &g_opal_vbdev, tailq, tmp_bdev) { 135 if (!strcmp(nvme_ctrlr_name, bdev->nvme_ctrlr->name)) { 136 vbdev_opal_delete(bdev); 137 } 138 } 139 } 140 141 static int 142 vbdev_opal_destruct(void *ctx) 143 { 144 struct spdk_bdev_part *part = ctx; 145 146 return spdk_bdev_part_free(part); 147 } 148 149 static void 150 vbdev_opal_base_free(void *ctx) 151 { 152 struct vbdev_opal_part_base *base = ctx; 153 SPDK_BDEV_PART_TAILQ *part_tailq = spdk_bdev_part_base_get_tailq(base->part_base); 154 155 free(part_tailq); 156 free(base->nvme_ctrlr_name); 157 free(base); 158 } 159 160 static void 161 vbdev_opal_resubmit_io(void *arg) 162 { 163 struct vbdev_opal_bdev_io *io_ctx = (struct vbdev_opal_bdev_io *)arg; 164 165 _vbdev_opal_submit_request(io_ctx->ch, io_ctx->bdev_io); 166 } 167 168 static void 169 vbdev_opal_queue_io(struct vbdev_opal_bdev_io *io_ctx) 170 { 171 int rc; 172 173 io_ctx->bdev_io_wait.bdev = io_ctx->bdev_io->bdev; 174 io_ctx->bdev_io_wait.cb_fn = vbdev_opal_resubmit_io; 175 io_ctx->bdev_io_wait.cb_arg = io_ctx; 176 177 rc = spdk_bdev_queue_io_wait(io_ctx->bdev_io->bdev, io_ctx->ch, &io_ctx->bdev_io_wait); 178 179 if (rc != 0) { 180 SPDK_ERRLOG("Queue io failed in vbdev_opal_queue_io: %d\n", rc); 181 spdk_bdev_io_complete(io_ctx->bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 182 } 183 } 184 185 static void 186 _vbdev_opal_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io) 187 { 188 struct vbdev_opal_channel *ch = spdk_io_channel_get_ctx(_ch); 189 struct vbdev_opal_bdev_io *io_ctx = (struct vbdev_opal_bdev_io *)bdev_io->driver_ctx; 190 int rc; 191 192 rc = spdk_bdev_part_submit_request(&ch->part_ch, bdev_io); 193 if (rc) { 194 if (rc == -ENOMEM) { 195 SPDK_DEBUGLOG(SPDK_LOG_VBDEV_OPAL, "opal: no memory, queue io.\n"); 196 io_ctx->ch = _ch; 197 io_ctx->bdev_io = bdev_io; 198 vbdev_opal_queue_io(io_ctx); 199 } else { 200 SPDK_ERRLOG("opal: error on io submission, rc=%d.\n", rc); 201 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 202 } 203 } 204 } 205 206 static void 207 vbdev_opal_io_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, bool success) 208 { 209 if (!success) { 210 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 211 return; 212 } 213 214 _vbdev_opal_submit_request(ch, bdev_io); 215 } 216 217 static void 218 vbdev_opal_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io) 219 { 220 switch (bdev_io->type) { 221 case SPDK_BDEV_IO_TYPE_READ: 222 spdk_bdev_io_get_buf(bdev_io, vbdev_opal_io_get_buf_cb, 223 bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen); 224 break; 225 default: 226 _vbdev_opal_submit_request(ch, bdev_io); 227 break; 228 } 229 } 230 231 struct spdk_opal_locking_range_info * 232 spdk_vbdev_opal_get_info_from_bdev(const char *opal_bdev_name, const char *password) 233 { 234 struct opal_vbdev *vbdev; 235 struct nvme_bdev_ctrlr *nvme_ctrlr; 236 int locking_range_id; 237 int rc; 238 239 TAILQ_FOREACH(vbdev, &g_opal_vbdev, tailq) { 240 if (strcmp(vbdev->name, opal_bdev_name) == 0) { 241 break; 242 } 243 } 244 245 if (vbdev == NULL) { 246 SPDK_ERRLOG("%s not found\n", opal_bdev_name); 247 return NULL; 248 } 249 250 nvme_ctrlr = vbdev->nvme_ctrlr; 251 if (nvme_ctrlr == NULL) { 252 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", vbdev->name); 253 return NULL; 254 } 255 256 if (spdk_opal_get_max_locking_ranges(nvme_ctrlr->opal_dev) == 0) { 257 rc = spdk_opal_cmd_get_max_ranges(nvme_ctrlr->opal_dev, password); 258 if (rc) { 259 SPDK_ERRLOG("Get locking range number failure: %d\n", rc); 260 return NULL; 261 } 262 } 263 264 locking_range_id = vbdev->cfg.locking_range_id; 265 rc = spdk_opal_cmd_get_locking_range_info(nvme_ctrlr->opal_dev, password, 266 OPAL_ADMIN1, locking_range_id); 267 if (rc) { 268 SPDK_ERRLOG("Get locking range info error: %d\n", rc); 269 return NULL; 270 } 271 272 return spdk_opal_get_locking_range_info(nvme_ctrlr->opal_dev, locking_range_id); 273 } 274 275 static int 276 vbdev_opal_dump_info_json(void *ctx, struct spdk_json_write_ctx *w) 277 { 278 struct spdk_bdev_part *part = ctx; 279 struct spdk_bdev *base_bdev = spdk_bdev_part_get_base_bdev(part); 280 uint64_t offset = spdk_bdev_part_get_offset_blocks(part); 281 282 spdk_json_write_named_object_begin(w, "opal"); 283 284 spdk_json_write_named_string(w, "base_bdev", spdk_bdev_get_name(base_bdev)); 285 spdk_json_write_named_uint64(w, "offset_blocks", offset); 286 287 spdk_json_write_object_end(w); 288 289 return 0; 290 } 291 292 static void 293 vbdev_opal_base_bdev_hotremove_cb(void *_part_base) 294 { 295 struct spdk_bdev_part_base *part_base = _part_base; 296 struct vbdev_opal_part_base *base = spdk_bdev_part_base_get_ctx(part_base); 297 298 spdk_bdev_part_base_hotremove(part_base, spdk_bdev_part_base_get_tailq(part_base)); 299 vbdev_opal_delete_all_base_config(base); 300 } 301 302 static bool 303 vbdev_opal_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type) 304 { 305 struct spdk_bdev_part *part = ctx; 306 struct spdk_bdev *base_bdev = spdk_bdev_part_get_base_bdev(part); 307 308 return spdk_bdev_io_type_supported(base_bdev, io_type); 309 } 310 311 static struct spdk_bdev_fn_table opal_vbdev_fn_table = { 312 .destruct = vbdev_opal_destruct, 313 .submit_request = vbdev_opal_submit_request, 314 .io_type_supported = vbdev_opal_io_type_supported, 315 .dump_info_json = vbdev_opal_dump_info_json, 316 .write_config_json = NULL, 317 }; 318 319 static struct spdk_bdev_module opal_if = { 320 .name = "opal", 321 .module_init = vbdev_opal_init, 322 .module_fini = vbdev_opal_fini, 323 .get_ctx_size = vbdev_opal_get_ctx_size, 324 .examine_config = vbdev_opal_examine, 325 .config_json = NULL, 326 }; 327 328 SPDK_BDEV_MODULE_REGISTER(opal, &opal_if) 329 330 static void 331 vbdev_opal_free_bdev(struct opal_vbdev *opal_bdev) 332 { 333 free(opal_bdev->cfg.nvme_ctrlr_name); 334 free(opal_bdev); 335 } 336 337 int 338 spdk_vbdev_opal_create(const char *nvme_ctrlr_name, uint32_t nsid, uint8_t locking_range_id, 339 uint64_t range_start, uint64_t range_length, const char *password) 340 { 341 int rc; 342 char *opal_vbdev_name; 343 char *base_bdev_name; 344 struct nvme_bdev_ctrlr *nvme_ctrlr; 345 struct opal_vbdev *opal_bdev; 346 struct vbdev_opal_part_base *opal_part_base; 347 struct spdk_bdev_part *part_bdev; 348 SPDK_BDEV_PART_TAILQ *part_tailq; 349 struct spdk_vbdev_opal_config *cfg; 350 struct nvme_bdev *nvme_bdev; 351 352 if (nsid != NSID_SUPPORTED) { 353 SPDK_ERRLOG("nsid %d not supported", nsid); 354 return -EINVAL; 355 } 356 357 nvme_ctrlr = nvme_bdev_ctrlr_get_by_name(nvme_ctrlr_name); 358 if (!nvme_ctrlr) { 359 SPDK_ERRLOG("get nvme ctrlr failed\n"); 360 return -ENODEV; 361 } 362 363 if (nvme_ctrlr->opal_dev == NULL) { 364 SPDK_ERRLOG("Opal not supported\n"); 365 return -ENODEV; 366 } 367 368 opal_bdev = calloc(1, sizeof(struct opal_vbdev)); 369 if (!opal_bdev) { 370 SPDK_ERRLOG("allocation for opal_bdev failed\n"); 371 return -ENOMEM; 372 } 373 374 cfg = &opal_bdev->cfg; 375 cfg->nvme_ctrlr_name = strdup(nvme_ctrlr_name); 376 if (!cfg->nvme_ctrlr_name) { 377 SPDK_ERRLOG("allocation for nvme_ctrlr_name failed\n"); 378 free(opal_bdev); 379 return -ENOMEM; 380 } 381 382 cfg->locking_range_id = locking_range_id; 383 cfg->range_start = range_start; 384 cfg->range_length = range_length; 385 386 opal_bdev->nvme_ctrlr = nvme_ctrlr; 387 opal_bdev->opal_dev = nvme_ctrlr->opal_dev; 388 if (!spdk_opal_supported(opal_bdev->opal_dev)) { 389 SPDK_ERRLOG("Opal not supported\n"); 390 vbdev_opal_free_bdev(opal_bdev); 391 return -EINVAL; 392 } 393 394 nvme_bdev = TAILQ_FIRST(&nvme_ctrlr->namespaces[nsid - 1]->bdevs); 395 assert(nvme_bdev != NULL); 396 base_bdev_name = nvme_bdev->disk.name; 397 398 /* traverse base list to see if part_base is already create for this base bdev */ 399 TAILQ_FOREACH(opal_part_base, &g_opal_base, tailq) { 400 if (!strcmp(spdk_bdev_part_base_get_bdev_name(opal_part_base->part_base), base_bdev_name)) { 401 cfg->opal_base = opal_part_base; 402 } 403 } 404 405 /* If there is not a corresponding opal_part_base, a new opal_part_base will be created. 406 For each new part_base, there will be one tailq to store all the parts of this base */ 407 if (cfg->opal_base == NULL) { 408 part_tailq = calloc(1, sizeof(*part_tailq)); 409 if (part_tailq == NULL) { 410 SPDK_ERRLOG("Could not allocate bdev_part_tailq\n"); 411 vbdev_opal_free_bdev(opal_bdev); 412 return -ENOMEM; 413 } 414 415 TAILQ_INIT(part_tailq); 416 cfg->part_tailq = part_tailq; 417 opal_part_base = calloc(1, sizeof(*opal_part_base)); 418 if (opal_part_base == NULL) { 419 SPDK_ERRLOG("Could not allocate opal_part_base\n"); 420 vbdev_opal_free_bdev(opal_bdev); 421 free(part_tailq); 422 return -ENOMEM; 423 } 424 425 opal_part_base->part_base = spdk_bdev_part_base_construct(spdk_bdev_get_by_name(base_bdev_name), 426 vbdev_opal_base_bdev_hotremove_cb, &opal_if, 427 &opal_vbdev_fn_table, part_tailq, vbdev_opal_base_free, opal_part_base, 428 sizeof(struct vbdev_opal_channel), NULL, NULL); 429 if (opal_part_base->part_base == NULL) { 430 SPDK_ERRLOG("Could not allocate part_base\n"); 431 vbdev_opal_free_bdev(opal_bdev); 432 free(part_tailq); 433 free(opal_part_base); 434 return -ENOMEM; 435 } 436 opal_part_base->num_of_part = 0; 437 opal_part_base->nvme_ctrlr_name = strdup(cfg->nvme_ctrlr_name); 438 if (opal_part_base->nvme_ctrlr_name == NULL) { 439 vbdev_opal_free_bdev(opal_bdev); 440 spdk_bdev_part_base_free(opal_part_base->part_base); 441 return -ENOMEM; 442 } 443 444 cfg->opal_base = opal_part_base; 445 TAILQ_INSERT_TAIL(&g_opal_base, opal_part_base, tailq); 446 } 447 448 part_bdev = calloc(1, sizeof(struct spdk_bdev_part)); 449 if (!part_bdev) { 450 SPDK_ERRLOG("Could not allocate part_bdev\n"); 451 vbdev_opal_free_bdev(opal_bdev); 452 return -ENOMEM; 453 } 454 455 TAILQ_INSERT_TAIL(&g_opal_vbdev, opal_bdev, tailq); 456 opal_vbdev_name = spdk_sprintf_alloc("%sr%" PRIu8, base_bdev_name, 457 cfg->locking_range_id); /* e.g.: nvme0n1r1 */ 458 if (opal_vbdev_name == NULL) { 459 SPDK_ERRLOG("Could not allocate opal_vbdev_name\n"); 460 rc = -ENOMEM; 461 goto err; 462 } 463 464 opal_bdev->name = opal_vbdev_name; 465 rc = spdk_opal_cmd_setup_locking_range(opal_bdev->opal_dev, OPAL_ADMIN1, 466 cfg->locking_range_id, cfg->range_start, cfg->range_length, password); 467 if (rc) { 468 SPDK_ERRLOG("Error construct %s\n", opal_vbdev_name); 469 goto err; 470 } 471 472 rc = spdk_bdev_part_construct(part_bdev, cfg->opal_base->part_base, opal_vbdev_name, 473 cfg->range_start, cfg->range_length, "Opal locking range"); 474 if (rc) { 475 SPDK_ERRLOG("Could not allocate bdev part\n"); 476 goto err; 477 } 478 479 /* lock this bdev initially */ 480 rc = spdk_opal_cmd_lock_unlock(opal_bdev->opal_dev, OPAL_ADMIN1, OPAL_RWLOCK, locking_range_id, 481 password); 482 if (rc) { 483 SPDK_ERRLOG("Error lock %s\n", opal_vbdev_name); 484 goto err; 485 } 486 487 opal_bdev->bdev_part = part_bdev; 488 cfg->opal_base->num_of_part++; 489 return 0; 490 491 err: 492 vbdev_opal_delete(opal_bdev); 493 free(part_bdev); 494 return rc; 495 } 496 497 static void 498 vbdev_opal_destruct_bdev(struct opal_vbdev *opal_bdev) 499 { 500 SPDK_BDEV_PART_TAILQ *opal_part_tailq; 501 struct spdk_bdev_part *part; 502 struct spdk_vbdev_opal_config *cfg = &opal_bdev->cfg; 503 504 if (cfg->opal_base != NULL) { 505 part = opal_bdev->bdev_part; 506 opal_part_tailq = spdk_bdev_part_base_get_tailq(cfg->opal_base->part_base); 507 if (opal_part_tailq == NULL) { 508 SPDK_ERRLOG("Can't get tailq for this opal_base\n"); 509 return; 510 } 511 if (cfg->range_start == spdk_bdev_part_get_offset_blocks(part)) { 512 if (cfg->opal_base->num_of_part <= 1) { 513 /* if there is only one part for this base, we can remove the base now */ 514 spdk_bdev_part_base_hotremove(cfg->opal_base->part_base, opal_part_tailq); 515 516 /* remove from the tailq vbdev_opal_part_base */ 517 TAILQ_REMOVE(&g_opal_base, cfg->opal_base, tailq); 518 } else { 519 spdk_bdev_unregister(spdk_bdev_part_get_bdev(part), NULL, NULL); 520 cfg->opal_base->num_of_part--; 521 } 522 } 523 } 524 vbdev_opal_delete(opal_bdev); 525 } 526 527 int 528 spdk_vbdev_opal_destruct(const char *bdev_name, const char *password) 529 { 530 struct spdk_vbdev_opal_config *cfg; 531 struct nvme_bdev_ctrlr *nvme_ctrlr; 532 int locking_range_id; 533 int rc; 534 struct opal_vbdev *opal_bdev; 535 536 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 537 if (strcmp(opal_bdev->name, bdev_name) == 0) { 538 break; 539 } 540 } 541 542 if (opal_bdev == NULL) { 543 SPDK_ERRLOG("%s not found\n", bdev_name); 544 rc = -ENODEV; 545 goto err; 546 } 547 548 cfg = &opal_bdev->cfg; 549 locking_range_id = cfg->locking_range_id; 550 551 nvme_ctrlr = opal_bdev->nvme_ctrlr; 552 if (nvme_ctrlr == NULL) { 553 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", bdev_name); 554 return -ENODEV; 555 } 556 557 /* secure erase locking range */ 558 rc = spdk_opal_cmd_erase_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 559 password); 560 if (rc) { 561 SPDK_ERRLOG("opal erase locking range failed\n"); 562 goto err; 563 } 564 565 /* reset the locking range to 0 */ 566 rc = spdk_opal_cmd_setup_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 0, 567 0, password); 568 if (rc) { 569 SPDK_ERRLOG("opal reset locking range failed\n"); 570 goto err; 571 } 572 573 spdk_opal_free_locking_range_info(opal_bdev->opal_dev, locking_range_id); 574 vbdev_opal_destruct_bdev(opal_bdev); 575 return 0; 576 577 err: 578 return rc; 579 } 580 581 static void 582 vbdev_opal_examine(struct spdk_bdev *bdev) 583 { 584 /* TODO */ 585 spdk_bdev_module_examine_done(&opal_if); 586 } 587 588 static int 589 vbdev_opal_recv_poll(void *arg) 590 { 591 struct nvme_bdev_ctrlr *nvme_ctrlr = arg; 592 int rc; 593 594 rc = spdk_opal_revert_poll(nvme_ctrlr->opal_dev); 595 if (rc == -EAGAIN) { 596 return -1; 597 } 598 599 /* receive end */ 600 spdk_poller_unregister(&nvme_ctrlr->opal_poller); 601 nvme_ctrlr->opal_poller = NULL; 602 return 1; 603 } 604 605 int 606 spdk_vbdev_opal_revert_tper(struct nvme_bdev_ctrlr *nvme_ctrlr, const char *password, 607 spdk_opal_revert_cb cb_fn, void *cb_ctx) 608 { 609 int rc; 610 611 rc = spdk_opal_cmd_revert_tper_async(nvme_ctrlr->opal_dev, password, cb_fn, cb_ctx); 612 if (rc) { 613 SPDK_ERRLOG("%s revert tper failure: %d\n", nvme_ctrlr->name, rc); 614 return rc; 615 } 616 nvme_ctrlr->opal_poller = spdk_poller_register(vbdev_opal_recv_poll, nvme_ctrlr, 50); 617 return 0; 618 } 619 620 int 621 spdk_vbdev_opal_set_lock_state(const char *bdev_name, uint16_t user_id, const char *password, 622 const char *lock_state) 623 { 624 struct nvme_bdev_ctrlr *nvme_ctrlr; 625 int locking_range_id; 626 int rc; 627 enum spdk_opal_lock_state state_flag; 628 struct opal_vbdev *opal_bdev; 629 630 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 631 if (strcmp(opal_bdev->name, bdev_name) == 0) { 632 break; 633 } 634 } 635 636 if (opal_bdev == NULL) { 637 SPDK_ERRLOG("%s not found\n", bdev_name); 638 return -ENODEV; 639 } 640 641 nvme_ctrlr = opal_bdev->nvme_ctrlr; 642 if (nvme_ctrlr == NULL) { 643 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 644 return -ENODEV; 645 } 646 647 if (strcasecmp(lock_state, "READWRITE") == 0) { 648 state_flag = OPAL_READWRITE; 649 } else if (strcasecmp(lock_state, "READONLY") == 0) { 650 state_flag = OPAL_READONLY; 651 } else if (strcasecmp(lock_state, "RWLOCK") == 0) { 652 state_flag = OPAL_RWLOCK; 653 } else { 654 SPDK_ERRLOG("Invalid OPAL lock state input\n"); 655 return -EINVAL; 656 } 657 658 locking_range_id = opal_bdev->cfg.locking_range_id; 659 rc = spdk_opal_cmd_lock_unlock(nvme_ctrlr->opal_dev, user_id, state_flag, locking_range_id, 660 password); 661 if (rc) { 662 SPDK_ERRLOG("%s lock/unlock failure: %d\n", bdev_name, rc); 663 } 664 665 return rc; 666 } 667 668 int 669 spdk_vbdev_opal_enable_new_user(const char *bdev_name, const char *admin_password, uint16_t user_id, 670 const char *user_password) 671 { 672 struct nvme_bdev_ctrlr *nvme_ctrlr; 673 int locking_range_id; 674 int rc; 675 struct opal_vbdev *opal_bdev; 676 677 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 678 if (strcmp(opal_bdev->name, bdev_name) == 0) { 679 break; 680 } 681 } 682 683 if (opal_bdev == NULL) { 684 SPDK_ERRLOG("%s not found\n", bdev_name); 685 return -ENODEV; 686 } 687 688 nvme_ctrlr = opal_bdev->nvme_ctrlr; 689 if (nvme_ctrlr == NULL) { 690 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 691 return -ENODEV; 692 } 693 694 rc = spdk_opal_cmd_enable_user(nvme_ctrlr->opal_dev, user_id, admin_password); 695 if (rc) { 696 SPDK_ERRLOG("%s enable user error: %d\n", bdev_name, rc); 697 return rc; 698 } 699 700 rc = spdk_opal_cmd_set_new_passwd(nvme_ctrlr->opal_dev, user_id, user_password, admin_password, 701 true); 702 if (rc) { 703 SPDK_ERRLOG("%s set user password error: %d\n", bdev_name, rc); 704 return rc; 705 } 706 707 locking_range_id = opal_bdev->cfg.locking_range_id; 708 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 709 OPAL_READONLY, admin_password); 710 if (rc) { 711 SPDK_ERRLOG("%s add user READONLY priority error: %d\n", bdev_name, rc); 712 return rc; 713 } 714 715 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 716 OPAL_READWRITE, admin_password); 717 if (rc) { 718 SPDK_ERRLOG("%s add user READWRITE priority error: %d\n", bdev_name, rc); 719 return rc; 720 } 721 722 return 0; 723 } 724 725 SPDK_LOG_REGISTER_COMPONENT("vbdev_opal", SPDK_LOG_VBDEV_OPAL) 726