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