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

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