Commit | Line | Data |
---|---|---|
c66ac9db NB |
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 | |
25985edc | 250 | * condition. Return the ASC/ASCQ of the highest priority UA |
c66ac9db NB |
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 | |
25985edc | 307 | * release all of the Unit Attention conditions for the associated |
c66ac9db NB |
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 | } |