drivers/target/target_core_alua.c

   1 /*******************************************************************************
   2  * Filename:  target_core_alua.c
   3  *
   4  * This file contains SPC-3 compliant asymmetric logical unit assigntment (ALUA)
   5  *
   6  * (c) Copyright 2009-2013 Datera, Inc.
   7  *
   8  * Nicholas A. Bellinger <nab@kernel.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  ******************************************************************************/
  25
  26 #include <linux/slab.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/configfs.h>
  29 #include <linux/export.h>
  30 #include <linux/file.h>
  31 #include <scsi/scsi_proto.h>
  32 #include <asm/unaligned.h>
  33
  34 #include <target/target_core_base.h>
  35 #include <target/target_core_backend.h>
  36 #include <target/target_core_fabric.h>
  37 #include <target/target_core_configfs.h>
  38
  39 #include "target_core_internal.h"
  40 #include "target_core_alua.h"
  41 #include "target_core_ua.h"
  42
  43 static sense_reason_t core_alua_check_transition(int state, int valid,
  44                                                  int *primary);
  45 static int core_alua_set_tg_pt_secondary_state(
  46                 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
  47                 struct se_port *port, int explicit, int offline);
  48
  49 static char *core_alua_dump_state(int state);
  50
  51 static u16 alua_lu_gps_counter;
  52 static u32 alua_lu_gps_count;
  53
  54 static DEFINE_SPINLOCK(lu_gps_lock);
  55 static LIST_HEAD(lu_gps_list);
  56
  57 struct t10_alua_lu_gp *default_lu_gp;
  58
  59 /*
  60  * REPORT REFERRALS
  61  *
  62  * See sbc3r35 section 5.23
  63  */
  64 sense_reason_t
  65 target_emulate_report_referrals(struct se_cmd *cmd)
  66 {
  67         struct se_device *dev = cmd->se_dev;
  68         struct t10_alua_lba_map *map;
  69         struct t10_alua_lba_map_member *map_mem;
  70         unsigned char *buf;
  71         u32 rd_len = 0, off;
  72
  73         if (cmd->data_length < 4) {
  74                 pr_warn("REPORT REFERRALS allocation length %u too"
  75                         " small\n", cmd->data_length);
  76                 return TCM_INVALID_CDB_FIELD;
  77         }
  78
  79         buf = transport_kmap_data_sg(cmd);
  80         if (!buf)
  81                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
  82
  83         off = 4;
  84         spin_lock(&dev->t10_alua.lba_map_lock);
  85         if (list_empty(&dev->t10_alua.lba_map_list)) {
  86                 spin_unlock(&dev->t10_alua.lba_map_lock);
  87                 transport_kunmap_data_sg(cmd);
  88
  89                 return TCM_UNSUPPORTED_SCSI_OPCODE;
  90         }
  91
  92         list_for_each_entry(map, &dev->t10_alua.lba_map_list,
  93                             lba_map_list) {
  94                 int desc_num = off + 3;
  95                 int pg_num;
  96
  97                 off += 4;
  98                 if (cmd->data_length > off)
  99                         put_unaligned_be64(map->lba_map_first_lba, &buf[off]);
 100                 off += 8;
 101                 if (cmd->data_length > off)
 102                         put_unaligned_be64(map->lba_map_last_lba, &buf[off]);
 103                 off += 8;
 104                 rd_len += 20;
 105                 pg_num = 0;
 106                 list_for_each_entry(map_mem, &map->lba_map_mem_list,
 107                                     lba_map_mem_list) {
 108                         int alua_state = map_mem->lba_map_mem_alua_state;
 109                         int alua_pg_id = map_mem->lba_map_mem_alua_pg_id;
 110
 111                         if (cmd->data_length > off)
 112                                 buf[off] = alua_state & 0x0f;
 113                         off += 2;
 114                         if (cmd->data_length > off)
 115                                 buf[off] = (alua_pg_id >> 8) & 0xff;
 116                         off++;
 117                         if (cmd->data_length > off)
 118                                 buf[off] = (alua_pg_id & 0xff);
 119                         off++;
 120                         rd_len += 4;
 121                         pg_num++;
 122                 }
 123                 if (cmd->data_length > desc_num)
 124                         buf[desc_num] = pg_num;
 125         }
 126         spin_unlock(&dev->t10_alua.lba_map_lock);
 127
 128         /*
 129          * Set the RETURN DATA LENGTH set in the header of the DataIN Payload
 130          */
 131         put_unaligned_be16(rd_len, &buf[2]);
 132
 133         transport_kunmap_data_sg(cmd);
 134
 135         target_complete_cmd(cmd, GOOD);
 136         return 0;
 137 }
 138
 139 /*
 140  * REPORT_TARGET_PORT_GROUPS
 141  *
 142  * See spc4r17 section 6.27
 143  */
 144 sense_reason_t
 145 target_emulate_report_target_port_groups(struct se_cmd *cmd)
 146 {
 147         struct se_device *dev = cmd->se_dev;
 148         struct se_port *port;
 149         struct t10_alua_tg_pt_gp *tg_pt_gp;
 150         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 151         unsigned char *buf;
 152         u32 rd_len = 0, off;
 153         int ext_hdr = (cmd->t_task_cdb[1] & 0x20);
 154
 155         /*
 156          * Skip over RESERVED area to first Target port group descriptor
 157          * depending on the PARAMETER DATA FORMAT type..
 158          */
 159         if (ext_hdr != 0)
 160                 off = 8;
 161         else
 162                 off = 4;
 163
 164         if (cmd->data_length < off) {
 165                 pr_warn("REPORT TARGET PORT GROUPS allocation length %u too"
 166                         " small for %s header\n", cmd->data_length,
 167                         (ext_hdr) ? "extended" : "normal");
 168                 return TCM_INVALID_CDB_FIELD;
 169         }
 170         buf = transport_kmap_data_sg(cmd);
 171         if (!buf)
 172                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 173
 174         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
 175         list_for_each_entry(tg_pt_gp, &dev->t10_alua.tg_pt_gps_list,
 176                         tg_pt_gp_list) {
 177                 /*
 178                  * Check if the Target port group and Target port descriptor list
 179                  * based on tg_pt_gp_members count will fit into the response payload.
 180                  * Otherwise, bump rd_len to let the initiator know we have exceeded
 181                  * the allocation length and the response is truncated.
 182                  */
 183                 if ((off + 8 + (tg_pt_gp->tg_pt_gp_members * 4)) >
 184                      cmd->data_length) {
 185                         rd_len += 8 + (tg_pt_gp->tg_pt_gp_members * 4);
 186                         continue;
 187                 }
 188                 /*
 189                  * PREF: Preferred target port bit, determine if this
 190                  * bit should be set for port group.
 191                  */
 192                 if (tg_pt_gp->tg_pt_gp_pref)
 193                         buf[off] = 0x80;
 194                 /*
 195                  * Set the ASYMMETRIC ACCESS State
 196                  */
 197                 buf[off++] |= (atomic_read(
 198                         &tg_pt_gp->tg_pt_gp_alua_access_state) & 0xff);
 199                 /*
 200                  * Set supported ASYMMETRIC ACCESS State bits
 201                  */
 202                 buf[off++] |= tg_pt_gp->tg_pt_gp_alua_supported_states;
 203                 /*
 204                  * TARGET PORT GROUP
 205                  */
 206                 buf[off++] = ((tg_pt_gp->tg_pt_gp_id >> 8) & 0xff);
 207                 buf[off++] = (tg_pt_gp->tg_pt_gp_id & 0xff);
 208
 209                 off++; /* Skip over Reserved */
 210                 /*
 211                  * STATUS CODE
 212                  */
 213                 buf[off++] = (tg_pt_gp->tg_pt_gp_alua_access_status & 0xff);
 214                 /*
 215                  * Vendor Specific field
 216                  */
 217                 buf[off++] = 0x00;
 218                 /*
 219                  * TARGET PORT COUNT
 220                  */
 221                 buf[off++] = (tg_pt_gp->tg_pt_gp_members & 0xff);
 222                 rd_len += 8;
 223
 224                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
 225                 list_for_each_entry(tg_pt_gp_mem, &tg_pt_gp->tg_pt_gp_mem_list,
 226                                 tg_pt_gp_mem_list) {
 227                         port = tg_pt_gp_mem->tg_pt;
 228                         /*
 229                          * Start Target Port descriptor format
 230                          *
 231                          * See spc4r17 section 6.2.7 Table 247
 232                          */
 233                         off += 2; /* Skip over Obsolete */
 234                         /*
 235                          * Set RELATIVE TARGET PORT IDENTIFIER
 236                          */
 237                         buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
 238                         buf[off++] = (port->sep_rtpi & 0xff);
 239                         rd_len += 4;
 240                 }
 241                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
 242         }
 243         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 244         /*
 245          * Set the RETURN DATA LENGTH set in the header of the DataIN Payload
 246          */
 247         put_unaligned_be32(rd_len, &buf[0]);
 248
 249         /*
 250          * Fill in the Extended header parameter data format if requested
 251          */
 252         if (ext_hdr != 0) {
 253                 buf[4] = 0x10;
 254                 /*
 255                  * Set the implicit transition time (in seconds) for the application
 256                  * client to use as a base for it's transition timeout value.
 257                  *
 258                  * Use the current tg_pt_gp_mem -> tg_pt_gp membership from the LUN
 259                  * this CDB was received upon to determine this value individually
 260                  * for ALUA target port group.
 261                  */
 262                 port = cmd->se_lun->lun_sep;
 263                 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
 264                 if (tg_pt_gp_mem) {
 265                         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 266                         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
 267                         if (tg_pt_gp)
 268                                 buf[5] = tg_pt_gp->tg_pt_gp_implicit_trans_secs;
 269                         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 270                 }
 271         }
 272         transport_kunmap_data_sg(cmd);
 273
 274         target_complete_cmd(cmd, GOOD);
 275         return 0;
 276 }
 277
 278 /*
 279  * SET_TARGET_PORT_GROUPS for explicit ALUA operation.
 280  *
 281  * See spc4r17 section 6.35
 282  */
 283 sense_reason_t
 284 target_emulate_set_target_port_groups(struct se_cmd *cmd)
 285 {
 286         struct se_device *dev = cmd->se_dev;
 287         struct se_port *port, *l_port = cmd->se_lun->lun_sep;
 288         struct se_node_acl *nacl = cmd->se_sess->se_node_acl;
 289         struct t10_alua_tg_pt_gp *tg_pt_gp = NULL, *l_tg_pt_gp;
 290         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem, *l_tg_pt_gp_mem;
 291         unsigned char *buf;
 292         unsigned char *ptr;
 293         sense_reason_t rc = TCM_NO_SENSE;
 294         u32 len = 4; /* Skip over RESERVED area in header */
 295         int alua_access_state, primary = 0, valid_states;
 296         u16 tg_pt_id, rtpi;
 297
 298         if (!l_port)
 299                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 300
 301         if (cmd->data_length < 4) {
 302                 pr_warn("SET TARGET PORT GROUPS parameter list length %u too"
 303                         " small\n", cmd->data_length);
 304                 return TCM_INVALID_PARAMETER_LIST;
 305         }
 306
 307         buf = transport_kmap_data_sg(cmd);
 308         if (!buf)
 309                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 310
 311         /*
 312          * Determine if explicit ALUA via SET_TARGET_PORT_GROUPS is allowed
 313          * for the local tg_pt_gp.
 314          */
 315         l_tg_pt_gp_mem = l_port->sep_alua_tg_pt_gp_mem;
 316         if (!l_tg_pt_gp_mem) {
 317                 pr_err("Unable to access l_port->sep_alua_tg_pt_gp_mem\n");
 318                 rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 319                 goto out;
 320         }
 321         spin_lock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
 322         l_tg_pt_gp = l_tg_pt_gp_mem->tg_pt_gp;
 323         if (!l_tg_pt_gp) {
 324                 spin_unlock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
 325                 pr_err("Unable to access *l_tg_pt_gp_mem->tg_pt_gp\n");
 326                 rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 327                 goto out;
 328         }
 329         spin_unlock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
 330
 331         if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
 332                 pr_debug("Unable to process SET_TARGET_PORT_GROUPS"
 333                                 " while TPGS_EXPLICIT_ALUA is disabled\n");
 334                 rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 335                 goto out;
 336         }
 337         valid_states = l_tg_pt_gp->tg_pt_gp_alua_supported_states;
 338
 339         ptr = &buf[4]; /* Skip over RESERVED area in header */
 340
 341         while (len < cmd->data_length) {
 342                 bool found = false;
 343                 alua_access_state = (ptr[0] & 0x0f);
 344                 /*
 345                  * Check the received ALUA access state, and determine if
 346                  * the state is a primary or secondary target port asymmetric
 347                  * access state.
 348                  */
 349                 rc = core_alua_check_transition(alua_access_state,
 350                                                 valid_states, &primary);
 351                 if (rc) {
 352                         /*
 353                          * If the SET TARGET PORT GROUPS attempts to establish
 354                          * an invalid combination of target port asymmetric
 355                          * access states or attempts to establish an
 356                          * unsupported target port asymmetric access state,
 357                          * then the command shall be terminated with CHECK
 358                          * CONDITION status, with the sense key set to ILLEGAL
 359                          * REQUEST, and the additional sense code set to INVALID
 360                          * FIELD IN PARAMETER LIST.
 361                          */
 362                         goto out;
 363                 }
 364
 365                 /*
 366                  * If the ASYMMETRIC ACCESS STATE field (see table 267)
 367                  * specifies a primary target port asymmetric access state,
 368                  * then the TARGET PORT GROUP OR TARGET PORT field specifies
 369                  * a primary target port group for which the primary target
 370                  * port asymmetric access state shall be changed. If the
 371                  * ASYMMETRIC ACCESS STATE field specifies a secondary target
 372                  * port asymmetric access state, then the TARGET PORT GROUP OR
 373                  * TARGET PORT field specifies the relative target port
 374                  * identifier (see 3.1.120) of the target port for which the
 375                  * secondary target port asymmetric access state shall be
 376                  * changed.
 377                  */
 378                 if (primary) {
 379                         tg_pt_id = get_unaligned_be16(ptr + 2);
 380                         /*
 381                          * Locate the matching target port group ID from
 382                          * the global tg_pt_gp list
 383                          */
 384                         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
 385                         list_for_each_entry(tg_pt_gp,
 386                                         &dev->t10_alua.tg_pt_gps_list,
 387                                         tg_pt_gp_list) {
 388                                 if (!tg_pt_gp->tg_pt_gp_valid_id)
 389                                         continue;
 390
 391                                 if (tg_pt_id != tg_pt_gp->tg_pt_gp_id)
 392                                         continue;
 393
 394                                 atomic_inc_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
 395
 396                                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 397
 398                                 if (!core_alua_do_port_transition(tg_pt_gp,
 399                                                 dev, l_port, nacl,
 400                                                 alua_access_state, 1))
 401                                         found = true;
 402
 403                                 spin_lock(&dev->t10_alua.tg_pt_gps_lock);
 404                                 atomic_dec_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
 405                                 break;
 406                         }
 407                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 408                 } else {
 409                         /*
 410                          * Extract the RELATIVE TARGET PORT IDENTIFIER to identify
 411                          * the Target Port in question for the the incoming
 412                          * SET_TARGET_PORT_GROUPS op.
 413                          */
 414                         rtpi = get_unaligned_be16(ptr + 2);
 415                         /*
 416                          * Locate the matching relative target port identifier
 417                          * for the struct se_device storage object.
 418                          */
 419                         spin_lock(&dev->se_port_lock);
 420                         list_for_each_entry(port, &dev->dev_sep_list,
 421                                                         sep_list) {
 422                                 if (port->sep_rtpi != rtpi)
 423                                         continue;
 424
 425                                 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
 426
 427                                 spin_unlock(&dev->se_port_lock);
 428
 429                                 if (!core_alua_set_tg_pt_secondary_state(
 430                                                 tg_pt_gp_mem, port, 1, 1))
 431                                         found = true;
 432
 433                                 spin_lock(&dev->se_port_lock);
 434                                 break;
 435                         }
 436                         spin_unlock(&dev->se_port_lock);
 437                 }
 438
 439                 if (!found) {
 440                         rc = TCM_INVALID_PARAMETER_LIST;
 441                         goto out;
 442                 }
 443
 444                 ptr += 4;
 445                 len += 4;
 446         }
 447
 448 out:
 449         transport_kunmap_data_sg(cmd);
 450         if (!rc)
 451                 target_complete_cmd(cmd, GOOD);
 452         return rc;
 453 }
 454
 455 static inline void set_ascq(struct se_cmd *cmd, u8 alua_ascq)
 456 {
 457         /*
 458          * Set SCSI additional sense code (ASC) to 'LUN Not Accessible';
 459          * The ALUA additional sense code qualifier (ASCQ) is determined
 460          * by the ALUA primary or secondary access state..
 461          */
 462         pr_debug("[%s]: ALUA TG Port not available, "
 463                 "SenseKey: NOT_READY, ASC/ASCQ: "
 464                 "0x04/0x%02x\n",
 465                 cmd->se_tfo->get_fabric_name(), alua_ascq);
 466
 467         cmd->scsi_asc = 0x04;
 468         cmd->scsi_ascq = alua_ascq;
 469 }
 470
 471 static inline void core_alua_state_nonoptimized(
 472         struct se_cmd *cmd,
 473         unsigned char *cdb,
 474         int nonop_delay_msecs)
 475 {
 476         /*
 477          * Set SCF_ALUA_NON_OPTIMIZED here, this value will be checked
 478          * later to determine if processing of this cmd needs to be
 479          * temporarily delayed for the Active/NonOptimized primary access state.
 480          */
 481         cmd->se_cmd_flags |= SCF_ALUA_NON_OPTIMIZED;
 482         cmd->alua_nonop_delay = nonop_delay_msecs;
 483 }
 484
 485 static inline int core_alua_state_lba_dependent(
 486         struct se_cmd *cmd,
 487         struct t10_alua_tg_pt_gp *tg_pt_gp)
 488 {
 489         struct se_device *dev = cmd->se_dev;
 490         u64 segment_size, segment_mult, sectors, lba;
 491
 492         /* Only need to check for cdb actually containing LBAs */
 493         if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB))
 494                 return 0;
 495
 496         spin_lock(&dev->t10_alua.lba_map_lock);
 497         segment_size = dev->t10_alua.lba_map_segment_size;
 498         segment_mult = dev->t10_alua.lba_map_segment_multiplier;
 499         sectors = cmd->data_length / dev->dev_attrib.block_size;
 500
 501         lba = cmd->t_task_lba;
 502         while (lba < cmd->t_task_lba + sectors) {
 503                 struct t10_alua_lba_map *cur_map = NULL, *map;
 504                 struct t10_alua_lba_map_member *map_mem;
 505
 506                 list_for_each_entry(map, &dev->t10_alua.lba_map_list,
 507                                     lba_map_list) {
 508                         u64 start_lba, last_lba;
 509                         u64 first_lba = map->lba_map_first_lba;
 510
 511                         if (segment_mult) {
 512                                 u64 tmp = lba;
 513                                 start_lba = do_div(tmp, segment_size * segment_mult);
 514
 515                                 last_lba = first_lba + segment_size - 1;
 516                                 if (start_lba >= first_lba &&
 517                                     start_lba <= last_lba) {
 518                                         lba += segment_size;
 519                                         cur_map = map;
 520                                         break;
 521                                 }
 522                         } else {
 523                                 last_lba = map->lba_map_last_lba;
 524                                 if (lba >= first_lba && lba <= last_lba) {
 525                                         lba = last_lba + 1;
 526                                         cur_map = map;
 527                                         break;
 528                                 }
 529                         }
 530                 }
 531                 if (!cur_map) {
 532                         spin_unlock(&dev->t10_alua.lba_map_lock);
 533                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE);
 534                         return 1;
 535                 }
 536                 list_for_each_entry(map_mem, &cur_map->lba_map_mem_list,
 537                                     lba_map_mem_list) {
 538                         if (map_mem->lba_map_mem_alua_pg_id !=
 539                             tg_pt_gp->tg_pt_gp_id)
 540                                 continue;
 541                         switch(map_mem->lba_map_mem_alua_state) {
 542                         case ALUA_ACCESS_STATE_STANDBY:
 543                                 spin_unlock(&dev->t10_alua.lba_map_lock);
 544                                 set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY);
 545                                 return 1;
 546                         case ALUA_ACCESS_STATE_UNAVAILABLE:
 547                                 spin_unlock(&dev->t10_alua.lba_map_lock);
 548                                 set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE);
 549                                 return 1;
 550                         default:
 551                                 break;
 552                         }
 553                 }
 554         }
 555         spin_unlock(&dev->t10_alua.lba_map_lock);
 556         return 0;
 557 }
 558
 559 static inline int core_alua_state_standby(
 560         struct se_cmd *cmd,
 561         unsigned char *cdb)
 562 {
 563         /*
 564          * Allowed CDBs for ALUA_ACCESS_STATE_STANDBY as defined by
 565          * spc4r17 section 5.9.2.4.4
 566          */
 567         switch (cdb[0]) {
 568         case INQUIRY:
 569         case LOG_SELECT:
 570         case LOG_SENSE:
 571         case MODE_SELECT:
 572         case MODE_SENSE:
 573         case REPORT_LUNS:
 574         case RECEIVE_DIAGNOSTIC:
 575         case SEND_DIAGNOSTIC:
 576         case READ_CAPACITY:
 577                 return 0;
 578         case SERVICE_ACTION_IN_16:
 579                 switch (cdb[1] & 0x1f) {
 580                 case SAI_READ_CAPACITY_16:
 581                         return 0;
 582                 default:
 583                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY);
 584                         return 1;
 585                 }
 586         case MAINTENANCE_IN:
 587                 switch (cdb[1] & 0x1f) {
 588                 case MI_REPORT_TARGET_PGS:
 589                         return 0;
 590                 default:
 591                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY);
 592                         return 1;
 593                 }
 594         case MAINTENANCE_OUT:
 595                 switch (cdb[1]) {
 596                 case MO_SET_TARGET_PGS:
 597                         return 0;
 598                 default:
 599                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY);
 600                         return 1;
 601                 }
 602         case REQUEST_SENSE:
 603         case PERSISTENT_RESERVE_IN:
 604         case PERSISTENT_RESERVE_OUT:
 605         case READ_BUFFER:
 606         case WRITE_BUFFER:
 607                 return 0;
 608         default:
 609                 set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY);
 610                 return 1;
 611         }
 612
 613         return 0;
 614 }
 615
 616 static inline int core_alua_state_unavailable(
 617         struct se_cmd *cmd,
 618         unsigned char *cdb)
 619 {
 620         /*
 621          * Allowed CDBs for ALUA_ACCESS_STATE_UNAVAILABLE as defined by
 622          * spc4r17 section 5.9.2.4.5
 623          */
 624         switch (cdb[0]) {
 625         case INQUIRY:
 626         case REPORT_LUNS:
 627                 return 0;
 628         case MAINTENANCE_IN:
 629                 switch (cdb[1] & 0x1f) {
 630                 case MI_REPORT_TARGET_PGS:
 631                         return 0;
 632                 default:
 633                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE);
 634                         return 1;
 635                 }
 636         case MAINTENANCE_OUT:
 637                 switch (cdb[1]) {
 638                 case MO_SET_TARGET_PGS:
 639                         return 0;
 640                 default:
 641                         set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE);
 642                         return 1;
 643                 }
 644         case REQUEST_SENSE:
 645         case READ_BUFFER:
 646         case WRITE_BUFFER:
 647                 return 0;
 648         default:
 649                 set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE);
 650                 return 1;
 651         }
 652
 653         return 0;
 654 }
 655
 656 static inline int core_alua_state_transition(
 657         struct se_cmd *cmd,
 658         unsigned char *cdb)
 659 {
 660         /*
 661          * Allowed CDBs for ALUA_ACCESS_STATE_TRANSITION as defined by
 662          * spc4r17 section 5.9.2.5
 663          */
 664         switch (cdb[0]) {
 665         case INQUIRY:
 666         case REPORT_LUNS:
 667                 return 0;
 668         case MAINTENANCE_IN:
 669                 switch (cdb[1] & 0x1f) {
 670                 case MI_REPORT_TARGET_PGS:
 671                         return 0;
 672                 default:
 673                         set_ascq(cmd, ASCQ_04H_ALUA_STATE_TRANSITION);
 674                         return 1;
 675                 }
 676         case REQUEST_SENSE:
 677         case READ_BUFFER:
 678         case WRITE_BUFFER:
 679                 return 0;
 680         default:
 681                 set_ascq(cmd, ASCQ_04H_ALUA_STATE_TRANSITION);
 682                 return 1;
 683         }
 684
 685         return 0;
 686 }
 687
 688 /*
 689  * return 1: Is used to signal LUN not accessible, and check condition/not ready
 690  * return 0: Used to signal success
 691  * return -1: Used to signal failure, and invalid cdb field
 692  */
 693 sense_reason_t
 694 target_alua_state_check(struct se_cmd *cmd)
 695 {
 696         struct se_device *dev = cmd->se_dev;
 697         unsigned char *cdb = cmd->t_task_cdb;
 698         struct se_lun *lun = cmd->se_lun;
 699         struct se_port *port = lun->lun_sep;
 700         struct t10_alua_tg_pt_gp *tg_pt_gp;
 701         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 702         int out_alua_state, nonop_delay_msecs;
 703
 704         if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)
 705                 return 0;
 706         if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH)
 707                 return 0;
 708
 709         if (!port)
 710                 return 0;
 711         /*
 712          * First, check for a struct se_port specific secondary ALUA target port
 713          * access state: OFFLINE
 714          */
 715         if (atomic_read(&port->sep_tg_pt_secondary_offline)) {
 716                 pr_debug("ALUA: Got secondary offline status for local"
 717                                 " target port\n");
 718                 set_ascq(cmd, ASCQ_04H_ALUA_OFFLINE);
 719                 return TCM_CHECK_CONDITION_NOT_READY;
 720         }
 721          /*
 722          * Second, obtain the struct t10_alua_tg_pt_gp_member pointer to the
 723          * ALUA target port group, to obtain current ALUA access state.
 724          * Otherwise look for the underlying struct se_device association with
 725          * a ALUA logical unit group.
 726          */
 727         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
 728         if (!tg_pt_gp_mem)
 729                 return 0;
 730
 731         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 732         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
 733         out_alua_state = atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state);
 734         nonop_delay_msecs = tg_pt_gp->tg_pt_gp_nonop_delay_msecs;
 735         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 736         /*
 737          * Process ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED in a separate conditional
 738          * statement so the compiler knows explicitly to check this case first.
 739          * For the Optimized ALUA access state case, we want to process the
 740          * incoming fabric cmd ASAP..
 741          */
 742         if (out_alua_state == ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED)
 743                 return 0;
 744
 745         switch (out_alua_state) {
 746         case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
 747                 core_alua_state_nonoptimized(cmd, cdb, nonop_delay_msecs);
 748                 break;
 749         case ALUA_ACCESS_STATE_STANDBY:
 750                 if (core_alua_state_standby(cmd, cdb))
 751                         return TCM_CHECK_CONDITION_NOT_READY;
 752                 break;
 753         case ALUA_ACCESS_STATE_UNAVAILABLE:
 754                 if (core_alua_state_unavailable(cmd, cdb))
 755                         return TCM_CHECK_CONDITION_NOT_READY;
 756                 break;
 757         case ALUA_ACCESS_STATE_TRANSITION:
 758                 if (core_alua_state_transition(cmd, cdb))
 759                         return TCM_CHECK_CONDITION_NOT_READY;
 760                 break;
 761         case ALUA_ACCESS_STATE_LBA_DEPENDENT:
 762                 if (core_alua_state_lba_dependent(cmd, tg_pt_gp))
 763                         return TCM_CHECK_CONDITION_NOT_READY;
 764                 break;
 765         /*
 766          * OFFLINE is a secondary ALUA target port group access state, that is
 767          * handled above with struct se_port->sep_tg_pt_secondary_offline=1
 768          */
 769         case ALUA_ACCESS_STATE_OFFLINE:
 770         default:
 771                 pr_err("Unknown ALUA access state: 0x%02x\n",
 772                                 out_alua_state);
 773                 return TCM_INVALID_CDB_FIELD;
 774         }
 775
 776         return 0;
 777 }
 778
 779 /*
 780  * Check implicit and explicit ALUA state change request.
 781  */
 782 static sense_reason_t
 783 core_alua_check_transition(int state, int valid, int *primary)
 784 {
 785         /*
 786          * OPTIMIZED, NON-OPTIMIZED, STANDBY and UNAVAILABLE are
 787          * defined as primary target port asymmetric access states.
 788          */
 789         switch (state) {
 790         case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED:
 791                 if (!(valid & ALUA_AO_SUP))
 792                         goto not_supported;
 793                 *primary = 1;
 794                 break;
 795         case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
 796                 if (!(valid & ALUA_AN_SUP))
 797                         goto not_supported;
 798                 *primary = 1;
 799                 break;
 800         case ALUA_ACCESS_STATE_STANDBY:
 801                 if (!(valid & ALUA_S_SUP))
 802                         goto not_supported;
 803                 *primary = 1;
 804                 break;
 805         case ALUA_ACCESS_STATE_UNAVAILABLE:
 806                 if (!(valid & ALUA_U_SUP))
 807                         goto not_supported;
 808                 *primary = 1;
 809                 break;
 810         case ALUA_ACCESS_STATE_LBA_DEPENDENT:
 811                 if (!(valid & ALUA_LBD_SUP))
 812                         goto not_supported;
 813                 *primary = 1;
 814                 break;
 815         case ALUA_ACCESS_STATE_OFFLINE:
 816                 /*
 817                  * OFFLINE state is defined as a secondary target port
 818                  * asymmetric access state.
 819                  */
 820                 if (!(valid & ALUA_O_SUP))
 821                         goto not_supported;
 822                 *primary = 0;
 823                 break;
 824         case ALUA_ACCESS_STATE_TRANSITION:
 825                 /*
 826                  * Transitioning is set internally, and
 827                  * cannot be selected manually.
 828                  */
 829                 goto not_supported;
 830         default:
 831                 pr_err("Unknown ALUA access state: 0x%02x\n", state);
 832                 return TCM_INVALID_PARAMETER_LIST;
 833         }
 834
 835         return 0;
 836
 837 not_supported:
 838         pr_err("ALUA access state %s not supported",
 839                core_alua_dump_state(state));
 840         return TCM_INVALID_PARAMETER_LIST;
 841 }
 842
 843 static char *core_alua_dump_state(int state)
 844 {
 845         switch (state) {
 846         case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED:
 847                 return "Active/Optimized";
 848         case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
 849                 return "Active/NonOptimized";
 850         case ALUA_ACCESS_STATE_LBA_DEPENDENT:
 851                 return "LBA Dependent";
 852         case ALUA_ACCESS_STATE_STANDBY:
 853                 return "Standby";
 854         case ALUA_ACCESS_STATE_UNAVAILABLE:
 855                 return "Unavailable";
 856         case ALUA_ACCESS_STATE_OFFLINE:
 857                 return "Offline";
 858         case ALUA_ACCESS_STATE_TRANSITION:
 859                 return "Transitioning";
 860         default:
 861                 return "Unknown";
 862         }
 863
 864         return NULL;
 865 }
 866
 867 char *core_alua_dump_status(int status)
 868 {
 869         switch (status) {
 870         case ALUA_STATUS_NONE:
 871                 return "None";
 872         case ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG:
 873                 return "Altered by Explicit STPG";
 874         case ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA:
 875                 return "Altered by Implicit ALUA";
 876         default:
 877                 return "Unknown";
 878         }
 879
 880         return NULL;
 881 }
 882
 883 /*
 884  * Used by fabric modules to determine when we need to delay processing
 885  * for the Active/NonOptimized paths..
 886  */
 887 int core_alua_check_nonop_delay(
 888         struct se_cmd *cmd)
 889 {
 890         if (!(cmd->se_cmd_flags & SCF_ALUA_NON_OPTIMIZED))
 891                 return 0;
 892         if (in_interrupt())
 893                 return 0;
 894         /*
 895          * The ALUA Active/NonOptimized access state delay can be disabled
 896          * in via configfs with a value of zero
 897          */
 898         if (!cmd->alua_nonop_delay)
 899                 return 0;
 900         /*
 901          * struct se_cmd->alua_nonop_delay gets set by a target port group
 902          * defined interval in core_alua_state_nonoptimized()
 903          */
 904         msleep_interruptible(cmd->alua_nonop_delay);
 905         return 0;
 906 }
 907 EXPORT_SYMBOL(core_alua_check_nonop_delay);
 908
 909 /*
 910  * Called with tg_pt_gp->tg_pt_gp_md_mutex or tg_pt_gp_mem->sep_tg_pt_md_mutex
 911  *
 912  */
 913 static int core_alua_write_tpg_metadata(
 914         const char *path,
 915         unsigned char *md_buf,
 916         u32 md_buf_len)
 917 {
 918         struct file *file = filp_open(path, O_RDWR | O_CREAT | O_TRUNC, 0600);
 919         int ret;
 920
 921         if (IS_ERR(file)) {
 922                 pr_err("filp_open(%s) for ALUA metadata failed\n", path);
 923                 return -ENODEV;
 924         }
 925         ret = kernel_write(file, md_buf, md_buf_len, 0);
 926         if (ret < 0)
 927                 pr_err("Error writing ALUA metadata file: %s\n", path);
 928         fput(file);
 929         return (ret < 0) ? -EIO : 0;
 930 }
 931
 932 /*
 933  * Called with tg_pt_gp->tg_pt_gp_md_mutex held
 934  */
 935 static int core_alua_update_tpg_primary_metadata(
 936         struct t10_alua_tg_pt_gp *tg_pt_gp)
 937 {
 938         unsigned char *md_buf;
 939         struct t10_wwn *wwn = &tg_pt_gp->tg_pt_gp_dev->t10_wwn;
 940         char path[ALUA_METADATA_PATH_LEN];
 941         int len, rc;
 942
 943         md_buf = kzalloc(ALUA_MD_BUF_LEN, GFP_KERNEL);
 944         if (!md_buf) {
 945                 pr_err("Unable to allocate buf for ALUA metadata\n");
 946                 return -ENOMEM;
 947         }
 948
 949         memset(path, 0, ALUA_METADATA_PATH_LEN);
 950
 951         len = snprintf(md_buf, ALUA_MD_BUF_LEN,
 952                         "tg_pt_gp_id=%hu\n"
 953                         "alua_access_state=0x%02x\n"
 954                         "alua_access_status=0x%02x\n",
 955                         tg_pt_gp->tg_pt_gp_id,
 956                         tg_pt_gp->tg_pt_gp_alua_pending_state,
 957                         tg_pt_gp->tg_pt_gp_alua_access_status);
 958
 959         snprintf(path, ALUA_METADATA_PATH_LEN,
 960                 "/var/target/alua/tpgs_%s/%s", &wwn->unit_serial[0],
 961                 config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item));
 962
 963         rc = core_alua_write_tpg_metadata(path, md_buf, len);
 964         kfree(md_buf);
 965         return rc;
 966 }
 967
 968 static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
 969 {
 970         struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(work,
 971                 struct t10_alua_tg_pt_gp, tg_pt_gp_transition_work.work);
 972         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
 973         struct se_dev_entry *se_deve;
 974         struct se_lun_acl *lacl;
 975         struct se_port *port;
 976         struct t10_alua_tg_pt_gp_member *mem;
 977         bool explicit = (tg_pt_gp->tg_pt_gp_alua_access_status ==
 978                          ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG);
 979
 980         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
 981         list_for_each_entry(mem, &tg_pt_gp->tg_pt_gp_mem_list,
 982                                 tg_pt_gp_mem_list) {
 983                 port = mem->tg_pt;
 984                 /*
 985                  * After an implicit target port asymmetric access state
 986                  * change, a device server shall establish a unit attention
 987                  * condition for the initiator port associated with every I_T
 988                  * nexus with the additional sense code set to ASYMMETRIC
 989                  * ACCESS STATE CHANGED.
 990                  *
 991                  * After an explicit target port asymmetric access state
 992                  * change, a device server shall establish a unit attention
 993                  * condition with the additional sense code set to ASYMMETRIC
 994                  * ACCESS STATE CHANGED for the initiator port associated with
 995                  * every I_T nexus other than the I_T nexus on which the SET
 996                  * TARGET PORT GROUPS command
 997                  */
 998                 atomic_inc_mb(&mem->tg_pt_gp_mem_ref_cnt);
 999                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1000
1001                 spin_lock_bh(&port->sep_alua_lock);
1002                 list_for_each_entry(se_deve, &port->sep_alua_list,
1003                                         alua_port_list) {
1004                         lacl = se_deve->se_lun_acl;
1005                         /*
1006                          * se_deve->se_lun_acl pointer may be NULL for a
1007                          * entry created without explicit Node+MappedLUN ACLs
1008                          */
1009                         if (!lacl)
1010                                 continue;
1011
1012                         if ((tg_pt_gp->tg_pt_gp_alua_access_status ==
1013                              ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
1014                            (tg_pt_gp->tg_pt_gp_alua_nacl != NULL) &&
1015                             (tg_pt_gp->tg_pt_gp_alua_nacl == lacl->se_lun_nacl) &&
1016                            (tg_pt_gp->tg_pt_gp_alua_port != NULL) &&
1017                             (tg_pt_gp->tg_pt_gp_alua_port == port))
1018                                 continue;
1019
1020                         core_scsi3_ua_allocate(lacl->se_lun_nacl,
1021                                 se_deve->mapped_lun, 0x2A,
1022                                 ASCQ_2AH_ASYMMETRIC_ACCESS_STATE_CHANGED);
1023                 }
1024                 spin_unlock_bh(&port->sep_alua_lock);
1025
1026                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1027                 atomic_dec_mb(&mem->tg_pt_gp_mem_ref_cnt);
1028         }
1029         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1030         /*
1031          * Update the ALUA metadata buf that has been allocated in
1032          * core_alua_do_port_transition(), this metadata will be written
1033          * to struct file.
1034          *
1035          * Note that there is the case where we do not want to update the
1036          * metadata when the saved metadata is being parsed in userspace
1037          * when setting the existing port access state and access status.
1038          *
1039          * Also note that the failure to write out the ALUA metadata to
1040          * struct file does NOT affect the actual ALUA transition.
1041          */
1042         if (tg_pt_gp->tg_pt_gp_write_metadata) {
1043                 mutex_lock(&tg_pt_gp->tg_pt_gp_md_mutex);
1044                 core_alua_update_tpg_primary_metadata(tg_pt_gp);
1045                 mutex_unlock(&tg_pt_gp->tg_pt_gp_md_mutex);
1046         }
1047         /*
1048          * Set the current primary ALUA access state to the requested new state
1049          */
1050         atomic_set(&tg_pt_gp->tg_pt_gp_alua_access_state,
1051                    tg_pt_gp->tg_pt_gp_alua_pending_state);
1052
1053         pr_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu"
1054                 " from primary access state %s to %s\n", (explicit) ? "explicit" :
1055                 "implicit", config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item),
1056                 tg_pt_gp->tg_pt_gp_id,
1057                 core_alua_dump_state(tg_pt_gp->tg_pt_gp_alua_previous_state),
1058                 core_alua_dump_state(tg_pt_gp->tg_pt_gp_alua_pending_state));
1059         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1060         atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
1061         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1062
1063         if (tg_pt_gp->tg_pt_gp_transition_complete)
1064                 complete(tg_pt_gp->tg_pt_gp_transition_complete);
1065 }
1066
1067 static int core_alua_do_transition_tg_pt(
1068         struct t10_alua_tg_pt_gp *tg_pt_gp,
1069         int new_state,
1070         int explicit)
1071 {
1072         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
1073         DECLARE_COMPLETION_ONSTACK(wait);
1074
1075         /* Nothing to be done here */
1076         if (atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state) == new_state)
1077                 return 0;
1078
1079         if (new_state == ALUA_ACCESS_STATE_TRANSITION)
1080                 return -EAGAIN;
1081
1082         /*
1083          * Flush any pending transitions
1084          */
1085         if (!explicit && tg_pt_gp->tg_pt_gp_implicit_trans_secs &&
1086             atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state) ==
1087             ALUA_ACCESS_STATE_TRANSITION) {
1088                 /* Just in case */
1089                 tg_pt_gp->tg_pt_gp_alua_pending_state = new_state;
1090                 tg_pt_gp->tg_pt_gp_transition_complete = &wait;
1091                 flush_delayed_work(&tg_pt_gp->tg_pt_gp_transition_work);
1092                 wait_for_completion(&wait);
1093                 tg_pt_gp->tg_pt_gp_transition_complete = NULL;
1094                 return 0;
1095         }
1096
1097         /*
1098          * Save the old primary ALUA access state, and set the current state
1099          * to ALUA_ACCESS_STATE_TRANSITION.
1100          */
1101         tg_pt_gp->tg_pt_gp_alua_previous_state =
1102                 atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state);
1103         tg_pt_gp->tg_pt_gp_alua_pending_state = new_state;
1104
1105         atomic_set(&tg_pt_gp->tg_pt_gp_alua_access_state,
1106                         ALUA_ACCESS_STATE_TRANSITION);
1107         tg_pt_gp->tg_pt_gp_alua_access_status = (explicit) ?
1108                                 ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
1109                                 ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
1110
1111         /*
1112          * Check for the optional ALUA primary state transition delay
1113          */
1114         if (tg_pt_gp->tg_pt_gp_trans_delay_msecs != 0)
1115                 msleep_interruptible(tg_pt_gp->tg_pt_gp_trans_delay_msecs);
1116
1117         /*
1118          * Take a reference for workqueue item
1119          */
1120         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1121         atomic_inc(&tg_pt_gp->tg_pt_gp_ref_cnt);
1122         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1123
1124         if (!explicit && tg_pt_gp->tg_pt_gp_implicit_trans_secs) {
1125                 unsigned long transition_tmo;
1126
1127                 transition_tmo = tg_pt_gp->tg_pt_gp_implicit_trans_secs * HZ;
1128                 queue_delayed_work(tg_pt_gp->tg_pt_gp_dev->tmr_wq,
1129                                    &tg_pt_gp->tg_pt_gp_transition_work,
1130                                    transition_tmo);
1131         } else {
1132                 tg_pt_gp->tg_pt_gp_transition_complete = &wait;
1133                 queue_delayed_work(tg_pt_gp->tg_pt_gp_dev->tmr_wq,
1134                                    &tg_pt_gp->tg_pt_gp_transition_work, 0);
1135                 wait_for_completion(&wait);
1136                 tg_pt_gp->tg_pt_gp_transition_complete = NULL;
1137         }
1138
1139         return 0;
1140 }
1141
1142 int core_alua_do_port_transition(
1143         struct t10_alua_tg_pt_gp *l_tg_pt_gp,
1144         struct se_device *l_dev,
1145         struct se_port *l_port,
1146         struct se_node_acl *l_nacl,
1147         int new_state,
1148         int explicit)
1149 {
1150         struct se_device *dev;
1151         struct t10_alua_lu_gp *lu_gp;
1152         struct t10_alua_lu_gp_member *lu_gp_mem, *local_lu_gp_mem;
1153         struct t10_alua_tg_pt_gp *tg_pt_gp;
1154         int primary, valid_states, rc = 0;
1155
1156         valid_states = l_tg_pt_gp->tg_pt_gp_alua_supported_states;
1157         if (core_alua_check_transition(new_state, valid_states, &primary) != 0)
1158                 return -EINVAL;
1159
1160         local_lu_gp_mem = l_dev->dev_alua_lu_gp_mem;
1161         spin_lock(&local_lu_gp_mem->lu_gp_mem_lock);
1162         lu_gp = local_lu_gp_mem->lu_gp;
1163         atomic_inc(&lu_gp->lu_gp_ref_cnt);
1164         spin_unlock(&local_lu_gp_mem->lu_gp_mem_lock);
1165         /*
1166          * For storage objects that are members of the 'default_lu_gp',
1167          * we only do transition on the passed *l_tp_pt_gp, and not
1168          * on all of the matching target port groups IDs in default_lu_gp.
1169          */
1170         if (!lu_gp->lu_gp_id) {
1171                 /*
1172                  * core_alua_do_transition_tg_pt() will always return
1173                  * success.
1174                  */
1175                 l_tg_pt_gp->tg_pt_gp_alua_port = l_port;
1176                 l_tg_pt_gp->tg_pt_gp_alua_nacl = l_nacl;
1177                 rc = core_alua_do_transition_tg_pt(l_tg_pt_gp,
1178                                                    new_state, explicit);
1179                 atomic_dec_mb(&lu_gp->lu_gp_ref_cnt);
1180                 return rc;
1181         }
1182         /*
1183          * For all other LU groups aside from 'default_lu_gp', walk all of
1184          * the associated storage objects looking for a matching target port
1185          * group ID from the local target port group.
1186          */
1187         spin_lock(&lu_gp->lu_gp_lock);
1188         list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list,
1189                                 lu_gp_mem_list) {
1190
1191                 dev = lu_gp_mem->lu_gp_mem_dev;
1192                 atomic_inc_mb(&lu_gp_mem->lu_gp_mem_ref_cnt);
1193                 spin_unlock(&lu_gp->lu_gp_lock);
1194
1195                 spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1196                 list_for_each_entry(tg_pt_gp,
1197                                 &dev->t10_alua.tg_pt_gps_list,
1198                                 tg_pt_gp_list) {
1199
1200                         if (!tg_pt_gp->tg_pt_gp_valid_id)
1201                                 continue;
1202                         /*
1203                          * If the target behavior port asymmetric access state
1204                          * is changed for any target port group accessible via
1205                          * a logical unit within a LU group, the target port
1206                          * behavior group asymmetric access states for the same
1207                          * target port group accessible via other logical units
1208                          * in that LU group will also change.
1209                          */
1210                         if (l_tg_pt_gp->tg_pt_gp_id != tg_pt_gp->tg_pt_gp_id)
1211                                 continue;
1212
1213                         if (l_tg_pt_gp == tg_pt_gp) {
1214                                 tg_pt_gp->tg_pt_gp_alua_port = l_port;
1215                                 tg_pt_gp->tg_pt_gp_alua_nacl = l_nacl;
1216                         } else {
1217                                 tg_pt_gp->tg_pt_gp_alua_port = NULL;
1218                                 tg_pt_gp->tg_pt_gp_alua_nacl = NULL;
1219                         }
1220                         atomic_inc_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
1221                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1222                         /*
1223                          * core_alua_do_transition_tg_pt() will always return
1224                          * success.
1225                          */
1226                         rc = core_alua_do_transition_tg_pt(tg_pt_gp,
1227                                         new_state, explicit);
1228
1229                         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1230                         atomic_dec_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
1231                         if (rc)
1232                                 break;
1233                 }
1234                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1235
1236                 spin_lock(&lu_gp->lu_gp_lock);
1237                 atomic_dec_mb(&lu_gp_mem->lu_gp_mem_ref_cnt);
1238         }
1239         spin_unlock(&lu_gp->lu_gp_lock);
1240
1241         if (!rc) {
1242                 pr_debug("Successfully processed LU Group: %s all ALUA TG PT"
1243                          " Group IDs: %hu %s transition to primary state: %s\n",
1244                          config_item_name(&lu_gp->lu_gp_group.cg_item),
1245                          l_tg_pt_gp->tg_pt_gp_id,
1246                          (explicit) ? "explicit" : "implicit",
1247                          core_alua_dump_state(new_state));
1248         }
1249
1250         atomic_dec_mb(&lu_gp->lu_gp_ref_cnt);
1251         return rc;
1252 }
1253
1254 /*
1255  * Called with tg_pt_gp_mem->sep_tg_pt_md_mutex held
1256  */
1257 static int core_alua_update_tpg_secondary_metadata(
1258         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
1259         struct se_port *port)
1260 {
1261         unsigned char *md_buf;
1262         struct se_portal_group *se_tpg = port->sep_tpg;
1263         char path[ALUA_METADATA_PATH_LEN], wwn[ALUA_SECONDARY_METADATA_WWN_LEN];
1264         int len, rc;
1265
1266         md_buf = kzalloc(ALUA_MD_BUF_LEN, GFP_KERNEL);
1267         if (!md_buf) {
1268                 pr_err("Unable to allocate buf for ALUA metadata\n");
1269                 return -ENOMEM;
1270         }
1271
1272         memset(path, 0, ALUA_METADATA_PATH_LEN);
1273         memset(wwn, 0, ALUA_SECONDARY_METADATA_WWN_LEN);
1274
1275         len = snprintf(wwn, ALUA_SECONDARY_METADATA_WWN_LEN, "%s",
1276                         se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg));
1277
1278         if (se_tpg->se_tpg_tfo->tpg_get_tag != NULL)
1279                 snprintf(wwn+len, ALUA_SECONDARY_METADATA_WWN_LEN-len, "+%hu",
1280                                 se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
1281
1282         len = snprintf(md_buf, ALUA_MD_BUF_LEN, "alua_tg_pt_offline=%d\n"
1283                         "alua_tg_pt_status=0x%02x\n",
1284                         atomic_read(&port->sep_tg_pt_secondary_offline),
1285                         port->sep_tg_pt_secondary_stat);
1286
1287         snprintf(path, ALUA_METADATA_PATH_LEN, "/var/target/alua/%s/%s/lun_%u",
1288                         se_tpg->se_tpg_tfo->get_fabric_name(), wwn,
1289                         port->sep_lun->unpacked_lun);
1290
1291         rc = core_alua_write_tpg_metadata(path, md_buf, len);
1292         kfree(md_buf);
1293
1294         return rc;
1295 }
1296
1297 static int core_alua_set_tg_pt_secondary_state(
1298         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
1299         struct se_port *port,
1300         int explicit,
1301         int offline)
1302 {
1303         struct t10_alua_tg_pt_gp *tg_pt_gp;
1304         int trans_delay_msecs;
1305
1306         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1307         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
1308         if (!tg_pt_gp) {
1309                 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1310                 pr_err("Unable to complete secondary state"
1311                                 " transition\n");
1312                 return -EINVAL;
1313         }
1314         trans_delay_msecs = tg_pt_gp->tg_pt_gp_trans_delay_msecs;
1315         /*
1316          * Set the secondary ALUA target port access state to OFFLINE
1317          * or release the previously secondary state for struct se_port
1318          */
1319         if (offline)
1320                 atomic_set(&port->sep_tg_pt_secondary_offline, 1);
1321         else
1322                 atomic_set(&port->sep_tg_pt_secondary_offline, 0);
1323
1324         port->sep_tg_pt_secondary_stat = (explicit) ?
1325                         ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
1326                         ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
1327
1328         pr_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu"
1329                 " to secondary access state: %s\n", (explicit) ? "explicit" :
1330                 "implicit", config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item),
1331                 tg_pt_gp->tg_pt_gp_id, (offline) ? "OFFLINE" : "ONLINE");
1332
1333         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1334         /*
1335          * Do the optional transition delay after we set the secondary
1336          * ALUA access state.
1337          */
1338         if (trans_delay_msecs != 0)
1339                 msleep_interruptible(trans_delay_msecs);
1340         /*
1341          * See if we need to update the ALUA fabric port metadata for
1342          * secondary state and status
1343          */
1344         if (port->sep_tg_pt_secondary_write_md) {
1345                 mutex_lock(&port->sep_tg_pt_md_mutex);
1346                 core_alua_update_tpg_secondary_metadata(tg_pt_gp_mem, port);
1347                 mutex_unlock(&port->sep_tg_pt_md_mutex);
1348         }
1349
1350         return 0;
1351 }
1352
1353 struct t10_alua_lba_map *
1354 core_alua_allocate_lba_map(struct list_head *list,
1355                            u64 first_lba, u64 last_lba)
1356 {
1357         struct t10_alua_lba_map *lba_map;
1358
1359         lba_map = kmem_cache_zalloc(t10_alua_lba_map_cache, GFP_KERNEL);
1360         if (!lba_map) {
1361                 pr_err("Unable to allocate struct t10_alua_lba_map\n");
1362                 return ERR_PTR(-ENOMEM);
1363         }
1364         INIT_LIST_HEAD(&lba_map->lba_map_mem_list);
1365         lba_map->lba_map_first_lba = first_lba;
1366         lba_map->lba_map_last_lba = last_lba;
1367
1368         list_add_tail(&lba_map->lba_map_list, list);
1369         return lba_map;
1370 }
1371
1372 int
1373 core_alua_allocate_lba_map_mem(struct t10_alua_lba_map *lba_map,
1374                                int pg_id, int state)
1375 {
1376         struct t10_alua_lba_map_member *lba_map_mem;
1377
1378         list_for_each_entry(lba_map_mem, &lba_map->lba_map_mem_list,
1379                             lba_map_mem_list) {
1380                 if (lba_map_mem->lba_map_mem_alua_pg_id == pg_id) {
1381                         pr_err("Duplicate pg_id %d in lba_map\n", pg_id);
1382                         return -EINVAL;
1383                 }
1384         }
1385
1386         lba_map_mem = kmem_cache_zalloc(t10_alua_lba_map_mem_cache, GFP_KERNEL);
1387         if (!lba_map_mem) {
1388                 pr_err("Unable to allocate struct t10_alua_lba_map_mem\n");
1389                 return -ENOMEM;
1390         }
1391         lba_map_mem->lba_map_mem_alua_state = state;
1392         lba_map_mem->lba_map_mem_alua_pg_id = pg_id;
1393
1394         list_add_tail(&lba_map_mem->lba_map_mem_list,
1395                       &lba_map->lba_map_mem_list);
1396         return 0;
1397 }
1398
1399 void
1400 core_alua_free_lba_map(struct list_head *lba_list)
1401 {
1402         struct t10_alua_lba_map *lba_map, *lba_map_tmp;
1403         struct t10_alua_lba_map_member *lba_map_mem, *lba_map_mem_tmp;
1404
1405         list_for_each_entry_safe(lba_map, lba_map_tmp, lba_list,
1406                                  lba_map_list) {
1407                 list_for_each_entry_safe(lba_map_mem, lba_map_mem_tmp,
1408                                          &lba_map->lba_map_mem_list,
1409                                          lba_map_mem_list) {
1410                         list_del(&lba_map_mem->lba_map_mem_list);
1411                         kmem_cache_free(t10_alua_lba_map_mem_cache,
1412                                         lba_map_mem);
1413                 }
1414                 list_del(&lba_map->lba_map_list);
1415                 kmem_cache_free(t10_alua_lba_map_cache, lba_map);
1416         }
1417 }
1418
1419 void
1420 core_alua_set_lba_map(struct se_device *dev, struct list_head *lba_map_list,
1421                       int segment_size, int segment_mult)
1422 {
1423         struct list_head old_lba_map_list;
1424         struct t10_alua_tg_pt_gp *tg_pt_gp;
1425         int activate = 0, supported;
1426
1427         INIT_LIST_HEAD(&old_lba_map_list);
1428         spin_lock(&dev->t10_alua.lba_map_lock);
1429         dev->t10_alua.lba_map_segment_size = segment_size;
1430         dev->t10_alua.lba_map_segment_multiplier = segment_mult;
1431         list_splice_init(&dev->t10_alua.lba_map_list, &old_lba_map_list);
1432         if (lba_map_list) {
1433                 list_splice_init(lba_map_list, &dev->t10_alua.lba_map_list);
1434                 activate = 1;
1435         }
1436         spin_unlock(&dev->t10_alua.lba_map_lock);
1437         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1438         list_for_each_entry(tg_pt_gp, &dev->t10_alua.tg_pt_gps_list,
1439                             tg_pt_gp_list) {
1440
1441                 if (!tg_pt_gp->tg_pt_gp_valid_id)
1442                         continue;
1443                 supported = tg_pt_gp->tg_pt_gp_alua_supported_states;
1444                 if (activate)
1445                         supported |= ALUA_LBD_SUP;
1446                 else
1447                         supported &= ~ALUA_LBD_SUP;
1448                 tg_pt_gp->tg_pt_gp_alua_supported_states = supported;
1449         }
1450         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1451         core_alua_free_lba_map(&old_lba_map_list);
1452 }
1453
1454 struct t10_alua_lu_gp *
1455 core_alua_allocate_lu_gp(const char *name, int def_group)
1456 {
1457         struct t10_alua_lu_gp *lu_gp;
1458
1459         lu_gp = kmem_cache_zalloc(t10_alua_lu_gp_cache, GFP_KERNEL);
1460         if (!lu_gp) {
1461                 pr_err("Unable to allocate struct t10_alua_lu_gp\n");
1462                 return ERR_PTR(-ENOMEM);
1463         }
1464         INIT_LIST_HEAD(&lu_gp->lu_gp_node);
1465         INIT_LIST_HEAD(&lu_gp->lu_gp_mem_list);
1466         spin_lock_init(&lu_gp->lu_gp_lock);
1467         atomic_set(&lu_gp->lu_gp_ref_cnt, 0);
1468
1469         if (def_group) {
1470                 lu_gp->lu_gp_id = alua_lu_gps_counter++;
1471                 lu_gp->lu_gp_valid_id = 1;
1472                 alua_lu_gps_count++;
1473         }
1474
1475         return lu_gp;
1476 }
1477
1478 int core_alua_set_lu_gp_id(struct t10_alua_lu_gp *lu_gp, u16 lu_gp_id)
1479 {
1480         struct t10_alua_lu_gp *lu_gp_tmp;
1481         u16 lu_gp_id_tmp;
1482         /*
1483          * The lu_gp->lu_gp_id may only be set once..
1484          */
1485         if (lu_gp->lu_gp_valid_id) {
1486                 pr_warn("ALUA LU Group already has a valid ID,"
1487                         " ignoring request\n");
1488                 return -EINVAL;
1489         }
1490
1491         spin_lock(&lu_gps_lock);
1492         if (alua_lu_gps_count == 0x0000ffff) {
1493                 pr_err("Maximum ALUA alua_lu_gps_count:"
1494                                 " 0x0000ffff reached\n");
1495                 spin_unlock(&lu_gps_lock);
1496                 kmem_cache_free(t10_alua_lu_gp_cache, lu_gp);
1497                 return -ENOSPC;
1498         }
1499 again:
1500         lu_gp_id_tmp = (lu_gp_id != 0) ? lu_gp_id :
1501                                 alua_lu_gps_counter++;
1502
1503         list_for_each_entry(lu_gp_tmp, &lu_gps_list, lu_gp_node) {
1504                 if (lu_gp_tmp->lu_gp_id == lu_gp_id_tmp) {
1505                         if (!lu_gp_id)
1506                                 goto again;
1507
1508                         pr_warn("ALUA Logical Unit Group ID: %hu"
1509                                 " already exists, ignoring request\n",
1510                                 lu_gp_id);
1511                         spin_unlock(&lu_gps_lock);
1512                         return -EINVAL;
1513                 }
1514         }
1515
1516         lu_gp->lu_gp_id = lu_gp_id_tmp;
1517         lu_gp->lu_gp_valid_id = 1;
1518         list_add_tail(&lu_gp->lu_gp_node, &lu_gps_list);
1519         alua_lu_gps_count++;
1520         spin_unlock(&lu_gps_lock);
1521
1522         return 0;
1523 }
1524
1525 static struct t10_alua_lu_gp_member *
1526 core_alua_allocate_lu_gp_mem(struct se_device *dev)
1527 {
1528         struct t10_alua_lu_gp_member *lu_gp_mem;
1529
1530         lu_gp_mem = kmem_cache_zalloc(t10_alua_lu_gp_mem_cache, GFP_KERNEL);
1531         if (!lu_gp_mem) {
1532                 pr_err("Unable to allocate struct t10_alua_lu_gp_member\n");
1533                 return ERR_PTR(-ENOMEM);
1534         }
1535         INIT_LIST_HEAD(&lu_gp_mem->lu_gp_mem_list);
1536         spin_lock_init(&lu_gp_mem->lu_gp_mem_lock);
1537         atomic_set(&lu_gp_mem->lu_gp_mem_ref_cnt, 0);
1538
1539         lu_gp_mem->lu_gp_mem_dev = dev;
1540         dev->dev_alua_lu_gp_mem = lu_gp_mem;
1541
1542         return lu_gp_mem;
1543 }
1544
1545 void core_alua_free_lu_gp(struct t10_alua_lu_gp *lu_gp)
1546 {
1547         struct t10_alua_lu_gp_member *lu_gp_mem, *lu_gp_mem_tmp;
1548         /*
1549          * Once we have reached this point, config_item_put() has
1550          * already been called from target_core_alua_drop_lu_gp().
1551          *
1552          * Here, we remove the *lu_gp from the global list so that
1553          * no associations can be made while we are releasing
1554          * struct t10_alua_lu_gp.
1555          */
1556         spin_lock(&lu_gps_lock);
1557         list_del(&lu_gp->lu_gp_node);
1558         alua_lu_gps_count--;
1559         spin_unlock(&lu_gps_lock);
1560         /*
1561          * Allow struct t10_alua_lu_gp * referenced by core_alua_get_lu_gp_by_name()
1562          * in target_core_configfs.c:target_core_store_alua_lu_gp() to be
1563          * released with core_alua_put_lu_gp_from_name()
1564          */
1565         while (atomic_read(&lu_gp->lu_gp_ref_cnt))
1566                 cpu_relax();
1567         /*
1568          * Release reference to struct t10_alua_lu_gp * from all associated
1569          * struct se_device.
1570          */
1571         spin_lock(&lu_gp->lu_gp_lock);
1572         list_for_each_entry_safe(lu_gp_mem, lu_gp_mem_tmp,
1573                                 &lu_gp->lu_gp_mem_list, lu_gp_mem_list) {
1574                 if (lu_gp_mem->lu_gp_assoc) {
1575                         list_del(&lu_gp_mem->lu_gp_mem_list);
1576                         lu_gp->lu_gp_members--;
1577                         lu_gp_mem->lu_gp_assoc = 0;
1578                 }
1579                 spin_unlock(&lu_gp->lu_gp_lock);
1580                 /*
1581                  *
1582                  * lu_gp_mem is associated with a single
1583                  * struct se_device->dev_alua_lu_gp_mem, and is released when
1584                  * struct se_device is released via core_alua_free_lu_gp_mem().
1585                  *
1586                  * If the passed lu_gp does NOT match the default_lu_gp, assume
1587                  * we want to re-associate a given lu_gp_mem with default_lu_gp.
1588                  */
1589                 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
1590                 if (lu_gp != default_lu_gp)
1591                         __core_alua_attach_lu_gp_mem(lu_gp_mem,
1592                                         default_lu_gp);
1593                 else
1594                         lu_gp_mem->lu_gp = NULL;
1595                 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
1596
1597                 spin_lock(&lu_gp->lu_gp_lock);
1598         }
1599         spin_unlock(&lu_gp->lu_gp_lock);
1600
1601         kmem_cache_free(t10_alua_lu_gp_cache, lu_gp);
1602 }
1603
1604 void core_alua_free_lu_gp_mem(struct se_device *dev)
1605 {
1606         struct t10_alua_lu_gp *lu_gp;
1607         struct t10_alua_lu_gp_member *lu_gp_mem;
1608
1609         lu_gp_mem = dev->dev_alua_lu_gp_mem;
1610         if (!lu_gp_mem)
1611                 return;
1612
1613         while (atomic_read(&lu_gp_mem->lu_gp_mem_ref_cnt))
1614                 cpu_relax();
1615
1616         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
1617         lu_gp = lu_gp_mem->lu_gp;
1618         if (lu_gp) {
1619                 spin_lock(&lu_gp->lu_gp_lock);
1620                 if (lu_gp_mem->lu_gp_assoc) {
1621                         list_del(&lu_gp_mem->lu_gp_mem_list);
1622                         lu_gp->lu_gp_members--;
1623                         lu_gp_mem->lu_gp_assoc = 0;
1624                 }
1625                 spin_unlock(&lu_gp->lu_gp_lock);
1626                 lu_gp_mem->lu_gp = NULL;
1627         }
1628         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
1629
1630         kmem_cache_free(t10_alua_lu_gp_mem_cache, lu_gp_mem);
1631 }
1632
1633 struct t10_alua_lu_gp *core_alua_get_lu_gp_by_name(const char *name)
1634 {
1635         struct t10_alua_lu_gp *lu_gp;
1636         struct config_item *ci;
1637
1638         spin_lock(&lu_gps_lock);
1639         list_for_each_entry(lu_gp, &lu_gps_list, lu_gp_node) {
1640                 if (!lu_gp->lu_gp_valid_id)
1641                         continue;
1642                 ci = &lu_gp->lu_gp_group.cg_item;
1643                 if (!strcmp(config_item_name(ci), name)) {
1644                         atomic_inc(&lu_gp->lu_gp_ref_cnt);
1645                         spin_unlock(&lu_gps_lock);
1646                         return lu_gp;
1647                 }
1648         }
1649         spin_unlock(&lu_gps_lock);
1650
1651         return NULL;
1652 }
1653
1654 void core_alua_put_lu_gp_from_name(struct t10_alua_lu_gp *lu_gp)
1655 {
1656         spin_lock(&lu_gps_lock);
1657         atomic_dec(&lu_gp->lu_gp_ref_cnt);
1658         spin_unlock(&lu_gps_lock);
1659 }
1660
1661 /*
1662  * Called with struct t10_alua_lu_gp_member->lu_gp_mem_lock
1663  */
1664 void __core_alua_attach_lu_gp_mem(
1665         struct t10_alua_lu_gp_member *lu_gp_mem,
1666         struct t10_alua_lu_gp *lu_gp)
1667 {
1668         spin_lock(&lu_gp->lu_gp_lock);
1669         lu_gp_mem->lu_gp = lu_gp;
1670         lu_gp_mem->lu_gp_assoc = 1;
1671         list_add_tail(&lu_gp_mem->lu_gp_mem_list, &lu_gp->lu_gp_mem_list);
1672         lu_gp->lu_gp_members++;
1673         spin_unlock(&lu_gp->lu_gp_lock);
1674 }
1675
1676 /*
1677  * Called with struct t10_alua_lu_gp_member->lu_gp_mem_lock
1678  */
1679 void __core_alua_drop_lu_gp_mem(
1680         struct t10_alua_lu_gp_member *lu_gp_mem,
1681         struct t10_alua_lu_gp *lu_gp)
1682 {
1683         spin_lock(&lu_gp->lu_gp_lock);
1684         list_del(&lu_gp_mem->lu_gp_mem_list);
1685         lu_gp_mem->lu_gp = NULL;
1686         lu_gp_mem->lu_gp_assoc = 0;
1687         lu_gp->lu_gp_members--;
1688         spin_unlock(&lu_gp->lu_gp_lock);
1689 }
1690
1691 struct t10_alua_tg_pt_gp *core_alua_allocate_tg_pt_gp(struct se_device *dev,
1692                 const char *name, int def_group)
1693 {
1694         struct t10_alua_tg_pt_gp *tg_pt_gp;
1695
1696         tg_pt_gp = kmem_cache_zalloc(t10_alua_tg_pt_gp_cache, GFP_KERNEL);
1697         if (!tg_pt_gp) {
1698                 pr_err("Unable to allocate struct t10_alua_tg_pt_gp\n");
1699                 return NULL;
1700         }
1701         INIT_LIST_HEAD(&tg_pt_gp->tg_pt_gp_list);
1702         INIT_LIST_HEAD(&tg_pt_gp->tg_pt_gp_mem_list);
1703         mutex_init(&tg_pt_gp->tg_pt_gp_md_mutex);
1704         spin_lock_init(&tg_pt_gp->tg_pt_gp_lock);
1705         atomic_set(&tg_pt_gp->tg_pt_gp_ref_cnt, 0);
1706         INIT_DELAYED_WORK(&tg_pt_gp->tg_pt_gp_transition_work,
1707                           core_alua_do_transition_tg_pt_work);
1708         tg_pt_gp->tg_pt_gp_dev = dev;
1709         atomic_set(&tg_pt_gp->tg_pt_gp_alua_access_state,
1710                 ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED);
1711         /*
1712          * Enable both explicit and implicit ALUA support by default
1713          */
1714         tg_pt_gp->tg_pt_gp_alua_access_type =
1715                         TPGS_EXPLICIT_ALUA | TPGS_IMPLICIT_ALUA;
1716         /*
1717          * Set the default Active/NonOptimized Delay in milliseconds
1718          */
1719         tg_pt_gp->tg_pt_gp_nonop_delay_msecs = ALUA_DEFAULT_NONOP_DELAY_MSECS;
1720         tg_pt_gp->tg_pt_gp_trans_delay_msecs = ALUA_DEFAULT_TRANS_DELAY_MSECS;
1721         tg_pt_gp->tg_pt_gp_implicit_trans_secs = ALUA_DEFAULT_IMPLICIT_TRANS_SECS;
1722
1723         /*
1724          * Enable all supported states
1725          */
1726         tg_pt_gp->tg_pt_gp_alua_supported_states =
1727             ALUA_T_SUP | ALUA_O_SUP |
1728             ALUA_U_SUP | ALUA_S_SUP | ALUA_AN_SUP | ALUA_AO_SUP;
1729
1730         if (def_group) {
1731                 spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1732                 tg_pt_gp->tg_pt_gp_id =
1733                                 dev->t10_alua.alua_tg_pt_gps_counter++;
1734                 tg_pt_gp->tg_pt_gp_valid_id = 1;
1735                 dev->t10_alua.alua_tg_pt_gps_count++;
1736                 list_add_tail(&tg_pt_gp->tg_pt_gp_list,
1737                               &dev->t10_alua.tg_pt_gps_list);
1738                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1739         }
1740
1741         return tg_pt_gp;
1742 }
1743
1744 int core_alua_set_tg_pt_gp_id(
1745         struct t10_alua_tg_pt_gp *tg_pt_gp,
1746         u16 tg_pt_gp_id)
1747 {
1748         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
1749         struct t10_alua_tg_pt_gp *tg_pt_gp_tmp;
1750         u16 tg_pt_gp_id_tmp;
1751
1752         /*
1753          * The tg_pt_gp->tg_pt_gp_id may only be set once..
1754          */
1755         if (tg_pt_gp->tg_pt_gp_valid_id) {
1756                 pr_warn("ALUA TG PT Group already has a valid ID,"
1757                         " ignoring request\n");
1758                 return -EINVAL;
1759         }
1760
1761         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1762         if (dev->t10_alua.alua_tg_pt_gps_count == 0x0000ffff) {
1763                 pr_err("Maximum ALUA alua_tg_pt_gps_count:"
1764                         " 0x0000ffff reached\n");
1765                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1766                 kmem_cache_free(t10_alua_tg_pt_gp_cache, tg_pt_gp);
1767                 return -ENOSPC;
1768         }
1769 again:
1770         tg_pt_gp_id_tmp = (tg_pt_gp_id != 0) ? tg_pt_gp_id :
1771                         dev->t10_alua.alua_tg_pt_gps_counter++;
1772
1773         list_for_each_entry(tg_pt_gp_tmp, &dev->t10_alua.tg_pt_gps_list,
1774                         tg_pt_gp_list) {
1775                 if (tg_pt_gp_tmp->tg_pt_gp_id == tg_pt_gp_id_tmp) {
1776                         if (!tg_pt_gp_id)
1777                                 goto again;
1778
1779                         pr_err("ALUA Target Port Group ID: %hu already"
1780                                 " exists, ignoring request\n", tg_pt_gp_id);
1781                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1782                         return -EINVAL;
1783                 }
1784         }
1785
1786         tg_pt_gp->tg_pt_gp_id = tg_pt_gp_id_tmp;
1787         tg_pt_gp->tg_pt_gp_valid_id = 1;
1788         list_add_tail(&tg_pt_gp->tg_pt_gp_list,
1789                         &dev->t10_alua.tg_pt_gps_list);
1790         dev->t10_alua.alua_tg_pt_gps_count++;
1791         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1792
1793         return 0;
1794 }
1795
1796 struct t10_alua_tg_pt_gp_member *core_alua_allocate_tg_pt_gp_mem(
1797         struct se_port *port)
1798 {
1799         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
1800
1801         tg_pt_gp_mem = kmem_cache_zalloc(t10_alua_tg_pt_gp_mem_cache,
1802                                 GFP_KERNEL);
1803         if (!tg_pt_gp_mem) {
1804                 pr_err("Unable to allocate struct t10_alua_tg_pt_gp_member\n");
1805                 return ERR_PTR(-ENOMEM);
1806         }
1807         INIT_LIST_HEAD(&tg_pt_gp_mem->tg_pt_gp_mem_list);
1808         spin_lock_init(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1809         atomic_set(&tg_pt_gp_mem->tg_pt_gp_mem_ref_cnt, 0);
1810
1811         tg_pt_gp_mem->tg_pt = port;
1812         port->sep_alua_tg_pt_gp_mem = tg_pt_gp_mem;
1813
1814         return tg_pt_gp_mem;
1815 }
1816
1817 void core_alua_free_tg_pt_gp(
1818         struct t10_alua_tg_pt_gp *tg_pt_gp)
1819 {
1820         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
1821         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem, *tg_pt_gp_mem_tmp;
1822
1823         /*
1824          * Once we have reached this point, config_item_put() has already
1825          * been called from target_core_alua_drop_tg_pt_gp().
1826          *
1827          * Here we remove *tg_pt_gp from the global list so that
1828          * no associations *OR* explicit ALUA via SET_TARGET_PORT_GROUPS
1829          * can be made while we are releasing struct t10_alua_tg_pt_gp.
1830          */
1831         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1832         list_del(&tg_pt_gp->tg_pt_gp_list);
1833         dev->t10_alua.alua_tg_pt_gps_counter--;
1834         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1835
1836         flush_delayed_work(&tg_pt_gp->tg_pt_gp_transition_work);
1837
1838         /*
1839          * Allow a struct t10_alua_tg_pt_gp_member * referenced by
1840          * core_alua_get_tg_pt_gp_by_name() in
1841          * target_core_configfs.c:target_core_store_alua_tg_pt_gp()
1842          * to be released with core_alua_put_tg_pt_gp_from_name().
1843          */
1844         while (atomic_read(&tg_pt_gp->tg_pt_gp_ref_cnt))
1845                 cpu_relax();
1846
1847         /*
1848          * Release reference to struct t10_alua_tg_pt_gp from all associated
1849          * struct se_port.
1850          */
1851         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1852         list_for_each_entry_safe(tg_pt_gp_mem, tg_pt_gp_mem_tmp,
1853                         &tg_pt_gp->tg_pt_gp_mem_list, tg_pt_gp_mem_list) {
1854                 if (tg_pt_gp_mem->tg_pt_gp_assoc) {
1855                         list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
1856                         tg_pt_gp->tg_pt_gp_members--;
1857                         tg_pt_gp_mem->tg_pt_gp_assoc = 0;
1858                 }
1859                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1860                 /*
1861                  * tg_pt_gp_mem is associated with a single
1862                  * se_port->sep_alua_tg_pt_gp_mem, and is released via
1863                  * core_alua_free_tg_pt_gp_mem().
1864                  *
1865                  * If the passed tg_pt_gp does NOT match the default_tg_pt_gp,
1866                  * assume we want to re-associate a given tg_pt_gp_mem with
1867                  * default_tg_pt_gp.
1868                  */
1869                 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1870                 if (tg_pt_gp != dev->t10_alua.default_tg_pt_gp) {
1871                         __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
1872                                         dev->t10_alua.default_tg_pt_gp);
1873                 } else
1874                         tg_pt_gp_mem->tg_pt_gp = NULL;
1875                 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1876
1877                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1878         }
1879         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1880
1881         kmem_cache_free(t10_alua_tg_pt_gp_cache, tg_pt_gp);
1882 }
1883
1884 void core_alua_free_tg_pt_gp_mem(struct se_port *port)
1885 {
1886         struct t10_alua_tg_pt_gp *tg_pt_gp;
1887         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
1888
1889         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
1890         if (!tg_pt_gp_mem)
1891                 return;
1892
1893         while (atomic_read(&tg_pt_gp_mem->tg_pt_gp_mem_ref_cnt))
1894                 cpu_relax();
1895
1896         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1897         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
1898         if (tg_pt_gp) {
1899                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1900                 if (tg_pt_gp_mem->tg_pt_gp_assoc) {
1901                         list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
1902                         tg_pt_gp->tg_pt_gp_members--;
1903                         tg_pt_gp_mem->tg_pt_gp_assoc = 0;
1904                 }
1905                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1906                 tg_pt_gp_mem->tg_pt_gp = NULL;
1907         }
1908         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1909
1910         kmem_cache_free(t10_alua_tg_pt_gp_mem_cache, tg_pt_gp_mem);
1911 }
1912
1913 static struct t10_alua_tg_pt_gp *core_alua_get_tg_pt_gp_by_name(
1914                 struct se_device *dev, const char *name)
1915 {
1916         struct t10_alua_tg_pt_gp *tg_pt_gp;
1917         struct config_item *ci;
1918
1919         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1920         list_for_each_entry(tg_pt_gp, &dev->t10_alua.tg_pt_gps_list,
1921                         tg_pt_gp_list) {
1922                 if (!tg_pt_gp->tg_pt_gp_valid_id)
1923                         continue;
1924                 ci = &tg_pt_gp->tg_pt_gp_group.cg_item;
1925                 if (!strcmp(config_item_name(ci), name)) {
1926                         atomic_inc(&tg_pt_gp->tg_pt_gp_ref_cnt);
1927                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1928                         return tg_pt_gp;
1929                 }
1930         }
1931         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1932
1933         return NULL;
1934 }
1935
1936 static void core_alua_put_tg_pt_gp_from_name(
1937         struct t10_alua_tg_pt_gp *tg_pt_gp)
1938 {
1939         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
1940
1941         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
1942         atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
1943         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
1944 }
1945
1946 /*
1947  * Called with struct t10_alua_tg_pt_gp_member->tg_pt_gp_mem_lock held
1948  */
1949 void __core_alua_attach_tg_pt_gp_mem(
1950         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
1951         struct t10_alua_tg_pt_gp *tg_pt_gp)
1952 {
1953         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1954         tg_pt_gp_mem->tg_pt_gp = tg_pt_gp;
1955         tg_pt_gp_mem->tg_pt_gp_assoc = 1;
1956         list_add_tail(&tg_pt_gp_mem->tg_pt_gp_mem_list,
1957                         &tg_pt_gp->tg_pt_gp_mem_list);
1958         tg_pt_gp->tg_pt_gp_members++;
1959         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1960 }
1961
1962 /*
1963  * Called with struct t10_alua_tg_pt_gp_member->tg_pt_gp_mem_lock held
1964  */
1965 static void __core_alua_drop_tg_pt_gp_mem(
1966         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
1967         struct t10_alua_tg_pt_gp *tg_pt_gp)
1968 {
1969         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
1970         list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
1971         tg_pt_gp_mem->tg_pt_gp = NULL;
1972         tg_pt_gp_mem->tg_pt_gp_assoc = 0;
1973         tg_pt_gp->tg_pt_gp_members--;
1974         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
1975 }
1976
1977 ssize_t core_alua_show_tg_pt_gp_info(struct se_port *port, char *page)
1978 {
1979         struct config_item *tg_pt_ci;
1980         struct t10_alua_tg_pt_gp *tg_pt_gp;
1981         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
1982         ssize_t len = 0;
1983
1984         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
1985         if (!tg_pt_gp_mem)
1986                 return len;
1987
1988         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
1989         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
1990         if (tg_pt_gp) {
1991                 tg_pt_ci = &tg_pt_gp->tg_pt_gp_group.cg_item;
1992                 len += sprintf(page, "TG Port Alias: %s\nTG Port Group ID:"
1993                         " %hu\nTG Port Primary Access State: %s\nTG Port "
1994                         "Primary Access Status: %s\nTG Port Secondary Access"
1995                         " State: %s\nTG Port Secondary Access Status: %s\n",
1996                         config_item_name(tg_pt_ci), tg_pt_gp->tg_pt_gp_id,
1997                         core_alua_dump_state(atomic_read(
1998                                         &tg_pt_gp->tg_pt_gp_alua_access_state)),
1999                         core_alua_dump_status(
2000                                 tg_pt_gp->tg_pt_gp_alua_access_status),
2001                         (atomic_read(&port->sep_tg_pt_secondary_offline)) ?
2002                         "Offline" : "None",
2003                         core_alua_dump_status(port->sep_tg_pt_secondary_stat));
2004         }
2005         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
2006
2007         return len;
2008 }
2009
2010 ssize_t core_alua_store_tg_pt_gp_info(
2011         struct se_port *port,
2012         const char *page,
2013         size_t count)
2014 {
2015         struct se_portal_group *tpg;
2016         struct se_lun *lun;
2017         struct se_device *dev = port->sep_lun->lun_se_dev;
2018         struct t10_alua_tg_pt_gp *tg_pt_gp = NULL, *tg_pt_gp_new = NULL;
2019         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
2020         unsigned char buf[TG_PT_GROUP_NAME_BUF];
2021         int move = 0;
2022
2023         tpg = port->sep_tpg;
2024         lun = port->sep_lun;
2025
2026         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
2027         if (!tg_pt_gp_mem)
2028                 return 0;
2029
2030         if (count > TG_PT_GROUP_NAME_BUF) {
2031                 pr_err("ALUA Target Port Group alias too large!\n");
2032                 return -EINVAL;
2033         }
2034         memset(buf, 0, TG_PT_GROUP_NAME_BUF);
2035         memcpy(buf, page, count);
2036         /*
2037          * Any ALUA target port group alias besides "NULL" means we will be
2038          * making a new group association.
2039          */
2040         if (strcmp(strstrip(buf), "NULL")) {
2041                 /*
2042                  * core_alua_get_tg_pt_gp_by_name() will increment reference to
2043                  * struct t10_alua_tg_pt_gp.  This reference is released with
2044                  * core_alua_put_tg_pt_gp_from_name() below.
2045                  */
2046                 tg_pt_gp_new = core_alua_get_tg_pt_gp_by_name(dev,
2047                                         strstrip(buf));
2048                 if (!tg_pt_gp_new)
2049                         return -ENODEV;
2050         }
2051
2052         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
2053         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
2054         if (tg_pt_gp) {
2055                 /*
2056                  * Clearing an existing tg_pt_gp association, and replacing
2057                  * with the default_tg_pt_gp.
2058                  */
2059                 if (!tg_pt_gp_new) {
2060                         pr_debug("Target_Core_ConfigFS: Moving"
2061                                 " %s/tpgt_%hu/%s from ALUA Target Port Group:"
2062                                 " alua/%s, ID: %hu back to"
2063                                 " default_tg_pt_gp\n",
2064                                 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
2065                                 tpg->se_tpg_tfo->tpg_get_tag(tpg),
2066                                 config_item_name(&lun->lun_group.cg_item),
2067                                 config_item_name(
2068                                         &tg_pt_gp->tg_pt_gp_group.cg_item),
2069                                 tg_pt_gp->tg_pt_gp_id);
2070
2071                         __core_alua_drop_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp);
2072                         __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
2073                                         dev->t10_alua.default_tg_pt_gp);
2074                         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
2075
2076                         return count;
2077                 }
2078                 /*
2079                  * Removing existing association of tg_pt_gp_mem with tg_pt_gp
2080                  */
2081                 __core_alua_drop_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp);
2082                 move = 1;
2083         }
2084         /*
2085          * Associate tg_pt_gp_mem with tg_pt_gp_new.
2086          */
2087         __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp_new);
2088         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
2089         pr_debug("Target_Core_ConfigFS: %s %s/tpgt_%hu/%s to ALUA"
2090                 " Target Port Group: alua/%s, ID: %hu\n", (move) ?
2091                 "Moving" : "Adding", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
2092                 tpg->se_tpg_tfo->tpg_get_tag(tpg),
2093                 config_item_name(&lun->lun_group.cg_item),
2094                 config_item_name(&tg_pt_gp_new->tg_pt_gp_group.cg_item),
2095                 tg_pt_gp_new->tg_pt_gp_id);
2096
2097         core_alua_put_tg_pt_gp_from_name(tg_pt_gp_new);
2098         return count;
2099 }
2100
2101 ssize_t core_alua_show_access_type(
2102         struct t10_alua_tg_pt_gp *tg_pt_gp,
2103         char *page)
2104 {
2105         if ((tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA) &&
2106             (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA))
2107                 return sprintf(page, "Implicit and Explicit\n");
2108         else if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)
2109                 return sprintf(page, "Implicit\n");
2110         else if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)
2111                 return sprintf(page, "Explicit\n");
2112         else
2113                 return sprintf(page, "None\n");
2114 }
2115
2116 ssize_t core_alua_store_access_type(
2117         struct t10_alua_tg_pt_gp *tg_pt_gp,
2118         const char *page,
2119         size_t count)
2120 {
2121         unsigned long tmp;
2122         int ret;
2123
2124         ret = kstrtoul(page, 0, &tmp);
2125         if (ret < 0) {
2126                 pr_err("Unable to extract alua_access_type\n");
2127                 return ret;
2128         }
2129         if ((tmp != 0) && (tmp != 1) && (tmp != 2) && (tmp != 3)) {
2130                 pr_err("Illegal value for alua_access_type:"
2131                                 " %lu\n", tmp);
2132                 return -EINVAL;
2133         }
2134         if (tmp == 3)
2135                 tg_pt_gp->tg_pt_gp_alua_access_type =
2136                         TPGS_IMPLICIT_ALUA | TPGS_EXPLICIT_ALUA;
2137         else if (tmp == 2)
2138                 tg_pt_gp->tg_pt_gp_alua_access_type = TPGS_EXPLICIT_ALUA;
2139         else if (tmp == 1)
2140                 tg_pt_gp->tg_pt_gp_alua_access_type = TPGS_IMPLICIT_ALUA;
2141         else
2142                 tg_pt_gp->tg_pt_gp_alua_access_type = 0;
2143
2144         return count;
2145 }
2146
2147 ssize_t core_alua_show_nonop_delay_msecs(
2148         struct t10_alua_tg_pt_gp *tg_pt_gp,
2149         char *page)
2150 {
2151         return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_nonop_delay_msecs);
2152 }
2153
2154 ssize_t core_alua_store_nonop_delay_msecs(
2155         struct t10_alua_tg_pt_gp *tg_pt_gp,
2156         const char *page,
2157         size_t count)
2158 {
2159         unsigned long tmp;
2160         int ret;
2161
2162         ret = kstrtoul(page, 0, &tmp);
2163         if (ret < 0) {
2164                 pr_err("Unable to extract nonop_delay_msecs\n");
2165                 return ret;
2166         }
2167         if (tmp > ALUA_MAX_NONOP_DELAY_MSECS) {
2168                 pr_err("Passed nonop_delay_msecs: %lu, exceeds"
2169                         " ALUA_MAX_NONOP_DELAY_MSECS: %d\n", tmp,
2170                         ALUA_MAX_NONOP_DELAY_MSECS);
2171                 return -EINVAL;
2172         }
2173         tg_pt_gp->tg_pt_gp_nonop_delay_msecs = (int)tmp;
2174
2175         return count;
2176 }
2177
2178 ssize_t core_alua_show_trans_delay_msecs(
2179         struct t10_alua_tg_pt_gp *tg_pt_gp,
2180         char *page)
2181 {
2182         return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_trans_delay_msecs);
2183 }
2184
2185 ssize_t core_alua_store_trans_delay_msecs(
2186         struct t10_alua_tg_pt_gp *tg_pt_gp,
2187         const char *page,
2188         size_t count)
2189 {
2190         unsigned long tmp;
2191         int ret;
2192
2193         ret = kstrtoul(page, 0, &tmp);
2194         if (ret < 0) {
2195                 pr_err("Unable to extract trans_delay_msecs\n");
2196                 return ret;
2197         }
2198         if (tmp > ALUA_MAX_TRANS_DELAY_MSECS) {
2199                 pr_err("Passed trans_delay_msecs: %lu, exceeds"
2200                         " ALUA_MAX_TRANS_DELAY_MSECS: %d\n", tmp,
2201                         ALUA_MAX_TRANS_DELAY_MSECS);
2202                 return -EINVAL;
2203         }
2204         tg_pt_gp->tg_pt_gp_trans_delay_msecs = (int)tmp;
2205
2206         return count;
2207 }
2208
2209 ssize_t core_alua_show_implicit_trans_secs(
2210         struct t10_alua_tg_pt_gp *tg_pt_gp,
2211         char *page)
2212 {
2213         return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_implicit_trans_secs);
2214 }
2215
2216 ssize_t core_alua_store_implicit_trans_secs(
2217         struct t10_alua_tg_pt_gp *tg_pt_gp,
2218         const char *page,
2219         size_t count)
2220 {
2221         unsigned long tmp;
2222         int ret;
2223
2224         ret = kstrtoul(page, 0, &tmp);
2225         if (ret < 0) {
2226                 pr_err("Unable to extract implicit_trans_secs\n");
2227                 return ret;
2228         }
2229         if (tmp > ALUA_MAX_IMPLICIT_TRANS_SECS) {
2230                 pr_err("Passed implicit_trans_secs: %lu, exceeds"
2231                         " ALUA_MAX_IMPLICIT_TRANS_SECS: %d\n", tmp,
2232                         ALUA_MAX_IMPLICIT_TRANS_SECS);
2233                 return  -EINVAL;
2234         }
2235         tg_pt_gp->tg_pt_gp_implicit_trans_secs = (int)tmp;
2236
2237         return count;
2238 }
2239
2240 ssize_t core_alua_show_preferred_bit(
2241         struct t10_alua_tg_pt_gp *tg_pt_gp,
2242         char *page)
2243 {
2244         return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_pref);
2245 }
2246
2247 ssize_t core_alua_store_preferred_bit(
2248         struct t10_alua_tg_pt_gp *tg_pt_gp,
2249         const char *page,
2250         size_t count)
2251 {
2252         unsigned long tmp;
2253         int ret;
2254
2255         ret = kstrtoul(page, 0, &tmp);
2256         if (ret < 0) {
2257                 pr_err("Unable to extract preferred ALUA value\n");
2258                 return ret;
2259         }
2260         if ((tmp != 0) && (tmp != 1)) {
2261                 pr_err("Illegal value for preferred ALUA: %lu\n", tmp);
2262                 return -EINVAL;
2263         }
2264         tg_pt_gp->tg_pt_gp_pref = (int)tmp;
2265
2266         return count;
2267 }
2268
2269 ssize_t core_alua_show_offline_bit(struct se_lun *lun, char *page)
2270 {
2271         if (!lun->lun_sep)
2272                 return -ENODEV;
2273
2274         return sprintf(page, "%d\n",
2275                 atomic_read(&lun->lun_sep->sep_tg_pt_secondary_offline));
2276 }
2277
2278 ssize_t core_alua_store_offline_bit(
2279         struct se_lun *lun,
2280         const char *page,
2281         size_t count)
2282 {
2283         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
2284         unsigned long tmp;
2285         int ret;
2286
2287         if (!lun->lun_sep)
2288                 return -ENODEV;
2289
2290         ret = kstrtoul(page, 0, &tmp);
2291         if (ret < 0) {
2292                 pr_err("Unable to extract alua_tg_pt_offline value\n");
2293                 return ret;
2294         }
2295         if ((tmp != 0) && (tmp != 1)) {
2296                 pr_err("Illegal value for alua_tg_pt_offline: %lu\n",
2297                                 tmp);
2298                 return -EINVAL;
2299         }
2300         tg_pt_gp_mem = lun->lun_sep->sep_alua_tg_pt_gp_mem;
2301         if (!tg_pt_gp_mem) {
2302                 pr_err("Unable to locate *tg_pt_gp_mem\n");
2303                 return -EINVAL;
2304         }
2305
2306         ret = core_alua_set_tg_pt_secondary_state(tg_pt_gp_mem,
2307                         lun->lun_sep, 0, (int)tmp);
2308         if (ret < 0)
2309                 return -EINVAL;
2310
2311         return count;
2312 }
2313
2314 ssize_t core_alua_show_secondary_status(
2315         struct se_lun *lun,
2316         char *page)
2317 {
2318         return sprintf(page, "%d\n", lun->lun_sep->sep_tg_pt_secondary_stat);
2319 }
2320
2321 ssize_t core_alua_store_secondary_status(
2322         struct se_lun *lun,
2323         const char *page,
2324         size_t count)
2325 {
2326         unsigned long tmp;
2327         int ret;
2328
2329         ret = kstrtoul(page, 0, &tmp);
2330         if (ret < 0) {
2331                 pr_err("Unable to extract alua_tg_pt_status\n");
2332                 return ret;
2333         }
2334         if ((tmp != ALUA_STATUS_NONE) &&
2335             (tmp != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
2336             (tmp != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) {
2337                 pr_err("Illegal value for alua_tg_pt_status: %lu\n",
2338                                 tmp);
2339                 return -EINVAL;
2340         }
2341         lun->lun_sep->sep_tg_pt_secondary_stat = (int)tmp;
2342
2343         return count;
2344 }
2345
2346 ssize_t core_alua_show_secondary_write_metadata(
2347         struct se_lun *lun,
2348         char *page)
2349 {
2350         return sprintf(page, "%d\n",
2351                         lun->lun_sep->sep_tg_pt_secondary_write_md);
2352 }
2353
2354 ssize_t core_alua_store_secondary_write_metadata(
2355         struct se_lun *lun,
2356         const char *page,
2357         size_t count)
2358 {
2359         unsigned long tmp;
2360         int ret;
2361
2362         ret = kstrtoul(page, 0, &tmp);
2363         if (ret < 0) {
2364                 pr_err("Unable to extract alua_tg_pt_write_md\n");
2365                 return ret;
2366         }
2367         if ((tmp != 0) && (tmp != 1)) {
2368                 pr_err("Illegal value for alua_tg_pt_write_md:"
2369                                 " %lu\n", tmp);
2370                 return -EINVAL;
2371         }
2372         lun->lun_sep->sep_tg_pt_secondary_write_md = (int)tmp;
2373
2374         return count;
2375 }
2376
2377 int core_setup_alua(struct se_device *dev)
2378 {
2379         if (!(dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) &&
2380             !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {
2381                 struct t10_alua_lu_gp_member *lu_gp_mem;
2382
2383                 /*
2384                  * Associate this struct se_device with the default ALUA
2385                  * LUN Group.
2386                  */
2387                 lu_gp_mem = core_alua_allocate_lu_gp_mem(dev);
2388                 if (IS_ERR(lu_gp_mem))
2389                         return PTR_ERR(lu_gp_mem);
2390
2391                 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
2392                 __core_alua_attach_lu_gp_mem(lu_gp_mem,
2393                                 default_lu_gp);
2394                 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2395
2396                 pr_debug("%s: Adding to default ALUA LU Group:"
2397                         " core/alua/lu_gps/default_lu_gp\n",
2398                         dev->transport->name);
2399         }
2400
2401         return 0;
2402 }