GNU Linux-libre 4.19.263-gnu1
[releases.git] / drivers / target / target_core_tmr.c
1 /*******************************************************************************
2  * Filename:  target_core_tmr.c
3  *
4  * This file contains SPC-3 task management infrastructure
5  *
6  * (c) Copyright 2009-2013 Datera, Inc.
7  *
8  * Nicholas A. Bellinger <nab@kernel.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
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
39 int 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 }
62 EXPORT_SYMBOL(core_tmr_alloc_req);
63
64 void 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
78 static int target_check_cdb_and_preempt(struct list_head *list,
79                 struct se_cmd *cmd)
80 {
81         struct t10_pr_registration *reg;
82
83         if (!list)
84                 return 0;
85         list_for_each_entry(reg, list, pr_reg_abort_list) {
86                 if (reg->pr_res_key == cmd->pr_res_key)
87                         return 0;
88         }
89
90         return 1;
91 }
92
93 static bool __target_check_io_state(struct se_cmd *se_cmd,
94                                     struct se_session *tmr_sess, int tas)
95 {
96         struct se_session *sess = se_cmd->se_sess;
97
98         assert_spin_locked(&sess->sess_cmd_lock);
99         WARN_ON_ONCE(!irqs_disabled());
100         /*
101          * If command already reached CMD_T_COMPLETE state within
102          * target_complete_cmd() or CMD_T_FABRIC_STOP due to shutdown,
103          * this se_cmd has been passed to fabric driver and will
104          * not be aborted.
105          *
106          * Otherwise, obtain a local se_cmd->cmd_kref now for TMR
107          * ABORT_TASK + LUN_RESET for CMD_T_ABORTED processing as
108          * long as se_cmd->cmd_kref is still active unless zero.
109          */
110         spin_lock(&se_cmd->t_state_lock);
111         if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
112                 pr_debug("Attempted to abort io tag: %llu already complete or"
113                         " fabric stop, skipping\n", se_cmd->tag);
114                 spin_unlock(&se_cmd->t_state_lock);
115                 return false;
116         }
117         if (se_cmd->transport_state & CMD_T_PRE_EXECUTE) {
118                 if (se_cmd->scsi_status) {
119                         pr_debug("Attempted to abort io tag: %llu early failure"
120                                  " status: 0x%02x\n", se_cmd->tag,
121                                  se_cmd->scsi_status);
122                         spin_unlock(&se_cmd->t_state_lock);
123                         return false;
124                 }
125         }
126         if (sess->sess_tearing_down) {
127                 pr_debug("Attempted to abort io tag: %llu already shutdown,"
128                         " skipping\n", se_cmd->tag);
129                 spin_unlock(&se_cmd->t_state_lock);
130                 return false;
131         }
132         se_cmd->transport_state |= CMD_T_ABORTED;
133
134         if ((tmr_sess != se_cmd->se_sess) && tas)
135                 se_cmd->transport_state |= CMD_T_TAS;
136
137         spin_unlock(&se_cmd->t_state_lock);
138
139         return kref_get_unless_zero(&se_cmd->cmd_kref);
140 }
141
142 void core_tmr_abort_task(
143         struct se_device *dev,
144         struct se_tmr_req *tmr,
145         struct se_session *se_sess)
146 {
147         struct se_cmd *se_cmd;
148         unsigned long flags;
149         u64 ref_tag;
150
151         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
152         list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
153
154                 if (dev != se_cmd->se_dev)
155                         continue;
156
157                 /* skip task management functions, including tmr->task_cmd */
158                 if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
159                         continue;
160
161                 ref_tag = se_cmd->tag;
162                 if (tmr->ref_task_tag != ref_tag)
163                         continue;
164
165                 printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
166                         se_cmd->se_tfo->get_fabric_name(), ref_tag);
167
168                 if (!__target_check_io_state(se_cmd, se_sess, 0))
169                         continue;
170
171                 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
172
173                 cancel_work_sync(&se_cmd->work);
174                 transport_wait_for_tasks(se_cmd);
175
176                 if (!transport_cmd_finish_abort(se_cmd))
177                         target_put_sess_cmd(se_cmd);
178
179                 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
180                                 " ref_tag: %llu\n", ref_tag);
181                 tmr->response = TMR_FUNCTION_COMPLETE;
182                 atomic_long_inc(&dev->aborts_complete);
183                 return;
184         }
185         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
186
187         printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
188                         tmr->ref_task_tag);
189         tmr->response = TMR_TASK_DOES_NOT_EXIST;
190         atomic_long_inc(&dev->aborts_no_task);
191 }
192
193 static void core_tmr_drain_tmr_list(
194         struct se_device *dev,
195         struct se_tmr_req *tmr,
196         struct list_head *preempt_and_abort_list)
197 {
198         LIST_HEAD(drain_tmr_list);
199         struct se_session *sess;
200         struct se_tmr_req *tmr_p, *tmr_pp;
201         struct se_cmd *cmd;
202         unsigned long flags;
203         bool rc;
204         /*
205          * Release all pending and outgoing TMRs aside from the received
206          * LUN_RESET tmr..
207          */
208         spin_lock_irqsave(&dev->se_tmr_lock, flags);
209         if (tmr)
210                 list_del_init(&tmr->tmr_list);
211         list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) {
212                 cmd = tmr_p->task_cmd;
213                 if (!cmd) {
214                         pr_err("Unable to locate struct se_cmd for TMR\n");
215                         continue;
216                 }
217                 /*
218                  * If this function was called with a valid pr_res_key
219                  * parameter (eg: for PROUT PREEMPT_AND_ABORT service action
220                  * skip non registration key matching TMRs.
221                  */
222                 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
223                         continue;
224
225                 sess = cmd->se_sess;
226                 if (WARN_ON_ONCE(!sess))
227                         continue;
228
229                 spin_lock(&sess->sess_cmd_lock);
230                 spin_lock(&cmd->t_state_lock);
231                 if (!(cmd->transport_state & CMD_T_ACTIVE) ||
232                      (cmd->transport_state & CMD_T_FABRIC_STOP)) {
233                         spin_unlock(&cmd->t_state_lock);
234                         spin_unlock(&sess->sess_cmd_lock);
235                         continue;
236                 }
237                 if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) {
238                         spin_unlock(&cmd->t_state_lock);
239                         spin_unlock(&sess->sess_cmd_lock);
240                         continue;
241                 }
242                 if (sess->sess_tearing_down) {
243                         spin_unlock(&cmd->t_state_lock);
244                         spin_unlock(&sess->sess_cmd_lock);
245                         continue;
246                 }
247                 cmd->transport_state |= CMD_T_ABORTED;
248                 spin_unlock(&cmd->t_state_lock);
249
250                 rc = kref_get_unless_zero(&cmd->cmd_kref);
251                 if (!rc) {
252                         printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n");
253                         spin_unlock(&sess->sess_cmd_lock);
254                         continue;
255                 }
256                 spin_unlock(&sess->sess_cmd_lock);
257
258                 list_move_tail(&tmr_p->tmr_list, &drain_tmr_list);
259         }
260         spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
261
262         list_for_each_entry_safe(tmr_p, tmr_pp, &drain_tmr_list, tmr_list) {
263                 list_del_init(&tmr_p->tmr_list);
264                 cmd = tmr_p->task_cmd;
265
266                 pr_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
267                         " Response: 0x%02x, t_state: %d\n",
268                         (preempt_and_abort_list) ? "Preempt" : "", tmr_p,
269                         tmr_p->function, tmr_p->response, cmd->t_state);
270
271                 cancel_work_sync(&cmd->work);
272                 transport_wait_for_tasks(cmd);
273
274                 if (!transport_cmd_finish_abort(cmd))
275                         target_put_sess_cmd(cmd);
276         }
277 }
278
279 static void core_tmr_drain_state_list(
280         struct se_device *dev,
281         struct se_cmd *prout_cmd,
282         struct se_session *tmr_sess,
283         int tas,
284         struct list_head *preempt_and_abort_list)
285 {
286         LIST_HEAD(drain_task_list);
287         struct se_session *sess;
288         struct se_cmd *cmd, *next;
289         unsigned long flags;
290         int rc;
291
292         /*
293          * Complete outstanding commands with TASK_ABORTED SAM status.
294          *
295          * This is following sam4r17, section 5.6 Aborting commands, Table 38
296          * for TMR LUN_RESET:
297          *
298          * a) "Yes" indicates that each command that is aborted on an I_T nexus
299          * other than the one that caused the SCSI device condition is
300          * completed with TASK ABORTED status, if the TAS bit is set to one in
301          * the Control mode page (see SPC-4). "No" indicates that no status is
302          * returned for aborted commands.
303          *
304          * d) If the logical unit reset is caused by a particular I_T nexus
305          * (e.g., by a LOGICAL UNIT RESET task management function), then "yes"
306          * (TASK_ABORTED status) applies.
307          *
308          * Otherwise (e.g., if triggered by a hard reset), "no"
309          * (no TASK_ABORTED SAM status) applies.
310          *
311          * Note that this seems to be independent of TAS (Task Aborted Status)
312          * in the Control Mode Page.
313          */
314         spin_lock_irqsave(&dev->execute_task_lock, flags);
315         list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
316                 /*
317                  * For PREEMPT_AND_ABORT usage, only process commands
318                  * with a matching reservation key.
319                  */
320                 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
321                         continue;
322
323                 /*
324                  * Not aborting PROUT PREEMPT_AND_ABORT CDB..
325                  */
326                 if (prout_cmd == cmd)
327                         continue;
328
329                 sess = cmd->se_sess;
330                 if (WARN_ON_ONCE(!sess))
331                         continue;
332
333                 spin_lock(&sess->sess_cmd_lock);
334                 rc = __target_check_io_state(cmd, tmr_sess, tas);
335                 spin_unlock(&sess->sess_cmd_lock);
336                 if (!rc)
337                         continue;
338
339                 list_move_tail(&cmd->state_list, &drain_task_list);
340                 cmd->state_active = false;
341         }
342         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
343
344         while (!list_empty(&drain_task_list)) {
345                 cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
346                 list_del_init(&cmd->state_list);
347
348                 target_show_cmd("LUN_RESET: ", cmd);
349                 pr_debug("LUN_RESET: ITT[0x%08llx] - %s pr_res_key: 0x%016Lx\n",
350                          cmd->tag, (preempt_and_abort_list) ? "preempt" : "",
351                          cmd->pr_res_key);
352
353                 /*
354                  * If the command may be queued onto a workqueue cancel it now.
355                  *
356                  * This is equivalent to removal from the execute queue in the
357                  * loop above, but we do it down here given that
358                  * cancel_work_sync may block.
359                  */
360                 cancel_work_sync(&cmd->work);
361                 transport_wait_for_tasks(cmd);
362
363                 if (!transport_cmd_finish_abort(cmd))
364                         target_put_sess_cmd(cmd);
365         }
366 }
367
368 int core_tmr_lun_reset(
369         struct se_device *dev,
370         struct se_tmr_req *tmr,
371         struct list_head *preempt_and_abort_list,
372         struct se_cmd *prout_cmd)
373 {
374         struct se_node_acl *tmr_nacl = NULL;
375         struct se_portal_group *tmr_tpg = NULL;
376         struct se_session *tmr_sess = NULL;
377         int tas;
378         /*
379          * TASK_ABORTED status bit, this is configurable via ConfigFS
380          * struct se_device attributes.  spc4r17 section 7.4.6 Control mode page
381          *
382          * A task aborted status (TAS) bit set to zero specifies that aborted
383          * tasks shall be terminated by the device server without any response
384          * to the application client. A TAS bit set to one specifies that tasks
385          * aborted by the actions of an I_T nexus other than the I_T nexus on
386          * which the command was received shall be completed with TASK ABORTED
387          * status (see SAM-4).
388          */
389         tas = dev->dev_attrib.emulate_tas;
390         /*
391          * Determine if this se_tmr is coming from a $FABRIC_MOD
392          * or struct se_device passthrough..
393          */
394         if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) {
395                 tmr_sess = tmr->task_cmd->se_sess;
396                 tmr_nacl = tmr_sess->se_node_acl;
397                 tmr_tpg = tmr_sess->se_tpg;
398                 if (tmr_nacl && tmr_tpg) {
399                         pr_debug("LUN_RESET: TMR caller fabric: %s"
400                                 " initiator port %s\n",
401                                 tmr_tpg->se_tpg_tfo->get_fabric_name(),
402                                 tmr_nacl->initiatorname);
403                 }
404         }
405         pr_debug("LUN_RESET: %s starting for [%s], tas: %d\n",
406                 (preempt_and_abort_list) ? "Preempt" : "TMR",
407                 dev->transport->name, tas);
408
409         core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
410         core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas,
411                                 preempt_and_abort_list);
412
413         /*
414          * Clear any legacy SPC-2 reservation when called during
415          * LOGICAL UNIT RESET
416          */
417         if (!preempt_and_abort_list &&
418              (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)) {
419                 spin_lock(&dev->dev_reservation_lock);
420                 dev->dev_reserved_node_acl = NULL;
421                 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
422                 spin_unlock(&dev->dev_reservation_lock);
423                 pr_debug("LUN_RESET: SCSI-2 Released reservation\n");
424         }
425
426         atomic_long_inc(&dev->num_resets);
427
428         pr_debug("LUN_RESET: %s for [%s] Complete\n",
429                         (preempt_and_abort_list) ? "Preempt" : "TMR",
430                         dev->transport->name);
431         return 0;
432 }
433