?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / s390 / scsi / zfcp_erp.c
blob1d91a32db08ef33bfe8e571375f243fa4871ef2c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * zfcp device driver
4 *
5 * Error Recovery Procedures (ERP).
6 *
7 * Copyright IBM Corp. 2002, 2016
8 */
9
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13 #include <linux/kthread.h>
14 #include "zfcp_ext.h"
15 #include "zfcp_reqlist.h"
16
17 #define ZFCP_MAX_ERPS 3
18
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,
26 };
27
28 enum zfcp_erp_steps {
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,
36 };
37
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,
43 };
44
45 enum zfcp_erp_act_state {
46 ZFCP_ERP_ACTION_RUNNING = 1,
47 ZFCP_ERP_ACTION_READY = 2,
48 };
49
50 enum zfcp_erp_act_result {
51 ZFCP_ERP_SUCCEEDED = 0,
52 ZFCP_ERP_FAILED = 1,
53 ZFCP_ERP_CONTINUES = 2,
54 ZFCP_ERP_EXIT = 3,
55 ZFCP_ERP_DISMISSED = 4,
56 ZFCP_ERP_NOMEM = 5,
57 };
58
59 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
60 {
61 zfcp_erp_clear_adapter_status(adapter,
62 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
63 }
64
65 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
66 {
67 struct zfcp_erp_action *curr_act;
68
69 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
70 if (act == curr_act)
71 return ZFCP_ERP_ACTION_RUNNING;
72 return 0;
73 }
74
75 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
76 {
77 struct zfcp_adapter *adapter = act->adapter;
78
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);
83 }
84
85 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
86 {
87 act->status |= ZFCP_STATUS_ERP_DISMISSED;
88 if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
89 zfcp_erp_action_ready(act);
90 }
91
92 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
93 {
94 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
95
96 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
97 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
98 }
99
100 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
101 {
102 struct scsi_device *sdev;
103
104 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
105 zfcp_erp_action_dismiss(&port->erp_action);
106 else {
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);
112 }
113 }
114
115 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
116 {
117 struct zfcp_port *port;
118
119 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
120 zfcp_erp_action_dismiss(&adapter->erp_action);
121 else {
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);
126 }
127 }
128
129 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
130 struct zfcp_port *port,
131 struct scsi_device *sdev)
132 {
133 int need = want;
134 int l_status, p_status, a_status;
135 struct zfcp_scsi_dev *zfcp_sdev;
136
137 switch (want) {
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)
142 return 0;
143 p_status = atomic_read(&port->status);
144 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
145 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
146 return 0;
147 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
148 need = ZFCP_ERP_ACTION_REOPEN_PORT;
149 /* fall through */
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;
154 /* fall through */
155 case ZFCP_ERP_ACTION_REOPEN_PORT:
156 p_status = atomic_read(&port->status);
157 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
158 return 0;
159 a_status = atomic_read(&adapter->status);
160 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
161 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
162 return 0;
163 if (p_status & ZFCP_STATUS_COMMON_NOESC)
164 return need;
165 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
166 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
167 /* fall through */
168 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
169 a_status = atomic_read(&adapter->status);
170 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
171 return 0;
172 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
173 !(a_status & ZFCP_STATUS_COMMON_OPEN))
174 return 0; /* shutdown requested for closed adapter */
175 }
176
177 return need;
178 }
179
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)
184 {
185 struct zfcp_erp_action *erp_action;
186 struct zfcp_scsi_dev *zfcp_sdev;
187
188 switch (need) {
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))
193 return NULL;
194 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
195 &zfcp_sdev->status);
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;
202 break;
203
204 case ZFCP_ERP_ACTION_REOPEN_PORT:
205 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
206 if (!get_device(&port->dev))
207 return NULL;
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;
215 break;
216
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;
227 break;
228
229 default:
230 return NULL;
231 }
232
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;
240
241 return erp_action;
242 }
243
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)
248 {
249 int retval = 1, need;
250 struct zfcp_erp_action *act;
251
252 if (!adapter->erp_thread)
253 return -EIO;
254
255 need = zfcp_erp_required_act(want, adapter, port, sdev);
256 if (!need)
257 goto out;
258
259 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
260 if (!act)
261 goto out;
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);
266 retval = 0;
267 out:
268 zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
269 return retval;
270 }
271
272 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
273 int clear_mask, char *id)
274 {
275 zfcp_erp_adapter_block(adapter, clear_mask);
276 zfcp_scsi_schedule_rports_block(adapter);
277
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);
282 return -EIO;
283 }
284 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
285 adapter, NULL, NULL, id, 0);
286 }
287
288 /**
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.
293 */
294 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
295 {
296 unsigned long flags;
297
298 zfcp_erp_adapter_block(adapter, clear);
299 zfcp_scsi_schedule_rports_block(adapter);
300
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);
305 else
306 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
307 NULL, NULL, id, 0);
308 write_unlock_irqrestore(&adapter->erp_lock, flags);
309 }
310
311 /**
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.
316 */
317 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
318 char *id)
319 {
320 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
321 zfcp_erp_adapter_reopen(adapter, clear | flags, id);
322 }
323
324 /**
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.
329 */
330 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
331 {
332 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
333 zfcp_erp_port_reopen(port, clear | flags, id);
334 }
335
336 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
337 {
338 zfcp_erp_clear_port_status(port,
339 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
340 }
341
342 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
343 char *id)
344 {
345 zfcp_erp_port_block(port, clear);
346 zfcp_scsi_schedule_rport_block(port);
347
348 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
349 return;
350
351 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
352 port->adapter, port, NULL, id, 0);
353 }
354
355 /**
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.
360 */
361 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
362 {
363 unsigned long flags;
364 struct zfcp_adapter *adapter = port->adapter;
365
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);
369 }
370
371 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
372 {
373 zfcp_erp_port_block(port, clear);
374 zfcp_scsi_schedule_rport_block(port);
375
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);
379 return -EIO;
380 }
381
382 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
383 port->adapter, port, NULL, id, 0);
384 }
385
386 /**
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.
391 *
392 * Returns 0 if recovery has been triggered, < 0 if not.
393 */
394 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
395 {
396 int retval;
397 unsigned long flags;
398 struct zfcp_adapter *adapter = port->adapter;
399
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);
403
404 return retval;
405 }
406
407 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
408 {
409 zfcp_erp_clear_lun_status(sdev,
410 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
411 }
412
413 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
414 u32 act_status)
415 {
416 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
417 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
418
419 zfcp_erp_lun_block(sdev, clear);
420
421 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
422 return;
423
424 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
425 zfcp_sdev->port, sdev, id, act_status);
426 }
427
428 /**
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.
433 *
434 * Return: 0 on success, < 0 on error
435 */
436 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
437 {
438 unsigned long flags;
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;
442
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);
446 }
447
448 /**
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.
453 */
454 void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
455 {
456 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
457 zfcp_erp_lun_reopen(sdev, clear | flags, id);
458 }
459
460 /**
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.
464 *
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.
469 */
470 void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
471 {
472 unsigned long flags;
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;
477
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);
481
482 zfcp_erp_wait(adapter);
483 }
484
485 static int status_change_set(unsigned long mask, atomic_t *status)
486 {
487 return (atomic_read(status) ^ mask) & mask;
488 }
489
490 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
491 {
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);
495 }
496
497 static void zfcp_erp_port_unblock(struct zfcp_port *port)
498 {
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);
502 }
503
504 static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
505 {
506 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
507
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);
511 }
512
513 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
514 {
515 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
516 zfcp_dbf_rec_run("erator1", erp_action);
517 }
518
519 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
520 {
521 struct zfcp_adapter *adapter = act->adapter;
522 struct zfcp_fsf_req *req;
523
524 if (!act->fsf_req_id)
525 return;
526
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;
535 }
536 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
537 zfcp_dbf_rec_run("erscf_2", act);
538 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
539 act->fsf_req_id = 0;
540 } else
541 act->fsf_req_id = 0;
542 spin_unlock(&adapter->req_list->lock);
543 }
544
545 /**
546 * zfcp_erp_notify - Trigger ERP action.
547 * @erp_action: ERP action to continue.
548 * @set_mask: ERP action status flags to set.
549 */
550 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
551 {
552 struct zfcp_adapter *adapter = erp_action->adapter;
553 unsigned long flags;
554
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);
559 }
560 write_unlock_irqrestore(&adapter->erp_lock, flags);
561 }
562
563 /**
564 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
565 * @data: ERP action (from timer data)
566 */
567 void zfcp_erp_timeout_handler(struct timer_list *t)
568 {
569 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
570 struct zfcp_erp_action *act = fsf_req->erp_action;
571
572 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
573 }
574
575 static void zfcp_erp_memwait_handler(struct timer_list *t)
576 {
577 struct zfcp_erp_action *act = from_timer(act, t, timer);
578
579 zfcp_erp_notify(act, 0);
580 }
581
582 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
583 {
584 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
585 erp_action->timer.expires = jiffies + HZ;
586 add_timer(&erp_action->timer);
587 }
588
589 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
590 int clear, char *id)
591 {
592 struct zfcp_port *port;
593
594 read_lock(&adapter->port_list_lock);
595 list_for_each_entry(port, &adapter->port_list, list)
596 _zfcp_erp_port_reopen(port, clear, id);
597 read_unlock(&adapter->port_list_lock);
598 }
599
600 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
601 char *id)
602 {
603 struct scsi_device *sdev;
604
605 spin_lock(port->adapter->scsi_host->host_lock);
606 __shost_for_each_device(sdev, port->adapter->scsi_host)
607 if (sdev_to_zfcp(sdev)->port == port)
608 _zfcp_erp_lun_reopen(sdev, clear, id, 0);
609 spin_unlock(port->adapter->scsi_host->host_lock);
610 }
611
612 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
613 {
614 switch (act->action) {
615 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
616 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
617 break;
618 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
619 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
620 break;
621 case ZFCP_ERP_ACTION_REOPEN_PORT:
622 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
623 break;
624 case ZFCP_ERP_ACTION_REOPEN_LUN:
625 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
626 break;
627 }
628 }
629
630 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
631 {
632 switch (act->action) {
633 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
634 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
635 break;
636 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
637 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
638 break;
639 case ZFCP_ERP_ACTION_REOPEN_PORT:
640 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
641 break;
642 }
643 }
644
645 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
646 {
647 unsigned long flags;
648
649 read_lock_irqsave(&adapter->erp_lock, flags);
650 if (list_empty(&adapter->erp_ready_head) &&
651 list_empty(&adapter->erp_running_head)) {
652 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
653 &adapter->status);
654 wake_up(&adapter->erp_done_wqh);
655 }
656 read_unlock_irqrestore(&adapter->erp_lock, flags);
657 }
658
659 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
660 {
661 struct zfcp_port *port;
662 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
663 adapter->peer_d_id);
664 if (IS_ERR(port)) /* error or port already attached */
665 return;
666 _zfcp_erp_port_reopen(port, 0, "ereptp1");
667 }
668
669 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
670 {
671 int retries;
672 int sleep = 1;
673 struct zfcp_adapter *adapter = erp_action->adapter;
674
675 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
676
677 for (retries = 7; retries; retries--) {
678 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
679 &adapter->status);
680 write_lock_irq(&adapter->erp_lock);
681 zfcp_erp_action_to_running(erp_action);
682 write_unlock_irq(&adapter->erp_lock);
683 if (zfcp_fsf_exchange_config_data(erp_action)) {
684 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
685 &adapter->status);
686 return ZFCP_ERP_FAILED;
687 }
688
689 wait_event(adapter->erp_ready_wq,
690 !list_empty(&adapter->erp_ready_head));
691 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
692 break;
693
694 if (!(atomic_read(&adapter->status) &
695 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
696 break;
697
698 ssleep(sleep);
699 sleep *= 2;
700 }
701
702 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
703 &adapter->status);
704
705 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
706 return ZFCP_ERP_FAILED;
707
708 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
709 zfcp_erp_enqueue_ptp_port(adapter);
710
711 return ZFCP_ERP_SUCCEEDED;
712 }
713
714 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
715 {
716 int ret;
717 struct zfcp_adapter *adapter = act->adapter;
718
719 write_lock_irq(&adapter->erp_lock);
720 zfcp_erp_action_to_running(act);
721 write_unlock_irq(&adapter->erp_lock);
722
723 ret = zfcp_fsf_exchange_port_data(act);
724 if (ret == -EOPNOTSUPP)
725 return ZFCP_ERP_SUCCEEDED;
726 if (ret)
727 return ZFCP_ERP_FAILED;
728
729 zfcp_dbf_rec_run("erasox1", act);
730 wait_event(adapter->erp_ready_wq,
731 !list_empty(&adapter->erp_ready_head));
732 zfcp_dbf_rec_run("erasox2", act);
733 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
734 return ZFCP_ERP_FAILED;
735
736 return ZFCP_ERP_SUCCEEDED;
737 }
738
739 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
740 {
741 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
742 return ZFCP_ERP_FAILED;
743
744 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
745 return ZFCP_ERP_FAILED;
746
747 if (mempool_resize(act->adapter->pool.sr_data,
748 act->adapter->stat_read_buf_num))
749 return ZFCP_ERP_FAILED;
750
751 if (mempool_resize(act->adapter->pool.status_read_req,
752 act->adapter->stat_read_buf_num))
753 return ZFCP_ERP_FAILED;
754
755 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
756 if (zfcp_status_read_refill(act->adapter))
757 return ZFCP_ERP_FAILED;
758
759 return ZFCP_ERP_SUCCEEDED;
760 }
761
762 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
763 {
764 struct zfcp_adapter *adapter = act->adapter;
765
766 /* close queues to ensure that buffers are not accessed by adapter */
767 zfcp_qdio_close(adapter->qdio);
768 zfcp_fsf_req_dismiss_all(adapter);
769 adapter->fsf_req_seq_no = 0;
770 zfcp_fc_wka_ports_force_offline(adapter->gs);
771 /* all ports and LUNs are closed */
772 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
773
774 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
775 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
776 }
777
778 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
779 {
780 struct zfcp_adapter *adapter = act->adapter;
781
782 if (zfcp_qdio_open(adapter->qdio)) {
783 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
784 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
785 &adapter->status);
786 return ZFCP_ERP_FAILED;
787 }
788
789 if (zfcp_erp_adapter_strategy_open_fsf(act)) {
790 zfcp_erp_adapter_strategy_close(act);
791 return ZFCP_ERP_FAILED;
792 }
793
794 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
795
796 return ZFCP_ERP_SUCCEEDED;
797 }
798
799 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
800 {
801 struct zfcp_adapter *adapter = act->adapter;
802
803 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
804 zfcp_erp_adapter_strategy_close(act);
805 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
806 return ZFCP_ERP_EXIT;
807 }
808
809 if (zfcp_erp_adapter_strategy_open(act)) {
810 ssleep(8);
811 return ZFCP_ERP_FAILED;
812 }
813
814 return ZFCP_ERP_SUCCEEDED;
815 }
816
817 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
818 {
819 int retval;
820
821 retval = zfcp_fsf_close_physical_port(act);
822 if (retval == -ENOMEM)
823 return ZFCP_ERP_NOMEM;
824 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
825 if (retval)
826 return ZFCP_ERP_FAILED;
827
828 return ZFCP_ERP_CONTINUES;
829 }
830
831 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
832 {
833 struct zfcp_port *port = erp_action->port;
834 int status = atomic_read(&port->status);
835
836 switch (erp_action->step) {
837 case ZFCP_ERP_STEP_UNINITIALIZED:
838 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
839 (status & ZFCP_STATUS_COMMON_OPEN))
840 return zfcp_erp_port_forced_strategy_close(erp_action);
841 else
842 return ZFCP_ERP_FAILED;
843
844 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
845 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
846 return ZFCP_ERP_SUCCEEDED;
847 }
848 return ZFCP_ERP_FAILED;
849 }
850
851 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
852 {
853 int retval;
854
855 retval = zfcp_fsf_close_port(erp_action);
856 if (retval == -ENOMEM)
857 return ZFCP_ERP_NOMEM;
858 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
859 if (retval)
860 return ZFCP_ERP_FAILED;
861 return ZFCP_ERP_CONTINUES;
862 }
863
864 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
865 {
866 int retval;
867
868 retval = zfcp_fsf_open_port(erp_action);
869 if (retval == -ENOMEM)
870 return ZFCP_ERP_NOMEM;
871 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
872 if (retval)
873 return ZFCP_ERP_FAILED;
874 return ZFCP_ERP_CONTINUES;
875 }
876
877 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
878 {
879 struct zfcp_adapter *adapter = act->adapter;
880 struct zfcp_port *port = act->port;
881
882 if (port->wwpn != adapter->peer_wwpn) {
883 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
884 return ZFCP_ERP_FAILED;
885 }
886 port->d_id = adapter->peer_d_id;
887 return zfcp_erp_port_strategy_open_port(act);
888 }
889
890 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
891 {
892 struct zfcp_adapter *adapter = act->adapter;
893 struct zfcp_port *port = act->port;
894 int p_status = atomic_read(&port->status);
895
896 switch (act->step) {
897 case ZFCP_ERP_STEP_UNINITIALIZED:
898 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
899 case ZFCP_ERP_STEP_PORT_CLOSING:
900 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
901 return zfcp_erp_open_ptp_port(act);
902 if (!port->d_id) {
903 zfcp_fc_trigger_did_lookup(port);
904 return ZFCP_ERP_EXIT;
905 }
906 return zfcp_erp_port_strategy_open_port(act);
907
908 case ZFCP_ERP_STEP_PORT_OPENING:
909 /* D_ID might have changed during open */
910 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
911 if (!port->d_id) {
912 zfcp_fc_trigger_did_lookup(port);
913 return ZFCP_ERP_EXIT;
914 }
915 return ZFCP_ERP_SUCCEEDED;
916 }
917 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
918 port->d_id = 0;
919 return ZFCP_ERP_FAILED;
920 }
921 /* fall through otherwise */
922 }
923 return ZFCP_ERP_FAILED;
924 }
925
926 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
927 {
928 struct zfcp_port *port = erp_action->port;
929 int p_status = atomic_read(&port->status);
930
931 if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
932 !(p_status & ZFCP_STATUS_COMMON_OPEN))
933 goto close_init_done;
934
935 switch (erp_action->step) {
936 case ZFCP_ERP_STEP_UNINITIALIZED:
937 if (p_status & ZFCP_STATUS_COMMON_OPEN)
938 return zfcp_erp_port_strategy_close(erp_action);
939 break;
940
941 case ZFCP_ERP_STEP_PORT_CLOSING:
942 if (p_status & ZFCP_STATUS_COMMON_OPEN)
943 return ZFCP_ERP_FAILED;
944 break;
945 }
946
947 close_init_done:
948 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
949 return ZFCP_ERP_EXIT;
950
951 return zfcp_erp_port_strategy_open_common(erp_action);
952 }
953
954 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
955 {
956 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
957
958 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
959 &zfcp_sdev->status);
960 }
961
962 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
963 {
964 int retval = zfcp_fsf_close_lun(erp_action);
965 if (retval == -ENOMEM)
966 return ZFCP_ERP_NOMEM;
967 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
968 if (retval)
969 return ZFCP_ERP_FAILED;
970 return ZFCP_ERP_CONTINUES;
971 }
972
973 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
974 {
975 int retval = zfcp_fsf_open_lun(erp_action);
976 if (retval == -ENOMEM)
977 return ZFCP_ERP_NOMEM;
978 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
979 if (retval)
980 return ZFCP_ERP_FAILED;
981 return ZFCP_ERP_CONTINUES;
982 }
983
984 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
985 {
986 struct scsi_device *sdev = erp_action->sdev;
987 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
988
989 switch (erp_action->step) {
990 case ZFCP_ERP_STEP_UNINITIALIZED:
991 zfcp_erp_lun_strategy_clearstati(sdev);
992 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
993 return zfcp_erp_lun_strategy_close(erp_action);
994 /* already closed, fall through */
995 case ZFCP_ERP_STEP_LUN_CLOSING:
996 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
997 return ZFCP_ERP_FAILED;
998 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
999 return ZFCP_ERP_EXIT;
1000 return zfcp_erp_lun_strategy_open(erp_action);
1001
1002 case ZFCP_ERP_STEP_LUN_OPENING:
1003 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1004 return ZFCP_ERP_SUCCEEDED;
1005 }
1006 return ZFCP_ERP_FAILED;
1007 }
1008
1009 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
1010 {
1011 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1012
1013 switch (result) {
1014 case ZFCP_ERP_SUCCEEDED :
1015 atomic_set(&zfcp_sdev->erp_counter, 0);
1016 zfcp_erp_lun_unblock(sdev);
1017 break;
1018 case ZFCP_ERP_FAILED :
1019 atomic_inc(&zfcp_sdev->erp_counter);
1020 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1021 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1022 "ERP failed for LUN 0x%016Lx on "
1023 "port 0x%016Lx\n",
1024 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1025 (unsigned long long)zfcp_sdev->port->wwpn);
1026 zfcp_erp_set_lun_status(sdev,
1027 ZFCP_STATUS_COMMON_ERP_FAILED);
1028 }
1029 break;
1030 }
1031
1032 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1033 zfcp_erp_lun_block(sdev, 0);
1034 result = ZFCP_ERP_EXIT;
1035 }
1036 return result;
1037 }
1038
1039 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1040 {
1041 switch (result) {
1042 case ZFCP_ERP_SUCCEEDED :
1043 atomic_set(&port->erp_counter, 0);
1044 zfcp_erp_port_unblock(port);
1045 break;
1046
1047 case ZFCP_ERP_FAILED :
1048 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1049 zfcp_erp_port_block(port, 0);
1050 result = ZFCP_ERP_EXIT;
1051 }
1052 atomic_inc(&port->erp_counter);
1053 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1054 dev_err(&port->adapter->ccw_device->dev,
1055 "ERP failed for remote port 0x%016Lx\n",
1056 (unsigned long long)port->wwpn);
1057 zfcp_erp_set_port_status(port,
1058 ZFCP_STATUS_COMMON_ERP_FAILED);
1059 }
1060 break;
1061 }
1062
1063 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1064 zfcp_erp_port_block(port, 0);
1065 result = ZFCP_ERP_EXIT;
1066 }
1067 return result;
1068 }
1069
1070 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1071 int result)
1072 {
1073 switch (result) {
1074 case ZFCP_ERP_SUCCEEDED :
1075 atomic_set(&adapter->erp_counter, 0);
1076 zfcp_erp_adapter_unblock(adapter);
1077 break;
1078
1079 case ZFCP_ERP_FAILED :
1080 atomic_inc(&adapter->erp_counter);
1081 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1082 dev_err(&adapter->ccw_device->dev,
1083 "ERP cannot recover an error "
1084 "on the FCP device\n");
1085 zfcp_erp_set_adapter_status(adapter,
1086 ZFCP_STATUS_COMMON_ERP_FAILED);
1087 }
1088 break;
1089 }
1090
1091 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1092 zfcp_erp_adapter_block(adapter, 0);
1093 result = ZFCP_ERP_EXIT;
1094 }
1095 return result;
1096 }
1097
1098 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1099 int result)
1100 {
1101 struct zfcp_adapter *adapter = erp_action->adapter;
1102 struct zfcp_port *port = erp_action->port;
1103 struct scsi_device *sdev = erp_action->sdev;
1104
1105 switch (erp_action->action) {
1106
1107 case ZFCP_ERP_ACTION_REOPEN_LUN:
1108 result = zfcp_erp_strategy_check_lun(sdev, result);
1109 break;
1110
1111 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1112 case ZFCP_ERP_ACTION_REOPEN_PORT:
1113 result = zfcp_erp_strategy_check_port(port, result);
1114 break;
1115
1116 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1117 result = zfcp_erp_strategy_check_adapter(adapter, result);
1118 break;
1119 }
1120 return result;
1121 }
1122
1123 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1124 {
1125 int status = atomic_read(target_status);
1126
1127 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1128 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1129 return 1; /* take it online */
1130
1131 if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1132 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1133 return 1; /* take it offline */
1134
1135 return 0;
1136 }
1137
1138 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1139 {
1140 int action = act->action;
1141 struct zfcp_adapter *adapter = act->adapter;
1142 struct zfcp_port *port = act->port;
1143 struct scsi_device *sdev = act->sdev;
1144 struct zfcp_scsi_dev *zfcp_sdev;
1145 u32 erp_status = act->status;
1146
1147 switch (action) {
1148 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1149 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1150 _zfcp_erp_adapter_reopen(adapter,
1151 ZFCP_STATUS_COMMON_ERP_FAILED,
1152 "ersscg1");
1153 return ZFCP_ERP_EXIT;
1154 }
1155 break;
1156
1157 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1158 case ZFCP_ERP_ACTION_REOPEN_PORT:
1159 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1160 _zfcp_erp_port_reopen(port,
1161 ZFCP_STATUS_COMMON_ERP_FAILED,
1162 "ersscg2");
1163 return ZFCP_ERP_EXIT;
1164 }
1165 break;
1166
1167 case ZFCP_ERP_ACTION_REOPEN_LUN:
1168 zfcp_sdev = sdev_to_zfcp(sdev);
1169 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1170 _zfcp_erp_lun_reopen(sdev,
1171 ZFCP_STATUS_COMMON_ERP_FAILED,
1172 "ersscg3", 0);
1173 return ZFCP_ERP_EXIT;
1174 }
1175 break;
1176 }
1177 return ret;
1178 }
1179
1180 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1181 {
1182 struct zfcp_adapter *adapter = erp_action->adapter;
1183 struct zfcp_scsi_dev *zfcp_sdev;
1184
1185 adapter->erp_total_count--;
1186 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1187 adapter->erp_low_mem_count--;
1188 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1189 }
1190
1191 list_del(&erp_action->list);
1192 zfcp_dbf_rec_run("eractd1", erp_action);
1193
1194 switch (erp_action->action) {
1195 case ZFCP_ERP_ACTION_REOPEN_LUN:
1196 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1197 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1198 &zfcp_sdev->status);
1199 break;
1200
1201 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1202 case ZFCP_ERP_ACTION_REOPEN_PORT:
1203 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1204 &erp_action->port->status);
1205 break;
1206
1207 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1208 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1209 &erp_action->adapter->status);
1210 break;
1211 }
1212 }
1213
1214 /**
1215 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1216 * @port: zfcp_port whose fc_rport we should try to unblock
1217 */
1218 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
1219 {
1220 unsigned long flags;
1221 struct zfcp_adapter *adapter = port->adapter;
1222 int port_status;
1223 struct Scsi_Host *shost = adapter->scsi_host;
1224 struct scsi_device *sdev;
1225
1226 write_lock_irqsave(&adapter->erp_lock, flags);
1227 port_status = atomic_read(&port->status);
1228 if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1229 (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
1230 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
1231 /* new ERP of severity >= port triggered elsewhere meanwhile or
1232 * local link down (adapter erp_failed but not clear unblock)
1233 */
1234 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
1235 write_unlock_irqrestore(&adapter->erp_lock, flags);
1236 return;
1237 }
1238 spin_lock(shost->host_lock);
1239 __shost_for_each_device(sdev, shost) {
1240 struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
1241 int lun_status;
1242
1243 if (zsdev->port != port)
1244 continue;
1245 /* LUN under port of interest */
1246 lun_status = atomic_read(&zsdev->status);
1247 if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
1248 continue; /* unblock rport despite failed LUNs */
1249 /* LUN recovery not given up yet [maybe follow-up pending] */
1250 if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1251 (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
1252 /* LUN blocked:
1253 * not yet unblocked [LUN recovery pending]
1254 * or meanwhile blocked [new LUN recovery triggered]
1255 */
1256 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
1257 spin_unlock(shost->host_lock);
1258 write_unlock_irqrestore(&adapter->erp_lock, flags);
1259 return;
1260 }
1261 }
1262 /* now port has no child or all children have completed recovery,
1263 * and no ERP of severity >= port was meanwhile triggered elsewhere
1264 */
1265 zfcp_scsi_schedule_rport_register(port);
1266 spin_unlock(shost->host_lock);
1267 write_unlock_irqrestore(&adapter->erp_lock, flags);
1268 }
1269
1270 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1271 {
1272 struct zfcp_adapter *adapter = act->adapter;
1273 struct zfcp_port *port = act->port;
1274 struct scsi_device *sdev = act->sdev;
1275
1276 switch (act->action) {
1277 case ZFCP_ERP_ACTION_REOPEN_LUN:
1278 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1279 scsi_device_put(sdev);
1280 zfcp_erp_try_rport_unblock(port);
1281 break;
1282
1283 case ZFCP_ERP_ACTION_REOPEN_PORT:
1284 /* This switch case might also happen after a forced reopen
1285 * was successfully done and thus overwritten with a new
1286 * non-forced reopen at `ersfs_2'. In this case, we must not
1287 * do the clean-up of the non-forced version.
1288 */
1289 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
1290 if (result == ZFCP_ERP_SUCCEEDED)
1291 zfcp_erp_try_rport_unblock(port);
1292 /* fall through */
1293 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1294 put_device(&port->dev);
1295 break;
1296
1297 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1298 if (result == ZFCP_ERP_SUCCEEDED) {
1299 register_service_level(&adapter->service_level);
1300 zfcp_fc_conditional_port_scan(adapter);
1301 queue_work(adapter->work_queue, &adapter->ns_up_work);
1302 } else
1303 unregister_service_level(&adapter->service_level);
1304
1305 kref_put(&adapter->ref, zfcp_adapter_release);
1306 break;
1307 }
1308 }
1309
1310 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1311 {
1312 switch (erp_action->action) {
1313 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1314 return zfcp_erp_adapter_strategy(erp_action);
1315 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1316 return zfcp_erp_port_forced_strategy(erp_action);
1317 case ZFCP_ERP_ACTION_REOPEN_PORT:
1318 return zfcp_erp_port_strategy(erp_action);
1319 case ZFCP_ERP_ACTION_REOPEN_LUN:
1320 return zfcp_erp_lun_strategy(erp_action);
1321 }
1322 return ZFCP_ERP_FAILED;
1323 }
1324
1325 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1326 {
1327 int retval;
1328 unsigned long flags;
1329 struct zfcp_adapter *adapter = erp_action->adapter;
1330
1331 kref_get(&adapter->ref);
1332
1333 write_lock_irqsave(&adapter->erp_lock, flags);
1334 zfcp_erp_strategy_check_fsfreq(erp_action);
1335
1336 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1337 zfcp_erp_action_dequeue(erp_action);
1338 retval = ZFCP_ERP_DISMISSED;
1339 goto unlock;
1340 }
1341
1342 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1343 retval = ZFCP_ERP_FAILED;
1344 goto check_target;
1345 }
1346
1347 zfcp_erp_action_to_running(erp_action);
1348
1349 /* no lock to allow for blocking operations */
1350 write_unlock_irqrestore(&adapter->erp_lock, flags);
1351 retval = zfcp_erp_strategy_do_action(erp_action);
1352 write_lock_irqsave(&adapter->erp_lock, flags);
1353
1354 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1355 retval = ZFCP_ERP_CONTINUES;
1356
1357 switch (retval) {
1358 case ZFCP_ERP_NOMEM:
1359 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1360 ++adapter->erp_low_mem_count;
1361 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1362 }
1363 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1364 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1365 else {
1366 zfcp_erp_strategy_memwait(erp_action);
1367 retval = ZFCP_ERP_CONTINUES;
1368 }
1369 goto unlock;
1370
1371 case ZFCP_ERP_CONTINUES:
1372 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1373 --adapter->erp_low_mem_count;
1374 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1375 }
1376 goto unlock;
1377 }
1378
1379 check_target:
1380 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1381 zfcp_erp_action_dequeue(erp_action);
1382 retval = zfcp_erp_strategy_statechange(erp_action, retval);
1383 if (retval == ZFCP_ERP_EXIT)
1384 goto unlock;
1385 if (retval == ZFCP_ERP_SUCCEEDED)
1386 zfcp_erp_strategy_followup_success(erp_action);
1387 if (retval == ZFCP_ERP_FAILED)
1388 zfcp_erp_strategy_followup_failed(erp_action);
1389
1390 unlock:
1391 write_unlock_irqrestore(&adapter->erp_lock, flags);
1392
1393 if (retval != ZFCP_ERP_CONTINUES)
1394 zfcp_erp_action_cleanup(erp_action, retval);
1395
1396 kref_put(&adapter->ref, zfcp_adapter_release);
1397 return retval;
1398 }
1399
1400 static int zfcp_erp_thread(void *data)
1401 {
1402 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1403 struct list_head *next;
1404 struct zfcp_erp_action *act;
1405 unsigned long flags;
1406
1407 for (;;) {
1408 wait_event_interruptible(adapter->erp_ready_wq,
1409 !list_empty(&adapter->erp_ready_head) ||
1410 kthread_should_stop());
1411
1412 if (kthread_should_stop())
1413 break;
1414
1415 write_lock_irqsave(&adapter->erp_lock, flags);
1416 next = adapter->erp_ready_head.next;
1417 write_unlock_irqrestore(&adapter->erp_lock, flags);
1418
1419 if (next != &adapter->erp_ready_head) {
1420 act = list_entry(next, struct zfcp_erp_action, list);
1421
1422 /* there is more to come after dismission, no notify */
1423 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1424 zfcp_erp_wakeup(adapter);
1425 }
1426 }
1427
1428 return 0;
1429 }
1430
1431 /**
1432 * zfcp_erp_thread_setup - Start ERP thread for adapter
1433 * @adapter: Adapter to start the ERP thread for
1434 *
1435 * Returns 0 on success or error code from kernel_thread()
1436 */
1437 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1438 {
1439 struct task_struct *thread;
1440
1441 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1442 dev_name(&adapter->ccw_device->dev));
1443 if (IS_ERR(thread)) {
1444 dev_err(&adapter->ccw_device->dev,
1445 "Creating an ERP thread for the FCP device failed.\n");
1446 return PTR_ERR(thread);
1447 }
1448
1449 adapter->erp_thread = thread;
1450 return 0;
1451 }
1452
1453 /**
1454 * zfcp_erp_thread_kill - Stop ERP thread.
1455 * @adapter: Adapter where the ERP thread should be stopped.
1456 *
1457 * The caller of this routine ensures that the specified adapter has
1458 * been shut down and that this operation has been completed. Thus,
1459 * there are no pending erp_actions which would need to be handled
1460 * here.
1461 */
1462 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1463 {
1464 kthread_stop(adapter->erp_thread);
1465 adapter->erp_thread = NULL;
1466 WARN_ON(!list_empty(&adapter->erp_ready_head));
1467 WARN_ON(!list_empty(&adapter->erp_running_head));
1468 }
1469
1470 /**
1471 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1472 * @adapter: adapter for which to wait for completion of its error recovery
1473 */
1474 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1475 {
1476 wait_event(adapter->erp_done_wqh,
1477 !(atomic_read(&adapter->status) &
1478 ZFCP_STATUS_ADAPTER_ERP_PENDING));
1479 }
1480
1481 /**
1482 * zfcp_erp_set_adapter_status - set adapter status bits
1483 * @adapter: adapter to change the status
1484 * @mask: status bits to change
1485 *
1486 * Changes in common status bits are propagated to attached ports and LUNs.
1487 */
1488 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1489 {
1490 struct zfcp_port *port;
1491 struct scsi_device *sdev;
1492 unsigned long flags;
1493 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1494
1495 atomic_or(mask, &adapter->status);
1496
1497 if (!common_mask)
1498 return;
1499
1500 read_lock_irqsave(&adapter->port_list_lock, flags);
1501 list_for_each_entry(port, &adapter->port_list, list)
1502 atomic_or(common_mask, &port->status);
1503 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1504
1505 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1506 __shost_for_each_device(sdev, adapter->scsi_host)
1507 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1508 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1509 }
1510
1511 /**
1512 * zfcp_erp_clear_adapter_status - clear adapter status bits
1513 * @adapter: adapter to change the status
1514 * @mask: status bits to change
1515 *
1516 * Changes in common status bits are propagated to attached ports and LUNs.
1517 */
1518 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1519 {
1520 struct zfcp_port *port;
1521 struct scsi_device *sdev;
1522 unsigned long flags;
1523 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1524 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1525
1526 atomic_andnot(mask, &adapter->status);
1527
1528 if (!common_mask)
1529 return;
1530
1531 if (clear_counter)
1532 atomic_set(&adapter->erp_counter, 0);
1533
1534 read_lock_irqsave(&adapter->port_list_lock, flags);
1535 list_for_each_entry(port, &adapter->port_list, list) {
1536 atomic_andnot(common_mask, &port->status);
1537 if (clear_counter)
1538 atomic_set(&port->erp_counter, 0);
1539 }
1540 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1541
1542 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1543 __shost_for_each_device(sdev, adapter->scsi_host) {
1544 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1545 if (clear_counter)
1546 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1547 }
1548 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1549 }
1550
1551 /**
1552 * zfcp_erp_set_port_status - set port status bits
1553 * @port: port to change the status
1554 * @mask: status bits to change
1555 *
1556 * Changes in common status bits are propagated to attached LUNs.
1557 */
1558 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1559 {
1560 struct scsi_device *sdev;
1561 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1562 unsigned long flags;
1563
1564 atomic_or(mask, &port->status);
1565
1566 if (!common_mask)
1567 return;
1568
1569 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1570 __shost_for_each_device(sdev, port->adapter->scsi_host)
1571 if (sdev_to_zfcp(sdev)->port == port)
1572 atomic_or(common_mask,
1573 &sdev_to_zfcp(sdev)->status);
1574 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1575 }
1576
1577 /**
1578 * zfcp_erp_clear_port_status - clear port status bits
1579 * @port: adapter to change the status
1580 * @mask: status bits to change
1581 *
1582 * Changes in common status bits are propagated to attached LUNs.
1583 */
1584 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1585 {
1586 struct scsi_device *sdev;
1587 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1588 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1589 unsigned long flags;
1590
1591 atomic_andnot(mask, &port->status);
1592
1593 if (!common_mask)
1594 return;
1595
1596 if (clear_counter)
1597 atomic_set(&port->erp_counter, 0);
1598
1599 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1600 __shost_for_each_device(sdev, port->adapter->scsi_host)
1601 if (sdev_to_zfcp(sdev)->port == port) {
1602 atomic_andnot(common_mask,
1603 &sdev_to_zfcp(sdev)->status);
1604 if (clear_counter)
1605 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1606 }
1607 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1608 }
1609
1610 /**
1611 * zfcp_erp_set_lun_status - set lun status bits
1612 * @sdev: SCSI device / lun to set the status bits
1613 * @mask: status bits to change
1614 */
1615 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1616 {
1617 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1618
1619 atomic_or(mask, &zfcp_sdev->status);
1620 }
1621
1622 /**
1623 * zfcp_erp_clear_lun_status - clear lun status bits
1624 * @sdev: SCSi device / lun to clear the status bits
1625 * @mask: status bits to change
1626 */
1627 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1628 {
1629 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1630
1631 atomic_andnot(mask, &zfcp_sdev->status);
1632
1633 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1634 atomic_set(&zfcp_sdev->erp_counter, 0);
1635 }
1636
CRIS linux kernel tree