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