]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/s390/scsi/zfcp_erp.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] zfcp: Locking for req_no and req_seq_no
[net-next-2.6.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;
f6c0e7a7 182 zfcp_erp_adapter_reopen(adapter, 0);
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);
ca880cf9
SS		 850 if (zfcp_reqlist_ismember(adapter,
851 erp_action->fsf_req->req_id)) {
1da177e4
LT		 852 /* fsf_req still exists */
853 debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
ca880cf9 854 debug_event(adapter->erp_dbf, 3, &erp_action->fsf_req,
1da177e4 855 sizeof (unsigned long));
fea9d6c7 856 /* dismiss fsf_req of timed out/dismissed erp_action */
1da177e4
LT		 857 if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED |
858 ZFCP_STATUS_ERP_TIMEDOUT)) {
859 debug_text_event(adapter->erp_dbf, 3,
860 "a_ca_disreq");
ca880cf9
SS		 861 erp_action->fsf_req->status |=
862 ZFCP_STATUS_FSFREQ_DISMISSED;
1da177e4
LT		 863 }
864 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
865 ZFCP_LOG_NORMAL("error: erp step timed out "
866 "(action=%d, fsf_req=%p)\n ",
867 erp_action->action,
868 erp_action->fsf_req);
869 }
870 /*
871 * If fsf_req is neither dismissed nor completed
872 * then keep it running asynchronously and don't mess
873 * with the association of erp_action and fsf_req.
874 */
ca880cf9
SS		 875 if (erp_action->fsf_req->status &
876 (ZFCP_STATUS_FSFREQ_COMPLETED |
1da177e4
LT		 877 ZFCP_STATUS_FSFREQ_DISMISSED)) {
878 /* forget about association between fsf_req
879 and erp_action */
1da177e4
LT		 880 erp_action->fsf_req = NULL;
881 }
882 } else {
883 debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq");
884 /*
885 * even if this fsf_req has gone, forget about
886 * association between erp_action and fsf_req
887 */
888 erp_action->fsf_req = NULL;
889 }
fea9d6c7 890 spin_unlock(&adapter->req_list_lock);
1da177e4
LT		 891 } else
892 debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq");
1da177e4
LT		 893}
894
f6c0e7a7
AH		 895/**
896 * zfcp_erp_async_handler_nolock - complete erp_action
1da177e4 897 *
f6c0e7a7
AH		 898 * Used for normal completion, time-out, dismissal and failure after
899 * low memory condition.
1da177e4 900 */
f6c0e7a7
AH		 901static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
902 unsigned long set_mask)
1da177e4 903{
1da177e4
LT		 904 struct zfcp_adapter *adapter = erp_action->adapter;
905
906 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
907 debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");
908 debug_event(adapter->erp_dbf, 2, &erp_action->action,
909 sizeof (int));
1da177e4
LT		 910 erp_action->status |= set_mask;
911 zfcp_erp_action_ready(erp_action);
1da177e4
LT		 912 } else {
913 /* action is ready or gone - nothing to do */
914 debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone");
915 debug_event(adapter->erp_dbf, 3, &erp_action->action,
916 sizeof (int));
1da177e4 917 }
1da177e4
LT		 918}
919
f6c0e7a7
AH		 920/**
921 * zfcp_erp_async_handler - wrapper for erp_async_handler_nolock w/ locking
1da177e4 922 */
f6c0e7a7
AH		 923void zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
924 unsigned long set_mask)
1da177e4
LT		 925{
926 struct zfcp_adapter *adapter = erp_action->adapter;
927 unsigned long flags;
1da177e4
LT		 928
929 write_lock_irqsave(&adapter->erp_lock, flags);
f6c0e7a7 930 zfcp_erp_async_handler_nolock(erp_action, set_mask);
1da177e4 931 write_unlock_irqrestore(&adapter->erp_lock, flags);
1da177e4
LT		 932}
933
934/*
935 * purpose: is called for erp_action which was slept waiting for
936 * memory becoming avaliable,
937 * will trigger that this action will be continued
938 */
939static void
940zfcp_erp_memwait_handler(unsigned long data)
941{
942 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
943 struct zfcp_adapter *adapter = erp_action->adapter;
944
945 debug_text_event(adapter->erp_dbf, 2, "a_mwh");
946 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
947
948 zfcp_erp_async_handler(erp_action, 0);
949}
950
951/*
952 * purpose: is called if an asynchronous erp step timed out,
953 * action gets an appropriate flag and will be processed
954 * accordingly
955 */
2abbe866 956void zfcp_erp_timeout_handler(unsigned long data)
1da177e4
LT		 957{
958 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
959 struct zfcp_adapter *adapter = erp_action->adapter;
960
961 debug_text_event(adapter->erp_dbf, 2, "a_th");
962 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
963
964 zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT);
965}
966
f6c0e7a7
AH		 967/**
968 * zfcp_erp_action_dismiss - dismiss an erp_action
1da177e4 969 *
f6c0e7a7
AH		 970 * adapter->erp_lock must be held
971 *
972 * Dismissal of an erp_action is usually required if an erp_action of
973 * higher priority is generated.
1da177e4 974 */
f6c0e7a7 975static void zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
1da177e4
LT		 976{
977 struct zfcp_adapter *adapter = erp_action->adapter;
978
979 debug_text_event(adapter->erp_dbf, 2, "a_adis");
980 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
981
982 zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED);
1da177e4
LT		 983}
984
985int
986zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
987{
988 int retval = 0;
989
990 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
991
1da177e4
LT		 992 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
993 if (retval < 0) {
994 ZFCP_LOG_NORMAL("error: creation of erp thread failed for "
995 "adapter %s\n",
996 zfcp_get_busid_by_adapter(adapter));
997 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail");
998 } else {
999 wait_event(adapter->erp_thread_wqh,
1000 atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1001 &adapter->status));
1002 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok");
1003 }
1004
1005 return (retval < 0);
1006}
1007
1008/*
1009 * function:
1010 *
1011 * purpose:
1012 *
1013 * returns:
1014 *
1015 * context: process (i.e. proc-fs or rmmod/insmod)
1016 *
1017 * note: The caller of this routine ensures that the specified
1018 * adapter has been shut down and that this operation
1019 * has been completed. Thus, there are no pending erp_actions
1020 * which would need to be handled here.
1021 */
1022int
1023zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1024{
1025 int retval = 0;
1026
1027 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1028 up(&adapter->erp_ready_sem);
1029
1030 wait_event(adapter->erp_thread_wqh,
1031 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1032 &adapter->status));
1033
1034 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1035 &adapter->status);
1036
1037 debug_text_event(adapter->erp_dbf, 5, "a_thki_ok");
1038
1039 return retval;
1040}
1041
1042/*
1043 * purpose: is run as a kernel thread,
1044 * goes through list of error recovery actions of associated adapter
1045 * and delegates single action to execution
1046 *
1047 * returns: 0
1048 */
1049static int
1050zfcp_erp_thread(void *data)
1051{
1052 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1053 struct list_head *next;
1054 struct zfcp_erp_action *erp_action;
1055 unsigned long flags;
1056
1057 daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter));
1058 /* Block all signals */
1059 siginitsetinv(&current->blocked, 0);
1060 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1061 debug_text_event(adapter->erp_dbf, 5, "a_th_run");
1062 wake_up(&adapter->erp_thread_wqh);
1063
1064 while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1065 &adapter->status)) {
1066
1067 write_lock_irqsave(&adapter->erp_lock, flags);
1068 next = adapter->erp_ready_head.prev;
1069 write_unlock_irqrestore(&adapter->erp_lock, flags);
1070
1071 if (next != &adapter->erp_ready_head) {
1072 erp_action =
1073 list_entry(next, struct zfcp_erp_action, list);
1074 /*
1075 * process action (incl. [re]moving it
1076 * from 'ready' queue)
1077 */
1078 zfcp_erp_strategy(erp_action);
1079 }
1080
1081 /*
1082 * sleep as long as there is nothing to do, i.e.
1083 * no action in 'ready' queue to be processed and
1084 * thread is not to be killed
1085 */
1086 down_interruptible(&adapter->erp_ready_sem);
1087 debug_text_event(adapter->erp_dbf, 5, "a_th_woken");
1088 }
1089
1090 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1091 debug_text_event(adapter->erp_dbf, 5, "a_th_stop");
1092 wake_up(&adapter->erp_thread_wqh);
1093
1094 return 0;
1095}
1096
1097/*
1098 * function:
1099 *
1100 * purpose: drives single error recovery action and schedules higher and
1101 * subordinate actions, if necessary
1102 *
1103 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
1104 * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd)
1105 * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd)
1106 * ZFCP_ERP_EXIT - action finished (dequeued), offline
1107 * ZFCP_ERP_DISMISSED - action canceled (dequeued)
1108 */
1109static int
1110zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1111{
1112 int retval = 0;
1113 struct zfcp_adapter *adapter = erp_action->adapter;
1114 struct zfcp_port *port = erp_action->port;
1115 struct zfcp_unit *unit = erp_action->unit;
1116 int action = erp_action->action;
1117 u32 status = erp_action->status;
1118 unsigned long flags;
1119
1120 /* serialise dismissing, timing out, moving, enqueueing */
1121 read_lock_irqsave(&zfcp_data.config_lock, flags);
1122 write_lock(&adapter->erp_lock);
1123
1124 /* dequeue dismissed action and leave, if required */
1125 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1126 if (retval == ZFCP_ERP_DISMISSED) {
1127 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1");
1128 goto unlock;
1129 }
1130
1131 /*
1132 * move action to 'running' queue before processing it
1133 * (to avoid a race condition regarding moving the
1134 * action to the 'running' queue and back)
1135 */
1136 zfcp_erp_action_to_running(erp_action);
1137
1138 /*
1139 * try to process action as far as possible,
1140 * no lock to allow for blocking operations (kmalloc, qdio, ...),
1141 * afterwards the lock is required again for the following reasons:
1142 * - dequeueing of finished action and enqueueing of
1143 * follow-up actions must be atomic so that any other
1144 * reopen-routine does not believe there is nothing to do
1145 * and that it is safe to enqueue something else,
1146 * - we want to force any control thread which is dismissing
1147 * actions to finish this before we decide about
1148 * necessary steps to be taken here further
1149 */
1150 write_unlock(&adapter->erp_lock);
1151 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1152 retval = zfcp_erp_strategy_do_action(erp_action);
1153 read_lock_irqsave(&zfcp_data.config_lock, flags);
1154 write_lock(&adapter->erp_lock);
1155
1156 /*
1157 * check for dismissed status again to avoid follow-up actions,
1158 * failing of targets and so on for dismissed actions
1159 */
1160 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1161
1162 switch (retval) {
1163 case ZFCP_ERP_DISMISSED:
1164 /* leave since this action has ridden to its ancestors */
1165 debug_text_event(adapter->erp_dbf, 6, "a_st_dis2");
1166 goto unlock;
1167 case ZFCP_ERP_NOMEM:
1168 /* no memory to continue immediately, let it sleep */
1169 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1170 ++adapter->erp_low_mem_count;
1171 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1172 }
1173 /* This condition is true if there is no memory available
1174 for any erp_action on this adapter. This implies that there
1175 are no elements in the memory pool(s) left for erp_actions.
1176 This might happen if an erp_action that used a memory pool
1177 element was timed out.
1178 */
1179 if (adapter->erp_total_count == adapter->erp_low_mem_count) {
1180 debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem");
1181 ZFCP_LOG_NORMAL("error: no mempool elements available, "
1182 "restarting I/O on adapter %s "
1183 "to free mempool\n",
1184 zfcp_get_busid_by_adapter(adapter));
1185 zfcp_erp_adapter_reopen_internal(adapter, 0);
1186 } else {
1187 debug_text_event(adapter->erp_dbf, 2, "a_st_memw");
1188 retval = zfcp_erp_strategy_memwait(erp_action);
1189 }
1190 goto unlock;
1191 case ZFCP_ERP_CONTINUES:
1192 /* leave since this action runs asynchronously */
1193 debug_text_event(adapter->erp_dbf, 6, "a_st_cont");
1194 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1195 --adapter->erp_low_mem_count;
1196 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1197 }
1198 goto unlock;
1199 }
1200 /* ok, finished action (whatever its result is) */
1201
1202 /* check for unrecoverable targets */
1203 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1204
1205 /* action must be dequeued (here to allow for further ones) */
1206 zfcp_erp_action_dequeue(erp_action);
1207
1208 /*
1209 * put this target through the erp mill again if someone has
1210 * requested to change the status of a target being online
1211 * to offline or the other way around
1212 * (old retval is preserved if nothing has to be done here)
1213 */
1214 retval = zfcp_erp_strategy_statechange(action, status, adapter,
1215 port, unit, retval);
1216
1217 /*
1218 * leave if target is in permanent error state or if
1219 * action is repeated in order to process state change
1220 */
1221 if (retval == ZFCP_ERP_EXIT) {
1222 debug_text_event(adapter->erp_dbf, 2, "a_st_exit");
1223 goto unlock;
1224 }
1225
1226 /* trigger follow up actions */
1227 zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval);
1228
1229 unlock:
1230 write_unlock(&adapter->erp_lock);
1231 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1232
1233 if (retval != ZFCP_ERP_CONTINUES)
1234 zfcp_erp_action_cleanup(action, adapter, port, unit, retval);
1235
1236 /*
1237 * a few tasks remain when the erp queues are empty
1238 * (don't do that if the last action evaluated was dismissed
1239 * since this clearly indicates that there is more to come) :
1240 * - close the name server port if it is open yet
1241 * (enqueues another [probably] final action)
1242 * - otherwise, wake up whoever wants to be woken when we are
1243 * done with erp
1244 */
1245 if (retval != ZFCP_ERP_DISMISSED)
1246 zfcp_erp_strategy_check_queues(adapter);
1247
1248 debug_text_event(adapter->erp_dbf, 6, "a_st_done");
1249
1250 return retval;
1251}
1252
1253/*
1254 * function:
1255 *
1256 * purpose:
1257 *
1258 * returns: ZFCP_ERP_DISMISSED - if action has been dismissed
1259 * retval - otherwise
1260 */
1261static int
1262zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval)
1263{
1264 struct zfcp_adapter *adapter = erp_action->adapter;
1265
1266 zfcp_erp_strategy_check_fsfreq(erp_action);
1267
1268 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1269 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1270 debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis");
1271 zfcp_erp_action_dequeue(erp_action);
1272 retval = ZFCP_ERP_DISMISSED;
1273 } else
1274 debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis");
1275
1276 return retval;
1277}
1278
1da177e4
LT		 1279static int
1280zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1281{
1282 int retval = ZFCP_ERP_FAILED;
1283 struct zfcp_adapter *adapter = erp_action->adapter;
1284
1285 /*
1286 * try to execute/continue action as far as possible,
1287 * note: no lock in subsequent strategy routines
1288 * (this allows these routine to call schedule, e.g.
1289 * kmalloc with such flags or qdio_initialize & friends)
1290 * Note: in case of timeout, the seperate strategies will fail
1291 * anyhow. No need for a special action. Even worse, a nameserver
1292 * failure would not wake up waiting ports without the call.
1293 */
1294 switch (erp_action->action) {
1295
1296 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1297 retval = zfcp_erp_adapter_strategy(erp_action);
1298 break;
1299
1300 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1301 retval = zfcp_erp_port_forced_strategy(erp_action);
1302 break;
1303
1304 case ZFCP_ERP_ACTION_REOPEN_PORT:
1305 retval = zfcp_erp_port_strategy(erp_action);
1306 break;
1307
1308 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1309 retval = zfcp_erp_unit_strategy(erp_action);
1310 break;
1311
1312 default:
1313 debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug");
1314 debug_event(adapter->erp_dbf, 1, &erp_action->action,
1315 sizeof (int));
1316 ZFCP_LOG_NORMAL("bug: unknown erp action requested on "
1317 "adapter %s (action=%d)\n",
1318 zfcp_get_busid_by_adapter(erp_action->adapter),
1319 erp_action->action);
1320 }
1321
1322 return retval;
1323}
1324
1325/*
1326 * function:
1327 *
1328 * purpose: triggers retry of this action after a certain amount of time
1329 * by means of timer provided by erp_action
1330 *
1331 * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue
1332 */
1333static int
1334zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
1335{
1336 int retval = ZFCP_ERP_CONTINUES;
1337 struct zfcp_adapter *adapter = erp_action->adapter;
1338
1339 debug_text_event(adapter->erp_dbf, 6, "a_mwinit");
1340 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
1341 init_timer(&erp_action->timer);
1342 erp_action->timer.function = zfcp_erp_memwait_handler;
1343 erp_action->timer.data = (unsigned long) erp_action;
1344 erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT;
1345 add_timer(&erp_action->timer);
1346
1347 return retval;
1348}
1349
1350/*
1351 * function: zfcp_erp_adapter_failed
1352 *
1353 * purpose: sets the adapter and all underlying devices to ERP_FAILED
1354 *
1355 */
1356void
1357zfcp_erp_adapter_failed(struct zfcp_adapter *adapter)
1358{
1359 zfcp_erp_modify_adapter_status(adapter,
1360 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1361 ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n",
1362 zfcp_get_busid_by_adapter(adapter));
1363 debug_text_event(adapter->erp_dbf, 2, "a_afail");
1364}
1365
1366/*
1367 * function: zfcp_erp_port_failed
1368 *
1369 * purpose: sets the port and all underlying devices to ERP_FAILED
1370 *
1371 */
1372void
1373zfcp_erp_port_failed(struct zfcp_port *port)
1374{
1375 zfcp_erp_modify_port_status(port,
1376 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1377
1378 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1379 ZFCP_LOG_NORMAL("port erp failed (adapter %s, "
1d589edf 1380 "port d_id=0x%06x)\n",
1da177e4
LT		 1381 zfcp_get_busid_by_port(port), port->d_id);
1382 else
1383 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n",
1384 zfcp_get_busid_by_port(port), port->wwpn);
1385
1386 debug_text_event(port->adapter->erp_dbf, 2, "p_pfail");
1387 debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t));
1388}
1389
1390/*
1391 * function: zfcp_erp_unit_failed
1392 *
1393 * purpose: sets the unit to ERP_FAILED
1394 *
1395 */
1396void
1397zfcp_erp_unit_failed(struct zfcp_unit *unit)
1398{
1399 zfcp_erp_modify_unit_status(unit,
1400 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1401
1402 ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx "
1403 " on adapter %s\n", unit->fcp_lun,
1404 unit->port->wwpn, zfcp_get_busid_by_unit(unit));
1405 debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail");
1406 debug_event(unit->port->adapter->erp_dbf, 2,
1407 &unit->fcp_lun, sizeof (fcp_lun_t));
1408}
1409
1410/*
1411 * function: zfcp_erp_strategy_check_target
1412 *
1413 * purpose: increments the erp action count on the device currently in
1414 * recovery if the action failed or resets the count in case of
1415 * success. If a maximum count is exceeded the device is marked
1416 * as ERP_FAILED.
1417 * The 'blocked' state of a target which has been recovered
1418 * successfully is reset.
1419 *
1420 * returns: ZFCP_ERP_CONTINUES - action continues (not considered)
1421 * ZFCP_ERP_SUCCEEDED - action finished successfully
1422 * ZFCP_ERP_EXIT - action failed and will not continue
1423 */
1424static int
1425zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result)
1426{
1427 struct zfcp_adapter *adapter = erp_action->adapter;
1428 struct zfcp_port *port = erp_action->port;
1429 struct zfcp_unit *unit = erp_action->unit;
1430
1431 debug_text_event(adapter->erp_dbf, 5, "a_stct_norm");
1432 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1433 debug_event(adapter->erp_dbf, 5, &result, sizeof (int));
1434
1435 switch (erp_action->action) {
1436
1437 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1438 result = zfcp_erp_strategy_check_unit(unit, result);
1439 break;
1440
1441 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1442 case ZFCP_ERP_ACTION_REOPEN_PORT:
1443 result = zfcp_erp_strategy_check_port(port, result);
1444 break;
1445
1446 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1447 result = zfcp_erp_strategy_check_adapter(adapter, result);
1448 break;
1449 }
1450
1451 return result;
1452}
1453
1da177e4
LT		 1454static int
1455zfcp_erp_strategy_statechange(int action,
1456 u32 status,
1457 struct zfcp_adapter *adapter,
1458 struct zfcp_port *port,
1459 struct zfcp_unit *unit, int retval)
1460{
1461 debug_text_event(adapter->erp_dbf, 3, "a_stsc");
1462 debug_event(adapter->erp_dbf, 3, &action, sizeof (int));
1463
1464 switch (action) {
1465
1466 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1467 if (zfcp_erp_strategy_statechange_detected(&adapter->status,
1468 status)) {
1469 zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
1470 retval = ZFCP_ERP_EXIT;
1471 }
1472 break;
1473
1474 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1475 case ZFCP_ERP_ACTION_REOPEN_PORT:
1476 if (zfcp_erp_strategy_statechange_detected(&port->status,
1477 status)) {
1478 zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED);
1479 retval = ZFCP_ERP_EXIT;
1480 }
1481 break;
1482
1483 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1484 if (zfcp_erp_strategy_statechange_detected(&unit->status,
1485 status)) {
1486 zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
1487 retval = ZFCP_ERP_EXIT;
1488 }
1489 break;
1490 }
1491
1492 return retval;
1493}
1494
1da177e4
LT		 1495static inline int
1496zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status)
1497{
1498 return
1499 /* take it online */
1500 (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1501 (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) ||
1502 /* take it offline */
1503 (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1504 !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status));
1505}
1506
1da177e4
LT		 1507static int
1508zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
1509{
1510 debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct");
1511 debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun,
1512 sizeof (fcp_lun_t));
1513
1514 switch (result) {
1515 case ZFCP_ERP_SUCCEEDED :
1516 atomic_set(&unit->erp_counter, 0);
1517 zfcp_erp_unit_unblock(unit);
1518 break;
1519 case ZFCP_ERP_FAILED :
1520 atomic_inc(&unit->erp_counter);
1521 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
1522 zfcp_erp_unit_failed(unit);
1523 break;
1524 case ZFCP_ERP_EXIT :
1525 /* nothing */
1526 break;
1527 }
1528
1529 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
1530 zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */
1531 result = ZFCP_ERP_EXIT;
1532 }
1533
1534 return result;
1535}
1536
1da177e4
LT		 1537static int
1538zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1539{
1540 debug_text_event(port->adapter->erp_dbf, 5, "p_stct");
1541 debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
1542
1543 switch (result) {
1544 case ZFCP_ERP_SUCCEEDED :
1545 atomic_set(&port->erp_counter, 0);
1546 zfcp_erp_port_unblock(port);
1547 break;
1548 case ZFCP_ERP_FAILED :
1549 atomic_inc(&port->erp_counter);
1550 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
1551 zfcp_erp_port_failed(port);
1552 break;
1553 case ZFCP_ERP_EXIT :
1554 /* nothing */
1555 break;
1556 }
1557
1558 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
1559 zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */
1560 result = ZFCP_ERP_EXIT;
1561 }
1562
1563 return result;
1564}
1565
1da177e4
LT		 1566static int
1567zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result)
1568{
1569 debug_text_event(adapter->erp_dbf, 5, "a_stct");
1570
1571 switch (result) {
1572 case ZFCP_ERP_SUCCEEDED :
1573 atomic_set(&adapter->erp_counter, 0);
1574 zfcp_erp_adapter_unblock(adapter);
1575 break;
1576 case ZFCP_ERP_FAILED :
1577 atomic_inc(&adapter->erp_counter);
1578 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS)
1579 zfcp_erp_adapter_failed(adapter);
1580 break;
1581 case ZFCP_ERP_EXIT :
1582 /* nothing */
1583 break;
1584 }
1585
1586 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
1587 zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */
1588 result = ZFCP_ERP_EXIT;
1589 }
1590
1591 return result;
1592}
1593
1594/*
1595 * function:
1596 *
1597 * purpose: remaining things in good cases,
1598 * escalation in bad cases
1599 *
1600 * returns:
1601 */
1602static int
1603zfcp_erp_strategy_followup_actions(int action,
1604 struct zfcp_adapter *adapter,
1605 struct zfcp_port *port,
1606 struct zfcp_unit *unit, int status)
1607{
1608 debug_text_event(adapter->erp_dbf, 5, "a_stfol");
1609 debug_event(adapter->erp_dbf, 5, &action, sizeof (int));
1610
1611 /* initiate follow-up actions depending on success of finished action */
1612 switch (action) {
1613
1614 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1615 if (status == ZFCP_ERP_SUCCEEDED)
1616 zfcp_erp_port_reopen_all_internal(adapter, 0);
1617 else
1618 zfcp_erp_adapter_reopen_internal(adapter, 0);
1619 break;
1620
1621 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1622 if (status == ZFCP_ERP_SUCCEEDED)
1623 zfcp_erp_port_reopen_internal(port, 0);
1624 else
1625 zfcp_erp_adapter_reopen_internal(adapter, 0);
1626 break;
1627
1628 case ZFCP_ERP_ACTION_REOPEN_PORT:
1629 if (status == ZFCP_ERP_SUCCEEDED)
1630 zfcp_erp_unit_reopen_all_internal(port, 0);
1631 else
1632 zfcp_erp_port_forced_reopen_internal(port, 0);
1633 break;
1634
1635 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1636 if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */
1637 else
1638 zfcp_erp_port_reopen_internal(unit->port, 0);
1639 break;
1640 }
1641
1642 return 0;
1643}
1644
1da177e4
LT		 1645static int
1646zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter)
1647{
1648 unsigned long flags;
1649
1650 read_lock_irqsave(&zfcp_data.config_lock, flags);
1651 read_lock(&adapter->erp_lock);
1652 if (list_empty(&adapter->erp_ready_head) &&
1653 list_empty(&adapter->erp_running_head)) {
1654 debug_text_event(adapter->erp_dbf, 4, "a_cq_wake");
1655 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1656 &adapter->status);
1657 wake_up(&adapter->erp_done_wqh);
1658 } else
1659 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty");
1660 read_unlock(&adapter->erp_lock);
1661 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1662
1663 return 0;
1664}
1665
1666/**
1667 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1668 * @adapter: adapter for which to wait for completion of its error recovery
1669 * Return: 0
1670 */
1671int
1672zfcp_erp_wait(struct zfcp_adapter *adapter)
1673{
1674 int retval = 0;
1675
1676 wait_event(adapter->erp_done_wqh,
1677 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1678 &adapter->status));
1679
1680 return retval;
1681}
1682
1da177e4
LT		 1683void
1684zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter,
1685 u32 mask, int set_or_clear)
1686{
1687 struct zfcp_port *port;
1688 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1689
1690 if (set_or_clear == ZFCP_SET) {
1691 atomic_set_mask(mask, &adapter->status);
1692 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s");
1693 } else {
1694 atomic_clear_mask(mask, &adapter->status);
1695 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1696 atomic_set(&adapter->erp_counter, 0);
1697 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c");
1698 }
1699 debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32));
1700
1701 /* Deal with all underlying devices, only pass common_mask */
1702 if (common_mask)
1703 list_for_each_entry(port, &adapter->port_list_head, list)
1704 zfcp_erp_modify_port_status(port, common_mask,
1705 set_or_clear);
1706}
1707
1708/*
1709 * function: zfcp_erp_modify_port_status
1710 *
1711 * purpose: sets the port and all underlying devices to ERP_FAILED
1712 *
1713 */
1714void
1715zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear)
1716{
1717 struct zfcp_unit *unit;
1718 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1719
1720 if (set_or_clear == ZFCP_SET) {
1721 atomic_set_mask(mask, &port->status);
1722 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s");
1723 } else {
1724 atomic_clear_mask(mask, &port->status);
1725 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1726 atomic_set(&port->erp_counter, 0);
1727 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c");
1728 }
1729 debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
1730 debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1731
1732 /* Modify status of all underlying devices, only pass common mask */
1733 if (common_mask)
1734 list_for_each_entry(unit, &port->unit_list_head, list)
1735 zfcp_erp_modify_unit_status(unit, common_mask,
1736 set_or_clear);
1737}
1738
1739/*
1740 * function: zfcp_erp_modify_unit_status
1741 *
1742 * purpose: sets the unit to ERP_FAILED
1743 *
1744 */
1745void
1746zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear)
1747{
1748 if (set_or_clear == ZFCP_SET) {
1749 atomic_set_mask(mask, &unit->status);
1750 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s");
1751 } else {
1752 atomic_clear_mask(mask, &unit->status);
1753 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1754 atomic_set(&unit->erp_counter, 0);
1755 }
1756 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c");
1757 }
1758 debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun,
1759 sizeof (fcp_lun_t));
1760 debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1761}
1762
1763/*
1764 * function:
1765 *
1766 * purpose: Wrappper for zfcp_erp_port_reopen_all_internal
1767 * used to ensure the correct locking
1768 *
d6e05edc 1769 * returns: 0 - initiated action successfully
1da177e4
LT		 1770 * <0 - failed to initiate action
1771 */
1772int
1773zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask)
1774{
1775 int retval;
1776 unsigned long flags;
1777
1778 read_lock_irqsave(&zfcp_data.config_lock, flags);
1779 write_lock(&adapter->erp_lock);
1780 retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask);
1781 write_unlock(&adapter->erp_lock);
1782 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1783
1784 return retval;
1785}
1786
1da177e4
LT		 1787static int
1788zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask)
1789{
1790 int retval = 0;
1791 struct zfcp_port *port;
1792
1793 list_for_each_entry(port, &adapter->port_list_head, list)
1794 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1795 zfcp_erp_port_reopen_internal(port, clear_mask);
1796
1797 return retval;
1798}
1799
1800/*
1801 * function:
1802 *
1803 * purpose:
1804 *
1805 * returns: FIXME
1806 */
1807static int
1808zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask)
1809{
1810 int retval = 0;
1811 struct zfcp_unit *unit;
1812
1813 list_for_each_entry(unit, &port->unit_list_head, list)
1814 zfcp_erp_unit_reopen_internal(unit, clear_mask);
1815
1816 return retval;
1817}
1818
1819/*
1820 * function:
1821 *
1822 * purpose: this routine executes the 'Reopen Adapter' action
1823 * (the entire action is processed synchronously, since
1824 * there are no actions which might be run concurrently
1825 * per definition)
1826 *
1827 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1828 * ZFCP_ERP_FAILED - action finished unsuccessfully
1829 */
1830static int
1831zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action)
1832{
1833 int retval;
1834 struct zfcp_adapter *adapter = erp_action->adapter;
1835
1836 retval = zfcp_erp_adapter_strategy_close(erp_action);
1837 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1838 retval = ZFCP_ERP_EXIT;
1839 else
1840 retval = zfcp_erp_adapter_strategy_open(erp_action);
1841
1842 debug_text_event(adapter->erp_dbf, 3, "a_ast/ret");
1843 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
1844 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
1845
1846 if (retval == ZFCP_ERP_FAILED) {
1847 ZFCP_LOG_INFO("Waiting to allow the adapter %s "
1848 "to recover itself\n",
1849 zfcp_get_busid_by_adapter(adapter));
1850 msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME));
1851 }
1852
1853 return retval;
1854}
1855
1856/*
1857 * function:
1858 *
1859 * purpose:
1860 *
1861 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1862 * ZFCP_ERP_FAILED - action finished unsuccessfully
1863 */
1864static int
1865zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action)
1866{
1867 int retval;
1868
1869 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING,
1870 &erp_action->adapter->status);
1871 retval = zfcp_erp_adapter_strategy_generic(erp_action, 1);
1872 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING,
1873 &erp_action->adapter->status);
1874
1875 return retval;
1876}
1877
1878/*
1879 * function:
1880 *
1881 * purpose:
1882 *
1883 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1884 * ZFCP_ERP_FAILED - action finished unsuccessfully
1885 */
1886static int
1887zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action)
1888{
1889 int retval;
1890
1891 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING,
1892 &erp_action->adapter->status);
1893 retval = zfcp_erp_adapter_strategy_generic(erp_action, 0);
1894 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING,
1895 &erp_action->adapter->status);
1896
1897 return retval;
1898}
1899
1900/*
1901 * function: zfcp_register_adapter
1902 *
1903 * purpose: allocate the irq associated with this devno and register
1904 * the FSF adapter with the SCSI stack
1905 *
1906 * returns:
1907 */
1908static int
1909zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
1910{
1911 int retval = ZFCP_ERP_SUCCEEDED;
1912
1913 if (close)
1914 goto close_only;
1915
1916 retval = zfcp_erp_adapter_strategy_open_qdio(erp_action);
1917 if (retval != ZFCP_ERP_SUCCEEDED)
1918 goto failed_qdio;
1919
1920 retval = zfcp_erp_adapter_strategy_open_fsf(erp_action);
1921 if (retval != ZFCP_ERP_SUCCEEDED)
1922 goto failed_openfcp;
1923
1924 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status);
1925 goto out;
1926
1927 close_only:
1928 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1929 &erp_action->adapter->status);
1930
1931 failed_openfcp:
2abbe866 1932 zfcp_close_fsf(erp_action->adapter);
1da177e4
LT		 1933 failed_qdio:
1934 out:
1935 return retval;
1936}
1937
1938/*
1939 * function: zfcp_qdio_init
1940 *
1941 * purpose: setup QDIO operation for specified adapter
1942 *
1943 * returns: 0 - successful setup
1944 * !0 - failed setup
1945 */
1946int
1947zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
1948{
1949 int retval;
1950 int i;
1951 volatile struct qdio_buffer_element *sbale;
1952 struct zfcp_adapter *adapter = erp_action->adapter;
1953
1954 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
1955 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "
1956 "adapter %s\n",
1957 zfcp_get_busid_by_adapter(adapter));
1958 goto failed_sanity;
1959 }
1960
1961 if (qdio_establish(&adapter->qdio_init_data) != 0) {
1962 ZFCP_LOG_INFO("error: establishment of QDIO queues failed "
1963 "on adapter %s\n",
1964 zfcp_get_busid_by_adapter(adapter));
1965 goto failed_qdio_establish;
1966 }
1967 debug_text_event(adapter->erp_dbf, 3, "qdio_est");
1968
1969 if (qdio_activate(adapter->ccw_device, 0) != 0) {
1970 ZFCP_LOG_INFO("error: activation of QDIO queues failed "
1971 "on adapter %s\n",
1972 zfcp_get_busid_by_adapter(adapter));
1973 goto failed_qdio_activate;
1974 }
1975 debug_text_event(adapter->erp_dbf, 3, "qdio_act");
1976
1977 /*
1978 * put buffers into response queue,
1979 */
1980 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
1981 sbale = &(adapter->response_queue.buffer[i]->element[0]);
1982 sbale->length = 0;
1983 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
6aae8738 1984 sbale->addr = NULL;
1da177e4
LT		 1985 }
1986
1987 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
1988 "queue_no=%i, index_in_queue=%i, count=%i)\n",
1989 zfcp_get_busid_by_adapter(adapter),
1990 QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);
1991
1992 retval = do_QDIO(adapter->ccw_device,
1993 QDIO_FLAG_SYNC_INPUT,
1994 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);
1995
1996 if (retval) {
1997 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",
1998 retval);
1999 goto failed_do_qdio;
2000 } else {
2001 adapter->response_queue.free_index = 0;
2002 atomic_set(&adapter->response_queue.free_count, 0);
2003 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "
2004 "response queue\n", QDIO_MAX_BUFFERS_PER_Q);
2005 }
2006 /* set index of first avalable SBALS / number of available SBALS */
2007 adapter->request_queue.free_index = 0;
2008 atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);
2009 adapter->request_queue.distance_from_int = 0;
2010
2011 /* initialize waitqueue used to wait for free SBALs in requests queue */
2012 init_waitqueue_head(&adapter->request_wq);
2013
2014 /* ok, we did it - skip all cleanups for different failures */
2015 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
2016 retval = ZFCP_ERP_SUCCEEDED;
2017 goto out;
2018
2019 failed_do_qdio:
2020 /* NOP */
2021
2022 failed_qdio_activate:
2023 debug_text_event(adapter->erp_dbf, 3, "qdio_down1a");
2024 while (qdio_shutdown(adapter->ccw_device,
2025 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
2026 msleep(1000);
2027 debug_text_event(adapter->erp_dbf, 3, "qdio_down1b");
2028
2029 failed_qdio_establish:
2030 failed_sanity:
2031 retval = ZFCP_ERP_FAILED;
2032
2033 out:
2034 return retval;
2035}
2036
1da177e4 2037
1da177e4
LT		 2038static int
2039zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
2040{
2448c459 2041 int retval;
aef4a983 2042
2448c459
AH		 2043 retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action);
2044 if (retval == ZFCP_ERP_FAILED)
2045 return ZFCP_ERP_FAILED;
2046
2047 retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action);
2048 if (retval == ZFCP_ERP_FAILED)
aef4a983 2049 return ZFCP_ERP_FAILED;
1da177e4 2050
aef4a983 2051 return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action);
1da177e4
LT		 2052}
2053
1da177e4
LT		 2054static int
2055zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
2056{
2057 int retval = ZFCP_ERP_SUCCEEDED;
2058 int retries;
22753fa5 2059 int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP;
1da177e4
LT		 2060 struct zfcp_adapter *adapter = erp_action->adapter;
2061
2062 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
1da177e4 2063
22753fa5 2064 for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) {
1da177e4
LT		 2065 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2066 &adapter->status);
2067 ZFCP_LOG_DEBUG("Doing exchange config data\n");
9f09c548 2068 write_lock_irq(&adapter->erp_lock);
1da177e4 2069 zfcp_erp_action_to_running(erp_action);
9f09c548 2070 write_unlock_irq(&adapter->erp_lock);
1da177e4
LT		 2071 if (zfcp_fsf_exchange_config_data(erp_action)) {
2072 retval = ZFCP_ERP_FAILED;
2073 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
2074 ZFCP_LOG_INFO("error: initiation of exchange of "
2075 "configuration data failed for "
2076 "adapter %s\n",
2077 zfcp_get_busid_by_adapter(adapter));
2078 break;
2079 }
2080 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok");
2081 ZFCP_LOG_DEBUG("Xchange underway\n");
2082
2083 /*
2084 * Why this works:
2085 * Both the normal completion handler as well as the timeout
2086 * handler will do an 'up' when the 'exchange config data'
2087 * request completes or times out. Thus, the signal to go on
2088 * won't be lost utilizing this semaphore.
2089 * Furthermore, this 'adapter_reopen' action is
2090 * guaranteed to be the only action being there (highest action
2091 * which prevents other actions from being created).
2092 * Resulting from that, the wake signal recognized here
2093 * _must_ be the one belonging to the 'exchange config
2094 * data' request.
2095 */
2096 down(&adapter->erp_ready_sem);
2097 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2098 ZFCP_LOG_INFO("error: exchange of configuration data "
2099 "for adapter %s timed out\n",
2100 zfcp_get_busid_by_adapter(adapter));
2101 break;
2102 }
22753fa5
AH		 2103
2104 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2105 &adapter->status))
2106 break;
2107
2108 ZFCP_LOG_DEBUG("host connection still initialising... "
2109 "waiting and retrying...\n");
2110 /* sleep a little bit before retry */
2111 msleep(jiffies_to_msecs(sleep));
2112 sleep *= 2;
2113 }
1da177e4
LT		 2114
2115 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
2116 &adapter->status)) {
2117 ZFCP_LOG_INFO("error: exchange of configuration data for "
2118 "adapter %s failed\n",
2119 zfcp_get_busid_by_adapter(adapter));
2120 retval = ZFCP_ERP_FAILED;
2121 }
2122
2123 return retval;
2124}
2125
aef4a983
MS		 2126static int
2127zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
2128{
2448c459 2129 int ret;
2f8f3ed5 2130 struct zfcp_adapter *adapter;
aef4a983 2131
2f8f3ed5 2132 adapter = erp_action->adapter;
aef4a983
MS		 2133 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
2134
9f09c548 2135 write_lock_irq(&adapter->erp_lock);
2f8f3ed5 2136 zfcp_erp_action_to_running(erp_action);
9f09c548 2137 write_unlock_irq(&adapter->erp_lock);
aef4a983 2138
2f8f3ed5
AH		 2139 ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);
2140 if (ret == -EOPNOTSUPP) {
2141 debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");
2142 return ZFCP_ERP_SUCCEEDED;
2143 } else if (ret) {
2144 debug_text_event(adapter->erp_dbf, 3, "a_xport_failed");
2145 return ZFCP_ERP_FAILED;
2146 }
2147 debug_text_event(adapter->erp_dbf, 6, "a_xport_ok");
2148
2149 ret = ZFCP_ERP_SUCCEEDED;
2150 down(&adapter->erp_ready_sem);
2151 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2152 ZFCP_LOG_INFO("error: exchange port data timed out (adapter "
2153 "%s)\n", zfcp_get_busid_by_adapter(adapter));
2154 ret = ZFCP_ERP_FAILED;
2155 }
f6c0e7a7
AH		 2156
2157 /* don't treat as error for the sake of compatibility */
2158 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status))
2159 ZFCP_LOG_INFO("warning: exchange port data failed (adapter "
2f8f3ed5 2160 "%s\n", zfcp_get_busid_by_adapter(adapter));
aef4a983 2161
2f8f3ed5 2162 return ret;
aef4a983
MS		 2163}
2164
1da177e4
LT		 2165static int
2166zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
2167 *erp_action)
2168{
2169 int retval = ZFCP_ERP_SUCCEEDED;
2170 int temp_ret;
2171 struct zfcp_adapter *adapter = erp_action->adapter;
2172 int i;
2173
2174 adapter->status_read_failed = 0;
2175 for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) {
2176 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL);
2177 if (temp_ret < 0) {
2178 ZFCP_LOG_INFO("error: set-up of unsolicited status "
2179 "notification failed on adapter %s\n",
2180 zfcp_get_busid_by_adapter(adapter));
2181 retval = ZFCP_ERP_FAILED;
2182 i--;
2183 break;
2184 }
2185 }
2186
2187 return retval;
2188}
2189
1da177e4
LT		 2190/*
2191 * function:
2192 *
2193 * purpose: this routine executes the 'Reopen Physical Port' action
2194 *
2195 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2196 * ZFCP_ERP_SUCCEEDED - action finished successfully
2197 * ZFCP_ERP_FAILED - action finished unsuccessfully
2198 */
2199static int
2200zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
2201{
2202 int retval = ZFCP_ERP_FAILED;
2203 struct zfcp_port *port = erp_action->port;
2204 struct zfcp_adapter *adapter = erp_action->adapter;
2205
2206 switch (erp_action->step) {
2207
2208 /*
2209 * FIXME:
2210 * the ULP spec. begs for waiting for oustanding commands
2211 */
2212 case ZFCP_ERP_STEP_UNINITIALIZED:
2213 zfcp_erp_port_strategy_clearstati(port);
2214 /*
2215 * it would be sufficient to test only the normal open flag
2216 * since the phys. open flag cannot be set if the normal
2217 * open flag is unset - however, this is for readabilty ...
2218 */
2219 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
2220 ZFCP_STATUS_COMMON_OPEN),
2221 &port->status)) {
2222 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2223 "close physical\n", port->wwpn);
2224 retval =
2225 zfcp_erp_port_forced_strategy_close(erp_action);
2226 } else
2227 retval = ZFCP_ERP_FAILED;
2228 break;
2229
2230 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2231 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
2232 &port->status)) {
2233 ZFCP_LOG_DEBUG("close physical failed for port "
2234 "0x%016Lx\n", port->wwpn);
2235 retval = ZFCP_ERP_FAILED;
2236 } else
2237 retval = ZFCP_ERP_SUCCEEDED;
2238 break;
2239 }
2240
2241 debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret");
2242 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2243 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2244 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2245
2246 return retval;
2247}
2248
2249/*
2250 * function:
2251 *
2252 * purpose: this routine executes the 'Reopen Port' action
2253 *
2254 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2255 * ZFCP_ERP_SUCCEEDED - action finished successfully
2256 * ZFCP_ERP_FAILED - action finished unsuccessfully
2257 */
2258static int
2259zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
2260{
2261 int retval = ZFCP_ERP_FAILED;
2262 struct zfcp_port *port = erp_action->port;
2263 struct zfcp_adapter *adapter = erp_action->adapter;
2264
2265 switch (erp_action->step) {
2266
2267 /*
2268 * FIXME:
2269 * the ULP spec. begs for waiting for oustanding commands
2270 */
2271 case ZFCP_ERP_STEP_UNINITIALIZED:
2272 zfcp_erp_port_strategy_clearstati(port);
2273 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2274 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2275 "close\n", port->wwpn);
2276 retval = zfcp_erp_port_strategy_close(erp_action);
2277 goto out;
2278 } /* else it's already closed, open it */
2279 break;
2280
2281 case ZFCP_ERP_STEP_PORT_CLOSING:
2282 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2283 ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
2284 port->wwpn);
2285 retval = ZFCP_ERP_FAILED;
2286 goto out;
2287 } /* else it's closed now, open it */
2288 break;
2289 }
2290 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2291 retval = ZFCP_ERP_EXIT;
2292 else
2293 retval = zfcp_erp_port_strategy_open(erp_action);
2294
2295 out:
2296 debug_text_event(adapter->erp_dbf, 3, "p_pst/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
1da177e4
LT		 2304static int
2305zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
2306{
2307 int retval;
2308
2309 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2310 &erp_action->port->status))
2311 retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
2312 else
2313 retval = zfcp_erp_port_strategy_open_common(erp_action);
2314
2315 return retval;
2316}
2317
1da177e4
LT		 2318static int
2319zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
2320{
2321 int retval = 0;
2322 struct zfcp_adapter *adapter = erp_action->adapter;
2323 struct zfcp_port *port = erp_action->port;
2324
2325 switch (erp_action->step) {
2326
2327 case ZFCP_ERP_STEP_UNINITIALIZED:
2328 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2329 case ZFCP_ERP_STEP_PORT_CLOSING:
ad757cdf 2330 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
6f71d9bc
JB		 2331 if (port->wwpn != adapter->peer_wwpn) {
2332 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
2333 "on adapter %s.\nPeer WWPN "
2334 "0x%016Lx does not match\n",
2335 port->wwpn,
2336 zfcp_get_busid_by_adapter(adapter),
2337 adapter->peer_wwpn);
2338 zfcp_erp_port_failed(port);
2339 retval = ZFCP_ERP_FAILED;
2340 break;
2341 }
2342 port->d_id = adapter->peer_d_id;
2343 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
2344 retval = zfcp_erp_port_strategy_open_port(erp_action);
2345 break;
2346 }
1da177e4
LT		 2347 if (!(adapter->nameserver_port)) {
2348 retval = zfcp_nameserver_enqueue(adapter);
2349 if (retval != 0) {
2350 ZFCP_LOG_NORMAL("error: nameserver port "
2351 "unavailable for adapter %s\n",
2352 zfcp_get_busid_by_adapter(adapter));
2353 retval = ZFCP_ERP_FAILED;
2354 break;
2355 }
2356 }
2357 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
2358 &adapter->nameserver_port->status)) {
2359 ZFCP_LOG_DEBUG("nameserver port is not open -> open "
2360 "nameserver port\n");
2361 /* nameserver port may live again */
2362 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
2363 &adapter->nameserver_port->status);
2364 if (zfcp_erp_port_reopen(adapter->nameserver_port, 0)
2365 >= 0) {
2366 erp_action->step =
2367 ZFCP_ERP_STEP_NAMESERVER_OPEN;
2368 retval = ZFCP_ERP_CONTINUES;
2369 } else
2370 retval = ZFCP_ERP_FAILED;
2371 break;
2372 }
2373 /* else nameserver port is already open, fall through */
2374 case ZFCP_ERP_STEP_NAMESERVER_OPEN:
2375 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
2376 &adapter->nameserver_port->status)) {
2377 ZFCP_LOG_DEBUG("open failed for nameserver port\n");
2378 retval = ZFCP_ERP_FAILED;
2379 } else {
2380 ZFCP_LOG_DEBUG("nameserver port is open -> "
2381 "nameserver look-up for port 0x%016Lx\n",
2382 port->wwpn);
2383 retval = zfcp_erp_port_strategy_open_common_lookup
2384 (erp_action);
2385 }
2386 break;
2387
2388 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
2389 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
2390 if (atomic_test_mask
2391 (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
2392 ZFCP_LOG_DEBUG("nameserver look-up failed "
2393 "for port 0x%016Lx "
2394 "(misconfigured WWPN?)\n",
2395 port->wwpn);
2396 zfcp_erp_port_failed(port);
2397 retval = ZFCP_ERP_EXIT;
2398 } else {
2399 ZFCP_LOG_DEBUG("nameserver look-up failed for "
2400 "port 0x%016Lx\n", port->wwpn);
2401 retval = ZFCP_ERP_FAILED;
2402 }
2403 } else {
1d589edf 2404 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> "
1da177e4
LT		 2405 "trying open\n", port->wwpn, port->d_id);
2406 retval = zfcp_erp_port_strategy_open_port(erp_action);
2407 }
2408 break;
2409
2410 case ZFCP_ERP_STEP_PORT_OPENING:
2411 /* D_ID might have changed during open */
2412 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
2413 ZFCP_STATUS_PORT_DID_DID),
2414 &port->status)) {
2415 ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
2416 retval = ZFCP_ERP_SUCCEEDED;
2417 } else {
2418 ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
2419 port->wwpn);
2420 retval = ZFCP_ERP_FAILED;
2421 }
2422 break;
2423
2424 default:
2425 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2426 erp_action->step);
2427 retval = ZFCP_ERP_FAILED;
2428 }
2429
2430 return retval;
2431}
2432
1da177e4
LT		 2433static int
2434zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
2435{
2436 int retval;
2437 struct zfcp_port *port = erp_action->port;
2438
2439 switch (erp_action->step) {
2440
2441 case ZFCP_ERP_STEP_UNINITIALIZED:
2442 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2443 case ZFCP_ERP_STEP_PORT_CLOSING:
1d589edf 2444 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> trying open\n",
1da177e4
LT		 2445 port->wwpn, port->d_id);
2446 retval = zfcp_erp_port_strategy_open_port(erp_action);
2447 break;
2448
2449 case ZFCP_ERP_STEP_PORT_OPENING:
2450 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2451 ZFCP_LOG_DEBUG("WKA port is open\n");
2452 retval = ZFCP_ERP_SUCCEEDED;
2453 } else {
2454 ZFCP_LOG_DEBUG("open failed for WKA port\n");
2455 retval = ZFCP_ERP_FAILED;
2456 }
2457 /* this is needed anyway (dont care for retval of wakeup) */
2458 ZFCP_LOG_DEBUG("continue other open port operations\n");
2459 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
2460 break;
2461
2462 default:
2463 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2464 erp_action->step);
2465 retval = ZFCP_ERP_FAILED;
2466 }
2467
2468 return retval;
2469}
2470
2471/*
2472 * function:
2473 *
2474 * purpose: makes the erp thread continue with reopen (physical) port
2475 * actions which have been paused until the name server port
2476 * is opened (or failed)
2477 *
2478 * returns: 0 (a kind of void retval, its not used)
2479 */
2480static int
2481zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
2482 *ns_erp_action)
2483{
2484 int retval = 0;
2485 unsigned long flags;
2486 struct zfcp_adapter *adapter = ns_erp_action->adapter;
2487 struct zfcp_erp_action *erp_action, *tmp;
2488
2489 read_lock_irqsave(&adapter->erp_lock, flags);
2490 list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
2491 list) {
2492 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n");
2493 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn,
2494 sizeof (wwn_t));
2495 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
2496 debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w");
2497 debug_event(adapter->erp_dbf, 3,
2498 &erp_action->port->wwpn, sizeof (wwn_t));
2499 if (atomic_test_mask(
2500 ZFCP_STATUS_COMMON_ERP_FAILED,
2501 &adapter->nameserver_port->status))
2502 zfcp_erp_port_failed(erp_action->port);
2503 zfcp_erp_action_ready(erp_action);
2504 }
2505 }
2506 read_unlock_irqrestore(&adapter->erp_lock, flags);
2507
2508 return retval;
2509}
2510
2511/*
2512 * function:
2513 *
2514 * purpose:
2515 *
2516 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2517 * ZFCP_ERP_FAILED - action finished unsuccessfully
2518 */
2519static int
2520zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
2521{
2522 int retval;
2523 struct zfcp_adapter *adapter = erp_action->adapter;
2524 struct zfcp_port *port = erp_action->port;
2525
1da177e4
LT		 2526 retval = zfcp_fsf_close_physical_port(erp_action);
2527 if (retval == -ENOMEM) {
2528 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
2529 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2530 retval = ZFCP_ERP_NOMEM;
2531 goto out;
2532 }
2533 erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
2534 if (retval != 0) {
2535 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf");
2536 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2537 /* could not send 'open', fail */
2538 retval = ZFCP_ERP_FAILED;
2539 goto out;
2540 }
2541 debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok");
2542 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2543 retval = ZFCP_ERP_CONTINUES;
2544 out:
2545 return retval;
2546}
2547
1da177e4
LT		 2548static int
2549zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
2550{
2551 int retval = 0;
2552 struct zfcp_adapter *adapter = port->adapter;
2553
2554 debug_text_event(adapter->erp_dbf, 5, "p_pstclst");
2555 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2556
2557 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2558 ZFCP_STATUS_COMMON_CLOSING |
2559 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2560 ZFCP_STATUS_PORT_DID_DID |
2561 ZFCP_STATUS_PORT_PHYS_CLOSING |
2562 ZFCP_STATUS_PORT_INVALID_WWPN,
2563 &port->status);
2564 return retval;
2565}
2566
2567/*
2568 * function:
2569 *
2570 * purpose:
2571 *
2572 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2573 * ZFCP_ERP_FAILED - action finished unsuccessfully
2574 */
2575static int
2576zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
2577{
2578 int retval;
2579 struct zfcp_adapter *adapter = erp_action->adapter;
2580 struct zfcp_port *port = erp_action->port;
2581
1da177e4
LT		 2582 retval = zfcp_fsf_close_port(erp_action);
2583 if (retval == -ENOMEM) {
2584 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
2585 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2586 retval = ZFCP_ERP_NOMEM;
2587 goto out;
2588 }
2589 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
2590 if (retval != 0) {
2591 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf");
2592 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2593 /* could not send 'close', fail */
2594 retval = ZFCP_ERP_FAILED;
2595 goto out;
2596 }
2597 debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok");
2598 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2599 retval = ZFCP_ERP_CONTINUES;
2600 out:
2601 return retval;
2602}
2603
2604/*
2605 * function:
2606 *
2607 * purpose:
2608 *
2609 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2610 * ZFCP_ERP_FAILED - action finished unsuccessfully
2611 */
2612static int
2613zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
2614{
2615 int retval;
2616 struct zfcp_adapter *adapter = erp_action->adapter;
2617 struct zfcp_port *port = erp_action->port;
2618
1da177e4
LT		 2619 retval = zfcp_fsf_open_port(erp_action);
2620 if (retval == -ENOMEM) {
2621 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
2622 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2623 retval = ZFCP_ERP_NOMEM;
2624 goto out;
2625 }
2626 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
2627 if (retval != 0) {
2628 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf");
2629 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2630 /* could not send 'open', fail */
2631 retval = ZFCP_ERP_FAILED;
2632 goto out;
2633 }
2634 debug_text_event(adapter->erp_dbf, 6, "p_psto_opok");
2635 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2636 retval = ZFCP_ERP_CONTINUES;
2637 out:
2638 return retval;
2639}
2640
2641/*
2642 * function:
2643 *
2644 * purpose:
2645 *
2646 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2647 * ZFCP_ERP_FAILED - action finished unsuccessfully
2648 */
2649static int
2650zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
2651{
2652 int retval;
2653 struct zfcp_adapter *adapter = erp_action->adapter;
2654 struct zfcp_port *port = erp_action->port;
2655
1da177e4
LT		 2656 retval = zfcp_ns_gid_pn_request(erp_action);
2657 if (retval == -ENOMEM) {
2658 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
2659 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2660 retval = ZFCP_ERP_NOMEM;
2661 goto out;
2662 }
2663 erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
2664 if (retval != 0) {
2665 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref");
2666 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2667 /* could not send nameserver request, fail */
2668 retval = ZFCP_ERP_FAILED;
2669 goto out;
2670 }
2671 debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok");
2672 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2673 retval = ZFCP_ERP_CONTINUES;
2674 out:
2675 return retval;
2676}
2677
2678/*
2679 * function:
2680 *
2681 * purpose: this routine executes the 'Reopen Unit' action
2682 * currently no retries
2683 *
2684 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2685 * ZFCP_ERP_SUCCEEDED - action finished successfully
2686 * ZFCP_ERP_FAILED - action finished unsuccessfully
2687 */
2688static int
2689zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
2690{
2691 int retval = ZFCP_ERP_FAILED;
2692 struct zfcp_unit *unit = erp_action->unit;
2693 struct zfcp_adapter *adapter = erp_action->adapter;
2694
2695 switch (erp_action->step) {
2696
2697 /*
2698 * FIXME:
2699 * the ULP spec. begs for waiting for oustanding commands
2700 */
2701 case ZFCP_ERP_STEP_UNINITIALIZED:
2702 zfcp_erp_unit_strategy_clearstati(unit);
2703 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2704 ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
2705 "trying close\n", unit->fcp_lun);
2706 retval = zfcp_erp_unit_strategy_close(erp_action);
2707 break;
2708 }
2709 /* else it's already closed, fall through */
2710 case ZFCP_ERP_STEP_UNIT_CLOSING:
2711 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2712 ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
2713 unit->fcp_lun);
2714 retval = ZFCP_ERP_FAILED;
2715 } else {
2716 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2717 retval = ZFCP_ERP_EXIT;
2718 else {
2719 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
2720 "trying open\n", unit->fcp_lun);
2721 retval =
2722 zfcp_erp_unit_strategy_open(erp_action);
2723 }
2724 }
2725 break;
2726
2727 case ZFCP_ERP_STEP_UNIT_OPENING:
2728 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2729 ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
2730 unit->fcp_lun);
2731 retval = ZFCP_ERP_SUCCEEDED;
2732 } else {
2733 ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
2734 unit->fcp_lun);
2735 retval = ZFCP_ERP_FAILED;
2736 }
2737 break;
2738 }
2739
2740 debug_text_event(adapter->erp_dbf, 3, "u_ust/ret");
2741 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t));
2742 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2743 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2744 return retval;
2745}
2746
1da177e4
LT		 2747static int
2748zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
2749{
2750 int retval = 0;
2751 struct zfcp_adapter *adapter = unit->port->adapter;
2752
2753 debug_text_event(adapter->erp_dbf, 5, "u_ustclst");
2754 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
2755
2756 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2757 ZFCP_STATUS_COMMON_CLOSING |
2758 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2759 ZFCP_STATUS_UNIT_SHARED |
2760 ZFCP_STATUS_UNIT_READONLY,
2761 &unit->status);
2762
2763 return retval;
2764}
2765
2766/*
2767 * function:
2768 *
2769 * purpose:
2770 *
2771 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2772 * ZFCP_ERP_FAILED - action finished unsuccessfully
2773 */
2774static int
2775zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
2776{
2777 int retval;
2778 struct zfcp_adapter *adapter = erp_action->adapter;
2779 struct zfcp_unit *unit = erp_action->unit;
2780
1da177e4
LT		 2781 retval = zfcp_fsf_close_unit(erp_action);
2782 if (retval == -ENOMEM) {
2783 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
2784 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2785 sizeof (fcp_lun_t));
2786 retval = ZFCP_ERP_NOMEM;
2787 goto out;
2788 }
2789 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
2790 if (retval != 0) {
2791 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf");
2792 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2793 sizeof (fcp_lun_t));
2794 /* could not send 'close', fail */
2795 retval = ZFCP_ERP_FAILED;
2796 goto out;
2797 }
2798 debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok");
2799 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2800 retval = ZFCP_ERP_CONTINUES;
2801
2802 out:
2803 return retval;
2804}
2805
2806/*
2807 * function:
2808 *
2809 * purpose:
2810 *
2811 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2812 * ZFCP_ERP_FAILED - action finished unsuccessfully
2813 */
2814static int
2815zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
2816{
2817 int retval;
2818 struct zfcp_adapter *adapter = erp_action->adapter;
2819 struct zfcp_unit *unit = erp_action->unit;
2820
1da177e4
LT		 2821 retval = zfcp_fsf_open_unit(erp_action);
2822 if (retval == -ENOMEM) {
2823 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
2824 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2825 sizeof (fcp_lun_t));
2826 retval = ZFCP_ERP_NOMEM;
2827 goto out;
2828 }
2829 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
2830 if (retval != 0) {
2831 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf");
2832 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2833 sizeof (fcp_lun_t));
2834 /* could not send 'open', fail */
2835 retval = ZFCP_ERP_FAILED;
2836 goto out;
2837 }
2838 debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok");
2839 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2840 retval = ZFCP_ERP_CONTINUES;
2841 out:
2842 return retval;
2843}
2844
2abbe866 2845void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)
1da177e4 2846{
2abbe866
AH		 2847 BUG_ON(!fsf_req->erp_action);
2848 fsf_req->timer.function = zfcp_erp_timeout_handler;
2849 fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
2850 fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;
2851 add_timer(&fsf_req->timer);
1da177e4
LT		 2852}
2853
2854/*
2855 * function:
2856 *
2857 * purpose: enqueue the specified error recovery action, if needed
2858 *
2859 * returns:
2860 */
2861static int
2862zfcp_erp_action_enqueue(int action,
2863 struct zfcp_adapter *adapter,
2864 struct zfcp_port *port, struct zfcp_unit *unit)
2865{
2866 int retval = 1;
2867 struct zfcp_erp_action *erp_action = NULL;
2868 int stronger_action = 0;
2869 u32 status = 0;
2870
2871 /*
2872 * We need some rules here which check whether we really need
2873 * this action or whether we should just drop it.
2874 * E.g. if there is a unfinished 'Reopen Port' request then we drop a
2875 * 'Reopen Unit' request for an associated unit since we can't
2876 * satisfy this request now. A 'Reopen Port' action will trigger
2877 * 'Reopen Unit' actions when it completes.
2878 * Thus, there are only actions in the queue which can immediately be
2879 * executed. This makes the processing of the action queue more
2880 * efficient.
2881 */
2882
2883 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
2884 &adapter->status))
2885 return -EIO;
2886
2887 debug_event(adapter->erp_dbf, 4, &action, sizeof (int));
2888 /* check whether we really need this */
2889 switch (action) {
2890 case ZFCP_ERP_ACTION_REOPEN_UNIT:
2891 if (atomic_test_mask
2892 (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
2893 debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp");
2894 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2895 sizeof (wwn_t));
2896 debug_event(adapter->erp_dbf, 4, &unit->fcp_lun,
2897 sizeof (fcp_lun_t));
2898 goto out;
2899 }
2900 if (!atomic_test_mask
2901 (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
2902 atomic_test_mask
2903 (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
2904 goto out;
2905 }
2906 if (!atomic_test_mask
2907 (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) {
2908 stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT;
2909 unit = NULL;
2910 }
2911 /* fall through !!! */
2912
2913 case ZFCP_ERP_ACTION_REOPEN_PORT:
2914 if (atomic_test_mask
2915 (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
2916 debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp");
2917 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2918 sizeof (wwn_t));
2919 goto out;
2920 }
2921 /* fall through !!! */
2922
2923 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3734d24b
AH		 2924 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2925 &port->status)) {
2926 if (port->erp_action.action !=
2927 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
2928 ZFCP_LOG_INFO("dropped erp action %i (port "
2929 "0x%016Lx, action in use: %i)\n",
2930 action, port->wwpn,
2931 port->erp_action.action);
2932 debug_text_event(adapter->erp_dbf, 4,
2933 "pf_actenq_drp");
2934 } else
2935 debug_text_event(adapter->erp_dbf, 4,
2936 "pf_actenq_drpcp");
1da177e4
LT		 2937 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2938 sizeof (wwn_t));
2939 goto out;
2940 }
2941 if (!atomic_test_mask
2942 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
2943 atomic_test_mask
2944 (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
2945 goto out;
2946 }
2947 if (!atomic_test_mask
2948 (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) {
2949 stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
2950 port = NULL;
2951 }
2952 /* fall through !!! */
2953
2954 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
2955 if (atomic_test_mask
2956 (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
2957 debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp");
2958 goto out;
2959 }
2960 break;
2961
2962 default:
2963 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug");
2964 debug_event(adapter->erp_dbf, 1, &action, sizeof (int));
2965 ZFCP_LOG_NORMAL("bug: unknown erp action requested "
2966 "on adapter %s (action=%d)\n",
2967 zfcp_get_busid_by_adapter(adapter), action);
2968 goto out;
2969 }
2970
2971 /* check whether we need something stronger first */
2972 if (stronger_action) {
2973 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str");
2974 debug_event(adapter->erp_dbf, 4, &stronger_action,
2975 sizeof (int));
2976 ZFCP_LOG_DEBUG("stronger erp action %d needed before "
2977 "erp action %d on adapter %s\n",
2978 stronger_action, action,
2979 zfcp_get_busid_by_adapter(adapter));
2980 action = stronger_action;
2981 }
2982
2983 /* mark adapter to have some error recovery pending */
2984 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
2985
2986 /* setup error recovery action */
2987 switch (action) {
2988
2989 case ZFCP_ERP_ACTION_REOPEN_UNIT:
2990 zfcp_unit_get(unit);
2991 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
2992 erp_action = &unit->erp_action;
2993 if (!atomic_test_mask
2994 (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
2995 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
2996 break;
2997
2998 case ZFCP_ERP_ACTION_REOPEN_PORT:
2999 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3000 zfcp_port_get(port);
3001 zfcp_erp_action_dismiss_port(port);
3002 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
3003 erp_action = &port->erp_action;
3004 if (!atomic_test_mask
3005 (ZFCP_STATUS_COMMON_RUNNING, &port->status))
3006 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3007 break;
3008
3009 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3010 zfcp_adapter_get(adapter);
3011 zfcp_erp_action_dismiss_adapter(adapter);
3012 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
3013 erp_action = &adapter->erp_action;
3014 if (!atomic_test_mask
3015 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
3016 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3017 break;
3018 }
3019
3020 debug_text_event(adapter->erp_dbf, 4, "a_actenq");
3021
3022 memset(erp_action, 0, sizeof (struct zfcp_erp_action));
3023 erp_action->adapter = adapter;
3024 erp_action->port = port;
3025 erp_action->unit = unit;
3026 erp_action->action = action;
3027 erp_action->status = status;
3028
3029 ++adapter->erp_total_count;
3030
3031 /* finally put it into 'ready' queue and kick erp thread */
3032 list_add(&erp_action->list, &adapter->erp_ready_head);
3033 up(&adapter->erp_ready_sem);
3034 retval = 0;
3035 out:
3036 return retval;
3037}
3038
1da177e4
LT		 3039static int
3040zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
3041{
3042 int retval = 0;
3043 struct zfcp_adapter *adapter = erp_action->adapter;
3044
3045 --adapter->erp_total_count;
3046 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
3047 --adapter->erp_low_mem_count;
3048 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
3049 }
3050
3051 debug_text_event(adapter->erp_dbf, 4, "a_actdeq");
3052 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
3053 list_del(&erp_action->list);
3054 switch (erp_action->action) {
3055 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3056 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3057 &erp_action->unit->status);
3058 break;
3059 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3060 case ZFCP_ERP_ACTION_REOPEN_PORT:
3061 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3062 &erp_action->port->status);
3063 break;
3064 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3065 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3066 &erp_action->adapter->status);
3067 break;
3068 default:
3069 /* bug */
3070 break;
3071 }
3072 return retval;
3073}
3074
3075/**
3076 * zfcp_erp_action_cleanup
3077 *
575c9687 3078 * Register unit with scsi stack if appropriate and fix reference counts.
1da177e4
LT		 3079 * Note: Temporary units are not registered with scsi stack.
3080 */
3081static void
3082zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
3083 struct zfcp_port *port, struct zfcp_unit *unit,
3084 int result)
3085{
3086 switch (action) {
3087 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3088 if ((result == ZFCP_ERP_SUCCEEDED)
3089 && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
3090 &unit->status))
3859f6a2 3091 && !unit->device
ad58f7db
AH		 3092 && port->rport) {
3093 atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
3094 &unit->status);
3095 scsi_scan_target(&port->rport->dev, 0,
3096 port->rport->scsi_target_id,
3097 unit->scsi_lun, 0);
3098 }
1da177e4
LT		 3099 zfcp_unit_put(unit);
3100 break;
3101 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3102 case ZFCP_ERP_ACTION_REOPEN_PORT:
338151e0
AH		 3103 if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN,
3104 &port->status)) {
3105 zfcp_port_put(port);
3106 break;
3107 }
3108
3859f6a2 3109 if ((result == ZFCP_ERP_SUCCEEDED)
3859f6a2
AH		 3110 && !port->rport) {
3111 struct fc_rport_identifiers ids;
3112 ids.node_name = port->wwnn;
3113 ids.port_name = port->wwpn;
3114 ids.port_id = port->d_id;
3115 ids.roles = FC_RPORT_ROLE_FCP_TARGET;
3116 port->rport =
3117 fc_remote_port_add(adapter->scsi_host, 0, &ids);
3118 if (!port->rport)
3119 ZFCP_LOG_NORMAL("failed registration of rport"
3120 "(adapter %s, wwpn=0x%016Lx)\n",
3121 zfcp_get_busid_by_port(port),
3122 port->wwpn);
75bfc283 3123 else {
61c41823 3124 scsi_flush_work(adapter->scsi_host);
75bfc283
RW		 3125 port->rport->maxframe_size = port->maxframe_size;
3126 port->rport->supported_classes =
3127 port->supported_classes;
3128 }
3859f6a2 3129 }
338151e0
AH		 3130 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
3131 fc_remote_port_delete(port->rport);
3132 port->rport = NULL;
3133 }
1da177e4
LT		 3134 zfcp_port_put(port);
3135 break;
3136 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
338151e0 3137 if (result != ZFCP_ERP_SUCCEEDED) {
338151e0
AH		 3138 list_for_each_entry(port, &adapter->port_list_head, list)
3139 if (port->rport &&
3140 !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
3141 &port->status)) {
3142 fc_remote_port_delete(port->rport);
3143 port->rport = NULL;
3144 }
3145 }
1da177e4
LT		 3146 zfcp_adapter_put(adapter);
3147 break;
3148 default:
3149 break;
3150 }
3151}
3152
3153
81654286 3154static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
1da177e4 3155{
1da177e4
LT		 3156 struct zfcp_port *port;
3157
3158 debug_text_event(adapter->erp_dbf, 5, "a_actab");
3159 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
3160 zfcp_erp_action_dismiss(&adapter->erp_action);
3161 else
3162 list_for_each_entry(port, &adapter->port_list_head, list)
3163 zfcp_erp_action_dismiss_port(port);
1da177e4
LT		 3164}
3165
f6c0e7a7 3166static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
1da177e4 3167{
1da177e4
LT		 3168 struct zfcp_unit *unit;
3169 struct zfcp_adapter *adapter = port->adapter;
3170
3171 debug_text_event(adapter->erp_dbf, 5, "p_actab");
3172 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
3173 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
3174 zfcp_erp_action_dismiss(&port->erp_action);
3175 else
3176 list_for_each_entry(unit, &port->unit_list_head, list)
3177 zfcp_erp_action_dismiss_unit(unit);
1da177e4
LT		 3178}
3179
f6c0e7a7 3180static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
1da177e4 3181{
1da177e4
LT		 3182 struct zfcp_adapter *adapter = unit->port->adapter;
3183
3184 debug_text_event(adapter->erp_dbf, 5, "u_actab");
3185 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
3186 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
3187 zfcp_erp_action_dismiss(&unit->erp_action);
1da177e4
LT		 3188}
3189
1da177e4
LT		 3190static inline void
3191zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
3192{
3193 struct zfcp_adapter *adapter = erp_action->adapter;
3194
3195 debug_text_event(adapter->erp_dbf, 6, "a_toru");
3196 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3197 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
3198}
3199
1da177e4
LT		 3200static inline void
3201zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
3202{
3203 struct zfcp_adapter *adapter = erp_action->adapter;
3204
3205 debug_text_event(adapter->erp_dbf, 6, "a_tore");
3206 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3207 list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
3208}
3209
d736a27b
AH		 3210void
3211zfcp_erp_port_boxed(struct zfcp_port *port)
3212{
3213 struct zfcp_adapter *adapter = port->adapter;
3214 unsigned long flags;
3215
3216 debug_text_event(adapter->erp_dbf, 3, "p_access_boxed");
3217 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3218 read_lock_irqsave(&zfcp_data.config_lock, flags);
3219 zfcp_erp_modify_port_status(port,
3220 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3221 ZFCP_SET);
3222 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3223 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED);
3224}
3225
d736a27b
AH		 3226void
3227zfcp_erp_unit_boxed(struct zfcp_unit *unit)
3228{
3229 struct zfcp_adapter *adapter = unit->port->adapter;
3230
3231 debug_text_event(adapter->erp_dbf, 3, "u_access_boxed");
3232 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3233 zfcp_erp_modify_unit_status(unit,
3234 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3235 ZFCP_SET);
3236 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
3237}
3238
1da177e4
LT		 3239void
3240zfcp_erp_port_access_denied(struct zfcp_port *port)
3241{
3242 struct zfcp_adapter *adapter = port->adapter;
3243 unsigned long flags;
3244
d736a27b 3245 debug_text_event(adapter->erp_dbf, 3, "p_access_denied");
1da177e4
LT		 3246 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3247 read_lock_irqsave(&zfcp_data.config_lock, flags);
d736a27b
AH		 3248 zfcp_erp_modify_port_status(port,
3249 ZFCP_STATUS_COMMON_ERP_FAILED |
3250 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3251 ZFCP_SET);
1da177e4
LT		 3252 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3253}
3254
1da177e4
LT		 3255void
3256zfcp_erp_unit_access_denied(struct zfcp_unit *unit)
3257{
3258 struct zfcp_adapter *adapter = unit->port->adapter;
3259
d736a27b 3260 debug_text_event(adapter->erp_dbf, 3, "u_access_denied");
1da177e4 3261 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
d736a27b
AH		 3262 zfcp_erp_modify_unit_status(unit,
3263 ZFCP_STATUS_COMMON_ERP_FAILED |
3264 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3265 ZFCP_SET);
1da177e4
LT		 3266}
3267
1da177e4
LT		 3268void
3269zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter)
3270{
3271 struct zfcp_port *port;
3272 unsigned long flags;
3273
aef4a983
MS		 3274 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
3275 return;
3276
d736a27b 3277 debug_text_event(adapter->erp_dbf, 3, "a_access_recover");
06506d00 3278 debug_event(adapter->erp_dbf, 3, zfcp_get_busid_by_adapter(adapter), 8);
1da177e4 3279
1da177e4 3280 read_lock_irqsave(&zfcp_data.config_lock, flags);
6f71d9bc
JB		 3281 if (adapter->nameserver_port)
3282 zfcp_erp_port_access_changed(adapter->nameserver_port);
1da177e4
LT		 3283 list_for_each_entry(port, &adapter->port_list_head, list)
3284 if (port != adapter->nameserver_port)
3285 zfcp_erp_port_access_changed(port);
3286 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3287}
3288
1da177e4
LT		 3289void
3290zfcp_erp_port_access_changed(struct zfcp_port *port)
3291{
3292 struct zfcp_adapter *adapter = port->adapter;
3293 struct zfcp_unit *unit;
3294
d736a27b 3295 debug_text_event(adapter->erp_dbf, 3, "p_access_recover");
1da177e4
LT		 3296 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3297
3298 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
d736a27b
AH		 3299 &port->status) &&
3300 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
1da177e4
LT		 3301 &port->status)) {
3302 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
3303 list_for_each_entry(unit, &port->unit_list_head, list)
3304 zfcp_erp_unit_access_changed(unit);
3305 return;
3306 }
3307
3308 ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
3309 "(due to ACT update)\n",
3310 port->wwpn, zfcp_get_busid_by_adapter(adapter));
3311 if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3312 ZFCP_LOG_NORMAL("failed reopen of port"
3313 "(adapter %s, wwpn=0x%016Lx)\n",
3314 zfcp_get_busid_by_adapter(adapter), port->wwpn);
3315}
3316
1da177e4
LT		 3317void
3318zfcp_erp_unit_access_changed(struct zfcp_unit *unit)
3319{
3320 struct zfcp_adapter *adapter = unit->port->adapter;
3321
d736a27b 3322 debug_text_event(adapter->erp_dbf, 3, "u_access_recover");
1da177e4
LT		 3323 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3324
d736a27b
AH		 3325 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3326 &unit->status) &&
3327 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3328 &unit->status))
1da177e4
LT		 3329 return;
3330
3331 ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
3332 " on adapter %s (due to ACT update)\n",
3333 unit->fcp_lun, unit->port->wwpn,
3334 zfcp_get_busid_by_adapter(adapter));
3335 if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3336 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
3337 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
3338 zfcp_get_busid_by_adapter(adapter),
3339 unit->port->wwpn, unit->fcp_lun);
3340}
3341
3342#undef ZFCP_LOG_AREA
Clone of davem's net-next-2.6 tree