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);