]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/s390/scsi/zfcp_erp.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] zfcp: IO stall after deleting and path checker changes after reenabling zfcp...
[mirror_ubuntu-bionic-kernel.git] / drivers / s390 / scsi / zfcp_erp.c
CommitLineData
1da177e4 1/*
4a9d2d8b
AH		 2 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
1da177e4 4 *
4a9d2d8b 5 * (C) Copyright IBM Corp. 2002, 2006
1da177e4
LT		 6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22#define ZFCP_LOG_AREA ZFCP_LOG_AREA_ERP
23
1da177e4
LT		 24#include "zfcp_ext.h"
25
64b29a13 26static int zfcp_erp_adisc(struct zfcp_port *);
1da177e4
LT		 27static void zfcp_erp_adisc_handler(unsigned long);
28
29static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int);
30static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int);
31static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int);
32static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int);
33
34static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int);
35static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int);
36
37static void zfcp_erp_adapter_block(struct zfcp_adapter *, int);
38static void zfcp_erp_adapter_unblock(struct zfcp_adapter *);
39static void zfcp_erp_port_block(struct zfcp_port *, int);
40static void zfcp_erp_port_unblock(struct zfcp_port *);
41static void zfcp_erp_unit_block(struct zfcp_unit *, int);
42static void zfcp_erp_unit_unblock(struct zfcp_unit *);
43
44static int zfcp_erp_thread(void *);
45
46static int zfcp_erp_strategy(struct zfcp_erp_action *);
47
48static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *);
49static int zfcp_erp_strategy_memwait(struct zfcp_erp_action *);
50static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *, int);
51static int zfcp_erp_strategy_check_unit(struct zfcp_unit *, int);
52static int zfcp_erp_strategy_check_port(struct zfcp_port *, int);
53static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int);
54static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *,
55 struct zfcp_port *,
56 struct zfcp_unit *, int);
57static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32);
58static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *,
59 struct zfcp_port *,
60 struct zfcp_unit *, int);
61static int zfcp_erp_strategy_check_queues(struct zfcp_adapter *);
62static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int);
63
64static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *);
65static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int);
66static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *);
1da177e4
LT		 67static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *);
68static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *);
69static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *);
70static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *);
aef4a983 71static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *);
1da177e4
LT		 72static int zfcp_erp_adapter_strategy_open_fsf_statusread(
73 struct zfcp_erp_action *);
74
75static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *);
76static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *);
77
78static int zfcp_erp_port_strategy(struct zfcp_erp_action *);
79static int zfcp_erp_port_strategy_clearstati(struct zfcp_port *);
80static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *);
81static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *);
82static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *);
83static int zfcp_erp_port_strategy_open_nameserver_wakeup(
84 struct zfcp_erp_action *);
85static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *);
86static int zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *);
87static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *);
88
89static int zfcp_erp_unit_strategy(struct zfcp_erp_action *);
90static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *);
91static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *);
92static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *);
93
81654286 94static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *);
f6c0e7a7
AH		 95static void zfcp_erp_action_dismiss_port(struct zfcp_port *);
96static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *);
97static void zfcp_erp_action_dismiss(struct zfcp_erp_action *);
1da177e4
LT		 98
99static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *,
100 struct zfcp_port *, struct zfcp_unit *);
101static int zfcp_erp_action_dequeue(struct zfcp_erp_action *);
102static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *,
103 struct zfcp_port *, struct zfcp_unit *,
104 int);
105
106static void zfcp_erp_action_ready(struct zfcp_erp_action *);
107static int zfcp_erp_action_exists(struct zfcp_erp_action *);
108
109static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
110static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);
111
112static void zfcp_erp_memwait_handler(unsigned long);
1da177e4
LT		 113
114/**
2abbe866 115 * zfcp_close_qdio - close qdio queues for an adapter
1da177e4 116 */
2abbe866 117static void zfcp_close_qdio(struct zfcp_adapter *adapter)
1da177e4 118{
2abbe866
AH		 119 struct zfcp_qdio_queue *req_queue;
120 int first, count;
1da177e4 121
2abbe866
AH		 122 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
123 return;
1da177e4 124
2abbe866
AH		 125 /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
126 req_queue = &adapter->request_queue;
127 write_lock_irq(&req_queue->queue_lock);
128 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
129 write_unlock_irq(&req_queue->queue_lock);
130
131 debug_text_event(adapter->erp_dbf, 3, "qdio_down2a");
132 while (qdio_shutdown(adapter->ccw_device,
133 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
134 msleep(1000);
135 debug_text_event(adapter->erp_dbf, 3, "qdio_down2b");
136
137 /* cleanup used outbound sbals */
138 count = atomic_read(&req_queue->free_count);
139 if (count < QDIO_MAX_BUFFERS_PER_Q) {
140 first = (req_queue->free_index+count) % QDIO_MAX_BUFFERS_PER_Q;
141 count = QDIO_MAX_BUFFERS_PER_Q - count;
142 zfcp_qdio_zero_sbals(req_queue->buffer, first, count);
143 }
144 req_queue->free_index = 0;
145 atomic_set(&req_queue->free_count, 0);
146 req_queue->distance_from_int = 0;
147 adapter->response_queue.free_index = 0;
148 atomic_set(&adapter->response_queue.free_count, 0);
1da177e4
LT		 149}
150
f6c0e7a7 151/**
2abbe866 152 * zfcp_close_fsf - stop FSF operations for an adapter
f6c0e7a7 153 *
2abbe866
AH		 154 * Dismiss and cleanup all pending fsf_reqs (this wakes up all initiators of
155 * requests waiting for completion; especially this returns SCSI commands
156 * with error state).
1da177e4 157 */
2abbe866 158static void zfcp_close_fsf(struct zfcp_adapter *adapter)
1da177e4 159{
2abbe866
AH		 160 /* close queues to ensure that buffers are not accessed by adapter */
161 zfcp_close_qdio(adapter);
162 zfcp_fsf_req_dismiss_all(adapter);
163 /* reset FSF request sequence number */
164 adapter->fsf_req_seq_no = 0;
165 /* all ports and units are closed */
166 zfcp_erp_modify_adapter_status(adapter,
167 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
168}
1da177e4 169
2abbe866
AH		 170/**
171 * zfcp_fsf_request_timeout_handler - called if a request timed out
172 * @data: pointer to adapter for handler function
173 *
174 * This function needs to be called if requests (ELS, Generic Service,
175 * or SCSI commands) exceed a certain time limit. The assumption is
176 * that after the time limit the adapter get stuck. So we trigger a reopen of
177 * the adapter.
178 */
179static void zfcp_fsf_request_timeout_handler(unsigned long data)
180{
181 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
3b02191a 182 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
1da177e4
LT		 183}
184
2abbe866
AH		 185void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, unsigned long timeout)
186{
187 fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
188 fsf_req->timer.data = (unsigned long) fsf_req->adapter;
9e3738f3 189 fsf_req->timer.expires = jiffies + timeout;
2abbe866
AH		 190 add_timer(&fsf_req->timer);
191}
192
1da177e4
LT		 193/*
194 * function:
195 *
196 * purpose: called if an adapter failed,
197 * initiates adapter recovery which is done
198 * asynchronously
199 *
d6e05edc 200 * returns: 0 - initiated action successfully
1da177e4
LT		 201 * <0 - failed to initiate action
202 */
2b67fc46 203static int
1da177e4
LT		 204zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask)
205{
206 int retval;
207
208 debug_text_event(adapter->erp_dbf, 5, "a_ro");
209 ZFCP_LOG_DEBUG("reopen adapter %s\n",
210 zfcp_get_busid_by_adapter(adapter));
211
212 zfcp_erp_adapter_block(adapter, clear_mask);
213
214 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
215 ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n",
216 zfcp_get_busid_by_adapter(adapter));
217 debug_text_event(adapter->erp_dbf, 5, "a_ro_f");
218 /* ensure propagation of failed status to new devices */
219 zfcp_erp_adapter_failed(adapter);
220 retval = -EIO;
221 goto out;
222 }
223 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
224 adapter, NULL, NULL);
225
226 out:
227 return retval;
228}
229
230/*
231 * function:
232 *
233 * purpose: Wrappper for zfcp_erp_adapter_reopen_internal
234 * used to ensure the correct locking
235 *
d6e05edc 236 * returns: 0 - initiated action successfully
1da177e4
LT		 237 * <0 - failed to initiate action
238 */
239int
240zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask)
241{
242 int retval;
243 unsigned long flags;
244
245 read_lock_irqsave(&zfcp_data.config_lock, flags);
246 write_lock(&adapter->erp_lock);
247 retval = zfcp_erp_adapter_reopen_internal(adapter, clear_mask);
248 write_unlock(&adapter->erp_lock);
249 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
250
251 return retval;
252}
253
1da177e4
LT		 254int
255zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask)
256{
257 int retval;
258
259 retval = zfcp_erp_adapter_reopen(adapter,
260 ZFCP_STATUS_COMMON_RUNNING |
261 ZFCP_STATUS_COMMON_ERP_FAILED |
262 clear_mask);
263
264 return retval;
265}
266
1da177e4
LT		 267int
268zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask)
269{
270 int retval;
271
272 retval = zfcp_erp_port_reopen(port,
273 ZFCP_STATUS_COMMON_RUNNING |
274 ZFCP_STATUS_COMMON_ERP_FAILED |
275 clear_mask);
276
277 return retval;
278}
279
1da177e4
LT		 280int
281zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask)
282{
283 int retval;
284
285 retval = zfcp_erp_unit_reopen(unit,
286 ZFCP_STATUS_COMMON_RUNNING |
287 ZFCP_STATUS_COMMON_ERP_FAILED |
288 clear_mask);
289
290 return retval;
291}
292
293
294/**
295 * zfcp_erp_adisc - send ADISC ELS command
64b29a13 296 * @port: port structure
1da177e4 297 */
2b67fc46 298static int
64b29a13 299zfcp_erp_adisc(struct zfcp_port *port)
1da177e4 300{
64b29a13 301 struct zfcp_adapter *adapter = port->adapter;
1da177e4
LT		 302 struct zfcp_send_els *send_els;
303 struct zfcp_ls_adisc *adisc;
304 void *address = NULL;
305 int retval = 0;
1da177e4 306
ec4081c6 307 send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);
1da177e4
LT		 308 if (send_els == NULL)
309 goto nomem;
1da177e4 310
ec4081c6 311 send_els->req = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC);
1da177e4
LT		 312 if (send_els->req == NULL)
313 goto nomem;
1da177e4 314
ec4081c6 315 send_els->resp = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC);
1da177e4
LT		 316 if (send_els->resp == NULL)
317 goto nomem;
1da177e4
LT		 318
319 address = (void *) get_zeroed_page(GFP_ATOMIC);
320 if (address == NULL)
321 goto nomem;
322
323 zfcp_address_to_sg(address, send_els->req);
324 address += PAGE_SIZE >> 1;
325 zfcp_address_to_sg(address, send_els->resp);
326 send_els->req_count = send_els->resp_count = 1;
327
328 send_els->adapter = adapter;
64b29a13
AH		 329 send_els->port = port;
330 send_els->d_id = port->d_id;
1da177e4
LT		 331 send_els->handler = zfcp_erp_adisc_handler;
332 send_els->handler_data = (unsigned long) send_els;
333
334 adisc = zfcp_sg_to_address(send_els->req);
335 send_els->ls_code = adisc->code = ZFCP_LS_ADISC;
336
337 send_els->req->length = sizeof(struct zfcp_ls_adisc);
338 send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc);
339
340 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
341 without FC-AL-2 capability, so we don't set it */
13e1e1f0
AH		 342 adisc->wwpn = fc_host_port_name(adapter->scsi_host);
343 adisc->wwnn = fc_host_node_name(adapter->scsi_host);
344 adisc->nport_id = fc_host_port_id(adapter->scsi_host);
1d589edf 345 ZFCP_LOG_INFO("ADISC request from s_id 0x%06x to d_id 0x%06x "
1da177e4 346 "(wwpn=0x%016Lx, wwnn=0x%016Lx, "
1d589edf 347 "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
13e1e1f0 348 adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn,
1da177e4
LT		 349 (wwn_t) adisc->wwnn, adisc->hard_nport_id,
350 adisc->nport_id);
351
1da177e4
LT		 352 retval = zfcp_fsf_send_els(send_els);
353 if (retval != 0) {
354 ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
1d589edf 355 "0x%06x on adapter %s\n", send_els->d_id,
1da177e4 356 zfcp_get_busid_by_adapter(adapter));
1da177e4
LT		 357 goto freemem;
358 }
359
360 goto out;
361
362 nomem:
363 retval = -ENOMEM;
364 freemem:
365 if (address != NULL)
366 __free_pages(send_els->req->page, 0);
367 if (send_els != NULL) {
1da177e4
LT		 368 kfree(send_els->req);
369 kfree(send_els->resp);
370 kfree(send_els);
371 }
372 out:
373 return retval;
374}
375
376
377/**
378 * zfcp_erp_adisc_handler - handler for ADISC ELS command
379 * @data: pointer to struct zfcp_send_els
380 *
381 * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered.
382 */
2b67fc46 383static void
1da177e4
LT		 384zfcp_erp_adisc_handler(unsigned long data)
385{
386 struct zfcp_send_els *send_els;
387 struct zfcp_port *port;
388 struct zfcp_adapter *adapter;
13e1e1f0 389 u32 d_id;
1da177e4
LT		 390 struct zfcp_ls_adisc_acc *adisc;
391
392 send_els = (struct zfcp_send_els *) data;
1da177e4 393 adapter = send_els->adapter;
64b29a13 394 port = send_els->port;
1da177e4
LT		 395 d_id = send_els->d_id;
396
1da177e4
LT		 397 /* request rejected or timed out */
398 if (send_els->status != 0) {
399 ZFCP_LOG_NORMAL("ELS request rejected/timed out, "
400 "force physical port reopen "
1d589edf 401 "(adapter %s, port d_id=0x%06x)\n",
1da177e4
LT		 402 zfcp_get_busid_by_adapter(adapter), d_id);
403 debug_text_event(adapter->erp_dbf, 3, "forcreop");
404 if (zfcp_erp_port_forced_reopen(port, 0))
405 ZFCP_LOG_NORMAL("failed reopen of port "
406 "(adapter %s, wwpn=0x%016Lx)\n",
407 zfcp_get_busid_by_port(port),
408 port->wwpn);
409 goto out;
410 }
411
412 adisc = zfcp_sg_to_address(send_els->resp);
413
1d589edf
CS		 414 ZFCP_LOG_INFO("ADISC response from d_id 0x%06x to s_id "
415 "0x%06x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
416 "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
13e1e1f0
AH		 417 d_id, fc_host_port_id(adapter->scsi_host),
418 (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn,
419 adisc->hard_nport_id, adisc->nport_id);
1da177e4
LT		 420
421 /* set wwnn for port */
422 if (port->wwnn == 0)
423 port->wwnn = adisc->wwnn;
424
425 if (port->wwpn != adisc->wwpn) {
426 ZFCP_LOG_NORMAL("d_id assignment changed, reopening "
427 "port (adapter %s, wwpn=0x%016Lx, "
428 "adisc_resp_wwpn=0x%016Lx)\n",
429 zfcp_get_busid_by_port(port),
430 port->wwpn, (wwn_t) adisc->wwpn);
431 if (zfcp_erp_port_reopen(port, 0))
432 ZFCP_LOG_NORMAL("failed reopen of port "
433 "(adapter %s, wwpn=0x%016Lx)\n",
434 zfcp_get_busid_by_port(port),
435 port->wwpn);
436 }
437
438 out:
439 zfcp_port_put(port);
440 __free_pages(send_els->req->page, 0);
1da177e4
LT		 441 kfree(send_els->req);
442 kfree(send_els->resp);
443 kfree(send_els);
444}
445
446
447/**
448 * zfcp_test_link - lightweight link test procedure
449 * @port: port to be tested
450 *
451 * Test status of a link to a remote port using the ELS command ADISC.
452 */
453int
454zfcp_test_link(struct zfcp_port *port)
455{
456 int retval;
457
458 zfcp_port_get(port);
64b29a13 459 retval = zfcp_erp_adisc(port);
1da177e4
LT		 460 if (retval != 0) {
461 zfcp_port_put(port);
462 ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx "
463 "on adapter %s\n ", port->wwpn,
464 zfcp_get_busid_by_port(port));
465 retval = zfcp_erp_port_forced_reopen(port, 0);
466 if (retval != 0) {
467 ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx "
468 "on adapter %s failed\n", port->wwpn,
469 zfcp_get_busid_by_port(port));
470 retval = -EPERM;
471 }
472 }
473
474 return retval;
475}
476
477
478/*
479 * function:
480 *
481 * purpose: called if a port failed to be opened normally
482 * initiates Forced Reopen recovery which is done
483 * asynchronously
484 *
d6e05edc 485 * returns: 0 - initiated action successfully
1da177e4
LT		 486 * <0 - failed to initiate action
487 */
488static int
489zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask)
490{
491 int retval;
492 struct zfcp_adapter *adapter = port->adapter;
493
494 debug_text_event(adapter->erp_dbf, 5, "pf_ro");
495 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
496
497 ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n",
498 port->wwpn, zfcp_get_busid_by_port(port));
499
500 zfcp_erp_port_block(port, clear_mask);
501
502 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
503 ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx "
504 "on adapter %s\n", port->wwpn,
505 zfcp_get_busid_by_port(port));
506 debug_text_event(adapter->erp_dbf, 5, "pf_ro_f");
507 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
508 retval = -EIO;
509 goto out;
510 }
511
512 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
513 port->adapter, port, NULL);
514
515 out:
516 return retval;
517}
518
519/*
520 * function:
521 *
522 * purpose: Wrappper for zfcp_erp_port_forced_reopen_internal
523 * used to ensure the correct locking
524 *
d6e05edc 525 * returns: 0 - initiated action successfully
1da177e4
LT		 526 * <0 - failed to initiate action
527 */
528int
529zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask)
530{
531 int retval;
532 unsigned long flags;
533 struct zfcp_adapter *adapter;
534
535 adapter = port->adapter;
536 read_lock_irqsave(&zfcp_data.config_lock, flags);
537 write_lock(&adapter->erp_lock);
538 retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask);
539 write_unlock(&adapter->erp_lock);
540 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
541
542 return retval;
543}
544
545/*
546 * function:
547 *
548 * purpose: called if a port is to be opened
549 * initiates Reopen recovery which is done
550 * asynchronously
551 *
d6e05edc 552 * returns: 0 - initiated action successfully
1da177e4
LT		 553 * <0 - failed to initiate action
554 */
555static int
556zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask)
557{
558 int retval;
559 struct zfcp_adapter *adapter = port->adapter;
560
561 debug_text_event(adapter->erp_dbf, 5, "p_ro");
562 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
563
564 ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n",
565 port->wwpn, zfcp_get_busid_by_port(port));
566
567 zfcp_erp_port_block(port, clear_mask);
568
569 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
570 ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx "
571 "on adapter %s\n", port->wwpn,
572 zfcp_get_busid_by_port(port));
573 debug_text_event(adapter->erp_dbf, 5, "p_ro_f");
574 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
575 /* ensure propagation of failed status to new devices */
576 zfcp_erp_port_failed(port);
577 retval = -EIO;
578 goto out;
579 }
580
581 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
582 port->adapter, port, NULL);
583
584 out:
585 return retval;
586}
587
588/**
589 * zfcp_erp_port_reopen - initiate reopen of a remote port
590 * @port: port to be reopened
591 * @clear_mask: specifies flags in port status to be cleared
592 * Return: 0 on success, < 0 on error
593 *
594 * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures
595 * correct locking. An error recovery task is initiated to do the reopen.
596 * To wait for the completion of the reopen zfcp_erp_wait should be used.
597 */
598int
599zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask)
600{
601 int retval;
602 unsigned long flags;
603 struct zfcp_adapter *adapter = port->adapter;
604
605 read_lock_irqsave(&zfcp_data.config_lock, flags);
606 write_lock(&adapter->erp_lock);
607 retval = zfcp_erp_port_reopen_internal(port, clear_mask);
608 write_unlock(&adapter->erp_lock);
609 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
610
611 return retval;
612}
613
614/*
615 * function:
616 *
617 * purpose: called if a unit is to be opened
618 * initiates Reopen recovery which is done
619 * asynchronously
620 *
d6e05edc 621 * returns: 0 - initiated action successfully
1da177e4
LT		 622 * <0 - failed to initiate action
623 */
624static int
625zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask)
626{
627 int retval;
628 struct zfcp_adapter *adapter = unit->port->adapter;
629
630 debug_text_event(adapter->erp_dbf, 5, "u_ro");
631 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
632 ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx "
633 "on adapter %s\n", unit->fcp_lun,
634 unit->port->wwpn, zfcp_get_busid_by_unit(unit));
635
636 zfcp_erp_unit_block(unit, clear_mask);
637
638 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
639 ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx "
640 "on port 0x%016Lx on adapter %s\n",
641 unit->fcp_lun, unit->port->wwpn,
642 zfcp_get_busid_by_unit(unit));
643 debug_text_event(adapter->erp_dbf, 5, "u_ro_f");
644 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
645 sizeof (fcp_lun_t));
646 retval = -EIO;
647 goto out;
648 }
649
650 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
651 unit->port->adapter, unit->port, unit);
652 out:
653 return retval;
654}
655
656/**
657 * zfcp_erp_unit_reopen - initiate reopen of a unit
658 * @unit: unit to be reopened
659 * @clear_mask: specifies flags in unit status to be cleared
660 * Return: 0 on success, < 0 on error
661 *
662 * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct
663 * locking. An error recovery task is initiated to do the reopen.
664 * To wait for the completion of the reopen zfcp_erp_wait should be used.
665 */
666int
667zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask)
668{
669 int retval;
670 unsigned long flags;
671 struct zfcp_adapter *adapter;
672 struct zfcp_port *port;
673
674 port = unit->port;
675 adapter = port->adapter;
676
677 read_lock_irqsave(&zfcp_data.config_lock, flags);
678 write_lock(&adapter->erp_lock);
679 retval = zfcp_erp_unit_reopen_internal(unit, clear_mask);
680 write_unlock(&adapter->erp_lock);
681 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
682
683 return retval;
684}
685
f6c0e7a7
AH		 686/**
687 * zfcp_erp_adapter_block - mark adapter as blocked, block scsi requests
1da177e4 688 */
f6c0e7a7 689static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
1da177e4
LT		 690{
691 debug_text_event(adapter->erp_dbf, 6, "a_bl");
692 zfcp_erp_modify_adapter_status(adapter,
693 ZFCP_STATUS_COMMON_UNBLOCKED |
694 clear_mask, ZFCP_CLEAR);
695}
696
f6c0e7a7
AH		 697/**
698 * zfcp_erp_adapter_unblock - mark adapter as unblocked, allow scsi requests
1da177e4 699 */
f6c0e7a7 700static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
1da177e4
LT		 701{
702 debug_text_event(adapter->erp_dbf, 6, "a_ubl");
703 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
704}
705
706/*
707 * function:
708 *
709 * purpose: disable I/O,
710 * return any open requests and clean them up,
711 * aim: no pending and incoming I/O
712 *
713 * returns:
714 */
715static void
716zfcp_erp_port_block(struct zfcp_port *port, int clear_mask)
717{
718 struct zfcp_adapter *adapter = port->adapter;
719
720 debug_text_event(adapter->erp_dbf, 6, "p_bl");
721 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
722 zfcp_erp_modify_port_status(port,
723 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
724 ZFCP_CLEAR);
725}
726
727/*
728 * function:
729 *
730 * purpose: enable I/O
731 *
732 * returns:
733 */
734static void
735zfcp_erp_port_unblock(struct zfcp_port *port)
736{
737 struct zfcp_adapter *adapter = port->adapter;
738
739 debug_text_event(adapter->erp_dbf, 6, "p_ubl");
740 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
741 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
742}
743
744/*
745 * function:
746 *
747 * purpose: disable I/O,
748 * return any open requests and clean them up,
749 * aim: no pending and incoming I/O
750 *
751 * returns:
752 */
753static void
754zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
755{
756 struct zfcp_adapter *adapter = unit->port->adapter;
757
758 debug_text_event(adapter->erp_dbf, 6, "u_bl");
759 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
760 zfcp_erp_modify_unit_status(unit,
761 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
762 ZFCP_CLEAR);
763}
764
765/*
766 * function:
767 *
768 * purpose: enable I/O
769 *
770 * returns:
771 */
772static void
773zfcp_erp_unit_unblock(struct zfcp_unit *unit)
774{
775 struct zfcp_adapter *adapter = unit->port->adapter;
776
777 debug_text_event(adapter->erp_dbf, 6, "u_ubl");
778 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
779 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
780}
781
1da177e4
LT		 782static void
783zfcp_erp_action_ready(struct zfcp_erp_action *erp_action)
784{
785 struct zfcp_adapter *adapter = erp_action->adapter;
786
787 debug_text_event(adapter->erp_dbf, 4, "a_ar");
788 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
789
790 zfcp_erp_action_to_ready(erp_action);
791 up(&adapter->erp_ready_sem);
792}
793
794/*
795 * function:
796 *
797 * purpose:
798 *
799 * returns: <0 erp_action not found in any list
800 * ZFCP_ERP_ACTION_READY erp_action is in ready list
801 * ZFCP_ERP_ACTION_RUNNING erp_action is in running list
802 *
803 * locks: erp_lock must be held
804 */
805static int
806zfcp_erp_action_exists(struct zfcp_erp_action *erp_action)
807{
808 int retval = -EINVAL;
809 struct list_head *entry;
810 struct zfcp_erp_action *entry_erp_action;
811 struct zfcp_adapter *adapter = erp_action->adapter;
812
813 /* search in running list */
814 list_for_each(entry, &adapter->erp_running_head) {
815 entry_erp_action =
816 list_entry(entry, struct zfcp_erp_action, list);
817 if (entry_erp_action == erp_action) {
818 retval = ZFCP_ERP_ACTION_RUNNING;
819 goto out;
820 }
821 }
822 /* search in ready list */
823 list_for_each(entry, &adapter->erp_ready_head) {
824 entry_erp_action =
825 list_entry(entry, struct zfcp_erp_action, list);
826 if (entry_erp_action == erp_action) {
827 retval = ZFCP_ERP_ACTION_READY;
828 goto out;
829 }
830 }
831
832 out:
833 return retval;
834}
835
836/*
837 * purpose: checks current status of action (timed out, dismissed, ...)
838 * and does appropriate preparations (dismiss fsf request, ...)
839 *
840 * locks: called under erp_lock (disabled interrupts)
1da177e4 841 */
ca880cf9 842static void
1da177e4
LT		 843zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
844{
1da177e4
LT		 845 struct zfcp_adapter *adapter = erp_action->adapter;
846
847 if (erp_action->fsf_req) {
fea9d6c7
VS		 848 /* take lock to ensure that request is not deleted meanwhile */
849 spin_lock(&adapter->req_list_lock);
ca2d02c2 850 if (zfcp_reqlist_find(adapter, erp_action->fsf_req->req_id)) {
1da177e4
LT		 851 /* fsf_req still exists */
852 debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
ca880cf9 853 debug_event(adapter->erp_dbf, 3, &erp_action->fsf_req,
1da177e4 854 sizeof (unsigned long));
fea9d6c7 855 /* dismiss fsf_req of timed out/dismissed erp_action */
1da177e4
LT		 856 if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED |
857 ZFCP_STATUS_ERP_TIMEDOUT)) {
858 debug_text_event(adapter->erp_dbf, 3,
859 "a_ca_disreq");
ca880cf9
SS		 860 erp_action->fsf_req->status |=
861 ZFCP_STATUS_FSFREQ_DISMISSED;
1da177e4
LT		 862 }
863 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
864 ZFCP_LOG_NORMAL("error: erp step timed out "
865 "(action=%d, fsf_req=%p)\n ",
866 erp_action->action,
867 erp_action->fsf_req);
868 }
869 /*
870 * If fsf_req is neither dismissed nor completed
871 * then keep it running asynchronously and don't mess
872 * with the association of erp_action and fsf_req.
873 */
ca880cf9
SS		 874 if (erp_action->fsf_req->status &
875 (ZFCP_STATUS_FSFREQ_COMPLETED |
1da177e4
LT		 876 ZFCP_STATUS_FSFREQ_DISMISSED)) {
877 /* forget about association between fsf_req
878 and erp_action */
1da177e4
LT		 879 erp_action->fsf_req = NULL;
880 }
881 } else {
882 debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq");
883 /*
884 * even if this fsf_req has gone, forget about
885 * association between erp_action and fsf_req
886 */
887 erp_action->fsf_req = NULL;
888 }
fea9d6c7 889 spin_unlock(&adapter->req_list_lock);
1da177e4
LT		 890 } else
891 debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq");
1da177e4
LT		 892}
893
f6c0e7a7
AH		 894/**
895 * zfcp_erp_async_handler_nolock - complete erp_action
1da177e4 896 *
f6c0e7a7
AH		 897 * Used for normal completion, time-out, dismissal and failure after
898 * low memory condition.
1da177e4 899 */
f6c0e7a7
AH		 900static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
901 unsigned long set_mask)
1da177e4 902{
1da177e4
LT		 903 struct zfcp_adapter *adapter = erp_action->adapter;
904
905 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
906 debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");
907 debug_event(adapter->erp_dbf, 2, &erp_action->action,
908 sizeof (int));
1da177e4
LT		 909 erp_action->status |= set_mask;
910 zfcp_erp_action_ready(erp_action);
1da177e4
LT		 911 } else {
912 /* action is ready or gone - nothing to do */
913 debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone");
914 debug_event(adapter->erp_dbf, 3, &erp_action->action,
915 sizeof (int));
1da177e4 916 }
1da177e4
LT		 917}
918
f6c0e7a7
AH		 919/**
920 * zfcp_erp_async_handler - wrapper for erp_async_handler_nolock w/ locking
1da177e4 921 */
f6c0e7a7
AH		 922void zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
923 unsigned long set_mask)
1da177e4
LT		 924{
925 struct zfcp_adapter *adapter = erp_action->adapter;
926 unsigned long flags;
1da177e4
LT		 927
928 write_lock_irqsave(&adapter->erp_lock, flags);
f6c0e7a7 929 zfcp_erp_async_handler_nolock(erp_action, set_mask);
1da177e4 930 write_unlock_irqrestore(&adapter->erp_lock, flags);
1da177e4
LT		 931}
932
933/*
934 * purpose: is called for erp_action which was slept waiting for
935 * memory becoming avaliable,
936 * will trigger that this action will be continued
937 */
938static void
939zfcp_erp_memwait_handler(unsigned long data)
940{
941 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
942 struct zfcp_adapter *adapter = erp_action->adapter;
943
944 debug_text_event(adapter->erp_dbf, 2, "a_mwh");
945 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
946
947 zfcp_erp_async_handler(erp_action, 0);
948}
949
950/*
951 * purpose: is called if an asynchronous erp step timed out,
952 * action gets an appropriate flag and will be processed
953 * accordingly
954 */
2abbe866 955void zfcp_erp_timeout_handler(unsigned long data)
1da177e4
LT		 956{
957 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
958 struct zfcp_adapter *adapter = erp_action->adapter;
959
960 debug_text_event(adapter->erp_dbf, 2, "a_th");
961 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
962
963 zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT);
964}
965
f6c0e7a7
AH		 966/**
967 * zfcp_erp_action_dismiss - dismiss an erp_action
1da177e4 968 *
f6c0e7a7
AH		 969 * adapter->erp_lock must be held
970 *
971 * Dismissal of an erp_action is usually required if an erp_action of
972 * higher priority is generated.
1da177e4 973 */
f6c0e7a7 974static void zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
1da177e4
LT		 975{
976 struct zfcp_adapter *adapter = erp_action->adapter;
977
978 debug_text_event(adapter->erp_dbf, 2, "a_adis");
979 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
980
981 zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED);
1da177e4
LT		 982}
983
984int
985zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
986{
987 int retval = 0;
988
989 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
990
1da177e4
LT		 991 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
992 if (retval < 0) {
993 ZFCP_LOG_NORMAL("error: creation of erp thread failed for "
994 "adapter %s\n",
995 zfcp_get_busid_by_adapter(adapter));
996 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail");
997 } else {
998 wait_event(adapter->erp_thread_wqh,
999 atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1000 &adapter->status));
1001 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok");
1002 }
1003
1004 return (retval < 0);
1005}
1006
1007/*
1008 * function:
1009 *
1010 * purpose:
1011 *
1012 * returns:
1013 *
1014 * context: process (i.e. proc-fs or rmmod/insmod)
1015 *
1016 * note: The caller of this routine ensures that the specified
1017 * adapter has been shut down and that this operation
1018 * has been completed. Thus, there are no pending erp_actions
1019 * which would need to be handled here.
1020 */
1021int
1022zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1023{
1024 int retval = 0;
1025
1026 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1027 up(&adapter->erp_ready_sem);
1028
1029 wait_event(adapter->erp_thread_wqh,
1030 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1031 &adapter->status));
1032
1033 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1034 &adapter->status);
1035
1036 debug_text_event(adapter->erp_dbf, 5, "a_thki_ok");
1037
1038 return retval;
1039}
1040
1041/*
1042 * purpose: is run as a kernel thread,
1043 * goes through list of error recovery actions of associated adapter
1044 * and delegates single action to execution
1045 *
1046 * returns: 0
1047 */
1048static int
1049zfcp_erp_thread(void *data)
1050{
1051 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1052 struct list_head *next;
1053 struct zfcp_erp_action *erp_action;
1054 unsigned long flags;
1055
1056 daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter));
1057 /* Block all signals */
1058 siginitsetinv(&current->blocked, 0);
1059 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1060 debug_text_event(adapter->erp_dbf, 5, "a_th_run");
1061 wake_up(&adapter->erp_thread_wqh);
1062
1063 while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1064 &adapter->status)) {
1065
1066 write_lock_irqsave(&adapter->erp_lock, flags);
1067 next = adapter->erp_ready_head.prev;
1068 write_unlock_irqrestore(&adapter->erp_lock, flags);
1069
1070 if (next != &adapter->erp_ready_head) {
1071 erp_action =
1072 list_entry(next, struct zfcp_erp_action, list);
1073 /*
1074 * process action (incl. [re]moving it
1075 * from 'ready' queue)
1076 */
1077 zfcp_erp_strategy(erp_action);
1078 }
1079
1080 /*
1081 * sleep as long as there is nothing to do, i.e.
1082 * no action in 'ready' queue to be processed and
1083 * thread is not to be killed
1084 */
1085 down_interruptible(&adapter->erp_ready_sem);
1086 debug_text_event(adapter->erp_dbf, 5, "a_th_woken");
1087 }
1088
1089 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1090 debug_text_event(adapter->erp_dbf, 5, "a_th_stop");
1091 wake_up(&adapter->erp_thread_wqh);
1092
1093 return 0;
1094}
1095
1096/*
1097 * function:
1098 *
1099 * purpose: drives single error recovery action and schedules higher and
1100 * subordinate actions, if necessary
1101 *
1102 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
1103 * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd)
1104 * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd)
1105 * ZFCP_ERP_EXIT - action finished (dequeued), offline
1106 * ZFCP_ERP_DISMISSED - action canceled (dequeued)
1107 */
1108static int
1109zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1110{
1111 int retval = 0;
1112 struct zfcp_adapter *adapter = erp_action->adapter;
1113 struct zfcp_port *port = erp_action->port;
1114 struct zfcp_unit *unit = erp_action->unit;
1115 int action = erp_action->action;
1116 u32 status = erp_action->status;
1117 unsigned long flags;
1118
1119 /* serialise dismissing, timing out, moving, enqueueing */
1120 read_lock_irqsave(&zfcp_data.config_lock, flags);
1121 write_lock(&adapter->erp_lock);
1122
1123 /* dequeue dismissed action and leave, if required */
1124 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1125 if (retval == ZFCP_ERP_DISMISSED) {
1126 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1");
1127 goto unlock;
1128 }
1129
1130 /*
1131 * move action to 'running' queue before processing it
1132 * (to avoid a race condition regarding moving the
1133 * action to the 'running' queue and back)
1134 */
1135 zfcp_erp_action_to_running(erp_action);
1136
1137 /*
1138 * try to process action as far as possible,
1139 * no lock to allow for blocking operations (kmalloc, qdio, ...),
1140 * afterwards the lock is required again for the following reasons:
1141 * - dequeueing of finished action and enqueueing of
1142 * follow-up actions must be atomic so that any other
1143 * reopen-routine does not believe there is nothing to do
1144 * and that it is safe to enqueue something else,
1145 * - we want to force any control thread which is dismissing
1146 * actions to finish this before we decide about
1147 * necessary steps to be taken here further
1148 */
1149 write_unlock(&adapter->erp_lock);
1150 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1151 retval = zfcp_erp_strategy_do_action(erp_action);
1152 read_lock_irqsave(&zfcp_data.config_lock, flags);
1153 write_lock(&adapter->erp_lock);
1154
1155 /*
1156 * check for dismissed status again to avoid follow-up actions,
1157 * failing of targets and so on for dismissed actions
1158 */
1159 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1160
1161 switch (retval) {
1162 case ZFCP_ERP_DISMISSED:
1163 /* leave since this action has ridden to its ancestors */
1164 debug_text_event(adapter->erp_dbf, 6, "a_st_dis2");
1165 goto unlock;
1166 case ZFCP_ERP_NOMEM:
1167 /* no memory to continue immediately, let it sleep */
1168 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1169 ++adapter->erp_low_mem_count;
1170 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1171 }
1172 /* This condition is true if there is no memory available
1173 for any erp_action on this adapter. This implies that there
1174 are no elements in the memory pool(s) left for erp_actions.
1175 This might happen if an erp_action that used a memory pool
1176 element was timed out.
1177 */
1178 if (adapter->erp_total_count == adapter->erp_low_mem_count) {
1179 debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem");
1180 ZFCP_LOG_NORMAL("error: no mempool elements available, "
1181 "restarting I/O on adapter %s "
1182 "to free mempool\n",
1183 zfcp_get_busid_by_adapter(adapter));
1184 zfcp_erp_adapter_reopen_internal(adapter, 0);
1185 } else {
1186 debug_text_event(adapter->erp_dbf, 2, "a_st_memw");
1187 retval = zfcp_erp_strategy_memwait(erp_action);
1188 }
1189 goto unlock;
1190 case ZFCP_ERP_CONTINUES:
1191 /* leave since this action runs asynchronously */
1192 debug_text_event(adapter->erp_dbf, 6, "a_st_cont");
1193 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1194 --adapter->erp_low_mem_count;
1195 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1196 }
1197 goto unlock;
1198 }
1199 /* ok, finished action (whatever its result is) */
1200
1201 /* check for unrecoverable targets */
1202 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1203
1204 /* action must be dequeued (here to allow for further ones) */
1205 zfcp_erp_action_dequeue(erp_action);
1206
1207 /*
1208 * put this target through the erp mill again if someone has
1209 * requested to change the status of a target being online
1210 * to offline or the other way around
1211 * (old retval is preserved if nothing has to be done here)
1212 */
1213 retval = zfcp_erp_strategy_statechange(action, status, adapter,
1214 port, unit, retval);
1215
1216 /*
1217 * leave if target is in permanent error state or if
1218 * action is repeated in order to process state change
1219 */
1220 if (retval == ZFCP_ERP_EXIT) {
1221 debug_text_event(adapter->erp_dbf, 2, "a_st_exit");
1222 goto unlock;
1223 }
1224
1225 /* trigger follow up actions */
1226 zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval);
1227
1228 unlock:
1229 write_unlock(&adapter->erp_lock);
1230 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1231
1232 if (retval != ZFCP_ERP_CONTINUES)
1233 zfcp_erp_action_cleanup(action, adapter, port, unit, retval);
1234
1235 /*
1236 * a few tasks remain when the erp queues are empty
1237 * (don't do that if the last action evaluated was dismissed
1238 * since this clearly indicates that there is more to come) :
1239 * - close the name server port if it is open yet
1240 * (enqueues another [probably] final action)
1241 * - otherwise, wake up whoever wants to be woken when we are
1242 * done with erp
1243 */
1244 if (retval != ZFCP_ERP_DISMISSED)
1245 zfcp_erp_strategy_check_queues(adapter);
1246
1247 debug_text_event(adapter->erp_dbf, 6, "a_st_done");
1248
1249 return retval;
1250}
1251
1252/*
1253 * function:
1254 *
1255 * purpose:
1256 *
1257 * returns: ZFCP_ERP_DISMISSED - if action has been dismissed
1258 * retval - otherwise
1259 */
1260static int
1261zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval)
1262{
1263 struct zfcp_adapter *adapter = erp_action->adapter;
1264
1265 zfcp_erp_strategy_check_fsfreq(erp_action);
1266
1267 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1268 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1269 debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis");
1270 zfcp_erp_action_dequeue(erp_action);
1271 retval = ZFCP_ERP_DISMISSED;
1272 } else
1273 debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis");
1274
1275 return retval;
1276}
1277
1da177e4
LT		 1278static int
1279zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1280{
1281 int retval = ZFCP_ERP_FAILED;
1282 struct zfcp_adapter *adapter = erp_action->adapter;
1283
1284 /*
1285 * try to execute/continue action as far as possible,
1286 * note: no lock in subsequent strategy routines
1287 * (this allows these routine to call schedule, e.g.
1288 * kmalloc with such flags or qdio_initialize & friends)
1289 * Note: in case of timeout, the seperate strategies will fail
1290 * anyhow. No need for a special action. Even worse, a nameserver
1291 * failure would not wake up waiting ports without the call.
1292 */
1293 switch (erp_action->action) {
1294
1295 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1296 retval = zfcp_erp_adapter_strategy(erp_action);
1297 break;
1298
1299 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1300 retval = zfcp_erp_port_forced_strategy(erp_action);
1301 break;
1302
1303 case ZFCP_ERP_ACTION_REOPEN_PORT:
1304 retval = zfcp_erp_port_strategy(erp_action);
1305 break;
1306
1307 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1308 retval = zfcp_erp_unit_strategy(erp_action);
1309 break;
1310
1311 default:
1312 debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug");
1313 debug_event(adapter->erp_dbf, 1, &erp_action->action,
1314 sizeof (int));
1315 ZFCP_LOG_NORMAL("bug: unknown erp action requested on "
1316 "adapter %s (action=%d)\n",
1317 zfcp_get_busid_by_adapter(erp_action->adapter),
1318 erp_action->action);
1319 }
1320
1321 return retval;
1322}
1323
1324/*
1325 * function:
1326 *
1327 * purpose: triggers retry of this action after a certain amount of time
1328 * by means of timer provided by erp_action
1329 *
1330 * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue
1331 */
1332static int
1333zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
1334{
1335 int retval = ZFCP_ERP_CONTINUES;
1336 struct zfcp_adapter *adapter = erp_action->adapter;
1337
1338 debug_text_event(adapter->erp_dbf, 6, "a_mwinit");
1339 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
1340 init_timer(&erp_action->timer);
1341 erp_action->timer.function = zfcp_erp_memwait_handler;
1342 erp_action->timer.data = (unsigned long) erp_action;
1343 erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT;
1344 add_timer(&erp_action->timer);
1345
1346 return retval;
1347}
1348
1349/*
1350 * function: zfcp_erp_adapter_failed
1351 *
1352 * purpose: sets the adapter and all underlying devices to ERP_FAILED
1353 *
1354 */
1355void
1356zfcp_erp_adapter_failed(struct zfcp_adapter *adapter)
1357{
1358 zfcp_erp_modify_adapter_status(adapter,
1359 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1360 ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n",
1361 zfcp_get_busid_by_adapter(adapter));
1362 debug_text_event(adapter->erp_dbf, 2, "a_afail");
1363}
1364
1365/*
1366 * function: zfcp_erp_port_failed
1367 *
1368 * purpose: sets the port and all underlying devices to ERP_FAILED
1369 *
1370 */
1371void
1372zfcp_erp_port_failed(struct zfcp_port *port)
1373{
1374 zfcp_erp_modify_port_status(port,
1375 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1376
1377 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1378 ZFCP_LOG_NORMAL("port erp failed (adapter %s, "
1d589edf 1379 "port d_id=0x%06x)\n",
1da177e4
LT		 1380 zfcp_get_busid_by_port(port), port->d_id);
1381 else
1382 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n",
1383 zfcp_get_busid_by_port(port), port->wwpn);
1384
1385 debug_text_event(port->adapter->erp_dbf, 2, "p_pfail");
1386 debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t));
1387}
1388
1389/*
1390 * function: zfcp_erp_unit_failed
1391 *
1392 * purpose: sets the unit to ERP_FAILED
1393 *
1394 */
1395void
1396zfcp_erp_unit_failed(struct zfcp_unit *unit)
1397{
1398 zfcp_erp_modify_unit_status(unit,
1399 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1400
1401 ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx "
1402 " on adapter %s\n", unit->fcp_lun,
1403 unit->port->wwpn, zfcp_get_busid_by_unit(unit));
1404 debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail");
1405 debug_event(unit->port->adapter->erp_dbf, 2,
1406 &unit->fcp_lun, sizeof (fcp_lun_t));
1407}
1408
1409/*
1410 * function: zfcp_erp_strategy_check_target
1411 *
1412 * purpose: increments the erp action count on the device currently in
1413 * recovery if the action failed or resets the count in case of
1414 * success. If a maximum count is exceeded the device is marked
1415 * as ERP_FAILED.
1416 * The 'blocked' state of a target which has been recovered
1417 * successfully is reset.
1418 *
1419 * returns: ZFCP_ERP_CONTINUES - action continues (not considered)
1420 * ZFCP_ERP_SUCCEEDED - action finished successfully
1421 * ZFCP_ERP_EXIT - action failed and will not continue
1422 */
1423static int
1424zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result)
1425{
1426 struct zfcp_adapter *adapter = erp_action->adapter;
1427 struct zfcp_port *port = erp_action->port;
1428 struct zfcp_unit *unit = erp_action->unit;
1429
1430 debug_text_event(adapter->erp_dbf, 5, "a_stct_norm");
1431 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1432 debug_event(adapter->erp_dbf, 5, &result, sizeof (int));
1433
1434 switch (erp_action->action) {
1435
1436 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1437 result = zfcp_erp_strategy_check_unit(unit, result);
1438 break;
1439
1440 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1441 case ZFCP_ERP_ACTION_REOPEN_PORT:
1442 result = zfcp_erp_strategy_check_port(port, result);
1443 break;
1444
1445 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1446 result = zfcp_erp_strategy_check_adapter(adapter, result);
1447 break;
1448 }
1449
1450 return result;
1451}
1452
1da177e4
LT		 1453static int
1454zfcp_erp_strategy_statechange(int action,
1455 u32 status,
1456 struct zfcp_adapter *adapter,
1457 struct zfcp_port *port,
1458 struct zfcp_unit *unit, int retval)
1459{
1460 debug_text_event(adapter->erp_dbf, 3, "a_stsc");
1461 debug_event(adapter->erp_dbf, 3, &action, sizeof (int));
1462
1463 switch (action) {
1464
1465 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1466 if (zfcp_erp_strategy_statechange_detected(&adapter->status,
1467 status)) {
1468 zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
1469 retval = ZFCP_ERP_EXIT;
1470 }
1471 break;
1472
1473 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1474 case ZFCP_ERP_ACTION_REOPEN_PORT:
1475 if (zfcp_erp_strategy_statechange_detected(&port->status,
1476 status)) {
1477 zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED);
1478 retval = ZFCP_ERP_EXIT;
1479 }
1480 break;
1481
1482 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1483 if (zfcp_erp_strategy_statechange_detected(&unit->status,
1484 status)) {
1485 zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
1486 retval = ZFCP_ERP_EXIT;
1487 }
1488 break;
1489 }
1490
1491 return retval;
1492}
1493
1da177e4
LT		 1494static inline int
1495zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status)
1496{
1497 return
1498 /* take it online */
1499 (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1500 (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) ||
1501 /* take it offline */
1502 (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1503 !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status));
1504}
1505
1da177e4
LT		 1506static int
1507zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
1508{
1509 debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct");
1510 debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun,
1511 sizeof (fcp_lun_t));
1512
1513 switch (result) {
1514 case ZFCP_ERP_SUCCEEDED :
1515 atomic_set(&unit->erp_counter, 0);
1516 zfcp_erp_unit_unblock(unit);
1517 break;
1518 case ZFCP_ERP_FAILED :
1519 atomic_inc(&unit->erp_counter);
1520 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
1521 zfcp_erp_unit_failed(unit);
1522 break;
1523 case ZFCP_ERP_EXIT :
1524 /* nothing */
1525 break;
1526 }
1527
1528 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
1529 zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */
1530 result = ZFCP_ERP_EXIT;
1531 }
1532
1533 return result;
1534}
1535
1da177e4
LT		 1536static int
1537zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1538{
1539 debug_text_event(port->adapter->erp_dbf, 5, "p_stct");
1540 debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
1541
1542 switch (result) {
1543 case ZFCP_ERP_SUCCEEDED :
1544 atomic_set(&port->erp_counter, 0);
1545 zfcp_erp_port_unblock(port);
1546 break;
1547 case ZFCP_ERP_FAILED :
1548 atomic_inc(&port->erp_counter);
1549 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
1550 zfcp_erp_port_failed(port);
1551 break;
1552 case ZFCP_ERP_EXIT :
1553 /* nothing */
1554 break;
1555 }
1556
1557 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
1558 zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */
1559 result = ZFCP_ERP_EXIT;
1560 }
1561
1562 return result;
1563}
1564
1da177e4
LT		 1565static int
1566zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result)
1567{
1568 debug_text_event(adapter->erp_dbf, 5, "a_stct");
1569
1570 switch (result) {
1571 case ZFCP_ERP_SUCCEEDED :
1572 atomic_set(&adapter->erp_counter, 0);
1573 zfcp_erp_adapter_unblock(adapter);
1574 break;
1575 case ZFCP_ERP_FAILED :
1576 atomic_inc(&adapter->erp_counter);
1577 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS)
1578 zfcp_erp_adapter_failed(adapter);
1579 break;
1580 case ZFCP_ERP_EXIT :
1581 /* nothing */
1582 break;
1583 }
1584
1585 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
1586 zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */
1587 result = ZFCP_ERP_EXIT;
1588 }
1589
1590 return result;
1591}
1592
5f852be9
CS		 1593struct zfcp_erp_add_work {
1594 struct zfcp_unit *unit;
1595 struct work_struct work;
1596};
1597
1598/**
1599 * zfcp_erp_scsi_scan
1600 * @data: pointer to a struct zfcp_erp_add_work
1601 *
1602 * Registers a logical unit with the SCSI stack.
1603 */
1604static void zfcp_erp_scsi_scan(struct work_struct *work)
1605{
1606 struct zfcp_erp_add_work *p =
1607 container_of(work, struct zfcp_erp_add_work, work);
1608 struct zfcp_unit *unit = p->unit;
1609 struct fc_rport *rport = unit->port->rport;
1610 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
1611 unit->scsi_lun, 0);
1612 atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1613 wake_up(&unit->scsi_scan_wq);
1614 zfcp_unit_put(unit);
1615 kfree(p);
1616}
1617
1618/**
1619 * zfcp_erp_schedule_work
1620 * @unit: pointer to unit which should be registered with SCSI stack
1621 *
1622 * Schedules work which registers a unit with the SCSI stack
1623 */
1624static void
1625zfcp_erp_schedule_work(struct zfcp_unit *unit)
1626{
1627 struct zfcp_erp_add_work *p;
1628
1629 p = kmalloc(sizeof(*p), GFP_KERNEL);
1630 if (!p) {
1631 ZFCP_LOG_NORMAL("error: Out of resources. Could not register "
1632 "the FCP-LUN 0x%Lx connected to "
1633 "the port with WWPN 0x%Lx connected to "
1634 "the adapter %s with the SCSI stack.\n",
1635 unit->fcp_lun,
1636 unit->port->wwpn,
1637 zfcp_get_busid_by_unit(unit));
1638 return;
1639 }
1640
1641 zfcp_unit_get(unit);
1642 memset(p, 0, sizeof(*p));
1643 atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1644 INIT_WORK(&p->work, zfcp_erp_scsi_scan);
1645 p->unit = unit;
1646 schedule_work(&p->work);
1647}
1648
1da177e4
LT		 1649/*
1650 * function:
1651 *
1652 * purpose: remaining things in good cases,
1653 * escalation in bad cases
1654 *
1655 * returns:
1656 */
1657static int
1658zfcp_erp_strategy_followup_actions(int action,
1659 struct zfcp_adapter *adapter,
1660 struct zfcp_port *port,
1661 struct zfcp_unit *unit, int status)
1662{
1663 debug_text_event(adapter->erp_dbf, 5, "a_stfol");
1664 debug_event(adapter->erp_dbf, 5, &action, sizeof (int));
1665
1666 /* initiate follow-up actions depending on success of finished action */
1667 switch (action) {
1668
1669 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1670 if (status == ZFCP_ERP_SUCCEEDED)
1671 zfcp_erp_port_reopen_all_internal(adapter, 0);
1672 else
1673 zfcp_erp_adapter_reopen_internal(adapter, 0);
1674 break;
1675
1676 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1677 if (status == ZFCP_ERP_SUCCEEDED)
1678 zfcp_erp_port_reopen_internal(port, 0);
1679 else
1680 zfcp_erp_adapter_reopen_internal(adapter, 0);
1681 break;
1682
1683 case ZFCP_ERP_ACTION_REOPEN_PORT:
1684 if (status == ZFCP_ERP_SUCCEEDED)
1685 zfcp_erp_unit_reopen_all_internal(port, 0);
1686 else
1687 zfcp_erp_port_forced_reopen_internal(port, 0);
1688 break;
1689
1690 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1691 if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */
1692 else
1693 zfcp_erp_port_reopen_internal(unit->port, 0);
1694 break;
1695 }
1696
1697 return 0;
1698}
1699
1da177e4
LT		 1700static int
1701zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter)
1702{
1703 unsigned long flags;
1704
1705 read_lock_irqsave(&zfcp_data.config_lock, flags);
1706 read_lock(&adapter->erp_lock);
1707 if (list_empty(&adapter->erp_ready_head) &&
1708 list_empty(&adapter->erp_running_head)) {
1709 debug_text_event(adapter->erp_dbf, 4, "a_cq_wake");
1710 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1711 &adapter->status);
1712 wake_up(&adapter->erp_done_wqh);
1713 } else
1714 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty");
1715 read_unlock(&adapter->erp_lock);
1716 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1717
1718 return 0;
1719}
1720
1721/**
1722 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1723 * @adapter: adapter for which to wait for completion of its error recovery
1724 * Return: 0
1725 */
1726int
1727zfcp_erp_wait(struct zfcp_adapter *adapter)
1728{
1729 int retval = 0;
1730
1731 wait_event(adapter->erp_done_wqh,
1732 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1733 &adapter->status));
1734
1735 return retval;
1736}
1737
1da177e4
LT		 1738void
1739zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter,
1740 u32 mask, int set_or_clear)
1741{
1742 struct zfcp_port *port;
1743 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1744
1745 if (set_or_clear == ZFCP_SET) {
1746 atomic_set_mask(mask, &adapter->status);
1747 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s");
1748 } else {
1749 atomic_clear_mask(mask, &adapter->status);
1750 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1751 atomic_set(&adapter->erp_counter, 0);
1752 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c");
1753 }
1754 debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32));
1755
1756 /* Deal with all underlying devices, only pass common_mask */
1757 if (common_mask)
1758 list_for_each_entry(port, &adapter->port_list_head, list)
1759 zfcp_erp_modify_port_status(port, common_mask,
1760 set_or_clear);
1761}
1762
1763/*
1764 * function: zfcp_erp_modify_port_status
1765 *
1766 * purpose: sets the port and all underlying devices to ERP_FAILED
1767 *
1768 */
1769void
1770zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear)
1771{
1772 struct zfcp_unit *unit;
1773 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1774
1775 if (set_or_clear == ZFCP_SET) {
1776 atomic_set_mask(mask, &port->status);
1777 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s");
1778 } else {
1779 atomic_clear_mask(mask, &port->status);
1780 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1781 atomic_set(&port->erp_counter, 0);
1782 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c");
1783 }
1784 debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
1785 debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1786
1787 /* Modify status of all underlying devices, only pass common mask */
1788 if (common_mask)
1789 list_for_each_entry(unit, &port->unit_list_head, list)
1790 zfcp_erp_modify_unit_status(unit, common_mask,
1791 set_or_clear);
1792}
1793
1794/*
1795 * function: zfcp_erp_modify_unit_status
1796 *
1797 * purpose: sets the unit to ERP_FAILED
1798 *
1799 */
1800void
1801zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear)
1802{
1803 if (set_or_clear == ZFCP_SET) {
1804 atomic_set_mask(mask, &unit->status);
1805 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s");
1806 } else {
1807 atomic_clear_mask(mask, &unit->status);
1808 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1809 atomic_set(&unit->erp_counter, 0);
1810 }
1811 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c");
1812 }
1813 debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun,
1814 sizeof (fcp_lun_t));
1815 debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1816}
1817
1818/*
1819 * function:
1820 *
1821 * purpose: Wrappper for zfcp_erp_port_reopen_all_internal
1822 * used to ensure the correct locking
1823 *
d6e05edc 1824 * returns: 0 - initiated action successfully
1da177e4
LT		 1825 * <0 - failed to initiate action
1826 */
1827int
1828zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask)
1829{
1830 int retval;
1831 unsigned long flags;
1832
1833 read_lock_irqsave(&zfcp_data.config_lock, flags);
1834 write_lock(&adapter->erp_lock);
1835 retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask);
1836 write_unlock(&adapter->erp_lock);
1837 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1838
1839 return retval;
1840}
1841
1da177e4
LT		 1842static int
1843zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask)
1844{
1845 int retval = 0;
1846 struct zfcp_port *port;
1847
1848 list_for_each_entry(port, &adapter->port_list_head, list)
1849 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1850 zfcp_erp_port_reopen_internal(port, clear_mask);
1851
1852 return retval;
1853}
1854
1855/*
1856 * function:
1857 *
1858 * purpose:
1859 *
1860 * returns: FIXME
1861 */
1862static int
1863zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask)
1864{
1865 int retval = 0;
1866 struct zfcp_unit *unit;
1867
1868 list_for_each_entry(unit, &port->unit_list_head, list)
1869 zfcp_erp_unit_reopen_internal(unit, clear_mask);
1870
1871 return retval;
1872}
1873
1874/*
1875 * function:
1876 *
1877 * purpose: this routine executes the 'Reopen Adapter' action
1878 * (the entire action is processed synchronously, since
1879 * there are no actions which might be run concurrently
1880 * per definition)
1881 *
1882 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1883 * ZFCP_ERP_FAILED - action finished unsuccessfully
1884 */
1885static int
1886zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action)
1887{
1888 int retval;
1889 struct zfcp_adapter *adapter = erp_action->adapter;
1890
1891 retval = zfcp_erp_adapter_strategy_close(erp_action);
1892 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1893 retval = ZFCP_ERP_EXIT;
1894 else
1895 retval = zfcp_erp_adapter_strategy_open(erp_action);
1896
1897 debug_text_event(adapter->erp_dbf, 3, "a_ast/ret");
1898 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
1899 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
1900
1901 if (retval == ZFCP_ERP_FAILED) {
1902 ZFCP_LOG_INFO("Waiting to allow the adapter %s "
1903 "to recover itself\n",
1904 zfcp_get_busid_by_adapter(adapter));
1905 msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME));
1906 }
1907
1908 return retval;
1909}
1910
1911/*
1912 * function:
1913 *
1914 * purpose:
1915 *
1916 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1917 * ZFCP_ERP_FAILED - action finished unsuccessfully
1918 */
1919static int
1920zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action)
1921{
1922 int retval;
1923
1924 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING,
1925 &erp_action->adapter->status);
1926 retval = zfcp_erp_adapter_strategy_generic(erp_action, 1);
1927 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING,
1928 &erp_action->adapter->status);
1929
1930 return retval;
1931}
1932
1933/*
1934 * function:
1935 *
1936 * purpose:
1937 *
1938 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1939 * ZFCP_ERP_FAILED - action finished unsuccessfully
1940 */
1941static int
1942zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action)
1943{
1944 int retval;
1945
1946 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING,
1947 &erp_action->adapter->status);
1948 retval = zfcp_erp_adapter_strategy_generic(erp_action, 0);
1949 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING,
1950 &erp_action->adapter->status);
1951
1952 return retval;
1953}
1954
1955/*
1956 * function: zfcp_register_adapter
1957 *
1958 * purpose: allocate the irq associated with this devno and register
1959 * the FSF adapter with the SCSI stack
1960 *
1961 * returns:
1962 */
1963static int
1964zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
1965{
1966 int retval = ZFCP_ERP_SUCCEEDED;
1967
1968 if (close)
1969 goto close_only;
1970
1971 retval = zfcp_erp_adapter_strategy_open_qdio(erp_action);
1972 if (retval != ZFCP_ERP_SUCCEEDED)
1973 goto failed_qdio;
1974
1975 retval = zfcp_erp_adapter_strategy_open_fsf(erp_action);
1976 if (retval != ZFCP_ERP_SUCCEEDED)
1977 goto failed_openfcp;
1978
1979 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status);
1980 goto out;
1981
1982 close_only:
1983 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1984 &erp_action->adapter->status);
1985
1986 failed_openfcp:
2abbe866 1987 zfcp_close_fsf(erp_action->adapter);
1da177e4
LT		 1988 failed_qdio:
1989 out:
1990 return retval;
1991}
1992
1993/*
1994 * function: zfcp_qdio_init
1995 *
1996 * purpose: setup QDIO operation for specified adapter
1997 *
1998 * returns: 0 - successful setup
1999 * !0 - failed setup
2000 */
2001int
2002zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
2003{
2004 int retval;
2005 int i;
2006 volatile struct qdio_buffer_element *sbale;
2007 struct zfcp_adapter *adapter = erp_action->adapter;
2008
2009 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
2010 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "
2011 "adapter %s\n",
2012 zfcp_get_busid_by_adapter(adapter));
2013 goto failed_sanity;
2014 }
2015
2016 if (qdio_establish(&adapter->qdio_init_data) != 0) {
2017 ZFCP_LOG_INFO("error: establishment of QDIO queues failed "
2018 "on adapter %s\n",
2019 zfcp_get_busid_by_adapter(adapter));
2020 goto failed_qdio_establish;
2021 }
2022 debug_text_event(adapter->erp_dbf, 3, "qdio_est");
2023
2024 if (qdio_activate(adapter->ccw_device, 0) != 0) {
2025 ZFCP_LOG_INFO("error: activation of QDIO queues failed "
2026 "on adapter %s\n",
2027 zfcp_get_busid_by_adapter(adapter));
2028 goto failed_qdio_activate;
2029 }
2030 debug_text_event(adapter->erp_dbf, 3, "qdio_act");
2031
2032 /*
2033 * put buffers into response queue,
2034 */
2035 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
2036 sbale = &(adapter->response_queue.buffer[i]->element[0]);
2037 sbale->length = 0;
2038 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
6aae8738 2039 sbale->addr = NULL;
1da177e4
LT		 2040 }
2041
2042 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
2043 "queue_no=%i, index_in_queue=%i, count=%i)\n",
2044 zfcp_get_busid_by_adapter(adapter),
2045 QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);
2046
2047 retval = do_QDIO(adapter->ccw_device,
2048 QDIO_FLAG_SYNC_INPUT,
2049 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);
2050
2051 if (retval) {
2052 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",
2053 retval);
2054 goto failed_do_qdio;
2055 } else {
2056 adapter->response_queue.free_index = 0;
2057 atomic_set(&adapter->response_queue.free_count, 0);
2058 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "
2059 "response queue\n", QDIO_MAX_BUFFERS_PER_Q);
2060 }
2061 /* set index of first avalable SBALS / number of available SBALS */
2062 adapter->request_queue.free_index = 0;
2063 atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);
2064 adapter->request_queue.distance_from_int = 0;
2065
2066 /* initialize waitqueue used to wait for free SBALs in requests queue */
2067 init_waitqueue_head(&adapter->request_wq);
2068
2069 /* ok, we did it - skip all cleanups for different failures */
2070 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
2071 retval = ZFCP_ERP_SUCCEEDED;
2072 goto out;
2073
2074 failed_do_qdio:
2075 /* NOP */
2076
2077 failed_qdio_activate:
2078 debug_text_event(adapter->erp_dbf, 3, "qdio_down1a");
2079 while (qdio_shutdown(adapter->ccw_device,
2080 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
2081 msleep(1000);
2082 debug_text_event(adapter->erp_dbf, 3, "qdio_down1b");
2083
2084 failed_qdio_establish:
2085 failed_sanity:
2086 retval = ZFCP_ERP_FAILED;
2087
2088 out:
2089 return retval;
2090}
2091
1da177e4 2092
1da177e4
LT		 2093static int
2094zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
2095{
2448c459 2096 int retval;
aef4a983 2097
2448c459
AH		 2098 retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action);
2099 if (retval == ZFCP_ERP_FAILED)
2100 return ZFCP_ERP_FAILED;
2101
2102 retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action);
2103 if (retval == ZFCP_ERP_FAILED)
aef4a983 2104 return ZFCP_ERP_FAILED;
1da177e4 2105
aef4a983 2106 return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action);
1da177e4
LT		 2107}
2108
1da177e4
LT		 2109static int
2110zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
2111{
2112 int retval = ZFCP_ERP_SUCCEEDED;
2113 int retries;
22753fa5 2114 int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP;
1da177e4
LT		 2115 struct zfcp_adapter *adapter = erp_action->adapter;
2116
2117 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
1da177e4 2118
22753fa5 2119 for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) {
1da177e4
LT		 2120 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2121 &adapter->status);
2122 ZFCP_LOG_DEBUG("Doing exchange config data\n");
9f09c548 2123 write_lock_irq(&adapter->erp_lock);
1da177e4 2124 zfcp_erp_action_to_running(erp_action);
9f09c548 2125 write_unlock_irq(&adapter->erp_lock);
1da177e4
LT		 2126 if (zfcp_fsf_exchange_config_data(erp_action)) {
2127 retval = ZFCP_ERP_FAILED;
2128 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
2129 ZFCP_LOG_INFO("error: initiation of exchange of "
2130 "configuration data failed for "
2131 "adapter %s\n",
2132 zfcp_get_busid_by_adapter(adapter));
2133 break;
2134 }
2135 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok");
2136 ZFCP_LOG_DEBUG("Xchange underway\n");
2137
2138 /*
2139 * Why this works:
2140 * Both the normal completion handler as well as the timeout
2141 * handler will do an 'up' when the 'exchange config data'
2142 * request completes or times out. Thus, the signal to go on
2143 * won't be lost utilizing this semaphore.
2144 * Furthermore, this 'adapter_reopen' action is
2145 * guaranteed to be the only action being there (highest action
2146 * which prevents other actions from being created).
2147 * Resulting from that, the wake signal recognized here
2148 * _must_ be the one belonging to the 'exchange config
2149 * data' request.
2150 */
2151 down(&adapter->erp_ready_sem);
2152 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2153 ZFCP_LOG_INFO("error: exchange of configuration data "
2154 "for adapter %s timed out\n",
2155 zfcp_get_busid_by_adapter(adapter));
2156 break;
2157 }
22753fa5
AH		 2158
2159 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2160 &adapter->status))
2161 break;
2162
2163 ZFCP_LOG_DEBUG("host connection still initialising... "
2164 "waiting and retrying...\n");
2165 /* sleep a little bit before retry */
2166 msleep(jiffies_to_msecs(sleep));
2167 sleep *= 2;
2168 }
1da177e4
LT		 2169
2170 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
2171 &adapter->status)) {
2172 ZFCP_LOG_INFO("error: exchange of configuration data for "
2173 "adapter %s failed\n",
2174 zfcp_get_busid_by_adapter(adapter));
2175 retval = ZFCP_ERP_FAILED;
2176 }
2177
2178 return retval;
2179}
2180
aef4a983
MS		 2181static int
2182zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
2183{
2448c459 2184 int ret;
2f8f3ed5 2185 struct zfcp_adapter *adapter;
aef4a983 2186
2f8f3ed5 2187 adapter = erp_action->adapter;
aef4a983
MS		 2188 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
2189
9f09c548 2190 write_lock_irq(&adapter->erp_lock);
2f8f3ed5 2191 zfcp_erp_action_to_running(erp_action);
9f09c548 2192 write_unlock_irq(&adapter->erp_lock);
aef4a983 2193
2f8f3ed5
AH		 2194 ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);
2195 if (ret == -EOPNOTSUPP) {
2196 debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");
2197 return ZFCP_ERP_SUCCEEDED;
2198 } else if (ret) {
2199 debug_text_event(adapter->erp_dbf, 3, "a_xport_failed");
2200 return ZFCP_ERP_FAILED;
2201 }
2202 debug_text_event(adapter->erp_dbf, 6, "a_xport_ok");
2203
2204 ret = ZFCP_ERP_SUCCEEDED;
2205 down(&adapter->erp_ready_sem);
2206 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2207 ZFCP_LOG_INFO("error: exchange port data timed out (adapter "
2208 "%s)\n", zfcp_get_busid_by_adapter(adapter));
2209 ret = ZFCP_ERP_FAILED;
2210 }
f6c0e7a7
AH		 2211
2212 /* don't treat as error for the sake of compatibility */
2213 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status))
2214 ZFCP_LOG_INFO("warning: exchange port data failed (adapter "
2f8f3ed5 2215 "%s\n", zfcp_get_busid_by_adapter(adapter));
aef4a983 2216
2f8f3ed5 2217 return ret;
aef4a983
MS		 2218}
2219
1da177e4
LT		 2220static int
2221zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
2222 *erp_action)
2223{
2224 int retval = ZFCP_ERP_SUCCEEDED;
2225 int temp_ret;
2226 struct zfcp_adapter *adapter = erp_action->adapter;
2227 int i;
2228
2229 adapter->status_read_failed = 0;
2230 for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) {
2231 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL);
2232 if (temp_ret < 0) {
2233 ZFCP_LOG_INFO("error: set-up of unsolicited status "
2234 "notification failed on adapter %s\n",
2235 zfcp_get_busid_by_adapter(adapter));
2236 retval = ZFCP_ERP_FAILED;
2237 i--;
2238 break;
2239 }
2240 }
2241
2242 return retval;
2243}
2244
1da177e4
LT		 2245/*
2246 * function:
2247 *
2248 * purpose: this routine executes the 'Reopen Physical Port' action
2249 *
2250 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2251 * ZFCP_ERP_SUCCEEDED - action finished successfully
2252 * ZFCP_ERP_FAILED - action finished unsuccessfully
2253 */
2254static int
2255zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
2256{
2257 int retval = ZFCP_ERP_FAILED;
2258 struct zfcp_port *port = erp_action->port;
2259 struct zfcp_adapter *adapter = erp_action->adapter;
2260
2261 switch (erp_action->step) {
2262
2263 /*
2264 * FIXME:
2265 * the ULP spec. begs for waiting for oustanding commands
2266 */
2267 case ZFCP_ERP_STEP_UNINITIALIZED:
2268 zfcp_erp_port_strategy_clearstati(port);
2269 /*
2270 * it would be sufficient to test only the normal open flag
2271 * since the phys. open flag cannot be set if the normal
2272 * open flag is unset - however, this is for readabilty ...
2273 */
2274 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
2275 ZFCP_STATUS_COMMON_OPEN),
2276 &port->status)) {
2277 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2278 "close physical\n", port->wwpn);
2279 retval =
2280 zfcp_erp_port_forced_strategy_close(erp_action);
2281 } else
2282 retval = ZFCP_ERP_FAILED;
2283 break;
2284
2285 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2286 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
2287 &port->status)) {
2288 ZFCP_LOG_DEBUG("close physical failed for port "
2289 "0x%016Lx\n", port->wwpn);
2290 retval = ZFCP_ERP_FAILED;
2291 } else
2292 retval = ZFCP_ERP_SUCCEEDED;
2293 break;
2294 }
2295
2296 debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret");
2297 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2298 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2299 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2300
2301 return retval;
2302}
2303
2304/*
2305 * function:
2306 *
2307 * purpose: this routine executes the 'Reopen Port' action
2308 *
2309 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2310 * ZFCP_ERP_SUCCEEDED - action finished successfully
2311 * ZFCP_ERP_FAILED - action finished unsuccessfully
2312 */
2313static int
2314zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
2315{
2316 int retval = ZFCP_ERP_FAILED;
2317 struct zfcp_port *port = erp_action->port;
2318 struct zfcp_adapter *adapter = erp_action->adapter;
2319
2320 switch (erp_action->step) {
2321
2322 /*
2323 * FIXME:
2324 * the ULP spec. begs for waiting for oustanding commands
2325 */
2326 case ZFCP_ERP_STEP_UNINITIALIZED:
2327 zfcp_erp_port_strategy_clearstati(port);
2328 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2329 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2330 "close\n", port->wwpn);
2331 retval = zfcp_erp_port_strategy_close(erp_action);
2332 goto out;
2333 } /* else it's already closed, open it */
2334 break;
2335
2336 case ZFCP_ERP_STEP_PORT_CLOSING:
2337 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2338 ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
2339 port->wwpn);
2340 retval = ZFCP_ERP_FAILED;
2341 goto out;
2342 } /* else it's closed now, open it */
2343 break;
2344 }
2345 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2346 retval = ZFCP_ERP_EXIT;
2347 else
2348 retval = zfcp_erp_port_strategy_open(erp_action);
2349
2350 out:
2351 debug_text_event(adapter->erp_dbf, 3, "p_pst/ret");
2352 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2353 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2354 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2355
2356 return retval;
2357}
2358
1da177e4
LT		 2359static int
2360zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
2361{
2362 int retval;
2363
2364 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2365 &erp_action->port->status))
2366 retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
2367 else
2368 retval = zfcp_erp_port_strategy_open_common(erp_action);
2369
2370 return retval;
2371}
2372
1da177e4
LT		 2373static int
2374zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
2375{
2376 int retval = 0;
2377 struct zfcp_adapter *adapter = erp_action->adapter;
2378 struct zfcp_port *port = erp_action->port;
2379
2380 switch (erp_action->step) {
2381
2382 case ZFCP_ERP_STEP_UNINITIALIZED:
2383 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2384 case ZFCP_ERP_STEP_PORT_CLOSING:
ad757cdf 2385 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
6f71d9bc
JB		 2386 if (port->wwpn != adapter->peer_wwpn) {
2387 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
2388 "on adapter %s.\nPeer WWPN "
2389 "0x%016Lx does not match\n",
2390 port->wwpn,
2391 zfcp_get_busid_by_adapter(adapter),
2392 adapter->peer_wwpn);
2393 zfcp_erp_port_failed(port);
2394 retval = ZFCP_ERP_FAILED;
2395 break;
2396 }
2397 port->d_id = adapter->peer_d_id;
2398 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
2399 retval = zfcp_erp_port_strategy_open_port(erp_action);
2400 break;
2401 }
1da177e4
LT		 2402 if (!(adapter->nameserver_port)) {
2403 retval = zfcp_nameserver_enqueue(adapter);
2404 if (retval != 0) {
2405 ZFCP_LOG_NORMAL("error: nameserver port "
2406 "unavailable for adapter %s\n",
2407 zfcp_get_busid_by_adapter(adapter));
2408 retval = ZFCP_ERP_FAILED;
2409 break;
2410 }
2411 }
2412 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
2413 &adapter->nameserver_port->status)) {
2414 ZFCP_LOG_DEBUG("nameserver port is not open -> open "
2415 "nameserver port\n");
2416 /* nameserver port may live again */
2417 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
2418 &adapter->nameserver_port->status);
2419 if (zfcp_erp_port_reopen(adapter->nameserver_port, 0)
2420 >= 0) {
2421 erp_action->step =
2422 ZFCP_ERP_STEP_NAMESERVER_OPEN;
2423 retval = ZFCP_ERP_CONTINUES;
2424 } else
2425 retval = ZFCP_ERP_FAILED;
2426 break;
2427 }
2428 /* else nameserver port is already open, fall through */
2429 case ZFCP_ERP_STEP_NAMESERVER_OPEN:
2430 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
2431 &adapter->nameserver_port->status)) {
2432 ZFCP_LOG_DEBUG("open failed for nameserver port\n");
2433 retval = ZFCP_ERP_FAILED;
2434 } else {
2435 ZFCP_LOG_DEBUG("nameserver port is open -> "
2436 "nameserver look-up for port 0x%016Lx\n",
2437 port->wwpn);
2438 retval = zfcp_erp_port_strategy_open_common_lookup
2439 (erp_action);
2440 }
2441 break;
2442
2443 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
2444 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
2445 if (atomic_test_mask
2446 (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
2447 ZFCP_LOG_DEBUG("nameserver look-up failed "
2448 "for port 0x%016Lx "
2449 "(misconfigured WWPN?)\n",
2450 port->wwpn);
2451 zfcp_erp_port_failed(port);
2452 retval = ZFCP_ERP_EXIT;
2453 } else {
2454 ZFCP_LOG_DEBUG("nameserver look-up failed for "
2455 "port 0x%016Lx\n", port->wwpn);
2456 retval = ZFCP_ERP_FAILED;
2457 }
2458 } else {
1d589edf 2459 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> "
1da177e4
LT		 2460 "trying open\n", port->wwpn, port->d_id);
2461 retval = zfcp_erp_port_strategy_open_port(erp_action);
2462 }
2463 break;
2464
2465 case ZFCP_ERP_STEP_PORT_OPENING:
2466 /* D_ID might have changed during open */
2467 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
2468 ZFCP_STATUS_PORT_DID_DID),
2469 &port->status)) {
2470 ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
2471 retval = ZFCP_ERP_SUCCEEDED;
2472 } else {
2473 ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
2474 port->wwpn);
2475 retval = ZFCP_ERP_FAILED;
2476 }
2477 break;
2478
2479 default:
2480 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2481 erp_action->step);
2482 retval = ZFCP_ERP_FAILED;
2483 }
2484
2485 return retval;
2486}
2487
1da177e4
LT		 2488static int
2489zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
2490{
2491 int retval;
2492 struct zfcp_port *port = erp_action->port;
2493
2494 switch (erp_action->step) {
2495
2496 case ZFCP_ERP_STEP_UNINITIALIZED:
2497 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2498 case ZFCP_ERP_STEP_PORT_CLOSING:
1d589edf 2499 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> trying open\n",
1da177e4
LT		 2500 port->wwpn, port->d_id);
2501 retval = zfcp_erp_port_strategy_open_port(erp_action);
2502 break;
2503
2504 case ZFCP_ERP_STEP_PORT_OPENING:
2505 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2506 ZFCP_LOG_DEBUG("WKA port is open\n");
2507 retval = ZFCP_ERP_SUCCEEDED;
2508 } else {
2509 ZFCP_LOG_DEBUG("open failed for WKA port\n");
2510 retval = ZFCP_ERP_FAILED;
2511 }
2512 /* this is needed anyway (dont care for retval of wakeup) */
2513 ZFCP_LOG_DEBUG("continue other open port operations\n");
2514 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
2515 break;
2516
2517 default:
2518 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2519 erp_action->step);
2520 retval = ZFCP_ERP_FAILED;
2521 }
2522
2523 return retval;
2524}
2525
2526/*
2527 * function:
2528 *
2529 * purpose: makes the erp thread continue with reopen (physical) port
2530 * actions which have been paused until the name server port
2531 * is opened (or failed)
2532 *
2533 * returns: 0 (a kind of void retval, its not used)
2534 */
2535static int
2536zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
2537 *ns_erp_action)
2538{
2539 int retval = 0;
2540 unsigned long flags;
2541 struct zfcp_adapter *adapter = ns_erp_action->adapter;
2542 struct zfcp_erp_action *erp_action, *tmp;
2543
2544 read_lock_irqsave(&adapter->erp_lock, flags);
2545 list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
2546 list) {
2547 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n");
2548 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn,
2549 sizeof (wwn_t));
2550 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
2551 debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w");
2552 debug_event(adapter->erp_dbf, 3,
2553 &erp_action->port->wwpn, sizeof (wwn_t));
2554 if (atomic_test_mask(
2555 ZFCP_STATUS_COMMON_ERP_FAILED,
2556 &adapter->nameserver_port->status))
2557 zfcp_erp_port_failed(erp_action->port);
2558 zfcp_erp_action_ready(erp_action);
2559 }
2560 }
2561 read_unlock_irqrestore(&adapter->erp_lock, flags);
2562
2563 return retval;
2564}
2565
2566/*
2567 * function:
2568 *
2569 * purpose:
2570 *
2571 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2572 * ZFCP_ERP_FAILED - action finished unsuccessfully
2573 */
2574static int
2575zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
2576{
2577 int retval;
2578 struct zfcp_adapter *adapter = erp_action->adapter;
2579 struct zfcp_port *port = erp_action->port;
2580
1da177e4
LT		 2581 retval = zfcp_fsf_close_physical_port(erp_action);
2582 if (retval == -ENOMEM) {
2583 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
2584 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2585 retval = ZFCP_ERP_NOMEM;
2586 goto out;
2587 }
2588 erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
2589 if (retval != 0) {
2590 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf");
2591 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2592 /* could not send 'open', fail */
2593 retval = ZFCP_ERP_FAILED;
2594 goto out;
2595 }
2596 debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok");
2597 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2598 retval = ZFCP_ERP_CONTINUES;
2599 out:
2600 return retval;
2601}
2602
1da177e4
LT		 2603static int
2604zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
2605{
2606 int retval = 0;
2607 struct zfcp_adapter *adapter = port->adapter;
2608
2609 debug_text_event(adapter->erp_dbf, 5, "p_pstclst");
2610 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2611
2612 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2613 ZFCP_STATUS_COMMON_CLOSING |
2614 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2615 ZFCP_STATUS_PORT_DID_DID |
2616 ZFCP_STATUS_PORT_PHYS_CLOSING |
2617 ZFCP_STATUS_PORT_INVALID_WWPN,
2618 &port->status);
2619 return retval;
2620}
2621
2622/*
2623 * function:
2624 *
2625 * purpose:
2626 *
2627 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2628 * ZFCP_ERP_FAILED - action finished unsuccessfully
2629 */
2630static int
2631zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
2632{
2633 int retval;
2634 struct zfcp_adapter *adapter = erp_action->adapter;
2635 struct zfcp_port *port = erp_action->port;
2636
1da177e4
LT		 2637 retval = zfcp_fsf_close_port(erp_action);
2638 if (retval == -ENOMEM) {
2639 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
2640 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2641 retval = ZFCP_ERP_NOMEM;
2642 goto out;
2643 }
2644 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
2645 if (retval != 0) {
2646 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf");
2647 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2648 /* could not send 'close', fail */
2649 retval = ZFCP_ERP_FAILED;
2650 goto out;
2651 }
2652 debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok");
2653 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2654 retval = ZFCP_ERP_CONTINUES;
2655 out:
2656 return retval;
2657}
2658
2659/*
2660 * function:
2661 *
2662 * purpose:
2663 *
2664 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2665 * ZFCP_ERP_FAILED - action finished unsuccessfully
2666 */
2667static int
2668zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
2669{
2670 int retval;
2671 struct zfcp_adapter *adapter = erp_action->adapter;
2672 struct zfcp_port *port = erp_action->port;
2673
1da177e4
LT		 2674 retval = zfcp_fsf_open_port(erp_action);
2675 if (retval == -ENOMEM) {
2676 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
2677 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2678 retval = ZFCP_ERP_NOMEM;
2679 goto out;
2680 }
2681 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
2682 if (retval != 0) {
2683 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf");
2684 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2685 /* could not send 'open', fail */
2686 retval = ZFCP_ERP_FAILED;
2687 goto out;
2688 }
2689 debug_text_event(adapter->erp_dbf, 6, "p_psto_opok");
2690 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2691 retval = ZFCP_ERP_CONTINUES;
2692 out:
2693 return retval;
2694}
2695
2696/*
2697 * function:
2698 *
2699 * purpose:
2700 *
2701 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2702 * ZFCP_ERP_FAILED - action finished unsuccessfully
2703 */
2704static int
2705zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
2706{
2707 int retval;
2708 struct zfcp_adapter *adapter = erp_action->adapter;
2709 struct zfcp_port *port = erp_action->port;
2710
1da177e4
LT		 2711 retval = zfcp_ns_gid_pn_request(erp_action);
2712 if (retval == -ENOMEM) {
2713 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
2714 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2715 retval = ZFCP_ERP_NOMEM;
2716 goto out;
2717 }
2718 erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
2719 if (retval != 0) {
2720 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref");
2721 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2722 /* could not send nameserver request, fail */
2723 retval = ZFCP_ERP_FAILED;
2724 goto out;
2725 }
2726 debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok");
2727 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2728 retval = ZFCP_ERP_CONTINUES;
2729 out:
2730 return retval;
2731}
2732
2733/*
2734 * function:
2735 *
2736 * purpose: this routine executes the 'Reopen Unit' action
2737 * currently no retries
2738 *
2739 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2740 * ZFCP_ERP_SUCCEEDED - action finished successfully
2741 * ZFCP_ERP_FAILED - action finished unsuccessfully
2742 */
2743static int
2744zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
2745{
2746 int retval = ZFCP_ERP_FAILED;
2747 struct zfcp_unit *unit = erp_action->unit;
2748 struct zfcp_adapter *adapter = erp_action->adapter;
2749
2750 switch (erp_action->step) {
2751
2752 /*
2753 * FIXME:
2754 * the ULP spec. begs for waiting for oustanding commands
2755 */
2756 case ZFCP_ERP_STEP_UNINITIALIZED:
2757 zfcp_erp_unit_strategy_clearstati(unit);
2758 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2759 ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
2760 "trying close\n", unit->fcp_lun);
2761 retval = zfcp_erp_unit_strategy_close(erp_action);
2762 break;
2763 }
2764 /* else it's already closed, fall through */
2765 case ZFCP_ERP_STEP_UNIT_CLOSING:
2766 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2767 ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
2768 unit->fcp_lun);
2769 retval = ZFCP_ERP_FAILED;
2770 } else {
2771 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2772 retval = ZFCP_ERP_EXIT;
2773 else {
2774 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
2775 "trying open\n", unit->fcp_lun);
2776 retval =
2777 zfcp_erp_unit_strategy_open(erp_action);
2778 }
2779 }
2780 break;
2781
2782 case ZFCP_ERP_STEP_UNIT_OPENING:
2783 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2784 ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
2785 unit->fcp_lun);
2786 retval = ZFCP_ERP_SUCCEEDED;
2787 } else {
2788 ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
2789 unit->fcp_lun);
2790 retval = ZFCP_ERP_FAILED;
2791 }
2792 break;
2793 }
2794
2795 debug_text_event(adapter->erp_dbf, 3, "u_ust/ret");
2796 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t));
2797 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2798 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2799 return retval;
2800}
2801
1da177e4
LT		 2802static int
2803zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
2804{
2805 int retval = 0;
2806 struct zfcp_adapter *adapter = unit->port->adapter;
2807
2808 debug_text_event(adapter->erp_dbf, 5, "u_ustclst");
2809 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
2810
2811 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2812 ZFCP_STATUS_COMMON_CLOSING |
2813 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2814 ZFCP_STATUS_UNIT_SHARED |
2815 ZFCP_STATUS_UNIT_READONLY,
2816 &unit->status);
2817
2818 return retval;
2819}
2820
2821/*
2822 * function:
2823 *
2824 * purpose:
2825 *
2826 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2827 * ZFCP_ERP_FAILED - action finished unsuccessfully
2828 */
2829static int
2830zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
2831{
2832 int retval;
2833 struct zfcp_adapter *adapter = erp_action->adapter;
2834 struct zfcp_unit *unit = erp_action->unit;
2835
1da177e4
LT		 2836 retval = zfcp_fsf_close_unit(erp_action);
2837 if (retval == -ENOMEM) {
2838 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
2839 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2840 sizeof (fcp_lun_t));
2841 retval = ZFCP_ERP_NOMEM;
2842 goto out;
2843 }
2844 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
2845 if (retval != 0) {
2846 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf");
2847 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2848 sizeof (fcp_lun_t));
2849 /* could not send 'close', fail */
2850 retval = ZFCP_ERP_FAILED;
2851 goto out;
2852 }
2853 debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok");
2854 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2855 retval = ZFCP_ERP_CONTINUES;
2856
2857 out:
2858 return retval;
2859}
2860
2861/*
2862 * function:
2863 *
2864 * purpose:
2865 *
2866 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2867 * ZFCP_ERP_FAILED - action finished unsuccessfully
2868 */
2869static int
2870zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
2871{
2872 int retval;
2873 struct zfcp_adapter *adapter = erp_action->adapter;
2874 struct zfcp_unit *unit = erp_action->unit;
2875
1da177e4
LT		 2876 retval = zfcp_fsf_open_unit(erp_action);
2877 if (retval == -ENOMEM) {
2878 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
2879 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2880 sizeof (fcp_lun_t));
2881 retval = ZFCP_ERP_NOMEM;
2882 goto out;
2883 }
2884 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
2885 if (retval != 0) {
2886 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf");
2887 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2888 sizeof (fcp_lun_t));
2889 /* could not send 'open', fail */
2890 retval = ZFCP_ERP_FAILED;
2891 goto out;
2892 }
2893 debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok");
2894 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2895 retval = ZFCP_ERP_CONTINUES;
2896 out:
2897 return retval;
2898}
2899
2abbe866 2900void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)
1da177e4 2901{
2abbe866
AH		 2902 BUG_ON(!fsf_req->erp_action);
2903 fsf_req->timer.function = zfcp_erp_timeout_handler;
2904 fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
2905 fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;
2906 add_timer(&fsf_req->timer);
1da177e4
LT		 2907}
2908
2909/*
2910 * function:
2911 *
2912 * purpose: enqueue the specified error recovery action, if needed
2913 *
2914 * returns:
2915 */
2916static int
2917zfcp_erp_action_enqueue(int action,
2918 struct zfcp_adapter *adapter,
2919 struct zfcp_port *port, struct zfcp_unit *unit)
2920{
2921 int retval = 1;
2922 struct zfcp_erp_action *erp_action = NULL;
2923 int stronger_action = 0;
2924 u32 status = 0;
2925
2926 /*
2927 * We need some rules here which check whether we really need
2928 * this action or whether we should just drop it.
2929 * E.g. if there is a unfinished 'Reopen Port' request then we drop a
2930 * 'Reopen Unit' request for an associated unit since we can't
2931 * satisfy this request now. A 'Reopen Port' action will trigger
2932 * 'Reopen Unit' actions when it completes.
2933 * Thus, there are only actions in the queue which can immediately be
2934 * executed. This makes the processing of the action queue more
2935 * efficient.
2936 */
2937
2938 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
2939 &adapter->status))
2940 return -EIO;
2941
2942 debug_event(adapter->erp_dbf, 4, &action, sizeof (int));
2943 /* check whether we really need this */
2944 switch (action) {
2945 case ZFCP_ERP_ACTION_REOPEN_UNIT:
2946 if (atomic_test_mask
2947 (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
2948 debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp");
2949 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2950 sizeof (wwn_t));
2951 debug_event(adapter->erp_dbf, 4, &unit->fcp_lun,
2952 sizeof (fcp_lun_t));
2953 goto out;
2954 }
2955 if (!atomic_test_mask
2956 (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
2957 atomic_test_mask
2958 (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
2959 goto out;
2960 }
2961 if (!atomic_test_mask
2962 (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) {
2963 stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT;
2964 unit = NULL;
2965 }
2966 /* fall through !!! */
2967
2968 case ZFCP_ERP_ACTION_REOPEN_PORT:
2969 if (atomic_test_mask
2970 (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
2971 debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp");
2972 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2973 sizeof (wwn_t));
2974 goto out;
2975 }
2976 /* fall through !!! */
2977
2978 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3734d24b
AH		 2979 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2980 &port->status)) {
2981 if (port->erp_action.action !=
2982 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
2983 ZFCP_LOG_INFO("dropped erp action %i (port "
2984 "0x%016Lx, action in use: %i)\n",
2985 action, port->wwpn,
2986 port->erp_action.action);
2987 debug_text_event(adapter->erp_dbf, 4,
2988 "pf_actenq_drp");
2989 } else
2990 debug_text_event(adapter->erp_dbf, 4,
2991 "pf_actenq_drpcp");
1da177e4
LT		 2992 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2993 sizeof (wwn_t));
2994 goto out;
2995 }
2996 if (!atomic_test_mask
2997 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
2998 atomic_test_mask
2999 (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
3000 goto out;
3001 }
3002 if (!atomic_test_mask
3003 (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) {
3004 stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
3005 port = NULL;
3006 }
3007 /* fall through !!! */
3008
3009 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3010 if (atomic_test_mask
3011 (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
3012 debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp");
3013 goto out;
3014 }
3015 break;
3016
3017 default:
3018 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug");
3019 debug_event(adapter->erp_dbf, 1, &action, sizeof (int));
3020 ZFCP_LOG_NORMAL("bug: unknown erp action requested "
3021 "on adapter %s (action=%d)\n",
3022 zfcp_get_busid_by_adapter(adapter), action);
3023 goto out;
3024 }
3025
3026 /* check whether we need something stronger first */
3027 if (stronger_action) {
3028 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str");
3029 debug_event(adapter->erp_dbf, 4, &stronger_action,
3030 sizeof (int));
3031 ZFCP_LOG_DEBUG("stronger erp action %d needed before "
3032 "erp action %d on adapter %s\n",
3033 stronger_action, action,
3034 zfcp_get_busid_by_adapter(adapter));
3035 action = stronger_action;
3036 }
3037
3038 /* mark adapter to have some error recovery pending */
3039 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
3040
3041 /* setup error recovery action */
3042 switch (action) {
3043
3044 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3045 zfcp_unit_get(unit);
3046 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
3047 erp_action = &unit->erp_action;
3048 if (!atomic_test_mask
3049 (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
3050 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3051 break;
3052
3053 case ZFCP_ERP_ACTION_REOPEN_PORT:
3054 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3055 zfcp_port_get(port);
3056 zfcp_erp_action_dismiss_port(port);
3057 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
3058 erp_action = &port->erp_action;
3059 if (!atomic_test_mask
3060 (ZFCP_STATUS_COMMON_RUNNING, &port->status))
3061 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3062 break;
3063
3064 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3065 zfcp_adapter_get(adapter);
3066 zfcp_erp_action_dismiss_adapter(adapter);
3067 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
3068 erp_action = &adapter->erp_action;
3069 if (!atomic_test_mask
3070 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
3071 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3072 break;
3073 }
3074
3075 debug_text_event(adapter->erp_dbf, 4, "a_actenq");
3076
3077 memset(erp_action, 0, sizeof (struct zfcp_erp_action));
3078 erp_action->adapter = adapter;
3079 erp_action->port = port;
3080 erp_action->unit = unit;
3081 erp_action->action = action;
3082 erp_action->status = status;
3083
3084 ++adapter->erp_total_count;
3085
3086 /* finally put it into 'ready' queue and kick erp thread */
3087 list_add(&erp_action->list, &adapter->erp_ready_head);
3088 up(&adapter->erp_ready_sem);
3089 retval = 0;
3090 out:
3091 return retval;
3092}
3093
1da177e4
LT		 3094static int
3095zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
3096{
3097 int retval = 0;
3098 struct zfcp_adapter *adapter = erp_action->adapter;
3099
3100 --adapter->erp_total_count;
3101 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
3102 --adapter->erp_low_mem_count;
3103 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
3104 }
3105
3106 debug_text_event(adapter->erp_dbf, 4, "a_actdeq");
3107 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
3108 list_del(&erp_action->list);
3109 switch (erp_action->action) {
3110 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3111 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3112 &erp_action->unit->status);
3113 break;
3114 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3115 case ZFCP_ERP_ACTION_REOPEN_PORT:
3116 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3117 &erp_action->port->status);
3118 break;
3119 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3120 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3121 &erp_action->adapter->status);
3122 break;
3123 default:
3124 /* bug */
3125 break;
3126 }
3127 return retval;
3128}
3129
3130/**
3131 * zfcp_erp_action_cleanup
3132 *
575c9687 3133 * Register unit with scsi stack if appropriate and fix reference counts.
1da177e4
LT		 3134 * Note: Temporary units are not registered with scsi stack.
3135 */
3136static void
3137zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
3138 struct zfcp_port *port, struct zfcp_unit *unit,
3139 int result)
3140{
3141 switch (action) {
3142 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3143 if ((result == ZFCP_ERP_SUCCEEDED)
3144 && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
3145 &unit->status))
3859f6a2 3146 && !unit->device
ad58f7db
AH		 3147 && port->rport) {
3148 atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
3149 &unit->status);
5f852be9
CS		 3150 if (atomic_test_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING,
3151 &unit->status) == 0)
3152 zfcp_erp_schedule_work(unit);
ad58f7db 3153 }
1da177e4
LT		 3154 zfcp_unit_put(unit);
3155 break;
3156 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3157 case ZFCP_ERP_ACTION_REOPEN_PORT:
338151e0
AH		 3158 if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN,
3159 &port->status)) {
3160 zfcp_port_put(port);
3161 break;
3162 }
3163
3859f6a2 3164 if ((result == ZFCP_ERP_SUCCEEDED)
3859f6a2
AH		 3165 && !port->rport) {
3166 struct fc_rport_identifiers ids;
3167 ids.node_name = port->wwnn;
3168 ids.port_name = port->wwpn;
3169 ids.port_id = port->d_id;
3170 ids.roles = FC_RPORT_ROLE_FCP_TARGET;
3171 port->rport =
3172 fc_remote_port_add(adapter->scsi_host, 0, &ids);
3173 if (!port->rport)
3174 ZFCP_LOG_NORMAL("failed registration of rport"
3175 "(adapter %s, wwpn=0x%016Lx)\n",
3176 zfcp_get_busid_by_port(port),
3177 port->wwpn);
75bfc283 3178 else {
5f852be9 3179 scsi_target_unblock(&port->rport->dev);
75bfc283
RW		 3180 port->rport->maxframe_size = port->maxframe_size;
3181 port->rport->supported_classes =
3182 port->supported_classes;
3183 }
3859f6a2 3184 }
338151e0
AH		 3185 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
3186 fc_remote_port_delete(port->rport);
3187 port->rport = NULL;
3188 }
1da177e4
LT		 3189 zfcp_port_put(port);
3190 break;
3191 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
338151e0 3192 if (result != ZFCP_ERP_SUCCEEDED) {
338151e0
AH		 3193 list_for_each_entry(port, &adapter->port_list_head, list)
3194 if (port->rport &&
3195 !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
3196 &port->status)) {
3197 fc_remote_port_delete(port->rport);
3198 port->rport = NULL;
3199 }
3200 }
1da177e4
LT		 3201 zfcp_adapter_put(adapter);
3202 break;
3203 default:
3204 break;
3205 }
3206}
3207
3208
81654286 3209static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
1da177e4 3210{
1da177e4
LT		 3211 struct zfcp_port *port;
3212
3213 debug_text_event(adapter->erp_dbf, 5, "a_actab");
3214 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
3215 zfcp_erp_action_dismiss(&adapter->erp_action);
3216 else
3217 list_for_each_entry(port, &adapter->port_list_head, list)
3218 zfcp_erp_action_dismiss_port(port);
1da177e4
LT		 3219}
3220
f6c0e7a7 3221static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
1da177e4 3222{
1da177e4
LT		 3223 struct zfcp_unit *unit;
3224 struct zfcp_adapter *adapter = port->adapter;
3225
3226 debug_text_event(adapter->erp_dbf, 5, "p_actab");
3227 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
3228 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
3229 zfcp_erp_action_dismiss(&port->erp_action);
3230 else
3231 list_for_each_entry(unit, &port->unit_list_head, list)
3232 zfcp_erp_action_dismiss_unit(unit);
1da177e4
LT		 3233}
3234
f6c0e7a7 3235static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
1da177e4 3236{
1da177e4
LT		 3237 struct zfcp_adapter *adapter = unit->port->adapter;
3238
3239 debug_text_event(adapter->erp_dbf, 5, "u_actab");
3240 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
3241 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
3242 zfcp_erp_action_dismiss(&unit->erp_action);
1da177e4
LT		 3243}
3244
1da177e4
LT		 3245static inline void
3246zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
3247{
3248 struct zfcp_adapter *adapter = erp_action->adapter;
3249
3250 debug_text_event(adapter->erp_dbf, 6, "a_toru");
3251 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3252 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
3253}
3254
1da177e4
LT		 3255static inline void
3256zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
3257{
3258 struct zfcp_adapter *adapter = erp_action->adapter;
3259
3260 debug_text_event(adapter->erp_dbf, 6, "a_tore");
3261 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3262 list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
3263}
3264
d736a27b
AH		 3265void
3266zfcp_erp_port_boxed(struct zfcp_port *port)
3267{
3268 struct zfcp_adapter *adapter = port->adapter;
3269 unsigned long flags;
3270
3271 debug_text_event(adapter->erp_dbf, 3, "p_access_boxed");
3272 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3273 read_lock_irqsave(&zfcp_data.config_lock, flags);
3274 zfcp_erp_modify_port_status(port,
3275 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3276 ZFCP_SET);
3277 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3278 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED);
3279}
3280
d736a27b
AH		 3281void
3282zfcp_erp_unit_boxed(struct zfcp_unit *unit)
3283{
3284 struct zfcp_adapter *adapter = unit->port->adapter;
3285
3286 debug_text_event(adapter->erp_dbf, 3, "u_access_boxed");
3287 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3288 zfcp_erp_modify_unit_status(unit,
3289 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3290 ZFCP_SET);
3291 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
3292}
3293
1da177e4
LT		 3294void
3295zfcp_erp_port_access_denied(struct zfcp_port *port)
3296{
3297 struct zfcp_adapter *adapter = port->adapter;
3298 unsigned long flags;
3299
d736a27b 3300 debug_text_event(adapter->erp_dbf, 3, "p_access_denied");
1da177e4
LT		 3301 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3302 read_lock_irqsave(&zfcp_data.config_lock, flags);
d736a27b
AH		 3303 zfcp_erp_modify_port_status(port,
3304 ZFCP_STATUS_COMMON_ERP_FAILED |
3305 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3306 ZFCP_SET);
1da177e4
LT		 3307 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3308}
3309
1da177e4
LT		 3310void
3311zfcp_erp_unit_access_denied(struct zfcp_unit *unit)
3312{
3313 struct zfcp_adapter *adapter = unit->port->adapter;
3314
d736a27b 3315 debug_text_event(adapter->erp_dbf, 3, "u_access_denied");
1da177e4 3316 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
d736a27b
AH		 3317 zfcp_erp_modify_unit_status(unit,
3318 ZFCP_STATUS_COMMON_ERP_FAILED |
3319 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3320 ZFCP_SET);
1da177e4
LT		 3321}
3322
1da177e4
LT		 3323void
3324zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter)
3325{
3326 struct zfcp_port *port;
3327 unsigned long flags;
3328
aef4a983
MS		 3329 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
3330 return;
3331
d736a27b 3332 debug_text_event(adapter->erp_dbf, 3, "a_access_recover");
06506d00 3333 debug_event(adapter->erp_dbf, 3, zfcp_get_busid_by_adapter(adapter), 8);
1da177e4 3334
1da177e4 3335 read_lock_irqsave(&zfcp_data.config_lock, flags);
6f71d9bc
JB		 3336 if (adapter->nameserver_port)
3337 zfcp_erp_port_access_changed(adapter->nameserver_port);
1da177e4
LT		 3338 list_for_each_entry(port, &adapter->port_list_head, list)
3339 if (port != adapter->nameserver_port)
3340 zfcp_erp_port_access_changed(port);
3341 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3342}
3343
1da177e4
LT		 3344void
3345zfcp_erp_port_access_changed(struct zfcp_port *port)
3346{
3347 struct zfcp_adapter *adapter = port->adapter;
3348 struct zfcp_unit *unit;
3349
d736a27b 3350 debug_text_event(adapter->erp_dbf, 3, "p_access_recover");
1da177e4
LT		 3351 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3352
3353 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
d736a27b
AH		 3354 &port->status) &&
3355 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
1da177e4
LT		 3356 &port->status)) {
3357 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
3358 list_for_each_entry(unit, &port->unit_list_head, list)
3359 zfcp_erp_unit_access_changed(unit);
3360 return;
3361 }
3362
3363 ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
3364 "(due to ACT update)\n",
3365 port->wwpn, zfcp_get_busid_by_adapter(adapter));
3366 if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3367 ZFCP_LOG_NORMAL("failed reopen of port"
3368 "(adapter %s, wwpn=0x%016Lx)\n",
3369 zfcp_get_busid_by_adapter(adapter), port->wwpn);
3370}
3371
1da177e4
LT		 3372void
3373zfcp_erp_unit_access_changed(struct zfcp_unit *unit)
3374{
3375 struct zfcp_adapter *adapter = unit->port->adapter;
3376
d736a27b 3377 debug_text_event(adapter->erp_dbf, 3, "u_access_recover");
1da177e4
LT		 3378 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3379
d736a27b
AH		 3380 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3381 &unit->status) &&
3382 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3383 &unit->status))
1da177e4
LT		 3384 return;
3385
3386 ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
3387 " on adapter %s (due to ACT update)\n",
3388 unit->fcp_lun, unit->port->wwpn,
3389 zfcp_get_busid_by_adapter(adapter));
3390 if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3391 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
3392 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
3393 zfcp_get_busid_by_adapter(adapter),
3394 unit->port->wwpn, unit->fcp_lun);
3395}
3396
3397#undef ZFCP_LOG_AREA
ubuntu-bionic-kernel mirror