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);
 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_lock(2, adapter);
 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_lock(4, adapter);
1054                 down_interruptible(&adapter->erp_ready_sem);
1055                 zfcp_rec_dbf_event_thread_lock(5, adapter);
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_lock(6, adapter);
2066                 down(&adapter->erp_ready_sem);
2067                 zfcp_rec_dbf_event_thread_lock(7, adapter);
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_lock(8, adapter);
2122         down(&adapter->erp_ready_sem);
2123         zfcp_rec_dbf_event_thread_lock(9, adapter);
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         struct zfcp_adapter *adapter = erp_action->adapter;
2143
2144         atomic_set(&adapter->stat_miss, 16);
2145         return zfcp_status_read_refill(adapter);
2146 }
2147
2148 /*
2149  * function:
2150  *
2151  * purpose:     this routine executes the 'Reopen Physical Port' action
2152  *
2153  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2154  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2155  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2156  */
2157 static int
2158 zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
2159 {
2160         int retval = ZFCP_ERP_FAILED;
2161         struct zfcp_port *port = erp_action->port;
2162
2163         switch (erp_action->step) {
2164
2165                 /*
2166                  * FIXME:
2167                  * the ULP spec. begs for waiting for oustanding commands
2168                  */
2169         case ZFCP_ERP_STEP_UNINITIALIZED:
2170                 zfcp_erp_port_strategy_clearstati(port);
2171                 /*
2172                  * it would be sufficient to test only the normal open flag
2173                  * since the phys. open flag cannot be set if the normal
2174                  * open flag is unset - however, this is for readabilty ...
2175                  */
2176                 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
2177                                       ZFCP_STATUS_COMMON_OPEN),
2178                                      &port->status)) {
2179                         ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2180                                        "close physical\n", port->wwpn);
2181                         retval =
2182                             zfcp_erp_port_forced_strategy_close(erp_action);
2183                 } else
2184                         retval = ZFCP_ERP_FAILED;
2185                 break;
2186
2187         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2188                 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
2189                                      &port->status)) {
2190                         ZFCP_LOG_DEBUG("close physical failed for port "
2191                                        "0x%016Lx\n", port->wwpn);
2192                         retval = ZFCP_ERP_FAILED;
2193                 } else
2194                         retval = ZFCP_ERP_SUCCEEDED;
2195                 break;
2196         }
2197
2198         return retval;
2199 }
2200
2201 /*
2202  * function:
2203  *
2204  * purpose:     this routine executes the 'Reopen Port' action
2205  *
2206  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2207  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2208  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2209  */
2210 static int
2211 zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
2212 {
2213         int retval = ZFCP_ERP_FAILED;
2214         struct zfcp_port *port = erp_action->port;
2215
2216         switch (erp_action->step) {
2217
2218                 /*
2219                  * FIXME:
2220                  * the ULP spec. begs for waiting for oustanding commands
2221                  */
2222         case ZFCP_ERP_STEP_UNINITIALIZED:
2223                 zfcp_erp_port_strategy_clearstati(port);
2224                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2225                         ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2226                                        "close\n", port->wwpn);
2227                         retval = zfcp_erp_port_strategy_close(erp_action);
2228                         goto out;
2229                 }               /* else it's already closed, open it */
2230                 break;
2231
2232         case ZFCP_ERP_STEP_PORT_CLOSING:
2233                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2234                         ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
2235                                        port->wwpn);
2236                         retval = ZFCP_ERP_FAILED;
2237                         goto out;
2238                 }               /* else it's closed now, open it */
2239                 break;
2240         }
2241         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2242                 retval = ZFCP_ERP_EXIT;
2243         else
2244                 retval = zfcp_erp_port_strategy_open(erp_action);
2245
2246  out:
2247         return retval;
2248 }
2249
2250 static int
2251 zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
2252 {
2253         int retval;
2254
2255         if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2256                              &erp_action->port->status))
2257                 retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
2258         else
2259                 retval = zfcp_erp_port_strategy_open_common(erp_action);
2260
2261         return retval;
2262 }
2263
2264 static int
2265 zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
2266 {
2267         int retval = 0;
2268         struct zfcp_adapter *adapter = erp_action->adapter;
2269         struct zfcp_port *port = erp_action->port;
2270
2271         switch (erp_action->step) {
2272
2273         case ZFCP_ERP_STEP_UNINITIALIZED:
2274         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2275         case ZFCP_ERP_STEP_PORT_CLOSING:
2276                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
2277                         if (port->wwpn != adapter->peer_wwpn) {
2278                                 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
2279                                                 "on adapter %s.\nPeer WWPN "
2280                                                 "0x%016Lx does not match\n",
2281                                                 port->wwpn,
2282                                                 zfcp_get_busid_by_adapter(adapter),
2283                                                 adapter->peer_wwpn);
2284                                 zfcp_erp_port_failed(port, 25, NULL);
2285                                 retval = ZFCP_ERP_FAILED;
2286                                 break;
2287                         }
2288                         port->d_id = adapter->peer_d_id;
2289                         atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
2290                         retval = zfcp_erp_port_strategy_open_port(erp_action);
2291                         break;
2292                 }
2293                 if (!(adapter->nameserver_port)) {
2294                         retval = zfcp_nameserver_enqueue(adapter);
2295                         if (retval != 0) {
2296                                 ZFCP_LOG_NORMAL("error: nameserver port "
2297                                                 "unavailable for adapter %s\n",
2298                                                 zfcp_get_busid_by_adapter(adapter));
2299                                 retval = ZFCP_ERP_FAILED;
2300                                 break;
2301                         }
2302                 }
2303                 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
2304                                       &adapter->nameserver_port->status)) {
2305                         ZFCP_LOG_DEBUG("nameserver port is not open -> open "
2306                                        "nameserver port\n");
2307                         /* nameserver port may live again */
2308                         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
2309                                         &adapter->nameserver_port->status);
2310                         if (zfcp_erp_port_reopen(adapter->nameserver_port, 0,
2311                                                  77, erp_action) >= 0) {
2312                                 erp_action->step =
2313                                         ZFCP_ERP_STEP_NAMESERVER_OPEN;
2314                                 retval = ZFCP_ERP_CONTINUES;
2315                         } else
2316                                 retval = ZFCP_ERP_FAILED;
2317                         break;
2318                 }
2319                 /* else nameserver port is already open, fall through */
2320         case ZFCP_ERP_STEP_NAMESERVER_OPEN:
2321                 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
2322                                       &adapter->nameserver_port->status)) {
2323                         ZFCP_LOG_DEBUG("open failed for nameserver port\n");
2324                         retval = ZFCP_ERP_FAILED;
2325                 } else {
2326                         ZFCP_LOG_DEBUG("nameserver port is open -> "
2327                                        "nameserver look-up for port 0x%016Lx\n",
2328                                        port->wwpn);
2329                         retval = zfcp_erp_port_strategy_open_common_lookup
2330                                 (erp_action);
2331                 }
2332                 break;
2333
2334         case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
2335                 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
2336                         if (atomic_test_mask
2337                             (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
2338                                 ZFCP_LOG_DEBUG("nameserver look-up failed "
2339                                                "for port 0x%016Lx "
2340                                                "(misconfigured WWPN?)\n",
2341                                                port->wwpn);
2342                                 zfcp_erp_port_failed(port, 26, NULL);
2343                                 retval = ZFCP_ERP_EXIT;
2344                         } else {
2345                                 ZFCP_LOG_DEBUG("nameserver look-up failed for "
2346                                                "port 0x%016Lx\n", port->wwpn);
2347                                 retval = ZFCP_ERP_FAILED;
2348                         }
2349                 } else {
2350                         ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> "
2351                                        "trying open\n", port->wwpn, port->d_id);
2352                         retval = zfcp_erp_port_strategy_open_port(erp_action);
2353                 }
2354                 break;
2355
2356         case ZFCP_ERP_STEP_PORT_OPENING:
2357                 /* D_ID might have changed during open */
2358                 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
2359                                       ZFCP_STATUS_PORT_DID_DID),
2360                                      &port->status)) {
2361                         ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
2362                         retval = ZFCP_ERP_SUCCEEDED;
2363                 } else {
2364                         ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
2365                                        port->wwpn);
2366                         retval = ZFCP_ERP_FAILED;
2367                 }
2368                 break;
2369
2370         default:
2371                 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2372                                 erp_action->step);
2373                 retval = ZFCP_ERP_FAILED;
2374         }
2375
2376         return retval;
2377 }
2378
2379 static int
2380 zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
2381 {
2382         int retval;
2383         struct zfcp_port *port = erp_action->port;
2384
2385         switch (erp_action->step) {
2386
2387         case ZFCP_ERP_STEP_UNINITIALIZED:
2388         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2389         case ZFCP_ERP_STEP_PORT_CLOSING:
2390                 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%06x -> trying open\n",
2391                                port->wwpn, port->d_id);
2392                 retval = zfcp_erp_port_strategy_open_port(erp_action);
2393                 break;
2394
2395         case ZFCP_ERP_STEP_PORT_OPENING:
2396                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2397                         ZFCP_LOG_DEBUG("WKA port is open\n");
2398                         retval = ZFCP_ERP_SUCCEEDED;
2399                 } else {
2400                         ZFCP_LOG_DEBUG("open failed for WKA port\n");
2401                         retval = ZFCP_ERP_FAILED;
2402                 }
2403                 /* this is needed anyway (dont care for retval of wakeup) */
2404                 ZFCP_LOG_DEBUG("continue other open port operations\n");
2405                 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
2406                 break;
2407
2408         default:
2409                 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2410                                 erp_action->step);
2411                 retval = ZFCP_ERP_FAILED;
2412         }
2413
2414         return retval;
2415 }
2416
2417 /*
2418  * function:
2419  *
2420  * purpose:     makes the erp thread continue with reopen (physical) port
2421  *              actions which have been paused until the name server port
2422  *              is opened (or failed)
2423  *
2424  * returns:     0       (a kind of void retval, its not used)
2425  */
2426 static int
2427 zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
2428                                               *ns_erp_action)
2429 {
2430         int retval = 0;
2431         unsigned long flags;
2432         struct zfcp_adapter *adapter = ns_erp_action->adapter;
2433         struct zfcp_erp_action *erp_action, *tmp;
2434
2435         read_lock_irqsave(&adapter->erp_lock, flags);
2436         list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
2437                                  list) {
2438                 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
2439                         if (atomic_test_mask(
2440                                     ZFCP_STATUS_COMMON_ERP_FAILED,
2441                                     &adapter->nameserver_port->status))
2442                                 zfcp_erp_port_failed(erp_action->port, 27,
2443                                                      NULL);
2444                         zfcp_erp_action_ready(erp_action);
2445                 }
2446         }
2447         read_unlock_irqrestore(&adapter->erp_lock, flags);
2448
2449         return retval;
2450 }
2451
2452 /*
2453  * function:
2454  *
2455  * purpose:
2456  *
2457  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2458  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2459  */
2460 static int
2461 zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
2462 {
2463         int retval;
2464
2465         retval = zfcp_fsf_close_physical_port(erp_action);
2466         if (retval == -ENOMEM) {
2467                 retval = ZFCP_ERP_NOMEM;
2468                 goto out;
2469         }
2470         erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
2471         if (retval != 0) {
2472                 /* could not send 'open', fail */
2473                 retval = ZFCP_ERP_FAILED;
2474                 goto out;
2475         }
2476         retval = ZFCP_ERP_CONTINUES;
2477  out:
2478         return retval;
2479 }
2480
2481 static int
2482 zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
2483 {
2484         int retval = 0;
2485
2486         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2487                           ZFCP_STATUS_COMMON_CLOSING |
2488                           ZFCP_STATUS_COMMON_ACCESS_DENIED |
2489                           ZFCP_STATUS_PORT_DID_DID |
2490                           ZFCP_STATUS_PORT_PHYS_CLOSING |
2491                           ZFCP_STATUS_PORT_INVALID_WWPN,
2492                           &port->status);
2493         return retval;
2494 }
2495
2496 /*
2497  * function:
2498  *
2499  * purpose:
2500  *
2501  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2502  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2503  */
2504 static int
2505 zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
2506 {
2507         int retval;
2508
2509         retval = zfcp_fsf_close_port(erp_action);
2510         if (retval == -ENOMEM) {
2511                 retval = ZFCP_ERP_NOMEM;
2512                 goto out;
2513         }
2514         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
2515         if (retval != 0) {
2516                 /* could not send 'close', fail */
2517                 retval = ZFCP_ERP_FAILED;
2518                 goto out;
2519         }
2520         retval = ZFCP_ERP_CONTINUES;
2521  out:
2522         return retval;
2523 }
2524
2525 /*
2526  * function:
2527  *
2528  * purpose:
2529  *
2530  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2531  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2532  */
2533 static int
2534 zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
2535 {
2536         int retval;
2537
2538         retval = zfcp_fsf_open_port(erp_action);
2539         if (retval == -ENOMEM) {
2540                 retval = ZFCP_ERP_NOMEM;
2541                 goto out;
2542         }
2543         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
2544         if (retval != 0) {
2545                 /* could not send 'open', fail */
2546                 retval = ZFCP_ERP_FAILED;
2547                 goto out;
2548         }
2549         retval = ZFCP_ERP_CONTINUES;
2550  out:
2551         return retval;
2552 }
2553
2554 /*
2555  * function:
2556  *
2557  * purpose:
2558  *
2559  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2560  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2561  */
2562 static int
2563 zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
2564 {
2565         int retval;
2566
2567         retval = zfcp_ns_gid_pn_request(erp_action);
2568         if (retval == -ENOMEM) {
2569                 retval = ZFCP_ERP_NOMEM;
2570                 goto out;
2571         }
2572         erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
2573         if (retval != 0) {
2574                 /* could not send nameserver request, fail */
2575                 retval = ZFCP_ERP_FAILED;
2576                 goto out;
2577         }
2578         retval = ZFCP_ERP_CONTINUES;
2579  out:
2580         return retval;
2581 }
2582
2583 /*
2584  * function:
2585  *
2586  * purpose:     this routine executes the 'Reopen Unit' action
2587  *              currently no retries
2588  *
2589  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2590  *              ZFCP_ERP_SUCCEEDED      - action finished successfully
2591  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2592  */
2593 static int
2594 zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
2595 {
2596         int retval = ZFCP_ERP_FAILED;
2597         struct zfcp_unit *unit = erp_action->unit;
2598
2599         switch (erp_action->step) {
2600
2601                 /*
2602                  * FIXME:
2603                  * the ULP spec. begs for waiting for oustanding commands
2604                  */
2605         case ZFCP_ERP_STEP_UNINITIALIZED:
2606                 zfcp_erp_unit_strategy_clearstati(unit);
2607                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2608                         ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
2609                                        "trying close\n", unit->fcp_lun);
2610                         retval = zfcp_erp_unit_strategy_close(erp_action);
2611                         break;
2612                 }
2613                 /* else it's already closed, fall through */
2614         case ZFCP_ERP_STEP_UNIT_CLOSING:
2615                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2616                         ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
2617                                        unit->fcp_lun);
2618                         retval = ZFCP_ERP_FAILED;
2619                 } else {
2620                         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2621                                 retval = ZFCP_ERP_EXIT;
2622                         else {
2623                                 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
2624                                                "trying open\n", unit->fcp_lun);
2625                                 retval =
2626                                     zfcp_erp_unit_strategy_open(erp_action);
2627                         }
2628                 }
2629                 break;
2630
2631         case ZFCP_ERP_STEP_UNIT_OPENING:
2632                 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2633                         ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
2634                                        unit->fcp_lun);
2635                         retval = ZFCP_ERP_SUCCEEDED;
2636                 } else {
2637                         ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
2638                                        unit->fcp_lun);
2639                         retval = ZFCP_ERP_FAILED;
2640                 }
2641                 break;
2642         }
2643
2644         return retval;
2645 }
2646
2647 static int
2648 zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
2649 {
2650         int retval = 0;
2651
2652         atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2653                           ZFCP_STATUS_COMMON_CLOSING |
2654                           ZFCP_STATUS_COMMON_ACCESS_DENIED |
2655                           ZFCP_STATUS_UNIT_SHARED |
2656                           ZFCP_STATUS_UNIT_READONLY,
2657                           &unit->status);
2658
2659         return retval;
2660 }
2661
2662 /*
2663  * function:
2664  *
2665  * purpose:
2666  *
2667  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2668  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2669  */
2670 static int
2671 zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
2672 {
2673         int retval;
2674
2675         retval = zfcp_fsf_close_unit(erp_action);
2676         if (retval == -ENOMEM) {
2677                 retval = ZFCP_ERP_NOMEM;
2678                 goto out;
2679         }
2680         erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
2681         if (retval != 0) {
2682                 /* could not send 'close', fail */
2683                 retval = ZFCP_ERP_FAILED;
2684                 goto out;
2685         }
2686         retval = ZFCP_ERP_CONTINUES;
2687
2688  out:
2689         return retval;
2690 }
2691
2692 /*
2693  * function:
2694  *
2695  * purpose:
2696  *
2697  * returns:     ZFCP_ERP_CONTINUES      - action continues (asynchronously)
2698  *              ZFCP_ERP_FAILED         - action finished unsuccessfully
2699  */
2700 static int
2701 zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
2702 {
2703         int retval;
2704
2705         retval = zfcp_fsf_open_unit(erp_action);
2706         if (retval == -ENOMEM) {
2707                 retval = ZFCP_ERP_NOMEM;
2708                 goto out;
2709         }
2710         erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
2711         if (retval != 0) {
2712                 /* could not send 'open', fail */
2713                 retval = ZFCP_ERP_FAILED;
2714                 goto out;
2715         }
2716         retval = ZFCP_ERP_CONTINUES;
2717  out:
2718         return retval;
2719 }
2720
2721 void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)
2722 {
2723         BUG_ON(!fsf_req->erp_action);
2724         fsf_req->timer.function = zfcp_erp_timeout_handler;
2725         fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
2726         fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;
2727         add_timer(&fsf_req->timer);
2728 }
2729
2730 /*
2731  * function:
2732  *
2733  * purpose:     enqueue the specified error recovery action, if needed
2734  *
2735  * returns:
2736  */
2737 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
2738                                    struct zfcp_port *port,
2739                                    struct zfcp_unit *unit, u8 id, void *ref)
2740 {
2741         int retval = 1, need = want;
2742         struct zfcp_erp_action *erp_action = NULL;
2743         u32 status = 0;
2744
2745         /*
2746          * We need some rules here which check whether we really need
2747          * this action or whether we should just drop it.
2748          * E.g. if there is a unfinished 'Reopen Port' request then we drop a
2749          * 'Reopen Unit' request for an associated unit since we can't
2750          * satisfy this request now. A 'Reopen Port' action will trigger
2751          * 'Reopen Unit' actions when it completes.
2752          * Thus, there are only actions in the queue which can immediately be
2753          * executed. This makes the processing of the action queue more
2754          * efficient.
2755          */
2756
2757         if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
2758                               &adapter->status))
2759                 return -EIO;
2760
2761         /* check whether we really need this */
2762         switch (want) {
2763         case ZFCP_ERP_ACTION_REOPEN_UNIT:
2764                 if (atomic_test_mask
2765                     (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
2766                         goto out;
2767                 }
2768                 if (!atomic_test_mask
2769                     (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
2770                     atomic_test_mask
2771                     (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
2772                         goto out;
2773                 }
2774                 if (!atomic_test_mask
2775                     (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
2776                         need = ZFCP_ERP_ACTION_REOPEN_PORT;
2777                 /* fall through !!! */
2778
2779         case ZFCP_ERP_ACTION_REOPEN_PORT:
2780                 if (atomic_test_mask
2781                     (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
2782                         goto out;
2783                 }
2784                 /* fall through !!! */
2785
2786         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
2787                 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2788                                      &port->status)) {
2789                         if (port->erp_action.action !=
2790                             ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
2791                                 ZFCP_LOG_INFO("dropped erp action %i (port "
2792                                               "0x%016Lx, action in use: %i)\n",
2793                                               want, port->wwpn,
2794                                               port->erp_action.action);
2795                         }
2796                         goto out;
2797                 }
2798                 if (!atomic_test_mask
2799                     (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
2800                     atomic_test_mask
2801                     (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
2802                         goto out;
2803                 }
2804                 if (!atomic_test_mask
2805                     (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
2806                         need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
2807                 /* fall through !!! */
2808
2809         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
2810                 if (atomic_test_mask
2811                     (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
2812                         goto out;
2813                 }
2814                 break;
2815
2816         default:
2817                 ZFCP_LOG_NORMAL("bug: unknown erp action requested "
2818                                 "on adapter %s (action=%d)\n",
2819                                 zfcp_get_busid_by_adapter(adapter), want);
2820                 goto out;
2821         }
2822
2823         /* check whether we need something stronger first */
2824         if (need) {
2825                 ZFCP_LOG_DEBUG("stronger erp action %d needed before "
2826                                "erp action %d on adapter %s\n",
2827                                need, want, zfcp_get_busid_by_adapter(adapter));
2828         }
2829
2830         /* mark adapter to have some error recovery pending */
2831         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
2832
2833         /* setup error recovery action */
2834         switch (need) {
2835
2836         case ZFCP_ERP_ACTION_REOPEN_UNIT:
2837                 zfcp_unit_get(unit);
2838                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
2839                 erp_action = &unit->erp_action;
2840                 if (!atomic_test_mask
2841                     (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
2842                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
2843                 break;
2844
2845         case ZFCP_ERP_ACTION_REOPEN_PORT:
2846         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
2847                 zfcp_port_get(port);
2848                 zfcp_erp_action_dismiss_port(port);
2849                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
2850                 erp_action = &port->erp_action;
2851                 if (!atomic_test_mask
2852                     (ZFCP_STATUS_COMMON_RUNNING, &port->status))
2853                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
2854                 break;
2855
2856         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
2857                 zfcp_adapter_get(adapter);
2858                 zfcp_erp_action_dismiss_adapter(adapter);
2859                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
2860                 erp_action = &adapter->erp_action;
2861                 if (!atomic_test_mask
2862                     (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
2863                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
2864                 break;
2865         }
2866
2867         memset(erp_action, 0, sizeof (struct zfcp_erp_action));
2868         erp_action->adapter = adapter;
2869         erp_action->port = port;
2870         erp_action->unit = unit;
2871         erp_action->action = need;
2872         erp_action->status = status;
2873
2874         ++adapter->erp_total_count;
2875
2876         /* finally put it into 'ready' queue and kick erp thread */
2877         list_add_tail(&erp_action->list, &adapter->erp_ready_head);
2878         up(&adapter->erp_ready_sem);
2879         zfcp_rec_dbf_event_thread(1, adapter);
2880         retval = 0;
2881  out:
2882         zfcp_rec_dbf_event_trigger(id, ref, want, need, erp_action,
2883                                    adapter, port, unit);
2884         return retval;
2885 }
2886
2887 static int
2888 zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
2889 {
2890         int retval = 0;
2891         struct zfcp_adapter *adapter = erp_action->adapter;
2892
2893         --adapter->erp_total_count;
2894         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
2895                 --adapter->erp_low_mem_count;
2896                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
2897         }
2898
2899         list_del(&erp_action->list);
2900         zfcp_rec_dbf_event_action(144, erp_action);
2901
2902         switch (erp_action->action) {
2903         case ZFCP_ERP_ACTION_REOPEN_UNIT:
2904                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2905                                   &erp_action->unit->status);
2906                 break;
2907         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
2908         case ZFCP_ERP_ACTION_REOPEN_PORT:
2909                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2910                                   &erp_action->port->status);
2911                 break;
2912         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
2913                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
2914                                   &erp_action->adapter->status);
2915                 break;
2916         default:
2917                 /* bug */
2918                 break;
2919         }
2920         return retval;
2921 }
2922
2923 /**
2924  * zfcp_erp_action_cleanup
2925  *
2926  * Register unit with scsi stack if appropriate and fix reference counts.
2927  * Note: Temporary units are not registered with scsi stack.
2928  */
2929 static void
2930 zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
2931                         struct zfcp_port *port, struct zfcp_unit *unit,
2932                         int result)
2933 {
2934         switch (action) {
2935         case ZFCP_ERP_ACTION_REOPEN_UNIT:
2936                 if ((result == ZFCP_ERP_SUCCEEDED)
2937                     && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
2938                                           &unit->status))
2939                     && !unit->device
2940                     && port->rport) {
2941                         atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
2942                                         &unit->status);
2943                         if (atomic_test_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING,
2944                                              &unit->status) == 0)
2945                                 zfcp_erp_schedule_work(unit);
2946                 }
2947                 zfcp_unit_put(unit);
2948                 break;
2949         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
2950         case ZFCP_ERP_ACTION_REOPEN_PORT:
2951                 if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN,
2952                                      &port->status)) {
2953                         zfcp_port_put(port);
2954                         break;
2955                 }
2956
2957                 if ((result == ZFCP_ERP_SUCCEEDED)
2958                     && !port->rport) {
2959                         struct fc_rport_identifiers ids;
2960                         ids.node_name = port->wwnn;
2961                         ids.port_name = port->wwpn;
2962                         ids.port_id = port->d_id;
2963                         ids.roles = FC_RPORT_ROLE_FCP_TARGET;
2964                         port->rport =
2965                                 fc_remote_port_add(adapter->scsi_host, 0, &ids);
2966                         if (!port->rport)
2967                                 ZFCP_LOG_NORMAL("failed registration of rport"
2968                                                 "(adapter %s, wwpn=0x%016Lx)\n",
2969                                                 zfcp_get_busid_by_port(port),
2970                                                 port->wwpn);
2971                         else {
2972                                 scsi_target_unblock(&port->rport->dev);
2973                                 port->rport->maxframe_size = port->maxframe_size;
2974                                 port->rport->supported_classes =
2975                                         port->supported_classes;
2976                         }
2977                 }
2978                 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
2979                         fc_remote_port_delete(port->rport);
2980                         port->rport = NULL;
2981                 }
2982                 zfcp_port_put(port);
2983                 break;
2984         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
2985                 if (result != ZFCP_ERP_SUCCEEDED) {
2986                         list_for_each_entry(port, &adapter->port_list_head, list)
2987                                 if (port->rport &&
2988                                     !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2989                                                       &port->status)) {
2990                                         fc_remote_port_delete(port->rport);
2991                                         port->rport = NULL;
2992                                 }
2993                 }
2994                 zfcp_adapter_put(adapter);
2995                 break;
2996         default:
2997                 break;
2998         }
2999 }
3000
3001
3002 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
3003 {
3004         struct zfcp_port *port;
3005
3006         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
3007                 zfcp_erp_action_dismiss(&adapter->erp_action);
3008         else
3009                 list_for_each_entry(port, &adapter->port_list_head, list)
3010                     zfcp_erp_action_dismiss_port(port);
3011 }
3012
3013 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
3014 {
3015         struct zfcp_unit *unit;
3016
3017         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
3018                 zfcp_erp_action_dismiss(&port->erp_action);
3019         else
3020                 list_for_each_entry(unit, &port->unit_list_head, list)
3021                     zfcp_erp_action_dismiss_unit(unit);
3022 }
3023
3024 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
3025 {
3026         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
3027                 zfcp_erp_action_dismiss(&unit->erp_action);
3028 }
3029
3030 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
3031 {
3032         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
3033         zfcp_rec_dbf_event_action(145, erp_action);
3034 }
3035
3036 static void zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
3037 {
3038         list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
3039         zfcp_rec_dbf_event_action(146, erp_action);
3040 }
3041
3042 void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref)
3043 {
3044         unsigned long flags;
3045
3046         read_lock_irqsave(&zfcp_data.config_lock, flags);
3047         zfcp_erp_modify_port_status(port, id, ref,
3048                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
3049         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3050         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
3051 }
3052
3053 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref)
3054 {
3055         zfcp_erp_modify_unit_status(unit, id, ref,
3056                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
3057         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
3058 }
3059
3060 void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref)
3061 {
3062         unsigned long flags;
3063
3064         read_lock_irqsave(&zfcp_data.config_lock, flags);
3065         zfcp_erp_modify_port_status(port, id, ref,
3066                                     ZFCP_STATUS_COMMON_ERP_FAILED |
3067                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
3068         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3069 }
3070
3071 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref)
3072 {
3073         zfcp_erp_modify_unit_status(unit, id, ref,
3074                                     ZFCP_STATUS_COMMON_ERP_FAILED |
3075                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
3076 }
3077
3078 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id,
3079                                      void *ref)
3080 {
3081         struct zfcp_port *port;
3082         unsigned long flags;
3083
3084         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
3085                 return;
3086
3087         read_lock_irqsave(&zfcp_data.config_lock, flags);
3088         if (adapter->nameserver_port)
3089                 zfcp_erp_port_access_changed(adapter->nameserver_port, id, ref);
3090         list_for_each_entry(port, &adapter->port_list_head, list)
3091                 if (port != adapter->nameserver_port)
3092                         zfcp_erp_port_access_changed(port, id, ref);
3093         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3094 }
3095
3096 void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id, void *ref)
3097 {
3098         struct zfcp_adapter *adapter = port->adapter;
3099         struct zfcp_unit *unit;
3100
3101         if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3102                               &port->status) &&
3103             !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3104                               &port->status)) {
3105                 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
3106                         list_for_each_entry(unit, &port->unit_list_head, list)
3107                                 zfcp_erp_unit_access_changed(unit, id, ref);
3108                 return;
3109         }
3110
3111         ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
3112                         "(due to ACT update)\n",
3113                         port->wwpn, zfcp_get_busid_by_adapter(adapter));
3114         if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref))
3115                 ZFCP_LOG_NORMAL("failed reopen of port"
3116                                 "(adapter %s, wwpn=0x%016Lx)\n",
3117                                 zfcp_get_busid_by_adapter(adapter), port->wwpn);
3118 }
3119
3120 void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id, void *ref)
3121 {
3122         struct zfcp_adapter *adapter = unit->port->adapter;
3123
3124         if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3125                               &unit->status) &&
3126             !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3127                               &unit->status))
3128                 return;
3129
3130         ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
3131                         " on adapter %s (due to ACT update)\n",
3132                         unit->fcp_lun, unit->port->wwpn,
3133                         zfcp_get_busid_by_adapter(adapter));
3134         if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref))
3135                 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
3136                                 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
3137                                 zfcp_get_busid_by_adapter(adapter),
3138                                 unit->port->wwpn, unit->fcp_lun);
3139 }
3140
3141 #undef ZFCP_LOG_AREA