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                 ssleep(1);
 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 = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC);
 312         if (send_els->req == NULL)
 313                 goto nomem;
 314         sg_init_table(send_els->req, 1);
 315
 316         send_els->resp = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC);
 317         if (send_els->resp == NULL)
 318                 goto nomem;
 319         sg_init_table(send_els->resp, 1);
 320
 321         address = (void *) get_zeroed_page(GFP_ATOMIC);
 322         if (address == NULL)
 323                 goto nomem;
 324
 325         zfcp_address_to_sg(address, send_els->req, sizeof(struct zfcp_ls_adisc));
 326         address += PAGE_SIZE >> 1;
 327         zfcp_address_to_sg(address, send_els->resp, sizeof(struct zfcp_ls_adisc_acc));
 328         send_els->req_count = send_els->resp_count = 1;
 329
 330         send_els->adapter = adapter;
 331         send_els->port = port;
 332         send_els->d_id = port->d_id;
 333         send_els->handler = zfcp_erp_adisc_handler;
 334         send_els->handler_data = (unsigned long) send_els;
 335
 336         adisc = zfcp_sg_to_address(send_els->req);
 337         send_els->ls_code = adisc->code = ZFCP_LS_ADISC;
 338
 339         /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
 340            without FC-AL-2 capability, so we don't set it */
 341         adisc->wwpn = fc_host_port_name(adapter->scsi_host);
 342         adisc->wwnn = fc_host_node_name(adapter->scsi_host);
 343         adisc->nport_id = fc_host_port_id(adapter->scsi_host);
 344         ZFCP_LOG_INFO("ADISC request from s_id 0x%06x to d_id 0x%06x "
 345                       "(wwpn=0x%016Lx, wwnn=0x%016Lx, "
 346                       "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
 347                       adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn,
 348                       (wwn_t) adisc->wwnn, adisc->hard_nport_id,
 349                       adisc->nport_id);
 350
 351         retval = zfcp_fsf_send_els(send_els);
 352         if (retval != 0) {
 353                 ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
 354                                 "0x%06x on adapter %s\n", send_els->d_id,
 355                                 zfcp_get_busid_by_adapter(adapter));
 356                 goto freemem;
 357         }
 358
 359         goto out;
 360
 361  nomem:
 362         retval = -ENOMEM;
 363  freemem:
 364         if (address != NULL)
 365                 __free_pages(sg_page(send_els->req), 0);
 366         if (send_els != NULL) {
 367                 kfree(send_els->req);
 368                 kfree(send_els->resp);
 369                 kfree(send_els);
 370         }
 371  out:
 372         return retval;
 373 }
 374
 375
 376 /**
 377  * zfcp_erp_adisc_handler - handler for ADISC ELS command
 378  * @data: pointer to struct zfcp_send_els
 379  *
 380  * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered.
 381  */
 382 static void
 383 zfcp_erp_adisc_handler(unsigned long data)
 384 {
 385         struct zfcp_send_els *send_els;
 386         struct zfcp_port *port;
 387         struct zfcp_adapter *adapter;
 388         u32 d_id;
 389         struct zfcp_ls_adisc_acc *adisc;
 390
 391         send_els = (struct zfcp_send_els *) data;
 392         adapter = send_els->adapter;
 393         port = send_els->port;
 394         d_id = send_els->d_id;
 395
 396         /* request rejected or timed out */
 397         if (send_els->status != 0) {
 398                 ZFCP_LOG_NORMAL("ELS request rejected/timed out, "
 399                                 "force physical port reopen "
 400                                 "(adapter %s, port d_id=0x%06x)\n",
 401                                 zfcp_get_busid_by_adapter(adapter), d_id);
 402                 debug_text_event(adapter->erp_dbf, 3, "forcreop");
 403                 if (zfcp_erp_port_forced_reopen(port, 0))
 404                         ZFCP_LOG_NORMAL("failed reopen of port "
 405                                         "(adapter %s, wwpn=0x%016Lx)\n",
 406                                         zfcp_get_busid_by_port(port),
 407                                         port->wwpn);
 408                 goto out;
 409         }
 410
 411         adisc = zfcp_sg_to_address(send_els->resp);
 412
 413         ZFCP_LOG_INFO("ADISC response from d_id 0x%06x to s_id "
 414                       "0x%06x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
 415                       "hard_nport_id=0x%06x, nport_id=0x%06x)\n",
 416                       d_id, fc_host_port_id(adapter->scsi_host),
 417                       (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn,
 418                       adisc->hard_nport_id, adisc->nport_id);
 419
 420         /* set wwnn for port */
 421         if (port->wwnn == 0)
 422                 port->wwnn = adisc->wwnn;
 423
 424         if (port->wwpn != adisc->wwpn) {
 425                 ZFCP_LOG_NORMAL("d_id assignment changed, reopening "
 426                                 "port (adapter %s, wwpn=0x%016Lx, "
 427                                 "adisc_resp_wwpn=0x%016Lx)\n",
 428                                 zfcp_get_busid_by_port(port),
 429                                 port->wwpn, (wwn_t) adisc->wwpn);
 430                 if (zfcp_erp_port_reopen(port, 0))
 431                         ZFCP_LOG_NORMAL("failed reopen of port "
 432                                         "(adapter %s, wwpn=0x%016Lx)\n",
 433                                         zfcp_get_busid_by_port(port),
 434                                         port->wwpn);
 435         }
 436
 437  out:
 438         zfcp_port_put(port);
 439         __free_pages(sg_page(send_els->req), 0);
 440         kfree(send_els->req);
 441         kfree(send_els->resp);
 442         kfree(send_els);
 443 }
 444
 445
 446 /**
 447  * zfcp_test_link - lightweight link test procedure
 448  * @port: port to be tested
 449  *
 450  * Test status of a link to a remote port using the ELS command ADISC.
 451  */
 452 int
 453 zfcp_test_link(struct zfcp_port *port)
 454 {
 455         int retval;
 456
 457         zfcp_port_get(port);
 458         retval = zfcp_erp_adisc(port);
 459         if (retval != 0 && retval != -EBUSY) {
 460                 zfcp_port_put(port);
 461                 ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx "
 462                                 "on adapter %s\n ", port->wwpn,
 463                                 zfcp_get_busid_by_port(port));
 464                 retval = zfcp_erp_port_forced_reopen(port, 0);
 465                 if (retval != 0) {
 466                         ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx "
 467                                         "on adapter %s failed\n", port->wwpn,
 468                                         zfcp_get_busid_by_port(port));
 469                         retval = -EPERM;
 470                 }
 471         }
 472
 473         return retval;
 474 }
 475
 476
 477 /*
 478  * function:
 479  *
 480  * purpose:     called if a port failed to be opened normally
 481  *              initiates Forced Reopen recovery which is done
 482  *              asynchronously
 483  *
 484  * returns:     0       - initiated action successfully
 485  *              <0      - failed to initiate action
 486  */
 487 static int
 488 zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask)
 489 {
 490         int retval;
 491         struct zfcp_adapter *adapter = port->adapter;
 492
 493         debug_text_event(adapter->erp_dbf, 5, "pf_ro");
 494         debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
 495
 496         ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n",
 497                        port->wwpn, zfcp_get_busid_by_port(port));
 498
 499         zfcp_erp_port_block(port, clear_mask);
 500
 501         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
 502                 ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx "
 503                                "on adapter %s\n", port->wwpn,
 504                                zfcp_get_busid_by_port(port));
 505                 debug_text_event(adapter->erp_dbf, 5, "pf_ro_f");
 506                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
 507                 retval = -EIO;
 508                 goto out;
 509         }
 510
 511         retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
 512                                          port->adapter, port, NULL);
 513
 514  out:
 515         return retval;
 516 }
 517
 518 /*
 519  * function:
 520  *
 521  * purpose:     Wrappper for zfcp_erp_port_forced_reopen_internal
 522  *              used to ensure the correct locking
 523  *
 524  * returns:     0       - initiated action successfully
 525  *              <0      - failed to initiate action
 526  */
 527 int
 528 zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask)
 529 {
 530         int retval;
 531         unsigned long flags;
 532         struct zfcp_adapter *adapter;
 533
 534         adapter = port->adapter;
 535         read_lock_irqsave(&zfcp_data.config_lock, flags);
 536         write_lock(&adapter->erp_lock);
 537         retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask);
 538         write_unlock(&adapter->erp_lock);
 539         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 540
 541         return retval;
 542 }
 543
 544 /*
 545  * function:
 546  *
 547  * purpose:     called if a port is to be opened
 548  *              initiates Reopen recovery which is done
 549  *              asynchronously
 550  *
 551  * returns:     0       - initiated action successfully
 552  *              <0      - failed to initiate action
 553  */
 554 static int
 555 zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask)
 556 {
 557         int retval;
 558         struct zfcp_adapter *adapter = port->adapter;
 559
 560         debug_text_event(adapter->erp_dbf, 5, "p_ro");
 561         debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
 562
 563         ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n",
 564                        port->wwpn, zfcp_get_busid_by_port(port));
 565
 566         zfcp_erp_port_block(port, clear_mask);
 567
 568         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
 569                 ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx "
 570                                "on adapter %s\n", port->wwpn,
 571                                zfcp_get_busid_by_port(port));
 572                 debug_text_event(adapter->erp_dbf, 5, "p_ro_f");
 573                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
 574                 /* ensure propagation of failed status to new devices */
 575                 zfcp_erp_port_failed(port);
 576                 retval = -EIO;
 577                 goto out;
 578         }
 579
 580         retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
 581                                          port->adapter, port, NULL);
 582
 583  out:
 584         return retval;
 585 }
 586
 587 /**
 588  * zfcp_erp_port_reopen - initiate reopen of a remote port
 589  * @port: port to be reopened
 590  * @clear_mask: specifies flags in port status to be cleared
 591  * Return: 0 on success, < 0 on error
 592  *
 593  * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures
 594  * correct locking. An error recovery task is initiated to do the reopen.
 595  * To wait for the completion of the reopen zfcp_erp_wait should be used.
 596  */
 597 int
 598 zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask)
 599 {
 600         int retval;
 601         unsigned long flags;
 602         struct zfcp_adapter *adapter = port->adapter;
 603
 604         read_lock_irqsave(&zfcp_data.config_lock, flags);
 605         write_lock(&adapter->erp_lock);
 606         retval = zfcp_erp_port_reopen_internal(port, clear_mask);
 607         write_unlock(&adapter->erp_lock);
 608         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 609
 610         return retval;
 611 }
 612
 613 /*
 614  * function:
 615  *
 616  * purpose:     called if a unit is to be opened
 617  *              initiates Reopen recovery which is done
 618  *              asynchronously
 619  *
 620  * returns:     0       - initiated action successfully
 621  *              <0      - failed to initiate action
 622  */
 623 static int
 624 zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask)
 625 {
 626         int retval;
 627         struct zfcp_adapter *adapter = unit->port->adapter;
 628
 629         debug_text_event(adapter->erp_dbf, 5, "u_ro");
 630         debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
 631         ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx "
 632                        "on adapter %s\n", unit->fcp_lun,
 633                        unit->port->wwpn, zfcp_get_busid_by_unit(unit));
 634
 635         zfcp_erp_unit_block(unit, clear_mask);
 636
 637         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
 638                 ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx "
 639                                "on port 0x%016Lx on adapter %s\n",
 640                                unit->fcp_lun, unit->port->wwpn,
 641                                zfcp_get_busid_by_unit(unit));
 642                 debug_text_event(adapter->erp_dbf, 5, "u_ro_f");
 643                 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
 644                             sizeof (fcp_lun_t));
 645                 retval = -EIO;
 646                 goto out;
 647         }
 648
 649         retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
 650                                          unit->port->adapter, unit->port, unit);
 651  out:
 652         return retval;
 653 }
 654
 655 /**
 656  * zfcp_erp_unit_reopen - initiate reopen of a unit
 657  * @unit: unit to be reopened
 658  * @clear_mask: specifies flags in unit status to be cleared
 659  * Return: 0 on success, < 0 on error
 660  *
 661  * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct
 662  * locking. An error recovery task is initiated to do the reopen.
 663  * To wait for the completion of the reopen zfcp_erp_wait should be used.
 664  */
 665 int
 666 zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask)
 667 {
 668         int retval;
 669         unsigned long flags;
 670         struct zfcp_adapter *adapter;
 671         struct zfcp_port *port;
 672
 673         port = unit->port;
 674         adapter = port->adapter;
 675
 676         read_lock_irqsave(&zfcp_data.config_lock, flags);
 677         write_lock(&adapter->erp_lock);
 678         retval = zfcp_erp_unit_reopen_internal(unit, clear_mask);
 679         write_unlock(&adapter->erp_lock);
 680         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 681
 682         return retval;
 683 }
 684
 685 /**
 686  * zfcp_erp_adapter_block - mark adapter as blocked, block scsi requests
 687  */
 688 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
 689 {
 690         debug_text_event(adapter->erp_dbf, 6, "a_bl");
 691         zfcp_erp_modify_adapter_status(adapter,
 692                                        ZFCP_STATUS_COMMON_UNBLOCKED |
 693                                        clear_mask, ZFCP_CLEAR);
 694 }
 695
 696 /**
 697  * zfcp_erp_adapter_unblock - mark adapter as unblocked, allow scsi requests
 698  */
 699 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 700 {
 701         debug_text_event(adapter->erp_dbf, 6, "a_ubl");
 702         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
 703 }
 704
 705 /*
 706  * function:
 707  *
 708  * purpose:     disable I/O,
 709  *              return any open requests and clean them up,
 710  *              aim: no pending and incoming I/O
 711  *
 712  * returns:
 713  */
 714 static void
 715 zfcp_erp_port_block(struct zfcp_port *port, int clear_mask)
 716 {
 717         struct zfcp_adapter *adapter = port->adapter;
 718
 719         debug_text_event(adapter->erp_dbf, 6, "p_bl");
 720         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
 721         zfcp_erp_modify_port_status(port,
 722                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
 723                                     ZFCP_CLEAR);
 724 }
 725
 726 /*
 727  * function:
 728  *
 729  * purpose:     enable I/O
 730  *
 731  * returns:
 732  */
 733 static void
 734 zfcp_erp_port_unblock(struct zfcp_port *port)
 735 {
 736         struct zfcp_adapter *adapter = port->adapter;
 737
 738         debug_text_event(adapter->erp_dbf, 6, "p_ubl");
 739         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
 740         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
 741 }
 742
 743 /*
 744  * function:
 745  *
 746  * purpose:     disable I/O,
 747  *              return any open requests and clean them up,
 748  *              aim: no pending and incoming I/O
 749  *
 750  * returns:
 751  */
 752 static void
 753 zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
 754 {
 755         struct zfcp_adapter *adapter = unit->port->adapter;
 756
 757         debug_text_event(adapter->erp_dbf, 6, "u_bl");
 758         debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
 759         zfcp_erp_modify_unit_status(unit,
 760                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
 761                                     ZFCP_CLEAR);
 762 }
 763
 764 /*
 765  * function:
 766  *
 767  * purpose:     enable I/O
 768  *
 769  * returns:
 770  */
 771 static void
 772 zfcp_erp_unit_unblock(struct zfcp_unit *unit)
 773 {
 774         struct zfcp_adapter *adapter = unit->port->adapter;
 775
 776         debug_text_event(adapter->erp_dbf, 6, "u_ubl");
 777         debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
 778         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
 779 }
 780
 781 static void
 782 zfcp_erp_action_ready(struct zfcp_erp_action *erp_action)
 783 {
 784         struct zfcp_adapter *adapter = erp_action->adapter;
 785
 786         debug_text_event(adapter->erp_dbf, 4, "a_ar");
 787         debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
 788
 789         zfcp_erp_action_to_ready(erp_action);
 790         up(&adapter->erp_ready_sem);
 791 }
 792
 793 /*
 794  * function:
 795  *
 796  * purpose:
 797  *
 798  * returns:     <0                      erp_action not found in any list
 799  *              ZFCP_ERP_ACTION_READY   erp_action is in ready list
 800  *              ZFCP_ERP_ACTION_RUNNING erp_action is in running list
 801  *
 802  * locks:       erp_lock must be held
 803  */
 804 static int
 805 zfcp_erp_action_exists(struct zfcp_erp_action *erp_action)
 806 {
 807         int retval = -EINVAL;
 808         struct list_head *entry;
 809         struct zfcp_erp_action *entry_erp_action;
 810         struct zfcp_adapter *adapter = erp_action->adapter;
 811
 812         /* search in running list */
 813         list_for_each(entry, &adapter->erp_running_head) {
 814                 entry_erp_action =
 815                     list_entry(entry, struct zfcp_erp_action, list);
 816                 if (entry_erp_action == erp_action) {
 817                         retval = ZFCP_ERP_ACTION_RUNNING;
 818                         goto out;
 819                 }
 820         }
 821         /* search in ready list */
 822         list_for_each(entry, &adapter->erp_ready_head) {
 823                 entry_erp_action =
 824                     list_entry(entry, struct zfcp_erp_action, list);
 825                 if (entry_erp_action == erp_action) {
 826                         retval = ZFCP_ERP_ACTION_READY;
 827                         goto out;
 828                 }
 829         }
 830
 831  out:
 832         return retval;
 833 }
 834
 835 /*
 836  * purpose:     checks current status of action (timed out, dismissed, ...)
 837  *              and does appropriate preparations (dismiss fsf request, ...)
 838  *
 839  * locks:       called under erp_lock (disabled interrupts)
 840  */
 841 static void
 842 zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
 843 {
 844         struct zfcp_adapter *adapter = erp_action->adapter;
 845
 846         if (erp_action->fsf_req) {
 847                 /* take lock to ensure that request is not deleted meanwhile */
 848                 spin_lock(&adapter->req_list_lock);
 849                 if (zfcp_reqlist_find_safe(adapter, erp_action->fsf_req) &&
 850                     erp_action->fsf_req->erp_action == erp_action) {
 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         erp_action->status |= ZFCP_STATUS_ERP_DISMISSED;
 982         if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING)
 983                 zfcp_erp_action_ready(erp_action);
 984 }
 985
 986 int
 987 zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
 988 {
 989         int retval = 0;
 990
 991         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
 992
 993         retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
 994         if (retval < 0) {
 995                 ZFCP_LOG_NORMAL("error: creation of erp thread failed for "
 996                                 "adapter %s\n",
 997                                 zfcp_get_busid_by_adapter(adapter));
 998                 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail");
 999         } else {
1000                 wait_event(adapter->erp_thread_wqh,
1001                            atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1002                                             &adapter->status));
1003                 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok");
1004         }
1005
1006         return (retval < 0);
1007 }
1008
1009 /*
1010  * function:
1011  *
1012  * purpose:
1013  *
1014  * returns:
1015  *
1016  * context:     process (i.e. proc-fs or rmmod/insmod)
1017  *
1018  * note:        The caller of this routine ensures that the specified
1019  *              adapter has been shut down and that this operation
1020  *              has been completed. Thus, there are no pending erp_actions
1021  *              which would need to be handled here.
1022  */
1023 int
1024 zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1025 {
1026         int retval = 0;
1027
1028         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1029         up(&adapter->erp_ready_sem);
1030
1031         wait_event(adapter->erp_thread_wqh,
1032                    !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1033                                      &adapter->status));
1034
1035         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1036                           &adapter->status);
1037
1038         debug_text_event(adapter->erp_dbf, 5, "a_thki_ok");
1039
1040         return retval;
1041 }
1042
1043 /*
1044  * purpose:     is run as a kernel thread,
1045  *              goes through list of error recovery actions of associated adapter
1046  *              and delegates single action to execution
1047  *
1048  * returns:     0
1049  */
1050 static int
1051 zfcp_erp_thread(void *data)
1052 {
1053         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1054         struct list_head *next;
1055         struct zfcp_erp_action *erp_action;
1056         unsigned long flags;
1057
1058         daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter));
1059         /* Block all signals */
1060         siginitsetinv(&current->blocked, 0);
1061         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1062         debug_text_event(adapter->erp_dbf, 5, "a_th_run");
1063         wake_up(&adapter->erp_thread_wqh);
1064
1065         while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1066                                  &adapter->status)) {
1067
1068                 write_lock_irqsave(&adapter->erp_lock, flags);
1069                 next = adapter->erp_ready_head.next;
1070                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1071
1072                 if (next != &adapter->erp_ready_head) {
1073                         erp_action =
1074                             list_entry(next, struct zfcp_erp_action, list);
1075                         /*
1076                          * process action (incl. [re]moving it
1077                          * from 'ready' queue)
1078                          */
1079                         zfcp_erp_strategy(erp_action);
1080                 }
1081
1082                 /*
1083                  * sleep as long as there is nothing to do, i.e.
1084                  * no action in 'ready' queue to be processed and
1085                  * thread is not to be killed
1086                  */
1087                 down_interruptible(&adapter->erp_ready_sem);
1088                 debug_text_event(adapter->erp_dbf, 5, "a_th_woken");
1089         }
1090
1091         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1092         debug_text_event(adapter->erp_dbf, 5, "a_th_stop");
1093         wake_up(&adapter->erp_thread_wqh);
1094
1095         return 0;
1096 }
1097
1098 /*
1099  * function:
1100  *
1101  * purpose:     drives single error recovery action and schedules higher and
1102  *              subordinate actions, if necessary
1103  *
1104  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
1105  *              ZFCP_ERP_SUCCEEDED      - action finished successfully (deqd)
1106  *              ZFCP_ERP_FAILED         - action finished unsuccessfully (deqd)
1107  *              ZFCP_ERP_EXIT           - action finished (dequeued), offline
1108  *              ZFCP_ERP_DISMISSED      - action canceled (dequeued)
1109  */
1110 static int
1111 zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1112 {
1113         int retval = 0;
1114         struct zfcp_adapter *adapter = erp_action->adapter;
1115         struct zfcp_port *port = erp_action->port;
1116         struct zfcp_unit *unit = erp_action->unit;
1117         int action = erp_action->action;
1118         u32 status = erp_action->status;
1119         unsigned long flags;
1120
1121         /* serialise dismissing, timing out, moving, enqueueing */
1122         read_lock_irqsave(&zfcp_data.config_lock, flags);
1123         write_lock(&adapter->erp_lock);
1124
1125         /* dequeue dismissed action and leave, if required */
1126         retval = zfcp_erp_strategy_check_action(erp_action, retval);
1127         if (retval == ZFCP_ERP_DISMISSED) {
1128                 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1");
1129                 goto unlock;
1130         }
1131
1132         /*
1133          * move action to 'running' queue before processing it
1134          * (to avoid a race condition regarding moving the
1135          * action to the 'running' queue and back)
1136          */
1137         zfcp_erp_action_to_running(erp_action);
1138
1139         /*
1140          * try to process action as far as possible,
1141          * no lock to allow for blocking operations (kmalloc, qdio, ...),
1142          * afterwards the lock is required again for the following reasons:
1143          * - dequeueing of finished action and enqueueing of
1144          *   follow-up actions must be atomic so that any other
1145          *   reopen-routine does not believe there is nothing to do
1146          *   and that it is safe to enqueue something else,
1147          * - we want to force any control thread which is dismissing
1148          *   actions to finish this before we decide about
1149          *   necessary steps to be taken here further
1150          */
1151         write_unlock(&adapter->erp_lock);
1152         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1153         retval = zfcp_erp_strategy_do_action(erp_action);
1154         read_lock_irqsave(&zfcp_data.config_lock, flags);
1155         write_lock(&adapter->erp_lock);
1156
1157         /*
1158          * check for dismissed status again to avoid follow-up actions,
1159          * failing of targets and so on for dismissed actions,
1160          * we go through down() here because there has been an up()
1161          */
1162         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1163                 retval = ZFCP_ERP_CONTINUES;
1164
1165         switch (retval) {
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 separate 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         zfcp_unit_put(unit);
1614         kfree(p);
1615 }
1616
1617 /**
1618  * zfcp_erp_schedule_work
1619  * @unit: pointer to unit which should be registered with SCSI stack
1620  *
1621  * Schedules work which registers a unit with the SCSI stack
1622  */
1623 static void
1624 zfcp_erp_schedule_work(struct zfcp_unit *unit)
1625 {
1626         struct zfcp_erp_add_work *p;
1627
1628         p = kzalloc(sizeof(*p), GFP_KERNEL);
1629         if (!p) {
1630                 ZFCP_LOG_NORMAL("error: Out of resources. Could not register "
1631                                 "the FCP-LUN 0x%Lx connected to "
1632                                 "the port with WWPN 0x%Lx connected to "
1633                                 "the adapter %s with the SCSI stack.\n",
1634                                 unit->fcp_lun,
1635                                 unit->port->wwpn,
1636                                 zfcp_get_busid_by_unit(unit));
1637                 return;
1638         }
1639
1640         zfcp_unit_get(unit);
1641         atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1642         INIT_WORK(&p->work, zfcp_erp_scsi_scan);
1643         p->unit = unit;
1644         schedule_work(&p->work);
1645 }
1646
1647 /*
1648  * function:
1649  *
1650  * purpose:     remaining things in good cases,
1651  *              escalation in bad cases
1652  *
1653  * returns:
1654  */
1655 static int
1656 zfcp_erp_strategy_followup_actions(int action,
1657                                    struct zfcp_adapter *adapter,
1658                                    struct zfcp_port *port,
1659                                    struct zfcp_unit *unit, int status)
1660 {
1661         debug_text_event(adapter->erp_dbf, 5, "a_stfol");
1662         debug_event(adapter->erp_dbf, 5, &action, sizeof (int));
1663
1664         /* initiate follow-up actions depending on success of finished action */
1665         switch (action) {
1666
1667         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1668                 if (status == ZFCP_ERP_SUCCEEDED)
1669                         zfcp_erp_port_reopen_all_internal(adapter, 0);
1670                 else
1671                         zfcp_erp_adapter_reopen_internal(adapter, 0);
1672                 break;
1673
1674         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1675                 if (status == ZFCP_ERP_SUCCEEDED)
1676                         zfcp_erp_port_reopen_internal(port, 0);
1677                 else
1678                         zfcp_erp_adapter_reopen_internal(adapter, 0);
1679                 break;
1680
1681         case ZFCP_ERP_ACTION_REOPEN_PORT:
1682                 if (status == ZFCP_ERP_SUCCEEDED)
1683                         zfcp_erp_unit_reopen_all_internal(port, 0);
1684                 else
1685                         zfcp_erp_port_forced_reopen_internal(port, 0);
1686                 break;
1687
1688         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1689                 /* Nothing to do if status == ZFCP_ERP_SUCCEEDED */
1690                 if (status != ZFCP_ERP_SUCCEEDED)
1691                         zfcp_erp_port_reopen_internal(unit->port, 0);
1692                 break;
1693         }
1694
1695         return 0;
1696 }
1697
1698 static int
1699 zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter)
1700 {
1701         unsigned long flags;
1702
1703         read_lock_irqsave(&zfcp_data.config_lock, flags);
1704         read_lock(&adapter->erp_lock);
1705         if (list_empty(&adapter->erp_ready_head) &&
1706             list_empty(&adapter->erp_running_head)) {
1707                         debug_text_event(adapter->erp_dbf, 4, "a_cq_wake");
1708                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1709                                           &adapter->status);
1710                         wake_up(&adapter->erp_done_wqh);
1711         } else
1712                 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty");
1713         read_unlock(&adapter->erp_lock);
1714         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1715
1716         return 0;
1717 }
1718
1719 /**
1720  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1721  * @adapter: adapter for which to wait for completion of its error recovery
1722  * Return: 0
1723  */
1724 int
1725 zfcp_erp_wait(struct zfcp_adapter *adapter)
1726 {
1727         int retval = 0;
1728
1729         wait_event(adapter->erp_done_wqh,
1730                    !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1731                                      &adapter->status));
1732
1733         return retval;
1734 }
1735
1736 void
1737 zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter,
1738                                u32 mask, int set_or_clear)
1739 {
1740         struct zfcp_port *port;
1741         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1742
1743         if (set_or_clear == ZFCP_SET) {
1744                 atomic_set_mask(mask, &adapter->status);
1745                 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s");
1746         } else {
1747                 atomic_clear_mask(mask, &adapter->status);
1748                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1749                         atomic_set(&adapter->erp_counter, 0);
1750                 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c");
1751         }
1752         debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32));
1753
1754         /* Deal with all underlying devices, only pass common_mask */
1755         if (common_mask)
1756                 list_for_each_entry(port, &adapter->port_list_head, list)
1757                     zfcp_erp_modify_port_status(port, common_mask,
1758                                                 set_or_clear);
1759 }
1760
1761 /*
1762  * function:    zfcp_erp_modify_port_status
1763  *
1764  * purpose:     sets the port and all underlying devices to ERP_FAILED
1765  *
1766  */
1767 void
1768 zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear)
1769 {
1770         struct zfcp_unit *unit;
1771         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1772
1773         if (set_or_clear == ZFCP_SET) {
1774                 atomic_set_mask(mask, &port->status);
1775                 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s");
1776         } else {
1777                 atomic_clear_mask(mask, &port->status);
1778                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1779                         atomic_set(&port->erp_counter, 0);
1780                 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c");
1781         }
1782         debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
1783         debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1784
1785         /* Modify status of all underlying devices, only pass common mask */
1786         if (common_mask)
1787                 list_for_each_entry(unit, &port->unit_list_head, list)
1788                     zfcp_erp_modify_unit_status(unit, common_mask,
1789                                                 set_or_clear);
1790 }
1791
1792 /*
1793  * function:    zfcp_erp_modify_unit_status
1794  *
1795  * purpose:     sets the unit to ERP_FAILED
1796  *
1797  */
1798 void
1799 zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear)
1800 {
1801         if (set_or_clear == ZFCP_SET) {
1802                 atomic_set_mask(mask, &unit->status);
1803                 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s");
1804         } else {
1805                 atomic_clear_mask(mask, &unit->status);
1806                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1807                         atomic_set(&unit->erp_counter, 0);
1808                 }
1809                 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c");
1810         }
1811         debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun,
1812                     sizeof (fcp_lun_t));
1813         debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1814 }
1815
1816 /*
1817  * function:
1818  *
1819  * purpose:     Wrappper for zfcp_erp_port_reopen_all_internal
1820  *              used to ensure the correct locking
1821  *
1822  * returns:     0       - initiated action successfully
1823  *              <0      - failed to initiate action
1824  */
1825 int
1826 zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask)
1827 {
1828         int retval;
1829         unsigned long flags;
1830
1831         read_lock_irqsave(&zfcp_data.config_lock, flags);
1832         write_lock(&adapter->erp_lock);
1833         retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask);
1834         write_unlock(&adapter->erp_lock);
1835         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1836
1837         return retval;
1838 }
1839
1840 static int
1841 zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask)
1842 {
1843         int retval = 0;
1844         struct zfcp_port *port;
1845
1846         list_for_each_entry(port, &adapter->port_list_head, list)
1847                 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1848                         zfcp_erp_port_reopen_internal(port, clear_mask);
1849
1850         return retval;
1851 }
1852
1853 /*
1854  * function:
1855  *
1856  * purpose:
1857  *
1858  * returns:     FIXME
1859  */
1860 static int
1861 zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask)
1862 {
1863         int retval = 0;
1864         struct zfcp_unit *unit;
1865
1866         list_for_each_entry(unit, &port->unit_list_head, list)
1867             zfcp_erp_unit_reopen_internal(unit, clear_mask);
1868
1869         return retval;
1870 }
1871
1872 /*
1873  * function:
1874  *
1875  * purpose:     this routine executes the 'Reopen Adapter' action
1876  *              (the entire action is processed synchronously, since
1877  *              there are no actions which might be run concurrently
1878  *              per definition)
1879  *
1880  * returns:     ZFCP_ERP_SUCCEEDED      - action finished successfully
1881  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
1882  */
1883 static int
1884 zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action)
1885 {
1886         int retval;
1887         struct zfcp_adapter *adapter = erp_action->adapter;
1888
1889         retval = zfcp_erp_adapter_strategy_close(erp_action);
1890         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1891                 retval = ZFCP_ERP_EXIT;
1892         else
1893                 retval = zfcp_erp_adapter_strategy_open(erp_action);
1894
1895         debug_text_event(adapter->erp_dbf, 3, "a_ast/ret");
1896         debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
1897         debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
1898
1899         if (retval == ZFCP_ERP_FAILED) {
1900                 ZFCP_LOG_INFO("Waiting to allow the adapter %s "
1901                               "to recover itself\n",
1902                               zfcp_get_busid_by_adapter(adapter));
1903                 ssleep(ZFCP_TYPE2_RECOVERY_TIME);
1904         }
1905
1906         return retval;
1907 }
1908
1909 /*
1910  * function:
1911  *
1912  * purpose:
1913  *
1914  * returns:     ZFCP_ERP_SUCCEEDED      - action finished successfully
1915  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
1916  */
1917 static int
1918 zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action)
1919 {
1920         int retval;
1921
1922         atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING,
1923                         &erp_action->adapter->status);
1924         retval = zfcp_erp_adapter_strategy_generic(erp_action, 1);
1925         atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING,
1926                           &erp_action->adapter->status);
1927
1928         return retval;
1929 }
1930
1931 /*
1932  * function:
1933  *
1934  * purpose:
1935  *
1936  * returns:     ZFCP_ERP_SUCCEEDED      - action finished successfully
1937  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
1938  */
1939 static int
1940 zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action)
1941 {
1942         int retval;
1943
1944         atomic_set_mask(ZFCP_STATUS_COMMON_OPENING,
1945                         &erp_action->adapter->status);
1946         retval = zfcp_erp_adapter_strategy_generic(erp_action, 0);
1947         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING,
1948                           &erp_action->adapter->status);
1949
1950         return retval;
1951 }
1952
1953 /*
1954  * function:    zfcp_register_adapter
1955  *
1956  * purpose:     allocate the irq associated with this devno and register
1957  *              the FSF adapter with the SCSI stack
1958  *
1959  * returns:
1960  */
1961 static int
1962 zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
1963 {
1964         int retval = ZFCP_ERP_SUCCEEDED;
1965
1966         if (close)
1967                 goto close_only;
1968
1969         retval = zfcp_erp_adapter_strategy_open_qdio(erp_action);
1970         if (retval != ZFCP_ERP_SUCCEEDED)
1971                 goto failed_qdio;
1972
1973         retval = zfcp_erp_adapter_strategy_open_fsf(erp_action);
1974         if (retval != ZFCP_ERP_SUCCEEDED)
1975                 goto failed_openfcp;
1976
1977         atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status);
1978         goto out;
1979
1980  close_only:
1981         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1982                           &erp_action->adapter->status);
1983
1984  failed_openfcp:
1985         zfcp_close_fsf(erp_action->adapter);
1986  failed_qdio:
1987         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
1988                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
1989                           ZFCP_STATUS_ADAPTER_XPORT_OK,
1990                           &erp_action->adapter->status);
1991  out:
1992         return retval;
1993 }
1994
1995 /*
1996  * function:    zfcp_qdio_init
1997  *
1998  * purpose:     setup QDIO operation for specified adapter
1999  *
2000  * returns:     0 - successful setup
2001  *              !0 - failed setup
2002  */
2003 static int
2004 zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
2005 {
2006         int retval;
2007         int i;
2008         volatile struct qdio_buffer_element *sbale;
2009         struct zfcp_adapter *adapter = erp_action->adapter;
2010
2011         if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
2012                 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "
2013                                 "adapter %s\n",
2014                                 zfcp_get_busid_by_adapter(adapter));
2015                 goto failed_sanity;
2016         }
2017
2018         if (qdio_establish(&adapter->qdio_init_data) != 0) {
2019                 ZFCP_LOG_INFO("error: establishment of QDIO queues failed "
2020                               "on adapter %s\n",
2021                               zfcp_get_busid_by_adapter(adapter));
2022                 goto failed_qdio_establish;
2023         }
2024         debug_text_event(adapter->erp_dbf, 3, "qdio_est");
2025
2026         if (qdio_activate(adapter->ccw_device, 0) != 0) {
2027                 ZFCP_LOG_INFO("error: activation of QDIO queues failed "
2028                               "on adapter %s\n",
2029                               zfcp_get_busid_by_adapter(adapter));
2030                 goto failed_qdio_activate;
2031         }
2032         debug_text_event(adapter->erp_dbf, 3, "qdio_act");
2033
2034         /*
2035          * put buffers into response queue,
2036          */
2037         for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
2038                 sbale = &(adapter->response_queue.buffer[i]->element[0]);
2039                 sbale->length = 0;
2040                 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
2041                 sbale->addr = NULL;
2042         }
2043
2044         ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
2045                        "queue_no=%i, index_in_queue=%i, count=%i)\n",
2046                        zfcp_get_busid_by_adapter(adapter),
2047                        QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);
2048
2049         retval = do_QDIO(adapter->ccw_device,
2050                          QDIO_FLAG_SYNC_INPUT,
2051                          0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);
2052
2053         if (retval) {
2054                 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",
2055                                 retval);
2056                 goto failed_do_qdio;
2057         } else {
2058                 adapter->response_queue.free_index = 0;
2059                 atomic_set(&adapter->response_queue.free_count, 0);
2060                 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "
2061                                "response queue\n", QDIO_MAX_BUFFERS_PER_Q);
2062         }
2063         /* set index of first avalable SBALS / number of available SBALS */
2064         adapter->request_queue.free_index = 0;
2065         atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);
2066         adapter->request_queue.distance_from_int = 0;
2067
2068         /* initialize waitqueue used to wait for free SBALs in requests queue */
2069         init_waitqueue_head(&adapter->request_wq);
2070
2071         /* ok, we did it - skip all cleanups for different failures */
2072         atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
2073         retval = ZFCP_ERP_SUCCEEDED;
2074         goto out;
2075
2076  failed_do_qdio:
2077         /* NOP */
2078
2079  failed_qdio_activate:
2080         debug_text_event(adapter->erp_dbf, 3, "qdio_down1a");
2081         while (qdio_shutdown(adapter->ccw_device,
2082                              QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
2083                 ssleep(1);
2084         debug_text_event(adapter->erp_dbf, 3, "qdio_down1b");
2085
2086  failed_qdio_establish:
2087  failed_sanity:
2088         retval = ZFCP_ERP_FAILED;
2089
2090  out:
2091         return retval;
2092 }
2093
2094
2095 static int
2096 zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
2097 {
2098         int retval;
2099
2100         retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action);
2101         if (retval == ZFCP_ERP_FAILED)
2102                 return ZFCP_ERP_FAILED;
2103
2104         retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action);
2105         if (retval == ZFCP_ERP_FAILED)
2106                 return ZFCP_ERP_FAILED;
2107
2108         return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action);
2109 }
2110
2111 static int
2112 zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
2113 {
2114         int retval = ZFCP_ERP_SUCCEEDED;
2115         int retries;
2116         int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP;
2117         struct zfcp_adapter *adapter = erp_action->adapter;
2118
2119         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
2120
2121         for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) {
2122                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2123                                   &adapter->status);
2124                 ZFCP_LOG_DEBUG("Doing exchange config data\n");
2125                 write_lock_irq(&adapter->erp_lock);
2126                 zfcp_erp_action_to_running(erp_action);
2127                 write_unlock_irq(&adapter->erp_lock);
2128                 if (zfcp_fsf_exchange_config_data(erp_action)) {
2129                         retval = ZFCP_ERP_FAILED;
2130                         debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
2131                         ZFCP_LOG_INFO("error:  initiation of exchange of "
2132                                       "configuration data failed for "
2133                                       "adapter %s\n",
2134                                       zfcp_get_busid_by_adapter(adapter));
2135                         break;
2136                 }
2137                 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok");
2138                 ZFCP_LOG_DEBUG("Xchange underway\n");
2139
2140                 /*
2141                  * Why this works:
2142                  * Both the normal completion handler as well as the timeout
2143                  * handler will do an 'up' when the 'exchange config data'
2144                  * request completes or times out. Thus, the signal to go on
2145                  * won't be lost utilizing this semaphore.
2146                  * Furthermore, this 'adapter_reopen' action is
2147                  * guaranteed to be the only action being there (highest action
2148                  * which prevents other actions from being created).
2149                  * Resulting from that, the wake signal recognized here
2150                  * _must_ be the one belonging to the 'exchange config
2151                  * data' request.
2152                  */
2153                 down(&adapter->erp_ready_sem);
2154                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2155                         ZFCP_LOG_INFO("error: exchange of configuration data "
2156                                       "for adapter %s timed out\n",
2157                                       zfcp_get_busid_by_adapter(adapter));
2158                         break;
2159                 }
2160
2161                 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2162                                      &adapter->status))
2163                         break;
2164
2165                 ZFCP_LOG_DEBUG("host connection still initialising... "
2166                                "waiting and retrying...\n");
2167                 /* sleep a little bit before retry */
2168                 ssleep(sleep);
2169                 sleep *= 2;
2170         }
2171
2172         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2173                           &adapter->status);
2174
2175         if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
2176                               &adapter->status)) {
2177                 ZFCP_LOG_INFO("error: exchange of configuration data for "
2178                               "adapter %s failed\n",
2179                               zfcp_get_busid_by_adapter(adapter));
2180                 retval = ZFCP_ERP_FAILED;
2181         }
2182
2183         return retval;
2184 }
2185
2186 static int
2187 zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
2188 {
2189         int ret;
2190         struct zfcp_adapter *adapter;
2191
2192         adapter = erp_action->adapter;
2193         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
2194
2195         write_lock_irq(&adapter->erp_lock);
2196         zfcp_erp_action_to_running(erp_action);
2197         write_unlock_irq(&adapter->erp_lock);
2198
2199         ret = zfcp_fsf_exchange_port_data(erp_action);
2200         if (ret == -EOPNOTSUPP) {
2201                 debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");
2202                 return ZFCP_ERP_SUCCEEDED;
2203         } else if (ret) {
2204                 debug_text_event(adapter->erp_dbf, 3, "a_xport_failed");
2205                 return ZFCP_ERP_FAILED;
2206         }
2207         debug_text_event(adapter->erp_dbf, 6, "a_xport_ok");
2208
2209         ret = ZFCP_ERP_SUCCEEDED;
2210         down(&adapter->erp_ready_sem);
2211         if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2212                 ZFCP_LOG_INFO("error: exchange port data timed out (adapter "
2213                               "%s)\n", zfcp_get_busid_by_adapter(adapter));
2214                 ret = ZFCP_ERP_FAILED;
2215         }
2216
2217         /* don't treat as error for the sake of compatibility */
2218         if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status))
2219                 ZFCP_LOG_INFO("warning: exchange port data failed (adapter "
2220                               "%s\n", zfcp_get_busid_by_adapter(adapter));
2221
2222         return ret;
2223 }
2224
2225 static int
2226 zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
2227                                               *erp_action)
2228 {
2229         int retval = ZFCP_ERP_SUCCEEDED;
2230         int temp_ret;
2231         struct zfcp_adapter *adapter = erp_action->adapter;
2232         int i;
2233
2234         adapter->status_read_failed = 0;
2235         for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) {
2236                 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL);
2237                 if (temp_ret < 0) {
2238                         ZFCP_LOG_INFO("error: set-up of unsolicited status "
2239                                       "notification failed on adapter %s\n",
2240                                       zfcp_get_busid_by_adapter(adapter));
2241                         retval = ZFCP_ERP_FAILED;
2242                         i--;
2243                         break;
2244                 }
2245         }
2246
2247         return retval;
2248 }
2249
2250 /*
2251  * function:
2252  *
2253  * purpose:     this routine executes the 'Reopen Physical Port' action
2254  *
2255  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2256  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2257  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2258  */
2259 static int
2260 zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
2261 {
2262         int retval = ZFCP_ERP_FAILED;
2263         struct zfcp_port *port = erp_action->port;
2264         struct zfcp_adapter *adapter = erp_action->adapter;
2265
2266         switch (erp_action->step) {
2267
2268                 /*
2269                  * FIXME:
2270                  * the ULP spec. begs for waiting for oustanding commands
2271                  */
2272         case ZFCP_ERP_STEP_UNINITIALIZED:
2273                 zfcp_erp_port_strategy_clearstati(port);
2274                 /*
2275                  * it would be sufficient to test only the normal open flag
2276                  * since the phys. open flag cannot be set if the normal
2277                  * open flag is unset - however, this is for readabilty ...
2278                  */
2279                 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
2280                                       ZFCP_STATUS_COMMON_OPEN),
2281                                      &port->status)) {
2282                         ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2283                                        "close physical\n", port->wwpn);
2284                         retval =
2285                             zfcp_erp_port_forced_strategy_close(erp_action);
2286                 } else
2287                         retval = ZFCP_ERP_FAILED;
2288                 break;
2289
2290         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2291                 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
2292                                      &port->status)) {
2293                         ZFCP_LOG_DEBUG("close physical failed for port "
2294                                        "0x%016Lx\n", port->wwpn);
2295                         retval = ZFCP_ERP_FAILED;
2296                 } else
2297                         retval = ZFCP_ERP_SUCCEEDED;
2298                 break;
2299         }
2300
2301         debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret");
2302         debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2303         debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2304         debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2305
2306         return retval;
2307 }
2308
2309 /*
2310  * function:
2311  *
2312  * purpose:     this routine executes the 'Reopen Port' action
2313  *
2314  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2315  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2316  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2317  */
2318 static int
2319 zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
2320 {
2321         int retval = ZFCP_ERP_FAILED;
2322         struct zfcp_port *port = erp_action->port;
2323         struct zfcp_adapter *adapter = erp_action->adapter;
2324
2325         switch (erp_action->step) {
2326
2327                 /*
2328                  * FIXME:
2329                  * the ULP spec. begs for waiting for oustanding commands
2330                  */
2331         case ZFCP_ERP_STEP_UNINITIALIZED:
2332                 zfcp_erp_port_strategy_clearstati(port);
2333                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2334                         ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2335                                        "close\n", port->wwpn);
2336                         retval = zfcp_erp_port_strategy_close(erp_action);
2337                         goto out;
2338                 }               /* else it's already closed, open it */
2339                 break;
2340
2341         case ZFCP_ERP_STEP_PORT_CLOSING:
2342                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2343                         ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
2344                                        port->wwpn);
2345                         retval = ZFCP_ERP_FAILED;
2346                         goto out;
2347                 }               /* else it's closed now, open it */
2348                 break;
2349         }
2350         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2351                 retval = ZFCP_ERP_EXIT;
2352         else
2353                 retval = zfcp_erp_port_strategy_open(erp_action);
2354
2355  out:
2356         debug_text_event(adapter->erp_dbf, 3, "p_pst/ret");
2357         debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2358         debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2359         debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2360
2361         return retval;
2362 }
2363
2364 static int
2365 zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
2366 {
2367         int retval;
2368
2369         if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2370                              &erp_action->port->status))
2371                 retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
2372         else
2373                 retval = zfcp_erp_port_strategy_open_common(erp_action);
2374
2375         return retval;
2376 }
2377
2378 static int
2379 zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
2380 {
2381         int retval = 0;
2382         struct zfcp_adapter *adapter = erp_action->adapter;
2383         struct zfcp_port *port = erp_action->port;
2384
2385         switch (erp_action->step) {
2386
2387         case ZFCP_ERP_STEP_UNINITIALIZED:
2388         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2389         case ZFCP_ERP_STEP_PORT_CLOSING:
2390                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
2391                         if (port->wwpn != adapter->peer_wwpn) {
2392                                 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
2393                                                 "on adapter %s.\nPeer WWPN "
2394                                                 "0x%016Lx does not match\n",
2395                                                 port->wwpn,
2396                                                 zfcp_get_busid_by_adapter(adapter),
2397                                                 adapter->peer_wwpn);
2398                                 zfcp_erp_port_failed(port);
2399                                 retval = ZFCP_ERP_FAILED;
2400                                 break;
2401                         }
2402                         port->d_id = adapter->peer_d_id;
2403                         atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
2404                         retval = zfcp_erp_port_strategy_open_port(erp_action);
2405                         break;
2406                 }
2407                 if (!(adapter->nameserver_port)) {
2408                         retval = zfcp_nameserver_enqueue(adapter);
2409                         if (retval != 0) {
2410                                 ZFCP_LOG_NORMAL("error: nameserver port "
2411                                                 "unavailable for adapter %s\n",
2412                                                 zfcp_get_busid_by_adapter(adapter));
2413                                 retval = ZFCP_ERP_FAILED;
2414                                 break;
2415                         }
2416                 }
2417                 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
2418                                       &adapter->nameserver_port->status)) {
2419                         ZFCP_LOG_DEBUG("nameserver port is not open -> open "
2420                                        "nameserver port\n");
2421                         /* nameserver port may live again */
2422                         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
2423                                         &adapter->nameserver_port->status);
2424                         if (zfcp_erp_port_reopen(adapter->nameserver_port, 0)
2425                             >= 0) {
2426                                 erp_action->step =
2427                                         ZFCP_ERP_STEP_NAMESERVER_OPEN;
2428                                 retval = ZFCP_ERP_CONTINUES;
2429                         } else
2430                                 retval = ZFCP_ERP_FAILED;
2431                         break;
2432                 }
2433                 /* else nameserver port is already open, fall through */
2434         case ZFCP_ERP_STEP_NAMESERVER_OPEN:
2435                 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
2436                                       &adapter->nameserver_port->status)) {
2437                         ZFCP_LOG_DEBUG("open failed for nameserver port\n");
2438                         retval = ZFCP_ERP_FAILED;
2439                 } else {
2440                         ZFCP_LOG_DEBUG("nameserver port is open -> "
2441                                        "nameserver look-up for port 0x%016Lx\n",
2442                                        port->wwpn);
2443                         retval = zfcp_erp_port_strategy_open_common_lookup
2444                                 (erp_action);
2445                 }
2446                 break;
2447
2448         case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
2449                 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
2450                         if (atomic_test_mask
2451                             (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
2452                                 ZFCP_LOG_DEBUG("nameserver look-up failed "
2453                                                "for port 0x%016Lx "
2454                                                "(misconfigured WWPN?)\n",
2455                                                port->wwpn);
2456                                 zfcp_erp_port_failed(port);
2457                                 retval = ZFCP_ERP_EXIT;
2458                         } else {
2459                                 ZFCP_LOG_DEBUG("nameserver look-up failed for "
2460                                                "port 0x%016Lx\n", port->wwpn);
2461                                 retval = ZFCP_ERP_FAILED;
2462                         }
2463                 } else {
2464                         ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> "
2465                                        "trying open\n", port->wwpn, port->d_id);
2466                         retval = zfcp_erp_port_strategy_open_port(erp_action);
2467                 }
2468                 break;
2469
2470         case ZFCP_ERP_STEP_PORT_OPENING:
2471                 /* D_ID might have changed during open */
2472                 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
2473                                       ZFCP_STATUS_PORT_DID_DID),
2474                                      &port->status)) {
2475                         ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
2476                         retval = ZFCP_ERP_SUCCEEDED;
2477                 } else {
2478                         ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
2479                                        port->wwpn);
2480                         retval = ZFCP_ERP_FAILED;
2481                 }
2482                 break;
2483
2484         default:
2485                 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2486                                 erp_action->step);
2487                 retval = ZFCP_ERP_FAILED;
2488         }
2489
2490         return retval;
2491 }
2492
2493 static int
2494 zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
2495 {
2496         int retval;
2497         struct zfcp_port *port = erp_action->port;
2498
2499         switch (erp_action->step) {
2500
2501         case ZFCP_ERP_STEP_UNINITIALIZED:
2502         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2503         case ZFCP_ERP_STEP_PORT_CLOSING:
2504                 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> trying open\n",
2505                                port->wwpn, port->d_id);
2506                 retval = zfcp_erp_port_strategy_open_port(erp_action);
2507                 break;
2508
2509         case ZFCP_ERP_STEP_PORT_OPENING:
2510                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2511                         ZFCP_LOG_DEBUG("WKA port is open\n");
2512                         retval = ZFCP_ERP_SUCCEEDED;
2513                 } else {
2514                         ZFCP_LOG_DEBUG("open failed for WKA port\n");
2515                         retval = ZFCP_ERP_FAILED;
2516                 }
2517                 /* this is needed anyway (dont care for retval of wakeup) */
2518                 ZFCP_LOG_DEBUG("continue other open port operations\n");
2519                 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
2520                 break;
2521
2522         default:
2523                 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2524                                 erp_action->step);
2525                 retval = ZFCP_ERP_FAILED;
2526         }
2527
2528         return retval;
2529 }
2530
2531 /*
2532  * function:
2533  *
2534  * purpose:     makes the erp thread continue with reopen (physical) port
2535  *              actions which have been paused until the name server port
2536  *              is opened (or failed)
2537  *
2538  * returns:     0       (a kind of void retval, its not used)
2539  */
2540 static int
2541 zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
2542                                               *ns_erp_action)
2543 {
2544         int retval = 0;
2545         unsigned long flags;
2546         struct zfcp_adapter *adapter = ns_erp_action->adapter;
2547         struct zfcp_erp_action *erp_action, *tmp;
2548
2549         read_lock_irqsave(&adapter->erp_lock, flags);
2550         list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
2551                                  list) {
2552                 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n");
2553                 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn,
2554                             sizeof (wwn_t));
2555                 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
2556                         debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w");
2557                         debug_event(adapter->erp_dbf, 3,
2558                                     &erp_action->port->wwpn, sizeof (wwn_t));
2559                         if (atomic_test_mask(
2560                                     ZFCP_STATUS_COMMON_ERP_FAILED,
2561                                     &adapter->nameserver_port->status))
2562                                 zfcp_erp_port_failed(erp_action->port);
2563                         zfcp_erp_action_ready(erp_action);
2564                 }
2565         }
2566         read_unlock_irqrestore(&adapter->erp_lock, flags);
2567
2568         return retval;
2569 }
2570
2571 /*
2572  * function:
2573  *
2574  * purpose:
2575  *
2576  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2577  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2578  */
2579 static int
2580 zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
2581 {
2582         int retval;
2583         struct zfcp_adapter *adapter = erp_action->adapter;
2584         struct zfcp_port *port = erp_action->port;
2585
2586         retval = zfcp_fsf_close_physical_port(erp_action);
2587         if (retval == -ENOMEM) {
2588                 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
2589                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2590                 retval = ZFCP_ERP_NOMEM;
2591                 goto out;
2592         }
2593         erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
2594         if (retval != 0) {
2595                 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf");
2596                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2597                 /* could not send 'open', fail */
2598                 retval = ZFCP_ERP_FAILED;
2599                 goto out;
2600         }
2601         debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok");
2602         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2603         retval = ZFCP_ERP_CONTINUES;
2604  out:
2605         return retval;
2606 }
2607
2608 static int
2609 zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
2610 {
2611         int retval = 0;
2612         struct zfcp_adapter *adapter = port->adapter;
2613
2614         debug_text_event(adapter->erp_dbf, 5, "p_pstclst");
2615         debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2616
2617         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2618                           ZFCP_STATUS_COMMON_CLOSING |
2619                           ZFCP_STATUS_COMMON_ACCESS_DENIED |
2620                           ZFCP_STATUS_PORT_DID_DID |
2621                           ZFCP_STATUS_PORT_PHYS_CLOSING |
2622                           ZFCP_STATUS_PORT_INVALID_WWPN,
2623                           &port->status);
2624         return retval;
2625 }
2626
2627 /*
2628  * function:
2629  *
2630  * purpose:
2631  *
2632  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2633  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2634  */
2635 static int
2636 zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
2637 {
2638         int retval;
2639         struct zfcp_adapter *adapter = erp_action->adapter;
2640         struct zfcp_port *port = erp_action->port;
2641
2642         retval = zfcp_fsf_close_port(erp_action);
2643         if (retval == -ENOMEM) {
2644                 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
2645                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2646                 retval = ZFCP_ERP_NOMEM;
2647                 goto out;
2648         }
2649         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
2650         if (retval != 0) {
2651                 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf");
2652                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2653                 /* could not send 'close', fail */
2654                 retval = ZFCP_ERP_FAILED;
2655                 goto out;
2656         }
2657         debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok");
2658         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2659         retval = ZFCP_ERP_CONTINUES;
2660  out:
2661         return retval;
2662 }
2663
2664 /*
2665  * function:
2666  *
2667  * purpose:
2668  *
2669  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2670  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2671  */
2672 static int
2673 zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
2674 {
2675         int retval;
2676         struct zfcp_adapter *adapter = erp_action->adapter;
2677         struct zfcp_port *port = erp_action->port;
2678
2679         retval = zfcp_fsf_open_port(erp_action);
2680         if (retval == -ENOMEM) {
2681                 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
2682                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2683                 retval = ZFCP_ERP_NOMEM;
2684                 goto out;
2685         }
2686         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
2687         if (retval != 0) {
2688                 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf");
2689                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2690                 /* could not send 'open', fail */
2691                 retval = ZFCP_ERP_FAILED;
2692                 goto out;
2693         }
2694         debug_text_event(adapter->erp_dbf, 6, "p_psto_opok");
2695         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2696         retval = ZFCP_ERP_CONTINUES;
2697  out:
2698         return retval;
2699 }
2700
2701 /*
2702  * function:
2703  *
2704  * purpose:
2705  *
2706  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2707  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2708  */
2709 static int
2710 zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
2711 {
2712         int retval;
2713         struct zfcp_adapter *adapter = erp_action->adapter;
2714         struct zfcp_port *port = erp_action->port;
2715
2716         retval = zfcp_ns_gid_pn_request(erp_action);
2717         if (retval == -ENOMEM) {
2718                 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
2719                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2720                 retval = ZFCP_ERP_NOMEM;
2721                 goto out;
2722         }
2723         erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
2724         if (retval != 0) {
2725                 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref");
2726                 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2727                 /* could not send nameserver request, fail */
2728                 retval = ZFCP_ERP_FAILED;
2729                 goto out;
2730         }
2731         debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok");
2732         debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2733         retval = ZFCP_ERP_CONTINUES;
2734  out:
2735         return retval;
2736 }
2737
2738 /*
2739  * function:
2740  *
2741  * purpose:     this routine executes the 'Reopen Unit' action
2742  *              currently no retries
2743  *
2744  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2745  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2746  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2747  */
2748 static int
2749 zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
2750 {
2751         int retval = ZFCP_ERP_FAILED;
2752         struct zfcp_unit *unit = erp_action->unit;
2753         struct zfcp_adapter *adapter = erp_action->adapter;
2754
2755         switch (erp_action->step) {
2756
2757                 /*
2758                  * FIXME:
2759                  * the ULP spec. begs for waiting for oustanding commands
2760                  */
2761         case ZFCP_ERP_STEP_UNINITIALIZED:
2762                 zfcp_erp_unit_strategy_clearstati(unit);
2763                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2764                         ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
2765                                        "trying close\n", unit->fcp_lun);
2766                         retval = zfcp_erp_unit_strategy_close(erp_action);
2767                         break;
2768                 }
2769                 /* else it's already closed, fall through */
2770         case ZFCP_ERP_STEP_UNIT_CLOSING:
2771                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2772                         ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
2773                                        unit->fcp_lun);
2774                         retval = ZFCP_ERP_FAILED;
2775                 } else {
2776                         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2777                                 retval = ZFCP_ERP_EXIT;
2778                         else {
2779                                 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
2780                                                "trying open\n", unit->fcp_lun);
2781                                 retval =
2782                                     zfcp_erp_unit_strategy_open(erp_action);
2783                         }
2784                 }
2785                 break;
2786
2787         case ZFCP_ERP_STEP_UNIT_OPENING:
2788                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2789                         ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
2790                                        unit->fcp_lun);
2791                         retval = ZFCP_ERP_SUCCEEDED;
2792                 } else {
2793                         ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
2794                                        unit->fcp_lun);
2795                         retval = ZFCP_ERP_FAILED;
2796                 }
2797                 break;
2798         }
2799
2800         debug_text_event(adapter->erp_dbf, 3, "u_ust/ret");
2801         debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t));
2802         debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2803         debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2804         return retval;
2805 }
2806
2807 static int
2808 zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
2809 {
2810         int retval = 0;
2811         struct zfcp_adapter *adapter = unit->port->adapter;
2812
2813         debug_text_event(adapter->erp_dbf, 5, "u_ustclst");
2814         debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
2815
2816         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2817                           ZFCP_STATUS_COMMON_CLOSING |
2818                           ZFCP_STATUS_COMMON_ACCESS_DENIED |
2819                           ZFCP_STATUS_UNIT_SHARED |
2820                           ZFCP_STATUS_UNIT_READONLY,
2821                           &unit->status);
2822
2823         return retval;
2824 }
2825
2826 /*
2827  * function:
2828  *
2829  * purpose:
2830  *
2831  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2832  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2833  */
2834 static int
2835 zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
2836 {
2837         int retval;
2838         struct zfcp_adapter *adapter = erp_action->adapter;
2839         struct zfcp_unit *unit = erp_action->unit;
2840
2841         retval = zfcp_fsf_close_unit(erp_action);
2842         if (retval == -ENOMEM) {
2843                 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
2844                 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2845                             sizeof (fcp_lun_t));
2846                 retval = ZFCP_ERP_NOMEM;
2847                 goto out;
2848         }
2849         erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
2850         if (retval != 0) {
2851                 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf");
2852                 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2853                             sizeof (fcp_lun_t));
2854                 /* could not send 'close', fail */
2855                 retval = ZFCP_ERP_FAILED;
2856                 goto out;
2857         }
2858         debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok");
2859         debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2860         retval = ZFCP_ERP_CONTINUES;
2861
2862  out:
2863         return retval;
2864 }
2865
2866 /*
2867  * function:
2868  *
2869  * purpose:
2870  *
2871  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2872  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2873  */
2874 static int
2875 zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
2876 {
2877         int retval;
2878         struct zfcp_adapter *adapter = erp_action->adapter;
2879         struct zfcp_unit *unit = erp_action->unit;
2880
2881         retval = zfcp_fsf_open_unit(erp_action);
2882         if (retval == -ENOMEM) {
2883                 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
2884                 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2885                             sizeof (fcp_lun_t));
2886                 retval = ZFCP_ERP_NOMEM;
2887                 goto out;
2888         }
2889         erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
2890         if (retval != 0) {
2891                 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf");
2892                 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2893                             sizeof (fcp_lun_t));
2894                 /* could not send 'open', fail */
2895                 retval = ZFCP_ERP_FAILED;
2896                 goto out;
2897         }
2898         debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok");
2899         debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2900         retval = ZFCP_ERP_CONTINUES;
2901  out:
2902         return retval;
2903 }
2904
2905 void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)
2906 {
2907         BUG_ON(!fsf_req->erp_action);
2908         fsf_req->timer.function = zfcp_erp_timeout_handler;
2909         fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
2910         fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;
2911         add_timer(&fsf_req->timer);
2912 }
2913
2914 /*
2915  * function:
2916  *
2917  * purpose:     enqueue the specified error recovery action, if needed
2918  *
2919  * returns:
2920  */
2921 static int
2922 zfcp_erp_action_enqueue(int action,
2923                         struct zfcp_adapter *adapter,
2924                         struct zfcp_port *port, struct zfcp_unit *unit)
2925 {
2926         int retval = 1;
2927         struct zfcp_erp_action *erp_action = NULL;
2928         int stronger_action = 0;
2929         u32 status = 0;
2930
2931         /*
2932          * We need some rules here which check whether we really need
2933          * this action or whether we should just drop it.
2934          * E.g. if there is a unfinished 'Reopen Port' request then we drop a
2935          * 'Reopen Unit' request for an associated unit since we can't
2936          * satisfy this request now. A 'Reopen Port' action will trigger
2937          * 'Reopen Unit' actions when it completes.
2938          * Thus, there are only actions in the queue which can immediately be
2939          * executed. This makes the processing of the action queue more
2940          * efficient.
2941          */
2942
2943         if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
2944                               &adapter->status))
2945                 return -EIO;
2946
2947         debug_event(adapter->erp_dbf, 4, &action, sizeof (int));
2948         /* check whether we really need this */
2949         switch (action) {
2950         case ZFCP_ERP_ACTION_REOPEN_UNIT:
2951                 if (atomic_test_mask
2952                     (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
2953                         debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp");
2954                         debug_event(adapter->erp_dbf, 4, &port->wwpn,
2955                                     sizeof (wwn_t));
2956                         debug_event(adapter->erp_dbf, 4, &unit->fcp_lun,
2957                                     sizeof (fcp_lun_t));
2958                         goto out;
2959                 }
2960                 if (!atomic_test_mask
2961                     (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
2962                     atomic_test_mask
2963                     (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
2964                         goto out;
2965                 }
2966                 if (!atomic_test_mask
2967                     (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) {
2968                         stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT;
2969                         unit = NULL;
2970                 }
2971                 /* fall through !!! */
2972
2973         case ZFCP_ERP_ACTION_REOPEN_PORT:
2974                 if (atomic_test_mask
2975                     (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
2976                         debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp");
2977                         debug_event(adapter->erp_dbf, 4, &port->wwpn,
2978                                     sizeof (wwn_t));
2979                         goto out;
2980                 }
2981                 /* fall through !!! */
2982
2983         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
2984                 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2985                                      &port->status)) {
2986                         if (port->erp_action.action !=
2987                             ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
2988                                 ZFCP_LOG_INFO("dropped erp action %i (port "
2989                                               "0x%016Lx, action in use: %i)\n",
2990                                               action, port->wwpn,
2991                                               port->erp_action.action);
2992                                 debug_text_event(adapter->erp_dbf, 4,
2993                                                  "pf_actenq_drp");
2994                         } else
2995                                 debug_text_event(adapter->erp_dbf, 4,
2996                                                  "pf_actenq_drpcp");
2997                         debug_event(adapter->erp_dbf, 4, &port->wwpn,
2998                                     sizeof (wwn_t));
2999                         goto out;
3000                 }
3001                 if (!atomic_test_mask
3002                     (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
3003                     atomic_test_mask
3004                     (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
3005                         goto out;
3006                 }
3007                 if (!atomic_test_mask
3008                     (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) {
3009                         stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
3010                         port = NULL;
3011                 }
3012                 /* fall through !!! */
3013
3014         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3015                 if (atomic_test_mask
3016                     (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
3017                         debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp");
3018                         goto out;
3019                 }
3020                 break;
3021
3022         default:
3023                 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug");
3024                 debug_event(adapter->erp_dbf, 1, &action, sizeof (int));
3025                 ZFCP_LOG_NORMAL("bug: unknown erp action requested "
3026                                 "on adapter %s (action=%d)\n",
3027                                 zfcp_get_busid_by_adapter(adapter), action);
3028                 goto out;
3029         }
3030
3031         /* check whether we need something stronger first */
3032         if (stronger_action) {
3033                 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str");
3034                 debug_event(adapter->erp_dbf, 4, &stronger_action,
3035                             sizeof (int));
3036                 ZFCP_LOG_DEBUG("stronger erp action %d needed before "
3037                                "erp action %d on adapter %s\n",
3038                                stronger_action, action,
3039                                zfcp_get_busid_by_adapter(adapter));
3040                 action = stronger_action;
3041         }
3042
3043         /* mark adapter to have some error recovery pending */
3044         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
3045
3046         /* setup error recovery action */
3047         switch (action) {
3048
3049         case ZFCP_ERP_ACTION_REOPEN_UNIT:
3050                 zfcp_unit_get(unit);
3051                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
3052                 erp_action = &unit->erp_action;
3053                 if (!atomic_test_mask
3054                     (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
3055                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3056                 break;
3057
3058         case ZFCP_ERP_ACTION_REOPEN_PORT:
3059         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3060                 zfcp_port_get(port);
3061                 zfcp_erp_action_dismiss_port(port);
3062                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
3063                 erp_action = &port->erp_action;
3064                 if (!atomic_test_mask
3065                     (ZFCP_STATUS_COMMON_RUNNING, &port->status))
3066                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3067                 break;
3068
3069         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3070                 zfcp_adapter_get(adapter);
3071                 zfcp_erp_action_dismiss_adapter(adapter);
3072                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
3073                 erp_action = &adapter->erp_action;
3074                 if (!atomic_test_mask
3075                     (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
3076                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3077                 break;
3078         }
3079
3080         debug_text_event(adapter->erp_dbf, 4, "a_actenq");
3081
3082         memset(erp_action, 0, sizeof (struct zfcp_erp_action));
3083         erp_action->adapter = adapter;
3084         erp_action->port = port;
3085         erp_action->unit = unit;
3086         erp_action->action = action;
3087         erp_action->status = status;
3088
3089         ++adapter->erp_total_count;
3090
3091         /* finally put it into 'ready' queue and kick erp thread */
3092         list_add_tail(&erp_action->list, &adapter->erp_ready_head);
3093         up(&adapter->erp_ready_sem);
3094         retval = 0;
3095  out:
3096         return retval;
3097 }
3098
3099 static int
3100 zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
3101 {
3102         int retval = 0;
3103         struct zfcp_adapter *adapter = erp_action->adapter;
3104
3105         --adapter->erp_total_count;
3106         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
3107                 --adapter->erp_low_mem_count;
3108                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
3109         }
3110
3111         debug_text_event(adapter->erp_dbf, 4, "a_actdeq");
3112         debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
3113         list_del(&erp_action->list);
3114         switch (erp_action->action) {
3115         case ZFCP_ERP_ACTION_REOPEN_UNIT:
3116                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3117                                   &erp_action->unit->status);
3118                 break;
3119         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3120         case ZFCP_ERP_ACTION_REOPEN_PORT:
3121                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3122                                   &erp_action->port->status);
3123                 break;
3124         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3125                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3126                                   &erp_action->adapter->status);
3127                 break;
3128         default:
3129                 /* bug */
3130                 break;
3131         }
3132         return retval;
3133 }
3134
3135 /**
3136  * zfcp_erp_action_cleanup
3137  *
3138  * Register unit with scsi stack if appropriate and fix reference counts.
3139  * Note: Temporary units are not registered with scsi stack.
3140  */
3141 static void
3142 zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
3143                         struct zfcp_port *port, struct zfcp_unit *unit,
3144                         int result)
3145 {
3146         switch (action) {
3147         case ZFCP_ERP_ACTION_REOPEN_UNIT:
3148                 if ((result == ZFCP_ERP_SUCCEEDED)
3149                     && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
3150                                           &unit->status))
3151                     && !unit->device
3152                     && port->rport) {
3153                         atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
3154                                         &unit->status);
3155                         if (atomic_test_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING,
3156                                              &unit->status) == 0)
3157                                 zfcp_erp_schedule_work(unit);
3158                 }
3159                 zfcp_unit_put(unit);
3160                 break;
3161         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3162         case ZFCP_ERP_ACTION_REOPEN_PORT:
3163                 if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN,
3164                                      &port->status)) {
3165                         zfcp_port_put(port);
3166                         break;
3167                 }
3168
3169                 if ((result == ZFCP_ERP_SUCCEEDED)
3170                     && !port->rport) {
3171                         struct fc_rport_identifiers ids;
3172                         ids.node_name = port->wwnn;
3173                         ids.port_name = port->wwpn;
3174                         ids.port_id = port->d_id;
3175                         ids.roles = FC_RPORT_ROLE_FCP_TARGET;
3176                         port->rport =
3177                                 fc_remote_port_add(adapter->scsi_host, 0, &ids);
3178                         if (!port->rport)
3179                                 ZFCP_LOG_NORMAL("failed registration of rport"
3180                                                 "(adapter %s, wwpn=0x%016Lx)\n",
3181                                                 zfcp_get_busid_by_port(port),
3182                                                 port->wwpn);
3183                         else {
3184                                 scsi_target_unblock(&port->rport->dev);
3185                                 port->rport->maxframe_size = port->maxframe_size;
3186                                 port->rport->supported_classes =
3187                                         port->supported_classes;
3188                         }
3189                 }
3190                 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
3191                         fc_remote_port_delete(port->rport);
3192                         port->rport = NULL;
3193                 }
3194                 zfcp_port_put(port);
3195                 break;
3196         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3197                 if (result != ZFCP_ERP_SUCCEEDED) {
3198                         list_for_each_entry(port, &adapter->port_list_head, list)
3199                                 if (port->rport &&
3200                                     !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
3201                                                       &port->status)) {
3202                                         fc_remote_port_delete(port->rport);
3203                                         port->rport = NULL;
3204                                 }
3205                 }
3206                 zfcp_adapter_put(adapter);
3207                 break;
3208         default:
3209                 break;
3210         }
3211 }
3212
3213
3214 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
3215 {
3216         struct zfcp_port *port;
3217
3218         debug_text_event(adapter->erp_dbf, 5, "a_actab");
3219         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
3220                 zfcp_erp_action_dismiss(&adapter->erp_action);
3221         else
3222                 list_for_each_entry(port, &adapter->port_list_head, list)
3223                     zfcp_erp_action_dismiss_port(port);
3224 }
3225
3226 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
3227 {
3228         struct zfcp_unit *unit;
3229         struct zfcp_adapter *adapter = port->adapter;
3230
3231         debug_text_event(adapter->erp_dbf, 5, "p_actab");
3232         debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
3233         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
3234                 zfcp_erp_action_dismiss(&port->erp_action);
3235         else
3236                 list_for_each_entry(unit, &port->unit_list_head, list)
3237                     zfcp_erp_action_dismiss_unit(unit);
3238 }
3239
3240 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
3241 {
3242         struct zfcp_adapter *adapter = unit->port->adapter;
3243
3244         debug_text_event(adapter->erp_dbf, 5, "u_actab");
3245         debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
3246         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
3247                 zfcp_erp_action_dismiss(&unit->erp_action);
3248 }
3249
3250 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
3251 {
3252         struct zfcp_adapter *adapter = erp_action->adapter;
3253
3254         debug_text_event(adapter->erp_dbf, 6, "a_toru");
3255         debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3256         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
3257 }
3258
3259 static void zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
3260 {
3261         struct zfcp_adapter *adapter = erp_action->adapter;
3262
3263         debug_text_event(adapter->erp_dbf, 6, "a_tore");
3264         debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3265         list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
3266 }
3267
3268 void
3269 zfcp_erp_port_boxed(struct zfcp_port *port)
3270 {
3271         struct zfcp_adapter *adapter = port->adapter;
3272         unsigned long flags;
3273
3274         debug_text_event(adapter->erp_dbf, 3, "p_access_boxed");
3275         debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3276         read_lock_irqsave(&zfcp_data.config_lock, flags);
3277         zfcp_erp_modify_port_status(port,
3278                         ZFCP_STATUS_COMMON_ACCESS_BOXED,
3279                         ZFCP_SET);
3280         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3281         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED);
3282 }
3283
3284 void
3285 zfcp_erp_unit_boxed(struct zfcp_unit *unit)
3286 {
3287         struct zfcp_adapter *adapter = unit->port->adapter;
3288
3289         debug_text_event(adapter->erp_dbf, 3, "u_access_boxed");
3290         debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3291         zfcp_erp_modify_unit_status(unit,
3292                         ZFCP_STATUS_COMMON_ACCESS_BOXED,
3293                         ZFCP_SET);
3294         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
3295 }
3296
3297 void
3298 zfcp_erp_port_access_denied(struct zfcp_port *port)
3299 {
3300         struct zfcp_adapter *adapter = port->adapter;
3301         unsigned long flags;
3302
3303         debug_text_event(adapter->erp_dbf, 3, "p_access_denied");
3304         debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3305         read_lock_irqsave(&zfcp_data.config_lock, flags);
3306         zfcp_erp_modify_port_status(port,
3307                         ZFCP_STATUS_COMMON_ERP_FAILED |
3308                         ZFCP_STATUS_COMMON_ACCESS_DENIED,
3309                         ZFCP_SET);
3310         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3311 }
3312
3313 void
3314 zfcp_erp_unit_access_denied(struct zfcp_unit *unit)
3315 {
3316         struct zfcp_adapter *adapter = unit->port->adapter;
3317
3318         debug_text_event(adapter->erp_dbf, 3, "u_access_denied");
3319         debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3320         zfcp_erp_modify_unit_status(unit,
3321                         ZFCP_STATUS_COMMON_ERP_FAILED |
3322                         ZFCP_STATUS_COMMON_ACCESS_DENIED,
3323                         ZFCP_SET);
3324 }
3325
3326 void
3327 zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter)
3328 {
3329         struct zfcp_port *port;
3330         unsigned long flags;
3331
3332         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
3333                 return;
3334
3335         debug_text_event(adapter->erp_dbf, 3, "a_access_recover");
3336         debug_event(adapter->erp_dbf, 3, zfcp_get_busid_by_adapter(adapter), 8);
3337
3338         read_lock_irqsave(&zfcp_data.config_lock, flags);
3339         if (adapter->nameserver_port)
3340                 zfcp_erp_port_access_changed(adapter->nameserver_port);
3341         list_for_each_entry(port, &adapter->port_list_head, list)
3342                 if (port != adapter->nameserver_port)
3343                         zfcp_erp_port_access_changed(port);
3344         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3345 }
3346
3347 void
3348 zfcp_erp_port_access_changed(struct zfcp_port *port)
3349 {
3350         struct zfcp_adapter *adapter = port->adapter;
3351         struct zfcp_unit *unit;
3352
3353         debug_text_event(adapter->erp_dbf, 3, "p_access_recover");
3354         debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3355
3356         if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3357                               &port->status) &&
3358             !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3359                               &port->status)) {
3360                 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
3361                         list_for_each_entry(unit, &port->unit_list_head, list)
3362                                 zfcp_erp_unit_access_changed(unit);
3363                 return;
3364         }
3365
3366         ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
3367                         "(due to ACT update)\n",
3368                         port->wwpn, zfcp_get_busid_by_adapter(adapter));
3369         if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3370                 ZFCP_LOG_NORMAL("failed reopen of port"
3371                                 "(adapter %s, wwpn=0x%016Lx)\n",
3372                                 zfcp_get_busid_by_adapter(adapter), port->wwpn);
3373 }
3374
3375 void
3376 zfcp_erp_unit_access_changed(struct zfcp_unit *unit)
3377 {
3378         struct zfcp_adapter *adapter = unit->port->adapter;
3379
3380         debug_text_event(adapter->erp_dbf, 3, "u_access_recover");
3381         debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3382
3383         if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3384                               &unit->status) &&
3385             !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3386                               &unit->status))
3387                 return;
3388
3389         ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
3390                         " on adapter %s (due to ACT update)\n",
3391                         unit->fcp_lun, unit->port->wwpn,
3392                         zfcp_get_busid_by_adapter(adapter));
3393         if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3394                 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
3395                                 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
3396                                 zfcp_get_busid_by_adapter(adapter),
3397                                 unit->port->wwpn, unit->fcp_lun);
3398 }
3399
3400 #undef ZFCP_LOG_AREA