drivers/s390/scsi/zfcp_erp.c

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