git.oblomov.eu Git - linux-2.6/blob - drivers/s390/scsi/zfcp_erp.c

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