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,
39 * enum zfcp_erp_act_type - Type of ERP action object.
40 * @ZFCP_ERP_ACTION_REOPEN_LUN: LUN recovery.
41 * @ZFCP_ERP_ACTION_REOPEN_PORT: Port recovery.
42 * @ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: Forced port recovery.
43 * @ZFCP_ERP_ACTION_REOPEN_ADAPTER: Adapter recovery.
44 * @ZFCP_ERP_ACTION_NONE: Eyecatcher pseudo flag to bitwise or-combine with
45 * either of the first four enum values.
46 * Used to indicate that an ERP action could not be
47 * set up despite a detected need for some recovery.
48 * @ZFCP_ERP_ACTION_FAILED: Eyecatcher pseudo flag to bitwise or-combine with
49 * either of the first four enum values.
50 * Used to indicate that ERP not needed because
51 * the object has ZFCP_STATUS_COMMON_ERP_FAILED.
53 enum zfcp_erp_act_type {
54 ZFCP_ERP_ACTION_REOPEN_LUN = 1,
55 ZFCP_ERP_ACTION_REOPEN_PORT = 2,
56 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
57 ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4,
58 ZFCP_ERP_ACTION_NONE = 0xc0,
59 ZFCP_ERP_ACTION_FAILED = 0xe0,
62 enum zfcp_erp_act_state {
63 ZFCP_ERP_ACTION_RUNNING = 1,
64 ZFCP_ERP_ACTION_READY = 2,
67 enum zfcp_erp_act_result {
68 ZFCP_ERP_SUCCEEDED = 0,
70 ZFCP_ERP_CONTINUES = 2,
72 ZFCP_ERP_DISMISSED = 4,
76 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
78 zfcp_erp_clear_adapter_status(adapter,
79 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
82 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
84 struct zfcp_erp_action *curr_act;
86 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
88 return ZFCP_ERP_ACTION_RUNNING;
92 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
94 struct zfcp_adapter *adapter = act->adapter;
96 list_move(&act->list, &act->adapter->erp_ready_head);
97 zfcp_dbf_rec_run("erardy1", act);
98 wake_up(&adapter->erp_ready_wq);
99 zfcp_dbf_rec_run("erardy2", act);
102 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
104 act->status |= ZFCP_STATUS_ERP_DISMISSED;
105 if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
106 zfcp_erp_action_ready(act);
109 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
111 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
113 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
114 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
117 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
119 struct scsi_device *sdev;
121 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
122 zfcp_erp_action_dismiss(&port->erp_action);
124 spin_lock(port->adapter->scsi_host->host_lock);
125 __shost_for_each_device(sdev, port->adapter->scsi_host)
126 if (sdev_to_zfcp(sdev)->port == port)
127 zfcp_erp_action_dismiss_lun(sdev);
128 spin_unlock(port->adapter->scsi_host->host_lock);
132 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
134 struct zfcp_port *port;
136 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
137 zfcp_erp_action_dismiss(&adapter->erp_action);
139 read_lock(&adapter->port_list_lock);
140 list_for_each_entry(port, &adapter->port_list, list)
141 zfcp_erp_action_dismiss_port(port);
142 read_unlock(&adapter->port_list_lock);
146 static int zfcp_erp_handle_failed(int want, struct zfcp_adapter *adapter,
147 struct zfcp_port *port,
148 struct scsi_device *sdev)
151 struct zfcp_scsi_dev *zsdev;
154 case ZFCP_ERP_ACTION_REOPEN_LUN:
155 zsdev = sdev_to_zfcp(sdev);
156 if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
159 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
160 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
163 case ZFCP_ERP_ACTION_REOPEN_PORT:
164 if (atomic_read(&port->status) &
165 ZFCP_STATUS_COMMON_ERP_FAILED) {
167 /* ensure propagation of failed status to new devices */
168 zfcp_erp_set_port_status(
169 port, ZFCP_STATUS_COMMON_ERP_FAILED);
172 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
173 if (atomic_read(&adapter->status) &
174 ZFCP_STATUS_COMMON_ERP_FAILED) {
176 /* ensure propagation of failed status to new devices */
177 zfcp_erp_set_adapter_status(
178 adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
189 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
190 struct zfcp_port *port,
191 struct scsi_device *sdev)
194 int l_status, p_status, a_status;
195 struct zfcp_scsi_dev *zfcp_sdev;
198 case ZFCP_ERP_ACTION_REOPEN_LUN:
199 zfcp_sdev = sdev_to_zfcp(sdev);
200 l_status = atomic_read(&zfcp_sdev->status);
201 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
203 p_status = atomic_read(&port->status);
204 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
205 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
207 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
208 need = ZFCP_ERP_ACTION_REOPEN_PORT;
210 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
211 p_status = atomic_read(&port->status);
212 if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
213 need = ZFCP_ERP_ACTION_REOPEN_PORT;
215 case ZFCP_ERP_ACTION_REOPEN_PORT:
216 p_status = atomic_read(&port->status);
217 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
219 a_status = atomic_read(&adapter->status);
220 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
221 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
223 if (p_status & ZFCP_STATUS_COMMON_NOESC)
225 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
226 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
228 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
229 a_status = atomic_read(&adapter->status);
230 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
232 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
233 !(a_status & ZFCP_STATUS_COMMON_OPEN))
234 return 0; /* shutdown requested for closed adapter */
240 static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
241 struct zfcp_adapter *adapter,
242 struct zfcp_port *port,
243 struct scsi_device *sdev)
245 struct zfcp_erp_action *erp_action;
246 struct zfcp_scsi_dev *zfcp_sdev;
249 case ZFCP_ERP_ACTION_REOPEN_LUN:
250 zfcp_sdev = sdev_to_zfcp(sdev);
251 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
252 if (scsi_device_get(sdev))
254 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
256 erp_action = &zfcp_sdev->erp_action;
257 WARN_ON_ONCE(erp_action->port != port);
258 WARN_ON_ONCE(erp_action->sdev != sdev);
259 if (!(atomic_read(&zfcp_sdev->status) &
260 ZFCP_STATUS_COMMON_RUNNING))
261 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
264 case ZFCP_ERP_ACTION_REOPEN_PORT:
265 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
266 if (!get_device(&port->dev))
268 zfcp_erp_action_dismiss_port(port);
269 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
270 erp_action = &port->erp_action;
271 WARN_ON_ONCE(erp_action->port != port);
272 WARN_ON_ONCE(erp_action->sdev != NULL);
273 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
274 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
277 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
278 kref_get(&adapter->ref);
279 zfcp_erp_action_dismiss_adapter(adapter);
280 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
281 erp_action = &adapter->erp_action;
282 WARN_ON_ONCE(erp_action->port != NULL);
283 WARN_ON_ONCE(erp_action->sdev != NULL);
284 if (!(atomic_read(&adapter->status) &
285 ZFCP_STATUS_COMMON_RUNNING))
286 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
293 WARN_ON_ONCE(erp_action->adapter != adapter);
294 memset(&erp_action->list, 0, sizeof(erp_action->list));
295 memset(&erp_action->timer, 0, sizeof(erp_action->timer));
296 erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
297 erp_action->fsf_req_id = 0;
298 erp_action->action = need;
299 erp_action->status = act_status;
304 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
305 struct zfcp_port *port,
306 struct scsi_device *sdev,
307 char *id, u32 act_status)
309 int retval = 1, need;
310 struct zfcp_erp_action *act;
312 need = zfcp_erp_handle_failed(want, adapter, port, sdev);
314 need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
318 if (!adapter->erp_thread) {
319 need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
324 need = zfcp_erp_required_act(want, adapter, port, sdev);
328 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
330 need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
333 atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
334 ++adapter->erp_total_count;
335 list_add_tail(&act->list, &adapter->erp_ready_head);
336 wake_up(&adapter->erp_ready_wq);
339 zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
343 void zfcp_erp_port_forced_no_port_dbf(char *id, struct zfcp_adapter *adapter,
344 u64 port_name, u32 port_id)
347 static /* don't waste stack */ struct zfcp_port tmpport;
349 write_lock_irqsave(&adapter->erp_lock, flags);
350 /* Stand-in zfcp port with fields just good enough for
351 * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
352 * Under lock because tmpport is static.
354 atomic_set(&tmpport.status, -1); /* unknown */
355 tmpport.wwpn = port_name;
356 tmpport.d_id = port_id;
357 zfcp_dbf_rec_trig(id, adapter, &tmpport, NULL,
358 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
359 ZFCP_ERP_ACTION_NONE);
360 write_unlock_irqrestore(&adapter->erp_lock, flags);
363 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
364 int clear_mask, char *id)
366 zfcp_erp_adapter_block(adapter, clear_mask);
367 zfcp_scsi_schedule_rports_block(adapter);
369 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
370 adapter, NULL, NULL, id, 0);
374 * zfcp_erp_adapter_reopen - Reopen adapter.
375 * @adapter: Adapter to reopen.
376 * @clear: Status flags to clear.
377 * @id: Id for debug trace event.
379 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
383 zfcp_erp_adapter_block(adapter, clear);
384 zfcp_scsi_schedule_rports_block(adapter);
386 write_lock_irqsave(&adapter->erp_lock, flags);
387 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
389 write_unlock_irqrestore(&adapter->erp_lock, flags);
393 * zfcp_erp_adapter_shutdown - Shutdown adapter.
394 * @adapter: Adapter to shut down.
395 * @clear: Status flags to clear.
396 * @id: Id for debug trace event.
398 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
401 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
402 zfcp_erp_adapter_reopen(adapter, clear | flags, id);
406 * zfcp_erp_port_shutdown - Shutdown port
407 * @port: Port to shut down.
408 * @clear: Status flags to clear.
409 * @id: Id for debug trace event.
411 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
413 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
414 zfcp_erp_port_reopen(port, clear | flags, id);
417 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
419 zfcp_erp_clear_port_status(port,
420 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
423 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
426 zfcp_erp_port_block(port, clear);
427 zfcp_scsi_schedule_rport_block(port);
429 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
430 port->adapter, port, NULL, id, 0);
434 * zfcp_erp_port_forced_reopen - Forced close of port and open again
435 * @port: Port to force close and to reopen.
436 * @clear: Status flags to clear.
437 * @id: Id for debug trace event.
439 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
442 struct zfcp_adapter *adapter = port->adapter;
444 write_lock_irqsave(&adapter->erp_lock, flags);
445 _zfcp_erp_port_forced_reopen(port, clear, id);
446 write_unlock_irqrestore(&adapter->erp_lock, flags);
449 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
451 zfcp_erp_port_block(port, clear);
452 zfcp_scsi_schedule_rport_block(port);
454 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
455 port->adapter, port, NULL, id, 0);
459 * zfcp_erp_port_reopen - trigger remote port recovery
460 * @port: port to recover
461 * @clear_mask: flags in port status to be cleared
462 * @id: Id for debug trace event.
464 * Returns 0 if recovery has been triggered, < 0 if not.
466 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
470 struct zfcp_adapter *adapter = port->adapter;
472 write_lock_irqsave(&adapter->erp_lock, flags);
473 retval = _zfcp_erp_port_reopen(port, clear, id);
474 write_unlock_irqrestore(&adapter->erp_lock, flags);
479 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
481 zfcp_erp_clear_lun_status(sdev,
482 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
485 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
488 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
489 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
491 zfcp_erp_lun_block(sdev, clear);
493 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
494 zfcp_sdev->port, sdev, id, act_status);
498 * zfcp_erp_lun_reopen - initiate reopen of a LUN
499 * @sdev: SCSI device / LUN to be reopened
500 * @clear_mask: specifies flags in LUN status to be cleared
501 * @id: Id for debug trace event.
503 * Return: 0 on success, < 0 on error
505 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
508 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
509 struct zfcp_port *port = zfcp_sdev->port;
510 struct zfcp_adapter *adapter = port->adapter;
512 write_lock_irqsave(&adapter->erp_lock, flags);
513 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
514 write_unlock_irqrestore(&adapter->erp_lock, flags);
518 * zfcp_erp_lun_shutdown - Shutdown LUN
519 * @sdev: SCSI device / LUN to shut down.
520 * @clear: Status flags to clear.
521 * @id: Id for debug trace event.
523 void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
525 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
526 zfcp_erp_lun_reopen(sdev, clear | flags, id);
530 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
531 * @sdev: SCSI device / LUN to shut down.
532 * @id: Id for debug trace event.
534 * Do not acquire a reference for the LUN when creating the ERP
535 * action. It is safe, because this function waits for the ERP to
536 * complete first. This allows to shutdown the LUN, even when the SCSI
537 * device is in the state SDEV_DEL when scsi_device_get will fail.
539 void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
542 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
543 struct zfcp_port *port = zfcp_sdev->port;
544 struct zfcp_adapter *adapter = port->adapter;
545 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
547 write_lock_irqsave(&adapter->erp_lock, flags);
548 _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
549 write_unlock_irqrestore(&adapter->erp_lock, flags);
551 zfcp_erp_wait(adapter);
554 static int status_change_set(unsigned long mask, atomic_t *status)
556 return (atomic_read(status) ^ mask) & mask;
559 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
561 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
562 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
563 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
566 static void zfcp_erp_port_unblock(struct zfcp_port *port)
568 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
569 zfcp_dbf_rec_run("erpubl1", &port->erp_action);
570 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
573 static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
575 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
577 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
578 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
579 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
582 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
584 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
585 zfcp_dbf_rec_run("erator1", erp_action);
588 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
590 struct zfcp_adapter *adapter = act->adapter;
591 struct zfcp_fsf_req *req;
593 if (!act->fsf_req_id)
596 spin_lock(&adapter->req_list->lock);
597 req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
598 if (req && req->erp_action == act) {
599 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
600 ZFCP_STATUS_ERP_TIMEDOUT)) {
601 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
602 zfcp_dbf_rec_run("erscf_1", act);
603 req->erp_action = NULL;
605 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
606 zfcp_dbf_rec_run("erscf_2", act);
607 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
611 spin_unlock(&adapter->req_list->lock);
615 * zfcp_erp_notify - Trigger ERP action.
616 * @erp_action: ERP action to continue.
617 * @set_mask: ERP action status flags to set.
619 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
621 struct zfcp_adapter *adapter = erp_action->adapter;
624 write_lock_irqsave(&adapter->erp_lock, flags);
625 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
626 erp_action->status |= set_mask;
627 zfcp_erp_action_ready(erp_action);
629 write_unlock_irqrestore(&adapter->erp_lock, flags);
633 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
634 * @data: ERP action (from timer data)
636 void zfcp_erp_timeout_handler(struct timer_list *t)
638 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
639 struct zfcp_erp_action *act = fsf_req->erp_action;
641 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
644 static void zfcp_erp_memwait_handler(struct timer_list *t)
646 struct zfcp_erp_action *act = from_timer(act, t, timer);
648 zfcp_erp_notify(act, 0);
651 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
653 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
654 erp_action->timer.expires = jiffies + HZ;
655 add_timer(&erp_action->timer);
658 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
661 struct zfcp_port *port;
663 read_lock(&adapter->port_list_lock);
664 list_for_each_entry(port, &adapter->port_list, list)
665 _zfcp_erp_port_reopen(port, clear, id);
666 read_unlock(&adapter->port_list_lock);
669 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
672 struct scsi_device *sdev;
674 spin_lock(port->adapter->scsi_host->host_lock);
675 __shost_for_each_device(sdev, port->adapter->scsi_host)
676 if (sdev_to_zfcp(sdev)->port == port)
677 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
678 spin_unlock(port->adapter->scsi_host->host_lock);
681 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
683 switch (act->action) {
684 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
685 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
687 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
688 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
690 case ZFCP_ERP_ACTION_REOPEN_PORT:
691 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
693 case ZFCP_ERP_ACTION_REOPEN_LUN:
694 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
699 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
701 switch (act->action) {
702 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
703 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
705 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
706 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
708 case ZFCP_ERP_ACTION_REOPEN_PORT:
709 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
714 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
718 read_lock_irqsave(&adapter->erp_lock, flags);
719 if (list_empty(&adapter->erp_ready_head) &&
720 list_empty(&adapter->erp_running_head)) {
721 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
723 wake_up(&adapter->erp_done_wqh);
725 read_unlock_irqrestore(&adapter->erp_lock, flags);
728 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
730 struct zfcp_port *port;
731 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
733 if (IS_ERR(port)) /* error or port already attached */
735 _zfcp_erp_port_reopen(port, 0, "ereptp1");
738 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
742 struct zfcp_adapter *adapter = erp_action->adapter;
744 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
746 for (retries = 7; retries; retries--) {
747 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
749 write_lock_irq(&adapter->erp_lock);
750 zfcp_erp_action_to_running(erp_action);
751 write_unlock_irq(&adapter->erp_lock);
752 if (zfcp_fsf_exchange_config_data(erp_action)) {
753 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
755 return ZFCP_ERP_FAILED;
758 wait_event(adapter->erp_ready_wq,
759 !list_empty(&adapter->erp_ready_head));
760 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
763 if (!(atomic_read(&adapter->status) &
764 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
771 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
774 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
775 return ZFCP_ERP_FAILED;
777 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
778 zfcp_erp_enqueue_ptp_port(adapter);
780 return ZFCP_ERP_SUCCEEDED;
783 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
786 struct zfcp_adapter *adapter = act->adapter;
788 write_lock_irq(&adapter->erp_lock);
789 zfcp_erp_action_to_running(act);
790 write_unlock_irq(&adapter->erp_lock);
792 ret = zfcp_fsf_exchange_port_data(act);
793 if (ret == -EOPNOTSUPP)
794 return ZFCP_ERP_SUCCEEDED;
796 return ZFCP_ERP_FAILED;
798 zfcp_dbf_rec_run("erasox1", act);
799 wait_event(adapter->erp_ready_wq,
800 !list_empty(&adapter->erp_ready_head));
801 zfcp_dbf_rec_run("erasox2", act);
802 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
803 return ZFCP_ERP_FAILED;
805 return ZFCP_ERP_SUCCEEDED;
808 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
810 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
811 return ZFCP_ERP_FAILED;
813 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
814 return ZFCP_ERP_FAILED;
816 if (mempool_resize(act->adapter->pool.sr_data,
817 act->adapter->stat_read_buf_num))
818 return ZFCP_ERP_FAILED;
820 if (mempool_resize(act->adapter->pool.status_read_req,
821 act->adapter->stat_read_buf_num))
822 return ZFCP_ERP_FAILED;
824 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
825 if (zfcp_status_read_refill(act->adapter))
826 return ZFCP_ERP_FAILED;
828 return ZFCP_ERP_SUCCEEDED;
831 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
833 struct zfcp_adapter *adapter = act->adapter;
835 /* close queues to ensure that buffers are not accessed by adapter */
836 zfcp_qdio_close(adapter->qdio);
837 zfcp_fsf_req_dismiss_all(adapter);
838 adapter->fsf_req_seq_no = 0;
839 zfcp_fc_wka_ports_force_offline(adapter->gs);
840 /* all ports and LUNs are closed */
841 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
843 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
844 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
847 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
849 struct zfcp_adapter *adapter = act->adapter;
851 if (zfcp_qdio_open(adapter->qdio)) {
852 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
853 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
855 return ZFCP_ERP_FAILED;
858 if (zfcp_erp_adapter_strategy_open_fsf(act)) {
859 zfcp_erp_adapter_strategy_close(act);
860 return ZFCP_ERP_FAILED;
863 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
865 return ZFCP_ERP_SUCCEEDED;
868 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
870 struct zfcp_adapter *adapter = act->adapter;
872 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
873 zfcp_erp_adapter_strategy_close(act);
874 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
875 return ZFCP_ERP_EXIT;
878 if (zfcp_erp_adapter_strategy_open(act)) {
880 return ZFCP_ERP_FAILED;
883 return ZFCP_ERP_SUCCEEDED;
886 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
890 retval = zfcp_fsf_close_physical_port(act);
891 if (retval == -ENOMEM)
892 return ZFCP_ERP_NOMEM;
893 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
895 return ZFCP_ERP_FAILED;
897 return ZFCP_ERP_CONTINUES;
900 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
902 struct zfcp_port *port = erp_action->port;
903 int status = atomic_read(&port->status);
905 switch (erp_action->step) {
906 case ZFCP_ERP_STEP_UNINITIALIZED:
907 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
908 (status & ZFCP_STATUS_COMMON_OPEN))
909 return zfcp_erp_port_forced_strategy_close(erp_action);
911 return ZFCP_ERP_FAILED;
913 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
914 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
915 return ZFCP_ERP_SUCCEEDED;
917 return ZFCP_ERP_FAILED;
920 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
924 retval = zfcp_fsf_close_port(erp_action);
925 if (retval == -ENOMEM)
926 return ZFCP_ERP_NOMEM;
927 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
929 return ZFCP_ERP_FAILED;
930 return ZFCP_ERP_CONTINUES;
933 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
937 retval = zfcp_fsf_open_port(erp_action);
938 if (retval == -ENOMEM)
939 return ZFCP_ERP_NOMEM;
940 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
942 return ZFCP_ERP_FAILED;
943 return ZFCP_ERP_CONTINUES;
946 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
948 struct zfcp_adapter *adapter = act->adapter;
949 struct zfcp_port *port = act->port;
951 if (port->wwpn != adapter->peer_wwpn) {
952 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
953 return ZFCP_ERP_FAILED;
955 port->d_id = adapter->peer_d_id;
956 return zfcp_erp_port_strategy_open_port(act);
959 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
961 struct zfcp_adapter *adapter = act->adapter;
962 struct zfcp_port *port = act->port;
963 int p_status = atomic_read(&port->status);
966 case ZFCP_ERP_STEP_UNINITIALIZED:
967 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
968 case ZFCP_ERP_STEP_PORT_CLOSING:
969 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
970 return zfcp_erp_open_ptp_port(act);
972 zfcp_fc_trigger_did_lookup(port);
973 return ZFCP_ERP_EXIT;
975 return zfcp_erp_port_strategy_open_port(act);
977 case ZFCP_ERP_STEP_PORT_OPENING:
978 /* D_ID might have changed during open */
979 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
981 zfcp_fc_trigger_did_lookup(port);
982 return ZFCP_ERP_EXIT;
984 return ZFCP_ERP_SUCCEEDED;
986 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
988 return ZFCP_ERP_FAILED;
990 /* fall through otherwise */
992 return ZFCP_ERP_FAILED;
995 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
997 struct zfcp_port *port = erp_action->port;
998 int p_status = atomic_read(&port->status);
1000 if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
1001 !(p_status & ZFCP_STATUS_COMMON_OPEN))
1002 goto close_init_done;
1004 switch (erp_action->step) {
1005 case ZFCP_ERP_STEP_UNINITIALIZED:
1006 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1007 return zfcp_erp_port_strategy_close(erp_action);
1010 case ZFCP_ERP_STEP_PORT_CLOSING:
1011 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1012 return ZFCP_ERP_FAILED;
1017 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1018 return ZFCP_ERP_EXIT;
1020 return zfcp_erp_port_strategy_open_common(erp_action);
1023 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
1025 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1027 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
1028 &zfcp_sdev->status);
1031 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
1033 int retval = zfcp_fsf_close_lun(erp_action);
1034 if (retval == -ENOMEM)
1035 return ZFCP_ERP_NOMEM;
1036 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
1038 return ZFCP_ERP_FAILED;
1039 return ZFCP_ERP_CONTINUES;
1042 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
1044 int retval = zfcp_fsf_open_lun(erp_action);
1045 if (retval == -ENOMEM)
1046 return ZFCP_ERP_NOMEM;
1047 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
1049 return ZFCP_ERP_FAILED;
1050 return ZFCP_ERP_CONTINUES;
1053 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
1055 struct scsi_device *sdev = erp_action->sdev;
1056 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1058 switch (erp_action->step) {
1059 case ZFCP_ERP_STEP_UNINITIALIZED:
1060 zfcp_erp_lun_strategy_clearstati(sdev);
1061 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1062 return zfcp_erp_lun_strategy_close(erp_action);
1063 /* already closed, fall through */
1064 case ZFCP_ERP_STEP_LUN_CLOSING:
1065 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1066 return ZFCP_ERP_FAILED;
1067 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1068 return ZFCP_ERP_EXIT;
1069 return zfcp_erp_lun_strategy_open(erp_action);
1071 case ZFCP_ERP_STEP_LUN_OPENING:
1072 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1073 return ZFCP_ERP_SUCCEEDED;
1075 return ZFCP_ERP_FAILED;
1078 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
1080 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1083 case ZFCP_ERP_SUCCEEDED :
1084 atomic_set(&zfcp_sdev->erp_counter, 0);
1085 zfcp_erp_lun_unblock(sdev);
1087 case ZFCP_ERP_FAILED :
1088 atomic_inc(&zfcp_sdev->erp_counter);
1089 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1090 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1091 "ERP failed for LUN 0x%016Lx on "
1093 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1094 (unsigned long long)zfcp_sdev->port->wwpn);
1095 zfcp_erp_set_lun_status(sdev,
1096 ZFCP_STATUS_COMMON_ERP_FAILED);
1101 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1102 zfcp_erp_lun_block(sdev, 0);
1103 result = ZFCP_ERP_EXIT;
1108 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1111 case ZFCP_ERP_SUCCEEDED :
1112 atomic_set(&port->erp_counter, 0);
1113 zfcp_erp_port_unblock(port);
1116 case ZFCP_ERP_FAILED :
1117 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1118 zfcp_erp_port_block(port, 0);
1119 result = ZFCP_ERP_EXIT;
1121 atomic_inc(&port->erp_counter);
1122 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1123 dev_err(&port->adapter->ccw_device->dev,
1124 "ERP failed for remote port 0x%016Lx\n",
1125 (unsigned long long)port->wwpn);
1126 zfcp_erp_set_port_status(port,
1127 ZFCP_STATUS_COMMON_ERP_FAILED);
1132 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1133 zfcp_erp_port_block(port, 0);
1134 result = ZFCP_ERP_EXIT;
1139 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1143 case ZFCP_ERP_SUCCEEDED :
1144 atomic_set(&adapter->erp_counter, 0);
1145 zfcp_erp_adapter_unblock(adapter);
1148 case ZFCP_ERP_FAILED :
1149 atomic_inc(&adapter->erp_counter);
1150 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1151 dev_err(&adapter->ccw_device->dev,
1152 "ERP cannot recover an error "
1153 "on the FCP device\n");
1154 zfcp_erp_set_adapter_status(adapter,
1155 ZFCP_STATUS_COMMON_ERP_FAILED);
1160 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1161 zfcp_erp_adapter_block(adapter, 0);
1162 result = ZFCP_ERP_EXIT;
1167 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1170 struct zfcp_adapter *adapter = erp_action->adapter;
1171 struct zfcp_port *port = erp_action->port;
1172 struct scsi_device *sdev = erp_action->sdev;
1174 switch (erp_action->action) {
1176 case ZFCP_ERP_ACTION_REOPEN_LUN:
1177 result = zfcp_erp_strategy_check_lun(sdev, result);
1180 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1181 case ZFCP_ERP_ACTION_REOPEN_PORT:
1182 result = zfcp_erp_strategy_check_port(port, result);
1185 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1186 result = zfcp_erp_strategy_check_adapter(adapter, result);
1192 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1194 int status = atomic_read(target_status);
1196 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1197 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1198 return 1; /* take it online */
1200 if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1201 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1202 return 1; /* take it offline */
1207 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1209 int action = act->action;
1210 struct zfcp_adapter *adapter = act->adapter;
1211 struct zfcp_port *port = act->port;
1212 struct scsi_device *sdev = act->sdev;
1213 struct zfcp_scsi_dev *zfcp_sdev;
1214 u32 erp_status = act->status;
1217 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1218 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1219 _zfcp_erp_adapter_reopen(adapter,
1220 ZFCP_STATUS_COMMON_ERP_FAILED,
1222 return ZFCP_ERP_EXIT;
1226 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1227 case ZFCP_ERP_ACTION_REOPEN_PORT:
1228 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1229 _zfcp_erp_port_reopen(port,
1230 ZFCP_STATUS_COMMON_ERP_FAILED,
1232 return ZFCP_ERP_EXIT;
1236 case ZFCP_ERP_ACTION_REOPEN_LUN:
1237 zfcp_sdev = sdev_to_zfcp(sdev);
1238 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1239 _zfcp_erp_lun_reopen(sdev,
1240 ZFCP_STATUS_COMMON_ERP_FAILED,
1242 return ZFCP_ERP_EXIT;
1249 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1251 struct zfcp_adapter *adapter = erp_action->adapter;
1252 struct zfcp_scsi_dev *zfcp_sdev;
1254 adapter->erp_total_count--;
1255 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1256 adapter->erp_low_mem_count--;
1257 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1260 list_del(&erp_action->list);
1261 zfcp_dbf_rec_run("eractd1", erp_action);
1263 switch (erp_action->action) {
1264 case ZFCP_ERP_ACTION_REOPEN_LUN:
1265 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1266 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1267 &zfcp_sdev->status);
1270 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1271 case ZFCP_ERP_ACTION_REOPEN_PORT:
1272 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1273 &erp_action->port->status);
1276 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1277 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1278 &erp_action->adapter->status);
1284 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1285 * @port: zfcp_port whose fc_rport we should try to unblock
1287 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
1289 unsigned long flags;
1290 struct zfcp_adapter *adapter = port->adapter;
1292 struct Scsi_Host *shost = adapter->scsi_host;
1293 struct scsi_device *sdev;
1295 write_lock_irqsave(&adapter->erp_lock, flags);
1296 port_status = atomic_read(&port->status);
1297 if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1298 (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
1299 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
1300 /* new ERP of severity >= port triggered elsewhere meanwhile or
1301 * local link down (adapter erp_failed but not clear unblock)
1303 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
1304 write_unlock_irqrestore(&adapter->erp_lock, flags);
1307 spin_lock(shost->host_lock);
1308 __shost_for_each_device(sdev, shost) {
1309 struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
1312 if (zsdev->port != port)
1314 /* LUN under port of interest */
1315 lun_status = atomic_read(&zsdev->status);
1316 if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
1317 continue; /* unblock rport despite failed LUNs */
1318 /* LUN recovery not given up yet [maybe follow-up pending] */
1319 if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1320 (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
1322 * not yet unblocked [LUN recovery pending]
1323 * or meanwhile blocked [new LUN recovery triggered]
1325 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
1326 spin_unlock(shost->host_lock);
1327 write_unlock_irqrestore(&adapter->erp_lock, flags);
1331 /* now port has no child or all children have completed recovery,
1332 * and no ERP of severity >= port was meanwhile triggered elsewhere
1334 zfcp_scsi_schedule_rport_register(port);
1335 spin_unlock(shost->host_lock);
1336 write_unlock_irqrestore(&adapter->erp_lock, flags);
1339 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1341 struct zfcp_adapter *adapter = act->adapter;
1342 struct zfcp_port *port = act->port;
1343 struct scsi_device *sdev = act->sdev;
1345 switch (act->action) {
1346 case ZFCP_ERP_ACTION_REOPEN_LUN:
1347 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1348 scsi_device_put(sdev);
1349 zfcp_erp_try_rport_unblock(port);
1352 case ZFCP_ERP_ACTION_REOPEN_PORT:
1353 /* This switch case might also happen after a forced reopen
1354 * was successfully done and thus overwritten with a new
1355 * non-forced reopen at `ersfs_2'. In this case, we must not
1356 * do the clean-up of the non-forced version.
1358 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
1359 if (result == ZFCP_ERP_SUCCEEDED)
1360 zfcp_erp_try_rport_unblock(port);
1362 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1363 put_device(&port->dev);
1366 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1367 if (result == ZFCP_ERP_SUCCEEDED) {
1368 register_service_level(&adapter->service_level);
1369 zfcp_fc_conditional_port_scan(adapter);
1370 queue_work(adapter->work_queue, &adapter->ns_up_work);
1372 unregister_service_level(&adapter->service_level);
1374 kref_put(&adapter->ref, zfcp_adapter_release);
1379 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1381 switch (erp_action->action) {
1382 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1383 return zfcp_erp_adapter_strategy(erp_action);
1384 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1385 return zfcp_erp_port_forced_strategy(erp_action);
1386 case ZFCP_ERP_ACTION_REOPEN_PORT:
1387 return zfcp_erp_port_strategy(erp_action);
1388 case ZFCP_ERP_ACTION_REOPEN_LUN:
1389 return zfcp_erp_lun_strategy(erp_action);
1391 return ZFCP_ERP_FAILED;
1394 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1397 unsigned long flags;
1398 struct zfcp_adapter *adapter = erp_action->adapter;
1400 kref_get(&adapter->ref);
1402 write_lock_irqsave(&adapter->erp_lock, flags);
1403 zfcp_erp_strategy_check_fsfreq(erp_action);
1405 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1406 zfcp_erp_action_dequeue(erp_action);
1407 retval = ZFCP_ERP_DISMISSED;
1411 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1412 retval = ZFCP_ERP_FAILED;
1416 zfcp_erp_action_to_running(erp_action);
1418 /* no lock to allow for blocking operations */
1419 write_unlock_irqrestore(&adapter->erp_lock, flags);
1420 retval = zfcp_erp_strategy_do_action(erp_action);
1421 write_lock_irqsave(&adapter->erp_lock, flags);
1423 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1424 retval = ZFCP_ERP_CONTINUES;
1427 case ZFCP_ERP_NOMEM:
1428 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1429 ++adapter->erp_low_mem_count;
1430 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1432 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1433 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1435 zfcp_erp_strategy_memwait(erp_action);
1436 retval = ZFCP_ERP_CONTINUES;
1440 case ZFCP_ERP_CONTINUES:
1441 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1442 --adapter->erp_low_mem_count;
1443 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1449 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1450 zfcp_erp_action_dequeue(erp_action);
1451 retval = zfcp_erp_strategy_statechange(erp_action, retval);
1452 if (retval == ZFCP_ERP_EXIT)
1454 if (retval == ZFCP_ERP_SUCCEEDED)
1455 zfcp_erp_strategy_followup_success(erp_action);
1456 if (retval == ZFCP_ERP_FAILED)
1457 zfcp_erp_strategy_followup_failed(erp_action);
1460 write_unlock_irqrestore(&adapter->erp_lock, flags);
1462 if (retval != ZFCP_ERP_CONTINUES)
1463 zfcp_erp_action_cleanup(erp_action, retval);
1465 kref_put(&adapter->ref, zfcp_adapter_release);
1469 static int zfcp_erp_thread(void *data)
1471 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1472 struct list_head *next;
1473 struct zfcp_erp_action *act;
1474 unsigned long flags;
1477 wait_event_interruptible(adapter->erp_ready_wq,
1478 !list_empty(&adapter->erp_ready_head) ||
1479 kthread_should_stop());
1481 if (kthread_should_stop())
1484 write_lock_irqsave(&adapter->erp_lock, flags);
1485 next = adapter->erp_ready_head.next;
1486 write_unlock_irqrestore(&adapter->erp_lock, flags);
1488 if (next != &adapter->erp_ready_head) {
1489 act = list_entry(next, struct zfcp_erp_action, list);
1491 /* there is more to come after dismission, no notify */
1492 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1493 zfcp_erp_wakeup(adapter);
1501 * zfcp_erp_thread_setup - Start ERP thread for adapter
1502 * @adapter: Adapter to start the ERP thread for
1504 * Returns 0 on success or error code from kernel_thread()
1506 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1508 struct task_struct *thread;
1510 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1511 dev_name(&adapter->ccw_device->dev));
1512 if (IS_ERR(thread)) {
1513 dev_err(&adapter->ccw_device->dev,
1514 "Creating an ERP thread for the FCP device failed.\n");
1515 return PTR_ERR(thread);
1518 adapter->erp_thread = thread;
1523 * zfcp_erp_thread_kill - Stop ERP thread.
1524 * @adapter: Adapter where the ERP thread should be stopped.
1526 * The caller of this routine ensures that the specified adapter has
1527 * been shut down and that this operation has been completed. Thus,
1528 * there are no pending erp_actions which would need to be handled
1531 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1533 kthread_stop(adapter->erp_thread);
1534 adapter->erp_thread = NULL;
1535 WARN_ON(!list_empty(&adapter->erp_ready_head));
1536 WARN_ON(!list_empty(&adapter->erp_running_head));
1540 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1541 * @adapter: adapter for which to wait for completion of its error recovery
1543 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1545 wait_event(adapter->erp_done_wqh,
1546 !(atomic_read(&adapter->status) &
1547 ZFCP_STATUS_ADAPTER_ERP_PENDING));
1551 * zfcp_erp_set_adapter_status - set adapter status bits
1552 * @adapter: adapter to change the status
1553 * @mask: status bits to change
1555 * Changes in common status bits are propagated to attached ports and LUNs.
1557 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1559 struct zfcp_port *port;
1560 struct scsi_device *sdev;
1561 unsigned long flags;
1562 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1564 atomic_or(mask, &adapter->status);
1569 read_lock_irqsave(&adapter->port_list_lock, flags);
1570 list_for_each_entry(port, &adapter->port_list, list)
1571 atomic_or(common_mask, &port->status);
1572 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1574 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1575 __shost_for_each_device(sdev, adapter->scsi_host)
1576 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1577 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1581 * zfcp_erp_clear_adapter_status - clear adapter status bits
1582 * @adapter: adapter to change the status
1583 * @mask: status bits to change
1585 * Changes in common status bits are propagated to attached ports and LUNs.
1587 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1589 struct zfcp_port *port;
1590 struct scsi_device *sdev;
1591 unsigned long flags;
1592 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1593 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1595 atomic_andnot(mask, &adapter->status);
1601 atomic_set(&adapter->erp_counter, 0);
1603 read_lock_irqsave(&adapter->port_list_lock, flags);
1604 list_for_each_entry(port, &adapter->port_list, list) {
1605 atomic_andnot(common_mask, &port->status);
1607 atomic_set(&port->erp_counter, 0);
1609 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1611 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1612 __shost_for_each_device(sdev, adapter->scsi_host) {
1613 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1615 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1617 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1621 * zfcp_erp_set_port_status - set port status bits
1622 * @port: port to change the status
1623 * @mask: status bits to change
1625 * Changes in common status bits are propagated to attached LUNs.
1627 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1629 struct scsi_device *sdev;
1630 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1631 unsigned long flags;
1633 atomic_or(mask, &port->status);
1638 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1639 __shost_for_each_device(sdev, port->adapter->scsi_host)
1640 if (sdev_to_zfcp(sdev)->port == port)
1641 atomic_or(common_mask,
1642 &sdev_to_zfcp(sdev)->status);
1643 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1647 * zfcp_erp_clear_port_status - clear port status bits
1648 * @port: adapter to change the status
1649 * @mask: status bits to change
1651 * Changes in common status bits are propagated to attached LUNs.
1653 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1655 struct scsi_device *sdev;
1656 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1657 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1658 unsigned long flags;
1660 atomic_andnot(mask, &port->status);
1666 atomic_set(&port->erp_counter, 0);
1668 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1669 __shost_for_each_device(sdev, port->adapter->scsi_host)
1670 if (sdev_to_zfcp(sdev)->port == port) {
1671 atomic_andnot(common_mask,
1672 &sdev_to_zfcp(sdev)->status);
1674 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1676 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1680 * zfcp_erp_set_lun_status - set lun status bits
1681 * @sdev: SCSI device / lun to set the status bits
1682 * @mask: status bits to change
1684 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1686 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1688 atomic_or(mask, &zfcp_sdev->status);
1692 * zfcp_erp_clear_lun_status - clear lun status bits
1693 * @sdev: SCSi device / lun to clear the status bits
1694 * @mask: status bits to change
1696 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1698 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1700 atomic_andnot(mask, &zfcp_sdev->status);
1702 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1703 atomic_set(&zfcp_sdev->erp_counter, 0);