4 * Error Recovery Procedures (ERP).
6 * Copyright IBM Corporation 2002, 2010
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/kthread.h>
14 #include "zfcp_reqlist.h"
16 #define ZFCP_MAX_ERPS 3
18 enum zfcp_erp_act_flags {
19 ZFCP_STATUS_ERP_TIMEDOUT = 0x10000000,
20 ZFCP_STATUS_ERP_CLOSE_ONLY = 0x01000000,
21 ZFCP_STATUS_ERP_DISMISSING = 0x00100000,
22 ZFCP_STATUS_ERP_DISMISSED = 0x00200000,
23 ZFCP_STATUS_ERP_LOWMEM = 0x00400000,
24 ZFCP_STATUS_ERP_NO_REF = 0x00800000,
28 ZFCP_ERP_STEP_UNINITIALIZED = 0x0000,
29 ZFCP_ERP_STEP_FSF_XCONFIG = 0x0001,
30 ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
31 ZFCP_ERP_STEP_PORT_CLOSING = 0x0100,
32 ZFCP_ERP_STEP_PORT_OPENING = 0x0800,
33 ZFCP_ERP_STEP_LUN_CLOSING = 0x1000,
34 ZFCP_ERP_STEP_LUN_OPENING = 0x2000,
37 enum zfcp_erp_act_type {
38 ZFCP_ERP_ACTION_REOPEN_LUN = 1,
39 ZFCP_ERP_ACTION_REOPEN_PORT = 2,
40 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
41 ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4,
44 enum zfcp_erp_act_state {
45 ZFCP_ERP_ACTION_RUNNING = 1,
46 ZFCP_ERP_ACTION_READY = 2,
49 enum zfcp_erp_act_result {
50 ZFCP_ERP_SUCCEEDED = 0,
52 ZFCP_ERP_CONTINUES = 2,
54 ZFCP_ERP_DISMISSED = 4,
58 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
60 zfcp_erp_clear_adapter_status(adapter,
61 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
64 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
66 struct zfcp_erp_action *curr_act;
68 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
70 return ZFCP_ERP_ACTION_RUNNING;
74 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
76 struct zfcp_adapter *adapter = act->adapter;
78 list_move(&act->list, &act->adapter->erp_ready_head);
79 zfcp_dbf_rec_action("erardy1", act);
80 wake_up(&adapter->erp_ready_wq);
81 zfcp_dbf_rec_thread("erardy2", adapter->dbf);
84 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
86 act->status |= ZFCP_STATUS_ERP_DISMISSED;
87 if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
88 zfcp_erp_action_ready(act);
91 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
93 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
95 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
96 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
99 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
101 struct scsi_device *sdev;
103 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
104 zfcp_erp_action_dismiss(&port->erp_action);
106 shost_for_each_device(sdev, port->adapter->scsi_host)
107 if (sdev_to_zfcp(sdev)->port == port)
108 zfcp_erp_action_dismiss_lun(sdev);
111 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
113 struct zfcp_port *port;
115 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
116 zfcp_erp_action_dismiss(&adapter->erp_action);
118 read_lock(&adapter->port_list_lock);
119 list_for_each_entry(port, &adapter->port_list, list)
120 zfcp_erp_action_dismiss_port(port);
121 read_unlock(&adapter->port_list_lock);
125 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
126 struct zfcp_port *port,
127 struct scsi_device *sdev)
130 int l_status, p_status, a_status;
131 struct zfcp_scsi_dev *zfcp_sdev;
134 case ZFCP_ERP_ACTION_REOPEN_LUN:
135 zfcp_sdev = sdev_to_zfcp(sdev);
136 l_status = atomic_read(&zfcp_sdev->status);
137 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
139 p_status = atomic_read(&port->status);
140 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
141 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
143 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
144 need = ZFCP_ERP_ACTION_REOPEN_PORT;
146 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
147 p_status = atomic_read(&port->status);
148 if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
149 need = ZFCP_ERP_ACTION_REOPEN_PORT;
151 case ZFCP_ERP_ACTION_REOPEN_PORT:
152 p_status = atomic_read(&port->status);
153 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
155 a_status = atomic_read(&adapter->status);
156 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
157 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
159 if (p_status & ZFCP_STATUS_COMMON_NOESC)
161 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
162 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
164 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
165 a_status = atomic_read(&adapter->status);
166 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
168 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
169 !(a_status & ZFCP_STATUS_COMMON_OPEN))
170 return 0; /* shutdown requested for closed adapter */
176 static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
177 struct zfcp_adapter *adapter,
178 struct zfcp_port *port,
179 struct scsi_device *sdev)
181 struct zfcp_erp_action *erp_action;
182 struct zfcp_scsi_dev *zfcp_sdev;
185 case ZFCP_ERP_ACTION_REOPEN_LUN:
186 zfcp_sdev = sdev_to_zfcp(sdev);
187 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
188 if (scsi_device_get(sdev))
190 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
192 erp_action = &zfcp_sdev->erp_action;
193 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
194 erp_action->port = port;
195 erp_action->sdev = sdev;
196 if (!(atomic_read(&zfcp_sdev->status) &
197 ZFCP_STATUS_COMMON_RUNNING))
198 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
201 case ZFCP_ERP_ACTION_REOPEN_PORT:
202 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
203 if (!get_device(&port->dev))
205 zfcp_erp_action_dismiss_port(port);
206 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
207 erp_action = &port->erp_action;
208 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
209 erp_action->port = port;
210 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
211 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
214 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
215 kref_get(&adapter->ref);
216 zfcp_erp_action_dismiss_adapter(adapter);
217 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
218 erp_action = &adapter->erp_action;
219 memset(erp_action, 0, sizeof(struct zfcp_erp_action));
220 if (!(atomic_read(&adapter->status) &
221 ZFCP_STATUS_COMMON_RUNNING))
222 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
229 erp_action->adapter = adapter;
230 erp_action->action = need;
231 erp_action->status = act_status;
236 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
237 struct zfcp_port *port,
238 struct scsi_device *sdev,
239 char *id, void *ref, u32 act_status)
241 int retval = 1, need;
242 struct zfcp_erp_action *act = NULL;
244 if (!adapter->erp_thread)
247 need = zfcp_erp_required_act(want, adapter, port, sdev);
251 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
254 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
255 ++adapter->erp_total_count;
256 list_add_tail(&act->list, &adapter->erp_ready_head);
257 wake_up(&adapter->erp_ready_wq);
258 zfcp_dbf_rec_thread("eracte1", adapter->dbf);
261 zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, sdev);
265 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
266 int clear_mask, char *id, void *ref)
268 zfcp_erp_adapter_block(adapter, clear_mask);
269 zfcp_scsi_schedule_rports_block(adapter);
271 /* ensure propagation of failed status to new devices */
272 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
273 zfcp_erp_set_adapter_status(adapter,
274 ZFCP_STATUS_COMMON_ERP_FAILED);
277 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
278 adapter, NULL, NULL, id, ref, 0);
282 * zfcp_erp_adapter_reopen - Reopen adapter.
283 * @adapter: Adapter to reopen.
284 * @clear: Status flags to clear.
285 * @id: Id for debug trace event.
286 * @ref: Reference for debug trace event.
288 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
293 zfcp_erp_adapter_block(adapter, clear);
294 zfcp_scsi_schedule_rports_block(adapter);
296 write_lock_irqsave(&adapter->erp_lock, flags);
297 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
298 zfcp_erp_set_adapter_status(adapter,
299 ZFCP_STATUS_COMMON_ERP_FAILED);
301 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
302 NULL, NULL, id, ref, 0);
303 write_unlock_irqrestore(&adapter->erp_lock, flags);
307 * zfcp_erp_adapter_shutdown - Shutdown adapter.
308 * @adapter: Adapter to shut down.
309 * @clear: Status flags to clear.
310 * @id: Id for debug trace event.
311 * @ref: Reference for debug trace event.
313 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
316 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
317 zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
321 * zfcp_erp_port_shutdown - Shutdown port
322 * @port: Port to shut down.
323 * @clear: Status flags to clear.
324 * @id: Id for debug trace event.
325 * @ref: Reference for debug trace event.
327 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id,
330 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
331 zfcp_erp_port_reopen(port, clear | flags, id, ref);
334 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
336 zfcp_erp_clear_port_status(port,
337 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
340 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
341 int clear, char *id, void *ref)
343 zfcp_erp_port_block(port, clear);
344 zfcp_scsi_schedule_rport_block(port);
346 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
349 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
350 port->adapter, port, NULL, id, ref, 0);
354 * zfcp_erp_port_forced_reopen - Forced close of port and open again
355 * @port: Port to force close and to reopen.
356 * @id: Id for debug trace event.
357 * @ref: Reference for debug trace event.
359 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id,
363 struct zfcp_adapter *adapter = port->adapter;
365 write_lock_irqsave(&adapter->erp_lock, flags);
366 _zfcp_erp_port_forced_reopen(port, clear, id, ref);
367 write_unlock_irqrestore(&adapter->erp_lock, flags);
370 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, ref, 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
391 * Returns 0 if recovery has been triggered, < 0 if not.
393 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref)
397 struct zfcp_adapter *adapter = port->adapter;
399 write_lock_irqsave(&adapter->erp_lock, flags);
400 retval = _zfcp_erp_port_reopen(port, clear, id, ref);
401 write_unlock_irqrestore(&adapter->erp_lock, flags);
406 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
408 zfcp_erp_clear_lun_status(sdev,
409 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
412 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
413 void *ref, u32 act_status)
415 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
416 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
418 zfcp_erp_lun_block(sdev, clear);
420 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
423 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
424 zfcp_sdev->port, sdev, id, ref, act_status);
428 * zfcp_erp_lun_reopen - initiate reopen of a LUN
429 * @sdev: SCSI device / LUN to be reopened
430 * @clear_mask: specifies flags in LUN status to be cleared
431 * Return: 0 on success, < 0 on error
433 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
437 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
438 struct zfcp_port *port = zfcp_sdev->port;
439 struct zfcp_adapter *adapter = port->adapter;
441 write_lock_irqsave(&adapter->erp_lock, flags);
442 _zfcp_erp_lun_reopen(sdev, clear, id, ref, 0);
443 write_unlock_irqrestore(&adapter->erp_lock, flags);
447 * zfcp_erp_lun_shutdown - Shutdown LUN
448 * @sdev: SCSI device / LUN to shut down.
449 * @clear: Status flags to clear.
450 * @id: Id for debug trace event.
451 * @ref: Reference for debug trace event.
453 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, ref);
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, NULL, 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_adapter("eraubl1", NULL, adapter->dbf);
494 atomic_set_mask(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_port("erpubl1", NULL, port);
501 atomic_set_mask(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_lun("erlubl1", NULL, sdev);
510 atomic_set_mask(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_action("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_action("erscf_1", act);
534 req->erp_action = NULL;
536 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
537 zfcp_dbf_rec_action("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 init_timer(&erp_action->timer);
581 erp_action->timer.function = zfcp_erp_memwait_handler;
582 erp_action->timer.data = (unsigned long) erp_action;
583 erp_action->timer.expires = jiffies + HZ;
584 add_timer(&erp_action->timer);
587 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
588 int clear, char *id, void *ref)
590 struct zfcp_port *port;
592 read_lock(&adapter->port_list_lock);
593 list_for_each_entry(port, &adapter->port_list, list)
594 _zfcp_erp_port_reopen(port, clear, id, ref);
595 read_unlock(&adapter->port_list_lock);
598 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
601 struct scsi_device *sdev;
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, ref, 0);
608 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
610 switch (act->action) {
611 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
612 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL);
614 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
615 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL);
617 case ZFCP_ERP_ACTION_REOPEN_PORT:
618 _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL);
620 case ZFCP_ERP_ACTION_REOPEN_LUN:
621 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", NULL, 0);
626 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
628 switch (act->action) {
629 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
630 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL);
632 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
633 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL);
635 case ZFCP_ERP_ACTION_REOPEN_PORT:
636 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3", NULL);
641 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
645 read_lock_irqsave(&adapter->erp_lock, flags);
646 if (list_empty(&adapter->erp_ready_head) &&
647 list_empty(&adapter->erp_running_head)) {
648 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
650 wake_up(&adapter->erp_done_wqh);
652 read_unlock_irqrestore(&adapter->erp_lock, flags);
655 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
657 struct zfcp_qdio *qdio = act->adapter->qdio;
659 if (zfcp_qdio_open(qdio))
660 return ZFCP_ERP_FAILED;
661 init_waitqueue_head(&qdio->req_q_wq);
662 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
663 return ZFCP_ERP_SUCCEEDED;
666 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
668 struct zfcp_port *port;
669 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
671 if (IS_ERR(port)) /* error or port already attached */
673 _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL);
676 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
680 struct zfcp_adapter *adapter = erp_action->adapter;
682 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
684 for (retries = 7; retries; retries--) {
685 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
687 write_lock_irq(&adapter->erp_lock);
688 zfcp_erp_action_to_running(erp_action);
689 write_unlock_irq(&adapter->erp_lock);
690 if (zfcp_fsf_exchange_config_data(erp_action)) {
691 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
693 return ZFCP_ERP_FAILED;
696 zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
697 wait_event(adapter->erp_ready_wq,
698 !list_empty(&adapter->erp_ready_head));
699 zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
700 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
703 if (!(atomic_read(&adapter->status) &
704 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
711 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
714 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
715 return ZFCP_ERP_FAILED;
717 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
718 zfcp_erp_enqueue_ptp_port(adapter);
720 return ZFCP_ERP_SUCCEEDED;
723 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
726 struct zfcp_adapter *adapter = act->adapter;
728 write_lock_irq(&adapter->erp_lock);
729 zfcp_erp_action_to_running(act);
730 write_unlock_irq(&adapter->erp_lock);
732 ret = zfcp_fsf_exchange_port_data(act);
733 if (ret == -EOPNOTSUPP)
734 return ZFCP_ERP_SUCCEEDED;
736 return ZFCP_ERP_FAILED;
738 zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf);
739 wait_event(adapter->erp_ready_wq,
740 !list_empty(&adapter->erp_ready_head));
741 zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf);
742 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
743 return ZFCP_ERP_FAILED;
745 return ZFCP_ERP_SUCCEEDED;
748 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
750 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
751 return ZFCP_ERP_FAILED;
753 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
754 return ZFCP_ERP_FAILED;
756 if (mempool_resize(act->adapter->pool.status_read_data,
757 act->adapter->stat_read_buf_num, GFP_KERNEL))
758 return ZFCP_ERP_FAILED;
760 if (mempool_resize(act->adapter->pool.status_read_req,
761 act->adapter->stat_read_buf_num, GFP_KERNEL))
762 return ZFCP_ERP_FAILED;
764 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
765 if (zfcp_status_read_refill(act->adapter))
766 return ZFCP_ERP_FAILED;
768 return ZFCP_ERP_SUCCEEDED;
771 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
773 struct zfcp_adapter *adapter = act->adapter;
775 /* close queues to ensure that buffers are not accessed by adapter */
776 zfcp_qdio_close(adapter->qdio);
777 zfcp_fsf_req_dismiss_all(adapter);
778 adapter->fsf_req_seq_no = 0;
779 zfcp_fc_wka_ports_force_offline(adapter->gs);
780 /* all ports and LUNs are closed */
781 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
783 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
784 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
787 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
789 struct zfcp_adapter *adapter = act->adapter;
791 if (zfcp_erp_adapter_strategy_open_qdio(act)) {
792 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
793 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
795 return ZFCP_ERP_FAILED;
798 if (zfcp_erp_adapter_strategy_open_fsf(act)) {
799 zfcp_erp_adapter_strategy_close(act);
800 return ZFCP_ERP_FAILED;
803 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
805 return ZFCP_ERP_SUCCEEDED;
808 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
810 struct zfcp_adapter *adapter = act->adapter;
812 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
813 zfcp_erp_adapter_strategy_close(act);
814 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
815 return ZFCP_ERP_EXIT;
818 if (zfcp_erp_adapter_strategy_open(act)) {
820 return ZFCP_ERP_FAILED;
823 return ZFCP_ERP_SUCCEEDED;
826 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
830 retval = zfcp_fsf_close_physical_port(act);
831 if (retval == -ENOMEM)
832 return ZFCP_ERP_NOMEM;
833 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
835 return ZFCP_ERP_FAILED;
837 return ZFCP_ERP_CONTINUES;
840 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
842 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status);
845 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
847 struct zfcp_port *port = erp_action->port;
848 int status = atomic_read(&port->status);
850 switch (erp_action->step) {
851 case ZFCP_ERP_STEP_UNINITIALIZED:
852 zfcp_erp_port_strategy_clearstati(port);
853 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
854 (status & ZFCP_STATUS_COMMON_OPEN))
855 return zfcp_erp_port_forced_strategy_close(erp_action);
857 return ZFCP_ERP_FAILED;
859 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
860 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
861 return ZFCP_ERP_SUCCEEDED;
863 return ZFCP_ERP_FAILED;
866 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
870 retval = zfcp_fsf_close_port(erp_action);
871 if (retval == -ENOMEM)
872 return ZFCP_ERP_NOMEM;
873 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
875 return ZFCP_ERP_FAILED;
876 return ZFCP_ERP_CONTINUES;
879 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
883 retval = zfcp_fsf_open_port(erp_action);
884 if (retval == -ENOMEM)
885 return ZFCP_ERP_NOMEM;
886 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
888 return ZFCP_ERP_FAILED;
889 return ZFCP_ERP_CONTINUES;
892 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
894 struct zfcp_adapter *adapter = act->adapter;
895 struct zfcp_port *port = act->port;
897 if (port->wwpn != adapter->peer_wwpn) {
898 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
899 return ZFCP_ERP_FAILED;
901 port->d_id = adapter->peer_d_id;
902 return zfcp_erp_port_strategy_open_port(act);
905 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
907 struct zfcp_adapter *adapter = act->adapter;
908 struct zfcp_port *port = act->port;
909 int p_status = atomic_read(&port->status);
912 case ZFCP_ERP_STEP_UNINITIALIZED:
913 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
914 case ZFCP_ERP_STEP_PORT_CLOSING:
915 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
916 return zfcp_erp_open_ptp_port(act);
918 zfcp_fc_trigger_did_lookup(port);
919 return ZFCP_ERP_EXIT;
921 return zfcp_erp_port_strategy_open_port(act);
923 case ZFCP_ERP_STEP_PORT_OPENING:
924 /* D_ID might have changed during open */
925 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
927 zfcp_fc_trigger_did_lookup(port);
928 return ZFCP_ERP_EXIT;
930 return ZFCP_ERP_SUCCEEDED;
932 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
934 return ZFCP_ERP_FAILED;
936 /* fall through otherwise */
938 return ZFCP_ERP_FAILED;
941 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
943 struct zfcp_port *port = erp_action->port;
944 int p_status = atomic_read(&port->status);
946 if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
947 !(p_status & ZFCP_STATUS_COMMON_OPEN))
948 goto close_init_done;
950 switch (erp_action->step) {
951 case ZFCP_ERP_STEP_UNINITIALIZED:
952 zfcp_erp_port_strategy_clearstati(port);
953 if (p_status & ZFCP_STATUS_COMMON_OPEN)
954 return zfcp_erp_port_strategy_close(erp_action);
957 case ZFCP_ERP_STEP_PORT_CLOSING:
958 if (p_status & ZFCP_STATUS_COMMON_OPEN)
959 return ZFCP_ERP_FAILED;
964 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
965 return ZFCP_ERP_EXIT;
967 return zfcp_erp_port_strategy_open_common(erp_action);
970 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
972 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
974 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
975 ZFCP_STATUS_LUN_SHARED | ZFCP_STATUS_LUN_READONLY,
979 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
981 int retval = zfcp_fsf_close_lun(erp_action);
982 if (retval == -ENOMEM)
983 return ZFCP_ERP_NOMEM;
984 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
986 return ZFCP_ERP_FAILED;
987 return ZFCP_ERP_CONTINUES;
990 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
992 int retval = zfcp_fsf_open_lun(erp_action);
993 if (retval == -ENOMEM)
994 return ZFCP_ERP_NOMEM;
995 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
997 return ZFCP_ERP_FAILED;
998 return ZFCP_ERP_CONTINUES;
1001 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
1003 struct scsi_device *sdev = erp_action->sdev;
1004 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1006 switch (erp_action->step) {
1007 case ZFCP_ERP_STEP_UNINITIALIZED:
1008 zfcp_erp_lun_strategy_clearstati(sdev);
1009 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1010 return zfcp_erp_lun_strategy_close(erp_action);
1011 /* already closed, fall through */
1012 case ZFCP_ERP_STEP_LUN_CLOSING:
1013 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1014 return ZFCP_ERP_FAILED;
1015 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1016 return ZFCP_ERP_EXIT;
1017 return zfcp_erp_lun_strategy_open(erp_action);
1019 case ZFCP_ERP_STEP_LUN_OPENING:
1020 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1021 return ZFCP_ERP_SUCCEEDED;
1023 return ZFCP_ERP_FAILED;
1026 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
1028 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1031 case ZFCP_ERP_SUCCEEDED :
1032 atomic_set(&zfcp_sdev->erp_counter, 0);
1033 zfcp_erp_lun_unblock(sdev);
1035 case ZFCP_ERP_FAILED :
1036 atomic_inc(&zfcp_sdev->erp_counter);
1037 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1038 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1039 "ERP failed for LUN 0x%016Lx on "
1041 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1042 (unsigned long long)zfcp_sdev->port->wwpn);
1043 zfcp_erp_set_lun_status(sdev,
1044 ZFCP_STATUS_COMMON_ERP_FAILED);
1049 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1050 zfcp_erp_lun_block(sdev, 0);
1051 result = ZFCP_ERP_EXIT;
1056 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1059 case ZFCP_ERP_SUCCEEDED :
1060 atomic_set(&port->erp_counter, 0);
1061 zfcp_erp_port_unblock(port);
1064 case ZFCP_ERP_FAILED :
1065 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1066 zfcp_erp_port_block(port, 0);
1067 result = ZFCP_ERP_EXIT;
1069 atomic_inc(&port->erp_counter);
1070 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1071 dev_err(&port->adapter->ccw_device->dev,
1072 "ERP failed for remote port 0x%016Lx\n",
1073 (unsigned long long)port->wwpn);
1074 zfcp_erp_set_port_status(port,
1075 ZFCP_STATUS_COMMON_ERP_FAILED);
1080 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1081 zfcp_erp_port_block(port, 0);
1082 result = ZFCP_ERP_EXIT;
1087 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1091 case ZFCP_ERP_SUCCEEDED :
1092 atomic_set(&adapter->erp_counter, 0);
1093 zfcp_erp_adapter_unblock(adapter);
1096 case ZFCP_ERP_FAILED :
1097 atomic_inc(&adapter->erp_counter);
1098 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1099 dev_err(&adapter->ccw_device->dev,
1100 "ERP cannot recover an error "
1101 "on the FCP device\n");
1102 zfcp_erp_set_adapter_status(adapter,
1103 ZFCP_STATUS_COMMON_ERP_FAILED);
1108 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1109 zfcp_erp_adapter_block(adapter, 0);
1110 result = ZFCP_ERP_EXIT;
1115 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1118 struct zfcp_adapter *adapter = erp_action->adapter;
1119 struct zfcp_port *port = erp_action->port;
1120 struct scsi_device *sdev = erp_action->sdev;
1122 switch (erp_action->action) {
1124 case ZFCP_ERP_ACTION_REOPEN_LUN:
1125 result = zfcp_erp_strategy_check_lun(sdev, result);
1128 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1129 case ZFCP_ERP_ACTION_REOPEN_PORT:
1130 result = zfcp_erp_strategy_check_port(port, result);
1133 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1134 result = zfcp_erp_strategy_check_adapter(adapter, result);
1140 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1142 int status = atomic_read(target_status);
1144 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1145 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1146 return 1; /* take it online */
1148 if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1149 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1150 return 1; /* take it offline */
1155 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1157 int action = act->action;
1158 struct zfcp_adapter *adapter = act->adapter;
1159 struct zfcp_port *port = act->port;
1160 struct scsi_device *sdev = act->sdev;
1161 struct zfcp_scsi_dev *zfcp_sdev;
1162 u32 erp_status = act->status;
1165 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1166 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1167 _zfcp_erp_adapter_reopen(adapter,
1168 ZFCP_STATUS_COMMON_ERP_FAILED,
1170 return ZFCP_ERP_EXIT;
1174 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1175 case ZFCP_ERP_ACTION_REOPEN_PORT:
1176 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1177 _zfcp_erp_port_reopen(port,
1178 ZFCP_STATUS_COMMON_ERP_FAILED,
1180 return ZFCP_ERP_EXIT;
1184 case ZFCP_ERP_ACTION_REOPEN_LUN:
1185 zfcp_sdev = sdev_to_zfcp(sdev);
1186 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1187 _zfcp_erp_lun_reopen(sdev,
1188 ZFCP_STATUS_COMMON_ERP_FAILED,
1189 "ersscg3", NULL, 0);
1190 return ZFCP_ERP_EXIT;
1197 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1199 struct zfcp_adapter *adapter = erp_action->adapter;
1200 struct zfcp_scsi_dev *zfcp_sdev;
1202 adapter->erp_total_count--;
1203 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1204 adapter->erp_low_mem_count--;
1205 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1208 list_del(&erp_action->list);
1209 zfcp_dbf_rec_action("eractd1", erp_action);
1211 switch (erp_action->action) {
1212 case ZFCP_ERP_ACTION_REOPEN_LUN:
1213 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1214 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1215 &zfcp_sdev->status);
1218 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1219 case ZFCP_ERP_ACTION_REOPEN_PORT:
1220 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1221 &erp_action->port->status);
1224 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1225 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1226 &erp_action->adapter->status);
1231 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1233 struct zfcp_adapter *adapter = act->adapter;
1234 struct zfcp_port *port = act->port;
1235 struct scsi_device *sdev = act->sdev;
1237 switch (act->action) {
1238 case ZFCP_ERP_ACTION_REOPEN_LUN:
1239 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1240 scsi_device_put(sdev);
1243 case ZFCP_ERP_ACTION_REOPEN_PORT:
1244 if (result == ZFCP_ERP_SUCCEEDED)
1245 zfcp_scsi_schedule_rport_register(port);
1247 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1248 put_device(&port->dev);
1251 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1252 if (result == ZFCP_ERP_SUCCEEDED) {
1253 register_service_level(&adapter->service_level);
1254 queue_work(adapter->work_queue, &adapter->scan_work);
1256 unregister_service_level(&adapter->service_level);
1257 kref_put(&adapter->ref, zfcp_adapter_release);
1262 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1264 switch (erp_action->action) {
1265 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1266 return zfcp_erp_adapter_strategy(erp_action);
1267 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1268 return zfcp_erp_port_forced_strategy(erp_action);
1269 case ZFCP_ERP_ACTION_REOPEN_PORT:
1270 return zfcp_erp_port_strategy(erp_action);
1271 case ZFCP_ERP_ACTION_REOPEN_LUN:
1272 return zfcp_erp_lun_strategy(erp_action);
1274 return ZFCP_ERP_FAILED;
1277 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1280 unsigned long flags;
1281 struct zfcp_adapter *adapter = erp_action->adapter;
1283 kref_get(&adapter->ref);
1285 write_lock_irqsave(&adapter->erp_lock, flags);
1286 zfcp_erp_strategy_check_fsfreq(erp_action);
1288 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1289 zfcp_erp_action_dequeue(erp_action);
1290 retval = ZFCP_ERP_DISMISSED;
1294 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1295 retval = ZFCP_ERP_FAILED;
1299 zfcp_erp_action_to_running(erp_action);
1301 /* no lock to allow for blocking operations */
1302 write_unlock_irqrestore(&adapter->erp_lock, flags);
1303 retval = zfcp_erp_strategy_do_action(erp_action);
1304 write_lock_irqsave(&adapter->erp_lock, flags);
1306 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1307 retval = ZFCP_ERP_CONTINUES;
1310 case ZFCP_ERP_NOMEM:
1311 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1312 ++adapter->erp_low_mem_count;
1313 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1315 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1316 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL);
1318 zfcp_erp_strategy_memwait(erp_action);
1319 retval = ZFCP_ERP_CONTINUES;
1323 case ZFCP_ERP_CONTINUES:
1324 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1325 --adapter->erp_low_mem_count;
1326 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1332 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1333 zfcp_erp_action_dequeue(erp_action);
1334 retval = zfcp_erp_strategy_statechange(erp_action, retval);
1335 if (retval == ZFCP_ERP_EXIT)
1337 if (retval == ZFCP_ERP_SUCCEEDED)
1338 zfcp_erp_strategy_followup_success(erp_action);
1339 if (retval == ZFCP_ERP_FAILED)
1340 zfcp_erp_strategy_followup_failed(erp_action);
1343 write_unlock_irqrestore(&adapter->erp_lock, flags);
1345 if (retval != ZFCP_ERP_CONTINUES)
1346 zfcp_erp_action_cleanup(erp_action, retval);
1348 kref_put(&adapter->ref, zfcp_adapter_release);
1352 static int zfcp_erp_thread(void *data)
1354 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1355 struct list_head *next;
1356 struct zfcp_erp_action *act;
1357 unsigned long flags;
1360 zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
1361 wait_event_interruptible(adapter->erp_ready_wq,
1362 !list_empty(&adapter->erp_ready_head) ||
1363 kthread_should_stop());
1364 zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
1366 if (kthread_should_stop())
1369 write_lock_irqsave(&adapter->erp_lock, flags);
1370 next = adapter->erp_ready_head.next;
1371 write_unlock_irqrestore(&adapter->erp_lock, flags);
1373 if (next != &adapter->erp_ready_head) {
1374 act = list_entry(next, struct zfcp_erp_action, list);
1376 /* there is more to come after dismission, no notify */
1377 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1378 zfcp_erp_wakeup(adapter);
1386 * zfcp_erp_thread_setup - Start ERP thread for adapter
1387 * @adapter: Adapter to start the ERP thread for
1389 * Returns 0 on success or error code from kernel_thread()
1391 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1393 struct task_struct *thread;
1395 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1396 dev_name(&adapter->ccw_device->dev));
1397 if (IS_ERR(thread)) {
1398 dev_err(&adapter->ccw_device->dev,
1399 "Creating an ERP thread for the FCP device failed.\n");
1400 return PTR_ERR(thread);
1403 adapter->erp_thread = thread;
1408 * zfcp_erp_thread_kill - Stop ERP thread.
1409 * @adapter: Adapter where the ERP thread should be stopped.
1411 * The caller of this routine ensures that the specified adapter has
1412 * been shut down and that this operation has been completed. Thus,
1413 * there are no pending erp_actions which would need to be handled
1416 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1418 kthread_stop(adapter->erp_thread);
1419 adapter->erp_thread = NULL;
1420 WARN_ON(!list_empty(&adapter->erp_ready_head));
1421 WARN_ON(!list_empty(&adapter->erp_running_head));
1425 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1426 * @adapter: adapter for which to wait for completion of its error recovery
1428 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1430 wait_event(adapter->erp_done_wqh,
1431 !(atomic_read(&adapter->status) &
1432 ZFCP_STATUS_ADAPTER_ERP_PENDING));
1436 * zfcp_erp_set_adapter_status - set adapter status bits
1437 * @adapter: adapter to change the status
1438 * @mask: status bits to change
1440 * Changes in common status bits are propagated to attached ports and LUNs.
1442 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1444 struct zfcp_port *port;
1445 struct scsi_device *sdev;
1446 unsigned long flags;
1447 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1449 atomic_set_mask(mask, &adapter->status);
1454 read_lock_irqsave(&adapter->port_list_lock, flags);
1455 list_for_each_entry(port, &adapter->port_list, list)
1456 atomic_set_mask(common_mask, &port->status);
1457 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1459 shost_for_each_device(sdev, adapter->scsi_host)
1460 atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1464 * zfcp_erp_clear_adapter_status - clear adapter status bits
1465 * @adapter: adapter to change the status
1466 * @mask: status bits to change
1468 * Changes in common status bits are propagated to attached ports and LUNs.
1470 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1472 struct zfcp_port *port;
1473 struct scsi_device *sdev;
1474 unsigned long flags;
1475 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1476 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1478 atomic_clear_mask(mask, &adapter->status);
1484 atomic_set(&adapter->erp_counter, 0);
1486 read_lock_irqsave(&adapter->port_list_lock, flags);
1487 list_for_each_entry(port, &adapter->port_list, list) {
1488 atomic_clear_mask(common_mask, &port->status);
1490 atomic_set(&port->erp_counter, 0);
1492 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1494 shost_for_each_device(sdev, adapter->scsi_host) {
1495 atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1497 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1502 * zfcp_erp_set_port_status - set port status bits
1503 * @port: port to change the status
1504 * @mask: status bits to change
1506 * Changes in common status bits are propagated to attached LUNs.
1508 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1510 struct scsi_device *sdev;
1511 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1513 atomic_set_mask(mask, &port->status);
1518 shost_for_each_device(sdev, port->adapter->scsi_host)
1519 if (sdev_to_zfcp(sdev)->port == port)
1520 atomic_set_mask(common_mask,
1521 &sdev_to_zfcp(sdev)->status);
1525 * zfcp_erp_clear_port_status - clear port status bits
1526 * @port: adapter to change the status
1527 * @mask: status bits to change
1529 * Changes in common status bits are propagated to attached LUNs.
1531 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1533 struct scsi_device *sdev;
1534 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1535 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1537 atomic_clear_mask(mask, &port->status);
1543 atomic_set(&port->erp_counter, 0);
1545 shost_for_each_device(sdev, port->adapter->scsi_host)
1546 if (sdev_to_zfcp(sdev)->port == port) {
1547 atomic_clear_mask(common_mask,
1548 &sdev_to_zfcp(sdev)->status);
1550 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1555 * zfcp_erp_set_lun_status - set lun status bits
1556 * @sdev: SCSI device / lun to set the status bits
1557 * @mask: status bits to change
1559 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1561 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1563 atomic_set_mask(mask, &zfcp_sdev->status);
1567 * zfcp_erp_clear_lun_status - clear lun status bits
1568 * @sdev: SCSi device / lun to clear the status bits
1569 * @mask: status bits to change
1571 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1573 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1575 atomic_clear_mask(mask, &zfcp_sdev->status);
1577 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1578 atomic_set(&zfcp_sdev->erp_counter, 0);