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

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