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