asus-nb-wmi: Asus Notebooks WMI Driver
[linux-2.6.git] / 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 }