drivers/s390/scsi/zfcp_erp.c

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