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