1 // SPDX-License-Identifier: GPL-2.0
5 * Error Recovery Procedures (ERP).
7 * Copyright IBM Corp. 2002, 2016
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/kthread.h>
15 #include "zfcp_reqlist.h"
17 #define ZFCP_MAX_ERPS 3
19 enum zfcp_erp_act_flags
{
20 ZFCP_STATUS_ERP_TIMEDOUT
= 0x10000000,
21 ZFCP_STATUS_ERP_CLOSE_ONLY
= 0x01000000,
22 ZFCP_STATUS_ERP_DISMISSING
= 0x00100000,
23 ZFCP_STATUS_ERP_DISMISSED
= 0x00200000,
24 ZFCP_STATUS_ERP_LOWMEM
= 0x00400000,
25 ZFCP_STATUS_ERP_NO_REF
= 0x00800000,
29 ZFCP_ERP_STEP_UNINITIALIZED
= 0x0000,
30 ZFCP_ERP_STEP_FSF_XCONFIG
= 0x0001,
31 ZFCP_ERP_STEP_PHYS_PORT_CLOSING
= 0x0010,
32 ZFCP_ERP_STEP_PORT_CLOSING
= 0x0100,
33 ZFCP_ERP_STEP_PORT_OPENING
= 0x0800,
34 ZFCP_ERP_STEP_LUN_CLOSING
= 0x1000,
35 ZFCP_ERP_STEP_LUN_OPENING
= 0x2000,
38 enum zfcp_erp_act_type
{
39 ZFCP_ERP_ACTION_REOPEN_LUN
= 1,
40 ZFCP_ERP_ACTION_REOPEN_PORT
= 2,
41 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
= 3,
42 ZFCP_ERP_ACTION_REOPEN_ADAPTER
= 4,
45 enum zfcp_erp_act_state
{
46 ZFCP_ERP_ACTION_RUNNING
= 1,
47 ZFCP_ERP_ACTION_READY
= 2,
50 enum zfcp_erp_act_result
{
51 ZFCP_ERP_SUCCEEDED
= 0,
53 ZFCP_ERP_CONTINUES
= 2,
55 ZFCP_ERP_DISMISSED
= 4,
59 static void zfcp_erp_adapter_block(struct zfcp_adapter
*adapter
, int mask
)
61 zfcp_erp_clear_adapter_status(adapter
,
62 ZFCP_STATUS_COMMON_UNBLOCKED
| mask
);
65 static int zfcp_erp_action_exists(struct zfcp_erp_action
*act
)
67 struct zfcp_erp_action
*curr_act
;
69 list_for_each_entry(curr_act
, &act
->adapter
->erp_running_head
, list
)
71 return ZFCP_ERP_ACTION_RUNNING
;
75 static void zfcp_erp_action_ready(struct zfcp_erp_action
*act
)
77 struct zfcp_adapter
*adapter
= act
->adapter
;
79 list_move(&act
->list
, &act
->adapter
->erp_ready_head
);
80 zfcp_dbf_rec_run("erardy1", act
);
81 wake_up(&adapter
->erp_ready_wq
);
82 zfcp_dbf_rec_run("erardy2", act
);
85 static void zfcp_erp_action_dismiss(struct zfcp_erp_action
*act
)
87 act
->status
|= ZFCP_STATUS_ERP_DISMISSED
;
88 if (zfcp_erp_action_exists(act
) == ZFCP_ERP_ACTION_RUNNING
)
89 zfcp_erp_action_ready(act
);
92 static void zfcp_erp_action_dismiss_lun(struct scsi_device
*sdev
)
94 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
96 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_ERP_INUSE
)
97 zfcp_erp_action_dismiss(&zfcp_sdev
->erp_action
);
100 static void zfcp_erp_action_dismiss_port(struct zfcp_port
*port
)
102 struct scsi_device
*sdev
;
104 if (atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_ERP_INUSE
)
105 zfcp_erp_action_dismiss(&port
->erp_action
);
107 spin_lock(port
->adapter
->scsi_host
->host_lock
);
108 __shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
109 if (sdev_to_zfcp(sdev
)->port
== port
)
110 zfcp_erp_action_dismiss_lun(sdev
);
111 spin_unlock(port
->adapter
->scsi_host
->host_lock
);
115 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter
*adapter
)
117 struct zfcp_port
*port
;
119 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_ERP_INUSE
)
120 zfcp_erp_action_dismiss(&adapter
->erp_action
);
122 read_lock(&adapter
->port_list_lock
);
123 list_for_each_entry(port
, &adapter
->port_list
, list
)
124 zfcp_erp_action_dismiss_port(port
);
125 read_unlock(&adapter
->port_list_lock
);
129 static int zfcp_erp_required_act(int want
, struct zfcp_adapter
*adapter
,
130 struct zfcp_port
*port
,
131 struct scsi_device
*sdev
)
134 int l_status
, p_status
, a_status
;
135 struct zfcp_scsi_dev
*zfcp_sdev
;
138 case ZFCP_ERP_ACTION_REOPEN_LUN
:
139 zfcp_sdev
= sdev_to_zfcp(sdev
);
140 l_status
= atomic_read(&zfcp_sdev
->status
);
141 if (l_status
& ZFCP_STATUS_COMMON_ERP_INUSE
)
143 p_status
= atomic_read(&port
->status
);
144 if (!(p_status
& ZFCP_STATUS_COMMON_RUNNING
) ||
145 p_status
& ZFCP_STATUS_COMMON_ERP_FAILED
)
147 if (!(p_status
& ZFCP_STATUS_COMMON_UNBLOCKED
))
148 need
= ZFCP_ERP_ACTION_REOPEN_PORT
;
150 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
151 p_status
= atomic_read(&port
->status
);
152 if (!(p_status
& ZFCP_STATUS_COMMON_OPEN
))
153 need
= ZFCP_ERP_ACTION_REOPEN_PORT
;
155 case ZFCP_ERP_ACTION_REOPEN_PORT
:
156 p_status
= atomic_read(&port
->status
);
157 if (p_status
& ZFCP_STATUS_COMMON_ERP_INUSE
)
159 a_status
= atomic_read(&adapter
->status
);
160 if (!(a_status
& ZFCP_STATUS_COMMON_RUNNING
) ||
161 a_status
& ZFCP_STATUS_COMMON_ERP_FAILED
)
163 if (p_status
& ZFCP_STATUS_COMMON_NOESC
)
165 if (!(a_status
& ZFCP_STATUS_COMMON_UNBLOCKED
))
166 need
= ZFCP_ERP_ACTION_REOPEN_ADAPTER
;
168 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
169 a_status
= atomic_read(&adapter
->status
);
170 if (a_status
& ZFCP_STATUS_COMMON_ERP_INUSE
)
172 if (!(a_status
& ZFCP_STATUS_COMMON_RUNNING
) &&
173 !(a_status
& ZFCP_STATUS_COMMON_OPEN
))
174 return 0; /* shutdown requested for closed adapter */
180 static struct zfcp_erp_action
*zfcp_erp_setup_act(int need
, u32 act_status
,
181 struct zfcp_adapter
*adapter
,
182 struct zfcp_port
*port
,
183 struct scsi_device
*sdev
)
185 struct zfcp_erp_action
*erp_action
;
186 struct zfcp_scsi_dev
*zfcp_sdev
;
189 case ZFCP_ERP_ACTION_REOPEN_LUN
:
190 zfcp_sdev
= sdev_to_zfcp(sdev
);
191 if (!(act_status
& ZFCP_STATUS_ERP_NO_REF
))
192 if (scsi_device_get(sdev
))
194 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE
,
196 erp_action
= &zfcp_sdev
->erp_action
;
197 WARN_ON_ONCE(erp_action
->port
!= port
);
198 WARN_ON_ONCE(erp_action
->sdev
!= sdev
);
199 if (!(atomic_read(&zfcp_sdev
->status
) &
200 ZFCP_STATUS_COMMON_RUNNING
))
201 act_status
|= ZFCP_STATUS_ERP_CLOSE_ONLY
;
204 case ZFCP_ERP_ACTION_REOPEN_PORT
:
205 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
206 if (!get_device(&port
->dev
))
208 zfcp_erp_action_dismiss_port(port
);
209 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE
, &port
->status
);
210 erp_action
= &port
->erp_action
;
211 WARN_ON_ONCE(erp_action
->port
!= port
);
212 WARN_ON_ONCE(erp_action
->sdev
!= NULL
);
213 if (!(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_RUNNING
))
214 act_status
|= ZFCP_STATUS_ERP_CLOSE_ONLY
;
217 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
218 kref_get(&adapter
->ref
);
219 zfcp_erp_action_dismiss_adapter(adapter
);
220 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE
, &adapter
->status
);
221 erp_action
= &adapter
->erp_action
;
222 WARN_ON_ONCE(erp_action
->port
!= NULL
);
223 WARN_ON_ONCE(erp_action
->sdev
!= NULL
);
224 if (!(atomic_read(&adapter
->status
) &
225 ZFCP_STATUS_COMMON_RUNNING
))
226 act_status
|= ZFCP_STATUS_ERP_CLOSE_ONLY
;
233 WARN_ON_ONCE(erp_action
->adapter
!= adapter
);
234 memset(&erp_action
->list
, 0, sizeof(erp_action
->list
));
235 memset(&erp_action
->timer
, 0, sizeof(erp_action
->timer
));
236 erp_action
->step
= ZFCP_ERP_STEP_UNINITIALIZED
;
237 erp_action
->fsf_req_id
= 0;
238 erp_action
->action
= need
;
239 erp_action
->status
= act_status
;
244 static int zfcp_erp_action_enqueue(int want
, struct zfcp_adapter
*adapter
,
245 struct zfcp_port
*port
,
246 struct scsi_device
*sdev
,
247 char *id
, u32 act_status
)
249 int retval
= 1, need
;
250 struct zfcp_erp_action
*act
;
252 if (!adapter
->erp_thread
)
255 need
= zfcp_erp_required_act(want
, adapter
, port
, sdev
);
259 act
= zfcp_erp_setup_act(need
, act_status
, adapter
, port
, sdev
);
262 atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING
, &adapter
->status
);
263 ++adapter
->erp_total_count
;
264 list_add_tail(&act
->list
, &adapter
->erp_ready_head
);
265 wake_up(&adapter
->erp_ready_wq
);
268 zfcp_dbf_rec_trig(id
, adapter
, port
, sdev
, want
, need
);
272 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter
*adapter
,
273 int clear_mask
, char *id
)
275 zfcp_erp_adapter_block(adapter
, clear_mask
);
276 zfcp_scsi_schedule_rports_block(adapter
);
278 /* ensure propagation of failed status to new devices */
279 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
) {
280 zfcp_erp_set_adapter_status(adapter
,
281 ZFCP_STATUS_COMMON_ERP_FAILED
);
284 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER
,
285 adapter
, NULL
, NULL
, id
, 0);
289 * zfcp_erp_adapter_reopen - Reopen adapter.
290 * @adapter: Adapter to reopen.
291 * @clear: Status flags to clear.
292 * @id: Id for debug trace event.
294 void zfcp_erp_adapter_reopen(struct zfcp_adapter
*adapter
, int clear
, char *id
)
298 zfcp_erp_adapter_block(adapter
, clear
);
299 zfcp_scsi_schedule_rports_block(adapter
);
301 write_lock_irqsave(&adapter
->erp_lock
, flags
);
302 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
)
303 zfcp_erp_set_adapter_status(adapter
,
304 ZFCP_STATUS_COMMON_ERP_FAILED
);
306 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER
, adapter
,
308 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
312 * zfcp_erp_adapter_shutdown - Shutdown adapter.
313 * @adapter: Adapter to shut down.
314 * @clear: Status flags to clear.
315 * @id: Id for debug trace event.
317 void zfcp_erp_adapter_shutdown(struct zfcp_adapter
*adapter
, int clear
,
320 int flags
= ZFCP_STATUS_COMMON_RUNNING
| ZFCP_STATUS_COMMON_ERP_FAILED
;
321 zfcp_erp_adapter_reopen(adapter
, clear
| flags
, id
);
325 * zfcp_erp_port_shutdown - Shutdown port
326 * @port: Port to shut down.
327 * @clear: Status flags to clear.
328 * @id: Id for debug trace event.
330 void zfcp_erp_port_shutdown(struct zfcp_port
*port
, int clear
, char *id
)
332 int flags
= ZFCP_STATUS_COMMON_RUNNING
| ZFCP_STATUS_COMMON_ERP_FAILED
;
333 zfcp_erp_port_reopen(port
, clear
| flags
, id
);
336 static void zfcp_erp_port_block(struct zfcp_port
*port
, int clear
)
338 zfcp_erp_clear_port_status(port
,
339 ZFCP_STATUS_COMMON_UNBLOCKED
| clear
);
342 static void _zfcp_erp_port_forced_reopen(struct zfcp_port
*port
, int clear
,
345 zfcp_erp_port_block(port
, clear
);
346 zfcp_scsi_schedule_rport_block(port
);
348 if (atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
)
351 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
,
352 port
->adapter
, port
, NULL
, id
, 0);
356 * zfcp_erp_port_forced_reopen - Forced close of port and open again
357 * @port: Port to force close and to reopen.
358 * @clear: Status flags to clear.
359 * @id: Id for debug trace event.
361 void zfcp_erp_port_forced_reopen(struct zfcp_port
*port
, int clear
, char *id
)
364 struct zfcp_adapter
*adapter
= port
->adapter
;
366 write_lock_irqsave(&adapter
->erp_lock
, flags
);
367 _zfcp_erp_port_forced_reopen(port
, clear
, id
);
368 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
371 static int _zfcp_erp_port_reopen(struct zfcp_port
*port
, int clear
, char *id
)
373 zfcp_erp_port_block(port
, clear
);
374 zfcp_scsi_schedule_rport_block(port
);
376 if (atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
) {
377 /* ensure propagation of failed status to new devices */
378 zfcp_erp_set_port_status(port
, ZFCP_STATUS_COMMON_ERP_FAILED
);
382 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT
,
383 port
->adapter
, port
, NULL
, id
, 0);
387 * zfcp_erp_port_reopen - trigger remote port recovery
388 * @port: port to recover
389 * @clear_mask: flags in port status to be cleared
390 * @id: Id for debug trace event.
392 * Returns 0 if recovery has been triggered, < 0 if not.
394 int zfcp_erp_port_reopen(struct zfcp_port
*port
, int clear
, char *id
)
398 struct zfcp_adapter
*adapter
= port
->adapter
;
400 write_lock_irqsave(&adapter
->erp_lock
, flags
);
401 retval
= _zfcp_erp_port_reopen(port
, clear
, id
);
402 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
407 static void zfcp_erp_lun_block(struct scsi_device
*sdev
, int clear_mask
)
409 zfcp_erp_clear_lun_status(sdev
,
410 ZFCP_STATUS_COMMON_UNBLOCKED
| clear_mask
);
413 static void _zfcp_erp_lun_reopen(struct scsi_device
*sdev
, int clear
, char *id
,
416 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
417 struct zfcp_adapter
*adapter
= zfcp_sdev
->port
->adapter
;
419 zfcp_erp_lun_block(sdev
, clear
);
421 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
)
424 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN
, adapter
,
425 zfcp_sdev
->port
, sdev
, id
, act_status
);
429 * zfcp_erp_lun_reopen - initiate reopen of a LUN
430 * @sdev: SCSI device / LUN to be reopened
431 * @clear_mask: specifies flags in LUN status to be cleared
432 * @id: Id for debug trace event.
434 * Return: 0 on success, < 0 on error
436 void zfcp_erp_lun_reopen(struct scsi_device
*sdev
, int clear
, char *id
)
439 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
440 struct zfcp_port
*port
= zfcp_sdev
->port
;
441 struct zfcp_adapter
*adapter
= port
->adapter
;
443 write_lock_irqsave(&adapter
->erp_lock
, flags
);
444 _zfcp_erp_lun_reopen(sdev
, clear
, id
, 0);
445 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
449 * zfcp_erp_lun_shutdown - Shutdown LUN
450 * @sdev: SCSI device / LUN to shut down.
451 * @clear: Status flags to clear.
452 * @id: Id for debug trace event.
454 void zfcp_erp_lun_shutdown(struct scsi_device
*sdev
, int clear
, char *id
)
456 int flags
= ZFCP_STATUS_COMMON_RUNNING
| ZFCP_STATUS_COMMON_ERP_FAILED
;
457 zfcp_erp_lun_reopen(sdev
, clear
| flags
, id
);
461 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
462 * @sdev: SCSI device / LUN to shut down.
463 * @id: Id for debug trace event.
465 * Do not acquire a reference for the LUN when creating the ERP
466 * action. It is safe, because this function waits for the ERP to
467 * complete first. This allows to shutdown the LUN, even when the SCSI
468 * device is in the state SDEV_DEL when scsi_device_get will fail.
470 void zfcp_erp_lun_shutdown_wait(struct scsi_device
*sdev
, char *id
)
473 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
474 struct zfcp_port
*port
= zfcp_sdev
->port
;
475 struct zfcp_adapter
*adapter
= port
->adapter
;
476 int clear
= ZFCP_STATUS_COMMON_RUNNING
| ZFCP_STATUS_COMMON_ERP_FAILED
;
478 write_lock_irqsave(&adapter
->erp_lock
, flags
);
479 _zfcp_erp_lun_reopen(sdev
, clear
, id
, ZFCP_STATUS_ERP_NO_REF
);
480 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
482 zfcp_erp_wait(adapter
);
485 static int status_change_set(unsigned long mask
, atomic_t
*status
)
487 return (atomic_read(status
) ^ mask
) & mask
;
490 static void zfcp_erp_adapter_unblock(struct zfcp_adapter
*adapter
)
492 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED
, &adapter
->status
))
493 zfcp_dbf_rec_run("eraubl1", &adapter
->erp_action
);
494 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED
, &adapter
->status
);
497 static void zfcp_erp_port_unblock(struct zfcp_port
*port
)
499 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED
, &port
->status
))
500 zfcp_dbf_rec_run("erpubl1", &port
->erp_action
);
501 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED
, &port
->status
);
504 static void zfcp_erp_lun_unblock(struct scsi_device
*sdev
)
506 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
508 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED
, &zfcp_sdev
->status
))
509 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev
)->erp_action
);
510 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED
, &zfcp_sdev
->status
);
513 static void zfcp_erp_action_to_running(struct zfcp_erp_action
*erp_action
)
515 list_move(&erp_action
->list
, &erp_action
->adapter
->erp_running_head
);
516 zfcp_dbf_rec_run("erator1", erp_action
);
519 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action
*act
)
521 struct zfcp_adapter
*adapter
= act
->adapter
;
522 struct zfcp_fsf_req
*req
;
524 if (!act
->fsf_req_id
)
527 spin_lock(&adapter
->req_list
->lock
);
528 req
= _zfcp_reqlist_find(adapter
->req_list
, act
->fsf_req_id
);
529 if (req
&& req
->erp_action
== act
) {
530 if (act
->status
& (ZFCP_STATUS_ERP_DISMISSED
|
531 ZFCP_STATUS_ERP_TIMEDOUT
)) {
532 req
->status
|= ZFCP_STATUS_FSFREQ_DISMISSED
;
533 zfcp_dbf_rec_run("erscf_1", act
);
534 req
->erp_action
= NULL
;
536 if (act
->status
& ZFCP_STATUS_ERP_TIMEDOUT
)
537 zfcp_dbf_rec_run("erscf_2", act
);
538 if (req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
)
542 spin_unlock(&adapter
->req_list
->lock
);
546 * zfcp_erp_notify - Trigger ERP action.
547 * @erp_action: ERP action to continue.
548 * @set_mask: ERP action status flags to set.
550 void zfcp_erp_notify(struct zfcp_erp_action
*erp_action
, unsigned long set_mask
)
552 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
555 write_lock_irqsave(&adapter
->erp_lock
, flags
);
556 if (zfcp_erp_action_exists(erp_action
) == ZFCP_ERP_ACTION_RUNNING
) {
557 erp_action
->status
|= set_mask
;
558 zfcp_erp_action_ready(erp_action
);
560 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
564 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
565 * @data: ERP action (from timer data)
567 void zfcp_erp_timeout_handler(unsigned long data
)
569 struct zfcp_erp_action
*act
= (struct zfcp_erp_action
*) data
;
570 zfcp_erp_notify(act
, ZFCP_STATUS_ERP_TIMEDOUT
);
573 static void zfcp_erp_memwait_handler(unsigned long data
)
575 zfcp_erp_notify((struct zfcp_erp_action
*)data
, 0);
578 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action
*erp_action
)
580 setup_timer(&erp_action
->timer
, zfcp_erp_memwait_handler
,
581 (unsigned long) erp_action
);
582 erp_action
->timer
.expires
= jiffies
+ HZ
;
583 add_timer(&erp_action
->timer
);
586 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter
*adapter
,
589 struct zfcp_port
*port
;
591 read_lock(&adapter
->port_list_lock
);
592 list_for_each_entry(port
, &adapter
->port_list
, list
)
593 _zfcp_erp_port_reopen(port
, clear
, id
);
594 read_unlock(&adapter
->port_list_lock
);
597 static void _zfcp_erp_lun_reopen_all(struct zfcp_port
*port
, int clear
,
600 struct scsi_device
*sdev
;
602 spin_lock(port
->adapter
->scsi_host
->host_lock
);
603 __shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
604 if (sdev_to_zfcp(sdev
)->port
== port
)
605 _zfcp_erp_lun_reopen(sdev
, clear
, id
, 0);
606 spin_unlock(port
->adapter
->scsi_host
->host_lock
);
609 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action
*act
)
611 switch (act
->action
) {
612 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
613 _zfcp_erp_adapter_reopen(act
->adapter
, 0, "ersff_1");
615 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
616 _zfcp_erp_port_forced_reopen(act
->port
, 0, "ersff_2");
618 case ZFCP_ERP_ACTION_REOPEN_PORT
:
619 _zfcp_erp_port_reopen(act
->port
, 0, "ersff_3");
621 case ZFCP_ERP_ACTION_REOPEN_LUN
:
622 _zfcp_erp_lun_reopen(act
->sdev
, 0, "ersff_4", 0);
627 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action
*act
)
629 switch (act
->action
) {
630 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
631 _zfcp_erp_port_reopen_all(act
->adapter
, 0, "ersfs_1");
633 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
634 _zfcp_erp_port_reopen(act
->port
, 0, "ersfs_2");
636 case ZFCP_ERP_ACTION_REOPEN_PORT
:
637 _zfcp_erp_lun_reopen_all(act
->port
, 0, "ersfs_3");
642 static void zfcp_erp_wakeup(struct zfcp_adapter
*adapter
)
646 read_lock_irqsave(&adapter
->erp_lock
, flags
);
647 if (list_empty(&adapter
->erp_ready_head
) &&
648 list_empty(&adapter
->erp_running_head
)) {
649 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING
,
651 wake_up(&adapter
->erp_done_wqh
);
653 read_unlock_irqrestore(&adapter
->erp_lock
, flags
);
656 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter
*adapter
)
658 struct zfcp_port
*port
;
659 port
= zfcp_port_enqueue(adapter
, adapter
->peer_wwpn
, 0,
661 if (IS_ERR(port
)) /* error or port already attached */
663 _zfcp_erp_port_reopen(port
, 0, "ereptp1");
666 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action
*erp_action
)
670 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
672 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK
, &adapter
->status
);
674 for (retries
= 7; retries
; retries
--) {
675 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
677 write_lock_irq(&adapter
->erp_lock
);
678 zfcp_erp_action_to_running(erp_action
);
679 write_unlock_irq(&adapter
->erp_lock
);
680 if (zfcp_fsf_exchange_config_data(erp_action
)) {
681 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
683 return ZFCP_ERP_FAILED
;
686 wait_event(adapter
->erp_ready_wq
,
687 !list_empty(&adapter
->erp_ready_head
));
688 if (erp_action
->status
& ZFCP_STATUS_ERP_TIMEDOUT
)
691 if (!(atomic_read(&adapter
->status
) &
692 ZFCP_STATUS_ADAPTER_HOST_CON_INIT
))
699 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
702 if (!(atomic_read(&adapter
->status
) & ZFCP_STATUS_ADAPTER_XCONFIG_OK
))
703 return ZFCP_ERP_FAILED
;
705 if (fc_host_port_type(adapter
->scsi_host
) == FC_PORTTYPE_PTP
)
706 zfcp_erp_enqueue_ptp_port(adapter
);
708 return ZFCP_ERP_SUCCEEDED
;
711 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action
*act
)
714 struct zfcp_adapter
*adapter
= act
->adapter
;
716 write_lock_irq(&adapter
->erp_lock
);
717 zfcp_erp_action_to_running(act
);
718 write_unlock_irq(&adapter
->erp_lock
);
720 ret
= zfcp_fsf_exchange_port_data(act
);
721 if (ret
== -EOPNOTSUPP
)
722 return ZFCP_ERP_SUCCEEDED
;
724 return ZFCP_ERP_FAILED
;
726 zfcp_dbf_rec_run("erasox1", act
);
727 wait_event(adapter
->erp_ready_wq
,
728 !list_empty(&adapter
->erp_ready_head
));
729 zfcp_dbf_rec_run("erasox2", act
);
730 if (act
->status
& ZFCP_STATUS_ERP_TIMEDOUT
)
731 return ZFCP_ERP_FAILED
;
733 return ZFCP_ERP_SUCCEEDED
;
736 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action
*act
)
738 if (zfcp_erp_adapter_strat_fsf_xconf(act
) == ZFCP_ERP_FAILED
)
739 return ZFCP_ERP_FAILED
;
741 if (zfcp_erp_adapter_strategy_open_fsf_xport(act
) == ZFCP_ERP_FAILED
)
742 return ZFCP_ERP_FAILED
;
744 if (mempool_resize(act
->adapter
->pool
.sr_data
,
745 act
->adapter
->stat_read_buf_num
))
746 return ZFCP_ERP_FAILED
;
748 if (mempool_resize(act
->adapter
->pool
.status_read_req
,
749 act
->adapter
->stat_read_buf_num
))
750 return ZFCP_ERP_FAILED
;
752 atomic_set(&act
->adapter
->stat_miss
, act
->adapter
->stat_read_buf_num
);
753 if (zfcp_status_read_refill(act
->adapter
))
754 return ZFCP_ERP_FAILED
;
756 return ZFCP_ERP_SUCCEEDED
;
759 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action
*act
)
761 struct zfcp_adapter
*adapter
= act
->adapter
;
763 /* close queues to ensure that buffers are not accessed by adapter */
764 zfcp_qdio_close(adapter
->qdio
);
765 zfcp_fsf_req_dismiss_all(adapter
);
766 adapter
->fsf_req_seq_no
= 0;
767 zfcp_fc_wka_ports_force_offline(adapter
->gs
);
768 /* all ports and LUNs are closed */
769 zfcp_erp_clear_adapter_status(adapter
, ZFCP_STATUS_COMMON_OPEN
);
771 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK
|
772 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
, &adapter
->status
);
775 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action
*act
)
777 struct zfcp_adapter
*adapter
= act
->adapter
;
779 if (zfcp_qdio_open(adapter
->qdio
)) {
780 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK
|
781 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
,
783 return ZFCP_ERP_FAILED
;
786 if (zfcp_erp_adapter_strategy_open_fsf(act
)) {
787 zfcp_erp_adapter_strategy_close(act
);
788 return ZFCP_ERP_FAILED
;
791 atomic_or(ZFCP_STATUS_COMMON_OPEN
, &adapter
->status
);
793 return ZFCP_ERP_SUCCEEDED
;
796 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action
*act
)
798 struct zfcp_adapter
*adapter
= act
->adapter
;
800 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_OPEN
) {
801 zfcp_erp_adapter_strategy_close(act
);
802 if (act
->status
& ZFCP_STATUS_ERP_CLOSE_ONLY
)
803 return ZFCP_ERP_EXIT
;
806 if (zfcp_erp_adapter_strategy_open(act
)) {
808 return ZFCP_ERP_FAILED
;
811 return ZFCP_ERP_SUCCEEDED
;
814 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action
*act
)
818 retval
= zfcp_fsf_close_physical_port(act
);
819 if (retval
== -ENOMEM
)
820 return ZFCP_ERP_NOMEM
;
821 act
->step
= ZFCP_ERP_STEP_PHYS_PORT_CLOSING
;
823 return ZFCP_ERP_FAILED
;
825 return ZFCP_ERP_CONTINUES
;
828 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action
*erp_action
)
830 struct zfcp_port
*port
= erp_action
->port
;
831 int status
= atomic_read(&port
->status
);
833 switch (erp_action
->step
) {
834 case ZFCP_ERP_STEP_UNINITIALIZED
:
835 if ((status
& ZFCP_STATUS_PORT_PHYS_OPEN
) &&
836 (status
& ZFCP_STATUS_COMMON_OPEN
))
837 return zfcp_erp_port_forced_strategy_close(erp_action
);
839 return ZFCP_ERP_FAILED
;
841 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING
:
842 if (!(status
& ZFCP_STATUS_PORT_PHYS_OPEN
))
843 return ZFCP_ERP_SUCCEEDED
;
845 return ZFCP_ERP_FAILED
;
848 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action
*erp_action
)
852 retval
= zfcp_fsf_close_port(erp_action
);
853 if (retval
== -ENOMEM
)
854 return ZFCP_ERP_NOMEM
;
855 erp_action
->step
= ZFCP_ERP_STEP_PORT_CLOSING
;
857 return ZFCP_ERP_FAILED
;
858 return ZFCP_ERP_CONTINUES
;
861 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action
*erp_action
)
865 retval
= zfcp_fsf_open_port(erp_action
);
866 if (retval
== -ENOMEM
)
867 return ZFCP_ERP_NOMEM
;
868 erp_action
->step
= ZFCP_ERP_STEP_PORT_OPENING
;
870 return ZFCP_ERP_FAILED
;
871 return ZFCP_ERP_CONTINUES
;
874 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action
*act
)
876 struct zfcp_adapter
*adapter
= act
->adapter
;
877 struct zfcp_port
*port
= act
->port
;
879 if (port
->wwpn
!= adapter
->peer_wwpn
) {
880 zfcp_erp_set_port_status(port
, ZFCP_STATUS_COMMON_ERP_FAILED
);
881 return ZFCP_ERP_FAILED
;
883 port
->d_id
= adapter
->peer_d_id
;
884 return zfcp_erp_port_strategy_open_port(act
);
887 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action
*act
)
889 struct zfcp_adapter
*adapter
= act
->adapter
;
890 struct zfcp_port
*port
= act
->port
;
891 int p_status
= atomic_read(&port
->status
);
894 case ZFCP_ERP_STEP_UNINITIALIZED
:
895 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING
:
896 case ZFCP_ERP_STEP_PORT_CLOSING
:
897 if (fc_host_port_type(adapter
->scsi_host
) == FC_PORTTYPE_PTP
)
898 return zfcp_erp_open_ptp_port(act
);
900 zfcp_fc_trigger_did_lookup(port
);
901 return ZFCP_ERP_EXIT
;
903 return zfcp_erp_port_strategy_open_port(act
);
905 case ZFCP_ERP_STEP_PORT_OPENING
:
906 /* D_ID might have changed during open */
907 if (p_status
& ZFCP_STATUS_COMMON_OPEN
) {
909 zfcp_fc_trigger_did_lookup(port
);
910 return ZFCP_ERP_EXIT
;
912 return ZFCP_ERP_SUCCEEDED
;
914 if (port
->d_id
&& !(p_status
& ZFCP_STATUS_COMMON_NOESC
)) {
916 return ZFCP_ERP_FAILED
;
918 /* fall through otherwise */
920 return ZFCP_ERP_FAILED
;
923 static int zfcp_erp_port_strategy(struct zfcp_erp_action
*erp_action
)
925 struct zfcp_port
*port
= erp_action
->port
;
926 int p_status
= atomic_read(&port
->status
);
928 if ((p_status
& ZFCP_STATUS_COMMON_NOESC
) &&
929 !(p_status
& ZFCP_STATUS_COMMON_OPEN
))
930 goto close_init_done
;
932 switch (erp_action
->step
) {
933 case ZFCP_ERP_STEP_UNINITIALIZED
:
934 if (p_status
& ZFCP_STATUS_COMMON_OPEN
)
935 return zfcp_erp_port_strategy_close(erp_action
);
938 case ZFCP_ERP_STEP_PORT_CLOSING
:
939 if (p_status
& ZFCP_STATUS_COMMON_OPEN
)
940 return ZFCP_ERP_FAILED
;
945 if (erp_action
->status
& ZFCP_STATUS_ERP_CLOSE_ONLY
)
946 return ZFCP_ERP_EXIT
;
948 return zfcp_erp_port_strategy_open_common(erp_action
);
951 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device
*sdev
)
953 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
955 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED
,
959 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action
*erp_action
)
961 int retval
= zfcp_fsf_close_lun(erp_action
);
962 if (retval
== -ENOMEM
)
963 return ZFCP_ERP_NOMEM
;
964 erp_action
->step
= ZFCP_ERP_STEP_LUN_CLOSING
;
966 return ZFCP_ERP_FAILED
;
967 return ZFCP_ERP_CONTINUES
;
970 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action
*erp_action
)
972 int retval
= zfcp_fsf_open_lun(erp_action
);
973 if (retval
== -ENOMEM
)
974 return ZFCP_ERP_NOMEM
;
975 erp_action
->step
= ZFCP_ERP_STEP_LUN_OPENING
;
977 return ZFCP_ERP_FAILED
;
978 return ZFCP_ERP_CONTINUES
;
981 static int zfcp_erp_lun_strategy(struct zfcp_erp_action
*erp_action
)
983 struct scsi_device
*sdev
= erp_action
->sdev
;
984 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
986 switch (erp_action
->step
) {
987 case ZFCP_ERP_STEP_UNINITIALIZED
:
988 zfcp_erp_lun_strategy_clearstati(sdev
);
989 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_OPEN
)
990 return zfcp_erp_lun_strategy_close(erp_action
);
991 /* already closed, fall through */
992 case ZFCP_ERP_STEP_LUN_CLOSING
:
993 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_OPEN
)
994 return ZFCP_ERP_FAILED
;
995 if (erp_action
->status
& ZFCP_STATUS_ERP_CLOSE_ONLY
)
996 return ZFCP_ERP_EXIT
;
997 return zfcp_erp_lun_strategy_open(erp_action
);
999 case ZFCP_ERP_STEP_LUN_OPENING
:
1000 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_OPEN
)
1001 return ZFCP_ERP_SUCCEEDED
;
1003 return ZFCP_ERP_FAILED
;
1006 static int zfcp_erp_strategy_check_lun(struct scsi_device
*sdev
, int result
)
1008 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
1011 case ZFCP_ERP_SUCCEEDED
:
1012 atomic_set(&zfcp_sdev
->erp_counter
, 0);
1013 zfcp_erp_lun_unblock(sdev
);
1015 case ZFCP_ERP_FAILED
:
1016 atomic_inc(&zfcp_sdev
->erp_counter
);
1017 if (atomic_read(&zfcp_sdev
->erp_counter
) > ZFCP_MAX_ERPS
) {
1018 dev_err(&zfcp_sdev
->port
->adapter
->ccw_device
->dev
,
1019 "ERP failed for LUN 0x%016Lx on "
1021 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
1022 (unsigned long long)zfcp_sdev
->port
->wwpn
);
1023 zfcp_erp_set_lun_status(sdev
,
1024 ZFCP_STATUS_COMMON_ERP_FAILED
);
1029 if (atomic_read(&zfcp_sdev
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
) {
1030 zfcp_erp_lun_block(sdev
, 0);
1031 result
= ZFCP_ERP_EXIT
;
1036 static int zfcp_erp_strategy_check_port(struct zfcp_port
*port
, int result
)
1039 case ZFCP_ERP_SUCCEEDED
:
1040 atomic_set(&port
->erp_counter
, 0);
1041 zfcp_erp_port_unblock(port
);
1044 case ZFCP_ERP_FAILED
:
1045 if (atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_NOESC
) {
1046 zfcp_erp_port_block(port
, 0);
1047 result
= ZFCP_ERP_EXIT
;
1049 atomic_inc(&port
->erp_counter
);
1050 if (atomic_read(&port
->erp_counter
) > ZFCP_MAX_ERPS
) {
1051 dev_err(&port
->adapter
->ccw_device
->dev
,
1052 "ERP failed for remote port 0x%016Lx\n",
1053 (unsigned long long)port
->wwpn
);
1054 zfcp_erp_set_port_status(port
,
1055 ZFCP_STATUS_COMMON_ERP_FAILED
);
1060 if (atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
) {
1061 zfcp_erp_port_block(port
, 0);
1062 result
= ZFCP_ERP_EXIT
;
1067 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter
*adapter
,
1071 case ZFCP_ERP_SUCCEEDED
:
1072 atomic_set(&adapter
->erp_counter
, 0);
1073 zfcp_erp_adapter_unblock(adapter
);
1076 case ZFCP_ERP_FAILED
:
1077 atomic_inc(&adapter
->erp_counter
);
1078 if (atomic_read(&adapter
->erp_counter
) > ZFCP_MAX_ERPS
) {
1079 dev_err(&adapter
->ccw_device
->dev
,
1080 "ERP cannot recover an error "
1081 "on the FCP device\n");
1082 zfcp_erp_set_adapter_status(adapter
,
1083 ZFCP_STATUS_COMMON_ERP_FAILED
);
1088 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_ERP_FAILED
) {
1089 zfcp_erp_adapter_block(adapter
, 0);
1090 result
= ZFCP_ERP_EXIT
;
1095 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action
*erp_action
,
1098 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1099 struct zfcp_port
*port
= erp_action
->port
;
1100 struct scsi_device
*sdev
= erp_action
->sdev
;
1102 switch (erp_action
->action
) {
1104 case ZFCP_ERP_ACTION_REOPEN_LUN
:
1105 result
= zfcp_erp_strategy_check_lun(sdev
, result
);
1108 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
1109 case ZFCP_ERP_ACTION_REOPEN_PORT
:
1110 result
= zfcp_erp_strategy_check_port(port
, result
);
1113 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
1114 result
= zfcp_erp_strategy_check_adapter(adapter
, result
);
1120 static int zfcp_erp_strat_change_det(atomic_t
*target_status
, u32 erp_status
)
1122 int status
= atomic_read(target_status
);
1124 if ((status
& ZFCP_STATUS_COMMON_RUNNING
) &&
1125 (erp_status
& ZFCP_STATUS_ERP_CLOSE_ONLY
))
1126 return 1; /* take it online */
1128 if (!(status
& ZFCP_STATUS_COMMON_RUNNING
) &&
1129 !(erp_status
& ZFCP_STATUS_ERP_CLOSE_ONLY
))
1130 return 1; /* take it offline */
1135 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action
*act
, int ret
)
1137 int action
= act
->action
;
1138 struct zfcp_adapter
*adapter
= act
->adapter
;
1139 struct zfcp_port
*port
= act
->port
;
1140 struct scsi_device
*sdev
= act
->sdev
;
1141 struct zfcp_scsi_dev
*zfcp_sdev
;
1142 u32 erp_status
= act
->status
;
1145 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
1146 if (zfcp_erp_strat_change_det(&adapter
->status
, erp_status
)) {
1147 _zfcp_erp_adapter_reopen(adapter
,
1148 ZFCP_STATUS_COMMON_ERP_FAILED
,
1150 return ZFCP_ERP_EXIT
;
1154 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
1155 case ZFCP_ERP_ACTION_REOPEN_PORT
:
1156 if (zfcp_erp_strat_change_det(&port
->status
, erp_status
)) {
1157 _zfcp_erp_port_reopen(port
,
1158 ZFCP_STATUS_COMMON_ERP_FAILED
,
1160 return ZFCP_ERP_EXIT
;
1164 case ZFCP_ERP_ACTION_REOPEN_LUN
:
1165 zfcp_sdev
= sdev_to_zfcp(sdev
);
1166 if (zfcp_erp_strat_change_det(&zfcp_sdev
->status
, erp_status
)) {
1167 _zfcp_erp_lun_reopen(sdev
,
1168 ZFCP_STATUS_COMMON_ERP_FAILED
,
1170 return ZFCP_ERP_EXIT
;
1177 static void zfcp_erp_action_dequeue(struct zfcp_erp_action
*erp_action
)
1179 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1180 struct zfcp_scsi_dev
*zfcp_sdev
;
1182 adapter
->erp_total_count
--;
1183 if (erp_action
->status
& ZFCP_STATUS_ERP_LOWMEM
) {
1184 adapter
->erp_low_mem_count
--;
1185 erp_action
->status
&= ~ZFCP_STATUS_ERP_LOWMEM
;
1188 list_del(&erp_action
->list
);
1189 zfcp_dbf_rec_run("eractd1", erp_action
);
1191 switch (erp_action
->action
) {
1192 case ZFCP_ERP_ACTION_REOPEN_LUN
:
1193 zfcp_sdev
= sdev_to_zfcp(erp_action
->sdev
);
1194 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE
,
1195 &zfcp_sdev
->status
);
1198 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
1199 case ZFCP_ERP_ACTION_REOPEN_PORT
:
1200 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE
,
1201 &erp_action
->port
->status
);
1204 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
1205 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE
,
1206 &erp_action
->adapter
->status
);
1212 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1213 * @port: zfcp_port whose fc_rport we should try to unblock
1215 static void zfcp_erp_try_rport_unblock(struct zfcp_port
*port
)
1217 unsigned long flags
;
1218 struct zfcp_adapter
*adapter
= port
->adapter
;
1220 struct Scsi_Host
*shost
= adapter
->scsi_host
;
1221 struct scsi_device
*sdev
;
1223 write_lock_irqsave(&adapter
->erp_lock
, flags
);
1224 port_status
= atomic_read(&port
->status
);
1225 if ((port_status
& ZFCP_STATUS_COMMON_UNBLOCKED
) == 0 ||
1226 (port_status
& (ZFCP_STATUS_COMMON_ERP_INUSE
|
1227 ZFCP_STATUS_COMMON_ERP_FAILED
)) != 0) {
1228 /* new ERP of severity >= port triggered elsewhere meanwhile or
1229 * local link down (adapter erp_failed but not clear unblock)
1231 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port
->erp_action
);
1232 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1235 spin_lock(shost
->host_lock
);
1236 __shost_for_each_device(sdev
, shost
) {
1237 struct zfcp_scsi_dev
*zsdev
= sdev_to_zfcp(sdev
);
1240 if (zsdev
->port
!= port
)
1242 /* LUN under port of interest */
1243 lun_status
= atomic_read(&zsdev
->status
);
1244 if ((lun_status
& ZFCP_STATUS_COMMON_ERP_FAILED
) != 0)
1245 continue; /* unblock rport despite failed LUNs */
1246 /* LUN recovery not given up yet [maybe follow-up pending] */
1247 if ((lun_status
& ZFCP_STATUS_COMMON_UNBLOCKED
) == 0 ||
1248 (lun_status
& ZFCP_STATUS_COMMON_ERP_INUSE
) != 0) {
1250 * not yet unblocked [LUN recovery pending]
1251 * or meanwhile blocked [new LUN recovery triggered]
1253 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev
->erp_action
);
1254 spin_unlock(shost
->host_lock
);
1255 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1259 /* now port has no child or all children have completed recovery,
1260 * and no ERP of severity >= port was meanwhile triggered elsewhere
1262 zfcp_scsi_schedule_rport_register(port
);
1263 spin_unlock(shost
->host_lock
);
1264 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1267 static void zfcp_erp_action_cleanup(struct zfcp_erp_action
*act
, int result
)
1269 struct zfcp_adapter
*adapter
= act
->adapter
;
1270 struct zfcp_port
*port
= act
->port
;
1271 struct scsi_device
*sdev
= act
->sdev
;
1273 switch (act
->action
) {
1274 case ZFCP_ERP_ACTION_REOPEN_LUN
:
1275 if (!(act
->status
& ZFCP_STATUS_ERP_NO_REF
))
1276 scsi_device_put(sdev
);
1277 zfcp_erp_try_rport_unblock(port
);
1280 case ZFCP_ERP_ACTION_REOPEN_PORT
:
1281 /* This switch case might also happen after a forced reopen
1282 * was successfully done and thus overwritten with a new
1283 * non-forced reopen at `ersfs_2'. In this case, we must not
1284 * do the clean-up of the non-forced version.
1286 if (act
->step
!= ZFCP_ERP_STEP_UNINITIALIZED
)
1287 if (result
== ZFCP_ERP_SUCCEEDED
)
1288 zfcp_erp_try_rport_unblock(port
);
1290 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
1291 put_device(&port
->dev
);
1294 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
1295 if (result
== ZFCP_ERP_SUCCEEDED
) {
1296 register_service_level(&adapter
->service_level
);
1297 zfcp_fc_conditional_port_scan(adapter
);
1298 queue_work(adapter
->work_queue
, &adapter
->ns_up_work
);
1300 unregister_service_level(&adapter
->service_level
);
1302 kref_put(&adapter
->ref
, zfcp_adapter_release
);
1307 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action
*erp_action
)
1309 switch (erp_action
->action
) {
1310 case ZFCP_ERP_ACTION_REOPEN_ADAPTER
:
1311 return zfcp_erp_adapter_strategy(erp_action
);
1312 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED
:
1313 return zfcp_erp_port_forced_strategy(erp_action
);
1314 case ZFCP_ERP_ACTION_REOPEN_PORT
:
1315 return zfcp_erp_port_strategy(erp_action
);
1316 case ZFCP_ERP_ACTION_REOPEN_LUN
:
1317 return zfcp_erp_lun_strategy(erp_action
);
1319 return ZFCP_ERP_FAILED
;
1322 static int zfcp_erp_strategy(struct zfcp_erp_action
*erp_action
)
1325 unsigned long flags
;
1326 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1328 kref_get(&adapter
->ref
);
1330 write_lock_irqsave(&adapter
->erp_lock
, flags
);
1331 zfcp_erp_strategy_check_fsfreq(erp_action
);
1333 if (erp_action
->status
& ZFCP_STATUS_ERP_DISMISSED
) {
1334 zfcp_erp_action_dequeue(erp_action
);
1335 retval
= ZFCP_ERP_DISMISSED
;
1339 if (erp_action
->status
& ZFCP_STATUS_ERP_TIMEDOUT
) {
1340 retval
= ZFCP_ERP_FAILED
;
1344 zfcp_erp_action_to_running(erp_action
);
1346 /* no lock to allow for blocking operations */
1347 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1348 retval
= zfcp_erp_strategy_do_action(erp_action
);
1349 write_lock_irqsave(&adapter
->erp_lock
, flags
);
1351 if (erp_action
->status
& ZFCP_STATUS_ERP_DISMISSED
)
1352 retval
= ZFCP_ERP_CONTINUES
;
1355 case ZFCP_ERP_NOMEM
:
1356 if (!(erp_action
->status
& ZFCP_STATUS_ERP_LOWMEM
)) {
1357 ++adapter
->erp_low_mem_count
;
1358 erp_action
->status
|= ZFCP_STATUS_ERP_LOWMEM
;
1360 if (adapter
->erp_total_count
== adapter
->erp_low_mem_count
)
1361 _zfcp_erp_adapter_reopen(adapter
, 0, "erstgy1");
1363 zfcp_erp_strategy_memwait(erp_action
);
1364 retval
= ZFCP_ERP_CONTINUES
;
1368 case ZFCP_ERP_CONTINUES
:
1369 if (erp_action
->status
& ZFCP_STATUS_ERP_LOWMEM
) {
1370 --adapter
->erp_low_mem_count
;
1371 erp_action
->status
&= ~ZFCP_STATUS_ERP_LOWMEM
;
1377 retval
= zfcp_erp_strategy_check_target(erp_action
, retval
);
1378 zfcp_erp_action_dequeue(erp_action
);
1379 retval
= zfcp_erp_strategy_statechange(erp_action
, retval
);
1380 if (retval
== ZFCP_ERP_EXIT
)
1382 if (retval
== ZFCP_ERP_SUCCEEDED
)
1383 zfcp_erp_strategy_followup_success(erp_action
);
1384 if (retval
== ZFCP_ERP_FAILED
)
1385 zfcp_erp_strategy_followup_failed(erp_action
);
1388 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1390 if (retval
!= ZFCP_ERP_CONTINUES
)
1391 zfcp_erp_action_cleanup(erp_action
, retval
);
1393 kref_put(&adapter
->ref
, zfcp_adapter_release
);
1397 static int zfcp_erp_thread(void *data
)
1399 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*) data
;
1400 struct list_head
*next
;
1401 struct zfcp_erp_action
*act
;
1402 unsigned long flags
;
1405 wait_event_interruptible(adapter
->erp_ready_wq
,
1406 !list_empty(&adapter
->erp_ready_head
) ||
1407 kthread_should_stop());
1409 if (kthread_should_stop())
1412 write_lock_irqsave(&adapter
->erp_lock
, flags
);
1413 next
= adapter
->erp_ready_head
.next
;
1414 write_unlock_irqrestore(&adapter
->erp_lock
, flags
);
1416 if (next
!= &adapter
->erp_ready_head
) {
1417 act
= list_entry(next
, struct zfcp_erp_action
, list
);
1419 /* there is more to come after dismission, no notify */
1420 if (zfcp_erp_strategy(act
) != ZFCP_ERP_DISMISSED
)
1421 zfcp_erp_wakeup(adapter
);
1429 * zfcp_erp_thread_setup - Start ERP thread for adapter
1430 * @adapter: Adapter to start the ERP thread for
1432 * Returns 0 on success or error code from kernel_thread()
1434 int zfcp_erp_thread_setup(struct zfcp_adapter
*adapter
)
1436 struct task_struct
*thread
;
1438 thread
= kthread_run(zfcp_erp_thread
, adapter
, "zfcperp%s",
1439 dev_name(&adapter
->ccw_device
->dev
));
1440 if (IS_ERR(thread
)) {
1441 dev_err(&adapter
->ccw_device
->dev
,
1442 "Creating an ERP thread for the FCP device failed.\n");
1443 return PTR_ERR(thread
);
1446 adapter
->erp_thread
= thread
;
1451 * zfcp_erp_thread_kill - Stop ERP thread.
1452 * @adapter: Adapter where the ERP thread should be stopped.
1454 * The caller of this routine ensures that the specified adapter has
1455 * been shut down and that this operation has been completed. Thus,
1456 * there are no pending erp_actions which would need to be handled
1459 void zfcp_erp_thread_kill(struct zfcp_adapter
*adapter
)
1461 kthread_stop(adapter
->erp_thread
);
1462 adapter
->erp_thread
= NULL
;
1463 WARN_ON(!list_empty(&adapter
->erp_ready_head
));
1464 WARN_ON(!list_empty(&adapter
->erp_running_head
));
1468 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1469 * @adapter: adapter for which to wait for completion of its error recovery
1471 void zfcp_erp_wait(struct zfcp_adapter
*adapter
)
1473 wait_event(adapter
->erp_done_wqh
,
1474 !(atomic_read(&adapter
->status
) &
1475 ZFCP_STATUS_ADAPTER_ERP_PENDING
));
1479 * zfcp_erp_set_adapter_status - set adapter status bits
1480 * @adapter: adapter to change the status
1481 * @mask: status bits to change
1483 * Changes in common status bits are propagated to attached ports and LUNs.
1485 void zfcp_erp_set_adapter_status(struct zfcp_adapter
*adapter
, u32 mask
)
1487 struct zfcp_port
*port
;
1488 struct scsi_device
*sdev
;
1489 unsigned long flags
;
1490 u32 common_mask
= mask
& ZFCP_COMMON_FLAGS
;
1492 atomic_or(mask
, &adapter
->status
);
1497 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
1498 list_for_each_entry(port
, &adapter
->port_list
, list
)
1499 atomic_or(common_mask
, &port
->status
);
1500 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
1502 spin_lock_irqsave(adapter
->scsi_host
->host_lock
, flags
);
1503 __shost_for_each_device(sdev
, adapter
->scsi_host
)
1504 atomic_or(common_mask
, &sdev_to_zfcp(sdev
)->status
);
1505 spin_unlock_irqrestore(adapter
->scsi_host
->host_lock
, flags
);
1509 * zfcp_erp_clear_adapter_status - clear adapter status bits
1510 * @adapter: adapter to change the status
1511 * @mask: status bits to change
1513 * Changes in common status bits are propagated to attached ports and LUNs.
1515 void zfcp_erp_clear_adapter_status(struct zfcp_adapter
*adapter
, u32 mask
)
1517 struct zfcp_port
*port
;
1518 struct scsi_device
*sdev
;
1519 unsigned long flags
;
1520 u32 common_mask
= mask
& ZFCP_COMMON_FLAGS
;
1521 u32 clear_counter
= mask
& ZFCP_STATUS_COMMON_ERP_FAILED
;
1523 atomic_andnot(mask
, &adapter
->status
);
1529 atomic_set(&adapter
->erp_counter
, 0);
1531 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
1532 list_for_each_entry(port
, &adapter
->port_list
, list
) {
1533 atomic_andnot(common_mask
, &port
->status
);
1535 atomic_set(&port
->erp_counter
, 0);
1537 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
1539 spin_lock_irqsave(adapter
->scsi_host
->host_lock
, flags
);
1540 __shost_for_each_device(sdev
, adapter
->scsi_host
) {
1541 atomic_andnot(common_mask
, &sdev_to_zfcp(sdev
)->status
);
1543 atomic_set(&sdev_to_zfcp(sdev
)->erp_counter
, 0);
1545 spin_unlock_irqrestore(adapter
->scsi_host
->host_lock
, flags
);
1549 * zfcp_erp_set_port_status - set port status bits
1550 * @port: port to change the status
1551 * @mask: status bits to change
1553 * Changes in common status bits are propagated to attached LUNs.
1555 void zfcp_erp_set_port_status(struct zfcp_port
*port
, u32 mask
)
1557 struct scsi_device
*sdev
;
1558 u32 common_mask
= mask
& ZFCP_COMMON_FLAGS
;
1559 unsigned long flags
;
1561 atomic_or(mask
, &port
->status
);
1566 spin_lock_irqsave(port
->adapter
->scsi_host
->host_lock
, flags
);
1567 __shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1568 if (sdev_to_zfcp(sdev
)->port
== port
)
1569 atomic_or(common_mask
,
1570 &sdev_to_zfcp(sdev
)->status
);
1571 spin_unlock_irqrestore(port
->adapter
->scsi_host
->host_lock
, flags
);
1575 * zfcp_erp_clear_port_status - clear port status bits
1576 * @port: adapter to change the status
1577 * @mask: status bits to change
1579 * Changes in common status bits are propagated to attached LUNs.
1581 void zfcp_erp_clear_port_status(struct zfcp_port
*port
, u32 mask
)
1583 struct scsi_device
*sdev
;
1584 u32 common_mask
= mask
& ZFCP_COMMON_FLAGS
;
1585 u32 clear_counter
= mask
& ZFCP_STATUS_COMMON_ERP_FAILED
;
1586 unsigned long flags
;
1588 atomic_andnot(mask
, &port
->status
);
1594 atomic_set(&port
->erp_counter
, 0);
1596 spin_lock_irqsave(port
->adapter
->scsi_host
->host_lock
, flags
);
1597 __shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1598 if (sdev_to_zfcp(sdev
)->port
== port
) {
1599 atomic_andnot(common_mask
,
1600 &sdev_to_zfcp(sdev
)->status
);
1602 atomic_set(&sdev_to_zfcp(sdev
)->erp_counter
, 0);
1604 spin_unlock_irqrestore(port
->adapter
->scsi_host
->host_lock
, flags
);
1608 * zfcp_erp_set_lun_status - set lun status bits
1609 * @sdev: SCSI device / lun to set the status bits
1610 * @mask: status bits to change
1612 void zfcp_erp_set_lun_status(struct scsi_device
*sdev
, u32 mask
)
1614 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
1616 atomic_or(mask
, &zfcp_sdev
->status
);
1620 * zfcp_erp_clear_lun_status - clear lun status bits
1621 * @sdev: SCSi device / lun to clear the status bits
1622 * @mask: status bits to change
1624 void zfcp_erp_clear_lun_status(struct scsi_device
*sdev
, u32 mask
)
1626 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
1628 atomic_andnot(mask
, &zfcp_sdev
->status
);
1630 if (mask
& ZFCP_STATUS_COMMON_ERP_FAILED
)
1631 atomic_set(&zfcp_sdev
->erp_counter
, 0);