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