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