1 /******************************************************************************* 2 * Filename: target_core_pr.c 3 * 4 * This file contains SPC-3 compliant persistent reservations and 5 * legacy SPC-2 reservations with compatible reservation handling (CRH=1) 6 * 7 * (c) Copyright 2009-2013 Datera, Inc. 8 * 9 * Nicholas A. Bellinger <nab@kernel.org> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 24 * 25 ******************************************************************************/ 26 27 #include <linux/slab.h> 28 #include <linux/spinlock.h> 29 #include <linux/list.h> 30 #include <linux/file.h> 31 #include <scsi/scsi.h> 32 #include <scsi/scsi_cmnd.h> 33 #include <asm/unaligned.h> 34 35 #include <target/target_core_base.h> 36 #include <target/target_core_backend.h> 37 #include <target/target_core_fabric.h> 38 #include <target/target_core_configfs.h> 39 40 #include "target_core_internal.h" 41 #include "target_core_pr.h" 42 #include "target_core_ua.h" 43 44 /* 45 * Used for Specify Initiator Ports Capable Bit (SPEC_I_PT) 46 */ 47 struct pr_transport_id_holder { 48 int dest_local_nexus; 49 struct t10_pr_registration *dest_pr_reg; 50 struct se_portal_group *dest_tpg; 51 struct se_node_acl *dest_node_acl; 52 struct se_dev_entry *dest_se_deve; 53 struct list_head dest_list; 54 }; 55 56 void core_pr_dump_initiator_port( 57 struct t10_pr_registration *pr_reg, 58 char *buf, 59 u32 size) 60 { 61 if (!pr_reg->isid_present_at_reg) 62 buf[0] = '\0'; 63 64 snprintf(buf, size, ",i,0x%s", pr_reg->pr_reg_isid); 65 } 66 67 enum register_type { 68 REGISTER, 69 REGISTER_AND_IGNORE_EXISTING_KEY, 70 REGISTER_AND_MOVE, 71 }; 72 73 enum preempt_type { 74 PREEMPT, 75 PREEMPT_AND_ABORT, 76 }; 77 78 static void __core_scsi3_complete_pro_release(struct se_device *, struct se_node_acl *, 79 struct t10_pr_registration *, int); 80 81 static sense_reason_t 82 target_scsi2_reservation_check(struct se_cmd *cmd) 83 { 84 struct se_device *dev = cmd->se_dev; 85 struct se_session *sess = cmd->se_sess; 86 87 switch (cmd->t_task_cdb[0]) { 88 case INQUIRY: 89 case RELEASE: 90 case RELEASE_10: 91 return 0; 92 default: 93 break; 94 } 95 96 if (!dev->dev_reserved_node_acl || !sess) 97 return 0; 98 99 if (dev->dev_reserved_node_acl != sess->se_node_acl) 100 return TCM_RESERVATION_CONFLICT; 101 102 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS_WITH_ISID) { 103 if (dev->dev_res_bin_isid != sess->sess_bin_isid) 104 return TCM_RESERVATION_CONFLICT; 105 } 106 107 return 0; 108 } 109 110 static struct t10_pr_registration *core_scsi3_locate_pr_reg(struct se_device *, 111 struct se_node_acl *, struct se_session *); 112 static void core_scsi3_put_pr_reg(struct t10_pr_registration *); 113 114 static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd) 115 { 116 struct se_session *se_sess = cmd->se_sess; 117 struct se_device *dev = cmd->se_dev; 118 struct t10_pr_registration *pr_reg; 119 struct t10_reservation *pr_tmpl = &dev->t10_pr; 120 int conflict = 0; 121 122 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl, 123 se_sess); 124 if (pr_reg) { 125 /* 126 * From spc4r17 5.7.3 Exceptions to SPC-2 RESERVE and RELEASE 127 * behavior 128 * 129 * A RESERVE(6) or RESERVE(10) command shall complete with GOOD 130 * status, but no reservation shall be established and the 131 * persistent reservation shall not be changed, if the command 132 * is received from a) and b) below. 133 * 134 * A RELEASE(6) or RELEASE(10) command shall complete with GOOD 135 * status, but the persistent reservation shall not be released, 136 * if the command is received from a) and b) 137 * 138 * a) An I_T nexus that is a persistent reservation holder; or 139 * b) An I_T nexus that is registered if a registrants only or 140 * all registrants type persistent reservation is present. 141 * 142 * In all other cases, a RESERVE(6) command, RESERVE(10) command, 143 * RELEASE(6) command, or RELEASE(10) command shall be processed 144 * as defined in SPC-2. 145 */ 146 if (pr_reg->pr_res_holder) { 147 core_scsi3_put_pr_reg(pr_reg); 148 return 1; 149 } 150 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY) || 151 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY) || 152 (pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) || 153 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) { 154 core_scsi3_put_pr_reg(pr_reg); 155 return 1; 156 } 157 core_scsi3_put_pr_reg(pr_reg); 158 conflict = 1; 159 } else { 160 /* 161 * Following spc2r20 5.5.1 Reservations overview: 162 * 163 * If a logical unit has executed a PERSISTENT RESERVE OUT 164 * command with the REGISTER or the REGISTER AND IGNORE 165 * EXISTING KEY service action and is still registered by any 166 * initiator, all RESERVE commands and all RELEASE commands 167 * regardless of initiator shall conflict and shall terminate 168 * with a RESERVATION CONFLICT status. 169 */ 170 spin_lock(&pr_tmpl->registration_lock); 171 conflict = (list_empty(&pr_tmpl->registration_list)) ? 0 : 1; 172 spin_unlock(&pr_tmpl->registration_lock); 173 } 174 175 if (conflict) { 176 pr_err("Received legacy SPC-2 RESERVE/RELEASE" 177 " while active SPC-3 registrations exist," 178 " returning RESERVATION_CONFLICT\n"); 179 return -EBUSY; 180 } 181 182 return 0; 183 } 184 185 sense_reason_t 186 target_scsi2_reservation_release(struct se_cmd *cmd) 187 { 188 struct se_device *dev = cmd->se_dev; 189 struct se_session *sess = cmd->se_sess; 190 struct se_portal_group *tpg; 191 int rc; 192 193 if (!sess || !sess->se_tpg) 194 goto out; 195 rc = target_check_scsi2_reservation_conflict(cmd); 196 if (rc == 1) 197 goto out; 198 if (rc < 0) 199 return TCM_RESERVATION_CONFLICT; 200 201 spin_lock(&dev->dev_reservation_lock); 202 if (!dev->dev_reserved_node_acl || !sess) 203 goto out_unlock; 204 205 if (dev->dev_reserved_node_acl != sess->se_node_acl) 206 goto out_unlock; 207 208 if (dev->dev_res_bin_isid != sess->sess_bin_isid) 209 goto out_unlock; 210 211 dev->dev_reserved_node_acl = NULL; 212 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS; 213 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS_WITH_ISID) { 214 dev->dev_res_bin_isid = 0; 215 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS_WITH_ISID; 216 } 217 tpg = sess->se_tpg; 218 pr_debug("SCSI-2 Released reservation for %s LUN: %u ->" 219 " MAPPED LUN: %u for %s\n", tpg->se_tpg_tfo->get_fabric_name(), 220 cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun, 221 sess->se_node_acl->initiatorname); 222 223 out_unlock: 224 spin_unlock(&dev->dev_reservation_lock); 225 out: 226 target_complete_cmd(cmd, GOOD); 227 return 0; 228 } 229 230 sense_reason_t 231 target_scsi2_reservation_reserve(struct se_cmd *cmd) 232 { 233 struct se_device *dev = cmd->se_dev; 234 struct se_session *sess = cmd->se_sess; 235 struct se_portal_group *tpg; 236 sense_reason_t ret = 0; 237 int rc; 238 239 if ((cmd->t_task_cdb[1] & 0x01) && 240 (cmd->t_task_cdb[1] & 0x02)) { 241 pr_err("LongIO and Obselete Bits set, returning" 242 " ILLEGAL_REQUEST\n"); 243 return TCM_UNSUPPORTED_SCSI_OPCODE; 244 } 245 /* 246 * This is currently the case for target_core_mod passthrough struct se_cmd 247 * ops 248 */ 249 if (!sess || !sess->se_tpg) 250 goto out; 251 rc = target_check_scsi2_reservation_conflict(cmd); 252 if (rc == 1) 253 goto out; 254 255 if (rc < 0) 256 return TCM_RESERVATION_CONFLICT; 257 258 tpg = sess->se_tpg; 259 spin_lock(&dev->dev_reservation_lock); 260 if (dev->dev_reserved_node_acl && 261 (dev->dev_reserved_node_acl != sess->se_node_acl)) { 262 pr_err("SCSI-2 RESERVATION CONFLIFT for %s fabric\n", 263 tpg->se_tpg_tfo->get_fabric_name()); 264 pr_err("Original reserver LUN: %u %s\n", 265 cmd->se_lun->unpacked_lun, 266 dev->dev_reserved_node_acl->initiatorname); 267 pr_err("Current attempt - LUN: %u -> MAPPED LUN: %u" 268 " from %s \n", cmd->se_lun->unpacked_lun, 269 cmd->se_deve->mapped_lun, 270 sess->se_node_acl->initiatorname); 271 ret = TCM_RESERVATION_CONFLICT; 272 goto out_unlock; 273 } 274 275 dev->dev_reserved_node_acl = sess->se_node_acl; 276 dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS; 277 if (sess->sess_bin_isid != 0) { 278 dev->dev_res_bin_isid = sess->sess_bin_isid; 279 dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS_WITH_ISID; 280 } 281 pr_debug("SCSI-2 Reserved %s LUN: %u -> MAPPED LUN: %u" 282 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(), 283 cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun, 284 sess->se_node_acl->initiatorname); 285 286 out_unlock: 287 spin_unlock(&dev->dev_reservation_lock); 288 out: 289 if (!ret) 290 target_complete_cmd(cmd, GOOD); 291 return ret; 292 } 293 294 295 /* 296 * Begin SPC-3/SPC-4 Persistent Reservations emulation support 297 * 298 * This function is called by those initiator ports who are *NOT* 299 * the active PR reservation holder when a reservation is present. 300 */ 301 static int core_scsi3_pr_seq_non_holder( 302 struct se_cmd *cmd, 303 u32 pr_reg_type) 304 { 305 unsigned char *cdb = cmd->t_task_cdb; 306 struct se_dev_entry *se_deve; 307 struct se_session *se_sess = cmd->se_sess; 308 int other_cdb = 0, ignore_reg; 309 int registered_nexus = 0, ret = 1; /* Conflict by default */ 310 int all_reg = 0, reg_only = 0; /* ALL_REG, REG_ONLY */ 311 int we = 0; /* Write Exclusive */ 312 int legacy = 0; /* Act like a legacy device and return 313 * RESERVATION CONFLICT on some CDBs */ 314 315 se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun]; 316 /* 317 * Determine if the registration should be ignored due to 318 * non-matching ISIDs in target_scsi3_pr_reservation_check(). 319 */ 320 ignore_reg = (pr_reg_type & 0x80000000); 321 if (ignore_reg) 322 pr_reg_type &= ~0x80000000; 323 324 switch (pr_reg_type) { 325 case PR_TYPE_WRITE_EXCLUSIVE: 326 we = 1; 327 case PR_TYPE_EXCLUSIVE_ACCESS: 328 /* 329 * Some commands are only allowed for the persistent reservation 330 * holder. 331 */ 332 if ((se_deve->def_pr_registered) && !(ignore_reg)) 333 registered_nexus = 1; 334 break; 335 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY: 336 we = 1; 337 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY: 338 /* 339 * Some commands are only allowed for registered I_T Nexuses. 340 */ 341 reg_only = 1; 342 if ((se_deve->def_pr_registered) && !(ignore_reg)) 343 registered_nexus = 1; 344 break; 345 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG: 346 we = 1; 347 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG: 348 /* 349 * Each registered I_T Nexus is a reservation holder. 350 */ 351 all_reg = 1; 352 if ((se_deve->def_pr_registered) && !(ignore_reg)) 353 registered_nexus = 1; 354 break; 355 default: 356 return -EINVAL; 357 } 358 /* 359 * Referenced from spc4r17 table 45 for *NON* PR holder access 360 */ 361 switch (cdb[0]) { 362 case SECURITY_PROTOCOL_IN: 363 if (registered_nexus) 364 return 0; 365 ret = (we) ? 0 : 1; 366 break; 367 case MODE_SENSE: 368 case MODE_SENSE_10: 369 case READ_ATTRIBUTE: 370 case READ_BUFFER: 371 case RECEIVE_DIAGNOSTIC: 372 if (legacy) { 373 ret = 1; 374 break; 375 } 376 if (registered_nexus) { 377 ret = 0; 378 break; 379 } 380 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */ 381 break; 382 case PERSISTENT_RESERVE_OUT: 383 /* 384 * This follows PERSISTENT_RESERVE_OUT service actions that 385 * are allowed in the presence of various reservations. 386 * See spc4r17, table 46 387 */ 388 switch (cdb[1] & 0x1f) { 389 case PRO_CLEAR: 390 case PRO_PREEMPT: 391 case PRO_PREEMPT_AND_ABORT: 392 ret = (registered_nexus) ? 0 : 1; 393 break; 394 case PRO_REGISTER: 395 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY: 396 ret = 0; 397 break; 398 case PRO_REGISTER_AND_MOVE: 399 case PRO_RESERVE: 400 ret = 1; 401 break; 402 case PRO_RELEASE: 403 ret = (registered_nexus) ? 0 : 1; 404 break; 405 default: 406 pr_err("Unknown PERSISTENT_RESERVE_OUT service" 407 " action: 0x%02x\n", cdb[1] & 0x1f); 408 return -EINVAL; 409 } 410 break; 411 case RELEASE: 412 case RELEASE_10: 413 /* Handled by CRH=1 in target_scsi2_reservation_release() */ 414 ret = 0; 415 break; 416 case RESERVE: 417 case RESERVE_10: 418 /* Handled by CRH=1 in target_scsi2_reservation_reserve() */ 419 ret = 0; 420 break; 421 case TEST_UNIT_READY: 422 ret = (legacy) ? 1 : 0; /* Conflict for legacy */ 423 break; 424 case MAINTENANCE_IN: 425 switch (cdb[1] & 0x1f) { 426 case MI_MANAGEMENT_PROTOCOL_IN: 427 if (registered_nexus) { 428 ret = 0; 429 break; 430 } 431 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */ 432 break; 433 case MI_REPORT_SUPPORTED_OPERATION_CODES: 434 case MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS: 435 if (legacy) { 436 ret = 1; 437 break; 438 } 439 if (registered_nexus) { 440 ret = 0; 441 break; 442 } 443 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */ 444 break; 445 case MI_REPORT_ALIASES: 446 case MI_REPORT_IDENTIFYING_INFORMATION: 447 case MI_REPORT_PRIORITY: 448 case MI_REPORT_TARGET_PGS: 449 case MI_REPORT_TIMESTAMP: 450 ret = 0; /* Allowed */ 451 break; 452 default: 453 pr_err("Unknown MI Service Action: 0x%02x\n", 454 (cdb[1] & 0x1f)); 455 return -EINVAL; 456 } 457 break; 458 case ACCESS_CONTROL_IN: 459 case ACCESS_CONTROL_OUT: 460 case INQUIRY: 461 case LOG_SENSE: 462 case READ_MEDIA_SERIAL_NUMBER: 463 case REPORT_LUNS: 464 case REQUEST_SENSE: 465 case PERSISTENT_RESERVE_IN: 466 ret = 0; /*/ Allowed CDBs */ 467 break; 468 default: 469 other_cdb = 1; 470 break; 471 } 472 /* 473 * Case where the CDB is explicitly allowed in the above switch 474 * statement. 475 */ 476 if (!ret && !other_cdb) { 477 pr_debug("Allowing explicit CDB: 0x%02x for %s" 478 " reservation holder\n", cdb[0], 479 core_scsi3_pr_dump_type(pr_reg_type)); 480 481 return ret; 482 } 483 /* 484 * Check if write exclusive initiator ports *NOT* holding the 485 * WRITE_EXCLUSIVE_* reservation. 486 */ 487 if (we && !registered_nexus) { 488 if (cmd->data_direction == DMA_TO_DEVICE) { 489 /* 490 * Conflict for write exclusive 491 */ 492 pr_debug("%s Conflict for unregistered nexus" 493 " %s CDB: 0x%02x to %s reservation\n", 494 transport_dump_cmd_direction(cmd), 495 se_sess->se_node_acl->initiatorname, cdb[0], 496 core_scsi3_pr_dump_type(pr_reg_type)); 497 return 1; 498 } else { 499 /* 500 * Allow non WRITE CDBs for all Write Exclusive 501 * PR TYPEs to pass for registered and 502 * non-registered_nexuxes NOT holding the reservation. 503 * 504 * We only make noise for the unregisterd nexuses, 505 * as we expect registered non-reservation holding 506 * nexuses to issue CDBs. 507 */ 508 509 if (!registered_nexus) { 510 pr_debug("Allowing implicit CDB: 0x%02x" 511 " for %s reservation on unregistered" 512 " nexus\n", cdb[0], 513 core_scsi3_pr_dump_type(pr_reg_type)); 514 } 515 516 return 0; 517 } 518 } else if ((reg_only) || (all_reg)) { 519 if (registered_nexus) { 520 /* 521 * For PR_*_REG_ONLY and PR_*_ALL_REG reservations, 522 * allow commands from registered nexuses. 523 */ 524 525 pr_debug("Allowing implicit CDB: 0x%02x for %s" 526 " reservation\n", cdb[0], 527 core_scsi3_pr_dump_type(pr_reg_type)); 528 529 return 0; 530 } 531 } 532 pr_debug("%s Conflict for %sregistered nexus %s CDB: 0x%2x" 533 " for %s reservation\n", transport_dump_cmd_direction(cmd), 534 (registered_nexus) ? "" : "un", 535 se_sess->se_node_acl->initiatorname, cdb[0], 536 core_scsi3_pr_dump_type(pr_reg_type)); 537 538 return 1; /* Conflict by default */ 539 } 540 541 static sense_reason_t 542 target_scsi3_pr_reservation_check(struct se_cmd *cmd) 543 { 544 struct se_device *dev = cmd->se_dev; 545 struct se_session *sess = cmd->se_sess; 546 u32 pr_reg_type; 547 548 if (!dev->dev_pr_res_holder) 549 return 0; 550 551 pr_reg_type = dev->dev_pr_res_holder->pr_res_type; 552 cmd->pr_res_key = dev->dev_pr_res_holder->pr_res_key; 553 if (dev->dev_pr_res_holder->pr_reg_nacl != sess->se_node_acl) 554 goto check_nonholder; 555 556 if (dev->dev_pr_res_holder->isid_present_at_reg) { 557 if (dev->dev_pr_res_holder->pr_reg_bin_isid != 558 sess->sess_bin_isid) { 559 pr_reg_type |= 0x80000000; 560 goto check_nonholder; 561 } 562 } 563 564 return 0; 565 566 check_nonholder: 567 if (core_scsi3_pr_seq_non_holder(cmd, pr_reg_type)) 568 return TCM_RESERVATION_CONFLICT; 569 return 0; 570 } 571 572 static u32 core_scsi3_pr_generation(struct se_device *dev) 573 { 574 u32 prg; 575 576 /* 577 * PRGeneration field shall contain the value of a 32-bit wrapping 578 * counter mainted by the device server. 579 * 580 * Note that this is done regardless of Active Persist across 581 * Target PowerLoss (APTPL) 582 * 583 * See spc4r17 section 6.3.12 READ_KEYS service action 584 */ 585 spin_lock(&dev->dev_reservation_lock); 586 prg = dev->t10_pr.pr_generation++; 587 spin_unlock(&dev->dev_reservation_lock); 588 589 return prg; 590 } 591 592 static struct t10_pr_registration *__core_scsi3_do_alloc_registration( 593 struct se_device *dev, 594 struct se_node_acl *nacl, 595 struct se_dev_entry *deve, 596 unsigned char *isid, 597 u64 sa_res_key, 598 int all_tg_pt, 599 int aptpl) 600 { 601 struct t10_pr_registration *pr_reg; 602 603 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_ATOMIC); 604 if (!pr_reg) { 605 pr_err("Unable to allocate struct t10_pr_registration\n"); 606 return NULL; 607 } 608 609 INIT_LIST_HEAD(&pr_reg->pr_reg_list); 610 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list); 611 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list); 612 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list); 613 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list); 614 atomic_set(&pr_reg->pr_res_holders, 0); 615 pr_reg->pr_reg_nacl = nacl; 616 pr_reg->pr_reg_deve = deve; 617 pr_reg->pr_res_mapped_lun = deve->mapped_lun; 618 pr_reg->pr_aptpl_target_lun = deve->se_lun->unpacked_lun; 619 pr_reg->pr_res_key = sa_res_key; 620 pr_reg->pr_reg_all_tg_pt = all_tg_pt; 621 pr_reg->pr_reg_aptpl = aptpl; 622 pr_reg->pr_reg_tg_pt_lun = deve->se_lun; 623 /* 624 * If an ISID value for this SCSI Initiator Port exists, 625 * save it to the registration now. 626 */ 627 if (isid != NULL) { 628 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid); 629 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid); 630 pr_reg->isid_present_at_reg = 1; 631 } 632 633 return pr_reg; 634 } 635 636 static int core_scsi3_lunacl_depend_item(struct se_dev_entry *); 637 static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *); 638 639 /* 640 * Function used for handling PR registrations for ALL_TG_PT=1 and ALL_TG_PT=0 641 * modes. 642 */ 643 static struct t10_pr_registration *__core_scsi3_alloc_registration( 644 struct se_device *dev, 645 struct se_node_acl *nacl, 646 struct se_dev_entry *deve, 647 unsigned char *isid, 648 u64 sa_res_key, 649 int all_tg_pt, 650 int aptpl) 651 { 652 struct se_dev_entry *deve_tmp; 653 struct se_node_acl *nacl_tmp; 654 struct se_port *port, *port_tmp; 655 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo; 656 struct t10_pr_registration *pr_reg, *pr_reg_atp, *pr_reg_tmp, *pr_reg_tmp_safe; 657 int ret; 658 /* 659 * Create a registration for the I_T Nexus upon which the 660 * PROUT REGISTER was received. 661 */ 662 pr_reg = __core_scsi3_do_alloc_registration(dev, nacl, deve, isid, 663 sa_res_key, all_tg_pt, aptpl); 664 if (!pr_reg) 665 return NULL; 666 /* 667 * Return pointer to pr_reg for ALL_TG_PT=0 668 */ 669 if (!all_tg_pt) 670 return pr_reg; 671 /* 672 * Create list of matching SCSI Initiator Port registrations 673 * for ALL_TG_PT=1 674 */ 675 spin_lock(&dev->se_port_lock); 676 list_for_each_entry_safe(port, port_tmp, &dev->dev_sep_list, sep_list) { 677 atomic_inc_mb(&port->sep_tg_pt_ref_cnt); 678 spin_unlock(&dev->se_port_lock); 679 680 spin_lock_bh(&port->sep_alua_lock); 681 list_for_each_entry(deve_tmp, &port->sep_alua_list, 682 alua_port_list) { 683 /* 684 * This pointer will be NULL for demo mode MappedLUNs 685 * that have not been make explicit via a ConfigFS 686 * MappedLUN group for the SCSI Initiator Node ACL. 687 */ 688 if (!deve_tmp->se_lun_acl) 689 continue; 690 691 nacl_tmp = deve_tmp->se_lun_acl->se_lun_nacl; 692 /* 693 * Skip the matching struct se_node_acl that is allocated 694 * above.. 695 */ 696 if (nacl == nacl_tmp) 697 continue; 698 /* 699 * Only perform PR registrations for target ports on 700 * the same fabric module as the REGISTER w/ ALL_TG_PT=1 701 * arrived. 702 */ 703 if (tfo != nacl_tmp->se_tpg->se_tpg_tfo) 704 continue; 705 /* 706 * Look for a matching Initiator Node ACL in ASCII format 707 */ 708 if (strcmp(nacl->initiatorname, nacl_tmp->initiatorname)) 709 continue; 710 711 atomic_inc_mb(&deve_tmp->pr_ref_count); 712 spin_unlock_bh(&port->sep_alua_lock); 713 /* 714 * Grab a configfs group dependency that is released 715 * for the exception path at label out: below, or upon 716 * completion of adding ALL_TG_PT=1 registrations in 717 * __core_scsi3_add_registration() 718 */ 719 ret = core_scsi3_lunacl_depend_item(deve_tmp); 720 if (ret < 0) { 721 pr_err("core_scsi3_lunacl_depend" 722 "_item() failed\n"); 723 atomic_dec_mb(&port->sep_tg_pt_ref_cnt); 724 atomic_dec_mb(&deve_tmp->pr_ref_count); 725 goto out; 726 } 727 /* 728 * Located a matching SCSI Initiator Port on a different 729 * port, allocate the pr_reg_atp and attach it to the 730 * pr_reg->pr_reg_atp_list that will be processed once 731 * the original *pr_reg is processed in 732 * __core_scsi3_add_registration() 733 */ 734 pr_reg_atp = __core_scsi3_do_alloc_registration(dev, 735 nacl_tmp, deve_tmp, NULL, 736 sa_res_key, all_tg_pt, aptpl); 737 if (!pr_reg_atp) { 738 atomic_dec_mb(&port->sep_tg_pt_ref_cnt); 739 atomic_dec_mb(&deve_tmp->pr_ref_count); 740 core_scsi3_lunacl_undepend_item(deve_tmp); 741 goto out; 742 } 743 744 list_add_tail(&pr_reg_atp->pr_reg_atp_mem_list, 745 &pr_reg->pr_reg_atp_list); 746 spin_lock_bh(&port->sep_alua_lock); 747 } 748 spin_unlock_bh(&port->sep_alua_lock); 749 750 spin_lock(&dev->se_port_lock); 751 atomic_dec_mb(&port->sep_tg_pt_ref_cnt); 752 } 753 spin_unlock(&dev->se_port_lock); 754 755 return pr_reg; 756 out: 757 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe, 758 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) { 759 list_del(&pr_reg_tmp->pr_reg_atp_mem_list); 760 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve); 761 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp); 762 } 763 kmem_cache_free(t10_pr_reg_cache, pr_reg); 764 return NULL; 765 } 766 767 int core_scsi3_alloc_aptpl_registration( 768 struct t10_reservation *pr_tmpl, 769 u64 sa_res_key, 770 unsigned char *i_port, 771 unsigned char *isid, 772 u32 mapped_lun, 773 unsigned char *t_port, 774 u16 tpgt, 775 u32 target_lun, 776 int res_holder, 777 int all_tg_pt, 778 u8 type) 779 { 780 struct t10_pr_registration *pr_reg; 781 782 if (!i_port || !t_port || !sa_res_key) { 783 pr_err("Illegal parameters for APTPL registration\n"); 784 return -EINVAL; 785 } 786 787 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_KERNEL); 788 if (!pr_reg) { 789 pr_err("Unable to allocate struct t10_pr_registration\n"); 790 return -ENOMEM; 791 } 792 793 INIT_LIST_HEAD(&pr_reg->pr_reg_list); 794 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list); 795 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list); 796 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list); 797 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list); 798 atomic_set(&pr_reg->pr_res_holders, 0); 799 pr_reg->pr_reg_nacl = NULL; 800 pr_reg->pr_reg_deve = NULL; 801 pr_reg->pr_res_mapped_lun = mapped_lun; 802 pr_reg->pr_aptpl_target_lun = target_lun; 803 pr_reg->pr_res_key = sa_res_key; 804 pr_reg->pr_reg_all_tg_pt = all_tg_pt; 805 pr_reg->pr_reg_aptpl = 1; 806 pr_reg->pr_reg_tg_pt_lun = NULL; 807 pr_reg->pr_res_scope = 0; /* Always LUN_SCOPE */ 808 pr_reg->pr_res_type = type; 809 /* 810 * If an ISID value had been saved in APTPL metadata for this 811 * SCSI Initiator Port, restore it now. 812 */ 813 if (isid != NULL) { 814 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid); 815 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid); 816 pr_reg->isid_present_at_reg = 1; 817 } 818 /* 819 * Copy the i_port and t_port information from caller. 820 */ 821 snprintf(pr_reg->pr_iport, PR_APTPL_MAX_IPORT_LEN, "%s", i_port); 822 snprintf(pr_reg->pr_tport, PR_APTPL_MAX_TPORT_LEN, "%s", t_port); 823 pr_reg->pr_reg_tpgt = tpgt; 824 /* 825 * Set pr_res_holder from caller, the pr_reg who is the reservation 826 * holder will get it's pointer set in core_scsi3_aptpl_reserve() once 827 * the Initiator Node LUN ACL from the fabric module is created for 828 * this registration. 829 */ 830 pr_reg->pr_res_holder = res_holder; 831 832 list_add_tail(&pr_reg->pr_reg_aptpl_list, &pr_tmpl->aptpl_reg_list); 833 pr_debug("SPC-3 PR APTPL Successfully added registration%s from" 834 " metadata\n", (res_holder) ? "+reservation" : ""); 835 return 0; 836 } 837 838 static void core_scsi3_aptpl_reserve( 839 struct se_device *dev, 840 struct se_portal_group *tpg, 841 struct se_node_acl *node_acl, 842 struct t10_pr_registration *pr_reg) 843 { 844 char i_buf[PR_REG_ISID_ID_LEN]; 845 846 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 847 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 848 849 spin_lock(&dev->dev_reservation_lock); 850 dev->dev_pr_res_holder = pr_reg; 851 spin_unlock(&dev->dev_reservation_lock); 852 853 pr_debug("SPC-3 PR [%s] Service Action: APTPL RESERVE created" 854 " new reservation holder TYPE: %s ALL_TG_PT: %d\n", 855 tpg->se_tpg_tfo->get_fabric_name(), 856 core_scsi3_pr_dump_type(pr_reg->pr_res_type), 857 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 858 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", 859 tpg->se_tpg_tfo->get_fabric_name(), node_acl->initiatorname, 860 i_buf); 861 } 862 863 static void __core_scsi3_add_registration(struct se_device *, struct se_node_acl *, 864 struct t10_pr_registration *, enum register_type, int); 865 866 static int __core_scsi3_check_aptpl_registration( 867 struct se_device *dev, 868 struct se_portal_group *tpg, 869 struct se_lun *lun, 870 u32 target_lun, 871 struct se_node_acl *nacl, 872 struct se_dev_entry *deve) 873 { 874 struct t10_pr_registration *pr_reg, *pr_reg_tmp; 875 struct t10_reservation *pr_tmpl = &dev->t10_pr; 876 unsigned char i_port[PR_APTPL_MAX_IPORT_LEN]; 877 unsigned char t_port[PR_APTPL_MAX_TPORT_LEN]; 878 u16 tpgt; 879 880 memset(i_port, 0, PR_APTPL_MAX_IPORT_LEN); 881 memset(t_port, 0, PR_APTPL_MAX_TPORT_LEN); 882 /* 883 * Copy Initiator Port information from struct se_node_acl 884 */ 885 snprintf(i_port, PR_APTPL_MAX_IPORT_LEN, "%s", nacl->initiatorname); 886 snprintf(t_port, PR_APTPL_MAX_TPORT_LEN, "%s", 887 tpg->se_tpg_tfo->tpg_get_wwn(tpg)); 888 tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg); 889 /* 890 * Look for the matching registrations+reservation from those 891 * created from APTPL metadata. Note that multiple registrations 892 * may exist for fabrics that use ISIDs in their SCSI Initiator Port 893 * TransportIDs. 894 */ 895 spin_lock(&pr_tmpl->aptpl_reg_lock); 896 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list, 897 pr_reg_aptpl_list) { 898 899 if (!strcmp(pr_reg->pr_iport, i_port) && 900 (pr_reg->pr_res_mapped_lun == deve->mapped_lun) && 901 !(strcmp(pr_reg->pr_tport, t_port)) && 902 (pr_reg->pr_reg_tpgt == tpgt) && 903 (pr_reg->pr_aptpl_target_lun == target_lun)) { 904 905 pr_reg->pr_reg_nacl = nacl; 906 pr_reg->pr_reg_deve = deve; 907 pr_reg->pr_reg_tg_pt_lun = lun; 908 909 list_del(&pr_reg->pr_reg_aptpl_list); 910 spin_unlock(&pr_tmpl->aptpl_reg_lock); 911 /* 912 * At this point all of the pointers in *pr_reg will 913 * be setup, so go ahead and add the registration. 914 */ 915 916 __core_scsi3_add_registration(dev, nacl, pr_reg, 0, 0); 917 /* 918 * If this registration is the reservation holder, 919 * make that happen now.. 920 */ 921 if (pr_reg->pr_res_holder) 922 core_scsi3_aptpl_reserve(dev, tpg, 923 nacl, pr_reg); 924 /* 925 * Reenable pr_aptpl_active to accept new metadata 926 * updates once the SCSI device is active again.. 927 */ 928 spin_lock(&pr_tmpl->aptpl_reg_lock); 929 pr_tmpl->pr_aptpl_active = 1; 930 } 931 } 932 spin_unlock(&pr_tmpl->aptpl_reg_lock); 933 934 return 0; 935 } 936 937 int core_scsi3_check_aptpl_registration( 938 struct se_device *dev, 939 struct se_portal_group *tpg, 940 struct se_lun *lun, 941 struct se_node_acl *nacl, 942 u32 mapped_lun) 943 { 944 struct se_dev_entry *deve = nacl->device_list[mapped_lun]; 945 946 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) 947 return 0; 948 949 return __core_scsi3_check_aptpl_registration(dev, tpg, lun, 950 lun->unpacked_lun, nacl, deve); 951 } 952 953 static void __core_scsi3_dump_registration( 954 struct target_core_fabric_ops *tfo, 955 struct se_device *dev, 956 struct se_node_acl *nacl, 957 struct t10_pr_registration *pr_reg, 958 enum register_type register_type) 959 { 960 struct se_portal_group *se_tpg = nacl->se_tpg; 961 char i_buf[PR_REG_ISID_ID_LEN]; 962 963 memset(&i_buf[0], 0, PR_REG_ISID_ID_LEN); 964 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 965 966 pr_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator" 967 " Node: %s%s\n", tfo->get_fabric_name(), (register_type == REGISTER_AND_MOVE) ? 968 "_AND_MOVE" : (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ? 969 "_AND_IGNORE_EXISTING_KEY" : "", nacl->initiatorname, 970 i_buf); 971 pr_debug("SPC-3 PR [%s] registration on Target Port: %s,0x%04x\n", 972 tfo->get_fabric_name(), tfo->tpg_get_wwn(se_tpg), 973 tfo->tpg_get_tag(se_tpg)); 974 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target" 975 " Port(s)\n", tfo->get_fabric_name(), 976 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE", 977 dev->transport->name); 978 pr_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:" 979 " 0x%08x APTPL: %d\n", tfo->get_fabric_name(), 980 pr_reg->pr_res_key, pr_reg->pr_res_generation, 981 pr_reg->pr_reg_aptpl); 982 } 983 984 /* 985 * this function can be called with struct se_device->dev_reservation_lock 986 * when register_move = 1 987 */ 988 static void __core_scsi3_add_registration( 989 struct se_device *dev, 990 struct se_node_acl *nacl, 991 struct t10_pr_registration *pr_reg, 992 enum register_type register_type, 993 int register_move) 994 { 995 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo; 996 struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe; 997 struct t10_reservation *pr_tmpl = &dev->t10_pr; 998 999 /* 1000 * Increment PRgeneration counter for struct se_device upon a successful 1001 * REGISTER, see spc4r17 section 6.3.2 READ_KEYS service action 1002 * 1003 * Also, when register_move = 1 for PROUT REGISTER_AND_MOVE service 1004 * action, the struct se_device->dev_reservation_lock will already be held, 1005 * so we do not call core_scsi3_pr_generation() which grabs the lock 1006 * for the REGISTER. 1007 */ 1008 pr_reg->pr_res_generation = (register_move) ? 1009 dev->t10_pr.pr_generation++ : 1010 core_scsi3_pr_generation(dev); 1011 1012 spin_lock(&pr_tmpl->registration_lock); 1013 list_add_tail(&pr_reg->pr_reg_list, &pr_tmpl->registration_list); 1014 pr_reg->pr_reg_deve->def_pr_registered = 1; 1015 1016 __core_scsi3_dump_registration(tfo, dev, nacl, pr_reg, register_type); 1017 spin_unlock(&pr_tmpl->registration_lock); 1018 /* 1019 * Skip extra processing for ALL_TG_PT=0 or REGISTER_AND_MOVE. 1020 */ 1021 if (!pr_reg->pr_reg_all_tg_pt || register_move) 1022 return; 1023 /* 1024 * Walk pr_reg->pr_reg_atp_list and add registrations for ALL_TG_PT=1 1025 * allocated in __core_scsi3_alloc_registration() 1026 */ 1027 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe, 1028 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) { 1029 list_del(&pr_reg_tmp->pr_reg_atp_mem_list); 1030 1031 pr_reg_tmp->pr_res_generation = core_scsi3_pr_generation(dev); 1032 1033 spin_lock(&pr_tmpl->registration_lock); 1034 list_add_tail(&pr_reg_tmp->pr_reg_list, 1035 &pr_tmpl->registration_list); 1036 pr_reg_tmp->pr_reg_deve->def_pr_registered = 1; 1037 1038 __core_scsi3_dump_registration(tfo, dev, 1039 pr_reg_tmp->pr_reg_nacl, pr_reg_tmp, 1040 register_type); 1041 spin_unlock(&pr_tmpl->registration_lock); 1042 /* 1043 * Drop configfs group dependency reference from 1044 * __core_scsi3_alloc_registration() 1045 */ 1046 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve); 1047 } 1048 } 1049 1050 static int core_scsi3_alloc_registration( 1051 struct se_device *dev, 1052 struct se_node_acl *nacl, 1053 struct se_dev_entry *deve, 1054 unsigned char *isid, 1055 u64 sa_res_key, 1056 int all_tg_pt, 1057 int aptpl, 1058 enum register_type register_type, 1059 int register_move) 1060 { 1061 struct t10_pr_registration *pr_reg; 1062 1063 pr_reg = __core_scsi3_alloc_registration(dev, nacl, deve, isid, 1064 sa_res_key, all_tg_pt, aptpl); 1065 if (!pr_reg) 1066 return -EPERM; 1067 1068 __core_scsi3_add_registration(dev, nacl, pr_reg, 1069 register_type, register_move); 1070 return 0; 1071 } 1072 1073 static struct t10_pr_registration *__core_scsi3_locate_pr_reg( 1074 struct se_device *dev, 1075 struct se_node_acl *nacl, 1076 unsigned char *isid) 1077 { 1078 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1079 struct t10_pr_registration *pr_reg, *pr_reg_tmp; 1080 struct se_portal_group *tpg; 1081 1082 spin_lock(&pr_tmpl->registration_lock); 1083 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 1084 &pr_tmpl->registration_list, pr_reg_list) { 1085 /* 1086 * First look for a matching struct se_node_acl 1087 */ 1088 if (pr_reg->pr_reg_nacl != nacl) 1089 continue; 1090 1091 tpg = pr_reg->pr_reg_nacl->se_tpg; 1092 /* 1093 * If this registration does NOT contain a fabric provided 1094 * ISID, then we have found a match. 1095 */ 1096 if (!pr_reg->isid_present_at_reg) { 1097 /* 1098 * Determine if this SCSI device server requires that 1099 * SCSI Intiatior TransportID w/ ISIDs is enforced 1100 * for fabric modules (iSCSI) requiring them. 1101 */ 1102 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) { 1103 if (dev->dev_attrib.enforce_pr_isids) 1104 continue; 1105 } 1106 atomic_inc_mb(&pr_reg->pr_res_holders); 1107 spin_unlock(&pr_tmpl->registration_lock); 1108 return pr_reg; 1109 } 1110 /* 1111 * If the *pr_reg contains a fabric defined ISID for multi-value 1112 * SCSI Initiator Port TransportIDs, then we expect a valid 1113 * matching ISID to be provided by the local SCSI Initiator Port. 1114 */ 1115 if (!isid) 1116 continue; 1117 if (strcmp(isid, pr_reg->pr_reg_isid)) 1118 continue; 1119 1120 atomic_inc_mb(&pr_reg->pr_res_holders); 1121 spin_unlock(&pr_tmpl->registration_lock); 1122 return pr_reg; 1123 } 1124 spin_unlock(&pr_tmpl->registration_lock); 1125 1126 return NULL; 1127 } 1128 1129 static struct t10_pr_registration *core_scsi3_locate_pr_reg( 1130 struct se_device *dev, 1131 struct se_node_acl *nacl, 1132 struct se_session *sess) 1133 { 1134 struct se_portal_group *tpg = nacl->se_tpg; 1135 unsigned char buf[PR_REG_ISID_LEN], *isid_ptr = NULL; 1136 1137 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) { 1138 memset(&buf[0], 0, PR_REG_ISID_LEN); 1139 tpg->se_tpg_tfo->sess_get_initiator_sid(sess, &buf[0], 1140 PR_REG_ISID_LEN); 1141 isid_ptr = &buf[0]; 1142 } 1143 1144 return __core_scsi3_locate_pr_reg(dev, nacl, isid_ptr); 1145 } 1146 1147 static void core_scsi3_put_pr_reg(struct t10_pr_registration *pr_reg) 1148 { 1149 atomic_dec_mb(&pr_reg->pr_res_holders); 1150 } 1151 1152 static int core_scsi3_check_implicit_release( 1153 struct se_device *dev, 1154 struct t10_pr_registration *pr_reg) 1155 { 1156 struct se_node_acl *nacl = pr_reg->pr_reg_nacl; 1157 struct t10_pr_registration *pr_res_holder; 1158 int ret = 0; 1159 1160 spin_lock(&dev->dev_reservation_lock); 1161 pr_res_holder = dev->dev_pr_res_holder; 1162 if (!pr_res_holder) { 1163 spin_unlock(&dev->dev_reservation_lock); 1164 return ret; 1165 } 1166 if (pr_res_holder == pr_reg) { 1167 /* 1168 * Perform an implicit RELEASE if the registration that 1169 * is being released is holding the reservation. 1170 * 1171 * From spc4r17, section 5.7.11.1: 1172 * 1173 * e) If the I_T nexus is the persistent reservation holder 1174 * and the persistent reservation is not an all registrants 1175 * type, then a PERSISTENT RESERVE OUT command with REGISTER 1176 * service action or REGISTER AND IGNORE EXISTING KEY 1177 * service action with the SERVICE ACTION RESERVATION KEY 1178 * field set to zero (see 5.7.11.3). 1179 */ 1180 __core_scsi3_complete_pro_release(dev, nacl, pr_reg, 0); 1181 ret = 1; 1182 /* 1183 * For 'All Registrants' reservation types, all existing 1184 * registrations are still processed as reservation holders 1185 * in core_scsi3_pr_seq_non_holder() after the initial 1186 * reservation holder is implicitly released here. 1187 */ 1188 } else if (pr_reg->pr_reg_all_tg_pt && 1189 (!strcmp(pr_res_holder->pr_reg_nacl->initiatorname, 1190 pr_reg->pr_reg_nacl->initiatorname)) && 1191 (pr_res_holder->pr_res_key == pr_reg->pr_res_key)) { 1192 pr_err("SPC-3 PR: Unable to perform ALL_TG_PT=1" 1193 " UNREGISTER while existing reservation with matching" 1194 " key 0x%016Lx is present from another SCSI Initiator" 1195 " Port\n", pr_reg->pr_res_key); 1196 ret = -EPERM; 1197 } 1198 spin_unlock(&dev->dev_reservation_lock); 1199 1200 return ret; 1201 } 1202 1203 /* 1204 * Called with struct t10_reservation->registration_lock held. 1205 */ 1206 static void __core_scsi3_free_registration( 1207 struct se_device *dev, 1208 struct t10_pr_registration *pr_reg, 1209 struct list_head *preempt_and_abort_list, 1210 int dec_holders) 1211 { 1212 struct target_core_fabric_ops *tfo = 1213 pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo; 1214 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1215 char i_buf[PR_REG_ISID_ID_LEN]; 1216 1217 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1218 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 1219 1220 pr_reg->pr_reg_deve->def_pr_registered = 0; 1221 pr_reg->pr_reg_deve->pr_res_key = 0; 1222 list_del(&pr_reg->pr_reg_list); 1223 /* 1224 * Caller accessing *pr_reg using core_scsi3_locate_pr_reg(), 1225 * so call core_scsi3_put_pr_reg() to decrement our reference. 1226 */ 1227 if (dec_holders) 1228 core_scsi3_put_pr_reg(pr_reg); 1229 /* 1230 * Wait until all reference from any other I_T nexuses for this 1231 * *pr_reg have been released. Because list_del() is called above, 1232 * the last core_scsi3_put_pr_reg(pr_reg) will release this reference 1233 * count back to zero, and we release *pr_reg. 1234 */ 1235 while (atomic_read(&pr_reg->pr_res_holders) != 0) { 1236 spin_unlock(&pr_tmpl->registration_lock); 1237 pr_debug("SPC-3 PR [%s] waiting for pr_res_holders\n", 1238 tfo->get_fabric_name()); 1239 cpu_relax(); 1240 spin_lock(&pr_tmpl->registration_lock); 1241 } 1242 1243 pr_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator" 1244 " Node: %s%s\n", tfo->get_fabric_name(), 1245 pr_reg->pr_reg_nacl->initiatorname, 1246 i_buf); 1247 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target" 1248 " Port(s)\n", tfo->get_fabric_name(), 1249 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE", 1250 dev->transport->name); 1251 pr_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:" 1252 " 0x%08x\n", tfo->get_fabric_name(), pr_reg->pr_res_key, 1253 pr_reg->pr_res_generation); 1254 1255 if (!preempt_and_abort_list) { 1256 pr_reg->pr_reg_deve = NULL; 1257 pr_reg->pr_reg_nacl = NULL; 1258 kmem_cache_free(t10_pr_reg_cache, pr_reg); 1259 return; 1260 } 1261 /* 1262 * For PREEMPT_AND_ABORT, the list of *pr_reg in preempt_and_abort_list 1263 * are released once the ABORT_TASK_SET has completed.. 1264 */ 1265 list_add_tail(&pr_reg->pr_reg_abort_list, preempt_and_abort_list); 1266 } 1267 1268 void core_scsi3_free_pr_reg_from_nacl( 1269 struct se_device *dev, 1270 struct se_node_acl *nacl) 1271 { 1272 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1273 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder; 1274 /* 1275 * If the passed se_node_acl matches the reservation holder, 1276 * release the reservation. 1277 */ 1278 spin_lock(&dev->dev_reservation_lock); 1279 pr_res_holder = dev->dev_pr_res_holder; 1280 if ((pr_res_holder != NULL) && 1281 (pr_res_holder->pr_reg_nacl == nacl)) 1282 __core_scsi3_complete_pro_release(dev, nacl, pr_res_holder, 0); 1283 spin_unlock(&dev->dev_reservation_lock); 1284 /* 1285 * Release any registration associated with the struct se_node_acl. 1286 */ 1287 spin_lock(&pr_tmpl->registration_lock); 1288 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 1289 &pr_tmpl->registration_list, pr_reg_list) { 1290 1291 if (pr_reg->pr_reg_nacl != nacl) 1292 continue; 1293 1294 __core_scsi3_free_registration(dev, pr_reg, NULL, 0); 1295 } 1296 spin_unlock(&pr_tmpl->registration_lock); 1297 } 1298 1299 void core_scsi3_free_all_registrations( 1300 struct se_device *dev) 1301 { 1302 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1303 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder; 1304 1305 spin_lock(&dev->dev_reservation_lock); 1306 pr_res_holder = dev->dev_pr_res_holder; 1307 if (pr_res_holder != NULL) { 1308 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl; 1309 __core_scsi3_complete_pro_release(dev, pr_res_nacl, 1310 pr_res_holder, 0); 1311 } 1312 spin_unlock(&dev->dev_reservation_lock); 1313 1314 spin_lock(&pr_tmpl->registration_lock); 1315 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 1316 &pr_tmpl->registration_list, pr_reg_list) { 1317 1318 __core_scsi3_free_registration(dev, pr_reg, NULL, 0); 1319 } 1320 spin_unlock(&pr_tmpl->registration_lock); 1321 1322 spin_lock(&pr_tmpl->aptpl_reg_lock); 1323 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list, 1324 pr_reg_aptpl_list) { 1325 list_del(&pr_reg->pr_reg_aptpl_list); 1326 kmem_cache_free(t10_pr_reg_cache, pr_reg); 1327 } 1328 spin_unlock(&pr_tmpl->aptpl_reg_lock); 1329 } 1330 1331 static int core_scsi3_tpg_depend_item(struct se_portal_group *tpg) 1332 { 1333 return configfs_depend_item(tpg->se_tpg_tfo->tf_subsys, 1334 &tpg->tpg_group.cg_item); 1335 } 1336 1337 static void core_scsi3_tpg_undepend_item(struct se_portal_group *tpg) 1338 { 1339 configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys, 1340 &tpg->tpg_group.cg_item); 1341 1342 atomic_dec_mb(&tpg->tpg_pr_ref_count); 1343 } 1344 1345 static int core_scsi3_nodeacl_depend_item(struct se_node_acl *nacl) 1346 { 1347 struct se_portal_group *tpg = nacl->se_tpg; 1348 1349 if (nacl->dynamic_node_acl) 1350 return 0; 1351 1352 return configfs_depend_item(tpg->se_tpg_tfo->tf_subsys, 1353 &nacl->acl_group.cg_item); 1354 } 1355 1356 static void core_scsi3_nodeacl_undepend_item(struct se_node_acl *nacl) 1357 { 1358 struct se_portal_group *tpg = nacl->se_tpg; 1359 1360 if (nacl->dynamic_node_acl) { 1361 atomic_dec_mb(&nacl->acl_pr_ref_count); 1362 return; 1363 } 1364 1365 configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys, 1366 &nacl->acl_group.cg_item); 1367 1368 atomic_dec_mb(&nacl->acl_pr_ref_count); 1369 } 1370 1371 static int core_scsi3_lunacl_depend_item(struct se_dev_entry *se_deve) 1372 { 1373 struct se_lun_acl *lun_acl = se_deve->se_lun_acl; 1374 struct se_node_acl *nacl; 1375 struct se_portal_group *tpg; 1376 /* 1377 * For nacl->dynamic_node_acl=1 1378 */ 1379 if (!lun_acl) 1380 return 0; 1381 1382 nacl = lun_acl->se_lun_nacl; 1383 tpg = nacl->se_tpg; 1384 1385 return configfs_depend_item(tpg->se_tpg_tfo->tf_subsys, 1386 &lun_acl->se_lun_group.cg_item); 1387 } 1388 1389 static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *se_deve) 1390 { 1391 struct se_lun_acl *lun_acl = se_deve->se_lun_acl; 1392 struct se_node_acl *nacl; 1393 struct se_portal_group *tpg; 1394 /* 1395 * For nacl->dynamic_node_acl=1 1396 */ 1397 if (!lun_acl) { 1398 atomic_dec_mb(&se_deve->pr_ref_count); 1399 return; 1400 } 1401 nacl = lun_acl->se_lun_nacl; 1402 tpg = nacl->se_tpg; 1403 1404 configfs_undepend_item(tpg->se_tpg_tfo->tf_subsys, 1405 &lun_acl->se_lun_group.cg_item); 1406 1407 atomic_dec_mb(&se_deve->pr_ref_count); 1408 } 1409 1410 static sense_reason_t 1411 core_scsi3_decode_spec_i_port( 1412 struct se_cmd *cmd, 1413 struct se_portal_group *tpg, 1414 unsigned char *l_isid, 1415 u64 sa_res_key, 1416 int all_tg_pt, 1417 int aptpl) 1418 { 1419 struct se_device *dev = cmd->se_dev; 1420 struct se_port *tmp_port; 1421 struct se_portal_group *dest_tpg = NULL, *tmp_tpg; 1422 struct se_session *se_sess = cmd->se_sess; 1423 struct se_node_acl *dest_node_acl = NULL; 1424 struct se_dev_entry *dest_se_deve = NULL, *local_se_deve; 1425 struct t10_pr_registration *dest_pr_reg, *local_pr_reg, *pr_reg_e; 1426 struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe; 1427 LIST_HEAD(tid_dest_list); 1428 struct pr_transport_id_holder *tidh_new, *tidh, *tidh_tmp; 1429 struct target_core_fabric_ops *tmp_tf_ops; 1430 unsigned char *buf; 1431 unsigned char *ptr, *i_str = NULL, proto_ident, tmp_proto_ident; 1432 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN]; 1433 sense_reason_t ret; 1434 u32 tpdl, tid_len = 0; 1435 int dest_local_nexus; 1436 u32 dest_rtpi = 0; 1437 1438 memset(dest_iport, 0, 64); 1439 1440 local_se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun]; 1441 /* 1442 * Allocate a struct pr_transport_id_holder and setup the 1443 * local_node_acl and local_se_deve pointers and add to 1444 * struct list_head tid_dest_list for add registration 1445 * processing in the loop of tid_dest_list below. 1446 */ 1447 tidh_new = kzalloc(sizeof(struct pr_transport_id_holder), GFP_KERNEL); 1448 if (!tidh_new) { 1449 pr_err("Unable to allocate tidh_new\n"); 1450 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1451 } 1452 INIT_LIST_HEAD(&tidh_new->dest_list); 1453 tidh_new->dest_tpg = tpg; 1454 tidh_new->dest_node_acl = se_sess->se_node_acl; 1455 tidh_new->dest_se_deve = local_se_deve; 1456 1457 local_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev, 1458 se_sess->se_node_acl, local_se_deve, l_isid, 1459 sa_res_key, all_tg_pt, aptpl); 1460 if (!local_pr_reg) { 1461 kfree(tidh_new); 1462 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1463 } 1464 tidh_new->dest_pr_reg = local_pr_reg; 1465 /* 1466 * The local I_T nexus does not hold any configfs dependances, 1467 * so we set tid_h->dest_local_nexus=1 to prevent the 1468 * configfs_undepend_item() calls in the tid_dest_list loops below. 1469 */ 1470 tidh_new->dest_local_nexus = 1; 1471 list_add_tail(&tidh_new->dest_list, &tid_dest_list); 1472 1473 if (cmd->data_length < 28) { 1474 pr_warn("SPC-PR: Received PR OUT parameter list" 1475 " length too small: %u\n", cmd->data_length); 1476 ret = TCM_INVALID_PARAMETER_LIST; 1477 goto out; 1478 } 1479 1480 buf = transport_kmap_data_sg(cmd); 1481 if (!buf) { 1482 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1483 goto out; 1484 } 1485 1486 /* 1487 * For a PERSISTENT RESERVE OUT specify initiator ports payload, 1488 * first extract TransportID Parameter Data Length, and make sure 1489 * the value matches up to the SCSI expected data transfer length. 1490 */ 1491 tpdl = (buf[24] & 0xff) << 24; 1492 tpdl |= (buf[25] & 0xff) << 16; 1493 tpdl |= (buf[26] & 0xff) << 8; 1494 tpdl |= buf[27] & 0xff; 1495 1496 if ((tpdl + 28) != cmd->data_length) { 1497 pr_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header" 1498 " does not equal CDB data_length: %u\n", tpdl, 1499 cmd->data_length); 1500 ret = TCM_INVALID_PARAMETER_LIST; 1501 goto out_unmap; 1502 } 1503 /* 1504 * Start processing the received transport IDs using the 1505 * receiving I_T Nexus portal's fabric dependent methods to 1506 * obtain the SCSI Initiator Port/Device Identifiers. 1507 */ 1508 ptr = &buf[28]; 1509 1510 while (tpdl > 0) { 1511 proto_ident = (ptr[0] & 0x0f); 1512 dest_tpg = NULL; 1513 1514 spin_lock(&dev->se_port_lock); 1515 list_for_each_entry(tmp_port, &dev->dev_sep_list, sep_list) { 1516 tmp_tpg = tmp_port->sep_tpg; 1517 if (!tmp_tpg) 1518 continue; 1519 tmp_tf_ops = tmp_tpg->se_tpg_tfo; 1520 if (!tmp_tf_ops) 1521 continue; 1522 if (!tmp_tf_ops->get_fabric_proto_ident || 1523 !tmp_tf_ops->tpg_parse_pr_out_transport_id) 1524 continue; 1525 /* 1526 * Look for the matching proto_ident provided by 1527 * the received TransportID 1528 */ 1529 tmp_proto_ident = tmp_tf_ops->get_fabric_proto_ident(tmp_tpg); 1530 if (tmp_proto_ident != proto_ident) 1531 continue; 1532 dest_rtpi = tmp_port->sep_rtpi; 1533 1534 i_str = tmp_tf_ops->tpg_parse_pr_out_transport_id( 1535 tmp_tpg, (const char *)ptr, &tid_len, 1536 &iport_ptr); 1537 if (!i_str) 1538 continue; 1539 1540 atomic_inc_mb(&tmp_tpg->tpg_pr_ref_count); 1541 spin_unlock(&dev->se_port_lock); 1542 1543 if (core_scsi3_tpg_depend_item(tmp_tpg)) { 1544 pr_err(" core_scsi3_tpg_depend_item()" 1545 " for tmp_tpg\n"); 1546 atomic_dec_mb(&tmp_tpg->tpg_pr_ref_count); 1547 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1548 goto out_unmap; 1549 } 1550 /* 1551 * Locate the destination initiator ACL to be registered 1552 * from the decoded fabric module specific TransportID 1553 * at *i_str. 1554 */ 1555 spin_lock_irq(&tmp_tpg->acl_node_lock); 1556 dest_node_acl = __core_tpg_get_initiator_node_acl( 1557 tmp_tpg, i_str); 1558 if (dest_node_acl) 1559 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count); 1560 spin_unlock_irq(&tmp_tpg->acl_node_lock); 1561 1562 if (!dest_node_acl) { 1563 core_scsi3_tpg_undepend_item(tmp_tpg); 1564 spin_lock(&dev->se_port_lock); 1565 continue; 1566 } 1567 1568 if (core_scsi3_nodeacl_depend_item(dest_node_acl)) { 1569 pr_err("configfs_depend_item() failed" 1570 " for dest_node_acl->acl_group\n"); 1571 atomic_dec_mb(&dest_node_acl->acl_pr_ref_count); 1572 core_scsi3_tpg_undepend_item(tmp_tpg); 1573 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1574 goto out_unmap; 1575 } 1576 1577 dest_tpg = tmp_tpg; 1578 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node:" 1579 " %s Port RTPI: %hu\n", 1580 dest_tpg->se_tpg_tfo->get_fabric_name(), 1581 dest_node_acl->initiatorname, dest_rtpi); 1582 1583 spin_lock(&dev->se_port_lock); 1584 break; 1585 } 1586 spin_unlock(&dev->se_port_lock); 1587 1588 if (!dest_tpg) { 1589 pr_err("SPC-3 PR SPEC_I_PT: Unable to locate" 1590 " dest_tpg\n"); 1591 ret = TCM_INVALID_PARAMETER_LIST; 1592 goto out_unmap; 1593 } 1594 1595 pr_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u" 1596 " tid_len: %d for %s + %s\n", 1597 dest_tpg->se_tpg_tfo->get_fabric_name(), cmd->data_length, 1598 tpdl, tid_len, i_str, iport_ptr); 1599 1600 if (tid_len > tpdl) { 1601 pr_err("SPC-3 PR SPEC_I_PT: Illegal tid_len:" 1602 " %u for Transport ID: %s\n", tid_len, ptr); 1603 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1604 core_scsi3_tpg_undepend_item(dest_tpg); 1605 ret = TCM_INVALID_PARAMETER_LIST; 1606 goto out_unmap; 1607 } 1608 /* 1609 * Locate the desintation struct se_dev_entry pointer for matching 1610 * RELATIVE TARGET PORT IDENTIFIER on the receiving I_T Nexus 1611 * Target Port. 1612 */ 1613 dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl, 1614 dest_rtpi); 1615 if (!dest_se_deve) { 1616 pr_err("Unable to locate %s dest_se_deve" 1617 " from destination RTPI: %hu\n", 1618 dest_tpg->se_tpg_tfo->get_fabric_name(), 1619 dest_rtpi); 1620 1621 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1622 core_scsi3_tpg_undepend_item(dest_tpg); 1623 ret = TCM_INVALID_PARAMETER_LIST; 1624 goto out_unmap; 1625 } 1626 1627 if (core_scsi3_lunacl_depend_item(dest_se_deve)) { 1628 pr_err("core_scsi3_lunacl_depend_item()" 1629 " failed\n"); 1630 atomic_dec_mb(&dest_se_deve->pr_ref_count); 1631 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1632 core_scsi3_tpg_undepend_item(dest_tpg); 1633 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1634 goto out_unmap; 1635 } 1636 1637 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s" 1638 " dest_se_deve mapped_lun: %u\n", 1639 dest_tpg->se_tpg_tfo->get_fabric_name(), 1640 dest_node_acl->initiatorname, dest_se_deve->mapped_lun); 1641 1642 /* 1643 * Skip any TransportIDs that already have a registration for 1644 * this target port. 1645 */ 1646 pr_reg_e = __core_scsi3_locate_pr_reg(dev, dest_node_acl, 1647 iport_ptr); 1648 if (pr_reg_e) { 1649 core_scsi3_put_pr_reg(pr_reg_e); 1650 core_scsi3_lunacl_undepend_item(dest_se_deve); 1651 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1652 core_scsi3_tpg_undepend_item(dest_tpg); 1653 ptr += tid_len; 1654 tpdl -= tid_len; 1655 tid_len = 0; 1656 continue; 1657 } 1658 /* 1659 * Allocate a struct pr_transport_id_holder and setup 1660 * the dest_node_acl and dest_se_deve pointers for the 1661 * loop below. 1662 */ 1663 tidh_new = kzalloc(sizeof(struct pr_transport_id_holder), 1664 GFP_KERNEL); 1665 if (!tidh_new) { 1666 pr_err("Unable to allocate tidh_new\n"); 1667 core_scsi3_lunacl_undepend_item(dest_se_deve); 1668 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1669 core_scsi3_tpg_undepend_item(dest_tpg); 1670 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1671 goto out_unmap; 1672 } 1673 INIT_LIST_HEAD(&tidh_new->dest_list); 1674 tidh_new->dest_tpg = dest_tpg; 1675 tidh_new->dest_node_acl = dest_node_acl; 1676 tidh_new->dest_se_deve = dest_se_deve; 1677 1678 /* 1679 * Allocate, but do NOT add the registration for the 1680 * TransportID referenced SCSI Initiator port. This 1681 * done because of the following from spc4r17 in section 1682 * 6.14.3 wrt SPEC_I_PT: 1683 * 1684 * "If a registration fails for any initiator port (e.g., if th 1685 * logical unit does not have enough resources available to 1686 * hold the registration information), no registrations shall be 1687 * made, and the command shall be terminated with 1688 * CHECK CONDITION status." 1689 * 1690 * That means we call __core_scsi3_alloc_registration() here, 1691 * and then call __core_scsi3_add_registration() in the 1692 * 2nd loop which will never fail. 1693 */ 1694 dest_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev, 1695 dest_node_acl, dest_se_deve, iport_ptr, 1696 sa_res_key, all_tg_pt, aptpl); 1697 if (!dest_pr_reg) { 1698 core_scsi3_lunacl_undepend_item(dest_se_deve); 1699 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1700 core_scsi3_tpg_undepend_item(dest_tpg); 1701 kfree(tidh_new); 1702 ret = TCM_INVALID_PARAMETER_LIST; 1703 goto out_unmap; 1704 } 1705 tidh_new->dest_pr_reg = dest_pr_reg; 1706 list_add_tail(&tidh_new->dest_list, &tid_dest_list); 1707 1708 ptr += tid_len; 1709 tpdl -= tid_len; 1710 tid_len = 0; 1711 1712 } 1713 1714 transport_kunmap_data_sg(cmd); 1715 1716 /* 1717 * Go ahead and create a registrations from tid_dest_list for the 1718 * SPEC_I_PT provided TransportID for the *tidh referenced dest_node_acl 1719 * and dest_se_deve. 1720 * 1721 * The SA Reservation Key from the PROUT is set for the 1722 * registration, and ALL_TG_PT is also passed. ALL_TG_PT=1 1723 * means that the TransportID Initiator port will be 1724 * registered on all of the target ports in the SCSI target device 1725 * ALL_TG_PT=0 means the registration will only be for the 1726 * SCSI target port the PROUT REGISTER with SPEC_I_PT=1 1727 * was received. 1728 */ 1729 list_for_each_entry_safe(tidh, tidh_tmp, &tid_dest_list, dest_list) { 1730 dest_tpg = tidh->dest_tpg; 1731 dest_node_acl = tidh->dest_node_acl; 1732 dest_se_deve = tidh->dest_se_deve; 1733 dest_pr_reg = tidh->dest_pr_reg; 1734 dest_local_nexus = tidh->dest_local_nexus; 1735 1736 list_del(&tidh->dest_list); 1737 kfree(tidh); 1738 1739 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1740 core_pr_dump_initiator_port(dest_pr_reg, i_buf, PR_REG_ISID_ID_LEN); 1741 1742 __core_scsi3_add_registration(cmd->se_dev, dest_node_acl, 1743 dest_pr_reg, 0, 0); 1744 1745 pr_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully" 1746 " registered Transport ID for Node: %s%s Mapped LUN:" 1747 " %u\n", dest_tpg->se_tpg_tfo->get_fabric_name(), 1748 dest_node_acl->initiatorname, i_buf, dest_se_deve->mapped_lun); 1749 1750 if (dest_local_nexus) 1751 continue; 1752 1753 core_scsi3_lunacl_undepend_item(dest_se_deve); 1754 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1755 core_scsi3_tpg_undepend_item(dest_tpg); 1756 } 1757 1758 return 0; 1759 out_unmap: 1760 transport_kunmap_data_sg(cmd); 1761 out: 1762 /* 1763 * For the failure case, release everything from tid_dest_list 1764 * including *dest_pr_reg and the configfs dependances.. 1765 */ 1766 list_for_each_entry_safe(tidh, tidh_tmp, &tid_dest_list, dest_list) { 1767 dest_tpg = tidh->dest_tpg; 1768 dest_node_acl = tidh->dest_node_acl; 1769 dest_se_deve = tidh->dest_se_deve; 1770 dest_pr_reg = tidh->dest_pr_reg; 1771 dest_local_nexus = tidh->dest_local_nexus; 1772 1773 list_del(&tidh->dest_list); 1774 kfree(tidh); 1775 /* 1776 * Release any extra ALL_TG_PT=1 registrations for 1777 * the SPEC_I_PT=1 case. 1778 */ 1779 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe, 1780 &dest_pr_reg->pr_reg_atp_list, 1781 pr_reg_atp_mem_list) { 1782 list_del(&pr_reg_tmp->pr_reg_atp_mem_list); 1783 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve); 1784 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp); 1785 } 1786 1787 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg); 1788 1789 if (dest_local_nexus) 1790 continue; 1791 1792 core_scsi3_lunacl_undepend_item(dest_se_deve); 1793 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1794 core_scsi3_tpg_undepend_item(dest_tpg); 1795 } 1796 return ret; 1797 } 1798 1799 static int core_scsi3_update_aptpl_buf( 1800 struct se_device *dev, 1801 unsigned char *buf, 1802 u32 pr_aptpl_buf_len) 1803 { 1804 struct se_lun *lun; 1805 struct se_portal_group *tpg; 1806 struct t10_pr_registration *pr_reg; 1807 unsigned char tmp[512], isid_buf[32]; 1808 ssize_t len = 0; 1809 int reg_count = 0; 1810 int ret = 0; 1811 1812 spin_lock(&dev->dev_reservation_lock); 1813 spin_lock(&dev->t10_pr.registration_lock); 1814 /* 1815 * Walk the registration list.. 1816 */ 1817 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list, 1818 pr_reg_list) { 1819 1820 tmp[0] = '\0'; 1821 isid_buf[0] = '\0'; 1822 tpg = pr_reg->pr_reg_nacl->se_tpg; 1823 lun = pr_reg->pr_reg_tg_pt_lun; 1824 /* 1825 * Write out any ISID value to APTPL metadata that was included 1826 * in the original registration. 1827 */ 1828 if (pr_reg->isid_present_at_reg) 1829 snprintf(isid_buf, 32, "initiator_sid=%s\n", 1830 pr_reg->pr_reg_isid); 1831 /* 1832 * Include special metadata if the pr_reg matches the 1833 * reservation holder. 1834 */ 1835 if (dev->dev_pr_res_holder == pr_reg) { 1836 snprintf(tmp, 512, "PR_REG_START: %d" 1837 "\ninitiator_fabric=%s\n" 1838 "initiator_node=%s\n%s" 1839 "sa_res_key=%llu\n" 1840 "res_holder=1\nres_type=%02x\n" 1841 "res_scope=%02x\nres_all_tg_pt=%d\n" 1842 "mapped_lun=%u\n", reg_count, 1843 tpg->se_tpg_tfo->get_fabric_name(), 1844 pr_reg->pr_reg_nacl->initiatorname, isid_buf, 1845 pr_reg->pr_res_key, pr_reg->pr_res_type, 1846 pr_reg->pr_res_scope, pr_reg->pr_reg_all_tg_pt, 1847 pr_reg->pr_res_mapped_lun); 1848 } else { 1849 snprintf(tmp, 512, "PR_REG_START: %d\n" 1850 "initiator_fabric=%s\ninitiator_node=%s\n%s" 1851 "sa_res_key=%llu\nres_holder=0\n" 1852 "res_all_tg_pt=%d\nmapped_lun=%u\n", 1853 reg_count, tpg->se_tpg_tfo->get_fabric_name(), 1854 pr_reg->pr_reg_nacl->initiatorname, isid_buf, 1855 pr_reg->pr_res_key, pr_reg->pr_reg_all_tg_pt, 1856 pr_reg->pr_res_mapped_lun); 1857 } 1858 1859 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) { 1860 pr_err("Unable to update renaming" 1861 " APTPL metadata\n"); 1862 ret = -EMSGSIZE; 1863 goto out; 1864 } 1865 len += sprintf(buf+len, "%s", tmp); 1866 1867 /* 1868 * Include information about the associated SCSI target port. 1869 */ 1870 snprintf(tmp, 512, "target_fabric=%s\ntarget_node=%s\n" 1871 "tpgt=%hu\nport_rtpi=%hu\ntarget_lun=%u\nPR_REG_END:" 1872 " %d\n", tpg->se_tpg_tfo->get_fabric_name(), 1873 tpg->se_tpg_tfo->tpg_get_wwn(tpg), 1874 tpg->se_tpg_tfo->tpg_get_tag(tpg), 1875 lun->lun_sep->sep_rtpi, lun->unpacked_lun, reg_count); 1876 1877 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) { 1878 pr_err("Unable to update renaming" 1879 " APTPL metadata\n"); 1880 ret = -EMSGSIZE; 1881 goto out; 1882 } 1883 len += sprintf(buf+len, "%s", tmp); 1884 reg_count++; 1885 } 1886 1887 if (!reg_count) 1888 len += sprintf(buf+len, "No Registrations or Reservations"); 1889 1890 out: 1891 spin_unlock(&dev->t10_pr.registration_lock); 1892 spin_unlock(&dev->dev_reservation_lock); 1893 1894 return ret; 1895 } 1896 1897 static int __core_scsi3_write_aptpl_to_file( 1898 struct se_device *dev, 1899 unsigned char *buf) 1900 { 1901 struct t10_wwn *wwn = &dev->t10_wwn; 1902 struct file *file; 1903 int flags = O_RDWR | O_CREAT | O_TRUNC; 1904 char path[512]; 1905 u32 pr_aptpl_buf_len; 1906 int ret; 1907 1908 memset(path, 0, 512); 1909 1910 if (strlen(&wwn->unit_serial[0]) >= 512) { 1911 pr_err("WWN value for struct se_device does not fit" 1912 " into path buffer\n"); 1913 return -EMSGSIZE; 1914 } 1915 1916 snprintf(path, 512, "/var/target/pr/aptpl_%s", &wwn->unit_serial[0]); 1917 file = filp_open(path, flags, 0600); 1918 if (IS_ERR(file)) { 1919 pr_err("filp_open(%s) for APTPL metadata" 1920 " failed\n", path); 1921 return PTR_ERR(file); 1922 } 1923 1924 pr_aptpl_buf_len = (strlen(buf) + 1); /* Add extra for NULL */ 1925 1926 ret = kernel_write(file, buf, pr_aptpl_buf_len, 0); 1927 1928 if (ret < 0) 1929 pr_debug("Error writing APTPL metadata file: %s\n", path); 1930 fput(file); 1931 1932 return (ret < 0) ? -EIO : 0; 1933 } 1934 1935 /* 1936 * Clear the APTPL metadata if APTPL has been disabled, otherwise 1937 * write out the updated metadata to struct file for this SCSI device. 1938 */ 1939 static sense_reason_t core_scsi3_update_and_write_aptpl(struct se_device *dev, bool aptpl) 1940 { 1941 unsigned char *buf; 1942 int rc; 1943 1944 if (!aptpl) { 1945 char *null_buf = "No Registrations or Reservations\n"; 1946 1947 rc = __core_scsi3_write_aptpl_to_file(dev, null_buf); 1948 dev->t10_pr.pr_aptpl_active = 0; 1949 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated\n"); 1950 1951 if (rc) 1952 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1953 1954 return 0; 1955 } 1956 1957 buf = kzalloc(PR_APTPL_BUF_LEN, GFP_KERNEL); 1958 if (!buf) 1959 return TCM_OUT_OF_RESOURCES; 1960 1961 rc = core_scsi3_update_aptpl_buf(dev, buf, PR_APTPL_BUF_LEN); 1962 if (rc < 0) { 1963 kfree(buf); 1964 return TCM_OUT_OF_RESOURCES; 1965 } 1966 1967 rc = __core_scsi3_write_aptpl_to_file(dev, buf); 1968 if (rc != 0) { 1969 pr_err("SPC-3 PR: Could not update APTPL\n"); 1970 kfree(buf); 1971 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1972 } 1973 dev->t10_pr.pr_aptpl_active = 1; 1974 kfree(buf); 1975 pr_debug("SPC-3 PR: Set APTPL Bit Activated\n"); 1976 return 0; 1977 } 1978 1979 static sense_reason_t 1980 core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key, 1981 bool aptpl, bool all_tg_pt, bool spec_i_pt, enum register_type register_type) 1982 { 1983 struct se_session *se_sess = cmd->se_sess; 1984 struct se_device *dev = cmd->se_dev; 1985 struct se_dev_entry *se_deve; 1986 struct se_lun *se_lun = cmd->se_lun; 1987 struct se_portal_group *se_tpg; 1988 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp; 1989 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1990 unsigned char isid_buf[PR_REG_ISID_LEN], *isid_ptr = NULL; 1991 sense_reason_t ret = TCM_NO_SENSE; 1992 int pr_holder = 0, type; 1993 1994 if (!se_sess || !se_lun) { 1995 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n"); 1996 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1997 } 1998 se_tpg = se_sess->se_tpg; 1999 se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun]; 2000 2001 if (se_tpg->se_tpg_tfo->sess_get_initiator_sid) { 2002 memset(&isid_buf[0], 0, PR_REG_ISID_LEN); 2003 se_tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, &isid_buf[0], 2004 PR_REG_ISID_LEN); 2005 isid_ptr = &isid_buf[0]; 2006 } 2007 /* 2008 * Follow logic from spc4r17 Section 5.7.7, Register Behaviors Table 47 2009 */ 2010 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess); 2011 if (!pr_reg) { 2012 if (res_key) { 2013 pr_warn("SPC-3 PR: Reservation Key non-zero" 2014 " for SA REGISTER, returning CONFLICT\n"); 2015 return TCM_RESERVATION_CONFLICT; 2016 } 2017 /* 2018 * Do nothing but return GOOD status. 2019 */ 2020 if (!sa_res_key) 2021 return 0; 2022 2023 if (!spec_i_pt) { 2024 /* 2025 * Perform the Service Action REGISTER on the Initiator 2026 * Port Endpoint that the PRO was received from on the 2027 * Logical Unit of the SCSI device server. 2028 */ 2029 if (core_scsi3_alloc_registration(cmd->se_dev, 2030 se_sess->se_node_acl, se_deve, isid_ptr, 2031 sa_res_key, all_tg_pt, aptpl, 2032 register_type, 0)) { 2033 pr_err("Unable to allocate" 2034 " struct t10_pr_registration\n"); 2035 return TCM_INVALID_PARAMETER_LIST; 2036 } 2037 } else { 2038 /* 2039 * Register both the Initiator port that received 2040 * PROUT SA REGISTER + SPEC_I_PT=1 and extract SCSI 2041 * TransportID from Parameter list and loop through 2042 * fabric dependent parameter list while calling 2043 * logic from of core_scsi3_alloc_registration() for 2044 * each TransportID provided SCSI Initiator Port/Device 2045 */ 2046 ret = core_scsi3_decode_spec_i_port(cmd, se_tpg, 2047 isid_ptr, sa_res_key, all_tg_pt, aptpl); 2048 if (ret != 0) 2049 return ret; 2050 } 2051 2052 return core_scsi3_update_and_write_aptpl(dev, aptpl); 2053 } 2054 2055 /* ok, existing registration */ 2056 2057 if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) { 2058 pr_err("SPC-3 PR REGISTER: Received" 2059 " res_key: 0x%016Lx does not match" 2060 " existing SA REGISTER res_key:" 2061 " 0x%016Lx\n", res_key, 2062 pr_reg->pr_res_key); 2063 ret = TCM_RESERVATION_CONFLICT; 2064 goto out; 2065 } 2066 2067 if (spec_i_pt) { 2068 pr_err("SPC-3 PR REGISTER: SPEC_I_PT" 2069 " set on a registered nexus\n"); 2070 ret = TCM_INVALID_PARAMETER_LIST; 2071 goto out; 2072 } 2073 2074 /* 2075 * An existing ALL_TG_PT=1 registration being released 2076 * must also set ALL_TG_PT=1 in the incoming PROUT. 2077 */ 2078 if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) { 2079 pr_err("SPC-3 PR REGISTER: ALL_TG_PT=1" 2080 " registration exists, but ALL_TG_PT=1 bit not" 2081 " present in received PROUT\n"); 2082 ret = TCM_INVALID_CDB_FIELD; 2083 goto out; 2084 } 2085 2086 /* 2087 * sa_res_key=1 Change Reservation Key for registered I_T Nexus. 2088 */ 2089 if (sa_res_key) { 2090 /* 2091 * Increment PRgeneration counter for struct se_device" 2092 * upon a successful REGISTER, see spc4r17 section 6.3.2 2093 * READ_KEYS service action. 2094 */ 2095 pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev); 2096 pr_reg->pr_res_key = sa_res_key; 2097 pr_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation" 2098 " Key for %s to: 0x%016Lx PRgeneration:" 2099 " 0x%08x\n", cmd->se_tfo->get_fabric_name(), 2100 (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ? "_AND_IGNORE_EXISTING_KEY" : "", 2101 pr_reg->pr_reg_nacl->initiatorname, 2102 pr_reg->pr_res_key, pr_reg->pr_res_generation); 2103 2104 } else { 2105 /* 2106 * sa_res_key=0 Unregister Reservation Key for registered I_T Nexus. 2107 */ 2108 pr_holder = core_scsi3_check_implicit_release( 2109 cmd->se_dev, pr_reg); 2110 if (pr_holder < 0) { 2111 ret = TCM_RESERVATION_CONFLICT; 2112 goto out; 2113 } 2114 type = pr_reg->pr_res_type; 2115 2116 spin_lock(&pr_tmpl->registration_lock); 2117 /* 2118 * Release all ALL_TG_PT=1 for the matching SCSI Initiator Port 2119 * and matching pr_res_key. 2120 */ 2121 if (pr_reg->pr_reg_all_tg_pt) { 2122 list_for_each_entry_safe(pr_reg_p, pr_reg_tmp, 2123 &pr_tmpl->registration_list, 2124 pr_reg_list) { 2125 2126 if (!pr_reg_p->pr_reg_all_tg_pt) 2127 continue; 2128 if (pr_reg_p->pr_res_key != res_key) 2129 continue; 2130 if (pr_reg == pr_reg_p) 2131 continue; 2132 if (strcmp(pr_reg->pr_reg_nacl->initiatorname, 2133 pr_reg_p->pr_reg_nacl->initiatorname)) 2134 continue; 2135 2136 __core_scsi3_free_registration(dev, 2137 pr_reg_p, NULL, 0); 2138 } 2139 } 2140 2141 /* 2142 * Release the calling I_T Nexus registration now.. 2143 */ 2144 __core_scsi3_free_registration(cmd->se_dev, pr_reg, NULL, 1); 2145 pr_reg = NULL; 2146 2147 /* 2148 * From spc4r17, section 5.7.11.3 Unregistering 2149 * 2150 * If the persistent reservation is a registrants only 2151 * type, the device server shall establish a unit 2152 * attention condition for the initiator port associated 2153 * with every registered I_T nexus except for the I_T 2154 * nexus on which the PERSISTENT RESERVE OUT command was 2155 * received, with the additional sense code set to 2156 * RESERVATIONS RELEASED. 2157 */ 2158 if (pr_holder && 2159 (type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY || 2160 type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY)) { 2161 list_for_each_entry(pr_reg_p, 2162 &pr_tmpl->registration_list, 2163 pr_reg_list) { 2164 2165 core_scsi3_ua_allocate( 2166 pr_reg_p->pr_reg_nacl, 2167 pr_reg_p->pr_res_mapped_lun, 2168 0x2A, 2169 ASCQ_2AH_RESERVATIONS_RELEASED); 2170 } 2171 } 2172 2173 spin_unlock(&pr_tmpl->registration_lock); 2174 } 2175 2176 ret = core_scsi3_update_and_write_aptpl(dev, aptpl); 2177 2178 out: 2179 if (pr_reg) 2180 core_scsi3_put_pr_reg(pr_reg); 2181 return ret; 2182 } 2183 2184 unsigned char *core_scsi3_pr_dump_type(int type) 2185 { 2186 switch (type) { 2187 case PR_TYPE_WRITE_EXCLUSIVE: 2188 return "Write Exclusive Access"; 2189 case PR_TYPE_EXCLUSIVE_ACCESS: 2190 return "Exclusive Access"; 2191 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY: 2192 return "Write Exclusive Access, Registrants Only"; 2193 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY: 2194 return "Exclusive Access, Registrants Only"; 2195 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG: 2196 return "Write Exclusive Access, All Registrants"; 2197 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG: 2198 return "Exclusive Access, All Registrants"; 2199 default: 2200 break; 2201 } 2202 2203 return "Unknown SPC-3 PR Type"; 2204 } 2205 2206 static sense_reason_t 2207 core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key) 2208 { 2209 struct se_device *dev = cmd->se_dev; 2210 struct se_session *se_sess = cmd->se_sess; 2211 struct se_lun *se_lun = cmd->se_lun; 2212 struct t10_pr_registration *pr_reg, *pr_res_holder; 2213 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2214 char i_buf[PR_REG_ISID_ID_LEN]; 2215 sense_reason_t ret; 2216 2217 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2218 2219 if (!se_sess || !se_lun) { 2220 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n"); 2221 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2222 } 2223 /* 2224 * Locate the existing *pr_reg via struct se_node_acl pointers 2225 */ 2226 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl, 2227 se_sess); 2228 if (!pr_reg) { 2229 pr_err("SPC-3 PR: Unable to locate" 2230 " PR_REGISTERED *pr_reg for RESERVE\n"); 2231 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2232 } 2233 /* 2234 * From spc4r17 Section 5.7.9: Reserving: 2235 * 2236 * An application client creates a persistent reservation by issuing 2237 * a PERSISTENT RESERVE OUT command with RESERVE service action through 2238 * a registered I_T nexus with the following parameters: 2239 * a) RESERVATION KEY set to the value of the reservation key that is 2240 * registered with the logical unit for the I_T nexus; and 2241 */ 2242 if (res_key != pr_reg->pr_res_key) { 2243 pr_err("SPC-3 PR RESERVE: Received res_key: 0x%016Lx" 2244 " does not match existing SA REGISTER res_key:" 2245 " 0x%016Lx\n", res_key, pr_reg->pr_res_key); 2246 ret = TCM_RESERVATION_CONFLICT; 2247 goto out_put_pr_reg; 2248 } 2249 /* 2250 * From spc4r17 Section 5.7.9: Reserving: 2251 * 2252 * From above: 2253 * b) TYPE field and SCOPE field set to the persistent reservation 2254 * being created. 2255 * 2256 * Only one persistent reservation is allowed at a time per logical unit 2257 * and that persistent reservation has a scope of LU_SCOPE. 2258 */ 2259 if (scope != PR_SCOPE_LU_SCOPE) { 2260 pr_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope); 2261 ret = TCM_INVALID_PARAMETER_LIST; 2262 goto out_put_pr_reg; 2263 } 2264 /* 2265 * See if we have an existing PR reservation holder pointer at 2266 * struct se_device->dev_pr_res_holder in the form struct t10_pr_registration 2267 * *pr_res_holder. 2268 */ 2269 spin_lock(&dev->dev_reservation_lock); 2270 pr_res_holder = dev->dev_pr_res_holder; 2271 if (pr_res_holder) { 2272 /* 2273 * From spc4r17 Section 5.7.9: Reserving: 2274 * 2275 * If the device server receives a PERSISTENT RESERVE OUT 2276 * command from an I_T nexus other than a persistent reservation 2277 * holder (see 5.7.10) that attempts to create a persistent 2278 * reservation when a persistent reservation already exists for 2279 * the logical unit, then the command shall be completed with 2280 * RESERVATION CONFLICT status. 2281 */ 2282 if (pr_res_holder != pr_reg) { 2283 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl; 2284 pr_err("SPC-3 PR: Attempted RESERVE from" 2285 " [%s]: %s while reservation already held by" 2286 " [%s]: %s, returning RESERVATION_CONFLICT\n", 2287 cmd->se_tfo->get_fabric_name(), 2288 se_sess->se_node_acl->initiatorname, 2289 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(), 2290 pr_res_holder->pr_reg_nacl->initiatorname); 2291 2292 spin_unlock(&dev->dev_reservation_lock); 2293 ret = TCM_RESERVATION_CONFLICT; 2294 goto out_put_pr_reg; 2295 } 2296 /* 2297 * From spc4r17 Section 5.7.9: Reserving: 2298 * 2299 * If a persistent reservation holder attempts to modify the 2300 * type or scope of an existing persistent reservation, the 2301 * command shall be completed with RESERVATION CONFLICT status. 2302 */ 2303 if ((pr_res_holder->pr_res_type != type) || 2304 (pr_res_holder->pr_res_scope != scope)) { 2305 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl; 2306 pr_err("SPC-3 PR: Attempted RESERVE from" 2307 " [%s]: %s trying to change TYPE and/or SCOPE," 2308 " while reservation already held by [%s]: %s," 2309 " returning RESERVATION_CONFLICT\n", 2310 cmd->se_tfo->get_fabric_name(), 2311 se_sess->se_node_acl->initiatorname, 2312 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(), 2313 pr_res_holder->pr_reg_nacl->initiatorname); 2314 2315 spin_unlock(&dev->dev_reservation_lock); 2316 ret = TCM_RESERVATION_CONFLICT; 2317 goto out_put_pr_reg; 2318 } 2319 /* 2320 * From spc4r17 Section 5.7.9: Reserving: 2321 * 2322 * If the device server receives a PERSISTENT RESERVE OUT 2323 * command with RESERVE service action where the TYPE field and 2324 * the SCOPE field contain the same values as the existing type 2325 * and scope from a persistent reservation holder, it shall not 2326 * make any change to the existing persistent reservation and 2327 * shall completethe command with GOOD status. 2328 */ 2329 spin_unlock(&dev->dev_reservation_lock); 2330 ret = 0; 2331 goto out_put_pr_reg; 2332 } 2333 /* 2334 * Otherwise, our *pr_reg becomes the PR reservation holder for said 2335 * TYPE/SCOPE. Also set the received scope and type in *pr_reg. 2336 */ 2337 pr_reg->pr_res_scope = scope; 2338 pr_reg->pr_res_type = type; 2339 pr_reg->pr_res_holder = 1; 2340 dev->dev_pr_res_holder = pr_reg; 2341 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 2342 2343 pr_debug("SPC-3 PR [%s] Service Action: RESERVE created new" 2344 " reservation holder TYPE: %s ALL_TG_PT: %d\n", 2345 cmd->se_tfo->get_fabric_name(), core_scsi3_pr_dump_type(type), 2346 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 2347 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", 2348 cmd->se_tfo->get_fabric_name(), 2349 se_sess->se_node_acl->initiatorname, 2350 i_buf); 2351 spin_unlock(&dev->dev_reservation_lock); 2352 2353 if (pr_tmpl->pr_aptpl_active) 2354 core_scsi3_update_and_write_aptpl(cmd->se_dev, true); 2355 2356 ret = 0; 2357 out_put_pr_reg: 2358 core_scsi3_put_pr_reg(pr_reg); 2359 return ret; 2360 } 2361 2362 static sense_reason_t 2363 core_scsi3_emulate_pro_reserve(struct se_cmd *cmd, int type, int scope, 2364 u64 res_key) 2365 { 2366 switch (type) { 2367 case PR_TYPE_WRITE_EXCLUSIVE: 2368 case PR_TYPE_EXCLUSIVE_ACCESS: 2369 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY: 2370 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY: 2371 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG: 2372 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG: 2373 return core_scsi3_pro_reserve(cmd, type, scope, res_key); 2374 default: 2375 pr_err("SPC-3 PR: Unknown Service Action RESERVE Type:" 2376 " 0x%02x\n", type); 2377 return TCM_INVALID_CDB_FIELD; 2378 } 2379 } 2380 2381 /* 2382 * Called with struct se_device->dev_reservation_lock held. 2383 */ 2384 static void __core_scsi3_complete_pro_release( 2385 struct se_device *dev, 2386 struct se_node_acl *se_nacl, 2387 struct t10_pr_registration *pr_reg, 2388 int explicit) 2389 { 2390 struct target_core_fabric_ops *tfo = se_nacl->se_tpg->se_tpg_tfo; 2391 char i_buf[PR_REG_ISID_ID_LEN]; 2392 2393 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2394 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 2395 /* 2396 * Go ahead and release the current PR reservation holder. 2397 */ 2398 dev->dev_pr_res_holder = NULL; 2399 2400 pr_debug("SPC-3 PR [%s] Service Action: %s RELEASE cleared" 2401 " reservation holder TYPE: %s ALL_TG_PT: %d\n", 2402 tfo->get_fabric_name(), (explicit) ? "explicit" : "implicit", 2403 core_scsi3_pr_dump_type(pr_reg->pr_res_type), 2404 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 2405 pr_debug("SPC-3 PR [%s] RELEASE Node: %s%s\n", 2406 tfo->get_fabric_name(), se_nacl->initiatorname, 2407 i_buf); 2408 /* 2409 * Clear TYPE and SCOPE for the next PROUT Service Action: RESERVE 2410 */ 2411 pr_reg->pr_res_holder = pr_reg->pr_res_type = pr_reg->pr_res_scope = 0; 2412 } 2413 2414 static sense_reason_t 2415 core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope, 2416 u64 res_key) 2417 { 2418 struct se_device *dev = cmd->se_dev; 2419 struct se_session *se_sess = cmd->se_sess; 2420 struct se_lun *se_lun = cmd->se_lun; 2421 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_res_holder; 2422 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2423 int all_reg = 0; 2424 sense_reason_t ret = 0; 2425 2426 if (!se_sess || !se_lun) { 2427 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n"); 2428 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2429 } 2430 /* 2431 * Locate the existing *pr_reg via struct se_node_acl pointers 2432 */ 2433 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess); 2434 if (!pr_reg) { 2435 pr_err("SPC-3 PR: Unable to locate" 2436 " PR_REGISTERED *pr_reg for RELEASE\n"); 2437 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2438 } 2439 /* 2440 * From spc4r17 Section 5.7.11.2 Releasing: 2441 * 2442 * If there is no persistent reservation or in response to a persistent 2443 * reservation release request from a registered I_T nexus that is not a 2444 * persistent reservation holder (see 5.7.10), the device server shall 2445 * do the following: 2446 * 2447 * a) Not release the persistent reservation, if any; 2448 * b) Not remove any registrations; and 2449 * c) Complete the command with GOOD status. 2450 */ 2451 spin_lock(&dev->dev_reservation_lock); 2452 pr_res_holder = dev->dev_pr_res_holder; 2453 if (!pr_res_holder) { 2454 /* 2455 * No persistent reservation, return GOOD status. 2456 */ 2457 spin_unlock(&dev->dev_reservation_lock); 2458 goto out_put_pr_reg; 2459 } 2460 if ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) || 2461 (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) 2462 all_reg = 1; 2463 2464 if ((all_reg == 0) && (pr_res_holder != pr_reg)) { 2465 /* 2466 * Non 'All Registrants' PR Type cases.. 2467 * Release request from a registered I_T nexus that is not a 2468 * persistent reservation holder. return GOOD status. 2469 */ 2470 spin_unlock(&dev->dev_reservation_lock); 2471 goto out_put_pr_reg; 2472 } 2473 2474 /* 2475 * From spc4r17 Section 5.7.11.2 Releasing: 2476 * 2477 * Only the persistent reservation holder (see 5.7.10) is allowed to 2478 * release a persistent reservation. 2479 * 2480 * An application client releases the persistent reservation by issuing 2481 * a PERSISTENT RESERVE OUT command with RELEASE service action through 2482 * an I_T nexus that is a persistent reservation holder with the 2483 * following parameters: 2484 * 2485 * a) RESERVATION KEY field set to the value of the reservation key 2486 * that is registered with the logical unit for the I_T nexus; 2487 */ 2488 if (res_key != pr_reg->pr_res_key) { 2489 pr_err("SPC-3 PR RELEASE: Received res_key: 0x%016Lx" 2490 " does not match existing SA REGISTER res_key:" 2491 " 0x%016Lx\n", res_key, pr_reg->pr_res_key); 2492 spin_unlock(&dev->dev_reservation_lock); 2493 ret = TCM_RESERVATION_CONFLICT; 2494 goto out_put_pr_reg; 2495 } 2496 /* 2497 * From spc4r17 Section 5.7.11.2 Releasing and above: 2498 * 2499 * b) TYPE field and SCOPE field set to match the persistent 2500 * reservation being released. 2501 */ 2502 if ((pr_res_holder->pr_res_type != type) || 2503 (pr_res_holder->pr_res_scope != scope)) { 2504 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl; 2505 pr_err("SPC-3 PR RELEASE: Attempted to release" 2506 " reservation from [%s]: %s with different TYPE " 2507 "and/or SCOPE while reservation already held by" 2508 " [%s]: %s, returning RESERVATION_CONFLICT\n", 2509 cmd->se_tfo->get_fabric_name(), 2510 se_sess->se_node_acl->initiatorname, 2511 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(), 2512 pr_res_holder->pr_reg_nacl->initiatorname); 2513 2514 spin_unlock(&dev->dev_reservation_lock); 2515 ret = TCM_RESERVATION_CONFLICT; 2516 goto out_put_pr_reg; 2517 } 2518 /* 2519 * In response to a persistent reservation release request from the 2520 * persistent reservation holder the device server shall perform a 2521 * release by doing the following as an uninterrupted series of actions: 2522 * a) Release the persistent reservation; 2523 * b) Not remove any registration(s); 2524 * c) If the released persistent reservation is a registrants only type 2525 * or all registrants type persistent reservation, 2526 * the device server shall establish a unit attention condition for 2527 * the initiator port associated with every regis- 2528 * tered I_T nexus other than I_T nexus on which the PERSISTENT 2529 * RESERVE OUT command with RELEASE service action was received, 2530 * with the additional sense code set to RESERVATIONS RELEASED; and 2531 * d) If the persistent reservation is of any other type, the device 2532 * server shall not establish a unit attention condition. 2533 */ 2534 __core_scsi3_complete_pro_release(dev, se_sess->se_node_acl, 2535 pr_reg, 1); 2536 2537 spin_unlock(&dev->dev_reservation_lock); 2538 2539 if ((type != PR_TYPE_WRITE_EXCLUSIVE_REGONLY) && 2540 (type != PR_TYPE_EXCLUSIVE_ACCESS_REGONLY) && 2541 (type != PR_TYPE_WRITE_EXCLUSIVE_ALLREG) && 2542 (type != PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) { 2543 /* 2544 * If no UNIT ATTENTION conditions will be established for 2545 * PR_TYPE_WRITE_EXCLUSIVE or PR_TYPE_EXCLUSIVE_ACCESS 2546 * go ahead and check for APTPL=1 update+write below 2547 */ 2548 goto write_aptpl; 2549 } 2550 2551 spin_lock(&pr_tmpl->registration_lock); 2552 list_for_each_entry(pr_reg_p, &pr_tmpl->registration_list, 2553 pr_reg_list) { 2554 /* 2555 * Do not establish a UNIT ATTENTION condition 2556 * for the calling I_T Nexus 2557 */ 2558 if (pr_reg_p == pr_reg) 2559 continue; 2560 2561 core_scsi3_ua_allocate(pr_reg_p->pr_reg_nacl, 2562 pr_reg_p->pr_res_mapped_lun, 2563 0x2A, ASCQ_2AH_RESERVATIONS_RELEASED); 2564 } 2565 spin_unlock(&pr_tmpl->registration_lock); 2566 2567 write_aptpl: 2568 if (pr_tmpl->pr_aptpl_active) 2569 core_scsi3_update_and_write_aptpl(cmd->se_dev, true); 2570 2571 out_put_pr_reg: 2572 core_scsi3_put_pr_reg(pr_reg); 2573 return ret; 2574 } 2575 2576 static sense_reason_t 2577 core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key) 2578 { 2579 struct se_device *dev = cmd->se_dev; 2580 struct se_node_acl *pr_reg_nacl; 2581 struct se_session *se_sess = cmd->se_sess; 2582 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2583 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder; 2584 u32 pr_res_mapped_lun = 0; 2585 int calling_it_nexus = 0; 2586 /* 2587 * Locate the existing *pr_reg via struct se_node_acl pointers 2588 */ 2589 pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev, 2590 se_sess->se_node_acl, se_sess); 2591 if (!pr_reg_n) { 2592 pr_err("SPC-3 PR: Unable to locate" 2593 " PR_REGISTERED *pr_reg for CLEAR\n"); 2594 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2595 } 2596 /* 2597 * From spc4r17 section 5.7.11.6, Clearing: 2598 * 2599 * Any application client may release the persistent reservation and 2600 * remove all registrations from a device server by issuing a 2601 * PERSISTENT RESERVE OUT command with CLEAR service action through a 2602 * registered I_T nexus with the following parameter: 2603 * 2604 * a) RESERVATION KEY field set to the value of the reservation key 2605 * that is registered with the logical unit for the I_T nexus. 2606 */ 2607 if (res_key != pr_reg_n->pr_res_key) { 2608 pr_err("SPC-3 PR REGISTER: Received" 2609 " res_key: 0x%016Lx does not match" 2610 " existing SA REGISTER res_key:" 2611 " 0x%016Lx\n", res_key, pr_reg_n->pr_res_key); 2612 core_scsi3_put_pr_reg(pr_reg_n); 2613 return TCM_RESERVATION_CONFLICT; 2614 } 2615 /* 2616 * a) Release the persistent reservation, if any; 2617 */ 2618 spin_lock(&dev->dev_reservation_lock); 2619 pr_res_holder = dev->dev_pr_res_holder; 2620 if (pr_res_holder) { 2621 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl; 2622 __core_scsi3_complete_pro_release(dev, pr_res_nacl, 2623 pr_res_holder, 0); 2624 } 2625 spin_unlock(&dev->dev_reservation_lock); 2626 /* 2627 * b) Remove all registration(s) (see spc4r17 5.7.7); 2628 */ 2629 spin_lock(&pr_tmpl->registration_lock); 2630 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 2631 &pr_tmpl->registration_list, pr_reg_list) { 2632 2633 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0; 2634 pr_reg_nacl = pr_reg->pr_reg_nacl; 2635 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2636 __core_scsi3_free_registration(dev, pr_reg, NULL, 2637 calling_it_nexus); 2638 /* 2639 * e) Establish a unit attention condition for the initiator 2640 * port associated with every registered I_T nexus other 2641 * than the I_T nexus on which the PERSISTENT RESERVE OUT 2642 * command with CLEAR service action was received, with the 2643 * additional sense code set to RESERVATIONS PREEMPTED. 2644 */ 2645 if (!calling_it_nexus) 2646 core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun, 2647 0x2A, ASCQ_2AH_RESERVATIONS_PREEMPTED); 2648 } 2649 spin_unlock(&pr_tmpl->registration_lock); 2650 2651 pr_debug("SPC-3 PR [%s] Service Action: CLEAR complete\n", 2652 cmd->se_tfo->get_fabric_name()); 2653 2654 core_scsi3_update_and_write_aptpl(cmd->se_dev, false); 2655 2656 core_scsi3_pr_generation(dev); 2657 return 0; 2658 } 2659 2660 /* 2661 * Called with struct se_device->dev_reservation_lock held. 2662 */ 2663 static void __core_scsi3_complete_pro_preempt( 2664 struct se_device *dev, 2665 struct t10_pr_registration *pr_reg, 2666 struct list_head *preempt_and_abort_list, 2667 int type, 2668 int scope, 2669 enum preempt_type preempt_type) 2670 { 2671 struct se_node_acl *nacl = pr_reg->pr_reg_nacl; 2672 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo; 2673 char i_buf[PR_REG_ISID_ID_LEN]; 2674 2675 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2676 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 2677 /* 2678 * Do an implicit RELEASE of the existing reservation. 2679 */ 2680 if (dev->dev_pr_res_holder) 2681 __core_scsi3_complete_pro_release(dev, nacl, 2682 dev->dev_pr_res_holder, 0); 2683 2684 dev->dev_pr_res_holder = pr_reg; 2685 pr_reg->pr_res_holder = 1; 2686 pr_reg->pr_res_type = type; 2687 pr_reg->pr_res_scope = scope; 2688 2689 pr_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new" 2690 " reservation holder TYPE: %s ALL_TG_PT: %d\n", 2691 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", 2692 core_scsi3_pr_dump_type(type), 2693 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 2694 pr_debug("SPC-3 PR [%s] PREEMPT%s from Node: %s%s\n", 2695 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", 2696 nacl->initiatorname, i_buf); 2697 /* 2698 * For PREEMPT_AND_ABORT, add the preempting reservation's 2699 * struct t10_pr_registration to the list that will be compared 2700 * against received CDBs.. 2701 */ 2702 if (preempt_and_abort_list) 2703 list_add_tail(&pr_reg->pr_reg_abort_list, 2704 preempt_and_abort_list); 2705 } 2706 2707 static void core_scsi3_release_preempt_and_abort( 2708 struct list_head *preempt_and_abort_list, 2709 struct t10_pr_registration *pr_reg_holder) 2710 { 2711 struct t10_pr_registration *pr_reg, *pr_reg_tmp; 2712 2713 list_for_each_entry_safe(pr_reg, pr_reg_tmp, preempt_and_abort_list, 2714 pr_reg_abort_list) { 2715 2716 list_del(&pr_reg->pr_reg_abort_list); 2717 if (pr_reg_holder == pr_reg) 2718 continue; 2719 if (pr_reg->pr_res_holder) { 2720 pr_warn("pr_reg->pr_res_holder still set\n"); 2721 continue; 2722 } 2723 2724 pr_reg->pr_reg_deve = NULL; 2725 pr_reg->pr_reg_nacl = NULL; 2726 kmem_cache_free(t10_pr_reg_cache, pr_reg); 2727 } 2728 } 2729 2730 static sense_reason_t 2731 core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key, 2732 u64 sa_res_key, enum preempt_type preempt_type) 2733 { 2734 struct se_device *dev = cmd->se_dev; 2735 struct se_node_acl *pr_reg_nacl; 2736 struct se_session *se_sess = cmd->se_sess; 2737 LIST_HEAD(preempt_and_abort_list); 2738 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder; 2739 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2740 u32 pr_res_mapped_lun = 0; 2741 int all_reg = 0, calling_it_nexus = 0, released_regs = 0; 2742 int prh_type = 0, prh_scope = 0; 2743 2744 if (!se_sess) 2745 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2746 2747 pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl, 2748 se_sess); 2749 if (!pr_reg_n) { 2750 pr_err("SPC-3 PR: Unable to locate" 2751 " PR_REGISTERED *pr_reg for PREEMPT%s\n", 2752 (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : ""); 2753 return TCM_RESERVATION_CONFLICT; 2754 } 2755 if (pr_reg_n->pr_res_key != res_key) { 2756 core_scsi3_put_pr_reg(pr_reg_n); 2757 return TCM_RESERVATION_CONFLICT; 2758 } 2759 if (scope != PR_SCOPE_LU_SCOPE) { 2760 pr_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope); 2761 core_scsi3_put_pr_reg(pr_reg_n); 2762 return TCM_INVALID_PARAMETER_LIST; 2763 } 2764 2765 spin_lock(&dev->dev_reservation_lock); 2766 pr_res_holder = dev->dev_pr_res_holder; 2767 if (pr_res_holder && 2768 ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) || 2769 (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG))) 2770 all_reg = 1; 2771 2772 if (!all_reg && !sa_res_key) { 2773 spin_unlock(&dev->dev_reservation_lock); 2774 core_scsi3_put_pr_reg(pr_reg_n); 2775 return TCM_INVALID_PARAMETER_LIST; 2776 } 2777 /* 2778 * From spc4r17, section 5.7.11.4.4 Removing Registrations: 2779 * 2780 * If the SERVICE ACTION RESERVATION KEY field does not identify a 2781 * persistent reservation holder or there is no persistent reservation 2782 * holder (i.e., there is no persistent reservation), then the device 2783 * server shall perform a preempt by doing the following in an 2784 * uninterrupted series of actions. (See below..) 2785 */ 2786 if (!pr_res_holder || (pr_res_holder->pr_res_key != sa_res_key)) { 2787 /* 2788 * No existing or SA Reservation Key matching reservations.. 2789 * 2790 * PROUT SA PREEMPT with All Registrant type reservations are 2791 * allowed to be processed without a matching SA Reservation Key 2792 */ 2793 spin_lock(&pr_tmpl->registration_lock); 2794 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 2795 &pr_tmpl->registration_list, pr_reg_list) { 2796 /* 2797 * Removing of registrations in non all registrants 2798 * type reservations without a matching SA reservation 2799 * key. 2800 * 2801 * a) Remove the registrations for all I_T nexuses 2802 * specified by the SERVICE ACTION RESERVATION KEY 2803 * field; 2804 * b) Ignore the contents of the SCOPE and TYPE fields; 2805 * c) Process tasks as defined in 5.7.1; and 2806 * d) Establish a unit attention condition for the 2807 * initiator port associated with every I_T nexus 2808 * that lost its registration other than the I_T 2809 * nexus on which the PERSISTENT RESERVE OUT command 2810 * was received, with the additional sense code set 2811 * to REGISTRATIONS PREEMPTED. 2812 */ 2813 if (!all_reg) { 2814 if (pr_reg->pr_res_key != sa_res_key) 2815 continue; 2816 2817 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0; 2818 pr_reg_nacl = pr_reg->pr_reg_nacl; 2819 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2820 __core_scsi3_free_registration(dev, pr_reg, 2821 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : 2822 NULL, calling_it_nexus); 2823 released_regs++; 2824 } else { 2825 /* 2826 * Case for any existing all registrants type 2827 * reservation, follow logic in spc4r17 section 2828 * 5.7.11.4 Preempting, Table 52 and Figure 7. 2829 * 2830 * For a ZERO SA Reservation key, release 2831 * all other registrations and do an implicit 2832 * release of active persistent reservation. 2833 * 2834 * For a non-ZERO SA Reservation key, only 2835 * release the matching reservation key from 2836 * registrations. 2837 */ 2838 if ((sa_res_key) && 2839 (pr_reg->pr_res_key != sa_res_key)) 2840 continue; 2841 2842 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0; 2843 if (calling_it_nexus) 2844 continue; 2845 2846 pr_reg_nacl = pr_reg->pr_reg_nacl; 2847 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2848 __core_scsi3_free_registration(dev, pr_reg, 2849 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : 2850 NULL, 0); 2851 released_regs++; 2852 } 2853 if (!calling_it_nexus) 2854 core_scsi3_ua_allocate(pr_reg_nacl, 2855 pr_res_mapped_lun, 0x2A, 2856 ASCQ_2AH_REGISTRATIONS_PREEMPTED); 2857 } 2858 spin_unlock(&pr_tmpl->registration_lock); 2859 /* 2860 * If a PERSISTENT RESERVE OUT with a PREEMPT service action or 2861 * a PREEMPT AND ABORT service action sets the SERVICE ACTION 2862 * RESERVATION KEY field to a value that does not match any 2863 * registered reservation key, then the device server shall 2864 * complete the command with RESERVATION CONFLICT status. 2865 */ 2866 if (!released_regs) { 2867 spin_unlock(&dev->dev_reservation_lock); 2868 core_scsi3_put_pr_reg(pr_reg_n); 2869 return TCM_RESERVATION_CONFLICT; 2870 } 2871 /* 2872 * For an existing all registrants type reservation 2873 * with a zero SA rservation key, preempt the existing 2874 * reservation with the new PR type and scope. 2875 */ 2876 if (pr_res_holder && all_reg && !(sa_res_key)) { 2877 __core_scsi3_complete_pro_preempt(dev, pr_reg_n, 2878 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL, 2879 type, scope, preempt_type); 2880 2881 if (preempt_type == PREEMPT_AND_ABORT) 2882 core_scsi3_release_preempt_and_abort( 2883 &preempt_and_abort_list, pr_reg_n); 2884 } 2885 spin_unlock(&dev->dev_reservation_lock); 2886 2887 if (pr_tmpl->pr_aptpl_active) 2888 core_scsi3_update_and_write_aptpl(cmd->se_dev, true); 2889 2890 core_scsi3_put_pr_reg(pr_reg_n); 2891 core_scsi3_pr_generation(cmd->se_dev); 2892 return 0; 2893 } 2894 /* 2895 * The PREEMPTing SA reservation key matches that of the 2896 * existing persistent reservation, first, we check if 2897 * we are preempting our own reservation. 2898 * From spc4r17, section 5.7.11.4.3 Preempting 2899 * persistent reservations and registration handling 2900 * 2901 * If an all registrants persistent reservation is not 2902 * present, it is not an error for the persistent 2903 * reservation holder to preempt itself (i.e., a 2904 * PERSISTENT RESERVE OUT with a PREEMPT service action 2905 * or a PREEMPT AND ABORT service action with the 2906 * SERVICE ACTION RESERVATION KEY value equal to the 2907 * persistent reservation holder's reservation key that 2908 * is received from the persistent reservation holder). 2909 * In that case, the device server shall establish the 2910 * new persistent reservation and maintain the 2911 * registration. 2912 */ 2913 prh_type = pr_res_holder->pr_res_type; 2914 prh_scope = pr_res_holder->pr_res_scope; 2915 /* 2916 * If the SERVICE ACTION RESERVATION KEY field identifies a 2917 * persistent reservation holder (see 5.7.10), the device 2918 * server shall perform a preempt by doing the following as 2919 * an uninterrupted series of actions: 2920 * 2921 * a) Release the persistent reservation for the holder 2922 * identified by the SERVICE ACTION RESERVATION KEY field; 2923 */ 2924 if (pr_reg_n != pr_res_holder) 2925 __core_scsi3_complete_pro_release(dev, 2926 pr_res_holder->pr_reg_nacl, 2927 dev->dev_pr_res_holder, 0); 2928 /* 2929 * b) Remove the registrations for all I_T nexuses identified 2930 * by the SERVICE ACTION RESERVATION KEY field, except the 2931 * I_T nexus that is being used for the PERSISTENT RESERVE 2932 * OUT command. If an all registrants persistent reservation 2933 * is present and the SERVICE ACTION RESERVATION KEY field 2934 * is set to zero, then all registrations shall be removed 2935 * except for that of the I_T nexus that is being used for 2936 * the PERSISTENT RESERVE OUT command; 2937 */ 2938 spin_lock(&pr_tmpl->registration_lock); 2939 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 2940 &pr_tmpl->registration_list, pr_reg_list) { 2941 2942 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0; 2943 if (calling_it_nexus) 2944 continue; 2945 2946 if (pr_reg->pr_res_key != sa_res_key) 2947 continue; 2948 2949 pr_reg_nacl = pr_reg->pr_reg_nacl; 2950 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2951 __core_scsi3_free_registration(dev, pr_reg, 2952 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL, 2953 calling_it_nexus); 2954 /* 2955 * e) Establish a unit attention condition for the initiator 2956 * port associated with every I_T nexus that lost its 2957 * persistent reservation and/or registration, with the 2958 * additional sense code set to REGISTRATIONS PREEMPTED; 2959 */ 2960 core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun, 0x2A, 2961 ASCQ_2AH_REGISTRATIONS_PREEMPTED); 2962 } 2963 spin_unlock(&pr_tmpl->registration_lock); 2964 /* 2965 * c) Establish a persistent reservation for the preempting 2966 * I_T nexus using the contents of the SCOPE and TYPE fields; 2967 */ 2968 __core_scsi3_complete_pro_preempt(dev, pr_reg_n, 2969 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL, 2970 type, scope, preempt_type); 2971 /* 2972 * d) Process tasks as defined in 5.7.1; 2973 * e) See above.. 2974 * f) If the type or scope has changed, then for every I_T nexus 2975 * whose reservation key was not removed, except for the I_T 2976 * nexus on which the PERSISTENT RESERVE OUT command was 2977 * received, the device server shall establish a unit 2978 * attention condition for the initiator port associated with 2979 * that I_T nexus, with the additional sense code set to 2980 * RESERVATIONS RELEASED. If the type or scope have not 2981 * changed, then no unit attention condition(s) shall be 2982 * established for this reason. 2983 */ 2984 if ((prh_type != type) || (prh_scope != scope)) { 2985 spin_lock(&pr_tmpl->registration_lock); 2986 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 2987 &pr_tmpl->registration_list, pr_reg_list) { 2988 2989 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0; 2990 if (calling_it_nexus) 2991 continue; 2992 2993 core_scsi3_ua_allocate(pr_reg->pr_reg_nacl, 2994 pr_reg->pr_res_mapped_lun, 0x2A, 2995 ASCQ_2AH_RESERVATIONS_RELEASED); 2996 } 2997 spin_unlock(&pr_tmpl->registration_lock); 2998 } 2999 spin_unlock(&dev->dev_reservation_lock); 3000 /* 3001 * Call LUN_RESET logic upon list of struct t10_pr_registration, 3002 * All received CDBs for the matching existing reservation and 3003 * registrations undergo ABORT_TASK logic. 3004 * 3005 * From there, core_scsi3_release_preempt_and_abort() will 3006 * release every registration in the list (which have already 3007 * been removed from the primary pr_reg list), except the 3008 * new persistent reservation holder, the calling Initiator Port. 3009 */ 3010 if (preempt_type == PREEMPT_AND_ABORT) { 3011 core_tmr_lun_reset(dev, NULL, &preempt_and_abort_list, cmd); 3012 core_scsi3_release_preempt_and_abort(&preempt_and_abort_list, 3013 pr_reg_n); 3014 } 3015 3016 if (pr_tmpl->pr_aptpl_active) 3017 core_scsi3_update_and_write_aptpl(cmd->se_dev, true); 3018 3019 core_scsi3_put_pr_reg(pr_reg_n); 3020 core_scsi3_pr_generation(cmd->se_dev); 3021 return 0; 3022 } 3023 3024 static sense_reason_t 3025 core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope, 3026 u64 res_key, u64 sa_res_key, enum preempt_type preempt_type) 3027 { 3028 switch (type) { 3029 case PR_TYPE_WRITE_EXCLUSIVE: 3030 case PR_TYPE_EXCLUSIVE_ACCESS: 3031 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY: 3032 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY: 3033 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG: 3034 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG: 3035 return core_scsi3_pro_preempt(cmd, type, scope, res_key, 3036 sa_res_key, preempt_type); 3037 default: 3038 pr_err("SPC-3 PR: Unknown Service Action PREEMPT%s" 3039 " Type: 0x%02x\n", (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type); 3040 return TCM_INVALID_CDB_FIELD; 3041 } 3042 } 3043 3044 3045 static sense_reason_t 3046 core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key, 3047 u64 sa_res_key, int aptpl, int unreg) 3048 { 3049 struct se_session *se_sess = cmd->se_sess; 3050 struct se_device *dev = cmd->se_dev; 3051 struct se_dev_entry *dest_se_deve = NULL; 3052 struct se_lun *se_lun = cmd->se_lun; 3053 struct se_node_acl *pr_res_nacl, *pr_reg_nacl, *dest_node_acl = NULL; 3054 struct se_port *se_port; 3055 struct se_portal_group *se_tpg, *dest_se_tpg = NULL; 3056 struct target_core_fabric_ops *dest_tf_ops = NULL, *tf_ops; 3057 struct t10_pr_registration *pr_reg, *pr_res_holder, *dest_pr_reg; 3058 struct t10_reservation *pr_tmpl = &dev->t10_pr; 3059 unsigned char *buf; 3060 unsigned char *initiator_str; 3061 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN]; 3062 u32 tid_len, tmp_tid_len; 3063 int new_reg = 0, type, scope, matching_iname; 3064 sense_reason_t ret; 3065 unsigned short rtpi; 3066 unsigned char proto_ident; 3067 3068 if (!se_sess || !se_lun) { 3069 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n"); 3070 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3071 } 3072 3073 memset(dest_iport, 0, 64); 3074 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 3075 se_tpg = se_sess->se_tpg; 3076 tf_ops = se_tpg->se_tpg_tfo; 3077 /* 3078 * Follow logic from spc4r17 Section 5.7.8, Table 50 -- 3079 * Register behaviors for a REGISTER AND MOVE service action 3080 * 3081 * Locate the existing *pr_reg via struct se_node_acl pointers 3082 */ 3083 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl, 3084 se_sess); 3085 if (!pr_reg) { 3086 pr_err("SPC-3 PR: Unable to locate PR_REGISTERED" 3087 " *pr_reg for REGISTER_AND_MOVE\n"); 3088 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3089 } 3090 /* 3091 * The provided reservation key much match the existing reservation key 3092 * provided during this initiator's I_T nexus registration. 3093 */ 3094 if (res_key != pr_reg->pr_res_key) { 3095 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Received" 3096 " res_key: 0x%016Lx does not match existing SA REGISTER" 3097 " res_key: 0x%016Lx\n", res_key, pr_reg->pr_res_key); 3098 ret = TCM_RESERVATION_CONFLICT; 3099 goto out_put_pr_reg; 3100 } 3101 /* 3102 * The service active reservation key needs to be non zero 3103 */ 3104 if (!sa_res_key) { 3105 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Received zero" 3106 " sa_res_key\n"); 3107 ret = TCM_INVALID_PARAMETER_LIST; 3108 goto out_put_pr_reg; 3109 } 3110 3111 /* 3112 * Determine the Relative Target Port Identifier where the reservation 3113 * will be moved to for the TransportID containing SCSI initiator WWN 3114 * information. 3115 */ 3116 buf = transport_kmap_data_sg(cmd); 3117 if (!buf) { 3118 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3119 goto out_put_pr_reg; 3120 } 3121 3122 rtpi = (buf[18] & 0xff) << 8; 3123 rtpi |= buf[19] & 0xff; 3124 tid_len = (buf[20] & 0xff) << 24; 3125 tid_len |= (buf[21] & 0xff) << 16; 3126 tid_len |= (buf[22] & 0xff) << 8; 3127 tid_len |= buf[23] & 0xff; 3128 transport_kunmap_data_sg(cmd); 3129 buf = NULL; 3130 3131 if ((tid_len + 24) != cmd->data_length) { 3132 pr_err("SPC-3 PR: Illegal tid_len: %u + 24 byte header" 3133 " does not equal CDB data_length: %u\n", tid_len, 3134 cmd->data_length); 3135 ret = TCM_INVALID_PARAMETER_LIST; 3136 goto out_put_pr_reg; 3137 } 3138 3139 spin_lock(&dev->se_port_lock); 3140 list_for_each_entry(se_port, &dev->dev_sep_list, sep_list) { 3141 if (se_port->sep_rtpi != rtpi) 3142 continue; 3143 dest_se_tpg = se_port->sep_tpg; 3144 if (!dest_se_tpg) 3145 continue; 3146 dest_tf_ops = dest_se_tpg->se_tpg_tfo; 3147 if (!dest_tf_ops) 3148 continue; 3149 3150 atomic_inc_mb(&dest_se_tpg->tpg_pr_ref_count); 3151 spin_unlock(&dev->se_port_lock); 3152 3153 if (core_scsi3_tpg_depend_item(dest_se_tpg)) { 3154 pr_err("core_scsi3_tpg_depend_item() failed" 3155 " for dest_se_tpg\n"); 3156 atomic_dec_mb(&dest_se_tpg->tpg_pr_ref_count); 3157 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3158 goto out_put_pr_reg; 3159 } 3160 3161 spin_lock(&dev->se_port_lock); 3162 break; 3163 } 3164 spin_unlock(&dev->se_port_lock); 3165 3166 if (!dest_se_tpg || !dest_tf_ops) { 3167 pr_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate" 3168 " fabric ops from Relative Target Port Identifier:" 3169 " %hu\n", rtpi); 3170 ret = TCM_INVALID_PARAMETER_LIST; 3171 goto out_put_pr_reg; 3172 } 3173 3174 buf = transport_kmap_data_sg(cmd); 3175 if (!buf) { 3176 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3177 goto out_put_pr_reg; 3178 } 3179 proto_ident = (buf[24] & 0x0f); 3180 3181 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:" 3182 " 0x%02x\n", proto_ident); 3183 3184 if (proto_ident != dest_tf_ops->get_fabric_proto_ident(dest_se_tpg)) { 3185 pr_err("SPC-3 PR REGISTER_AND_MOVE: Received" 3186 " proto_ident: 0x%02x does not match ident: 0x%02x" 3187 " from fabric: %s\n", proto_ident, 3188 dest_tf_ops->get_fabric_proto_ident(dest_se_tpg), 3189 dest_tf_ops->get_fabric_name()); 3190 ret = TCM_INVALID_PARAMETER_LIST; 3191 goto out; 3192 } 3193 if (dest_tf_ops->tpg_parse_pr_out_transport_id == NULL) { 3194 pr_err("SPC-3 PR REGISTER_AND_MOVE: Fabric does not" 3195 " containg a valid tpg_parse_pr_out_transport_id" 3196 " function pointer\n"); 3197 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3198 goto out; 3199 } 3200 initiator_str = dest_tf_ops->tpg_parse_pr_out_transport_id(dest_se_tpg, 3201 (const char *)&buf[24], &tmp_tid_len, &iport_ptr); 3202 if (!initiator_str) { 3203 pr_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate" 3204 " initiator_str from Transport ID\n"); 3205 ret = TCM_INVALID_PARAMETER_LIST; 3206 goto out; 3207 } 3208 3209 transport_kunmap_data_sg(cmd); 3210 buf = NULL; 3211 3212 pr_debug("SPC-3 PR [%s] Extracted initiator %s identifier: %s" 3213 " %s\n", dest_tf_ops->get_fabric_name(), (iport_ptr != NULL) ? 3214 "port" : "device", initiator_str, (iport_ptr != NULL) ? 3215 iport_ptr : ""); 3216 /* 3217 * If a PERSISTENT RESERVE OUT command with a REGISTER AND MOVE service 3218 * action specifies a TransportID that is the same as the initiator port 3219 * of the I_T nexus for the command received, then the command shall 3220 * be terminated with CHECK CONDITION status, with the sense key set to 3221 * ILLEGAL REQUEST, and the additional sense code set to INVALID FIELD 3222 * IN PARAMETER LIST. 3223 */ 3224 pr_reg_nacl = pr_reg->pr_reg_nacl; 3225 matching_iname = (!strcmp(initiator_str, 3226 pr_reg_nacl->initiatorname)) ? 1 : 0; 3227 if (!matching_iname) 3228 goto after_iport_check; 3229 3230 if (!iport_ptr || !pr_reg->isid_present_at_reg) { 3231 pr_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s" 3232 " matches: %s on received I_T Nexus\n", initiator_str, 3233 pr_reg_nacl->initiatorname); 3234 ret = TCM_INVALID_PARAMETER_LIST; 3235 goto out; 3236 } 3237 if (!strcmp(iport_ptr, pr_reg->pr_reg_isid)) { 3238 pr_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s %s" 3239 " matches: %s %s on received I_T Nexus\n", 3240 initiator_str, iport_ptr, pr_reg_nacl->initiatorname, 3241 pr_reg->pr_reg_isid); 3242 ret = TCM_INVALID_PARAMETER_LIST; 3243 goto out; 3244 } 3245 after_iport_check: 3246 /* 3247 * Locate the destination struct se_node_acl from the received Transport ID 3248 */ 3249 spin_lock_irq(&dest_se_tpg->acl_node_lock); 3250 dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg, 3251 initiator_str); 3252 if (dest_node_acl) 3253 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count); 3254 spin_unlock_irq(&dest_se_tpg->acl_node_lock); 3255 3256 if (!dest_node_acl) { 3257 pr_err("Unable to locate %s dest_node_acl for" 3258 " TransportID%s\n", dest_tf_ops->get_fabric_name(), 3259 initiator_str); 3260 ret = TCM_INVALID_PARAMETER_LIST; 3261 goto out; 3262 } 3263 3264 if (core_scsi3_nodeacl_depend_item(dest_node_acl)) { 3265 pr_err("core_scsi3_nodeacl_depend_item() for" 3266 " dest_node_acl\n"); 3267 atomic_dec_mb(&dest_node_acl->acl_pr_ref_count); 3268 dest_node_acl = NULL; 3269 ret = TCM_INVALID_PARAMETER_LIST; 3270 goto out; 3271 } 3272 3273 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl:" 3274 " %s from TransportID\n", dest_tf_ops->get_fabric_name(), 3275 dest_node_acl->initiatorname); 3276 3277 /* 3278 * Locate the struct se_dev_entry pointer for the matching RELATIVE TARGET 3279 * PORT IDENTIFIER. 3280 */ 3281 dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl, rtpi); 3282 if (!dest_se_deve) { 3283 pr_err("Unable to locate %s dest_se_deve from RTPI:" 3284 " %hu\n", dest_tf_ops->get_fabric_name(), rtpi); 3285 ret = TCM_INVALID_PARAMETER_LIST; 3286 goto out; 3287 } 3288 3289 if (core_scsi3_lunacl_depend_item(dest_se_deve)) { 3290 pr_err("core_scsi3_lunacl_depend_item() failed\n"); 3291 atomic_dec_mb(&dest_se_deve->pr_ref_count); 3292 dest_se_deve = NULL; 3293 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3294 goto out; 3295 } 3296 3297 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN" 3298 " ACL for dest_se_deve->mapped_lun: %u\n", 3299 dest_tf_ops->get_fabric_name(), dest_node_acl->initiatorname, 3300 dest_se_deve->mapped_lun); 3301 3302 /* 3303 * A persistent reservation needs to already existing in order to 3304 * successfully complete the REGISTER_AND_MOVE service action.. 3305 */ 3306 spin_lock(&dev->dev_reservation_lock); 3307 pr_res_holder = dev->dev_pr_res_holder; 3308 if (!pr_res_holder) { 3309 pr_warn("SPC-3 PR REGISTER_AND_MOVE: No reservation" 3310 " currently held\n"); 3311 spin_unlock(&dev->dev_reservation_lock); 3312 ret = TCM_INVALID_CDB_FIELD; 3313 goto out; 3314 } 3315 /* 3316 * The received on I_T Nexus must be the reservation holder. 3317 * 3318 * From spc4r17 section 5.7.8 Table 50 -- 3319 * Register behaviors for a REGISTER AND MOVE service action 3320 */ 3321 if (pr_res_holder != pr_reg) { 3322 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Calling I_T" 3323 " Nexus is not reservation holder\n"); 3324 spin_unlock(&dev->dev_reservation_lock); 3325 ret = TCM_RESERVATION_CONFLICT; 3326 goto out; 3327 } 3328 /* 3329 * From spc4r17 section 5.7.8: registering and moving reservation 3330 * 3331 * If a PERSISTENT RESERVE OUT command with a REGISTER AND MOVE service 3332 * action is received and the established persistent reservation is a 3333 * Write Exclusive - All Registrants type or Exclusive Access - 3334 * All Registrants type reservation, then the command shall be completed 3335 * with RESERVATION CONFLICT status. 3336 */ 3337 if ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) || 3338 (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) { 3339 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Unable to move" 3340 " reservation for type: %s\n", 3341 core_scsi3_pr_dump_type(pr_res_holder->pr_res_type)); 3342 spin_unlock(&dev->dev_reservation_lock); 3343 ret = TCM_RESERVATION_CONFLICT; 3344 goto out; 3345 } 3346 pr_res_nacl = pr_res_holder->pr_reg_nacl; 3347 /* 3348 * b) Ignore the contents of the (received) SCOPE and TYPE fields; 3349 */ 3350 type = pr_res_holder->pr_res_type; 3351 scope = pr_res_holder->pr_res_type; 3352 /* 3353 * c) Associate the reservation key specified in the SERVICE ACTION 3354 * RESERVATION KEY field with the I_T nexus specified as the 3355 * destination of the register and move, where: 3356 * A) The I_T nexus is specified by the TransportID and the 3357 * RELATIVE TARGET PORT IDENTIFIER field (see 6.14.4); and 3358 * B) Regardless of the TransportID format used, the association for 3359 * the initiator port is based on either the initiator port name 3360 * (see 3.1.71) on SCSI transport protocols where port names are 3361 * required or the initiator port identifier (see 3.1.70) on SCSI 3362 * transport protocols where port names are not required; 3363 * d) Register the reservation key specified in the SERVICE ACTION 3364 * RESERVATION KEY field; 3365 * e) Retain the reservation key specified in the SERVICE ACTION 3366 * RESERVATION KEY field and associated information; 3367 * 3368 * Also, It is not an error for a REGISTER AND MOVE service action to 3369 * register an I_T nexus that is already registered with the same 3370 * reservation key or a different reservation key. 3371 */ 3372 dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl, 3373 iport_ptr); 3374 if (!dest_pr_reg) { 3375 if (core_scsi3_alloc_registration(cmd->se_dev, 3376 dest_node_acl, dest_se_deve, iport_ptr, 3377 sa_res_key, 0, aptpl, 2, 1)) { 3378 spin_unlock(&dev->dev_reservation_lock); 3379 ret = TCM_INVALID_PARAMETER_LIST; 3380 goto out; 3381 } 3382 dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl, 3383 iport_ptr); 3384 new_reg = 1; 3385 } 3386 /* 3387 * f) Release the persistent reservation for the persistent reservation 3388 * holder (i.e., the I_T nexus on which the 3389 */ 3390 __core_scsi3_complete_pro_release(dev, pr_res_nacl, 3391 dev->dev_pr_res_holder, 0); 3392 /* 3393 * g) Move the persistent reservation to the specified I_T nexus using 3394 * the same scope and type as the persistent reservation released in 3395 * item f); and 3396 */ 3397 dev->dev_pr_res_holder = dest_pr_reg; 3398 dest_pr_reg->pr_res_holder = 1; 3399 dest_pr_reg->pr_res_type = type; 3400 pr_reg->pr_res_scope = scope; 3401 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 3402 /* 3403 * Increment PRGeneration for existing registrations.. 3404 */ 3405 if (!new_reg) 3406 dest_pr_reg->pr_res_generation = pr_tmpl->pr_generation++; 3407 spin_unlock(&dev->dev_reservation_lock); 3408 3409 pr_debug("SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE" 3410 " created new reservation holder TYPE: %s on object RTPI:" 3411 " %hu PRGeneration: 0x%08x\n", dest_tf_ops->get_fabric_name(), 3412 core_scsi3_pr_dump_type(type), rtpi, 3413 dest_pr_reg->pr_res_generation); 3414 pr_debug("SPC-3 PR Successfully moved reservation from" 3415 " %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n", 3416 tf_ops->get_fabric_name(), pr_reg_nacl->initiatorname, 3417 i_buf, dest_tf_ops->get_fabric_name(), 3418 dest_node_acl->initiatorname, (iport_ptr != NULL) ? 3419 iport_ptr : ""); 3420 /* 3421 * It is now safe to release configfs group dependencies for destination 3422 * of Transport ID Initiator Device/Port Identifier 3423 */ 3424 core_scsi3_lunacl_undepend_item(dest_se_deve); 3425 core_scsi3_nodeacl_undepend_item(dest_node_acl); 3426 core_scsi3_tpg_undepend_item(dest_se_tpg); 3427 /* 3428 * h) If the UNREG bit is set to one, unregister (see 5.7.11.3) the I_T 3429 * nexus on which PERSISTENT RESERVE OUT command was received. 3430 */ 3431 if (unreg) { 3432 spin_lock(&pr_tmpl->registration_lock); 3433 __core_scsi3_free_registration(dev, pr_reg, NULL, 1); 3434 spin_unlock(&pr_tmpl->registration_lock); 3435 } else 3436 core_scsi3_put_pr_reg(pr_reg); 3437 3438 core_scsi3_update_and_write_aptpl(cmd->se_dev, aptpl); 3439 3440 transport_kunmap_data_sg(cmd); 3441 3442 core_scsi3_put_pr_reg(dest_pr_reg); 3443 return 0; 3444 out: 3445 if (buf) 3446 transport_kunmap_data_sg(cmd); 3447 if (dest_se_deve) 3448 core_scsi3_lunacl_undepend_item(dest_se_deve); 3449 if (dest_node_acl) 3450 core_scsi3_nodeacl_undepend_item(dest_node_acl); 3451 core_scsi3_tpg_undepend_item(dest_se_tpg); 3452 3453 out_put_pr_reg: 3454 core_scsi3_put_pr_reg(pr_reg); 3455 return ret; 3456 } 3457 3458 static unsigned long long core_scsi3_extract_reservation_key(unsigned char *cdb) 3459 { 3460 unsigned int __v1, __v2; 3461 3462 __v1 = (cdb[0] << 24) | (cdb[1] << 16) | (cdb[2] << 8) | cdb[3]; 3463 __v2 = (cdb[4] << 24) | (cdb[5] << 16) | (cdb[6] << 8) | cdb[7]; 3464 3465 return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 3466 } 3467 3468 /* 3469 * See spc4r17 section 6.14 Table 170 3470 */ 3471 sense_reason_t 3472 target_scsi3_emulate_pr_out(struct se_cmd *cmd) 3473 { 3474 struct se_device *dev = cmd->se_dev; 3475 unsigned char *cdb = &cmd->t_task_cdb[0]; 3476 unsigned char *buf; 3477 u64 res_key, sa_res_key; 3478 int sa, scope, type, aptpl; 3479 int spec_i_pt = 0, all_tg_pt = 0, unreg = 0; 3480 sense_reason_t ret; 3481 3482 /* 3483 * Following spc2r20 5.5.1 Reservations overview: 3484 * 3485 * If a logical unit has been reserved by any RESERVE command and is 3486 * still reserved by any initiator, all PERSISTENT RESERVE IN and all 3487 * PERSISTENT RESERVE OUT commands shall conflict regardless of 3488 * initiator or service action and shall terminate with a RESERVATION 3489 * CONFLICT status. 3490 */ 3491 if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) { 3492 pr_err("Received PERSISTENT_RESERVE CDB while legacy" 3493 " SPC-2 reservation is held, returning" 3494 " RESERVATION_CONFLICT\n"); 3495 return TCM_RESERVATION_CONFLICT; 3496 } 3497 3498 /* 3499 * FIXME: A NULL struct se_session pointer means an this is not coming from 3500 * a $FABRIC_MOD's nexus, but from internal passthrough ops. 3501 */ 3502 if (!cmd->se_sess) 3503 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3504 3505 if (cmd->data_length < 24) { 3506 pr_warn("SPC-PR: Received PR OUT parameter list" 3507 " length too small: %u\n", cmd->data_length); 3508 return TCM_INVALID_PARAMETER_LIST; 3509 } 3510 3511 /* 3512 * From the PERSISTENT_RESERVE_OUT command descriptor block (CDB) 3513 */ 3514 sa = (cdb[1] & 0x1f); 3515 scope = (cdb[2] & 0xf0); 3516 type = (cdb[2] & 0x0f); 3517 3518 buf = transport_kmap_data_sg(cmd); 3519 if (!buf) 3520 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3521 3522 /* 3523 * From PERSISTENT_RESERVE_OUT parameter list (payload) 3524 */ 3525 res_key = core_scsi3_extract_reservation_key(&buf[0]); 3526 sa_res_key = core_scsi3_extract_reservation_key(&buf[8]); 3527 /* 3528 * REGISTER_AND_MOVE uses a different SA parameter list containing 3529 * SCSI TransportIDs. 3530 */ 3531 if (sa != PRO_REGISTER_AND_MOVE) { 3532 spec_i_pt = (buf[20] & 0x08); 3533 all_tg_pt = (buf[20] & 0x04); 3534 aptpl = (buf[20] & 0x01); 3535 } else { 3536 aptpl = (buf[17] & 0x01); 3537 unreg = (buf[17] & 0x02); 3538 } 3539 /* 3540 * If the backend device has been configured to force APTPL metadata 3541 * write-out, go ahead and propigate aptpl=1 down now. 3542 */ 3543 if (dev->dev_attrib.force_pr_aptpl) 3544 aptpl = 1; 3545 3546 transport_kunmap_data_sg(cmd); 3547 buf = NULL; 3548 3549 /* 3550 * SPEC_I_PT=1 is only valid for Service action: REGISTER 3551 */ 3552 if (spec_i_pt && ((cdb[1] & 0x1f) != PRO_REGISTER)) 3553 return TCM_INVALID_PARAMETER_LIST; 3554 3555 /* 3556 * From spc4r17 section 6.14: 3557 * 3558 * If the SPEC_I_PT bit is set to zero, the service action is not 3559 * REGISTER AND MOVE, and the parameter list length is not 24, then 3560 * the command shall be terminated with CHECK CONDITION status, with 3561 * the sense key set to ILLEGAL REQUEST, and the additional sense 3562 * code set to PARAMETER LIST LENGTH ERROR. 3563 */ 3564 if (!spec_i_pt && ((cdb[1] & 0x1f) != PRO_REGISTER_AND_MOVE) && 3565 (cmd->data_length != 24)) { 3566 pr_warn("SPC-PR: Received PR OUT illegal parameter" 3567 " list length: %u\n", cmd->data_length); 3568 return TCM_INVALID_PARAMETER_LIST; 3569 } 3570 3571 /* 3572 * (core_scsi3_emulate_pro_* function parameters 3573 * are defined by spc4r17 Table 174: 3574 * PERSISTENT_RESERVE_OUT service actions and valid parameters. 3575 */ 3576 switch (sa) { 3577 case PRO_REGISTER: 3578 ret = core_scsi3_emulate_pro_register(cmd, 3579 res_key, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER); 3580 break; 3581 case PRO_RESERVE: 3582 ret = core_scsi3_emulate_pro_reserve(cmd, type, scope, res_key); 3583 break; 3584 case PRO_RELEASE: 3585 ret = core_scsi3_emulate_pro_release(cmd, type, scope, res_key); 3586 break; 3587 case PRO_CLEAR: 3588 ret = core_scsi3_emulate_pro_clear(cmd, res_key); 3589 break; 3590 case PRO_PREEMPT: 3591 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope, 3592 res_key, sa_res_key, PREEMPT); 3593 break; 3594 case PRO_PREEMPT_AND_ABORT: 3595 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope, 3596 res_key, sa_res_key, PREEMPT_AND_ABORT); 3597 break; 3598 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY: 3599 ret = core_scsi3_emulate_pro_register(cmd, 3600 0, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER_AND_IGNORE_EXISTING_KEY); 3601 break; 3602 case PRO_REGISTER_AND_MOVE: 3603 ret = core_scsi3_emulate_pro_register_and_move(cmd, res_key, 3604 sa_res_key, aptpl, unreg); 3605 break; 3606 default: 3607 pr_err("Unknown PERSISTENT_RESERVE_OUT service" 3608 " action: 0x%02x\n", cdb[1] & 0x1f); 3609 return TCM_INVALID_CDB_FIELD; 3610 } 3611 3612 if (!ret) 3613 target_complete_cmd(cmd, GOOD); 3614 return ret; 3615 } 3616 3617 /* 3618 * PERSISTENT_RESERVE_IN Service Action READ_KEYS 3619 * 3620 * See spc4r17 section 5.7.6.2 and section 6.13.2, Table 160 3621 */ 3622 static sense_reason_t 3623 core_scsi3_pri_read_keys(struct se_cmd *cmd) 3624 { 3625 struct se_device *dev = cmd->se_dev; 3626 struct t10_pr_registration *pr_reg; 3627 unsigned char *buf; 3628 u32 add_len = 0, off = 8; 3629 3630 if (cmd->data_length < 8) { 3631 pr_err("PRIN SA READ_KEYS SCSI Data Length: %u" 3632 " too small\n", cmd->data_length); 3633 return TCM_INVALID_CDB_FIELD; 3634 } 3635 3636 buf = transport_kmap_data_sg(cmd); 3637 if (!buf) 3638 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3639 3640 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff); 3641 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff); 3642 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff); 3643 buf[3] = (dev->t10_pr.pr_generation & 0xff); 3644 3645 spin_lock(&dev->t10_pr.registration_lock); 3646 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list, 3647 pr_reg_list) { 3648 /* 3649 * Check for overflow of 8byte PRI READ_KEYS payload and 3650 * next reservation key list descriptor. 3651 */ 3652 if ((add_len + 8) > (cmd->data_length - 8)) 3653 break; 3654 3655 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff); 3656 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff); 3657 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff); 3658 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff); 3659 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff); 3660 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff); 3661 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff); 3662 buf[off++] = (pr_reg->pr_res_key & 0xff); 3663 3664 add_len += 8; 3665 } 3666 spin_unlock(&dev->t10_pr.registration_lock); 3667 3668 buf[4] = ((add_len >> 24) & 0xff); 3669 buf[5] = ((add_len >> 16) & 0xff); 3670 buf[6] = ((add_len >> 8) & 0xff); 3671 buf[7] = (add_len & 0xff); 3672 3673 transport_kunmap_data_sg(cmd); 3674 3675 return 0; 3676 } 3677 3678 /* 3679 * PERSISTENT_RESERVE_IN Service Action READ_RESERVATION 3680 * 3681 * See spc4r17 section 5.7.6.3 and section 6.13.3.2 Table 161 and 162 3682 */ 3683 static sense_reason_t 3684 core_scsi3_pri_read_reservation(struct se_cmd *cmd) 3685 { 3686 struct se_device *dev = cmd->se_dev; 3687 struct t10_pr_registration *pr_reg; 3688 unsigned char *buf; 3689 u64 pr_res_key; 3690 u32 add_len = 16; /* Hardcoded to 16 when a reservation is held. */ 3691 3692 if (cmd->data_length < 8) { 3693 pr_err("PRIN SA READ_RESERVATIONS SCSI Data Length: %u" 3694 " too small\n", cmd->data_length); 3695 return TCM_INVALID_CDB_FIELD; 3696 } 3697 3698 buf = transport_kmap_data_sg(cmd); 3699 if (!buf) 3700 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3701 3702 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff); 3703 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff); 3704 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff); 3705 buf[3] = (dev->t10_pr.pr_generation & 0xff); 3706 3707 spin_lock(&dev->dev_reservation_lock); 3708 pr_reg = dev->dev_pr_res_holder; 3709 if (pr_reg) { 3710 /* 3711 * Set the hardcoded Additional Length 3712 */ 3713 buf[4] = ((add_len >> 24) & 0xff); 3714 buf[5] = ((add_len >> 16) & 0xff); 3715 buf[6] = ((add_len >> 8) & 0xff); 3716 buf[7] = (add_len & 0xff); 3717 3718 if (cmd->data_length < 22) 3719 goto err; 3720 3721 /* 3722 * Set the Reservation key. 3723 * 3724 * From spc4r17, section 5.7.10: 3725 * A persistent reservation holder has its reservation key 3726 * returned in the parameter data from a PERSISTENT 3727 * RESERVE IN command with READ RESERVATION service action as 3728 * follows: 3729 * a) For a persistent reservation of the type Write Exclusive 3730 * - All Registrants or Exclusive Access All Regitrants, 3731 * the reservation key shall be set to zero; or 3732 * b) For all other persistent reservation types, the 3733 * reservation key shall be set to the registered 3734 * reservation key for the I_T nexus that holds the 3735 * persistent reservation. 3736 */ 3737 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) || 3738 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) 3739 pr_res_key = 0; 3740 else 3741 pr_res_key = pr_reg->pr_res_key; 3742 3743 buf[8] = ((pr_res_key >> 56) & 0xff); 3744 buf[9] = ((pr_res_key >> 48) & 0xff); 3745 buf[10] = ((pr_res_key >> 40) & 0xff); 3746 buf[11] = ((pr_res_key >> 32) & 0xff); 3747 buf[12] = ((pr_res_key >> 24) & 0xff); 3748 buf[13] = ((pr_res_key >> 16) & 0xff); 3749 buf[14] = ((pr_res_key >> 8) & 0xff); 3750 buf[15] = (pr_res_key & 0xff); 3751 /* 3752 * Set the SCOPE and TYPE 3753 */ 3754 buf[21] = (pr_reg->pr_res_scope & 0xf0) | 3755 (pr_reg->pr_res_type & 0x0f); 3756 } 3757 3758 err: 3759 spin_unlock(&dev->dev_reservation_lock); 3760 transport_kunmap_data_sg(cmd); 3761 3762 return 0; 3763 } 3764 3765 /* 3766 * PERSISTENT_RESERVE_IN Service Action REPORT_CAPABILITIES 3767 * 3768 * See spc4r17 section 6.13.4 Table 165 3769 */ 3770 static sense_reason_t 3771 core_scsi3_pri_report_capabilities(struct se_cmd *cmd) 3772 { 3773 struct se_device *dev = cmd->se_dev; 3774 struct t10_reservation *pr_tmpl = &dev->t10_pr; 3775 unsigned char *buf; 3776 u16 add_len = 8; /* Hardcoded to 8. */ 3777 3778 if (cmd->data_length < 6) { 3779 pr_err("PRIN SA REPORT_CAPABILITIES SCSI Data Length:" 3780 " %u too small\n", cmd->data_length); 3781 return TCM_INVALID_CDB_FIELD; 3782 } 3783 3784 buf = transport_kmap_data_sg(cmd); 3785 if (!buf) 3786 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3787 3788 buf[0] = ((add_len >> 8) & 0xff); 3789 buf[1] = (add_len & 0xff); 3790 buf[2] |= 0x10; /* CRH: Compatible Reservation Hanlding bit. */ 3791 buf[2] |= 0x08; /* SIP_C: Specify Initiator Ports Capable bit */ 3792 buf[2] |= 0x04; /* ATP_C: All Target Ports Capable bit */ 3793 buf[2] |= 0x01; /* PTPL_C: Persistence across Target Power Loss bit */ 3794 /* 3795 * We are filling in the PERSISTENT RESERVATION TYPE MASK below, so 3796 * set the TMV: Task Mask Valid bit. 3797 */ 3798 buf[3] |= 0x80; 3799 /* 3800 * Change ALLOW COMMANDs to 0x20 or 0x40 later from Table 166 3801 */ 3802 buf[3] |= 0x10; /* ALLOW COMMANDs field 001b */ 3803 /* 3804 * PTPL_A: Persistence across Target Power Loss Active bit 3805 */ 3806 if (pr_tmpl->pr_aptpl_active) 3807 buf[3] |= 0x01; 3808 /* 3809 * Setup the PERSISTENT RESERVATION TYPE MASK from Table 167 3810 */ 3811 buf[4] |= 0x80; /* PR_TYPE_EXCLUSIVE_ACCESS_ALLREG */ 3812 buf[4] |= 0x40; /* PR_TYPE_EXCLUSIVE_ACCESS_REGONLY */ 3813 buf[4] |= 0x20; /* PR_TYPE_WRITE_EXCLUSIVE_REGONLY */ 3814 buf[4] |= 0x08; /* PR_TYPE_EXCLUSIVE_ACCESS */ 3815 buf[4] |= 0x02; /* PR_TYPE_WRITE_EXCLUSIVE */ 3816 buf[5] |= 0x01; /* PR_TYPE_EXCLUSIVE_ACCESS_ALLREG */ 3817 3818 transport_kunmap_data_sg(cmd); 3819 3820 return 0; 3821 } 3822 3823 /* 3824 * PERSISTENT_RESERVE_IN Service Action READ_FULL_STATUS 3825 * 3826 * See spc4r17 section 6.13.5 Table 168 and 169 3827 */ 3828 static sense_reason_t 3829 core_scsi3_pri_read_full_status(struct se_cmd *cmd) 3830 { 3831 struct se_device *dev = cmd->se_dev; 3832 struct se_node_acl *se_nacl; 3833 struct se_portal_group *se_tpg; 3834 struct t10_pr_registration *pr_reg, *pr_reg_tmp; 3835 struct t10_reservation *pr_tmpl = &dev->t10_pr; 3836 unsigned char *buf; 3837 u32 add_desc_len = 0, add_len = 0, desc_len, exp_desc_len; 3838 u32 off = 8; /* off into first Full Status descriptor */ 3839 int format_code = 0; 3840 3841 if (cmd->data_length < 8) { 3842 pr_err("PRIN SA READ_FULL_STATUS SCSI Data Length: %u" 3843 " too small\n", cmd->data_length); 3844 return TCM_INVALID_CDB_FIELD; 3845 } 3846 3847 buf = transport_kmap_data_sg(cmd); 3848 if (!buf) 3849 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 3850 3851 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff); 3852 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff); 3853 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff); 3854 buf[3] = (dev->t10_pr.pr_generation & 0xff); 3855 3856 spin_lock(&pr_tmpl->registration_lock); 3857 list_for_each_entry_safe(pr_reg, pr_reg_tmp, 3858 &pr_tmpl->registration_list, pr_reg_list) { 3859 3860 se_nacl = pr_reg->pr_reg_nacl; 3861 se_tpg = pr_reg->pr_reg_nacl->se_tpg; 3862 add_desc_len = 0; 3863 3864 atomic_inc_mb(&pr_reg->pr_res_holders); 3865 spin_unlock(&pr_tmpl->registration_lock); 3866 /* 3867 * Determine expected length of $FABRIC_MOD specific 3868 * TransportID full status descriptor.. 3869 */ 3870 exp_desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id_len( 3871 se_tpg, se_nacl, pr_reg, &format_code); 3872 3873 if ((exp_desc_len + add_len) > cmd->data_length) { 3874 pr_warn("SPC-3 PRIN READ_FULL_STATUS ran" 3875 " out of buffer: %d\n", cmd->data_length); 3876 spin_lock(&pr_tmpl->registration_lock); 3877 atomic_dec_mb(&pr_reg->pr_res_holders); 3878 break; 3879 } 3880 /* 3881 * Set RESERVATION KEY 3882 */ 3883 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff); 3884 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff); 3885 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff); 3886 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff); 3887 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff); 3888 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff); 3889 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff); 3890 buf[off++] = (pr_reg->pr_res_key & 0xff); 3891 off += 4; /* Skip Over Reserved area */ 3892 3893 /* 3894 * Set ALL_TG_PT bit if PROUT SA REGISTER had this set. 3895 */ 3896 if (pr_reg->pr_reg_all_tg_pt) 3897 buf[off] = 0x02; 3898 /* 3899 * The struct se_lun pointer will be present for the 3900 * reservation holder for PR_HOLDER bit. 3901 * 3902 * Also, if this registration is the reservation 3903 * holder, fill in SCOPE and TYPE in the next byte. 3904 */ 3905 if (pr_reg->pr_res_holder) { 3906 buf[off++] |= 0x01; 3907 buf[off++] = (pr_reg->pr_res_scope & 0xf0) | 3908 (pr_reg->pr_res_type & 0x0f); 3909 } else 3910 off += 2; 3911 3912 off += 4; /* Skip over reserved area */ 3913 /* 3914 * From spc4r17 6.3.15: 3915 * 3916 * If the ALL_TG_PT bit set to zero, the RELATIVE TARGET PORT 3917 * IDENTIFIER field contains the relative port identifier (see 3918 * 3.1.120) of the target port that is part of the I_T nexus 3919 * described by this full status descriptor. If the ALL_TG_PT 3920 * bit is set to one, the contents of the RELATIVE TARGET PORT 3921 * IDENTIFIER field are not defined by this standard. 3922 */ 3923 if (!pr_reg->pr_reg_all_tg_pt) { 3924 struct se_port *port = pr_reg->pr_reg_tg_pt_lun->lun_sep; 3925 3926 buf[off++] = ((port->sep_rtpi >> 8) & 0xff); 3927 buf[off++] = (port->sep_rtpi & 0xff); 3928 } else 3929 off += 2; /* Skip over RELATIVE TARGET PORT IDENTIFIER */ 3930 3931 /* 3932 * Now, have the $FABRIC_MOD fill in the protocol identifier 3933 */ 3934 desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id(se_tpg, 3935 se_nacl, pr_reg, &format_code, &buf[off+4]); 3936 3937 spin_lock(&pr_tmpl->registration_lock); 3938 atomic_dec_mb(&pr_reg->pr_res_holders); 3939 /* 3940 * Set the ADDITIONAL DESCRIPTOR LENGTH 3941 */ 3942 buf[off++] = ((desc_len >> 24) & 0xff); 3943 buf[off++] = ((desc_len >> 16) & 0xff); 3944 buf[off++] = ((desc_len >> 8) & 0xff); 3945 buf[off++] = (desc_len & 0xff); 3946 /* 3947 * Size of full desctipor header minus TransportID 3948 * containing $FABRIC_MOD specific) initiator device/port 3949 * WWN information. 3950 * 3951 * See spc4r17 Section 6.13.5 Table 169 3952 */ 3953 add_desc_len = (24 + desc_len); 3954 3955 off += desc_len; 3956 add_len += add_desc_len; 3957 } 3958 spin_unlock(&pr_tmpl->registration_lock); 3959 /* 3960 * Set ADDITIONAL_LENGTH 3961 */ 3962 buf[4] = ((add_len >> 24) & 0xff); 3963 buf[5] = ((add_len >> 16) & 0xff); 3964 buf[6] = ((add_len >> 8) & 0xff); 3965 buf[7] = (add_len & 0xff); 3966 3967 transport_kunmap_data_sg(cmd); 3968 3969 return 0; 3970 } 3971 3972 sense_reason_t 3973 target_scsi3_emulate_pr_in(struct se_cmd *cmd) 3974 { 3975 sense_reason_t ret; 3976 3977 /* 3978 * Following spc2r20 5.5.1 Reservations overview: 3979 * 3980 * If a logical unit has been reserved by any RESERVE command and is 3981 * still reserved by any initiator, all PERSISTENT RESERVE IN and all 3982 * PERSISTENT RESERVE OUT commands shall conflict regardless of 3983 * initiator or service action and shall terminate with a RESERVATION 3984 * CONFLICT status. 3985 */ 3986 if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) { 3987 pr_err("Received PERSISTENT_RESERVE CDB while legacy" 3988 " SPC-2 reservation is held, returning" 3989 " RESERVATION_CONFLICT\n"); 3990 return TCM_RESERVATION_CONFLICT; 3991 } 3992 3993 switch (cmd->t_task_cdb[1] & 0x1f) { 3994 case PRI_READ_KEYS: 3995 ret = core_scsi3_pri_read_keys(cmd); 3996 break; 3997 case PRI_READ_RESERVATION: 3998 ret = core_scsi3_pri_read_reservation(cmd); 3999 break; 4000 case PRI_REPORT_CAPABILITIES: 4001 ret = core_scsi3_pri_report_capabilities(cmd); 4002 break; 4003 case PRI_READ_FULL_STATUS: 4004 ret = core_scsi3_pri_read_full_status(cmd); 4005 break; 4006 default: 4007 pr_err("Unknown PERSISTENT_RESERVE_IN service" 4008 " action: 0x%02x\n", cmd->t_task_cdb[1] & 0x1f); 4009 return TCM_INVALID_CDB_FIELD; 4010 } 4011 4012 if (!ret) 4013 target_complete_cmd(cmd, GOOD); 4014 return ret; 4015 } 4016 4017 sense_reason_t 4018 target_check_reservation(struct se_cmd *cmd) 4019 { 4020 struct se_device *dev = cmd->se_dev; 4021 sense_reason_t ret; 4022 4023 if (!cmd->se_sess) 4024 return 0; 4025 if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE) 4026 return 0; 4027 if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) 4028 return 0; 4029 4030 spin_lock(&dev->dev_reservation_lock); 4031 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) 4032 ret = target_scsi2_reservation_check(cmd); 4033 else 4034 ret = target_scsi3_pr_reservation_check(cmd); 4035 spin_unlock(&dev->dev_reservation_lock); 4036 4037 return ret; 4038 } 4039