drivers/target/target_core_tmr.c

   1 /*******************************************************************************
   2  * Filename:  target_core_tmr.c
   3  *
   4  * This file contains SPC-3 task management infrastructure
   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/list.h>
  29 #include <linux/export.h>
  30
  31 #include <target/target_core_base.h>
  32 #include <target/target_core_backend.h>
  33 #include <target/target_core_fabric.h>
  34
  35 #include "target_core_internal.h"
  36 #include "target_core_alua.h"
  37 #include "target_core_pr.h"
  38
  39 int core_tmr_alloc_req(
  40         struct se_cmd *se_cmd,
  41         void *fabric_tmr_ptr,
  42         u8 function,
  43         gfp_t gfp_flags)
  44 {
  45         struct se_tmr_req *tmr;
  46
  47         tmr = kzalloc(sizeof(struct se_tmr_req), gfp_flags);
  48         if (!tmr) {
  49                 pr_err("Unable to allocate struct se_tmr_req\n");
  50                 return -ENOMEM;
  51         }
  52
  53         se_cmd->se_cmd_flags |= SCF_SCSI_TMR_CDB;
  54         se_cmd->se_tmr_req = tmr;
  55         tmr->task_cmd = se_cmd;
  56         tmr->fabric_tmr_ptr = fabric_tmr_ptr;
  57         tmr->function = function;
  58         INIT_LIST_HEAD(&tmr->tmr_list);
  59
  60         return 0;
  61 }
  62 EXPORT_SYMBOL(core_tmr_alloc_req);
  63
  64 void core_tmr_release_req(struct se_tmr_req *tmr)
  65 {
  66         struct se_device *dev = tmr->tmr_dev;
  67         unsigned long flags;
  68
  69         if (dev) {
  70                 spin_lock_irqsave(&dev->se_tmr_lock, flags);
  71                 list_del_init(&tmr->tmr_list);
  72                 spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
  73         }
  74
  75         kfree(tmr);
  76 }
  77
  78 static int target_check_cdb_and_preempt(struct list_head *list,
  79                 struct se_cmd *cmd)
  80 {
  81         struct t10_pr_registration *reg;
  82
  83         if (!list)
  84                 return 0;
  85         list_for_each_entry(reg, list, pr_reg_abort_list) {
  86                 if (reg->pr_res_key == cmd->pr_res_key)
  87                         return 0;
  88         }
  89
  90         return 1;
  91 }
  92
  93 static bool __target_check_io_state(struct se_cmd *se_cmd,
  94                                     struct se_session *tmr_sess, int tas)
  95 {
  96         struct se_session *sess = se_cmd->se_sess;
  97
  98         assert_spin_locked(&sess->sess_cmd_lock);
  99         WARN_ON_ONCE(!irqs_disabled());
 100         /*
 101          * If command already reached CMD_T_COMPLETE state within
 102          * target_complete_cmd() or CMD_T_FABRIC_STOP due to shutdown,
 103          * this se_cmd has been passed to fabric driver and will
 104          * not be aborted.
 105          *
 106          * Otherwise, obtain a local se_cmd->cmd_kref now for TMR
 107          * ABORT_TASK + LUN_RESET for CMD_T_ABORTED processing as
 108          * long as se_cmd->cmd_kref is still active unless zero.
 109          */
 110         spin_lock(&se_cmd->t_state_lock);
 111         if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
 112                 pr_debug("Attempted to abort io tag: %llu already complete or"
 113                         " fabric stop, skipping\n", se_cmd->tag);
 114                 spin_unlock(&se_cmd->t_state_lock);
 115                 return false;
 116         }
 117         se_cmd->transport_state |= CMD_T_ABORTED;
 118
 119         if ((tmr_sess != se_cmd->se_sess) && tas)
 120                 se_cmd->transport_state |= CMD_T_TAS;
 121
 122         spin_unlock(&se_cmd->t_state_lock);
 123
 124         return kref_get_unless_zero(&se_cmd->cmd_kref);
 125 }
 126
 127 void core_tmr_abort_task(
 128         struct se_device *dev,
 129         struct se_tmr_req *tmr,
 130         struct se_session *se_sess)
 131 {
 132         struct se_cmd *se_cmd;
 133         unsigned long flags;
 134         u64 ref_tag;
 135
 136         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
 137         list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
 138
 139                 if (dev != se_cmd->se_dev)
 140                         continue;
 141
 142                 /* skip task management functions, including tmr->task_cmd */
 143                 if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
 144                         continue;
 145
 146                 ref_tag = se_cmd->tag;
 147                 if (tmr->ref_task_tag != ref_tag)
 148                         continue;
 149
 150                 printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
 151                         se_cmd->se_tfo->fabric_name, ref_tag);
 152
 153                 if (!__target_check_io_state(se_cmd, se_sess,
 154                                              dev->dev_attrib.emulate_tas))
 155                         continue;
 156
 157                 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
 158
 159                 /*
 160                  * Ensure that this ABORT request is visible to the LU RESET
 161                  * code.
 162                  */
 163                 if (!tmr->tmr_dev)
 164                         WARN_ON_ONCE(transport_lookup_tmr_lun(tmr->task_cmd,
 165                                                 se_cmd->orig_fe_lun) < 0);
 166
 167                 target_put_cmd_and_wait(se_cmd);
 168
 169                 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
 170                                 " ref_tag: %llu\n", ref_tag);
 171                 tmr->response = TMR_FUNCTION_COMPLETE;
 172                 atomic_long_inc(&dev->aborts_complete);
 173                 return;
 174         }
 175         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
 176
 177         printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
 178                         tmr->ref_task_tag);
 179         tmr->response = TMR_TASK_DOES_NOT_EXIST;
 180         atomic_long_inc(&dev->aborts_no_task);
 181 }
 182
 183 static void core_tmr_drain_tmr_list(
 184         struct se_device *dev,
 185         struct se_tmr_req *tmr,
 186         struct list_head *preempt_and_abort_list)
 187 {
 188         LIST_HEAD(drain_tmr_list);
 189         struct se_session *sess;
 190         struct se_tmr_req *tmr_p, *tmr_pp;
 191         struct se_cmd *cmd;
 192         unsigned long flags;
 193         bool rc;
 194         /*
 195          * Release all pending and outgoing TMRs aside from the received
 196          * LUN_RESET tmr..
 197          */
 198         spin_lock_irqsave(&dev->se_tmr_lock, flags);
 199         if (tmr)
 200                 list_del_init(&tmr->tmr_list);
 201         list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) {
 202                 cmd = tmr_p->task_cmd;
 203                 if (!cmd) {
 204                         pr_err("Unable to locate struct se_cmd for TMR\n");
 205                         continue;
 206                 }
 207                 /*
 208                  * If this function was called with a valid pr_res_key
 209                  * parameter (eg: for PROUT PREEMPT_AND_ABORT service action
 210                  * skip non registration key matching TMRs.
 211                  */
 212                 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
 213                         continue;
 214
 215                 sess = cmd->se_sess;
 216                 if (WARN_ON_ONCE(!sess))
 217                         continue;
 218
 219                 spin_lock(&sess->sess_cmd_lock);
 220                 rc = __target_check_io_state(cmd, sess, 0);
 221                 spin_unlock(&sess->sess_cmd_lock);
 222
 223                 if (!rc) {
 224                         printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n");
 225                         continue;
 226                 }
 227
 228                 list_move_tail(&tmr_p->tmr_list, &drain_tmr_list);
 229         }
 230         spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
 231
 232         list_for_each_entry_safe(tmr_p, tmr_pp, &drain_tmr_list, tmr_list) {
 233                 list_del_init(&tmr_p->tmr_list);
 234                 cmd = tmr_p->task_cmd;
 235
 236                 pr_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
 237                         " Response: 0x%02x, t_state: %d\n",
 238                         (preempt_and_abort_list) ? "Preempt" : "", tmr_p,
 239                         tmr_p->function, tmr_p->response, cmd->t_state);
 240
 241                 target_put_cmd_and_wait(cmd);
 242         }
 243 }
 244
 245 /**
 246  * core_tmr_drain_state_list() - abort SCSI commands associated with a device
 247  *
 248  * @dev:       Device for which to abort outstanding SCSI commands.
 249  * @prout_cmd: Pointer to the SCSI PREEMPT AND ABORT if this function is called
 250  *             to realize the PREEMPT AND ABORT functionality.
 251  * @tmr_sess:  Session through which the LUN RESET has been received.
 252  * @tas:       Task Aborted Status (TAS) bit from the SCSI control mode page.
 253  *             A quote from SPC-4, paragraph "7.5.10 Control mode page":
 254  *             "A task aborted status (TAS) bit set to zero specifies that
 255  *             aborted commands shall be terminated by the device server
 256  *             without any response to the application client. A TAS bit set
 257  *             to one specifies that commands aborted by the actions of an I_T
 258  *             nexus other than the I_T nexus on which the command was
 259  *             received shall be completed with TASK ABORTED status."
 260  * @preempt_and_abort_list: For the PREEMPT AND ABORT functionality, a list
 261  *             with registrations that will be preempted.
 262  */
 263 static void core_tmr_drain_state_list(
 264         struct se_device *dev,
 265         struct se_cmd *prout_cmd,
 266         struct se_session *tmr_sess,
 267         int tas,
 268         struct list_head *preempt_and_abort_list)
 269 {
 270         LIST_HEAD(drain_task_list);
 271         struct se_session *sess;
 272         struct se_cmd *cmd, *next;
 273         unsigned long flags;
 274         int rc;
 275
 276         /*
 277          * Complete outstanding commands with TASK_ABORTED SAM status.
 278          *
 279          * This is following sam4r17, section 5.6 Aborting commands, Table 38
 280          * for TMR LUN_RESET:
 281          *
 282          * a) "Yes" indicates that each command that is aborted on an I_T nexus
 283          * other than the one that caused the SCSI device condition is
 284          * completed with TASK ABORTED status, if the TAS bit is set to one in
 285          * the Control mode page (see SPC-4). "No" indicates that no status is
 286          * returned for aborted commands.
 287          *
 288          * d) If the logical unit reset is caused by a particular I_T nexus
 289          * (e.g., by a LOGICAL UNIT RESET task management function), then "yes"
 290          * (TASK_ABORTED status) applies.
 291          *
 292          * Otherwise (e.g., if triggered by a hard reset), "no"
 293          * (no TASK_ABORTED SAM status) applies.
 294          *
 295          * Note that this seems to be independent of TAS (Task Aborted Status)
 296          * in the Control Mode Page.
 297          */
 298         spin_lock_irqsave(&dev->execute_task_lock, flags);
 299         list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
 300                 /*
 301                  * For PREEMPT_AND_ABORT usage, only process commands
 302                  * with a matching reservation key.
 303                  */
 304                 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
 305                         continue;
 306
 307                 /*
 308                  * Not aborting PROUT PREEMPT_AND_ABORT CDB..
 309                  */
 310                 if (prout_cmd == cmd)
 311                         continue;
 312
 313                 sess = cmd->se_sess;
 314                 if (WARN_ON_ONCE(!sess))
 315                         continue;
 316
 317                 spin_lock(&sess->sess_cmd_lock);
 318                 rc = __target_check_io_state(cmd, tmr_sess, tas);
 319                 spin_unlock(&sess->sess_cmd_lock);
 320                 if (!rc)
 321                         continue;
 322
 323                 list_move_tail(&cmd->state_list, &drain_task_list);
 324                 cmd->state_active = false;
 325         }
 326         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 327
 328         while (!list_empty(&drain_task_list)) {
 329                 cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
 330                 list_del_init(&cmd->state_list);
 331
 332                 target_show_cmd("LUN_RESET: ", cmd);
 333                 pr_debug("LUN_RESET: ITT[0x%08llx] - %s pr_res_key: 0x%016Lx\n",
 334                          cmd->tag, (preempt_and_abort_list) ? "preempt" : "",
 335                          cmd->pr_res_key);
 336
 337                 target_put_cmd_and_wait(cmd);
 338         }
 339 }
 340
 341 int core_tmr_lun_reset(
 342         struct se_device *dev,
 343         struct se_tmr_req *tmr,
 344         struct list_head *preempt_and_abort_list,
 345         struct se_cmd *prout_cmd)
 346 {
 347         struct se_node_acl *tmr_nacl = NULL;
 348         struct se_portal_group *tmr_tpg = NULL;
 349         struct se_session *tmr_sess = NULL;
 350         int tas;
 351         /*
 352          * TASK_ABORTED status bit, this is configurable via ConfigFS
 353          * struct se_device attributes.  spc4r17 section 7.4.6 Control mode page
 354          *
 355          * A task aborted status (TAS) bit set to zero specifies that aborted
 356          * tasks shall be terminated by the device server without any response
 357          * to the application client. A TAS bit set to one specifies that tasks
 358          * aborted by the actions of an I_T nexus other than the I_T nexus on
 359          * which the command was received shall be completed with TASK ABORTED
 360          * status (see SAM-4).
 361          */
 362         tas = dev->dev_attrib.emulate_tas;
 363         /*
 364          * Determine if this se_tmr is coming from a $FABRIC_MOD
 365          * or struct se_device passthrough..
 366          */
 367         if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) {
 368                 tmr_sess = tmr->task_cmd->se_sess;
 369                 tmr_nacl = tmr_sess->se_node_acl;
 370                 tmr_tpg = tmr_sess->se_tpg;
 371                 if (tmr_nacl && tmr_tpg) {
 372                         pr_debug("LUN_RESET: TMR caller fabric: %s"
 373                                 " initiator port %s\n",
 374                                 tmr_tpg->se_tpg_tfo->fabric_name,
 375                                 tmr_nacl->initiatorname);
 376                 }
 377         }
 378         pr_debug("LUN_RESET: %s starting for [%s], tas: %d\n",
 379                 (preempt_and_abort_list) ? "Preempt" : "TMR",
 380                 dev->transport->name, tas);
 381
 382         core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
 383         core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas,
 384                                 preempt_and_abort_list);
 385
 386         /*
 387          * Clear any legacy SPC-2 reservation when called during
 388          * LOGICAL UNIT RESET
 389          */
 390         if (!preempt_and_abort_list &&
 391              (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)) {
 392                 spin_lock(&dev->dev_reservation_lock);
 393                 dev->dev_reserved_node_acl = NULL;
 394                 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
 395                 spin_unlock(&dev->dev_reservation_lock);
 396                 pr_debug("LUN_RESET: SCSI-2 Released reservation\n");
 397         }
 398
 399         atomic_long_inc(&dev->num_resets);
 400
 401         pr_debug("LUN_RESET: %s for [%s] Complete\n",
 402                         (preempt_and_abort_list) ? "Preempt" : "TMR",
 403                         dev->transport->name);
 404         return 0;
 405 }
 406