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 | |
| 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 | } |