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