drivers/scsi/qla2xxx/tcm_qla2xxx.c

   1 /*******************************************************************************
   2  * This file contains tcm implementation using v4 configfs fabric infrastructure
   3  * for QLogic target mode HBAs
   4  *
   5  * (c) Copyright 2010-2013 Datera, Inc.
   6  *
   7  * Author: Nicholas A. Bellinger <nab@daterainc.com>
   8  *
   9  * tcm_qla2xxx_parse_wwn() and tcm_qla2xxx_format_wwn() contains code from
  10  * the TCM_FC / Open-FCoE.org fabric module.
  11  *
  12  * Copyright (c) 2010 Cisco Systems, Inc
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  ****************************************************************************/
  24
  25
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <generated/utsrelease.h>
  29 #include <linux/utsname.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/init.h>
  32 #include <linux/list.h>
  33 #include <linux/slab.h>
  34 #include <linux/kthread.h>
  35 #include <linux/types.h>
  36 #include <linux/string.h>
  37 #include <linux/configfs.h>
  38 #include <linux/ctype.h>
  39 #include <asm/unaligned.h>
  40 #include <scsi/scsi.h>
  41 #include <scsi/scsi_host.h>
  42 #include <scsi/scsi_device.h>
  43 #include <scsi/scsi_cmnd.h>
  44 #include <target/target_core_base.h>
  45 #include <target/target_core_fabric.h>
  46 #include <target/target_core_fabric_configfs.h>
  47 #include <target/target_core_configfs.h>
  48 #include <target/configfs_macros.h>
  49
  50 #include "qla_def.h"
  51 #include "qla_target.h"
  52 #include "tcm_qla2xxx.h"
  53
  54 static struct workqueue_struct *tcm_qla2xxx_free_wq;
  55 static struct workqueue_struct *tcm_qla2xxx_cmd_wq;
  56
  57 static const struct target_core_fabric_ops tcm_qla2xxx_ops;
  58 static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops;
  59
  60 /*
  61  * Parse WWN.
  62  * If strict, we require lower-case hex and colon separators to be sure
  63  * the name is the same as what would be generated by ft_format_wwn()
  64  * so the name and wwn are mapped one-to-one.
  65  */
  66 static ssize_t tcm_qla2xxx_parse_wwn(const char *name, u64 *wwn, int strict)
  67 {
  68         const char *cp;
  69         char c;
  70         u32 nibble;
  71         u32 byte = 0;
  72         u32 pos = 0;
  73         u32 err;
  74
  75         *wwn = 0;
  76         for (cp = name; cp < &name[TCM_QLA2XXX_NAMELEN - 1]; cp++) {
  77                 c = *cp;
  78                 if (c == '\n' && cp[1] == '\0')
  79                         continue;
  80                 if (strict && pos++ == 2 && byte++ < 7) {
  81                         pos = 0;
  82                         if (c == ':')
  83                                 continue;
  84                         err = 1;
  85                         goto fail;
  86                 }
  87                 if (c == '\0') {
  88                         err = 2;
  89                         if (strict && byte != 8)
  90                                 goto fail;
  91                         return cp - name;
  92                 }
  93                 err = 3;
  94                 if (isdigit(c))
  95                         nibble = c - '0';
  96                 else if (isxdigit(c) && (islower(c) || !strict))
  97                         nibble = tolower(c) - 'a' + 10;
  98                 else
  99                         goto fail;
 100                 *wwn = (*wwn << 4) | nibble;
 101         }
 102         err = 4;
 103 fail:
 104         pr_debug("err %u len %zu pos %u byte %u\n",
 105                         err, cp - name, pos, byte);
 106         return -1;
 107 }
 108
 109 static ssize_t tcm_qla2xxx_format_wwn(char *buf, size_t len, u64 wwn)
 110 {
 111         u8 b[8];
 112
 113         put_unaligned_be64(wwn, b);
 114         return snprintf(buf, len,
 115                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
 116                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
 117 }
 118
 119 static char *tcm_qla2xxx_get_fabric_name(void)
 120 {
 121         return "qla2xxx";
 122 }
 123
 124 /*
 125  * From drivers/scsi/scsi_transport_fc.c:fc_parse_wwn
 126  */
 127 static int tcm_qla2xxx_npiv_extract_wwn(const char *ns, u64 *nm)
 128 {
 129         unsigned int i, j;
 130         u8 wwn[8];
 131
 132         memset(wwn, 0, sizeof(wwn));
 133
 134         /* Validate and store the new name */
 135         for (i = 0, j = 0; i < 16; i++) {
 136                 int value;
 137
 138                 value = hex_to_bin(*ns++);
 139                 if (value >= 0)
 140                         j = (j << 4) | value;
 141                 else
 142                         return -EINVAL;
 143
 144                 if (i % 2) {
 145                         wwn[i/2] = j & 0xff;
 146                         j = 0;
 147                 }
 148         }
 149
 150         *nm = wwn_to_u64(wwn);
 151         return 0;
 152 }
 153
 154 /*
 155  * This parsing logic follows drivers/scsi/scsi_transport_fc.c:
 156  * store_fc_host_vport_create()
 157  */
 158 static int tcm_qla2xxx_npiv_parse_wwn(
 159         const char *name,
 160         size_t count,
 161         u64 *wwpn,
 162         u64 *wwnn)
 163 {
 164         unsigned int cnt = count;
 165         int rc;
 166
 167         *wwpn = 0;
 168         *wwnn = 0;
 169
 170         /* count may include a LF at end of string */
 171         if (name[cnt-1] == '\n' || name[cnt-1] == 0)
 172                 cnt--;
 173
 174         /* validate we have enough characters for WWPN */
 175         if ((cnt != (16+1+16)) || (name[16] != ':'))
 176                 return -EINVAL;
 177
 178         rc = tcm_qla2xxx_npiv_extract_wwn(&name[0], wwpn);
 179         if (rc != 0)
 180                 return rc;
 181
 182         rc = tcm_qla2xxx_npiv_extract_wwn(&name[17], wwnn);
 183         if (rc != 0)
 184                 return rc;
 185
 186         return 0;
 187 }
 188
 189 static char *tcm_qla2xxx_npiv_get_fabric_name(void)
 190 {
 191         return "qla2xxx_npiv";
 192 }
 193
 194 static u8 tcm_qla2xxx_get_fabric_proto_ident(struct se_portal_group *se_tpg)
 195 {
 196         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 197                                 struct tcm_qla2xxx_tpg, se_tpg);
 198         struct tcm_qla2xxx_lport *lport = tpg->lport;
 199         u8 proto_id;
 200
 201         switch (lport->lport_proto_id) {
 202         case SCSI_PROTOCOL_FCP:
 203         default:
 204                 proto_id = fc_get_fabric_proto_ident(se_tpg);
 205                 break;
 206         }
 207
 208         return proto_id;
 209 }
 210
 211 static char *tcm_qla2xxx_get_fabric_wwn(struct se_portal_group *se_tpg)
 212 {
 213         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 214                                 struct tcm_qla2xxx_tpg, se_tpg);
 215         struct tcm_qla2xxx_lport *lport = tpg->lport;
 216
 217         return lport->lport_naa_name;
 218 }
 219
 220 static u16 tcm_qla2xxx_get_tag(struct se_portal_group *se_tpg)
 221 {
 222         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 223                                 struct tcm_qla2xxx_tpg, se_tpg);
 224         return tpg->lport_tpgt;
 225 }
 226
 227 static u32 tcm_qla2xxx_get_default_depth(struct se_portal_group *se_tpg)
 228 {
 229         return 1;
 230 }
 231
 232 static u32 tcm_qla2xxx_get_pr_transport_id(
 233         struct se_portal_group *se_tpg,
 234         struct se_node_acl *se_nacl,
 235         struct t10_pr_registration *pr_reg,
 236         int *format_code,
 237         unsigned char *buf)
 238 {
 239         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 240                                 struct tcm_qla2xxx_tpg, se_tpg);
 241         struct tcm_qla2xxx_lport *lport = tpg->lport;
 242         int ret = 0;
 243
 244         switch (lport->lport_proto_id) {
 245         case SCSI_PROTOCOL_FCP:
 246         default:
 247                 ret = fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
 248                                         format_code, buf);
 249                 break;
 250         }
 251
 252         return ret;
 253 }
 254
 255 static u32 tcm_qla2xxx_get_pr_transport_id_len(
 256         struct se_portal_group *se_tpg,
 257         struct se_node_acl *se_nacl,
 258         struct t10_pr_registration *pr_reg,
 259         int *format_code)
 260 {
 261         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 262                                 struct tcm_qla2xxx_tpg, se_tpg);
 263         struct tcm_qla2xxx_lport *lport = tpg->lport;
 264         int ret = 0;
 265
 266         switch (lport->lport_proto_id) {
 267         case SCSI_PROTOCOL_FCP:
 268         default:
 269                 ret = fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
 270                                         format_code);
 271                 break;
 272         }
 273
 274         return ret;
 275 }
 276
 277 static char *tcm_qla2xxx_parse_pr_out_transport_id(
 278         struct se_portal_group *se_tpg,
 279         const char *buf,
 280         u32 *out_tid_len,
 281         char **port_nexus_ptr)
 282 {
 283         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 284                                 struct tcm_qla2xxx_tpg, se_tpg);
 285         struct tcm_qla2xxx_lport *lport = tpg->lport;
 286         char *tid = NULL;
 287
 288         switch (lport->lport_proto_id) {
 289         case SCSI_PROTOCOL_FCP:
 290         default:
 291                 tid = fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
 292                                         port_nexus_ptr);
 293                 break;
 294         }
 295
 296         return tid;
 297 }
 298
 299 static int tcm_qla2xxx_check_demo_mode(struct se_portal_group *se_tpg)
 300 {
 301         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 302                                 struct tcm_qla2xxx_tpg, se_tpg);
 303
 304         return tpg->tpg_attrib.generate_node_acls;
 305 }
 306
 307 static int tcm_qla2xxx_check_demo_mode_cache(struct se_portal_group *se_tpg)
 308 {
 309         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 310                                 struct tcm_qla2xxx_tpg, se_tpg);
 311
 312         return tpg->tpg_attrib.cache_dynamic_acls;
 313 }
 314
 315 static int tcm_qla2xxx_check_demo_write_protect(struct se_portal_group *se_tpg)
 316 {
 317         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 318                                 struct tcm_qla2xxx_tpg, se_tpg);
 319
 320         return tpg->tpg_attrib.demo_mode_write_protect;
 321 }
 322
 323 static int tcm_qla2xxx_check_prod_write_protect(struct se_portal_group *se_tpg)
 324 {
 325         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 326                                 struct tcm_qla2xxx_tpg, se_tpg);
 327
 328         return tpg->tpg_attrib.prod_mode_write_protect;
 329 }
 330
 331 static int tcm_qla2xxx_check_demo_mode_login_only(struct se_portal_group *se_tpg)
 332 {
 333         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 334                                 struct tcm_qla2xxx_tpg, se_tpg);
 335
 336         return tpg->tpg_attrib.demo_mode_login_only;
 337 }
 338
 339 static int tcm_qla2xxx_check_prot_fabric_only(struct se_portal_group *se_tpg)
 340 {
 341         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 342                                 struct tcm_qla2xxx_tpg, se_tpg);
 343
 344         return tpg->tpg_attrib.fabric_prot_type;
 345 }
 346
 347 static struct se_node_acl *tcm_qla2xxx_alloc_fabric_acl(
 348         struct se_portal_group *se_tpg)
 349 {
 350         struct tcm_qla2xxx_nacl *nacl;
 351
 352         nacl = kzalloc(sizeof(struct tcm_qla2xxx_nacl), GFP_KERNEL);
 353         if (!nacl) {
 354                 pr_err("Unable to allocate struct tcm_qla2xxx_nacl\n");
 355                 return NULL;
 356         }
 357
 358         return &nacl->se_node_acl;
 359 }
 360
 361 static void tcm_qla2xxx_release_fabric_acl(
 362         struct se_portal_group *se_tpg,
 363         struct se_node_acl *se_nacl)
 364 {
 365         struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
 366                         struct tcm_qla2xxx_nacl, se_node_acl);
 367         kfree(nacl);
 368 }
 369
 370 static u32 tcm_qla2xxx_tpg_get_inst_index(struct se_portal_group *se_tpg)
 371 {
 372         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
 373                                 struct tcm_qla2xxx_tpg, se_tpg);
 374
 375         return tpg->lport_tpgt;
 376 }
 377
 378 static void tcm_qla2xxx_complete_mcmd(struct work_struct *work)
 379 {
 380         struct qla_tgt_mgmt_cmd *mcmd = container_of(work,
 381                         struct qla_tgt_mgmt_cmd, free_work);
 382
 383         transport_generic_free_cmd(&mcmd->se_cmd, 0);
 384 }
 385
 386 /*
 387  * Called from qla_target_template->free_mcmd(), and will call
 388  * tcm_qla2xxx_release_cmd() via normal struct target_core_fabric_ops
 389  * release callback.  qla_hw_data->hardware_lock is expected to be held
 390  */
 391 static void tcm_qla2xxx_free_mcmd(struct qla_tgt_mgmt_cmd *mcmd)
 392 {
 393         INIT_WORK(&mcmd->free_work, tcm_qla2xxx_complete_mcmd);
 394         queue_work(tcm_qla2xxx_free_wq, &mcmd->free_work);
 395 }
 396
 397 static void tcm_qla2xxx_complete_free(struct work_struct *work)
 398 {
 399         struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
 400
 401         cmd->cmd_in_wq = 0;
 402
 403         WARN_ON(cmd->cmd_flags &  BIT_16);
 404
 405         cmd->cmd_flags |= BIT_16;
 406         transport_generic_free_cmd(&cmd->se_cmd, 0);
 407 }
 408
 409 /*
 410  * Called from qla_target_template->free_cmd(), and will call
 411  * tcm_qla2xxx_release_cmd via normal struct target_core_fabric_ops
 412  * release callback.  qla_hw_data->hardware_lock is expected to be held
 413  */
 414 static void tcm_qla2xxx_free_cmd(struct qla_tgt_cmd *cmd)
 415 {
 416         cmd->cmd_in_wq = 1;
 417         INIT_WORK(&cmd->work, tcm_qla2xxx_complete_free);
 418         queue_work(tcm_qla2xxx_free_wq, &cmd->work);
 419 }
 420
 421 /*
 422  * Called from struct target_core_fabric_ops->check_stop_free() context
 423  */
 424 static int tcm_qla2xxx_check_stop_free(struct se_cmd *se_cmd)
 425 {
 426         struct qla_tgt_cmd *cmd;
 427
 428         if ((se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) == 0) {
 429                 cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
 430                 cmd->cmd_flags |= BIT_14;
 431         }
 432
 433         return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
 434 }
 435
 436 /* tcm_qla2xxx_release_cmd - Callback from TCM Core to release underlying
 437  * fabric descriptor @se_cmd command to release
 438  */
 439 static void tcm_qla2xxx_release_cmd(struct se_cmd *se_cmd)
 440 {
 441         struct qla_tgt_cmd *cmd;
 442
 443         if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) {
 444                 struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,
 445                                 struct qla_tgt_mgmt_cmd, se_cmd);
 446                 qlt_free_mcmd(mcmd);
 447                 return;
 448         }
 449
 450         cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
 451         qlt_free_cmd(cmd);
 452 }
 453
 454 static int tcm_qla2xxx_shutdown_session(struct se_session *se_sess)
 455 {
 456         struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
 457         struct scsi_qla_host *vha;
 458         unsigned long flags;
 459
 460         BUG_ON(!sess);
 461         vha = sess->vha;
 462
 463         spin_lock_irqsave(&vha->hw->hardware_lock, flags);
 464         target_sess_cmd_list_set_waiting(se_sess);
 465         spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
 466
 467         return 1;
 468 }
 469
 470 static void tcm_qla2xxx_close_session(struct se_session *se_sess)
 471 {
 472         struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
 473         struct scsi_qla_host *vha;
 474         unsigned long flags;
 475
 476         BUG_ON(!sess);
 477         vha = sess->vha;
 478
 479         spin_lock_irqsave(&vha->hw->hardware_lock, flags);
 480         qlt_unreg_sess(sess);
 481         spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
 482 }
 483
 484 static u32 tcm_qla2xxx_sess_get_index(struct se_session *se_sess)
 485 {
 486         return 0;
 487 }
 488
 489 static int tcm_qla2xxx_write_pending(struct se_cmd *se_cmd)
 490 {
 491         struct qla_tgt_cmd *cmd = container_of(se_cmd,
 492                                 struct qla_tgt_cmd, se_cmd);
 493
 494         cmd->bufflen = se_cmd->data_length;
 495         cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
 496
 497         cmd->sg_cnt = se_cmd->t_data_nents;
 498         cmd->sg = se_cmd->t_data_sg;
 499
 500         cmd->prot_sg_cnt = se_cmd->t_prot_nents;
 501         cmd->prot_sg = se_cmd->t_prot_sg;
 502         cmd->blk_sz  = se_cmd->se_dev->dev_attrib.block_size;
 503         se_cmd->pi_err = 0;
 504
 505         /*
 506          * qla_target.c:qlt_rdy_to_xfer() will call pci_map_sg() to setup
 507          * the SGL mappings into PCIe memory for incoming FCP WRITE data.
 508          */
 509         return qlt_rdy_to_xfer(cmd);
 510 }
 511
 512 static int tcm_qla2xxx_write_pending_status(struct se_cmd *se_cmd)
 513 {
 514         unsigned long flags;
 515         /*
 516          * Check for WRITE_PENDING status to determine if we need to wait for
 517          * CTIO aborts to be posted via hardware in tcm_qla2xxx_handle_data().
 518          */
 519         spin_lock_irqsave(&se_cmd->t_state_lock, flags);
 520         if (se_cmd->t_state == TRANSPORT_WRITE_PENDING ||
 521             se_cmd->t_state == TRANSPORT_COMPLETE_QF_WP) {
 522                 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
 523                 wait_for_completion_timeout(&se_cmd->t_transport_stop_comp,
 524                                                 3000);
 525                 return 0;
 526         }
 527         spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
 528
 529         return 0;
 530 }
 531
 532 static void tcm_qla2xxx_set_default_node_attrs(struct se_node_acl *nacl)
 533 {
 534         return;
 535 }
 536
 537 static u32 tcm_qla2xxx_get_task_tag(struct se_cmd *se_cmd)
 538 {
 539         struct qla_tgt_cmd *cmd;
 540
 541         /* check for task mgmt cmd */
 542         if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
 543                 return 0xffffffff;
 544
 545         cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
 546
 547         return cmd->tag;
 548 }
 549
 550 static int tcm_qla2xxx_get_cmd_state(struct se_cmd *se_cmd)
 551 {
 552         return 0;
 553 }
 554
 555 /*
 556  * Called from process context in qla_target.c:qlt_do_work() code
 557  */
 558 static int tcm_qla2xxx_handle_cmd(scsi_qla_host_t *vha, struct qla_tgt_cmd *cmd,
 559         unsigned char *cdb, uint32_t data_length, int fcp_task_attr,
 560         int data_dir, int bidi)
 561 {
 562         struct se_cmd *se_cmd = &cmd->se_cmd;
 563         struct se_session *se_sess;
 564         struct qla_tgt_sess *sess;
 565         int flags = TARGET_SCF_ACK_KREF;
 566
 567         if (bidi)
 568                 flags |= TARGET_SCF_BIDI_OP;
 569
 570         sess = cmd->sess;
 571         if (!sess) {
 572                 pr_err("Unable to locate struct qla_tgt_sess from qla_tgt_cmd\n");
 573                 return -EINVAL;
 574         }
 575
 576         se_sess = sess->se_sess;
 577         if (!se_sess) {
 578                 pr_err("Unable to locate active struct se_session\n");
 579                 return -EINVAL;
 580         }
 581
 582         return target_submit_cmd(se_cmd, se_sess, cdb, &cmd->sense_buffer[0],
 583                                 cmd->unpacked_lun, data_length, fcp_task_attr,
 584                                 data_dir, flags);
 585 }
 586
 587 static void tcm_qla2xxx_handle_data_work(struct work_struct *work)
 588 {
 589         struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
 590
 591         /*
 592          * Ensure that the complete FCP WRITE payload has been received.
 593          * Otherwise return an exception via CHECK_CONDITION status.
 594          */
 595         cmd->cmd_in_wq = 0;
 596         cmd->cmd_flags |= BIT_11;
 597         if (!cmd->write_data_transferred) {
 598                 /*
 599                  * Check if se_cmd has already been aborted via LUN_RESET, and
 600                  * waiting upon completion in tcm_qla2xxx_write_pending_status()
 601                  */
 602                 if (cmd->se_cmd.transport_state & CMD_T_ABORTED) {
 603                         complete(&cmd->se_cmd.t_transport_stop_comp);
 604                         return;
 605                 }
 606
 607                 if (cmd->se_cmd.pi_err)
 608                         transport_generic_request_failure(&cmd->se_cmd,
 609                                 cmd->se_cmd.pi_err);
 610                 else
 611                         transport_generic_request_failure(&cmd->se_cmd,
 612                                 TCM_CHECK_CONDITION_ABORT_CMD);
 613
 614                 return;
 615         }
 616
 617         return target_execute_cmd(&cmd->se_cmd);
 618 }
 619
 620 /*
 621  * Called from qla_target.c:qlt_do_ctio_completion()
 622  */
 623 static void tcm_qla2xxx_handle_data(struct qla_tgt_cmd *cmd)
 624 {
 625         cmd->cmd_flags |= BIT_10;
 626         cmd->cmd_in_wq = 1;
 627         INIT_WORK(&cmd->work, tcm_qla2xxx_handle_data_work);
 628         queue_work(tcm_qla2xxx_free_wq, &cmd->work);
 629 }
 630
 631 static void tcm_qla2xxx_handle_dif_work(struct work_struct *work)
 632 {
 633         struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
 634
 635         /* take an extra kref to prevent cmd free too early.
 636          * need to wait for SCSI status/check condition to
 637          * finish responding generate by transport_generic_request_failure.
 638          */
 639         kref_get(&cmd->se_cmd.cmd_kref);
 640         transport_generic_request_failure(&cmd->se_cmd, cmd->se_cmd.pi_err);
 641 }
 642
 643 /*
 644  * Called from qla_target.c:qlt_do_ctio_completion()
 645  */
 646 static void tcm_qla2xxx_handle_dif_err(struct qla_tgt_cmd *cmd)
 647 {
 648         INIT_WORK(&cmd->work, tcm_qla2xxx_handle_dif_work);
 649         queue_work(tcm_qla2xxx_free_wq, &cmd->work);
 650 }
 651
 652 /*
 653  * Called from qla_target.c:qlt_issue_task_mgmt()
 654  */
 655 static int tcm_qla2xxx_handle_tmr(struct qla_tgt_mgmt_cmd *mcmd, uint32_t lun,
 656         uint8_t tmr_func, uint32_t tag)
 657 {
 658         struct qla_tgt_sess *sess = mcmd->sess;
 659         struct se_cmd *se_cmd = &mcmd->se_cmd;
 660
 661         return target_submit_tmr(se_cmd, sess->se_sess, NULL, lun, mcmd,
 662                         tmr_func, GFP_ATOMIC, tag, TARGET_SCF_ACK_KREF);
 663 }
 664
 665 static int tcm_qla2xxx_queue_data_in(struct se_cmd *se_cmd)
 666 {
 667         struct qla_tgt_cmd *cmd = container_of(se_cmd,
 668                                 struct qla_tgt_cmd, se_cmd);
 669
 670         cmd->cmd_flags |= BIT_4;
 671         cmd->bufflen = se_cmd->data_length;
 672         cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
 673         cmd->aborted = (se_cmd->transport_state & CMD_T_ABORTED);
 674
 675         cmd->sg_cnt = se_cmd->t_data_nents;
 676         cmd->sg = se_cmd->t_data_sg;
 677         cmd->offset = 0;
 678         cmd->cmd_flags |= BIT_3;
 679
 680         cmd->prot_sg_cnt = se_cmd->t_prot_nents;
 681         cmd->prot_sg = se_cmd->t_prot_sg;
 682         cmd->blk_sz  = se_cmd->se_dev->dev_attrib.block_size;
 683         se_cmd->pi_err = 0;
 684
 685         /*
 686          * Now queue completed DATA_IN the qla2xxx LLD and response ring
 687          */
 688         return qlt_xmit_response(cmd, QLA_TGT_XMIT_DATA|QLA_TGT_XMIT_STATUS,
 689                                 se_cmd->scsi_status);
 690 }
 691
 692 static int tcm_qla2xxx_queue_status(struct se_cmd *se_cmd)
 693 {
 694         struct qla_tgt_cmd *cmd = container_of(se_cmd,
 695                                 struct qla_tgt_cmd, se_cmd);
 696         int xmit_type = QLA_TGT_XMIT_STATUS;
 697
 698         cmd->bufflen = se_cmd->data_length;
 699         cmd->sg = NULL;
 700         cmd->sg_cnt = 0;
 701         cmd->offset = 0;
 702         cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
 703         cmd->aborted = (se_cmd->transport_state & CMD_T_ABORTED);
 704         if (cmd->cmd_flags &  BIT_5) {
 705                 pr_crit("Bit_5 already set for cmd = %p.\n", cmd);
 706                 dump_stack();
 707         }
 708         cmd->cmd_flags |= BIT_5;
 709
 710         if (se_cmd->data_direction == DMA_FROM_DEVICE) {
 711                 /*
 712                  * For FCP_READ with CHECK_CONDITION status, clear cmd->bufflen
 713                  * for qla_tgt_xmit_response LLD code
 714                  */
 715                 if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
 716                         se_cmd->se_cmd_flags &= ~SCF_OVERFLOW_BIT;
 717                         se_cmd->residual_count = 0;
 718                 }
 719                 se_cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
 720                 se_cmd->residual_count += se_cmd->data_length;
 721
 722                 cmd->bufflen = 0;
 723         }
 724         /*
 725          * Now queue status response to qla2xxx LLD code and response ring
 726          */
 727         return qlt_xmit_response(cmd, xmit_type, se_cmd->scsi_status);
 728 }
 729
 730 static void tcm_qla2xxx_queue_tm_rsp(struct se_cmd *se_cmd)
 731 {
 732         struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
 733         struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,
 734                                 struct qla_tgt_mgmt_cmd, se_cmd);
 735
 736         pr_debug("queue_tm_rsp: mcmd: %p func: 0x%02x response: 0x%02x\n",
 737                         mcmd, se_tmr->function, se_tmr->response);
 738         /*
 739          * Do translation between TCM TM response codes and
 740          * QLA2xxx FC TM response codes.
 741          */
 742         switch (se_tmr->response) {
 743         case TMR_FUNCTION_COMPLETE:
 744                 mcmd->fc_tm_rsp = FC_TM_SUCCESS;
 745                 break;
 746         case TMR_TASK_DOES_NOT_EXIST:
 747                 mcmd->fc_tm_rsp = FC_TM_BAD_CMD;
 748                 break;
 749         case TMR_FUNCTION_REJECTED:
 750                 mcmd->fc_tm_rsp = FC_TM_REJECT;
 751                 break;
 752         case TMR_LUN_DOES_NOT_EXIST:
 753         default:
 754                 mcmd->fc_tm_rsp = FC_TM_FAILED;
 755                 break;
 756         }
 757         /*
 758          * Queue the TM response to QLA2xxx LLD to build a
 759          * CTIO response packet.
 760          */
 761         qlt_xmit_tm_rsp(mcmd);
 762 }
 763
 764 static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd)
 765 {
 766         struct qla_tgt_cmd *cmd = container_of(se_cmd,
 767                                 struct qla_tgt_cmd, se_cmd);
 768         struct scsi_qla_host *vha = cmd->vha;
 769         struct qla_hw_data *ha = vha->hw;
 770
 771         if (!cmd->sg_mapped)
 772                 return;
 773
 774         pci_unmap_sg(ha->pdev, cmd->sg, cmd->sg_cnt, cmd->dma_data_direction);
 775         cmd->sg_mapped = 0;
 776 }
 777
 778 static void tcm_qla2xxx_clear_sess_lookup(struct tcm_qla2xxx_lport *,
 779                         struct tcm_qla2xxx_nacl *, struct qla_tgt_sess *);
 780 /*
 781  * Expected to be called with struct qla_hw_data->hardware_lock held
 782  */
 783 static void tcm_qla2xxx_clear_nacl_from_fcport_map(struct qla_tgt_sess *sess)
 784 {
 785         struct se_node_acl *se_nacl = sess->se_sess->se_node_acl;
 786         struct se_portal_group *se_tpg = se_nacl->se_tpg;
 787         struct se_wwn *se_wwn = se_tpg->se_tpg_wwn;
 788         struct tcm_qla2xxx_lport *lport = container_of(se_wwn,
 789                                 struct tcm_qla2xxx_lport, lport_wwn);
 790         struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
 791                                 struct tcm_qla2xxx_nacl, se_node_acl);
 792         void *node;
 793
 794         pr_debug("fc_rport domain: port_id 0x%06x\n", nacl->nport_id);
 795
 796         node = btree_remove32(&lport->lport_fcport_map, nacl->nport_id);
 797         if (WARN_ON(node && (node != se_nacl))) {
 798                 /*
 799                  * The nacl no longer matches what we think it should be.
 800                  * Most likely a new dynamic acl has been added while
 801                  * someone dropped the hardware lock.  It clearly is a
 802                  * bug elsewhere, but this bit can't make things worse.
 803                  */
 804                 btree_insert32(&lport->lport_fcport_map, nacl->nport_id,
 805                                node, GFP_ATOMIC);
 806         }
 807
 808         pr_debug("Removed from fcport_map: %p for WWNN: 0x%016LX, port_id: 0x%06x\n",
 809             se_nacl, nacl->nport_wwnn, nacl->nport_id);
 810         /*
 811          * Now clear the se_nacl and session pointers from our HW lport lookup
 812          * table mapping for this initiator's fabric S_ID and LOOP_ID entries.
 813          *
 814          * This is done ahead of callbacks into tcm_qla2xxx_free_session() ->
 815          * target_wait_for_sess_cmds() before the session waits for outstanding
 816          * I/O to complete, to avoid a race between session shutdown execution
 817          * and incoming ATIOs or TMRs picking up a stale se_node_act reference.
 818          */
 819         tcm_qla2xxx_clear_sess_lookup(lport, nacl, sess);
 820 }
 821
 822 static void tcm_qla2xxx_release_session(struct kref *kref)
 823 {
 824         struct se_session *se_sess = container_of(kref,
 825                         struct se_session, sess_kref);
 826
 827         qlt_unreg_sess(se_sess->fabric_sess_ptr);
 828 }
 829
 830 static void tcm_qla2xxx_put_session(struct se_session *se_sess)
 831 {
 832         struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
 833         struct qla_hw_data *ha = sess->vha->hw;
 834         unsigned long flags;
 835
 836         spin_lock_irqsave(&ha->hardware_lock, flags);
 837         kref_put(&se_sess->sess_kref, tcm_qla2xxx_release_session);
 838         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 839 }
 840
 841 static void tcm_qla2xxx_put_sess(struct qla_tgt_sess *sess)
 842 {
 843         if (!sess)
 844                 return;
 845
 846         assert_spin_locked(&sess->vha->hw->hardware_lock);
 847         kref_put(&sess->se_sess->sess_kref, tcm_qla2xxx_release_session);
 848 }
 849
 850 static void tcm_qla2xxx_shutdown_sess(struct qla_tgt_sess *sess)
 851 {
 852         assert_spin_locked(&sess->vha->hw->hardware_lock);
 853         target_sess_cmd_list_set_waiting(sess->se_sess);
 854 }
 855
 856 static struct se_node_acl *tcm_qla2xxx_make_nodeacl(
 857         struct se_portal_group *se_tpg,
 858         struct config_group *group,
 859         const char *name)
 860 {
 861         struct se_node_acl *se_nacl, *se_nacl_new;
 862         struct tcm_qla2xxx_nacl *nacl;
 863         u64 wwnn;
 864         u32 qla2xxx_nexus_depth;
 865
 866         if (tcm_qla2xxx_parse_wwn(name, &wwnn, 1) < 0)
 867                 return ERR_PTR(-EINVAL);
 868
 869         se_nacl_new = tcm_qla2xxx_alloc_fabric_acl(se_tpg);
 870         if (!se_nacl_new)
 871                 return ERR_PTR(-ENOMEM);
 872 /* #warning FIXME: Hardcoded qla2xxx_nexus depth in tcm_qla2xxx_make_nodeacl */
 873         qla2xxx_nexus_depth = 1;
 874
 875         /*
 876          * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
 877          * when converting a NodeACL from demo mode -> explict
 878          */
 879         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
 880                                 name, qla2xxx_nexus_depth);
 881         if (IS_ERR(se_nacl)) {
 882                 tcm_qla2xxx_release_fabric_acl(se_tpg, se_nacl_new);
 883                 return se_nacl;
 884         }
 885         /*
 886          * Locate our struct tcm_qla2xxx_nacl and set the FC Nport WWPN
 887          */
 888         nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
 889         nacl->nport_wwnn = wwnn;
 890         tcm_qla2xxx_format_wwn(&nacl->nport_name[0], TCM_QLA2XXX_NAMELEN, wwnn);
 891
 892         return se_nacl;
 893 }
 894
 895 static void tcm_qla2xxx_drop_nodeacl(struct se_node_acl *se_acl)
 896 {
 897         struct se_portal_group *se_tpg = se_acl->se_tpg;
 898         struct tcm_qla2xxx_nacl *nacl = container_of(se_acl,
 899                                 struct tcm_qla2xxx_nacl, se_node_acl);
 900
 901         core_tpg_del_initiator_node_acl(se_tpg, se_acl, 1);
 902         kfree(nacl);
 903 }
 904
 905 /* Start items for tcm_qla2xxx_tpg_attrib_cit */
 906
 907 #define DEF_QLA_TPG_ATTRIB(name)                                        \
 908                                                                         \
 909 static ssize_t tcm_qla2xxx_tpg_attrib_show_##name(                      \
 910         struct se_portal_group *se_tpg,                                 \
 911         char *page)                                                     \
 912 {                                                                       \
 913         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,              \
 914                         struct tcm_qla2xxx_tpg, se_tpg);                \
 915                                                                         \
 916         return sprintf(page, "%u\n", tpg->tpg_attrib.name);     \
 917 }                                                                       \
 918                                                                         \
 919 static ssize_t tcm_qla2xxx_tpg_attrib_store_##name(                     \
 920         struct se_portal_group *se_tpg,                                 \
 921         const char *page,                                               \
 922         size_t count)                                                   \
 923 {                                                                       \
 924         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,              \
 925                         struct tcm_qla2xxx_tpg, se_tpg);                \
 926         unsigned long val;                                              \
 927         int ret;                                                        \
 928                                                                         \
 929         ret = kstrtoul(page, 0, &val);                                  \
 930         if (ret < 0) {                                                  \
 931                 pr_err("kstrtoul() failed with"                         \
 932                                 " ret: %d\n", ret);                     \
 933                 return -EINVAL;                                         \
 934         }                                                               \
 935         ret = tcm_qla2xxx_set_attrib_##name(tpg, val);                  \
 936                                                                         \
 937         return (!ret) ? count : -EINVAL;                                \
 938 }
 939
 940 #define DEF_QLA_TPG_ATTR_BOOL(_name)                                    \
 941                                                                         \
 942 static int tcm_qla2xxx_set_attrib_##_name(                              \
 943         struct tcm_qla2xxx_tpg *tpg,                                    \
 944         unsigned long val)                                              \
 945 {                                                                       \
 946         struct tcm_qla2xxx_tpg_attrib *a = &tpg->tpg_attrib;            \
 947                                                                         \
 948         if ((val != 0) && (val != 1)) {                                 \
 949                 pr_err("Illegal boolean value %lu\n", val);             \
 950                 return -EINVAL;                                         \
 951         }                                                               \
 952                                                                         \
 953         a->_name = val;                                                 \
 954         return 0;                                                       \
 955 }
 956
 957 #define QLA_TPG_ATTR(_name, _mode) \
 958         TF_TPG_ATTRIB_ATTR(tcm_qla2xxx, _name, _mode);
 959
 960 /*
 961  * Define tcm_qla2xxx_tpg_attrib_s_generate_node_acls
 962  */
 963 DEF_QLA_TPG_ATTR_BOOL(generate_node_acls);
 964 DEF_QLA_TPG_ATTRIB(generate_node_acls);
 965 QLA_TPG_ATTR(generate_node_acls, S_IRUGO | S_IWUSR);
 966
 967 /*
 968  Define tcm_qla2xxx_attrib_s_cache_dynamic_acls
 969  */
 970 DEF_QLA_TPG_ATTR_BOOL(cache_dynamic_acls);
 971 DEF_QLA_TPG_ATTRIB(cache_dynamic_acls);
 972 QLA_TPG_ATTR(cache_dynamic_acls, S_IRUGO | S_IWUSR);
 973
 974 /*
 975  * Define tcm_qla2xxx_tpg_attrib_s_demo_mode_write_protect
 976  */
 977 DEF_QLA_TPG_ATTR_BOOL(demo_mode_write_protect);
 978 DEF_QLA_TPG_ATTRIB(demo_mode_write_protect);
 979 QLA_TPG_ATTR(demo_mode_write_protect, S_IRUGO | S_IWUSR);
 980
 981 /*
 982  * Define tcm_qla2xxx_tpg_attrib_s_prod_mode_write_protect
 983  */
 984 DEF_QLA_TPG_ATTR_BOOL(prod_mode_write_protect);
 985 DEF_QLA_TPG_ATTRIB(prod_mode_write_protect);
 986 QLA_TPG_ATTR(prod_mode_write_protect, S_IRUGO | S_IWUSR);
 987
 988 /*
 989  * Define tcm_qla2xxx_tpg_attrib_s_demo_mode_login_only
 990  */
 991 DEF_QLA_TPG_ATTR_BOOL(demo_mode_login_only);
 992 DEF_QLA_TPG_ATTRIB(demo_mode_login_only);
 993 QLA_TPG_ATTR(demo_mode_login_only, S_IRUGO | S_IWUSR);
 994
 995 static struct configfs_attribute *tcm_qla2xxx_tpg_attrib_attrs[] = {
 996         &tcm_qla2xxx_tpg_attrib_generate_node_acls.attr,
 997         &tcm_qla2xxx_tpg_attrib_cache_dynamic_acls.attr,
 998         &tcm_qla2xxx_tpg_attrib_demo_mode_write_protect.attr,
 999         &tcm_qla2xxx_tpg_attrib_prod_mode_write_protect.attr,
1000         &tcm_qla2xxx_tpg_attrib_demo_mode_login_only.attr,
1001         NULL,
1002 };
1003
1004 /* End items for tcm_qla2xxx_tpg_attrib_cit */
1005
1006 static ssize_t tcm_qla2xxx_tpg_show_enable(
1007         struct se_portal_group *se_tpg,
1008         char *page)
1009 {
1010         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1011                         struct tcm_qla2xxx_tpg, se_tpg);
1012
1013         return snprintf(page, PAGE_SIZE, "%d\n",
1014                         atomic_read(&tpg->lport_tpg_enabled));
1015 }
1016
1017 static void tcm_qla2xxx_depend_tpg(struct work_struct *work)
1018 {
1019         struct tcm_qla2xxx_tpg *base_tpg = container_of(work,
1020                                 struct tcm_qla2xxx_tpg, tpg_base_work);
1021         struct se_portal_group *se_tpg = &base_tpg->se_tpg;
1022         struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha;
1023
1024         if (!target_depend_item(&se_tpg->tpg_group.cg_item)) {
1025                 atomic_set(&base_tpg->lport_tpg_enabled, 1);
1026                 qlt_enable_vha(base_vha);
1027         }
1028         complete(&base_tpg->tpg_base_comp);
1029 }
1030
1031 static void tcm_qla2xxx_undepend_tpg(struct work_struct *work)
1032 {
1033         struct tcm_qla2xxx_tpg *base_tpg = container_of(work,
1034                                 struct tcm_qla2xxx_tpg, tpg_base_work);
1035         struct se_portal_group *se_tpg = &base_tpg->se_tpg;
1036         struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha;
1037
1038         if (!qlt_stop_phase1(base_vha->vha_tgt.qla_tgt)) {
1039                 atomic_set(&base_tpg->lport_tpg_enabled, 0);
1040                 target_undepend_item(&se_tpg->tpg_group.cg_item);
1041         }
1042         complete(&base_tpg->tpg_base_comp);
1043 }
1044
1045 static ssize_t tcm_qla2xxx_tpg_store_enable(
1046         struct se_portal_group *se_tpg,
1047         const char *page,
1048         size_t count)
1049 {
1050         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1051                         struct tcm_qla2xxx_tpg, se_tpg);
1052         unsigned long op;
1053         int rc;
1054
1055         rc = kstrtoul(page, 0, &op);
1056         if (rc < 0) {
1057                 pr_err("kstrtoul() returned %d\n", rc);
1058                 return -EINVAL;
1059         }
1060         if ((op != 1) && (op != 0)) {
1061                 pr_err("Illegal value for tpg_enable: %lu\n", op);
1062                 return -EINVAL;
1063         }
1064         if (op) {
1065                 if (atomic_read(&tpg->lport_tpg_enabled))
1066                         return -EEXIST;
1067
1068                 INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_depend_tpg);
1069         } else {
1070                 if (!atomic_read(&tpg->lport_tpg_enabled))
1071                         return count;
1072
1073                 INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_undepend_tpg);
1074         }
1075         init_completion(&tpg->tpg_base_comp);
1076         schedule_work(&tpg->tpg_base_work);
1077         wait_for_completion(&tpg->tpg_base_comp);
1078
1079         if (op) {
1080                 if (!atomic_read(&tpg->lport_tpg_enabled))
1081                         return -ENODEV;
1082         } else {
1083                 if (atomic_read(&tpg->lport_tpg_enabled))
1084                         return -EPERM;
1085         }
1086         return count;
1087 }
1088
1089 TF_TPG_BASE_ATTR(tcm_qla2xxx, enable, S_IRUGO | S_IWUSR);
1090
1091 static ssize_t tcm_qla2xxx_tpg_show_dynamic_sessions(
1092         struct se_portal_group *se_tpg,
1093         char *page)
1094 {
1095         return target_show_dynamic_sessions(se_tpg, page);
1096 }
1097
1098 TF_TPG_BASE_ATTR_RO(tcm_qla2xxx, dynamic_sessions);
1099
1100 static ssize_t tcm_qla2xxx_tpg_store_fabric_prot_type(
1101         struct se_portal_group *se_tpg,
1102         const char *page,
1103         size_t count)
1104 {
1105         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1106                                 struct tcm_qla2xxx_tpg, se_tpg);
1107         unsigned long val;
1108         int ret = kstrtoul(page, 0, &val);
1109
1110         if (ret) {
1111                 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret);
1112                 return ret;
1113         }
1114         if (val != 0 && val != 1 && val != 3) {
1115                 pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val);
1116                 return -EINVAL;
1117         }
1118         tpg->tpg_attrib.fabric_prot_type = val;
1119
1120         return count;
1121 }
1122
1123 static ssize_t tcm_qla2xxx_tpg_show_fabric_prot_type(
1124         struct se_portal_group *se_tpg,
1125         char *page)
1126 {
1127         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1128                                 struct tcm_qla2xxx_tpg, se_tpg);
1129
1130         return sprintf(page, "%d\n", tpg->tpg_attrib.fabric_prot_type);
1131 }
1132 TF_TPG_BASE_ATTR(tcm_qla2xxx, fabric_prot_type, S_IRUGO | S_IWUSR);
1133
1134 static struct configfs_attribute *tcm_qla2xxx_tpg_attrs[] = {
1135         &tcm_qla2xxx_tpg_enable.attr,
1136         &tcm_qla2xxx_tpg_dynamic_sessions.attr,
1137         &tcm_qla2xxx_tpg_fabric_prot_type.attr,
1138         NULL,
1139 };
1140
1141 static struct se_portal_group *tcm_qla2xxx_make_tpg(
1142         struct se_wwn *wwn,
1143         struct config_group *group,
1144         const char *name)
1145 {
1146         struct tcm_qla2xxx_lport *lport = container_of(wwn,
1147                         struct tcm_qla2xxx_lport, lport_wwn);
1148         struct tcm_qla2xxx_tpg *tpg;
1149         unsigned long tpgt;
1150         int ret;
1151
1152         if (strstr(name, "tpgt_") != name)
1153                 return ERR_PTR(-EINVAL);
1154         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > USHRT_MAX)
1155                 return ERR_PTR(-EINVAL);
1156
1157         if ((tpgt != 1)) {
1158                 pr_err("In non NPIV mode, a single TPG=1 is used for HW port mappings\n");
1159                 return ERR_PTR(-ENOSYS);
1160         }
1161
1162         tpg = kzalloc(sizeof(struct tcm_qla2xxx_tpg), GFP_KERNEL);
1163         if (!tpg) {
1164                 pr_err("Unable to allocate struct tcm_qla2xxx_tpg\n");
1165                 return ERR_PTR(-ENOMEM);
1166         }
1167         tpg->lport = lport;
1168         tpg->lport_tpgt = tpgt;
1169         /*
1170          * By default allow READ-ONLY TPG demo-mode access w/ cached dynamic
1171          * NodeACLs
1172          */
1173         tpg->tpg_attrib.generate_node_acls = 1;
1174         tpg->tpg_attrib.demo_mode_write_protect = 1;
1175         tpg->tpg_attrib.cache_dynamic_acls = 1;
1176         tpg->tpg_attrib.demo_mode_login_only = 1;
1177
1178         ret = core_tpg_register(&tcm_qla2xxx_ops, wwn,
1179                                 &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
1180         if (ret < 0) {
1181                 kfree(tpg);
1182                 return NULL;
1183         }
1184
1185         lport->tpg_1 = tpg;
1186
1187         return &tpg->se_tpg;
1188 }
1189
1190 static void tcm_qla2xxx_drop_tpg(struct se_portal_group *se_tpg)
1191 {
1192         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1193                         struct tcm_qla2xxx_tpg, se_tpg);
1194         struct tcm_qla2xxx_lport *lport = tpg->lport;
1195         struct scsi_qla_host *vha = lport->qla_vha;
1196         /*
1197          * Call into qla2x_target.c LLD logic to shutdown the active
1198          * FC Nexuses and disable target mode operation for this qla_hw_data
1199          */
1200         if (vha->vha_tgt.qla_tgt && !vha->vha_tgt.qla_tgt->tgt_stop)
1201                 qlt_stop_phase1(vha->vha_tgt.qla_tgt);
1202
1203         core_tpg_deregister(se_tpg);
1204         /*
1205          * Clear local TPG=1 pointer for non NPIV mode.
1206          */
1207         lport->tpg_1 = NULL;
1208         kfree(tpg);
1209 }
1210
1211 static ssize_t tcm_qla2xxx_npiv_tpg_show_enable(
1212         struct se_portal_group *se_tpg,
1213         char *page)
1214 {
1215         return tcm_qla2xxx_tpg_show_enable(se_tpg, page);
1216 }
1217
1218 static ssize_t tcm_qla2xxx_npiv_tpg_store_enable(
1219         struct se_portal_group *se_tpg,
1220         const char *page,
1221         size_t count)
1222 {
1223         struct se_wwn *se_wwn = se_tpg->se_tpg_wwn;
1224         struct tcm_qla2xxx_lport *lport = container_of(se_wwn,
1225                         struct tcm_qla2xxx_lport, lport_wwn);
1226         struct scsi_qla_host *vha = lport->qla_vha;
1227         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1228                         struct tcm_qla2xxx_tpg, se_tpg);
1229         unsigned long op;
1230         int rc;
1231
1232         rc = kstrtoul(page, 0, &op);
1233         if (rc < 0) {
1234                 pr_err("kstrtoul() returned %d\n", rc);
1235                 return -EINVAL;
1236         }
1237         if ((op != 1) && (op != 0)) {
1238                 pr_err("Illegal value for tpg_enable: %lu\n", op);
1239                 return -EINVAL;
1240         }
1241         if (op) {
1242                 if (atomic_read(&tpg->lport_tpg_enabled))
1243                         return -EEXIST;
1244
1245                 atomic_set(&tpg->lport_tpg_enabled, 1);
1246                 qlt_enable_vha(vha);
1247         } else {
1248                 if (!atomic_read(&tpg->lport_tpg_enabled))
1249                         return count;
1250
1251                 atomic_set(&tpg->lport_tpg_enabled, 0);
1252                 qlt_stop_phase1(vha->vha_tgt.qla_tgt);
1253         }
1254
1255         return count;
1256 }
1257
1258 TF_TPG_BASE_ATTR(tcm_qla2xxx_npiv, enable, S_IRUGO | S_IWUSR);
1259
1260 static struct configfs_attribute *tcm_qla2xxx_npiv_tpg_attrs[] = {
1261         &tcm_qla2xxx_npiv_tpg_enable.attr,
1262         NULL,
1263 };
1264
1265 static struct se_portal_group *tcm_qla2xxx_npiv_make_tpg(
1266         struct se_wwn *wwn,
1267         struct config_group *group,
1268         const char *name)
1269 {
1270         struct tcm_qla2xxx_lport *lport = container_of(wwn,
1271                         struct tcm_qla2xxx_lport, lport_wwn);
1272         struct tcm_qla2xxx_tpg *tpg;
1273         unsigned long tpgt;
1274         int ret;
1275
1276         if (strstr(name, "tpgt_") != name)
1277                 return ERR_PTR(-EINVAL);
1278         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > USHRT_MAX)
1279                 return ERR_PTR(-EINVAL);
1280
1281         tpg = kzalloc(sizeof(struct tcm_qla2xxx_tpg), GFP_KERNEL);
1282         if (!tpg) {
1283                 pr_err("Unable to allocate struct tcm_qla2xxx_tpg\n");
1284                 return ERR_PTR(-ENOMEM);
1285         }
1286         tpg->lport = lport;
1287         tpg->lport_tpgt = tpgt;
1288
1289         /*
1290          * By default allow READ-ONLY TPG demo-mode access w/ cached dynamic
1291          * NodeACLs
1292          */
1293         tpg->tpg_attrib.generate_node_acls = 1;
1294         tpg->tpg_attrib.demo_mode_write_protect = 1;
1295         tpg->tpg_attrib.cache_dynamic_acls = 1;
1296         tpg->tpg_attrib.demo_mode_login_only = 1;
1297
1298         ret = core_tpg_register(&tcm_qla2xxx_npiv_ops, wwn,
1299                                 &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
1300         if (ret < 0) {
1301                 kfree(tpg);
1302                 return NULL;
1303         }
1304         lport->tpg_1 = tpg;
1305         return &tpg->se_tpg;
1306 }
1307
1308 /*
1309  * Expected to be called with struct qla_hw_data->hardware_lock held
1310  */
1311 static struct qla_tgt_sess *tcm_qla2xxx_find_sess_by_s_id(
1312         scsi_qla_host_t *vha,
1313         const uint8_t *s_id)
1314 {
1315         struct tcm_qla2xxx_lport *lport;
1316         struct se_node_acl *se_nacl;
1317         struct tcm_qla2xxx_nacl *nacl;
1318         u32 key;
1319
1320         lport = vha->vha_tgt.target_lport_ptr;
1321         if (!lport) {
1322                 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1323                 dump_stack();
1324                 return NULL;
1325         }
1326
1327         key = (((unsigned long)s_id[0] << 16) |
1328                ((unsigned long)s_id[1] << 8) |
1329                (unsigned long)s_id[2]);
1330         pr_debug("find_sess_by_s_id: 0x%06x\n", key);
1331
1332         se_nacl = btree_lookup32(&lport->lport_fcport_map, key);
1333         if (!se_nacl) {
1334                 pr_debug("Unable to locate s_id: 0x%06x\n", key);
1335                 return NULL;
1336         }
1337         pr_debug("find_sess_by_s_id: located se_nacl: %p, initiatorname: %s\n",
1338             se_nacl, se_nacl->initiatorname);
1339
1340         nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1341         if (!nacl->qla_tgt_sess) {
1342                 pr_err("Unable to locate struct qla_tgt_sess\n");
1343                 return NULL;
1344         }
1345
1346         return nacl->qla_tgt_sess;
1347 }
1348
1349 /*
1350  * Expected to be called with struct qla_hw_data->hardware_lock held
1351  */
1352 static void tcm_qla2xxx_set_sess_by_s_id(
1353         struct tcm_qla2xxx_lport *lport,
1354         struct se_node_acl *new_se_nacl,
1355         struct tcm_qla2xxx_nacl *nacl,
1356         struct se_session *se_sess,
1357         struct qla_tgt_sess *qla_tgt_sess,
1358         uint8_t *s_id)
1359 {
1360         u32 key;
1361         void *slot;
1362         int rc;
1363
1364         key = (((unsigned long)s_id[0] << 16) |
1365                ((unsigned long)s_id[1] << 8) |
1366                (unsigned long)s_id[2]);
1367         pr_debug("set_sess_by_s_id: %06x\n", key);
1368
1369         slot = btree_lookup32(&lport->lport_fcport_map, key);
1370         if (!slot) {
1371                 if (new_se_nacl) {
1372                         pr_debug("Setting up new fc_port entry to new_se_nacl\n");
1373                         nacl->nport_id = key;
1374                         rc = btree_insert32(&lport->lport_fcport_map, key,
1375                                         new_se_nacl, GFP_ATOMIC);
1376                         if (rc)
1377                                 printk(KERN_ERR "Unable to insert s_id into fcport_map: %06x\n",
1378                                     (int)key);
1379                 } else {
1380                         pr_debug("Wiping nonexisting fc_port entry\n");
1381                 }
1382
1383                 qla_tgt_sess->se_sess = se_sess;
1384                 nacl->qla_tgt_sess = qla_tgt_sess;
1385                 return;
1386         }
1387
1388         if (nacl->qla_tgt_sess) {
1389                 if (new_se_nacl == NULL) {
1390                         pr_debug("Clearing existing nacl->qla_tgt_sess and fc_port entry\n");
1391                         btree_remove32(&lport->lport_fcport_map, key);
1392                         nacl->qla_tgt_sess = NULL;
1393                         return;
1394                 }
1395                 pr_debug("Replacing existing nacl->qla_tgt_sess and fc_port entry\n");
1396                 btree_update32(&lport->lport_fcport_map, key, new_se_nacl);
1397                 qla_tgt_sess->se_sess = se_sess;
1398                 nacl->qla_tgt_sess = qla_tgt_sess;
1399                 return;
1400         }
1401
1402         if (new_se_nacl == NULL) {
1403                 pr_debug("Clearing existing fc_port entry\n");
1404                 btree_remove32(&lport->lport_fcport_map, key);
1405                 return;
1406         }
1407
1408         pr_debug("Replacing existing fc_port entry w/o active nacl->qla_tgt_sess\n");
1409         btree_update32(&lport->lport_fcport_map, key, new_se_nacl);
1410         qla_tgt_sess->se_sess = se_sess;
1411         nacl->qla_tgt_sess = qla_tgt_sess;
1412
1413         pr_debug("Setup nacl->qla_tgt_sess %p by s_id for se_nacl: %p, initiatorname: %s\n",
1414             nacl->qla_tgt_sess, new_se_nacl, new_se_nacl->initiatorname);
1415 }
1416
1417 /*
1418  * Expected to be called with struct qla_hw_data->hardware_lock held
1419  */
1420 static struct qla_tgt_sess *tcm_qla2xxx_find_sess_by_loop_id(
1421         scsi_qla_host_t *vha,
1422         const uint16_t loop_id)
1423 {
1424         struct tcm_qla2xxx_lport *lport;
1425         struct se_node_acl *se_nacl;
1426         struct tcm_qla2xxx_nacl *nacl;
1427         struct tcm_qla2xxx_fc_loopid *fc_loopid;
1428
1429         lport = vha->vha_tgt.target_lport_ptr;
1430         if (!lport) {
1431                 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1432                 dump_stack();
1433                 return NULL;
1434         }
1435
1436         pr_debug("find_sess_by_loop_id: Using loop_id: 0x%04x\n", loop_id);
1437
1438         fc_loopid = lport->lport_loopid_map + loop_id;
1439         se_nacl = fc_loopid->se_nacl;
1440         if (!se_nacl) {
1441                 pr_debug("Unable to locate se_nacl by loop_id: 0x%04x\n",
1442                     loop_id);
1443                 return NULL;
1444         }
1445
1446         nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1447
1448         if (!nacl->qla_tgt_sess) {
1449                 pr_err("Unable to locate struct qla_tgt_sess\n");
1450                 return NULL;
1451         }
1452
1453         return nacl->qla_tgt_sess;
1454 }
1455
1456 /*
1457  * Expected to be called with struct qla_hw_data->hardware_lock held
1458  */
1459 static void tcm_qla2xxx_set_sess_by_loop_id(
1460         struct tcm_qla2xxx_lport *lport,
1461         struct se_node_acl *new_se_nacl,
1462         struct tcm_qla2xxx_nacl *nacl,
1463         struct se_session *se_sess,
1464         struct qla_tgt_sess *qla_tgt_sess,
1465         uint16_t loop_id)
1466 {
1467         struct se_node_acl *saved_nacl;
1468         struct tcm_qla2xxx_fc_loopid *fc_loopid;
1469
1470         pr_debug("set_sess_by_loop_id: Using loop_id: 0x%04x\n", loop_id);
1471
1472         fc_loopid = &((struct tcm_qla2xxx_fc_loopid *)
1473                         lport->lport_loopid_map)[loop_id];
1474
1475         saved_nacl = fc_loopid->se_nacl;
1476         if (!saved_nacl) {
1477                 pr_debug("Setting up new fc_loopid->se_nacl to new_se_nacl\n");
1478                 fc_loopid->se_nacl = new_se_nacl;
1479                 if (qla_tgt_sess->se_sess != se_sess)
1480                         qla_tgt_sess->se_sess = se_sess;
1481                 if (nacl->qla_tgt_sess != qla_tgt_sess)
1482                         nacl->qla_tgt_sess = qla_tgt_sess;
1483                 return;
1484         }
1485
1486         if (nacl->qla_tgt_sess) {
1487                 if (new_se_nacl == NULL) {
1488                         pr_debug("Clearing nacl->qla_tgt_sess and fc_loopid->se_nacl\n");
1489                         fc_loopid->se_nacl = NULL;
1490                         nacl->qla_tgt_sess = NULL;
1491                         return;
1492                 }
1493
1494                 pr_debug("Replacing existing nacl->qla_tgt_sess and fc_loopid->se_nacl\n");
1495                 fc_loopid->se_nacl = new_se_nacl;
1496                 if (qla_tgt_sess->se_sess != se_sess)
1497                         qla_tgt_sess->se_sess = se_sess;
1498                 if (nacl->qla_tgt_sess != qla_tgt_sess)
1499                         nacl->qla_tgt_sess = qla_tgt_sess;
1500                 return;
1501         }
1502
1503         if (new_se_nacl == NULL) {
1504                 pr_debug("Clearing fc_loopid->se_nacl\n");
1505                 fc_loopid->se_nacl = NULL;
1506                 return;
1507         }
1508
1509         pr_debug("Replacing existing fc_loopid->se_nacl w/o active nacl->qla_tgt_sess\n");
1510         fc_loopid->se_nacl = new_se_nacl;
1511         if (qla_tgt_sess->se_sess != se_sess)
1512                 qla_tgt_sess->se_sess = se_sess;
1513         if (nacl->qla_tgt_sess != qla_tgt_sess)
1514                 nacl->qla_tgt_sess = qla_tgt_sess;
1515
1516         pr_debug("Setup nacl->qla_tgt_sess %p by loop_id for se_nacl: %p, initiatorname: %s\n",
1517             nacl->qla_tgt_sess, new_se_nacl, new_se_nacl->initiatorname);
1518 }
1519
1520 /*
1521  * Should always be called with qla_hw_data->hardware_lock held.
1522  */
1523 static void tcm_qla2xxx_clear_sess_lookup(struct tcm_qla2xxx_lport *lport,
1524                 struct tcm_qla2xxx_nacl *nacl, struct qla_tgt_sess *sess)
1525 {
1526         struct se_session *se_sess = sess->se_sess;
1527         unsigned char be_sid[3];
1528
1529         be_sid[0] = sess->s_id.b.domain;
1530         be_sid[1] = sess->s_id.b.area;
1531         be_sid[2] = sess->s_id.b.al_pa;
1532
1533         tcm_qla2xxx_set_sess_by_s_id(lport, NULL, nacl, se_sess,
1534                                 sess, be_sid);
1535         tcm_qla2xxx_set_sess_by_loop_id(lport, NULL, nacl, se_sess,
1536                                 sess, sess->loop_id);
1537 }
1538
1539 static void tcm_qla2xxx_free_session(struct qla_tgt_sess *sess)
1540 {
1541         struct qla_tgt *tgt = sess->tgt;
1542         struct qla_hw_data *ha = tgt->ha;
1543         scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
1544         struct se_session *se_sess;
1545         struct se_node_acl *se_nacl;
1546         struct tcm_qla2xxx_lport *lport;
1547         struct tcm_qla2xxx_nacl *nacl;
1548
1549         BUG_ON(in_interrupt());
1550
1551         se_sess = sess->se_sess;
1552         if (!se_sess) {
1553                 pr_err("struct qla_tgt_sess->se_sess is NULL\n");
1554                 dump_stack();
1555                 return;
1556         }
1557         se_nacl = se_sess->se_node_acl;
1558         nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1559
1560         lport = vha->vha_tgt.target_lport_ptr;
1561         if (!lport) {
1562                 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1563                 dump_stack();
1564                 return;
1565         }
1566         target_wait_for_sess_cmds(se_sess);
1567
1568         transport_deregister_session_configfs(sess->se_sess);
1569         transport_deregister_session(sess->se_sess);
1570 }
1571
1572 /*
1573  * Called via qlt_create_sess():ha->qla2x_tmpl->check_initiator_node_acl()
1574  * to locate struct se_node_acl
1575  */
1576 static int tcm_qla2xxx_check_initiator_node_acl(
1577         scsi_qla_host_t *vha,
1578         unsigned char *fc_wwpn,
1579         void *qla_tgt_sess,
1580         uint8_t *s_id,
1581         uint16_t loop_id)
1582 {
1583         struct qla_hw_data *ha = vha->hw;
1584         struct tcm_qla2xxx_lport *lport;
1585         struct tcm_qla2xxx_tpg *tpg;
1586         struct tcm_qla2xxx_nacl *nacl;
1587         struct se_portal_group *se_tpg;
1588         struct se_node_acl *se_nacl;
1589         struct se_session *se_sess;
1590         struct qla_tgt_sess *sess = qla_tgt_sess;
1591         unsigned char port_name[36];
1592         unsigned long flags;
1593         int num_tags = (ha->fw_xcb_count) ? ha->fw_xcb_count :
1594                        TCM_QLA2XXX_DEFAULT_TAGS;
1595
1596         lport = vha->vha_tgt.target_lport_ptr;
1597         if (!lport) {
1598                 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1599                 dump_stack();
1600                 return -EINVAL;
1601         }
1602         /*
1603          * Locate the TPG=1 reference..
1604          */
1605         tpg = lport->tpg_1;
1606         if (!tpg) {
1607                 pr_err("Unable to lcoate struct tcm_qla2xxx_lport->tpg_1\n");
1608                 return -EINVAL;
1609         }
1610         se_tpg = &tpg->se_tpg;
1611
1612         se_sess = transport_init_session_tags(num_tags,
1613                                               sizeof(struct qla_tgt_cmd),
1614                                               TARGET_PROT_ALL);
1615         if (IS_ERR(se_sess)) {
1616                 pr_err("Unable to initialize struct se_session\n");
1617                 return PTR_ERR(se_sess);
1618         }
1619         /*
1620          * Format the FCP Initiator port_name into colon seperated values to
1621          * match the format by tcm_qla2xxx explict ConfigFS NodeACLs.
1622          */
1623         memset(&port_name, 0, 36);
1624         snprintf(port_name, sizeof(port_name), "%8phC", fc_wwpn);
1625         /*
1626          * Locate our struct se_node_acl either from an explict NodeACL created
1627          * via ConfigFS, or via running in TPG demo mode.
1628          */
1629         se_sess->se_node_acl = core_tpg_check_initiator_node_acl(se_tpg,
1630                                         port_name);
1631         if (!se_sess->se_node_acl) {
1632                 transport_free_session(se_sess);
1633                 return -EINVAL;
1634         }
1635         se_nacl = se_sess->se_node_acl;
1636         nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1637         /*
1638          * And now setup the new se_nacl and session pointers into our HW lport
1639          * mappings for fabric S_ID and LOOP_ID.
1640          */
1641         spin_lock_irqsave(&ha->hardware_lock, flags);
1642         tcm_qla2xxx_set_sess_by_s_id(lport, se_nacl, nacl, se_sess,
1643                         qla_tgt_sess, s_id);
1644         tcm_qla2xxx_set_sess_by_loop_id(lport, se_nacl, nacl, se_sess,
1645                         qla_tgt_sess, loop_id);
1646         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1647         /*
1648          * Finally register the new FC Nexus with TCM
1649          */
1650         transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
1651
1652         return 0;
1653 }
1654
1655 static void tcm_qla2xxx_update_sess(struct qla_tgt_sess *sess, port_id_t s_id,
1656                                     uint16_t loop_id, bool conf_compl_supported)
1657 {
1658         struct qla_tgt *tgt = sess->tgt;
1659         struct qla_hw_data *ha = tgt->ha;
1660         scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
1661         struct tcm_qla2xxx_lport *lport = vha->vha_tgt.target_lport_ptr;
1662         struct se_node_acl *se_nacl = sess->se_sess->se_node_acl;
1663         struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
1664                         struct tcm_qla2xxx_nacl, se_node_acl);
1665         u32 key;
1666
1667
1668         if (sess->loop_id != loop_id || sess->s_id.b24 != s_id.b24)
1669                 pr_info("Updating session %p from port %8phC loop_id %d -> %d s_id %x:%x:%x -> %x:%x:%x\n",
1670                     sess, sess->port_name,
1671                     sess->loop_id, loop_id, sess->s_id.b.domain,
1672                     sess->s_id.b.area, sess->s_id.b.al_pa, s_id.b.domain,
1673                     s_id.b.area, s_id.b.al_pa);
1674
1675         if (sess->loop_id != loop_id) {
1676                 /*
1677                  * Because we can shuffle loop IDs around and we
1678                  * update different sessions non-atomically, we might
1679                  * have overwritten this session's old loop ID
1680                  * already, and we might end up overwriting some other
1681                  * session that will be updated later.  So we have to
1682                  * be extra careful and we can't warn about those things...
1683                  */
1684                 if (lport->lport_loopid_map[sess->loop_id].se_nacl == se_nacl)
1685                         lport->lport_loopid_map[sess->loop_id].se_nacl = NULL;
1686
1687                 lport->lport_loopid_map[loop_id].se_nacl = se_nacl;
1688
1689                 sess->loop_id = loop_id;
1690         }
1691
1692         if (sess->s_id.b24 != s_id.b24) {
1693                 key = (((u32) sess->s_id.b.domain << 16) |
1694                        ((u32) sess->s_id.b.area   <<  8) |
1695                        ((u32) sess->s_id.b.al_pa));
1696
1697                 if (btree_lookup32(&lport->lport_fcport_map, key))
1698                         WARN(btree_remove32(&lport->lport_fcport_map, key) != se_nacl,
1699                              "Found wrong se_nacl when updating s_id %x:%x:%x\n",
1700                              sess->s_id.b.domain, sess->s_id.b.area, sess->s_id.b.al_pa);
1701                 else
1702                         WARN(1, "No lport_fcport_map entry for s_id %x:%x:%x\n",
1703                              sess->s_id.b.domain, sess->s_id.b.area, sess->s_id.b.al_pa);
1704
1705                 key = (((u32) s_id.b.domain << 16) |
1706                        ((u32) s_id.b.area   <<  8) |
1707                        ((u32) s_id.b.al_pa));
1708
1709                 if (btree_lookup32(&lport->lport_fcport_map, key)) {
1710                         WARN(1, "Already have lport_fcport_map entry for s_id %x:%x:%x\n",
1711                              s_id.b.domain, s_id.b.area, s_id.b.al_pa);
1712                         btree_update32(&lport->lport_fcport_map, key, se_nacl);
1713                 } else {
1714                         btree_insert32(&lport->lport_fcport_map, key, se_nacl, GFP_ATOMIC);
1715                 }
1716
1717                 sess->s_id = s_id;
1718                 nacl->nport_id = key;
1719         }
1720
1721         sess->conf_compl_supported = conf_compl_supported;
1722 }
1723
1724 /*
1725  * Calls into tcm_qla2xxx used by qla2xxx LLD I/O path.
1726  */
1727 static struct qla_tgt_func_tmpl tcm_qla2xxx_template = {
1728         .handle_cmd             = tcm_qla2xxx_handle_cmd,
1729         .handle_data            = tcm_qla2xxx_handle_data,
1730         .handle_dif_err         = tcm_qla2xxx_handle_dif_err,
1731         .handle_tmr             = tcm_qla2xxx_handle_tmr,
1732         .free_cmd               = tcm_qla2xxx_free_cmd,
1733         .free_mcmd              = tcm_qla2xxx_free_mcmd,
1734         .free_session           = tcm_qla2xxx_free_session,
1735         .update_sess            = tcm_qla2xxx_update_sess,
1736         .check_initiator_node_acl = tcm_qla2xxx_check_initiator_node_acl,
1737         .find_sess_by_s_id      = tcm_qla2xxx_find_sess_by_s_id,
1738         .find_sess_by_loop_id   = tcm_qla2xxx_find_sess_by_loop_id,
1739         .clear_nacl_from_fcport_map = tcm_qla2xxx_clear_nacl_from_fcport_map,
1740         .put_sess               = tcm_qla2xxx_put_sess,
1741         .shutdown_sess          = tcm_qla2xxx_shutdown_sess,
1742 };
1743
1744 static int tcm_qla2xxx_init_lport(struct tcm_qla2xxx_lport *lport)
1745 {
1746         int rc;
1747
1748         rc = btree_init32(&lport->lport_fcport_map);
1749         if (rc) {
1750                 pr_err("Unable to initialize lport->lport_fcport_map btree\n");
1751                 return rc;
1752         }
1753
1754         lport->lport_loopid_map = vmalloc(sizeof(struct tcm_qla2xxx_fc_loopid) *
1755                                 65536);
1756         if (!lport->lport_loopid_map) {
1757                 pr_err("Unable to allocate lport->lport_loopid_map of %zu bytes\n",
1758                     sizeof(struct tcm_qla2xxx_fc_loopid) * 65536);
1759                 btree_destroy32(&lport->lport_fcport_map);
1760                 return -ENOMEM;
1761         }
1762         memset(lport->lport_loopid_map, 0, sizeof(struct tcm_qla2xxx_fc_loopid)
1763                * 65536);
1764         pr_debug("qla2xxx: Allocated lport_loopid_map of %zu bytes\n",
1765                sizeof(struct tcm_qla2xxx_fc_loopid) * 65536);
1766         return 0;
1767 }
1768
1769 static int tcm_qla2xxx_lport_register_cb(struct scsi_qla_host *vha,
1770                                          void *target_lport_ptr,
1771                                          u64 npiv_wwpn, u64 npiv_wwnn)
1772 {
1773         struct qla_hw_data *ha = vha->hw;
1774         struct tcm_qla2xxx_lport *lport =
1775                         (struct tcm_qla2xxx_lport *)target_lport_ptr;
1776         /*
1777          * Setup tgt_ops, local pointer to vha and target_lport_ptr
1778          */
1779         ha->tgt.tgt_ops = &tcm_qla2xxx_template;
1780         vha->vha_tgt.target_lport_ptr = target_lport_ptr;
1781         lport->qla_vha = vha;
1782
1783         return 0;
1784 }
1785
1786 static struct se_wwn *tcm_qla2xxx_make_lport(
1787         struct target_fabric_configfs *tf,
1788         struct config_group *group,
1789         const char *name)
1790 {
1791         struct tcm_qla2xxx_lport *lport;
1792         u64 wwpn;
1793         int ret = -ENODEV;
1794
1795         if (tcm_qla2xxx_parse_wwn(name, &wwpn, 1) < 0)
1796                 return ERR_PTR(-EINVAL);
1797
1798         lport = kzalloc(sizeof(struct tcm_qla2xxx_lport), GFP_KERNEL);
1799         if (!lport) {
1800                 pr_err("Unable to allocate struct tcm_qla2xxx_lport\n");
1801                 return ERR_PTR(-ENOMEM);
1802         }
1803         lport->lport_wwpn = wwpn;
1804         tcm_qla2xxx_format_wwn(&lport->lport_name[0], TCM_QLA2XXX_NAMELEN,
1805                                 wwpn);
1806         sprintf(lport->lport_naa_name, "naa.%016llx", (unsigned long long) wwpn);
1807
1808         ret = tcm_qla2xxx_init_lport(lport);
1809         if (ret != 0)
1810                 goto out;
1811
1812         ret = qlt_lport_register(lport, wwpn, 0, 0,
1813                                  tcm_qla2xxx_lport_register_cb);
1814         if (ret != 0)
1815                 goto out_lport;
1816
1817         return &lport->lport_wwn;
1818 out_lport:
1819         vfree(lport->lport_loopid_map);
1820         btree_destroy32(&lport->lport_fcport_map);
1821 out:
1822         kfree(lport);
1823         return ERR_PTR(ret);
1824 }
1825
1826 static void tcm_qla2xxx_drop_lport(struct se_wwn *wwn)
1827 {
1828         struct tcm_qla2xxx_lport *lport = container_of(wwn,
1829                         struct tcm_qla2xxx_lport, lport_wwn);
1830         struct scsi_qla_host *vha = lport->qla_vha;
1831         struct se_node_acl *node;
1832         u32 key = 0;
1833
1834         /*
1835          * Call into qla2x_target.c LLD logic to complete the
1836          * shutdown of struct qla_tgt after the call to
1837          * qlt_stop_phase1() from tcm_qla2xxx_drop_tpg() above..
1838          */
1839         if (vha->vha_tgt.qla_tgt && !vha->vha_tgt.qla_tgt->tgt_stopped)
1840                 qlt_stop_phase2(vha->vha_tgt.qla_tgt);
1841
1842         qlt_lport_deregister(vha);
1843
1844         vfree(lport->lport_loopid_map);
1845         btree_for_each_safe32(&lport->lport_fcport_map, key, node)
1846                 btree_remove32(&lport->lport_fcport_map, key);
1847         btree_destroy32(&lport->lport_fcport_map);
1848         kfree(lport);
1849 }
1850
1851 static int tcm_qla2xxx_lport_register_npiv_cb(struct scsi_qla_host *base_vha,
1852                                               void *target_lport_ptr,
1853                                               u64 npiv_wwpn, u64 npiv_wwnn)
1854 {
1855         struct fc_vport *vport;
1856         struct Scsi_Host *sh = base_vha->host;
1857         struct scsi_qla_host *npiv_vha;
1858         struct tcm_qla2xxx_lport *lport =
1859                         (struct tcm_qla2xxx_lport *)target_lport_ptr;
1860         struct tcm_qla2xxx_lport *base_lport =
1861                         (struct tcm_qla2xxx_lport *)base_vha->vha_tgt.target_lport_ptr;
1862         struct tcm_qla2xxx_tpg *base_tpg;
1863         struct fc_vport_identifiers vport_id;
1864
1865         if (!qla_tgt_mode_enabled(base_vha)) {
1866                 pr_err("qla2xxx base_vha not enabled for target mode\n");
1867                 return -EPERM;
1868         }
1869
1870         if (!base_lport || !base_lport->tpg_1 ||
1871             !atomic_read(&base_lport->tpg_1->lport_tpg_enabled)) {
1872                 pr_err("qla2xxx base_lport or tpg_1 not available\n");
1873                 return -EPERM;
1874         }
1875         base_tpg = base_lport->tpg_1;
1876
1877         memset(&vport_id, 0, sizeof(vport_id));
1878         vport_id.port_name = npiv_wwpn;
1879         vport_id.node_name = npiv_wwnn;
1880         vport_id.roles = FC_PORT_ROLE_FCP_INITIATOR;
1881         vport_id.vport_type = FC_PORTTYPE_NPIV;
1882         vport_id.disable = false;
1883
1884         vport = fc_vport_create(sh, 0, &vport_id);
1885         if (!vport) {
1886                 pr_err("fc_vport_create failed for qla2xxx_npiv\n");
1887                 return -ENODEV;
1888         }
1889         /*
1890          * Setup local pointer to NPIV vhba + target_lport_ptr
1891          */
1892         npiv_vha = (struct scsi_qla_host *)vport->dd_data;
1893         npiv_vha->vha_tgt.target_lport_ptr = target_lport_ptr;
1894         lport->qla_vha = npiv_vha;
1895         scsi_host_get(npiv_vha->host);
1896         return 0;
1897 }
1898
1899
1900 static struct se_wwn *tcm_qla2xxx_npiv_make_lport(
1901         struct target_fabric_configfs *tf,
1902         struct config_group *group,
1903         const char *name)
1904 {
1905         struct tcm_qla2xxx_lport *lport;
1906         u64 phys_wwpn, npiv_wwpn, npiv_wwnn;
1907         char *p, tmp[128];
1908         int ret;
1909
1910         snprintf(tmp, 128, "%s", name);
1911
1912         p = strchr(tmp, '@');
1913         if (!p) {
1914                 pr_err("Unable to locate NPIV '@' seperator\n");
1915                 return ERR_PTR(-EINVAL);
1916         }
1917         *p++ = '\0';
1918
1919         if (tcm_qla2xxx_parse_wwn(tmp, &phys_wwpn, 1) < 0)
1920                 return ERR_PTR(-EINVAL);
1921
1922         if (tcm_qla2xxx_npiv_parse_wwn(p, strlen(p)+1,
1923                                        &npiv_wwpn, &npiv_wwnn) < 0)
1924                 return ERR_PTR(-EINVAL);
1925
1926         lport = kzalloc(sizeof(struct tcm_qla2xxx_lport), GFP_KERNEL);
1927         if (!lport) {
1928                 pr_err("Unable to allocate struct tcm_qla2xxx_lport for NPIV\n");
1929                 return ERR_PTR(-ENOMEM);
1930         }
1931         lport->lport_npiv_wwpn = npiv_wwpn;
1932         lport->lport_npiv_wwnn = npiv_wwnn;
1933         sprintf(lport->lport_naa_name, "naa.%016llx", (unsigned long long) npiv_wwpn);
1934
1935         ret = tcm_qla2xxx_init_lport(lport);
1936         if (ret != 0)
1937                 goto out;
1938
1939         ret = qlt_lport_register(lport, phys_wwpn, npiv_wwpn, npiv_wwnn,
1940                                  tcm_qla2xxx_lport_register_npiv_cb);
1941         if (ret != 0)
1942                 goto out_lport;
1943
1944         return &lport->lport_wwn;
1945 out_lport:
1946         vfree(lport->lport_loopid_map);
1947         btree_destroy32(&lport->lport_fcport_map);
1948 out:
1949         kfree(lport);
1950         return ERR_PTR(ret);
1951 }
1952
1953 static void tcm_qla2xxx_npiv_drop_lport(struct se_wwn *wwn)
1954 {
1955         struct tcm_qla2xxx_lport *lport = container_of(wwn,
1956                         struct tcm_qla2xxx_lport, lport_wwn);
1957         struct scsi_qla_host *npiv_vha = lport->qla_vha;
1958         struct qla_hw_data *ha = npiv_vha->hw;
1959         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
1960
1961         scsi_host_put(npiv_vha->host);
1962         /*
1963          * Notify libfc that we want to release the vha->fc_vport
1964          */
1965         fc_vport_terminate(npiv_vha->fc_vport);
1966         scsi_host_put(base_vha->host);
1967         kfree(lport);
1968 }
1969
1970
1971 static ssize_t tcm_qla2xxx_wwn_show_attr_version(
1972         struct target_fabric_configfs *tf,
1973         char *page)
1974 {
1975         return sprintf(page,
1976             "TCM QLOGIC QLA2XXX NPIV capable fabric module %s on %s/%s on "
1977             UTS_RELEASE"\n", TCM_QLA2XXX_VERSION, utsname()->sysname,
1978             utsname()->machine);
1979 }
1980
1981 TF_WWN_ATTR_RO(tcm_qla2xxx, version);
1982
1983 static struct configfs_attribute *tcm_qla2xxx_wwn_attrs[] = {
1984         &tcm_qla2xxx_wwn_version.attr,
1985         NULL,
1986 };
1987
1988 static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
1989         .module                         = THIS_MODULE,
1990         .name                           = "qla2xxx",
1991         .get_fabric_name                = tcm_qla2xxx_get_fabric_name,
1992         .get_fabric_proto_ident         = tcm_qla2xxx_get_fabric_proto_ident,
1993         .tpg_get_wwn                    = tcm_qla2xxx_get_fabric_wwn,
1994         .tpg_get_tag                    = tcm_qla2xxx_get_tag,
1995         .tpg_get_default_depth          = tcm_qla2xxx_get_default_depth,
1996         .tpg_get_pr_transport_id        = tcm_qla2xxx_get_pr_transport_id,
1997         .tpg_get_pr_transport_id_len    = tcm_qla2xxx_get_pr_transport_id_len,
1998         .tpg_parse_pr_out_transport_id  = tcm_qla2xxx_parse_pr_out_transport_id,
1999         .tpg_check_demo_mode            = tcm_qla2xxx_check_demo_mode,
2000         .tpg_check_demo_mode_cache      = tcm_qla2xxx_check_demo_mode_cache,
2001         .tpg_check_demo_mode_write_protect =
2002                                         tcm_qla2xxx_check_demo_write_protect,
2003         .tpg_check_prod_mode_write_protect =
2004                                         tcm_qla2xxx_check_prod_write_protect,
2005         .tpg_check_prot_fabric_only     = tcm_qla2xxx_check_prot_fabric_only,
2006         .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
2007         .tpg_alloc_fabric_acl           = tcm_qla2xxx_alloc_fabric_acl,
2008         .tpg_release_fabric_acl         = tcm_qla2xxx_release_fabric_acl,
2009         .tpg_get_inst_index             = tcm_qla2xxx_tpg_get_inst_index,
2010         .check_stop_free                = tcm_qla2xxx_check_stop_free,
2011         .release_cmd                    = tcm_qla2xxx_release_cmd,
2012         .put_session                    = tcm_qla2xxx_put_session,
2013         .shutdown_session               = tcm_qla2xxx_shutdown_session,
2014         .close_session                  = tcm_qla2xxx_close_session,
2015         .sess_get_index                 = tcm_qla2xxx_sess_get_index,
2016         .sess_get_initiator_sid         = NULL,
2017         .write_pending                  = tcm_qla2xxx_write_pending,
2018         .write_pending_status           = tcm_qla2xxx_write_pending_status,
2019         .set_default_node_attributes    = tcm_qla2xxx_set_default_node_attrs,
2020         .get_task_tag                   = tcm_qla2xxx_get_task_tag,
2021         .get_cmd_state                  = tcm_qla2xxx_get_cmd_state,
2022         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
2023         .queue_status                   = tcm_qla2xxx_queue_status,
2024         .queue_tm_rsp                   = tcm_qla2xxx_queue_tm_rsp,
2025         .aborted_task                   = tcm_qla2xxx_aborted_task,
2026         /*
2027          * Setup function pointers for generic logic in
2028          * target_core_fabric_configfs.c
2029          */
2030         .fabric_make_wwn                = tcm_qla2xxx_make_lport,
2031         .fabric_drop_wwn                = tcm_qla2xxx_drop_lport,
2032         .fabric_make_tpg                = tcm_qla2xxx_make_tpg,
2033         .fabric_drop_tpg                = tcm_qla2xxx_drop_tpg,
2034         .fabric_post_link               = NULL,
2035         .fabric_pre_unlink              = NULL,
2036         .fabric_make_np                 = NULL,
2037         .fabric_drop_np                 = NULL,
2038         .fabric_make_nodeacl            = tcm_qla2xxx_make_nodeacl,
2039         .fabric_drop_nodeacl            = tcm_qla2xxx_drop_nodeacl,
2040
2041         .tfc_wwn_attrs                  = tcm_qla2xxx_wwn_attrs,
2042         .tfc_tpg_base_attrs             = tcm_qla2xxx_tpg_attrs,
2043         .tfc_tpg_attrib_attrs           = tcm_qla2xxx_tpg_attrib_attrs,
2044 };
2045
2046 static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
2047         .module                         = THIS_MODULE,
2048         .name                           = "qla2xxx_npiv",
2049         .get_fabric_name                = tcm_qla2xxx_npiv_get_fabric_name,
2050         .get_fabric_proto_ident         = tcm_qla2xxx_get_fabric_proto_ident,
2051         .tpg_get_wwn                    = tcm_qla2xxx_get_fabric_wwn,
2052         .tpg_get_tag                    = tcm_qla2xxx_get_tag,
2053         .tpg_get_default_depth          = tcm_qla2xxx_get_default_depth,
2054         .tpg_get_pr_transport_id        = tcm_qla2xxx_get_pr_transport_id,
2055         .tpg_get_pr_transport_id_len    = tcm_qla2xxx_get_pr_transport_id_len,
2056         .tpg_parse_pr_out_transport_id  = tcm_qla2xxx_parse_pr_out_transport_id,
2057         .tpg_check_demo_mode            = tcm_qla2xxx_check_demo_mode,
2058         .tpg_check_demo_mode_cache      = tcm_qla2xxx_check_demo_mode_cache,
2059         .tpg_check_demo_mode_write_protect = tcm_qla2xxx_check_demo_mode,
2060         .tpg_check_prod_mode_write_protect =
2061             tcm_qla2xxx_check_prod_write_protect,
2062         .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
2063         .tpg_alloc_fabric_acl           = tcm_qla2xxx_alloc_fabric_acl,
2064         .tpg_release_fabric_acl         = tcm_qla2xxx_release_fabric_acl,
2065         .tpg_get_inst_index             = tcm_qla2xxx_tpg_get_inst_index,
2066         .check_stop_free                = tcm_qla2xxx_check_stop_free,
2067         .release_cmd                    = tcm_qla2xxx_release_cmd,
2068         .put_session                    = tcm_qla2xxx_put_session,
2069         .shutdown_session               = tcm_qla2xxx_shutdown_session,
2070         .close_session                  = tcm_qla2xxx_close_session,
2071         .sess_get_index                 = tcm_qla2xxx_sess_get_index,
2072         .sess_get_initiator_sid         = NULL,
2073         .write_pending                  = tcm_qla2xxx_write_pending,
2074         .write_pending_status           = tcm_qla2xxx_write_pending_status,
2075         .set_default_node_attributes    = tcm_qla2xxx_set_default_node_attrs,
2076         .get_task_tag                   = tcm_qla2xxx_get_task_tag,
2077         .get_cmd_state                  = tcm_qla2xxx_get_cmd_state,
2078         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
2079         .queue_status                   = tcm_qla2xxx_queue_status,
2080         .queue_tm_rsp                   = tcm_qla2xxx_queue_tm_rsp,
2081         .aborted_task                   = tcm_qla2xxx_aborted_task,
2082         /*
2083          * Setup function pointers for generic logic in
2084          * target_core_fabric_configfs.c
2085          */
2086         .fabric_make_wwn                = tcm_qla2xxx_npiv_make_lport,
2087         .fabric_drop_wwn                = tcm_qla2xxx_npiv_drop_lport,
2088         .fabric_make_tpg                = tcm_qla2xxx_npiv_make_tpg,
2089         .fabric_drop_tpg                = tcm_qla2xxx_drop_tpg,
2090         .fabric_post_link               = NULL,
2091         .fabric_pre_unlink              = NULL,
2092         .fabric_make_np                 = NULL,
2093         .fabric_drop_np                 = NULL,
2094         .fabric_make_nodeacl            = tcm_qla2xxx_make_nodeacl,
2095         .fabric_drop_nodeacl            = tcm_qla2xxx_drop_nodeacl,
2096
2097         .tfc_wwn_attrs                  = tcm_qla2xxx_wwn_attrs,
2098         .tfc_tpg_base_attrs             = tcm_qla2xxx_npiv_tpg_attrs,
2099 };
2100
2101 static int tcm_qla2xxx_register_configfs(void)
2102 {
2103         int ret;
2104
2105         pr_debug("TCM QLOGIC QLA2XXX fabric module %s on %s/%s on "
2106             UTS_RELEASE"\n", TCM_QLA2XXX_VERSION, utsname()->sysname,
2107             utsname()->machine);
2108
2109         ret = target_register_template(&tcm_qla2xxx_ops);
2110         if (ret)
2111                 return ret;
2112
2113         ret = target_register_template(&tcm_qla2xxx_npiv_ops);
2114         if (ret)
2115                 goto out_fabric;
2116
2117         tcm_qla2xxx_free_wq = alloc_workqueue("tcm_qla2xxx_free",
2118                                                 WQ_MEM_RECLAIM, 0);
2119         if (!tcm_qla2xxx_free_wq) {
2120                 ret = -ENOMEM;
2121                 goto out_fabric_npiv;
2122         }
2123
2124         tcm_qla2xxx_cmd_wq = alloc_workqueue("tcm_qla2xxx_cmd", 0, 0);
2125         if (!tcm_qla2xxx_cmd_wq) {
2126                 ret = -ENOMEM;
2127                 goto out_free_wq;
2128         }
2129
2130         return 0;
2131
2132 out_free_wq:
2133         destroy_workqueue(tcm_qla2xxx_free_wq);
2134 out_fabric_npiv:
2135         target_unregister_template(&tcm_qla2xxx_npiv_ops);
2136 out_fabric:
2137         target_unregister_template(&tcm_qla2xxx_ops);
2138         return ret;
2139 }
2140
2141 static void tcm_qla2xxx_deregister_configfs(void)
2142 {
2143         destroy_workqueue(tcm_qla2xxx_cmd_wq);
2144         destroy_workqueue(tcm_qla2xxx_free_wq);
2145
2146         target_unregister_template(&tcm_qla2xxx_ops);
2147         target_unregister_template(&tcm_qla2xxx_npiv_ops);
2148 }
2149
2150 static int __init tcm_qla2xxx_init(void)
2151 {
2152         int ret;
2153
2154         ret = tcm_qla2xxx_register_configfs();
2155         if (ret < 0)
2156                 return ret;
2157
2158         return 0;
2159 }
2160
2161 static void __exit tcm_qla2xxx_exit(void)
2162 {
2163         tcm_qla2xxx_deregister_configfs();
2164 }
2165
2166 MODULE_DESCRIPTION("TCM QLA2XXX series NPIV enabled fabric driver");
2167 MODULE_LICENSE("GPL");
2168 module_init(tcm_qla2xxx_init);
2169 module_exit(tcm_qla2xxx_exit);