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 opal_vbdev { 44 char *name; 45 struct nvme_bdev_ctrlr *nvme_ctrlr; 46 struct spdk_opal_dev *opal_dev; 47 struct spdk_bdev_part *bdev_part; 48 49 uint8_t locking_range_id; 50 uint64_t range_start; 51 uint64_t range_length; 52 struct vbdev_opal_part_base *opal_base; 53 54 TAILQ_ENTRY(opal_vbdev) tailq; 55 }; 56 57 static TAILQ_HEAD(, opal_vbdev) g_opal_vbdev = 58 TAILQ_HEAD_INITIALIZER(g_opal_vbdev); 59 60 struct vbdev_opal_bdev_io { 61 struct spdk_io_channel *ch; 62 struct spdk_bdev_io *bdev_io; 63 struct spdk_bdev_io_wait_entry bdev_io_wait; 64 }; 65 66 struct vbdev_opal_channel { 67 struct spdk_bdev_part_channel part_ch; 68 }; 69 70 struct vbdev_opal_part_base { 71 char *nvme_ctrlr_name; 72 struct spdk_bdev_part_base *part_base; 73 SPDK_BDEV_PART_TAILQ part_tailq; 74 TAILQ_ENTRY(vbdev_opal_part_base) tailq; 75 }; 76 77 static TAILQ_HEAD(, vbdev_opal_part_base) g_opal_base = TAILQ_HEAD_INITIALIZER(g_opal_base); 78 79 static void _vbdev_opal_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io); 80 81 static void vbdev_opal_examine(struct spdk_bdev *bdev); 82 83 static void 84 vbdev_opal_delete(struct opal_vbdev *opal_bdev) 85 { 86 TAILQ_REMOVE(&g_opal_vbdev, opal_bdev, tailq); 87 free(opal_bdev->name); 88 free(opal_bdev); 89 opal_bdev = NULL; 90 } 91 92 static void 93 vbdev_opal_clear(void) 94 { 95 struct opal_vbdev *opal_bdev, *tmp; 96 97 TAILQ_FOREACH_SAFE(opal_bdev, &g_opal_vbdev, tailq, tmp) { 98 vbdev_opal_delete(opal_bdev); 99 } 100 } 101 102 static int 103 vbdev_opal_init(void) 104 { 105 /* TODO */ 106 return 0; 107 } 108 109 static void 110 vbdev_opal_fini(void) 111 { 112 vbdev_opal_clear(); 113 } 114 115 static int 116 vbdev_opal_get_ctx_size(void) 117 { 118 return sizeof(struct vbdev_opal_bdev_io); 119 } 120 121 /* delete all the config of the same base bdev */ 122 static void 123 vbdev_opal_delete_all_base_config(struct vbdev_opal_part_base *base) 124 { 125 char *nvme_ctrlr_name = base->nvme_ctrlr_name; 126 struct opal_vbdev *bdev, *tmp_bdev; 127 128 TAILQ_FOREACH_SAFE(bdev, &g_opal_vbdev, tailq, tmp_bdev) { 129 if (!strcmp(nvme_ctrlr_name, bdev->nvme_ctrlr->name)) { 130 vbdev_opal_delete(bdev); 131 } 132 } 133 } 134 135 static int 136 _vbdev_opal_destruct(void *ctx) 137 { 138 struct spdk_bdev_part *part = ctx; 139 140 return spdk_bdev_part_free(part); 141 } 142 143 static void 144 vbdev_opal_base_free(void *ctx) 145 { 146 struct vbdev_opal_part_base *base = ctx; 147 148 TAILQ_REMOVE(&g_opal_base, base, tailq); 149 150 free(base->nvme_ctrlr_name); 151 free(base); 152 } 153 154 static void 155 vbdev_opal_resubmit_io(void *arg) 156 { 157 struct vbdev_opal_bdev_io *io_ctx = (struct vbdev_opal_bdev_io *)arg; 158 159 _vbdev_opal_submit_request(io_ctx->ch, io_ctx->bdev_io); 160 } 161 162 static void 163 vbdev_opal_queue_io(struct vbdev_opal_bdev_io *io_ctx) 164 { 165 struct vbdev_opal_channel *ch = spdk_io_channel_get_ctx(io_ctx->ch); 166 int rc; 167 168 io_ctx->bdev_io_wait.bdev = io_ctx->bdev_io->bdev; 169 io_ctx->bdev_io_wait.cb_fn = vbdev_opal_resubmit_io; 170 io_ctx->bdev_io_wait.cb_arg = io_ctx; 171 172 rc = spdk_bdev_queue_io_wait(io_ctx->bdev_io->bdev, ch->part_ch.base_ch, &io_ctx->bdev_io_wait); 173 174 if (rc != 0) { 175 SPDK_ERRLOG("Queue io failed in vbdev_opal_queue_io: %d\n", rc); 176 spdk_bdev_io_complete(io_ctx->bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 177 } 178 } 179 180 static void 181 _vbdev_opal_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io) 182 { 183 struct vbdev_opal_channel *ch = spdk_io_channel_get_ctx(_ch); 184 struct vbdev_opal_bdev_io *io_ctx = (struct vbdev_opal_bdev_io *)bdev_io->driver_ctx; 185 int rc; 186 187 rc = spdk_bdev_part_submit_request(&ch->part_ch, bdev_io); 188 if (rc) { 189 if (rc == -ENOMEM) { 190 SPDK_DEBUGLOG(SPDK_LOG_VBDEV_OPAL, "opal: no memory, queue io.\n"); 191 io_ctx->ch = _ch; 192 io_ctx->bdev_io = bdev_io; 193 vbdev_opal_queue_io(io_ctx); 194 } else { 195 SPDK_ERRLOG("opal: error on io submission, rc=%d.\n", rc); 196 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 197 } 198 } 199 } 200 201 static void 202 vbdev_opal_io_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, bool success) 203 { 204 if (!success) { 205 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 206 return; 207 } 208 209 _vbdev_opal_submit_request(ch, bdev_io); 210 } 211 212 static void 213 vbdev_opal_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io) 214 { 215 switch (bdev_io->type) { 216 case SPDK_BDEV_IO_TYPE_READ: 217 spdk_bdev_io_get_buf(bdev_io, vbdev_opal_io_get_buf_cb, 218 bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen); 219 break; 220 default: 221 _vbdev_opal_submit_request(ch, bdev_io); 222 break; 223 } 224 } 225 226 struct spdk_opal_locking_range_info * 227 vbdev_opal_get_info_from_bdev(const char *opal_bdev_name, const char *password) 228 { 229 struct opal_vbdev *vbdev; 230 struct nvme_bdev_ctrlr *nvme_ctrlr; 231 int locking_range_id; 232 int rc; 233 234 TAILQ_FOREACH(vbdev, &g_opal_vbdev, tailq) { 235 if (strcmp(vbdev->name, opal_bdev_name) == 0) { 236 break; 237 } 238 } 239 240 if (vbdev == NULL) { 241 SPDK_ERRLOG("%s not found\n", opal_bdev_name); 242 return NULL; 243 } 244 245 nvme_ctrlr = vbdev->nvme_ctrlr; 246 if (nvme_ctrlr == NULL) { 247 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", vbdev->name); 248 return NULL; 249 } 250 251 locking_range_id = vbdev->locking_range_id; 252 rc = spdk_opal_cmd_get_locking_range_info(nvme_ctrlr->opal_dev, password, 253 OPAL_ADMIN1, locking_range_id); 254 if (rc) { 255 SPDK_ERRLOG("Get locking range info error: %d\n", rc); 256 return NULL; 257 } 258 259 return spdk_opal_get_locking_range_info(nvme_ctrlr->opal_dev, locking_range_id); 260 } 261 262 static int 263 vbdev_opal_dump_info_json(void *ctx, struct spdk_json_write_ctx *w) 264 { 265 struct spdk_bdev_part *part = ctx; 266 struct spdk_bdev *base_bdev = spdk_bdev_part_get_base_bdev(part); 267 uint64_t offset = spdk_bdev_part_get_offset_blocks(part); 268 269 spdk_json_write_named_object_begin(w, "opal"); 270 271 spdk_json_write_named_string(w, "base_bdev", spdk_bdev_get_name(base_bdev)); 272 spdk_json_write_named_uint64(w, "offset_blocks", offset); 273 274 spdk_json_write_object_end(w); 275 276 return 0; 277 } 278 279 static void 280 vbdev_opal_base_bdev_hotremove_cb(void *_part_base) 281 { 282 struct spdk_bdev_part_base *part_base = _part_base; 283 struct vbdev_opal_part_base *base = spdk_bdev_part_base_get_ctx(part_base); 284 285 spdk_bdev_part_base_hotremove(part_base, spdk_bdev_part_base_get_tailq(part_base)); 286 vbdev_opal_delete_all_base_config(base); 287 } 288 289 static bool 290 vbdev_opal_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type) 291 { 292 struct spdk_bdev_part *part = ctx; 293 struct spdk_bdev *base_bdev = spdk_bdev_part_get_base_bdev(part); 294 295 return spdk_bdev_io_type_supported(base_bdev, io_type); 296 } 297 298 static struct spdk_bdev_fn_table opal_vbdev_fn_table = { 299 .destruct = _vbdev_opal_destruct, 300 .submit_request = vbdev_opal_submit_request, 301 .io_type_supported = vbdev_opal_io_type_supported, 302 .dump_info_json = vbdev_opal_dump_info_json, 303 .write_config_json = NULL, 304 }; 305 306 static struct spdk_bdev_module opal_if = { 307 .name = "opal", 308 .module_init = vbdev_opal_init, 309 .module_fini = vbdev_opal_fini, 310 .get_ctx_size = vbdev_opal_get_ctx_size, 311 .examine_config = vbdev_opal_examine, 312 .config_json = NULL, 313 }; 314 315 SPDK_BDEV_MODULE_REGISTER(opal, &opal_if) 316 317 int 318 vbdev_opal_create(const char *nvme_ctrlr_name, uint32_t nsid, uint8_t locking_range_id, 319 uint64_t range_start, uint64_t range_length, const char *password) 320 { 321 int rc; 322 char *opal_vbdev_name; 323 char *base_bdev_name; 324 struct nvme_bdev_ctrlr *nvme_ctrlr; 325 struct opal_vbdev *opal_bdev; 326 struct vbdev_opal_part_base *opal_part_base = NULL; 327 struct spdk_bdev_part *part_bdev; 328 struct nvme_bdev *nvme_bdev; 329 330 if (nsid != NSID_SUPPORTED) { 331 SPDK_ERRLOG("nsid %d not supported", nsid); 332 return -EINVAL; 333 } 334 335 nvme_ctrlr = nvme_bdev_ctrlr_get_by_name(nvme_ctrlr_name); 336 if (!nvme_ctrlr) { 337 SPDK_ERRLOG("get nvme ctrlr failed\n"); 338 return -ENODEV; 339 } 340 341 if (!nvme_ctrlr->opal_dev) { 342 SPDK_ERRLOG("Opal not supported\n"); 343 return -ENOTSUP; 344 } 345 346 opal_bdev = calloc(1, sizeof(struct opal_vbdev)); 347 if (!opal_bdev) { 348 SPDK_ERRLOG("allocation for opal_bdev failed\n"); 349 return -ENOMEM; 350 } 351 352 opal_bdev->locking_range_id = locking_range_id; 353 opal_bdev->range_start = range_start; 354 opal_bdev->range_length = range_length; 355 356 opal_bdev->nvme_ctrlr = nvme_ctrlr; 357 opal_bdev->opal_dev = nvme_ctrlr->opal_dev; 358 359 nvme_bdev = TAILQ_FIRST(&nvme_ctrlr->namespaces[nsid - 1]->bdevs); 360 assert(nvme_bdev != NULL); 361 base_bdev_name = nvme_bdev->disk.name; 362 363 /* traverse base list to see if part_base is already create for this base bdev */ 364 TAILQ_FOREACH(opal_part_base, &g_opal_base, tailq) { 365 if (!strcmp(spdk_bdev_part_base_get_bdev_name(opal_part_base->part_base), base_bdev_name)) { 366 break; 367 } 368 } 369 370 /* If there is not a corresponding opal_part_base, a new opal_part_base will be created. 371 For each new part_base, there will be one tailq to store all the parts of this base */ 372 if (opal_part_base == NULL) { 373 opal_part_base = calloc(1, sizeof(*opal_part_base)); 374 if (opal_part_base == NULL) { 375 SPDK_ERRLOG("Could not allocate opal_part_base\n"); 376 free(opal_bdev); 377 return -ENOMEM; 378 } 379 TAILQ_INIT(&opal_part_base->part_tailq); 380 381 opal_part_base->part_base = spdk_bdev_part_base_construct(spdk_bdev_get_by_name(base_bdev_name), 382 vbdev_opal_base_bdev_hotremove_cb, &opal_if, 383 &opal_vbdev_fn_table, &opal_part_base->part_tailq, vbdev_opal_base_free, 384 opal_part_base, sizeof(struct vbdev_opal_channel), NULL, NULL); 385 if (opal_part_base->part_base == NULL) { 386 SPDK_ERRLOG("Could not allocate part_base\n"); 387 free(opal_bdev); 388 free(opal_part_base); 389 return -ENOMEM; 390 } 391 opal_part_base->nvme_ctrlr_name = strdup(nvme_ctrlr_name); 392 if (opal_part_base->nvme_ctrlr_name == NULL) { 393 free(opal_bdev); 394 spdk_bdev_part_base_free(opal_part_base->part_base); 395 return -ENOMEM; 396 } 397 398 TAILQ_INSERT_TAIL(&g_opal_base, opal_part_base, tailq); 399 } 400 assert(opal_part_base != NULL); 401 opal_bdev->opal_base = opal_part_base; 402 403 part_bdev = calloc(1, sizeof(struct spdk_bdev_part)); 404 if (!part_bdev) { 405 SPDK_ERRLOG("Could not allocate part_bdev\n"); 406 free(opal_bdev); 407 return -ENOMEM; 408 } 409 410 TAILQ_INSERT_TAIL(&g_opal_vbdev, opal_bdev, tailq); 411 opal_vbdev_name = spdk_sprintf_alloc("%sr%" PRIu8, base_bdev_name, 412 opal_bdev->locking_range_id); /* e.g.: nvme0n1r1 */ 413 if (opal_vbdev_name == NULL) { 414 SPDK_ERRLOG("Could not allocate opal_vbdev_name\n"); 415 rc = -ENOMEM; 416 goto err; 417 } 418 419 opal_bdev->name = opal_vbdev_name; 420 rc = spdk_opal_cmd_setup_locking_range(opal_bdev->opal_dev, OPAL_ADMIN1, 421 opal_bdev->locking_range_id, opal_bdev->range_start, 422 opal_bdev->range_length, password); 423 if (rc) { 424 SPDK_ERRLOG("Error construct %s\n", opal_vbdev_name); 425 goto err; 426 } 427 428 rc = spdk_bdev_part_construct(part_bdev, opal_bdev->opal_base->part_base, opal_vbdev_name, 429 opal_bdev->range_start, opal_bdev->range_length, "Opal locking range"); 430 if (rc) { 431 SPDK_ERRLOG("Could not allocate bdev part\n"); 432 goto err; 433 } 434 435 /* lock this bdev initially */ 436 rc = spdk_opal_cmd_lock_unlock(opal_bdev->opal_dev, OPAL_ADMIN1, OPAL_RWLOCK, locking_range_id, 437 password); 438 if (rc) { 439 SPDK_ERRLOG("Error lock %s\n", opal_vbdev_name); 440 goto err; 441 } 442 443 opal_bdev->bdev_part = part_bdev; 444 return 0; 445 446 err: 447 vbdev_opal_delete(opal_bdev); 448 free(part_bdev); 449 return rc; 450 } 451 452 static void 453 vbdev_opal_destruct_bdev(struct opal_vbdev *opal_bdev) 454 { 455 struct spdk_bdev_part *part = opal_bdev->bdev_part; 456 457 assert(opal_bdev->opal_base != NULL); 458 assert(part != NULL); 459 460 if (opal_bdev->range_start == spdk_bdev_part_get_offset_blocks(part)) { 461 spdk_bdev_unregister(spdk_bdev_part_get_bdev(part), NULL, NULL); 462 } 463 vbdev_opal_delete(opal_bdev); 464 } 465 466 int 467 vbdev_opal_destruct(const char *bdev_name, const char *password) 468 { 469 struct nvme_bdev_ctrlr *nvme_ctrlr; 470 int locking_range_id; 471 int rc; 472 struct opal_vbdev *opal_bdev; 473 474 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 475 if (strcmp(opal_bdev->name, bdev_name) == 0) { 476 break; 477 } 478 } 479 480 if (opal_bdev == NULL) { 481 SPDK_ERRLOG("%s not found\n", bdev_name); 482 rc = -ENODEV; 483 goto err; 484 } 485 486 locking_range_id = opal_bdev->locking_range_id; 487 488 nvme_ctrlr = opal_bdev->nvme_ctrlr; 489 if (nvme_ctrlr == NULL) { 490 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", bdev_name); 491 return -ENODEV; 492 } 493 494 /* secure erase locking range */ 495 rc = spdk_opal_cmd_secure_erase_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 496 password); 497 if (rc) { 498 SPDK_ERRLOG("opal erase locking range failed\n"); 499 goto err; 500 } 501 502 /* reset the locking range to 0 */ 503 rc = spdk_opal_cmd_setup_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 0, 504 0, password); 505 if (rc) { 506 SPDK_ERRLOG("opal reset locking range failed\n"); 507 goto err; 508 } 509 510 spdk_opal_free_locking_range_info(opal_bdev->opal_dev, locking_range_id); 511 vbdev_opal_destruct_bdev(opal_bdev); 512 return 0; 513 514 err: 515 return rc; 516 } 517 518 static void 519 vbdev_opal_examine(struct spdk_bdev *bdev) 520 { 521 /* TODO */ 522 spdk_bdev_module_examine_done(&opal_if); 523 } 524 525 int 526 vbdev_opal_set_lock_state(const char *bdev_name, uint16_t user_id, const char *password, 527 const char *lock_state) 528 { 529 struct nvme_bdev_ctrlr *nvme_ctrlr; 530 int locking_range_id; 531 int rc; 532 enum spdk_opal_lock_state state_flag; 533 struct opal_vbdev *opal_bdev; 534 535 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 536 if (strcmp(opal_bdev->name, bdev_name) == 0) { 537 break; 538 } 539 } 540 541 if (opal_bdev == NULL) { 542 SPDK_ERRLOG("%s not found\n", bdev_name); 543 return -ENODEV; 544 } 545 546 nvme_ctrlr = opal_bdev->nvme_ctrlr; 547 if (nvme_ctrlr == NULL) { 548 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 549 return -ENODEV; 550 } 551 552 if (strcasecmp(lock_state, "READWRITE") == 0) { 553 state_flag = OPAL_READWRITE; 554 } else if (strcasecmp(lock_state, "READONLY") == 0) { 555 state_flag = OPAL_READONLY; 556 } else if (strcasecmp(lock_state, "RWLOCK") == 0) { 557 state_flag = OPAL_RWLOCK; 558 } else { 559 SPDK_ERRLOG("Invalid OPAL lock state input\n"); 560 return -EINVAL; 561 } 562 563 locking_range_id = opal_bdev->locking_range_id; 564 rc = spdk_opal_cmd_lock_unlock(nvme_ctrlr->opal_dev, user_id, state_flag, locking_range_id, 565 password); 566 if (rc) { 567 SPDK_ERRLOG("%s lock/unlock failure: %d\n", bdev_name, rc); 568 } 569 570 return rc; 571 } 572 573 int 574 vbdev_opal_enable_new_user(const char *bdev_name, const char *admin_password, uint16_t user_id, 575 const char *user_password) 576 { 577 struct nvme_bdev_ctrlr *nvme_ctrlr; 578 int locking_range_id; 579 int rc; 580 struct opal_vbdev *opal_bdev; 581 582 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 583 if (strcmp(opal_bdev->name, bdev_name) == 0) { 584 break; 585 } 586 } 587 588 if (opal_bdev == NULL) { 589 SPDK_ERRLOG("%s not found\n", bdev_name); 590 return -ENODEV; 591 } 592 593 nvme_ctrlr = opal_bdev->nvme_ctrlr; 594 if (nvme_ctrlr == NULL) { 595 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 596 return -ENODEV; 597 } 598 599 rc = spdk_opal_cmd_enable_user(nvme_ctrlr->opal_dev, user_id, admin_password); 600 if (rc) { 601 SPDK_ERRLOG("%s enable user error: %d\n", bdev_name, rc); 602 return rc; 603 } 604 605 rc = spdk_opal_cmd_set_new_passwd(nvme_ctrlr->opal_dev, user_id, user_password, admin_password, 606 true); 607 if (rc) { 608 SPDK_ERRLOG("%s set user password error: %d\n", bdev_name, rc); 609 return rc; 610 } 611 612 locking_range_id = opal_bdev->locking_range_id; 613 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 614 OPAL_READONLY, admin_password); 615 if (rc) { 616 SPDK_ERRLOG("%s add user READONLY priority error: %d\n", bdev_name, rc); 617 return rc; 618 } 619 620 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 621 OPAL_READWRITE, admin_password); 622 if (rc) { 623 SPDK_ERRLOG("%s add user READWRITE priority error: %d\n", bdev_name, rc); 624 return rc; 625 } 626 627 return 0; 628 } 629 630 SPDK_LOG_REGISTER_COMPONENT("vbdev_opal", SPDK_LOG_VBDEV_OPAL) 631