1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/slab.h>
27#include <linux/spinlock.h>
28#include <linux/list.h>
29#include <linux/export.h>
30
31#include <target/target_core_base.h>
32#include <target/target_core_backend.h>
33#include <target/target_core_fabric.h>
34
35#include "target_core_internal.h"
36#include "target_core_alua.h"
37#include "target_core_pr.h"
38
39int core_tmr_alloc_req(
40 struct se_cmd *se_cmd,
41 void *fabric_tmr_ptr,
42 u8 function,
43 gfp_t gfp_flags)
44{
45 struct se_tmr_req *tmr;
46
47 tmr = kzalloc(sizeof(struct se_tmr_req), gfp_flags);
48 if (!tmr) {
49 pr_err("Unable to allocate struct se_tmr_req\n");
50 return -ENOMEM;
51 }
52
53 se_cmd->se_cmd_flags |= SCF_SCSI_TMR_CDB;
54 se_cmd->se_tmr_req = tmr;
55 tmr->task_cmd = se_cmd;
56 tmr->fabric_tmr_ptr = fabric_tmr_ptr;
57 tmr->function = function;
58 INIT_LIST_HEAD(&tmr->tmr_list);
59
60 return 0;
61}
62EXPORT_SYMBOL(core_tmr_alloc_req);
63
64void core_tmr_release_req(struct se_tmr_req *tmr)
65{
66 struct se_device *dev = tmr->tmr_dev;
67 unsigned long flags;
68
69 if (dev) {
70 spin_lock_irqsave(&dev->se_tmr_lock, flags);
71 list_del_init(&tmr->tmr_list);
72 spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
73 }
74
75 kfree(tmr);
76}
77
78static int core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas)
79{
80 unsigned long flags;
81 bool remove = true, send_tas;
82
83
84
85 spin_lock_irqsave(&cmd->t_state_lock, flags);
86 send_tas = (cmd->transport_state & CMD_T_TAS);
87 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
88
89 if (send_tas) {
90 remove = false;
91 transport_send_task_abort(cmd);
92 }
93
94 return transport_cmd_finish_abort(cmd, remove);
95}
96
97static int target_check_cdb_and_preempt(struct list_head *list,
98 struct se_cmd *cmd)
99{
100 struct t10_pr_registration *reg;
101
102 if (!list)
103 return 0;
104 list_for_each_entry(reg, list, pr_reg_abort_list) {
105 if (reg->pr_res_key == cmd->pr_res_key)
106 return 0;
107 }
108
109 return 1;
110}
111
112static bool __target_check_io_state(struct se_cmd *se_cmd,
113 struct se_session *tmr_sess, int tas)
114{
115 struct se_session *sess = se_cmd->se_sess;
116
117 assert_spin_locked(&sess->sess_cmd_lock);
118 WARN_ON_ONCE(!irqs_disabled());
119
120
121
122
123
124
125
126
127
128
129 spin_lock(&se_cmd->t_state_lock);
130 if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
131 pr_debug("Attempted to abort io tag: %llu already complete or"
132 " fabric stop, skipping\n", se_cmd->tag);
133 spin_unlock(&se_cmd->t_state_lock);
134 return false;
135 }
136 if (sess->sess_tearing_down || se_cmd->cmd_wait_set) {
137 pr_debug("Attempted to abort io tag: %llu already shutdown,"
138 " skipping\n", se_cmd->tag);
139 spin_unlock(&se_cmd->t_state_lock);
140 return false;
141 }
142 se_cmd->transport_state |= CMD_T_ABORTED;
143
144 if ((tmr_sess != se_cmd->se_sess) && tas)
145 se_cmd->transport_state |= CMD_T_TAS;
146
147 spin_unlock(&se_cmd->t_state_lock);
148
149 return kref_get_unless_zero(&se_cmd->cmd_kref);
150}
151
152void core_tmr_abort_task(
153 struct se_device *dev,
154 struct se_tmr_req *tmr,
155 struct se_session *se_sess)
156{
157 struct se_cmd *se_cmd;
158 unsigned long flags;
159 u64 ref_tag;
160
161 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
162 list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
163
164 if (dev != se_cmd->se_dev)
165 continue;
166
167
168 if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
169 continue;
170
171 ref_tag = se_cmd->tag;
172 if (tmr->ref_task_tag != ref_tag)
173 continue;
174
175 printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
176 se_cmd->se_tfo->get_fabric_name(), ref_tag);
177
178 if (!__target_check_io_state(se_cmd, se_sess, 0))
179 continue;
180
181 list_del_init(&se_cmd->se_cmd_list);
182 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
183
184 cancel_work_sync(&se_cmd->work);
185 transport_wait_for_tasks(se_cmd);
186
187 if (!transport_cmd_finish_abort(se_cmd, true))
188 target_put_sess_cmd(se_cmd);
189
190 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
191 " ref_tag: %llu\n", ref_tag);
192 tmr->response = TMR_FUNCTION_COMPLETE;
193 atomic_long_inc(&dev->aborts_complete);
194 return;
195 }
196 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
197
198 printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
199 tmr->ref_task_tag);
200 tmr->response = TMR_TASK_DOES_NOT_EXIST;
201 atomic_long_inc(&dev->aborts_no_task);
202}
203
204static void core_tmr_drain_tmr_list(
205 struct se_device *dev,
206 struct se_tmr_req *tmr,
207 struct list_head *preempt_and_abort_list)
208{
209 LIST_HEAD(drain_tmr_list);
210 struct se_session *sess;
211 struct se_tmr_req *tmr_p, *tmr_pp;
212 struct se_cmd *cmd;
213 unsigned long flags;
214 bool rc;
215
216
217
218
219 spin_lock_irqsave(&dev->se_tmr_lock, flags);
220 list_del_init(&tmr->tmr_list);
221 list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) {
222 cmd = tmr_p->task_cmd;
223 if (!cmd) {
224 pr_err("Unable to locate struct se_cmd for TMR\n");
225 continue;
226 }
227
228
229
230
231
232 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
233 continue;
234
235 sess = cmd->se_sess;
236 if (WARN_ON_ONCE(!sess))
237 continue;
238
239 spin_lock(&sess->sess_cmd_lock);
240 spin_lock(&cmd->t_state_lock);
241 if (!(cmd->transport_state & CMD_T_ACTIVE) ||
242 (cmd->transport_state & CMD_T_FABRIC_STOP)) {
243 spin_unlock(&cmd->t_state_lock);
244 spin_unlock(&sess->sess_cmd_lock);
245 continue;
246 }
247 if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) {
248 spin_unlock(&cmd->t_state_lock);
249 spin_unlock(&sess->sess_cmd_lock);
250 continue;
251 }
252 if (sess->sess_tearing_down || cmd->cmd_wait_set) {
253 spin_unlock(&cmd->t_state_lock);
254 spin_unlock(&sess->sess_cmd_lock);
255 continue;
256 }
257 cmd->transport_state |= CMD_T_ABORTED;
258 spin_unlock(&cmd->t_state_lock);
259
260 rc = kref_get_unless_zero(&cmd->cmd_kref);
261 if (!rc) {
262 printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n");
263 spin_unlock(&sess->sess_cmd_lock);
264 continue;
265 }
266 spin_unlock(&sess->sess_cmd_lock);
267
268 list_move_tail(&tmr_p->tmr_list, &drain_tmr_list);
269 }
270 spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
271
272 list_for_each_entry_safe(tmr_p, tmr_pp, &drain_tmr_list, tmr_list) {
273 list_del_init(&tmr_p->tmr_list);
274 cmd = tmr_p->task_cmd;
275
276 pr_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
277 " Response: 0x%02x, t_state: %d\n",
278 (preempt_and_abort_list) ? "Preempt" : "", tmr_p,
279 tmr_p->function, tmr_p->response, cmd->t_state);
280
281 cancel_work_sync(&cmd->work);
282 transport_wait_for_tasks(cmd);
283
284 if (!transport_cmd_finish_abort(cmd, 1))
285 target_put_sess_cmd(cmd);
286 }
287}
288
289static void core_tmr_drain_state_list(
290 struct se_device *dev,
291 struct se_cmd *prout_cmd,
292 struct se_session *tmr_sess,
293 int tas,
294 struct list_head *preempt_and_abort_list)
295{
296 LIST_HEAD(drain_task_list);
297 struct se_session *sess;
298 struct se_cmd *cmd, *next;
299 unsigned long flags;
300 int rc;
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324 spin_lock_irqsave(&dev->execute_task_lock, flags);
325 list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
326
327
328
329
330 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
331 continue;
332
333
334
335
336 if (prout_cmd == cmd)
337 continue;
338
339 sess = cmd->se_sess;
340 if (WARN_ON_ONCE(!sess))
341 continue;
342
343 spin_lock(&sess->sess_cmd_lock);
344 rc = __target_check_io_state(cmd, tmr_sess, tas);
345 spin_unlock(&sess->sess_cmd_lock);
346 if (!rc)
347 continue;
348
349 list_move_tail(&cmd->state_list, &drain_task_list);
350 cmd->state_active = false;
351 }
352 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
353
354 while (!list_empty(&drain_task_list)) {
355 cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
356 list_del_init(&cmd->state_list);
357
358 target_show_cmd("LUN_RESET: ", cmd);
359 pr_debug("LUN_RESET: ITT[0x%08llx] - %s pr_res_key: 0x%016Lx\n",
360 cmd->tag, (preempt_and_abort_list) ? "preempt" : "",
361 cmd->pr_res_key);
362
363
364
365
366
367
368
369
370 cancel_work_sync(&cmd->work);
371 transport_wait_for_tasks(cmd);
372
373 if (!core_tmr_handle_tas_abort(cmd, tas))
374 target_put_sess_cmd(cmd);
375 }
376}
377
378int core_tmr_lun_reset(
379 struct se_device *dev,
380 struct se_tmr_req *tmr,
381 struct list_head *preempt_and_abort_list,
382 struct se_cmd *prout_cmd)
383{
384 struct se_node_acl *tmr_nacl = NULL;
385 struct se_portal_group *tmr_tpg = NULL;
386 struct se_session *tmr_sess = NULL;
387 int tas;
388
389
390
391
392
393
394
395
396
397
398
399 tas = dev->dev_attrib.emulate_tas;
400
401
402
403
404 if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) {
405 tmr_sess = tmr->task_cmd->se_sess;
406 tmr_nacl = tmr_sess->se_node_acl;
407 tmr_tpg = tmr_sess->se_tpg;
408 if (tmr_nacl && tmr_tpg) {
409 pr_debug("LUN_RESET: TMR caller fabric: %s"
410 " initiator port %s\n",
411 tmr_tpg->se_tpg_tfo->get_fabric_name(),
412 tmr_nacl->initiatorname);
413 }
414 }
415 pr_debug("LUN_RESET: %s starting for [%s], tas: %d\n",
416 (preempt_and_abort_list) ? "Preempt" : "TMR",
417 dev->transport->name, tas);
418
419 core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
420 core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas,
421 preempt_and_abort_list);
422
423
424
425
426
427 if (!preempt_and_abort_list &&
428 (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)) {
429 spin_lock(&dev->dev_reservation_lock);
430 dev->dev_reserved_node_acl = NULL;
431 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
432 spin_unlock(&dev->dev_reservation_lock);
433 pr_debug("LUN_RESET: SCSI-2 Released reservation\n");
434 }
435
436 atomic_long_inc(&dev->num_resets);
437
438 pr_debug("LUN_RESET: %s for [%s] Complete\n",
439 (preempt_and_abort_list) ? "Preempt" : "TMR",
440 dev->transport->name);
441 return 0;
442}
443
444