root/drivers/target/target_core_tmr.c

DEFINITIONS

1. core_tmr_alloc_req
2. core_tmr_release_req
3. target_check_cdb_and_preempt
4. __target_check_io_state
5. core_tmr_abort_task
6. core_tmr_drain_tmr_list
7. core_tmr_drain_state_list
8. core_tmr_lun_reset

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