drivers/s390/scsi/zfcp_erp.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Error Recovery Procedures (ERP).
   5  *
   6  * Copyright IBM Corporation 2002, 2009
   7  */
   8
   9 #define KMSG_COMPONENT "zfcp"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include <linux/kthread.h>
  13 #include "zfcp_ext.h"
  14
  15 #define ZFCP_MAX_ERPS                   3
  16
  17 enum zfcp_erp_act_flags {
  18         ZFCP_STATUS_ERP_TIMEDOUT        = 0x10000000,
  19         ZFCP_STATUS_ERP_CLOSE_ONLY      = 0x01000000,
  20         ZFCP_STATUS_ERP_DISMISSING      = 0x00100000,
  21         ZFCP_STATUS_ERP_DISMISSED       = 0x00200000,
  22         ZFCP_STATUS_ERP_LOWMEM          = 0x00400000,
  23 };
  24
  25 enum zfcp_erp_steps {
  26         ZFCP_ERP_STEP_UNINITIALIZED     = 0x0000,
  27         ZFCP_ERP_STEP_FSF_XCONFIG       = 0x0001,
  28         ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
  29         ZFCP_ERP_STEP_PORT_CLOSING      = 0x0100,
  30         ZFCP_ERP_STEP_PORT_OPENING      = 0x0800,
  31         ZFCP_ERP_STEP_UNIT_CLOSING      = 0x1000,
  32         ZFCP_ERP_STEP_UNIT_OPENING      = 0x2000,
  33 };
  34
  35 enum zfcp_erp_act_type {
  36         ZFCP_ERP_ACTION_REOPEN_UNIT        = 1,
  37         ZFCP_ERP_ACTION_REOPEN_PORT        = 2,
  38         ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
  39         ZFCP_ERP_ACTION_REOPEN_ADAPTER     = 4,
  40 };
  41
  42 enum zfcp_erp_act_state {
  43         ZFCP_ERP_ACTION_RUNNING = 1,
  44         ZFCP_ERP_ACTION_READY   = 2,
  45 };
  46
  47 enum zfcp_erp_act_result {
  48         ZFCP_ERP_SUCCEEDED = 0,
  49         ZFCP_ERP_FAILED    = 1,
  50         ZFCP_ERP_CONTINUES = 2,
  51         ZFCP_ERP_EXIT      = 3,
  52         ZFCP_ERP_DISMISSED = 4,
  53         ZFCP_ERP_NOMEM     = 5,
  54 };
  55
  56 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
  57 {
  58         zfcp_erp_modify_adapter_status(adapter, "erablk1", NULL,
  59                                        ZFCP_STATUS_COMMON_UNBLOCKED | mask,
  60                                        ZFCP_CLEAR);
  61 }
  62
  63 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
  64 {
  65         struct zfcp_erp_action *curr_act;
  66
  67         list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
  68                 if (act == curr_act)
  69                         return ZFCP_ERP_ACTION_RUNNING;
  70         return 0;
  71 }
  72
  73 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
  74 {
  75         struct zfcp_adapter *adapter = act->adapter;
  76
  77         list_move(&act->list, &act->adapter->erp_ready_head);
  78         zfcp_dbf_rec_action("erardy1", act);
  79         wake_up(&adapter->erp_ready_wq);
  80         zfcp_dbf_rec_thread("erardy2", adapter->dbf);
  81 }
  82
  83 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
  84 {
  85         act->status |= ZFCP_STATUS_ERP_DISMISSED;
  86         if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
  87                 zfcp_erp_action_ready(act);
  88 }
  89
  90 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
  91 {
  92         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
  93                 zfcp_erp_action_dismiss(&unit->erp_action);
  94 }
  95
  96 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
  97 {
  98         struct zfcp_unit *unit;
  99
 100         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 101                 zfcp_erp_action_dismiss(&port->erp_action);
 102         else
 103                 list_for_each_entry(unit, &port->unit_list_head, list)
 104                     zfcp_erp_action_dismiss_unit(unit);
 105 }
 106
 107 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 108 {
 109         struct zfcp_port *port;
 110
 111         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 112                 zfcp_erp_action_dismiss(&adapter->erp_action);
 113         else
 114                 list_for_each_entry(port, &adapter->port_list_head, list)
 115                     zfcp_erp_action_dismiss_port(port);
 116 }
 117
 118 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
 119                                  struct zfcp_port *port,
 120                                  struct zfcp_unit *unit)
 121 {
 122         int need = want;
 123         int u_status, p_status, a_status;
 124
 125         switch (want) {
 126         case ZFCP_ERP_ACTION_REOPEN_UNIT:
 127                 u_status = atomic_read(&unit->status);
 128                 if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 129                         return 0;
 130                 p_status = atomic_read(&port->status);
 131                 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
 132                       p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
 133                         return 0;
 134                 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
 135                         need = ZFCP_ERP_ACTION_REOPEN_PORT;
 136                 /* fall through */
 137         case ZFCP_ERP_ACTION_REOPEN_PORT:
 138         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 139                 p_status = atomic_read(&port->status);
 140                 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 141                         return 0;
 142                 a_status = atomic_read(&adapter->status);
 143                 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
 144                       a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
 145                         return 0;
 146                 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
 147                         need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
 148                 /* fall through */
 149         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 150                 a_status = atomic_read(&adapter->status);
 151                 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 152                         return 0;
 153                 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
 154                     !(a_status & ZFCP_STATUS_COMMON_OPEN))
 155                         return 0; /* shutdown requested for closed adapter */
 156         }
 157
 158         return need;
 159 }
 160
 161 static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 162                                                   struct zfcp_adapter *adapter,
 163                                                   struct zfcp_port *port,
 164                                                   struct zfcp_unit *unit)
 165 {
 166         struct zfcp_erp_action *erp_action;
 167         u32 status = 0;
 168
 169         switch (need) {
 170         case ZFCP_ERP_ACTION_REOPEN_UNIT:
 171                 zfcp_unit_get(unit);
 172                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
 173                 erp_action = &unit->erp_action;
 174                 if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING))
 175                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 176                 break;
 177
 178         case ZFCP_ERP_ACTION_REOPEN_PORT:
 179         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 180                 zfcp_port_get(port);
 181                 zfcp_erp_action_dismiss_port(port);
 182                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
 183                 erp_action = &port->erp_action;
 184                 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
 185                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 186                 break;
 187
 188         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 189                 zfcp_adapter_get(adapter);
 190                 zfcp_erp_action_dismiss_adapter(adapter);
 191                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
 192                 erp_action = &adapter->erp_action;
 193                 if (!(atomic_read(&adapter->status) &
 194                       ZFCP_STATUS_COMMON_RUNNING))
 195                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 196                 break;
 197
 198         default:
 199                 return NULL;
 200         }
 201
 202         memset(erp_action, 0, sizeof(struct zfcp_erp_action));
 203         erp_action->adapter = adapter;
 204         erp_action->port = port;
 205         erp_action->unit = unit;
 206         erp_action->action = need;
 207         erp_action->status = status;
 208
 209         return erp_action;
 210 }
 211
 212 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
 213                                    struct zfcp_port *port,
 214                                    struct zfcp_unit *unit, char *id, void *ref)
 215 {
 216         int retval = 1, need;
 217         struct zfcp_erp_action *act = NULL;
 218
 219         if (!adapter->erp_thread)
 220                 return -EIO;
 221
 222         need = zfcp_erp_required_act(want, adapter, port, unit);
 223         if (!need)
 224                 goto out;
 225
 226         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
 227         act = zfcp_erp_setup_act(need, adapter, port, unit);
 228         if (!act)
 229                 goto out;
 230         ++adapter->erp_total_count;
 231         list_add_tail(&act->list, &adapter->erp_ready_head);
 232         wake_up(&adapter->erp_ready_wq);
 233         zfcp_dbf_rec_thread("eracte1", adapter->dbf);
 234         retval = 0;
 235  out:
 236         zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, unit);
 237         return retval;
 238 }
 239
 240 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
 241                                     int clear_mask, char *id, void *ref)
 242 {
 243         zfcp_erp_adapter_block(adapter, clear_mask);
 244         zfcp_scsi_schedule_rports_block(adapter);
 245
 246         /* ensure propagation of failed status to new devices */
 247         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 248                 zfcp_erp_adapter_failed(adapter, "erareo1", NULL);
 249                 return -EIO;
 250         }
 251         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
 252                                        adapter, NULL, NULL, id, ref);
 253 }
 254
 255 /**
 256  * zfcp_erp_adapter_reopen - Reopen adapter.
 257  * @adapter: Adapter to reopen.
 258  * @clear: Status flags to clear.
 259  * @id: Id for debug trace event.
 260  * @ref: Reference for debug trace event.
 261  */
 262 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
 263                              char *id, void *ref)
 264 {
 265         unsigned long flags;
 266
 267         read_lock_irqsave(&zfcp_data.config_lock, flags);
 268         write_lock(&adapter->erp_lock);
 269         _zfcp_erp_adapter_reopen(adapter, clear, id, ref);
 270         write_unlock(&adapter->erp_lock);
 271         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 272 }
 273
 274 /**
 275  * zfcp_erp_adapter_shutdown - Shutdown adapter.
 276  * @adapter: Adapter to shut down.
 277  * @clear: Status flags to clear.
 278  * @id: Id for debug trace event.
 279  * @ref: Reference for debug trace event.
 280  */
 281 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
 282                                char *id, void *ref)
 283 {
 284         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 285         zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
 286 }
 287
 288 /**
 289  * zfcp_erp_port_shutdown - Shutdown port
 290  * @port: Port to shut down.
 291  * @clear: Status flags to clear.
 292  * @id: Id for debug trace event.
 293  * @ref: Reference for debug trace event.
 294  */
 295 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id,
 296                             void *ref)
 297 {
 298         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 299         zfcp_erp_port_reopen(port, clear | flags, id, ref);
 300 }
 301
 302 /**
 303  * zfcp_erp_unit_shutdown - Shutdown unit
 304  * @unit: Unit to shut down.
 305  * @clear: Status flags to clear.
 306  * @id: Id for debug trace event.
 307  * @ref: Reference for debug trace event.
 308  */
 309 void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear, char *id,
 310                             void *ref)
 311 {
 312         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 313         zfcp_erp_unit_reopen(unit, clear | flags, id, ref);
 314 }
 315
 316 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
 317 {
 318         zfcp_erp_modify_port_status(port, "erpblk1", NULL,
 319                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear,
 320                                     ZFCP_CLEAR);
 321 }
 322
 323 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
 324                                          int clear, char *id, void *ref)
 325 {
 326         zfcp_erp_port_block(port, clear);
 327         zfcp_scsi_schedule_rport_block(port);
 328
 329         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
 330                 return;
 331
 332         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
 333                                 port->adapter, port, NULL, id, ref);
 334 }
 335
 336 /**
 337  * zfcp_erp_port_forced_reopen - Forced close of port and open again
 338  * @port: Port to force close and to reopen.
 339  * @id: Id for debug trace event.
 340  * @ref: Reference for debug trace event.
 341  */
 342 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id,
 343                                  void *ref)
 344 {
 345         unsigned long flags;
 346         struct zfcp_adapter *adapter = port->adapter;
 347
 348         read_lock_irqsave(&zfcp_data.config_lock, flags);
 349         write_lock(&adapter->erp_lock);
 350         _zfcp_erp_port_forced_reopen(port, clear, id, ref);
 351         write_unlock(&adapter->erp_lock);
 352         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 353 }
 354
 355 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
 356                                  void *ref)
 357 {
 358         zfcp_erp_port_block(port, clear);
 359         zfcp_scsi_schedule_rport_block(port);
 360
 361         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 362                 /* ensure propagation of failed status to new devices */
 363                 zfcp_erp_port_failed(port, "erpreo1", NULL);
 364                 return -EIO;
 365         }
 366
 367         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
 368                                        port->adapter, port, NULL, id, ref);
 369 }
 370
 371 /**
 372  * zfcp_erp_port_reopen - trigger remote port recovery
 373  * @port: port to recover
 374  * @clear_mask: flags in port status to be cleared
 375  *
 376  * Returns 0 if recovery has been triggered, < 0 if not.
 377  */
 378 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref)
 379 {
 380         unsigned long flags;
 381         int retval;
 382         struct zfcp_adapter *adapter = port->adapter;
 383
 384         read_lock_irqsave(&zfcp_data.config_lock, flags);
 385         write_lock(&adapter->erp_lock);
 386         retval = _zfcp_erp_port_reopen(port, clear, id, ref);
 387         write_unlock(&adapter->erp_lock);
 388         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 389
 390         return retval;
 391 }
 392
 393 static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
 394 {
 395         zfcp_erp_modify_unit_status(unit, "erublk1", NULL,
 396                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
 397                                     ZFCP_CLEAR);
 398 }
 399
 400 static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id,
 401                                   void *ref)
 402 {
 403         struct zfcp_adapter *adapter = unit->port->adapter;
 404
 405         zfcp_erp_unit_block(unit, clear);
 406
 407         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
 408                 return;
 409
 410         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
 411                                 adapter, unit->port, unit, id, ref);
 412 }
 413
 414 /**
 415  * zfcp_erp_unit_reopen - initiate reopen of a unit
 416  * @unit: unit to be reopened
 417  * @clear_mask: specifies flags in unit status to be cleared
 418  * Return: 0 on success, < 0 on error
 419  */
 420 void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id,
 421                           void *ref)
 422 {
 423         unsigned long flags;
 424         struct zfcp_port *port = unit->port;
 425         struct zfcp_adapter *adapter = port->adapter;
 426
 427         read_lock_irqsave(&zfcp_data.config_lock, flags);
 428         write_lock(&adapter->erp_lock);
 429         _zfcp_erp_unit_reopen(unit, clear, id, ref);
 430         write_unlock(&adapter->erp_lock);
 431         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 432 }
 433
 434 static int status_change_set(unsigned long mask, atomic_t *status)
 435 {
 436         return (atomic_read(status) ^ mask) & mask;
 437 }
 438
 439 static int status_change_clear(unsigned long mask, atomic_t *status)
 440 {
 441         return atomic_read(status) & mask;
 442 }
 443
 444 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 445 {
 446         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
 447                 zfcp_dbf_rec_adapter("eraubl1", NULL, adapter->dbf);
 448         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
 449 }
 450
 451 static void zfcp_erp_port_unblock(struct zfcp_port *port)
 452 {
 453         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
 454                 zfcp_dbf_rec_port("erpubl1", NULL, port);
 455         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
 456 }
 457
 458 static void zfcp_erp_unit_unblock(struct zfcp_unit *unit)
 459 {
 460         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status))
 461                 zfcp_dbf_rec_unit("eruubl1", NULL, unit);
 462         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
 463 }
 464
 465 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 466 {
 467         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
 468         zfcp_dbf_rec_action("erator1", erp_action);
 469 }
 470
 471 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
 472 {
 473         struct zfcp_adapter *adapter = act->adapter;
 474
 475         if (!act->fsf_req)
 476                 return;
 477
 478         spin_lock(&adapter->req_list_lock);
 479         if (zfcp_reqlist_find_safe(adapter, act->fsf_req) &&
 480             act->fsf_req->erp_action == act) {
 481                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
 482                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
 483                         act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
 484                         zfcp_dbf_rec_action("erscf_1", act);
 485                         act->fsf_req->erp_action = NULL;
 486                 }
 487                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
 488                         zfcp_dbf_rec_action("erscf_2", act);
 489                 if (act->fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
 490                         act->fsf_req = NULL;
 491         } else
 492                 act->fsf_req = NULL;
 493         spin_unlock(&adapter->req_list_lock);
 494 }
 495
 496 /**
 497  * zfcp_erp_notify - Trigger ERP action.
 498  * @erp_action: ERP action to continue.
 499  * @set_mask: ERP action status flags to set.
 500  */
 501 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
 502 {
 503         struct zfcp_adapter *adapter = erp_action->adapter;
 504         unsigned long flags;
 505
 506         write_lock_irqsave(&adapter->erp_lock, flags);
 507         if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
 508                 erp_action->status |= set_mask;
 509                 zfcp_erp_action_ready(erp_action);
 510         }
 511         write_unlock_irqrestore(&adapter->erp_lock, flags);
 512 }
 513
 514 /**
 515  * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
 516  * @data: ERP action (from timer data)
 517  */
 518 void zfcp_erp_timeout_handler(unsigned long data)
 519 {
 520         struct zfcp_erp_action *act = (struct zfcp_erp_action *) data;
 521         zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
 522 }
 523
 524 static void zfcp_erp_memwait_handler(unsigned long data)
 525 {
 526         zfcp_erp_notify((struct zfcp_erp_action *)data, 0);
 527 }
 528
 529 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
 530 {
 531         init_timer(&erp_action->timer);
 532         erp_action->timer.function = zfcp_erp_memwait_handler;
 533         erp_action->timer.data = (unsigned long) erp_action;
 534         erp_action->timer.expires = jiffies + HZ;
 535         add_timer(&erp_action->timer);
 536 }
 537
 538 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
 539                                       int clear, char *id, void *ref)
 540 {
 541         struct zfcp_port *port;
 542
 543         list_for_each_entry(port, &adapter->port_list_head, list)
 544                 _zfcp_erp_port_reopen(port, clear, id, ref);
 545 }
 546
 547 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear,
 548                                       char *id, void *ref)
 549 {
 550         struct zfcp_unit *unit;
 551
 552         list_for_each_entry(unit, &port->unit_list_head, list)
 553                 _zfcp_erp_unit_reopen(unit, clear, id, ref);
 554 }
 555
 556 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
 557 {
 558         switch (act->action) {
 559         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 560                 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL);
 561                 break;
 562         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 563                 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL);
 564                 break;
 565         case ZFCP_ERP_ACTION_REOPEN_PORT:
 566                 _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL);
 567                 break;
 568         case ZFCP_ERP_ACTION_REOPEN_UNIT:
 569                 _zfcp_erp_unit_reopen(act->unit, 0, "ersff_4", NULL);
 570                 break;
 571         }
 572 }
 573
 574 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
 575 {
 576         switch (act->action) {
 577         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 578                 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL);
 579                 break;
 580         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 581                 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL);
 582                 break;
 583         case ZFCP_ERP_ACTION_REOPEN_PORT:
 584                 _zfcp_erp_unit_reopen_all(act->port, 0, "ersfs_3", NULL);
 585                 break;
 586         }
 587 }
 588
 589 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
 590 {
 591         unsigned long flags;
 592
 593         read_lock_irqsave(&zfcp_data.config_lock, flags);
 594         read_lock(&adapter->erp_lock);
 595         if (list_empty(&adapter->erp_ready_head) &&
 596             list_empty(&adapter->erp_running_head)) {
 597                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
 598                                           &adapter->status);
 599                         wake_up(&adapter->erp_done_wqh);
 600         }
 601         read_unlock(&adapter->erp_lock);
 602         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 603 }
 604
 605 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
 606 {
 607         struct zfcp_qdio *qdio = act->adapter->qdio;
 608
 609         if (zfcp_qdio_open(qdio))
 610                 return ZFCP_ERP_FAILED;
 611         init_waitqueue_head(&qdio->req_q_wq);
 612         atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
 613         return ZFCP_ERP_SUCCEEDED;
 614 }
 615
 616 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
 617 {
 618         struct zfcp_port *port;
 619         port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
 620                                  adapter->peer_d_id);
 621         if (IS_ERR(port)) /* error or port already attached */
 622                 return;
 623         _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL);
 624 }
 625
 626 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
 627 {
 628         int retries;
 629         int sleep = 1;
 630         struct zfcp_adapter *adapter = erp_action->adapter;
 631
 632         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
 633
 634         for (retries = 7; retries; retries--) {
 635                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 636                                   &adapter->status);
 637                 write_lock_irq(&adapter->erp_lock);
 638                 zfcp_erp_action_to_running(erp_action);
 639                 write_unlock_irq(&adapter->erp_lock);
 640                 if (zfcp_fsf_exchange_config_data(erp_action)) {
 641                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 642                                           &adapter->status);
 643                         return ZFCP_ERP_FAILED;
 644                 }
 645
 646                 zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
 647                 wait_event(adapter->erp_ready_wq,
 648                            !list_empty(&adapter->erp_ready_head));
 649                 zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
 650                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
 651                         break;
 652
 653                 if (!(atomic_read(&adapter->status) &
 654                       ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
 655                         break;
 656
 657                 ssleep(sleep);
 658                 sleep *= 2;
 659         }
 660
 661         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 662                           &adapter->status);
 663
 664         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
 665                 return ZFCP_ERP_FAILED;
 666
 667         if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 668                 zfcp_erp_enqueue_ptp_port(adapter);
 669
 670         return ZFCP_ERP_SUCCEEDED;
 671 }
 672
 673 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
 674 {
 675         int ret;
 676         struct zfcp_adapter *adapter = act->adapter;
 677
 678         write_lock_irq(&adapter->erp_lock);
 679         zfcp_erp_action_to_running(act);
 680         write_unlock_irq(&adapter->erp_lock);
 681
 682         ret = zfcp_fsf_exchange_port_data(act);
 683         if (ret == -EOPNOTSUPP)
 684                 return ZFCP_ERP_SUCCEEDED;
 685         if (ret)
 686                 return ZFCP_ERP_FAILED;
 687
 688         zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf);
 689         wait_event(adapter->erp_ready_wq,
 690                    !list_empty(&adapter->erp_ready_head));
 691         zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf);
 692         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
 693                 return ZFCP_ERP_FAILED;
 694
 695         return ZFCP_ERP_SUCCEEDED;
 696 }
 697
 698 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
 699 {
 700         if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
 701                 return ZFCP_ERP_FAILED;
 702
 703         if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
 704                 return ZFCP_ERP_FAILED;
 705
 706         atomic_set(&act->adapter->stat_miss, 16);
 707         if (zfcp_status_read_refill(act->adapter))
 708                 return ZFCP_ERP_FAILED;
 709
 710         return ZFCP_ERP_SUCCEEDED;
 711 }
 712
 713 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
 714 {
 715         struct zfcp_adapter *adapter = act->adapter;
 716
 717         /* close queues to ensure that buffers are not accessed by adapter */
 718         zfcp_qdio_close(adapter->qdio);
 719         zfcp_fsf_req_dismiss_all(adapter);
 720         adapter->fsf_req_seq_no = 0;
 721         zfcp_fc_wka_ports_force_offline(adapter->gs);
 722         /* all ports and units are closed */
 723         zfcp_erp_modify_adapter_status(adapter, "erascl1", NULL,
 724                                        ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
 725
 726         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
 727                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
 728 }
 729
 730 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
 731 {
 732         struct zfcp_adapter *adapter = act->adapter;
 733
 734         if (zfcp_erp_adapter_strategy_open_qdio(act)) {
 735                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
 736                                   ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
 737                                   &adapter->status);
 738                 return ZFCP_ERP_FAILED;
 739         }
 740
 741         if (zfcp_erp_adapter_strategy_open_fsf(act)) {
 742                 zfcp_erp_adapter_strategy_close(act);
 743                 return ZFCP_ERP_FAILED;
 744         }
 745
 746         atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
 747
 748         return ZFCP_ERP_SUCCEEDED;
 749 }
 750
 751 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
 752 {
 753         struct zfcp_adapter *adapter = act->adapter;
 754
 755         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
 756                 zfcp_erp_adapter_strategy_close(act);
 757                 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 758                         return ZFCP_ERP_EXIT;
 759         }
 760
 761         if (zfcp_erp_adapter_strategy_open(act)) {
 762                 ssleep(8);
 763                 return ZFCP_ERP_FAILED;
 764         }
 765
 766         return ZFCP_ERP_SUCCEEDED;
 767 }
 768
 769 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
 770 {
 771         int retval;
 772
 773         retval = zfcp_fsf_close_physical_port(act);
 774         if (retval == -ENOMEM)
 775                 return ZFCP_ERP_NOMEM;
 776         act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
 777         if (retval)
 778                 return ZFCP_ERP_FAILED;
 779
 780         return ZFCP_ERP_CONTINUES;
 781 }
 782
 783 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
 784 {
 785         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status);
 786 }
 787
 788 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 789 {
 790         struct zfcp_port *port = erp_action->port;
 791         int status = atomic_read(&port->status);
 792
 793         switch (erp_action->step) {
 794         case ZFCP_ERP_STEP_UNINITIALIZED:
 795                 zfcp_erp_port_strategy_clearstati(port);
 796                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
 797                     (status & ZFCP_STATUS_COMMON_OPEN))
 798                         return zfcp_erp_port_forced_strategy_close(erp_action);
 799                 else
 800                         return ZFCP_ERP_FAILED;
 801
 802         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 803                 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
 804                         return ZFCP_ERP_SUCCEEDED;
 805         }
 806         return ZFCP_ERP_FAILED;
 807 }
 808
 809 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
 810 {
 811         int retval;
 812
 813         retval = zfcp_fsf_close_port(erp_action);
 814         if (retval == -ENOMEM)
 815                 return ZFCP_ERP_NOMEM;
 816         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
 817         if (retval)
 818                 return ZFCP_ERP_FAILED;
 819         return ZFCP_ERP_CONTINUES;
 820 }
 821
 822 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
 823 {
 824         int retval;
 825
 826         retval = zfcp_fsf_open_port(erp_action);
 827         if (retval == -ENOMEM)
 828                 return ZFCP_ERP_NOMEM;
 829         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
 830         if (retval)
 831                 return ZFCP_ERP_FAILED;
 832         return ZFCP_ERP_CONTINUES;
 833 }
 834
 835 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
 836 {
 837         struct zfcp_adapter *adapter = act->adapter;
 838         struct zfcp_port *port = act->port;
 839
 840         if (port->wwpn != adapter->peer_wwpn) {
 841                 zfcp_erp_port_failed(port, "eroptp1", NULL);
 842                 return ZFCP_ERP_FAILED;
 843         }
 844         port->d_id = adapter->peer_d_id;
 845         return zfcp_erp_port_strategy_open_port(act);
 846 }
 847
 848 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
 849 {
 850         struct zfcp_adapter *adapter = act->adapter;
 851         struct zfcp_port *port = act->port;
 852         int p_status = atomic_read(&port->status);
 853
 854         switch (act->step) {
 855         case ZFCP_ERP_STEP_UNINITIALIZED:
 856         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 857         case ZFCP_ERP_STEP_PORT_CLOSING:
 858                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 859                         return zfcp_erp_open_ptp_port(act);
 860                 if (!port->d_id) {
 861                         zfcp_port_get(port);
 862                         if (!queue_work(adapter->work_queue,
 863                                         &port->gid_pn_work))
 864                                 zfcp_port_put(port);
 865                         return ZFCP_ERP_EXIT;
 866                 }
 867                 return zfcp_erp_port_strategy_open_port(act);
 868
 869         case ZFCP_ERP_STEP_PORT_OPENING:
 870                 /* D_ID might have changed during open */
 871                 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
 872                         if (port->d_id)
 873                                 return ZFCP_ERP_SUCCEEDED;
 874                         else {
 875                                 act->step = ZFCP_ERP_STEP_PORT_CLOSING;
 876                                 return ZFCP_ERP_CONTINUES;
 877                         }
 878                 }
 879                 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
 880                         port->d_id = 0;
 881                         _zfcp_erp_port_reopen(port, 0, "erpsoc1", NULL);
 882                         return ZFCP_ERP_EXIT;
 883                 }
 884                 /* fall through otherwise */
 885         }
 886         return ZFCP_ERP_FAILED;
 887 }
 888
 889 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
 890 {
 891         struct zfcp_port *port = erp_action->port;
 892
 893         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)
 894                 goto close_init_done;
 895
 896         switch (erp_action->step) {
 897         case ZFCP_ERP_STEP_UNINITIALIZED:
 898                 zfcp_erp_port_strategy_clearstati(port);
 899                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
 900                         return zfcp_erp_port_strategy_close(erp_action);
 901                 break;
 902
 903         case ZFCP_ERP_STEP_PORT_CLOSING:
 904                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
 905                         return ZFCP_ERP_FAILED;
 906                 break;
 907         }
 908
 909 close_init_done:
 910         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 911                 return ZFCP_ERP_EXIT;
 912
 913         return zfcp_erp_port_strategy_open_common(erp_action);
 914 }
 915
 916 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
 917 {
 918         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
 919                           ZFCP_STATUS_UNIT_SHARED |
 920                           ZFCP_STATUS_UNIT_READONLY,
 921                           &unit->status);
 922 }
 923
 924 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
 925 {
 926         int retval = zfcp_fsf_close_unit(erp_action);
 927         if (retval == -ENOMEM)
 928                 return ZFCP_ERP_NOMEM;
 929         erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
 930         if (retval)
 931                 return ZFCP_ERP_FAILED;
 932         return ZFCP_ERP_CONTINUES;
 933 }
 934
 935 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
 936 {
 937         int retval = zfcp_fsf_open_unit(erp_action);
 938         if (retval == -ENOMEM)
 939                 return ZFCP_ERP_NOMEM;
 940         erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
 941         if (retval)
 942                 return  ZFCP_ERP_FAILED;
 943         return ZFCP_ERP_CONTINUES;
 944 }
 945
 946 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
 947 {
 948         struct zfcp_unit *unit = erp_action->unit;
 949
 950         switch (erp_action->step) {
 951         case ZFCP_ERP_STEP_UNINITIALIZED:
 952                 zfcp_erp_unit_strategy_clearstati(unit);
 953                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 954                         return zfcp_erp_unit_strategy_close(erp_action);
 955                 /* already closed, fall through */
 956         case ZFCP_ERP_STEP_UNIT_CLOSING:
 957                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 958                         return ZFCP_ERP_FAILED;
 959                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 960                         return ZFCP_ERP_EXIT;
 961                 return zfcp_erp_unit_strategy_open(erp_action);
 962
 963         case ZFCP_ERP_STEP_UNIT_OPENING:
 964                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 965                         return ZFCP_ERP_SUCCEEDED;
 966         }
 967         return ZFCP_ERP_FAILED;
 968 }
 969
 970 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
 971 {
 972         switch (result) {
 973         case ZFCP_ERP_SUCCEEDED :
 974                 atomic_set(&unit->erp_counter, 0);
 975                 zfcp_erp_unit_unblock(unit);
 976                 break;
 977         case ZFCP_ERP_FAILED :
 978                 atomic_inc(&unit->erp_counter);
 979                 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
 980                         dev_err(&unit->port->adapter->ccw_device->dev,
 981                                 "ERP failed for unit 0x%016Lx on "
 982                                 "port 0x%016Lx\n",
 983                                 (unsigned long long)unit->fcp_lun,
 984                                 (unsigned long long)unit->port->wwpn);
 985                         zfcp_erp_unit_failed(unit, "erusck1", NULL);
 986                 }
 987                 break;
 988         }
 989
 990         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 991                 zfcp_erp_unit_block(unit, 0);
 992                 result = ZFCP_ERP_EXIT;
 993         }
 994         return result;
 995 }
 996
 997 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
 998 {
 999         switch (result) {
1000         case ZFCP_ERP_SUCCEEDED :
1001                 atomic_set(&port->erp_counter, 0);
1002                 zfcp_erp_port_unblock(port);
1003                 break;
1004
1005         case ZFCP_ERP_FAILED :
1006                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1007                         zfcp_erp_port_block(port, 0);
1008                         result = ZFCP_ERP_EXIT;
1009                 }
1010                 atomic_inc(&port->erp_counter);
1011                 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1012                         dev_err(&port->adapter->ccw_device->dev,
1013                                 "ERP failed for remote port 0x%016Lx\n",
1014                                 (unsigned long long)port->wwpn);
1015                         zfcp_erp_port_failed(port, "erpsck1", NULL);
1016                 }
1017                 break;
1018         }
1019
1020         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1021                 zfcp_erp_port_block(port, 0);
1022                 result = ZFCP_ERP_EXIT;
1023         }
1024         return result;
1025 }
1026
1027 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1028                                            int result)
1029 {
1030         switch (result) {
1031         case ZFCP_ERP_SUCCEEDED :
1032                 atomic_set(&adapter->erp_counter, 0);
1033                 zfcp_erp_adapter_unblock(adapter);
1034                 break;
1035
1036         case ZFCP_ERP_FAILED :
1037                 atomic_inc(&adapter->erp_counter);
1038                 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1039                         dev_err(&adapter->ccw_device->dev,
1040                                 "ERP cannot recover an error "
1041                                 "on the FCP device\n");
1042                         zfcp_erp_adapter_failed(adapter, "erasck1", NULL);
1043                 }
1044                 break;
1045         }
1046
1047         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1048                 zfcp_erp_adapter_block(adapter, 0);
1049                 result = ZFCP_ERP_EXIT;
1050         }
1051         return result;
1052 }
1053
1054 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1055                                           int result)
1056 {
1057         struct zfcp_adapter *adapter = erp_action->adapter;
1058         struct zfcp_port *port = erp_action->port;
1059         struct zfcp_unit *unit = erp_action->unit;
1060
1061         switch (erp_action->action) {
1062
1063         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1064                 result = zfcp_erp_strategy_check_unit(unit, result);
1065                 break;
1066
1067         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1068         case ZFCP_ERP_ACTION_REOPEN_PORT:
1069                 result = zfcp_erp_strategy_check_port(port, result);
1070                 break;
1071
1072         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1073                 result = zfcp_erp_strategy_check_adapter(adapter, result);
1074                 break;
1075         }
1076         return result;
1077 }
1078
1079 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1080 {
1081         int status = atomic_read(target_status);
1082
1083         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1084             (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1085                 return 1; /* take it online */
1086
1087         if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1088             !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1089                 return 1; /* take it offline */
1090
1091         return 0;
1092 }
1093
1094 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1095 {
1096         int action = act->action;
1097         struct zfcp_adapter *adapter = act->adapter;
1098         struct zfcp_port *port = act->port;
1099         struct zfcp_unit *unit = act->unit;
1100         u32 erp_status = act->status;
1101
1102         switch (action) {
1103         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1104                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1105                         _zfcp_erp_adapter_reopen(adapter,
1106                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
1107                                                  "ersscg1", NULL);
1108                         return ZFCP_ERP_EXIT;
1109                 }
1110                 break;
1111
1112         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1113         case ZFCP_ERP_ACTION_REOPEN_PORT:
1114                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1115                         _zfcp_erp_port_reopen(port,
1116                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1117                                               "ersscg2", NULL);
1118                         return ZFCP_ERP_EXIT;
1119                 }
1120                 break;
1121
1122         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1123                 if (zfcp_erp_strat_change_det(&unit->status, erp_status)) {
1124                         _zfcp_erp_unit_reopen(unit,
1125                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1126                                               "ersscg3", NULL);
1127                         return ZFCP_ERP_EXIT;
1128                 }
1129                 break;
1130         }
1131         return ret;
1132 }
1133
1134 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1135 {
1136         struct zfcp_adapter *adapter = erp_action->adapter;
1137
1138         adapter->erp_total_count--;
1139         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1140                 adapter->erp_low_mem_count--;
1141                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1142         }
1143
1144         list_del(&erp_action->list);
1145         zfcp_dbf_rec_action("eractd1", erp_action);
1146
1147         switch (erp_action->action) {
1148         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1149                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1150                                   &erp_action->unit->status);
1151                 break;
1152
1153         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1154         case ZFCP_ERP_ACTION_REOPEN_PORT:
1155                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1156                                   &erp_action->port->status);
1157                 break;
1158
1159         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1160                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1161                                   &erp_action->adapter->status);
1162                 break;
1163         }
1164 }
1165
1166 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1167 {
1168         struct zfcp_adapter *adapter = act->adapter;
1169         struct zfcp_port *port = act->port;
1170         struct zfcp_unit *unit = act->unit;
1171
1172         switch (act->action) {
1173         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1174                 if ((result == ZFCP_ERP_SUCCEEDED) && !unit->device) {
1175                         zfcp_unit_get(unit);
1176                         if (scsi_queue_work(unit->port->adapter->scsi_host,
1177                                             &unit->scsi_work) <= 0)
1178                                 zfcp_unit_put(unit);
1179                 }
1180                 zfcp_unit_put(unit);
1181                 break;
1182
1183         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1184         case ZFCP_ERP_ACTION_REOPEN_PORT:
1185                 if (result == ZFCP_ERP_SUCCEEDED)
1186                         zfcp_scsi_schedule_rport_register(port);
1187                 zfcp_port_put(port);
1188                 break;
1189
1190         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1191                 if (result == ZFCP_ERP_SUCCEEDED) {
1192                         register_service_level(&adapter->service_level);
1193                         schedule_work(&adapter->scan_work);
1194                 } else
1195                         unregister_service_level(&adapter->service_level);
1196                 zfcp_adapter_put(adapter);
1197                 break;
1198         }
1199 }
1200
1201 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1202 {
1203         switch (erp_action->action) {
1204         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1205                 return zfcp_erp_adapter_strategy(erp_action);
1206         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1207                 return zfcp_erp_port_forced_strategy(erp_action);
1208         case ZFCP_ERP_ACTION_REOPEN_PORT:
1209                 return zfcp_erp_port_strategy(erp_action);
1210         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1211                 return zfcp_erp_unit_strategy(erp_action);
1212         }
1213         return ZFCP_ERP_FAILED;
1214 }
1215
1216 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1217 {
1218         int retval;
1219         struct zfcp_adapter *adapter = erp_action->adapter;
1220         unsigned long flags;
1221
1222         read_lock_irqsave(&zfcp_data.config_lock, flags);
1223         write_lock(&adapter->erp_lock);
1224
1225         zfcp_erp_strategy_check_fsfreq(erp_action);
1226
1227         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1228                 zfcp_erp_action_dequeue(erp_action);
1229                 retval = ZFCP_ERP_DISMISSED;
1230                 goto unlock;
1231         }
1232
1233         zfcp_erp_action_to_running(erp_action);
1234
1235         /* no lock to allow for blocking operations */
1236         write_unlock(&adapter->erp_lock);
1237         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1238         retval = zfcp_erp_strategy_do_action(erp_action);
1239         read_lock_irqsave(&zfcp_data.config_lock, flags);
1240         write_lock(&adapter->erp_lock);
1241
1242         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1243                 retval = ZFCP_ERP_CONTINUES;
1244
1245         switch (retval) {
1246         case ZFCP_ERP_NOMEM:
1247                 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1248                         ++adapter->erp_low_mem_count;
1249                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1250                 }
1251                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1252                         _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL);
1253                 else {
1254                         zfcp_erp_strategy_memwait(erp_action);
1255                         retval = ZFCP_ERP_CONTINUES;
1256                 }
1257                 goto unlock;
1258
1259         case ZFCP_ERP_CONTINUES:
1260                 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1261                         --adapter->erp_low_mem_count;
1262                         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1263                 }
1264                 goto unlock;
1265         }
1266
1267         retval = zfcp_erp_strategy_check_target(erp_action, retval);
1268         zfcp_erp_action_dequeue(erp_action);
1269         retval = zfcp_erp_strategy_statechange(erp_action, retval);
1270         if (retval == ZFCP_ERP_EXIT)
1271                 goto unlock;
1272         if (retval == ZFCP_ERP_SUCCEEDED)
1273                 zfcp_erp_strategy_followup_success(erp_action);
1274         if (retval == ZFCP_ERP_FAILED)
1275                 zfcp_erp_strategy_followup_failed(erp_action);
1276
1277  unlock:
1278         write_unlock(&adapter->erp_lock);
1279         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1280
1281         if (retval != ZFCP_ERP_CONTINUES)
1282                 zfcp_erp_action_cleanup(erp_action, retval);
1283
1284         return retval;
1285 }
1286
1287 static int zfcp_erp_thread(void *data)
1288 {
1289         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1290         struct list_head *next;
1291         struct zfcp_erp_action *act;
1292         unsigned long flags;
1293
1294         for (;;) {
1295                 zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
1296                 wait_event_interruptible(adapter->erp_ready_wq,
1297                            !list_empty(&adapter->erp_ready_head) ||
1298                            kthread_should_stop());
1299                 zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
1300
1301                 if (kthread_should_stop())
1302                         break;
1303
1304                 write_lock_irqsave(&adapter->erp_lock, flags);
1305                 next = adapter->erp_ready_head.next;
1306                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1307
1308                 if (next != &adapter->erp_ready_head) {
1309                         act = list_entry(next, struct zfcp_erp_action, list);
1310
1311                         /* there is more to come after dismission, no notify */
1312                         if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1313                                 zfcp_erp_wakeup(adapter);
1314                 }
1315         }
1316
1317         return 0;
1318 }
1319
1320 /**
1321  * zfcp_erp_thread_setup - Start ERP thread for adapter
1322  * @adapter: Adapter to start the ERP thread for
1323  *
1324  * Returns 0 on success or error code from kernel_thread()
1325  */
1326 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1327 {
1328         struct task_struct *thread;
1329
1330         thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1331                              dev_name(&adapter->ccw_device->dev));
1332         if (IS_ERR(thread)) {
1333                 dev_err(&adapter->ccw_device->dev,
1334                         "Creating an ERP thread for the FCP device failed.\n");
1335                 return PTR_ERR(thread);
1336         }
1337
1338         adapter->erp_thread = thread;
1339         return 0;
1340 }
1341
1342 /**
1343  * zfcp_erp_thread_kill - Stop ERP thread.
1344  * @adapter: Adapter where the ERP thread should be stopped.
1345  *
1346  * The caller of this routine ensures that the specified adapter has
1347  * been shut down and that this operation has been completed. Thus,
1348  * there are no pending erp_actions which would need to be handled
1349  * here.
1350  */
1351 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1352 {
1353         kthread_stop(adapter->erp_thread);
1354         adapter->erp_thread = NULL;
1355         WARN_ON(!list_empty(&adapter->erp_ready_head));
1356         WARN_ON(!list_empty(&adapter->erp_running_head));
1357 }
1358
1359 /**
1360  * zfcp_erp_adapter_failed - Set adapter status to failed.
1361  * @adapter: Failed adapter.
1362  * @id: Event id for debug trace.
1363  * @ref: Reference for debug trace.
1364  */
1365 void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, char *id, void *ref)
1366 {
1367         zfcp_erp_modify_adapter_status(adapter, id, ref,
1368                                        ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1369 }
1370
1371 /**
1372  * zfcp_erp_port_failed - Set port status to failed.
1373  * @port: Failed port.
1374  * @id: Event id for debug trace.
1375  * @ref: Reference for debug trace.
1376  */
1377 void zfcp_erp_port_failed(struct zfcp_port *port, char *id, void *ref)
1378 {
1379         zfcp_erp_modify_port_status(port, id, ref,
1380                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1381 }
1382
1383 /**
1384  * zfcp_erp_unit_failed - Set unit status to failed.
1385  * @unit: Failed unit.
1386  * @id: Event id for debug trace.
1387  * @ref: Reference for debug trace.
1388  */
1389 void zfcp_erp_unit_failed(struct zfcp_unit *unit, char *id, void *ref)
1390 {
1391         zfcp_erp_modify_unit_status(unit, id, ref,
1392                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1393 }
1394
1395 /**
1396  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1397  * @adapter: adapter for which to wait for completion of its error recovery
1398  */
1399 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1400 {
1401         wait_event(adapter->erp_done_wqh,
1402                    !(atomic_read(&adapter->status) &
1403                         ZFCP_STATUS_ADAPTER_ERP_PENDING));
1404 }
1405
1406 /**
1407  * zfcp_erp_modify_adapter_status - change adapter status bits
1408  * @adapter: adapter to change the status
1409  * @id: id for the debug trace
1410  * @ref: reference for the debug trace
1411  * @mask: status bits to change
1412  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1413  *
1414  * Changes in common status bits are propagated to attached ports and units.
1415  */
1416 void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, char *id,
1417                                     void *ref, u32 mask, int set_or_clear)
1418 {
1419         struct zfcp_port *port;
1420         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1421
1422         if (set_or_clear == ZFCP_SET) {
1423                 if (status_change_set(mask, &adapter->status))
1424                         zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
1425                 atomic_set_mask(mask, &adapter->status);
1426         } else {
1427                 if (status_change_clear(mask, &adapter->status))
1428                         zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
1429                 atomic_clear_mask(mask, &adapter->status);
1430                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1431                         atomic_set(&adapter->erp_counter, 0);
1432         }
1433
1434         if (common_mask)
1435                 list_for_each_entry(port, &adapter->port_list_head, list)
1436                         zfcp_erp_modify_port_status(port, id, ref, common_mask,
1437                                                     set_or_clear);
1438 }
1439
1440 /**
1441  * zfcp_erp_modify_port_status - change port status bits
1442  * @port: port to change the status bits
1443  * @id: id for the debug trace
1444  * @ref: reference for the debug trace
1445  * @mask: status bits to change
1446  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1447  *
1448  * Changes in common status bits are propagated to attached units.
1449  */
1450 void zfcp_erp_modify_port_status(struct zfcp_port *port, char *id, void *ref,
1451                                  u32 mask, int set_or_clear)
1452 {
1453         struct zfcp_unit *unit;
1454         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1455
1456         if (set_or_clear == ZFCP_SET) {
1457                 if (status_change_set(mask, &port->status))
1458                         zfcp_dbf_rec_port(id, ref, port);
1459                 atomic_set_mask(mask, &port->status);
1460         } else {
1461                 if (status_change_clear(mask, &port->status))
1462                         zfcp_dbf_rec_port(id, ref, port);
1463                 atomic_clear_mask(mask, &port->status);
1464                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1465                         atomic_set(&port->erp_counter, 0);
1466         }
1467
1468         if (common_mask)
1469                 list_for_each_entry(unit, &port->unit_list_head, list)
1470                         zfcp_erp_modify_unit_status(unit, id, ref, common_mask,
1471                                                     set_or_clear);
1472 }
1473
1474 /**
1475  * zfcp_erp_modify_unit_status - change unit status bits
1476  * @unit: unit to change the status bits
1477  * @id: id for the debug trace
1478  * @ref: reference for the debug trace
1479  * @mask: status bits to change
1480  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1481  */
1482 void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, char *id, void *ref,
1483                                  u32 mask, int set_or_clear)
1484 {
1485         if (set_or_clear == ZFCP_SET) {
1486                 if (status_change_set(mask, &unit->status))
1487                         zfcp_dbf_rec_unit(id, ref, unit);
1488                 atomic_set_mask(mask, &unit->status);
1489         } else {
1490                 if (status_change_clear(mask, &unit->status))
1491                         zfcp_dbf_rec_unit(id, ref, unit);
1492                 atomic_clear_mask(mask, &unit->status);
1493                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1494                         atomic_set(&unit->erp_counter, 0);
1495                 }
1496         }
1497 }
1498
1499 /**
1500  * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
1501  * @port: The "boxed" port.
1502  * @id: The debug trace id.
1503  * @id: Reference for the debug trace.
1504  */
1505 void zfcp_erp_port_boxed(struct zfcp_port *port, char *id, void *ref)
1506 {
1507         unsigned long flags;
1508
1509         read_lock_irqsave(&zfcp_data.config_lock, flags);
1510         zfcp_erp_modify_port_status(port, id, ref,
1511                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1512         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1513         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1514 }
1515
1516 /**
1517  * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
1518  * @port: The "boxed" unit.
1519  * @id: The debug trace id.
1520  * @id: Reference for the debug trace.
1521  */
1522 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, char *id, void *ref)
1523 {
1524         zfcp_erp_modify_unit_status(unit, id, ref,
1525                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1526         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1527 }
1528
1529 /**
1530  * zfcp_erp_port_access_denied - Adapter denied access to port.
1531  * @port: port where access has been denied
1532  * @id: id for debug trace
1533  * @ref: reference for debug trace
1534  *
1535  * Since the adapter has denied access, stop using the port and the
1536  * attached units.
1537  */
1538 void zfcp_erp_port_access_denied(struct zfcp_port *port, char *id, void *ref)
1539 {
1540         unsigned long flags;
1541
1542         read_lock_irqsave(&zfcp_data.config_lock, flags);
1543         zfcp_erp_modify_port_status(port, id, ref,
1544                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1545                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1546         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1547 }
1548
1549 /**
1550  * zfcp_erp_unit_access_denied - Adapter denied access to unit.
1551  * @unit: unit where access has been denied
1552  * @id: id for debug trace
1553  * @ref: reference for debug trace
1554  *
1555  * Since the adapter has denied access, stop using the unit.
1556  */
1557 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, char *id, void *ref)
1558 {
1559         zfcp_erp_modify_unit_status(unit, id, ref,
1560                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1561                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1562 }
1563
1564 static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, char *id,
1565                                          void *ref)
1566 {
1567         int status = atomic_read(&unit->status);
1568         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1569                         ZFCP_STATUS_COMMON_ACCESS_BOXED)))
1570                 return;
1571
1572         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1573 }
1574
1575 static void zfcp_erp_port_access_changed(struct zfcp_port *port, char *id,
1576                                          void *ref)
1577 {
1578         struct zfcp_unit *unit;
1579         int status = atomic_read(&port->status);
1580
1581         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1582                         ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
1583                 list_for_each_entry(unit, &port->unit_list_head, list)
1584                                     zfcp_erp_unit_access_changed(unit, id, ref);
1585                 return;
1586         }
1587
1588         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1589 }
1590
1591 /**
1592  * zfcp_erp_adapter_access_changed - Process change in adapter ACT
1593  * @adapter: Adapter where the Access Control Table (ACT) changed
1594  * @id: Id for debug trace
1595  * @ref: Reference for debug trace
1596  */
1597 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, char *id,
1598                                      void *ref)
1599 {
1600         struct zfcp_port *port;
1601         unsigned long flags;
1602
1603         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
1604                 return;
1605
1606         read_lock_irqsave(&zfcp_data.config_lock, flags);
1607         list_for_each_entry(port, &adapter->port_list_head, list)
1608                 zfcp_erp_port_access_changed(port, id, ref);
1609         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1610 }