err.no Git - linux-2.6/blob - drivers/s390/scsi/zfcp_erp.c

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