drivers/target/target_core_ua.c

   1 /*******************************************************************************
   2  * Filename: target_core_ua.c
   3  *
   4  * This file contains logic for SPC-3 Unit Attention emulation
   5  *
   6  * Copyright (c) 2009,2010 Rising Tide Systems
   7  * Copyright (c) 2009,2010 Linux-iSCSI.org
   8  *
   9  * Nicholas A. Bellinger <nab@kernel.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24  *
  25  ******************************************************************************/
  26
  27 #include <linux/version.h>
  28 #include <linux/slab.h>
  29 #include <linux/spinlock.h>
  30 #include <scsi/scsi.h>
  31 #include <scsi/scsi_cmnd.h>
  32
  33 #include <target/target_core_base.h>
  34 #include <target/target_core_device.h>
  35 #include <target/target_core_transport.h>
  36 #include <target/target_core_fabric_ops.h>
  37 #include <target/target_core_configfs.h>
  38
  39 #include "target_core_alua.h"
  40 #include "target_core_hba.h"
  41 #include "target_core_pr.h"
  42 #include "target_core_ua.h"
  43
  44 int core_scsi3_ua_check(
  45         struct se_cmd *cmd,
  46         unsigned char *cdb)
  47 {
  48         struct se_dev_entry *deve;
  49         struct se_session *sess = cmd->se_sess;
  50         struct se_node_acl *nacl;
  51
  52         if (!(sess))
  53                 return 0;
  54
  55         nacl = sess->se_node_acl;
  56         if (!(nacl))
  57                 return 0;
  58
  59         deve = &nacl->device_list[cmd->orig_fe_lun];
  60         if (!(atomic_read(&deve->ua_count)))
  61                 return 0;
  62         /*
  63          * From sam4r14, section 5.14 Unit attention condition:
  64          *
  65          * a) if an INQUIRY command enters the enabled command state, the
  66          *    device server shall process the INQUIRY command and shall neither
  67          *    report nor clear any unit attention condition;
  68          * b) if a REPORT LUNS command enters the enabled command state, the
  69          *    device server shall process the REPORT LUNS command and shall not
  70          *    report any unit attention condition;
  71          * e) if a REQUEST SENSE command enters the enabled command state while
  72          *    a unit attention condition exists for the SCSI initiator port
  73          *    associated with the I_T nexus on which the REQUEST SENSE command
  74          *    was received, then the device server shall process the command
  75          *    and either:
  76          */
  77         switch (cdb[0]) {
  78         case INQUIRY:
  79         case REPORT_LUNS:
  80         case REQUEST_SENSE:
  81                 return 0;
  82         default:
  83                 return -1;
  84         }
  85
  86         return -1;
  87 }
  88
  89 int core_scsi3_ua_allocate(
  90         struct se_node_acl *nacl,
  91         u32 unpacked_lun,
  92         u8 asc,
  93         u8 ascq)
  94 {
  95         struct se_dev_entry *deve;
  96         struct se_ua *ua, *ua_p, *ua_tmp;
  97         /*
  98          * PASSTHROUGH OPS
  99          */
 100         if (!(nacl))
 101                 return -1;
 102
 103         ua = kmem_cache_zalloc(se_ua_cache, GFP_ATOMIC);
 104         if (!(ua)) {
 105                 printk(KERN_ERR "Unable to allocate struct se_ua\n");
 106                 return -1;
 107         }
 108         INIT_LIST_HEAD(&ua->ua_dev_list);
 109         INIT_LIST_HEAD(&ua->ua_nacl_list);
 110
 111         ua->ua_nacl = nacl;
 112         ua->ua_asc = asc;
 113         ua->ua_ascq = ascq;
 114
 115         spin_lock_irq(&nacl->device_list_lock);
 116         deve = &nacl->device_list[unpacked_lun];
 117
 118         spin_lock(&deve->ua_lock);
 119         list_for_each_entry_safe(ua_p, ua_tmp, &deve->ua_list, ua_nacl_list) {
 120                 /*
 121                  * Do not report the same UNIT ATTENTION twice..
 122                  */
 123                 if ((ua_p->ua_asc == asc) && (ua_p->ua_ascq == ascq)) {
 124                         spin_unlock(&deve->ua_lock);
 125                         spin_unlock_irq(&nacl->device_list_lock);
 126                         kmem_cache_free(se_ua_cache, ua);
 127                         return 0;
 128                 }
 129                 /*
 130                  * Attach the highest priority Unit Attention to
 131                  * the head of the list following sam4r14,
 132                  * Section 5.14 Unit Attention Condition:
 133                  *
 134                  * POWER ON, RESET, OR BUS DEVICE RESET OCCURRED highest
 135                  * POWER ON OCCURRED or
 136                  * DEVICE INTERNAL RESET
 137                  * SCSI BUS RESET OCCURRED or
 138                  * MICROCODE HAS BEEN CHANGED or
 139                  * protocol specific
 140                  * BUS DEVICE RESET FUNCTION OCCURRED
 141                  * I_T NEXUS LOSS OCCURRED
 142                  * COMMANDS CLEARED BY POWER LOSS NOTIFICATION
 143                  * all others                                    Lowest
 144                  *
 145                  * Each of the ASCQ codes listed above are defined in
 146                  * the 29h ASC family, see spc4r17 Table D.1
 147                  */
 148                 if (ua_p->ua_asc == 0x29) {
 149                         if ((asc == 0x29) && (ascq > ua_p->ua_ascq))
 150                                 list_add(&ua->ua_nacl_list,
 151                                                 &deve->ua_list);
 152                         else
 153                                 list_add_tail(&ua->ua_nacl_list,
 154                                                 &deve->ua_list);
 155                 } else if (ua_p->ua_asc == 0x2a) {
 156                         /*
 157                          * Incoming Family 29h ASCQ codes will override
 158                          * Family 2AHh ASCQ codes for Unit Attention condition.
 159                          */
 160                         if ((asc == 0x29) || (ascq > ua_p->ua_asc))
 161                                 list_add(&ua->ua_nacl_list,
 162                                         &deve->ua_list);
 163                         else
 164                                 list_add_tail(&ua->ua_nacl_list,
 165                                                 &deve->ua_list);
 166                 } else
 167                         list_add_tail(&ua->ua_nacl_list,
 168                                 &deve->ua_list);
 169                 spin_unlock(&deve->ua_lock);
 170                 spin_unlock_irq(&nacl->device_list_lock);
 171
 172                 atomic_inc(&deve->ua_count);
 173                 smp_mb__after_atomic_inc();
 174                 return 0;
 175         }
 176         list_add_tail(&ua->ua_nacl_list, &deve->ua_list);
 177         spin_unlock(&deve->ua_lock);
 178         spin_unlock_irq(&nacl->device_list_lock);
 179
 180         printk(KERN_INFO "[%s]: Allocated UNIT ATTENTION, mapped LUN: %u, ASC:"
 181                 " 0x%02x, ASCQ: 0x%02x\n",
 182                 TPG_TFO(nacl->se_tpg)->get_fabric_name(), unpacked_lun,
 183                 asc, ascq);
 184
 185         atomic_inc(&deve->ua_count);
 186         smp_mb__after_atomic_inc();
 187         return 0;
 188 }
 189
 190 void core_scsi3_ua_release_all(
 191         struct se_dev_entry *deve)
 192 {
 193         struct se_ua *ua, *ua_p;
 194
 195         spin_lock(&deve->ua_lock);
 196         list_for_each_entry_safe(ua, ua_p, &deve->ua_list, ua_nacl_list) {
 197                 list_del(&ua->ua_nacl_list);
 198                 kmem_cache_free(se_ua_cache, ua);
 199
 200                 atomic_dec(&deve->ua_count);
 201                 smp_mb__after_atomic_dec();
 202         }
 203         spin_unlock(&deve->ua_lock);
 204 }
 205
 206 void core_scsi3_ua_for_check_condition(
 207         struct se_cmd *cmd,
 208         u8 *asc,
 209         u8 *ascq)
 210 {
 211         struct se_device *dev = SE_DEV(cmd);
 212         struct se_dev_entry *deve;
 213         struct se_session *sess = cmd->se_sess;
 214         struct se_node_acl *nacl;
 215         struct se_ua *ua = NULL, *ua_p;
 216         int head = 1;
 217
 218         if (!(sess))
 219                 return;
 220
 221         nacl = sess->se_node_acl;
 222         if (!(nacl))
 223                 return;
 224
 225         spin_lock_irq(&nacl->device_list_lock);
 226         deve = &nacl->device_list[cmd->orig_fe_lun];
 227         if (!(atomic_read(&deve->ua_count))) {
 228                 spin_unlock_irq(&nacl->device_list_lock);
 229                 return;
 230         }
 231         /*
 232          * The highest priority Unit Attentions are placed at the head of the
 233          * struct se_dev_entry->ua_list, and will be returned in CHECK_CONDITION +
 234          * sense data for the received CDB.
 235          */
 236         spin_lock(&deve->ua_lock);
 237         list_for_each_entry_safe(ua, ua_p, &deve->ua_list, ua_nacl_list) {
 238                 /*
 239                  * For ua_intlck_ctrl code not equal to 00b, only report the
 240                  * highest priority UNIT_ATTENTION and ASC/ASCQ without
 241                  * clearing it.
 242                  */
 243                 if (DEV_ATTRIB(dev)->emulate_ua_intlck_ctrl != 0) {
 244                         *asc = ua->ua_asc;
 245                         *ascq = ua->ua_ascq;
 246                         break;
 247                 }
 248                 /*
 249                  * Otherwise for the default 00b, release the UNIT ATTENTION
 250                  * condition.  Return the ASC/ASCQ of the higest priority UA
 251                  * (head of the list) in the outgoing CHECK_CONDITION + sense.
 252                  */
 253                 if (head) {
 254                         *asc = ua->ua_asc;
 255                         *ascq = ua->ua_ascq;
 256                         head = 0;
 257                 }
 258                 list_del(&ua->ua_nacl_list);
 259                 kmem_cache_free(se_ua_cache, ua);
 260
 261                 atomic_dec(&deve->ua_count);
 262                 smp_mb__after_atomic_dec();
 263         }
 264         spin_unlock(&deve->ua_lock);
 265         spin_unlock_irq(&nacl->device_list_lock);
 266
 267         printk(KERN_INFO "[%s]: %s UNIT ATTENTION condition with"
 268                 " INTLCK_CTRL: %d, mapped LUN: %u, got CDB: 0x%02x"
 269                 " reported ASC: 0x%02x, ASCQ: 0x%02x\n",
 270                 TPG_TFO(nacl->se_tpg)->get_fabric_name(),
 271                 (DEV_ATTRIB(dev)->emulate_ua_intlck_ctrl != 0) ? "Reporting" :
 272                 "Releasing", DEV_ATTRIB(dev)->emulate_ua_intlck_ctrl,
 273                 cmd->orig_fe_lun, T_TASK(cmd)->t_task_cdb[0], *asc, *ascq);
 274 }
 275
 276 int core_scsi3_ua_clear_for_request_sense(
 277         struct se_cmd *cmd,
 278         u8 *asc,
 279         u8 *ascq)
 280 {
 281         struct se_dev_entry *deve;
 282         struct se_session *sess = cmd->se_sess;
 283         struct se_node_acl *nacl;
 284         struct se_ua *ua = NULL, *ua_p;
 285         int head = 1;
 286
 287         if (!(sess))
 288                 return -1;
 289
 290         nacl = sess->se_node_acl;
 291         if (!(nacl))
 292                 return -1;
 293
 294         spin_lock_irq(&nacl->device_list_lock);
 295         deve = &nacl->device_list[cmd->orig_fe_lun];
 296         if (!(atomic_read(&deve->ua_count))) {
 297                 spin_unlock_irq(&nacl->device_list_lock);
 298                 return -1;
 299         }
 300         /*
 301          * The highest priority Unit Attentions are placed at the head of the
 302          * struct se_dev_entry->ua_list.  The First (and hence highest priority)
 303          * ASC/ASCQ will be returned in REQUEST_SENSE payload data for the
 304          * matching struct se_lun.
 305          *
 306          * Once the returning ASC/ASCQ values are set, we go ahead and
 307          * release all of the Unit Attention conditions for the assoicated
 308          * struct se_lun.
 309          */
 310         spin_lock(&deve->ua_lock);
 311         list_for_each_entry_safe(ua, ua_p, &deve->ua_list, ua_nacl_list) {
 312                 if (head) {
 313                         *asc = ua->ua_asc;
 314                         *ascq = ua->ua_ascq;
 315                         head = 0;
 316                 }
 317                 list_del(&ua->ua_nacl_list);
 318                 kmem_cache_free(se_ua_cache, ua);
 319
 320                 atomic_dec(&deve->ua_count);
 321                 smp_mb__after_atomic_dec();
 322         }
 323         spin_unlock(&deve->ua_lock);
 324         spin_unlock_irq(&nacl->device_list_lock);
 325
 326         printk(KERN_INFO "[%s]: Released UNIT ATTENTION condition, mapped"
 327                 " LUN: %u, got REQUEST_SENSE reported ASC: 0x%02x,"
 328                 " ASCQ: 0x%02x\n", TPG_TFO(nacl->se_tpg)->get_fabric_name(),
 329                 cmd->orig_fe_lun, *asc, *ascq);
 330
 331         return (head) ? -1 : 0;
 332 }