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/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(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 assert(nsid <= nvme_ctrlr->num_ns); 360 nvme_bdev = nvme_bdev_ns_to_bdev(nvme_ctrlr->namespaces[nsid - 1]); 361 assert(nvme_bdev != NULL); 362 base_bdev_name = nvme_bdev->disk.name; 363 364 /* traverse base list to see if part_base is already create for this base bdev */ 365 TAILQ_FOREACH(opal_part_base, &g_opal_base, tailq) { 366 if (!strcmp(spdk_bdev_part_base_get_bdev_name(opal_part_base->part_base), base_bdev_name)) { 367 break; 368 } 369 } 370 371 /* If there is not a corresponding opal_part_base, a new opal_part_base will be created. 372 For each new part_base, there will be one tailq to store all the parts of this base */ 373 if (opal_part_base == NULL) { 374 opal_part_base = calloc(1, sizeof(*opal_part_base)); 375 if (opal_part_base == NULL) { 376 SPDK_ERRLOG("Could not allocate opal_part_base\n"); 377 free(opal_bdev); 378 return -ENOMEM; 379 } 380 TAILQ_INIT(&opal_part_base->part_tailq); 381 382 rc = spdk_bdev_part_base_construct_ext(base_bdev_name, 383 vbdev_opal_base_bdev_hotremove_cb, &opal_if, 384 &opal_vbdev_fn_table, &opal_part_base->part_tailq, 385 vbdev_opal_base_free, opal_part_base, 386 sizeof(struct vbdev_opal_channel), NULL, NULL, 387 &opal_part_base->part_base); 388 if (rc != 0) { 389 if (rc != -ENODEV) { 390 SPDK_ERRLOG("Could not allocate part_base\n"); 391 } 392 free(opal_bdev); 393 free(opal_part_base); 394 return rc; 395 } 396 opal_part_base->nvme_ctrlr_name = strdup(nvme_ctrlr_name); 397 if (opal_part_base->nvme_ctrlr_name == NULL) { 398 free(opal_bdev); 399 spdk_bdev_part_base_free(opal_part_base->part_base); 400 return -ENOMEM; 401 } 402 403 TAILQ_INSERT_TAIL(&g_opal_base, opal_part_base, tailq); 404 } 405 assert(opal_part_base != NULL); 406 opal_bdev->opal_base = opal_part_base; 407 408 part_bdev = calloc(1, sizeof(struct spdk_bdev_part)); 409 if (!part_bdev) { 410 SPDK_ERRLOG("Could not allocate part_bdev\n"); 411 free(opal_bdev); 412 return -ENOMEM; 413 } 414 415 TAILQ_INSERT_TAIL(&g_opal_vbdev, opal_bdev, tailq); 416 opal_vbdev_name = spdk_sprintf_alloc("%sr%" PRIu8, base_bdev_name, 417 opal_bdev->locking_range_id); /* e.g.: nvme0n1r1 */ 418 if (opal_vbdev_name == NULL) { 419 SPDK_ERRLOG("Could not allocate opal_vbdev_name\n"); 420 rc = -ENOMEM; 421 goto err; 422 } 423 424 opal_bdev->name = opal_vbdev_name; 425 rc = spdk_opal_cmd_setup_locking_range(opal_bdev->opal_dev, OPAL_ADMIN1, 426 opal_bdev->locking_range_id, opal_bdev->range_start, 427 opal_bdev->range_length, password); 428 if (rc) { 429 SPDK_ERRLOG("Error construct %s\n", opal_vbdev_name); 430 goto err; 431 } 432 433 rc = spdk_bdev_part_construct(part_bdev, opal_bdev->opal_base->part_base, opal_vbdev_name, 434 opal_bdev->range_start, opal_bdev->range_length, "Opal locking range"); 435 if (rc) { 436 SPDK_ERRLOG("Could not allocate bdev part\n"); 437 goto err; 438 } 439 440 /* lock this bdev initially */ 441 rc = spdk_opal_cmd_lock_unlock(opal_bdev->opal_dev, OPAL_ADMIN1, OPAL_RWLOCK, locking_range_id, 442 password); 443 if (rc) { 444 SPDK_ERRLOG("Error lock %s\n", opal_vbdev_name); 445 goto err; 446 } 447 448 opal_bdev->bdev_part = part_bdev; 449 return 0; 450 451 err: 452 vbdev_opal_delete(opal_bdev); 453 free(part_bdev); 454 return rc; 455 } 456 457 static void 458 vbdev_opal_destruct_bdev(struct opal_vbdev *opal_bdev) 459 { 460 struct spdk_bdev_part *part = opal_bdev->bdev_part; 461 462 assert(opal_bdev->opal_base != NULL); 463 assert(part != NULL); 464 465 if (opal_bdev->range_start == spdk_bdev_part_get_offset_blocks(part)) { 466 spdk_bdev_unregister(spdk_bdev_part_get_bdev(part), NULL, NULL); 467 } 468 vbdev_opal_delete(opal_bdev); 469 } 470 471 int 472 vbdev_opal_destruct(const char *bdev_name, const char *password) 473 { 474 struct nvme_bdev_ctrlr *nvme_ctrlr; 475 int locking_range_id; 476 int rc; 477 struct opal_vbdev *opal_bdev; 478 479 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 480 if (strcmp(opal_bdev->name, bdev_name) == 0) { 481 break; 482 } 483 } 484 485 if (opal_bdev == NULL) { 486 SPDK_ERRLOG("%s not found\n", bdev_name); 487 rc = -ENODEV; 488 goto err; 489 } 490 491 locking_range_id = opal_bdev->locking_range_id; 492 493 nvme_ctrlr = opal_bdev->nvme_ctrlr; 494 if (nvme_ctrlr == NULL) { 495 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", bdev_name); 496 return -ENODEV; 497 } 498 499 /* secure erase locking range */ 500 rc = spdk_opal_cmd_secure_erase_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 501 password); 502 if (rc) { 503 SPDK_ERRLOG("opal erase locking range failed\n"); 504 goto err; 505 } 506 507 /* reset the locking range to 0 */ 508 rc = spdk_opal_cmd_setup_locking_range(nvme_ctrlr->opal_dev, OPAL_ADMIN1, locking_range_id, 0, 509 0, password); 510 if (rc) { 511 SPDK_ERRLOG("opal reset locking range failed\n"); 512 goto err; 513 } 514 515 spdk_opal_free_locking_range_info(opal_bdev->opal_dev, locking_range_id); 516 vbdev_opal_destruct_bdev(opal_bdev); 517 return 0; 518 519 err: 520 return rc; 521 } 522 523 static void 524 vbdev_opal_examine(struct spdk_bdev *bdev) 525 { 526 /* TODO */ 527 spdk_bdev_module_examine_done(&opal_if); 528 } 529 530 int 531 vbdev_opal_set_lock_state(const char *bdev_name, uint16_t user_id, const char *password, 532 const char *lock_state) 533 { 534 struct nvme_bdev_ctrlr *nvme_ctrlr; 535 int locking_range_id; 536 int rc; 537 enum spdk_opal_lock_state state_flag; 538 struct opal_vbdev *opal_bdev; 539 540 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 541 if (strcmp(opal_bdev->name, bdev_name) == 0) { 542 break; 543 } 544 } 545 546 if (opal_bdev == NULL) { 547 SPDK_ERRLOG("%s not found\n", bdev_name); 548 return -ENODEV; 549 } 550 551 nvme_ctrlr = opal_bdev->nvme_ctrlr; 552 if (nvme_ctrlr == NULL) { 553 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 554 return -ENODEV; 555 } 556 557 if (strcasecmp(lock_state, "READWRITE") == 0) { 558 state_flag = OPAL_READWRITE; 559 } else if (strcasecmp(lock_state, "READONLY") == 0) { 560 state_flag = OPAL_READONLY; 561 } else if (strcasecmp(lock_state, "RWLOCK") == 0) { 562 state_flag = OPAL_RWLOCK; 563 } else { 564 SPDK_ERRLOG("Invalid OPAL lock state input\n"); 565 return -EINVAL; 566 } 567 568 locking_range_id = opal_bdev->locking_range_id; 569 rc = spdk_opal_cmd_lock_unlock(nvme_ctrlr->opal_dev, user_id, state_flag, locking_range_id, 570 password); 571 if (rc) { 572 SPDK_ERRLOG("%s lock/unlock failure: %d\n", bdev_name, rc); 573 } 574 575 return rc; 576 } 577 578 int 579 vbdev_opal_enable_new_user(const char *bdev_name, const char *admin_password, uint16_t user_id, 580 const char *user_password) 581 { 582 struct nvme_bdev_ctrlr *nvme_ctrlr; 583 int locking_range_id; 584 int rc; 585 struct opal_vbdev *opal_bdev; 586 587 TAILQ_FOREACH(opal_bdev, &g_opal_vbdev, tailq) { 588 if (strcmp(opal_bdev->name, bdev_name) == 0) { 589 break; 590 } 591 } 592 593 if (opal_bdev == NULL) { 594 SPDK_ERRLOG("%s not found\n", bdev_name); 595 return -ENODEV; 596 } 597 598 nvme_ctrlr = opal_bdev->nvme_ctrlr; 599 if (nvme_ctrlr == NULL) { 600 SPDK_ERRLOG("can't find nvme_ctrlr of %s\n", opal_bdev->name); 601 return -ENODEV; 602 } 603 604 rc = spdk_opal_cmd_enable_user(nvme_ctrlr->opal_dev, user_id, admin_password); 605 if (rc) { 606 SPDK_ERRLOG("%s enable user error: %d\n", bdev_name, rc); 607 return rc; 608 } 609 610 rc = spdk_opal_cmd_set_new_passwd(nvme_ctrlr->opal_dev, user_id, user_password, admin_password, 611 true); 612 if (rc) { 613 SPDK_ERRLOG("%s set user password error: %d\n", bdev_name, rc); 614 return rc; 615 } 616 617 locking_range_id = opal_bdev->locking_range_id; 618 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 619 OPAL_READONLY, admin_password); 620 if (rc) { 621 SPDK_ERRLOG("%s add user READONLY priority error: %d\n", bdev_name, rc); 622 return rc; 623 } 624 625 rc = spdk_opal_cmd_add_user_to_locking_range(nvme_ctrlr->opal_dev, user_id, locking_range_id, 626 OPAL_READWRITE, admin_password); 627 if (rc) { 628 SPDK_ERRLOG("%s add user READWRITE priority error: %d\n", bdev_name, rc); 629 return rc; 630 } 631 632 return 0; 633 } 634 635 SPDK_LOG_REGISTER_COMPONENT(vbdev_opal) 636