drivers/s390/scsi/zfcp_erp.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Error Recovery Procedures (ERP).
   5  *
   6  * Copyright IBM Corp. 2002, 2010
   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         init_timer(&erp_action->timer);
 576         erp_action->timer.function = zfcp_erp_memwait_handler;
 577         erp_action->timer.data = (unsigned long) erp_action;
 578         erp_action->timer.expires = jiffies + HZ;
 579         add_timer(&erp_action->timer);
 580 }
 581
 582 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
 583                                       int clear, char *id)
 584 {
 585         struct zfcp_port *port;
 586
 587         read_lock(&adapter->port_list_lock);
 588         list_for_each_entry(port, &adapter->port_list, list)
 589                 _zfcp_erp_port_reopen(port, clear, id);
 590         read_unlock(&adapter->port_list_lock);
 591 }
 592
 593 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
 594                                      char *id)
 595 {
 596         struct scsi_device *sdev;
 597
 598         spin_lock(port->adapter->scsi_host->host_lock);
 599         __shost_for_each_device(sdev, port->adapter->scsi_host)
 600                 if (sdev_to_zfcp(sdev)->port == port)
 601                         _zfcp_erp_lun_reopen(sdev, clear, id, 0);
 602         spin_unlock(port->adapter->scsi_host->host_lock);
 603 }
 604
 605 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
 606 {
 607         switch (act->action) {
 608         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 609                 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
 610                 break;
 611         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 612                 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
 613                 break;
 614         case ZFCP_ERP_ACTION_REOPEN_PORT:
 615                 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
 616                 break;
 617         case ZFCP_ERP_ACTION_REOPEN_LUN:
 618                 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
 619                 break;
 620         }
 621 }
 622
 623 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
 624 {
 625         switch (act->action) {
 626         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 627                 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
 628                 break;
 629         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 630                 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
 631                 break;
 632         case ZFCP_ERP_ACTION_REOPEN_PORT:
 633                 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
 634                 break;
 635         }
 636 }
 637
 638 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
 639 {
 640         unsigned long flags;
 641
 642         read_lock_irqsave(&adapter->erp_lock, flags);
 643         if (list_empty(&adapter->erp_ready_head) &&
 644             list_empty(&adapter->erp_running_head)) {
 645                         atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
 646                                           &adapter->status);
 647                         wake_up(&adapter->erp_done_wqh);
 648         }
 649         read_unlock_irqrestore(&adapter->erp_lock, flags);
 650 }
 651
 652 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
 653 {
 654         struct zfcp_port *port;
 655         port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
 656                                  adapter->peer_d_id);
 657         if (IS_ERR(port)) /* error or port already attached */
 658                 return;
 659         _zfcp_erp_port_reopen(port, 0, "ereptp1");
 660 }
 661
 662 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
 663 {
 664         int retries;
 665         int sleep = 1;
 666         struct zfcp_adapter *adapter = erp_action->adapter;
 667
 668         atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
 669
 670         for (retries = 7; retries; retries--) {
 671                 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 672                                   &adapter->status);
 673                 write_lock_irq(&adapter->erp_lock);
 674                 zfcp_erp_action_to_running(erp_action);
 675                 write_unlock_irq(&adapter->erp_lock);
 676                 if (zfcp_fsf_exchange_config_data(erp_action)) {
 677                         atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 678                                           &adapter->status);
 679                         return ZFCP_ERP_FAILED;
 680                 }
 681
 682                 wait_event(adapter->erp_ready_wq,
 683                            !list_empty(&adapter->erp_ready_head));
 684                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
 685                         break;
 686
 687                 if (!(atomic_read(&adapter->status) &
 688                       ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
 689                         break;
 690
 691                 ssleep(sleep);
 692                 sleep *= 2;
 693         }
 694
 695         atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 696                           &adapter->status);
 697
 698         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
 699                 return ZFCP_ERP_FAILED;
 700
 701         if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 702                 zfcp_erp_enqueue_ptp_port(adapter);
 703
 704         return ZFCP_ERP_SUCCEEDED;
 705 }
 706
 707 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
 708 {
 709         int ret;
 710         struct zfcp_adapter *adapter = act->adapter;
 711
 712         write_lock_irq(&adapter->erp_lock);
 713         zfcp_erp_action_to_running(act);
 714         write_unlock_irq(&adapter->erp_lock);
 715
 716         ret = zfcp_fsf_exchange_port_data(act);
 717         if (ret == -EOPNOTSUPP)
 718                 return ZFCP_ERP_SUCCEEDED;
 719         if (ret)
 720                 return ZFCP_ERP_FAILED;
 721
 722         zfcp_dbf_rec_run("erasox1", act);
 723         wait_event(adapter->erp_ready_wq,
 724                    !list_empty(&adapter->erp_ready_head));
 725         zfcp_dbf_rec_run("erasox2", act);
 726         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
 727                 return ZFCP_ERP_FAILED;
 728
 729         return ZFCP_ERP_SUCCEEDED;
 730 }
 731
 732 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
 733 {
 734         if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
 735                 return ZFCP_ERP_FAILED;
 736
 737         if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
 738                 return ZFCP_ERP_FAILED;
 739
 740         if (mempool_resize(act->adapter->pool.sr_data,
 741                            act->adapter->stat_read_buf_num))
 742                 return ZFCP_ERP_FAILED;
 743
 744         if (mempool_resize(act->adapter->pool.status_read_req,
 745                            act->adapter->stat_read_buf_num))
 746                 return ZFCP_ERP_FAILED;
 747
 748         atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
 749         if (zfcp_status_read_refill(act->adapter))
 750                 return ZFCP_ERP_FAILED;
 751
 752         return ZFCP_ERP_SUCCEEDED;
 753 }
 754
 755 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
 756 {
 757         struct zfcp_adapter *adapter = act->adapter;
 758
 759         /* close queues to ensure that buffers are not accessed by adapter */
 760         zfcp_qdio_close(adapter->qdio);
 761         zfcp_fsf_req_dismiss_all(adapter);
 762         adapter->fsf_req_seq_no = 0;
 763         zfcp_fc_wka_ports_force_offline(adapter->gs);
 764         /* all ports and LUNs are closed */
 765         zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
 766
 767         atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
 768                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
 769 }
 770
 771 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
 772 {
 773         struct zfcp_adapter *adapter = act->adapter;
 774
 775         if (zfcp_qdio_open(adapter->qdio)) {
 776                 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
 777                                   ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
 778                                   &adapter->status);
 779                 return ZFCP_ERP_FAILED;
 780         }
 781
 782         if (zfcp_erp_adapter_strategy_open_fsf(act)) {
 783                 zfcp_erp_adapter_strategy_close(act);
 784                 return ZFCP_ERP_FAILED;
 785         }
 786
 787         atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
 788
 789         return ZFCP_ERP_SUCCEEDED;
 790 }
 791
 792 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
 793 {
 794         struct zfcp_adapter *adapter = act->adapter;
 795
 796         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
 797                 zfcp_erp_adapter_strategy_close(act);
 798                 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 799                         return ZFCP_ERP_EXIT;
 800         }
 801
 802         if (zfcp_erp_adapter_strategy_open(act)) {
 803                 ssleep(8);
 804                 return ZFCP_ERP_FAILED;
 805         }
 806
 807         return ZFCP_ERP_SUCCEEDED;
 808 }
 809
 810 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
 811 {
 812         int retval;
 813
 814         retval = zfcp_fsf_close_physical_port(act);
 815         if (retval == -ENOMEM)
 816                 return ZFCP_ERP_NOMEM;
 817         act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
 818         if (retval)
 819                 return ZFCP_ERP_FAILED;
 820
 821         return ZFCP_ERP_CONTINUES;
 822 }
 823
 824 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 825 {
 826         struct zfcp_port *port = erp_action->port;
 827         int status = atomic_read(&port->status);
 828
 829         switch (erp_action->step) {
 830         case ZFCP_ERP_STEP_UNINITIALIZED:
 831                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
 832                     (status & ZFCP_STATUS_COMMON_OPEN))
 833                         return zfcp_erp_port_forced_strategy_close(erp_action);
 834                 else
 835                         return ZFCP_ERP_FAILED;
 836
 837         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 838                 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
 839                         return ZFCP_ERP_SUCCEEDED;
 840         }
 841         return ZFCP_ERP_FAILED;
 842 }
 843
 844 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
 845 {
 846         int retval;
 847
 848         retval = zfcp_fsf_close_port(erp_action);
 849         if (retval == -ENOMEM)
 850                 return ZFCP_ERP_NOMEM;
 851         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
 852         if (retval)
 853                 return ZFCP_ERP_FAILED;
 854         return ZFCP_ERP_CONTINUES;
 855 }
 856
 857 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
 858 {
 859         int retval;
 860
 861         retval = zfcp_fsf_open_port(erp_action);
 862         if (retval == -ENOMEM)
 863                 return ZFCP_ERP_NOMEM;
 864         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
 865         if (retval)
 866                 return ZFCP_ERP_FAILED;
 867         return ZFCP_ERP_CONTINUES;
 868 }
 869
 870 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
 871 {
 872         struct zfcp_adapter *adapter = act->adapter;
 873         struct zfcp_port *port = act->port;
 874
 875         if (port->wwpn != adapter->peer_wwpn) {
 876                 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
 877                 return ZFCP_ERP_FAILED;
 878         }
 879         port->d_id = adapter->peer_d_id;
 880         return zfcp_erp_port_strategy_open_port(act);
 881 }
 882
 883 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
 884 {
 885         struct zfcp_adapter *adapter = act->adapter;
 886         struct zfcp_port *port = act->port;
 887         int p_status = atomic_read(&port->status);
 888
 889         switch (act->step) {
 890         case ZFCP_ERP_STEP_UNINITIALIZED:
 891         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 892         case ZFCP_ERP_STEP_PORT_CLOSING:
 893                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 894                         return zfcp_erp_open_ptp_port(act);
 895                 if (!port->d_id) {
 896                         zfcp_fc_trigger_did_lookup(port);
 897                         return ZFCP_ERP_EXIT;
 898                 }
 899                 return zfcp_erp_port_strategy_open_port(act);
 900
 901         case ZFCP_ERP_STEP_PORT_OPENING:
 902                 /* D_ID might have changed during open */
 903                 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
 904                         if (!port->d_id) {
 905                                 zfcp_fc_trigger_did_lookup(port);
 906                                 return ZFCP_ERP_EXIT;
 907                         }
 908                         return ZFCP_ERP_SUCCEEDED;
 909                 }
 910                 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
 911                         port->d_id = 0;
 912                         return ZFCP_ERP_FAILED;
 913                 }
 914                 /* fall through otherwise */
 915         }
 916         return ZFCP_ERP_FAILED;
 917 }
 918
 919 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
 920 {
 921         struct zfcp_port *port = erp_action->port;
 922         int p_status = atomic_read(&port->status);
 923
 924         if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
 925             !(p_status & ZFCP_STATUS_COMMON_OPEN))
 926                 goto close_init_done;
 927
 928         switch (erp_action->step) {
 929         case ZFCP_ERP_STEP_UNINITIALIZED:
 930                 if (p_status & ZFCP_STATUS_COMMON_OPEN)
 931                         return zfcp_erp_port_strategy_close(erp_action);
 932                 break;
 933
 934         case ZFCP_ERP_STEP_PORT_CLOSING:
 935                 if (p_status & ZFCP_STATUS_COMMON_OPEN)
 936                         return ZFCP_ERP_FAILED;
 937                 break;
 938         }
 939
 940 close_init_done:
 941         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 942                 return ZFCP_ERP_EXIT;
 943
 944         return zfcp_erp_port_strategy_open_common(erp_action);
 945 }
 946
 947 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
 948 {
 949         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 950
 951         atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
 952                           &zfcp_sdev->status);
 953 }
 954
 955 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
 956 {
 957         int retval = zfcp_fsf_close_lun(erp_action);
 958         if (retval == -ENOMEM)
 959                 return ZFCP_ERP_NOMEM;
 960         erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
 961         if (retval)
 962                 return ZFCP_ERP_FAILED;
 963         return ZFCP_ERP_CONTINUES;
 964 }
 965
 966 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
 967 {
 968         int retval = zfcp_fsf_open_lun(erp_action);
 969         if (retval == -ENOMEM)
 970                 return ZFCP_ERP_NOMEM;
 971         erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
 972         if (retval)
 973                 return  ZFCP_ERP_FAILED;
 974         return ZFCP_ERP_CONTINUES;
 975 }
 976
 977 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
 978 {
 979         struct scsi_device *sdev = erp_action->sdev;
 980         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 981
 982         switch (erp_action->step) {
 983         case ZFCP_ERP_STEP_UNINITIALIZED:
 984                 zfcp_erp_lun_strategy_clearstati(sdev);
 985                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
 986                         return zfcp_erp_lun_strategy_close(erp_action);
 987                 /* already closed, fall through */
 988         case ZFCP_ERP_STEP_LUN_CLOSING:
 989                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
 990                         return ZFCP_ERP_FAILED;
 991                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 992                         return ZFCP_ERP_EXIT;
 993                 return zfcp_erp_lun_strategy_open(erp_action);
 994
 995         case ZFCP_ERP_STEP_LUN_OPENING:
 996                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
 997                         return ZFCP_ERP_SUCCEEDED;
 998         }
 999         return ZFCP_ERP_FAILED;
1000 }
1001
1002 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
1003 {
1004         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1005
1006         switch (result) {
1007         case ZFCP_ERP_SUCCEEDED :
1008                 atomic_set(&zfcp_sdev->erp_counter, 0);
1009                 zfcp_erp_lun_unblock(sdev);
1010                 break;
1011         case ZFCP_ERP_FAILED :
1012                 atomic_inc(&zfcp_sdev->erp_counter);
1013                 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1014                         dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1015                                 "ERP failed for LUN 0x%016Lx on "
1016                                 "port 0x%016Lx\n",
1017                                 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1018                                 (unsigned long long)zfcp_sdev->port->wwpn);
1019                         zfcp_erp_set_lun_status(sdev,
1020                                                 ZFCP_STATUS_COMMON_ERP_FAILED);
1021                 }
1022                 break;
1023         }
1024
1025         if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1026                 zfcp_erp_lun_block(sdev, 0);
1027                 result = ZFCP_ERP_EXIT;
1028         }
1029         return result;
1030 }
1031
1032 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1033 {
1034         switch (result) {
1035         case ZFCP_ERP_SUCCEEDED :
1036                 atomic_set(&port->erp_counter, 0);
1037                 zfcp_erp_port_unblock(port);
1038                 break;
1039
1040         case ZFCP_ERP_FAILED :
1041                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1042                         zfcp_erp_port_block(port, 0);
1043                         result = ZFCP_ERP_EXIT;
1044                 }
1045                 atomic_inc(&port->erp_counter);
1046                 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1047                         dev_err(&port->adapter->ccw_device->dev,
1048                                 "ERP failed for remote port 0x%016Lx\n",
1049                                 (unsigned long long)port->wwpn);
1050                         zfcp_erp_set_port_status(port,
1051                                          ZFCP_STATUS_COMMON_ERP_FAILED);
1052                 }
1053                 break;
1054         }
1055
1056         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1057                 zfcp_erp_port_block(port, 0);
1058                 result = ZFCP_ERP_EXIT;
1059         }
1060         return result;
1061 }
1062
1063 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1064                                            int result)
1065 {
1066         switch (result) {
1067         case ZFCP_ERP_SUCCEEDED :
1068                 atomic_set(&adapter->erp_counter, 0);
1069                 zfcp_erp_adapter_unblock(adapter);
1070                 break;
1071
1072         case ZFCP_ERP_FAILED :
1073                 atomic_inc(&adapter->erp_counter);
1074                 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1075                         dev_err(&adapter->ccw_device->dev,
1076                                 "ERP cannot recover an error "
1077                                 "on the FCP device\n");
1078                         zfcp_erp_set_adapter_status(adapter,
1079                                             ZFCP_STATUS_COMMON_ERP_FAILED);
1080                 }
1081                 break;
1082         }
1083
1084         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1085                 zfcp_erp_adapter_block(adapter, 0);
1086                 result = ZFCP_ERP_EXIT;
1087         }
1088         return result;
1089 }
1090
1091 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1092                                           int result)
1093 {
1094         struct zfcp_adapter *adapter = erp_action->adapter;
1095         struct zfcp_port *port = erp_action->port;
1096         struct scsi_device *sdev = erp_action->sdev;
1097
1098         switch (erp_action->action) {
1099
1100         case ZFCP_ERP_ACTION_REOPEN_LUN:
1101                 result = zfcp_erp_strategy_check_lun(sdev, result);
1102                 break;
1103
1104         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1105         case ZFCP_ERP_ACTION_REOPEN_PORT:
1106                 result = zfcp_erp_strategy_check_port(port, result);
1107                 break;
1108
1109         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1110                 result = zfcp_erp_strategy_check_adapter(adapter, result);
1111                 break;
1112         }
1113         return result;
1114 }
1115
1116 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1117 {
1118         int status = atomic_read(target_status);
1119
1120         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1121             (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1122                 return 1; /* take it online */
1123
1124         if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1125             !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1126                 return 1; /* take it offline */
1127
1128         return 0;
1129 }
1130
1131 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1132 {
1133         int action = act->action;
1134         struct zfcp_adapter *adapter = act->adapter;
1135         struct zfcp_port *port = act->port;
1136         struct scsi_device *sdev = act->sdev;
1137         struct zfcp_scsi_dev *zfcp_sdev;
1138         u32 erp_status = act->status;
1139
1140         switch (action) {
1141         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1142                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1143                         _zfcp_erp_adapter_reopen(adapter,
1144                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
1145                                                  "ersscg1");
1146                         return ZFCP_ERP_EXIT;
1147                 }
1148                 break;
1149
1150         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1151         case ZFCP_ERP_ACTION_REOPEN_PORT:
1152                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1153                         _zfcp_erp_port_reopen(port,
1154                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1155                                               "ersscg2");
1156                         return ZFCP_ERP_EXIT;
1157                 }
1158                 break;
1159
1160         case ZFCP_ERP_ACTION_REOPEN_LUN:
1161                 zfcp_sdev = sdev_to_zfcp(sdev);
1162                 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1163                         _zfcp_erp_lun_reopen(sdev,
1164                                              ZFCP_STATUS_COMMON_ERP_FAILED,
1165                                              "ersscg3", 0);
1166                         return ZFCP_ERP_EXIT;
1167                 }
1168                 break;
1169         }
1170         return ret;
1171 }
1172
1173 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1174 {
1175         struct zfcp_adapter *adapter = erp_action->adapter;
1176         struct zfcp_scsi_dev *zfcp_sdev;
1177
1178         adapter->erp_total_count--;
1179         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1180                 adapter->erp_low_mem_count--;
1181                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1182         }
1183
1184         list_del(&erp_action->list);
1185         zfcp_dbf_rec_run("eractd1", erp_action);
1186
1187         switch (erp_action->action) {
1188         case ZFCP_ERP_ACTION_REOPEN_LUN:
1189                 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1190                 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1191                                   &zfcp_sdev->status);
1192                 break;
1193
1194         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1195         case ZFCP_ERP_ACTION_REOPEN_PORT:
1196                 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1197                                   &erp_action->port->status);
1198                 break;
1199
1200         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1201                 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1202                                   &erp_action->adapter->status);
1203                 break;
1204         }
1205 }
1206
1207 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1208 {
1209         struct zfcp_adapter *adapter = act->adapter;
1210         struct zfcp_port *port = act->port;
1211         struct scsi_device *sdev = act->sdev;
1212
1213         switch (act->action) {
1214         case ZFCP_ERP_ACTION_REOPEN_LUN:
1215                 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1216                         scsi_device_put(sdev);
1217                 break;
1218
1219         case ZFCP_ERP_ACTION_REOPEN_PORT:
1220                 if (result == ZFCP_ERP_SUCCEEDED)
1221                         zfcp_scsi_schedule_rport_register(port);
1222                 /* fall through */
1223         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1224                 put_device(&port->dev);
1225                 break;
1226
1227         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1228                 if (result == ZFCP_ERP_SUCCEEDED) {
1229                         register_service_level(&adapter->service_level);
1230                         zfcp_fc_conditional_port_scan(adapter);
1231                         queue_work(adapter->work_queue, &adapter->ns_up_work);
1232                 } else
1233                         unregister_service_level(&adapter->service_level);
1234
1235                 kref_put(&adapter->ref, zfcp_adapter_release);
1236                 break;
1237         }
1238 }
1239
1240 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1241 {
1242         switch (erp_action->action) {
1243         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1244                 return zfcp_erp_adapter_strategy(erp_action);
1245         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1246                 return zfcp_erp_port_forced_strategy(erp_action);
1247         case ZFCP_ERP_ACTION_REOPEN_PORT:
1248                 return zfcp_erp_port_strategy(erp_action);
1249         case ZFCP_ERP_ACTION_REOPEN_LUN:
1250                 return zfcp_erp_lun_strategy(erp_action);
1251         }
1252         return ZFCP_ERP_FAILED;
1253 }
1254
1255 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1256 {
1257         int retval;
1258         unsigned long flags;
1259         struct zfcp_adapter *adapter = erp_action->adapter;
1260
1261         kref_get(&adapter->ref);
1262
1263         write_lock_irqsave(&adapter->erp_lock, flags);
1264         zfcp_erp_strategy_check_fsfreq(erp_action);
1265
1266         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1267                 zfcp_erp_action_dequeue(erp_action);
1268                 retval = ZFCP_ERP_DISMISSED;
1269                 goto unlock;
1270         }
1271
1272         if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1273                 retval = ZFCP_ERP_FAILED;
1274                 goto check_target;
1275         }
1276
1277         zfcp_erp_action_to_running(erp_action);
1278
1279         /* no lock to allow for blocking operations */
1280         write_unlock_irqrestore(&adapter->erp_lock, flags);
1281         retval = zfcp_erp_strategy_do_action(erp_action);
1282         write_lock_irqsave(&adapter->erp_lock, flags);
1283
1284         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1285                 retval = ZFCP_ERP_CONTINUES;
1286
1287         switch (retval) {
1288         case ZFCP_ERP_NOMEM:
1289                 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1290                         ++adapter->erp_low_mem_count;
1291                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1292                 }
1293                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1294                         _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1295                 else {
1296                         zfcp_erp_strategy_memwait(erp_action);
1297                         retval = ZFCP_ERP_CONTINUES;
1298                 }
1299                 goto unlock;
1300
1301         case ZFCP_ERP_CONTINUES:
1302                 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1303                         --adapter->erp_low_mem_count;
1304                         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1305                 }
1306                 goto unlock;
1307         }
1308
1309 check_target:
1310         retval = zfcp_erp_strategy_check_target(erp_action, retval);
1311         zfcp_erp_action_dequeue(erp_action);
1312         retval = zfcp_erp_strategy_statechange(erp_action, retval);
1313         if (retval == ZFCP_ERP_EXIT)
1314                 goto unlock;
1315         if (retval == ZFCP_ERP_SUCCEEDED)
1316                 zfcp_erp_strategy_followup_success(erp_action);
1317         if (retval == ZFCP_ERP_FAILED)
1318                 zfcp_erp_strategy_followup_failed(erp_action);
1319
1320  unlock:
1321         write_unlock_irqrestore(&adapter->erp_lock, flags);
1322
1323         if (retval != ZFCP_ERP_CONTINUES)
1324                 zfcp_erp_action_cleanup(erp_action, retval);
1325
1326         kref_put(&adapter->ref, zfcp_adapter_release);
1327         return retval;
1328 }
1329
1330 static int zfcp_erp_thread(void *data)
1331 {
1332         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1333         struct list_head *next;
1334         struct zfcp_erp_action *act;
1335         unsigned long flags;
1336
1337         for (;;) {
1338                 wait_event_interruptible(adapter->erp_ready_wq,
1339                            !list_empty(&adapter->erp_ready_head) ||
1340                            kthread_should_stop());
1341
1342                 if (kthread_should_stop())
1343                         break;
1344
1345                 write_lock_irqsave(&adapter->erp_lock, flags);
1346                 next = adapter->erp_ready_head.next;
1347                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1348
1349                 if (next != &adapter->erp_ready_head) {
1350                         act = list_entry(next, struct zfcp_erp_action, list);
1351
1352                         /* there is more to come after dismission, no notify */
1353                         if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1354                                 zfcp_erp_wakeup(adapter);
1355                 }
1356         }
1357
1358         return 0;
1359 }
1360
1361 /**
1362  * zfcp_erp_thread_setup - Start ERP thread for adapter
1363  * @adapter: Adapter to start the ERP thread for
1364  *
1365  * Returns 0 on success or error code from kernel_thread()
1366  */
1367 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1368 {
1369         struct task_struct *thread;
1370
1371         thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1372                              dev_name(&adapter->ccw_device->dev));
1373         if (IS_ERR(thread)) {
1374                 dev_err(&adapter->ccw_device->dev,
1375                         "Creating an ERP thread for the FCP device failed.\n");
1376                 return PTR_ERR(thread);
1377         }
1378
1379         adapter->erp_thread = thread;
1380         return 0;
1381 }
1382
1383 /**
1384  * zfcp_erp_thread_kill - Stop ERP thread.
1385  * @adapter: Adapter where the ERP thread should be stopped.
1386  *
1387  * The caller of this routine ensures that the specified adapter has
1388  * been shut down and that this operation has been completed. Thus,
1389  * there are no pending erp_actions which would need to be handled
1390  * here.
1391  */
1392 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1393 {
1394         kthread_stop(adapter->erp_thread);
1395         adapter->erp_thread = NULL;
1396         WARN_ON(!list_empty(&adapter->erp_ready_head));
1397         WARN_ON(!list_empty(&adapter->erp_running_head));
1398 }
1399
1400 /**
1401  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1402  * @adapter: adapter for which to wait for completion of its error recovery
1403  */
1404 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1405 {
1406         wait_event(adapter->erp_done_wqh,
1407                    !(atomic_read(&adapter->status) &
1408                         ZFCP_STATUS_ADAPTER_ERP_PENDING));
1409 }
1410
1411 /**
1412  * zfcp_erp_set_adapter_status - set adapter status bits
1413  * @adapter: adapter to change the status
1414  * @mask: status bits to change
1415  *
1416  * Changes in common status bits are propagated to attached ports and LUNs.
1417  */
1418 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1419 {
1420         struct zfcp_port *port;
1421         struct scsi_device *sdev;
1422         unsigned long flags;
1423         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1424
1425         atomic_or(mask, &adapter->status);
1426
1427         if (!common_mask)
1428                 return;
1429
1430         read_lock_irqsave(&adapter->port_list_lock, flags);
1431         list_for_each_entry(port, &adapter->port_list, list)
1432                 atomic_or(common_mask, &port->status);
1433         read_unlock_irqrestore(&adapter->port_list_lock, flags);
1434
1435         spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1436         __shost_for_each_device(sdev, adapter->scsi_host)
1437                 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1438         spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1439 }
1440
1441 /**
1442  * zfcp_erp_clear_adapter_status - clear adapter status bits
1443  * @adapter: adapter to change the status
1444  * @mask: status bits to change
1445  *
1446  * Changes in common status bits are propagated to attached ports and LUNs.
1447  */
1448 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1449 {
1450         struct zfcp_port *port;
1451         struct scsi_device *sdev;
1452         unsigned long flags;
1453         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1454         u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1455
1456         atomic_andnot(mask, &adapter->status);
1457
1458         if (!common_mask)
1459                 return;
1460
1461         if (clear_counter)
1462                 atomic_set(&adapter->erp_counter, 0);
1463
1464         read_lock_irqsave(&adapter->port_list_lock, flags);
1465         list_for_each_entry(port, &adapter->port_list, list) {
1466                 atomic_andnot(common_mask, &port->status);
1467                 if (clear_counter)
1468                         atomic_set(&port->erp_counter, 0);
1469         }
1470         read_unlock_irqrestore(&adapter->port_list_lock, flags);
1471
1472         spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1473         __shost_for_each_device(sdev, adapter->scsi_host) {
1474                 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1475                 if (clear_counter)
1476                         atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1477         }
1478         spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1479 }
1480
1481 /**
1482  * zfcp_erp_set_port_status - set port status bits
1483  * @port: port to change the status
1484  * @mask: status bits to change
1485  *
1486  * Changes in common status bits are propagated to attached LUNs.
1487  */
1488 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1489 {
1490         struct scsi_device *sdev;
1491         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1492         unsigned long flags;
1493
1494         atomic_or(mask, &port->status);
1495
1496         if (!common_mask)
1497                 return;
1498
1499         spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1500         __shost_for_each_device(sdev, port->adapter->scsi_host)
1501                 if (sdev_to_zfcp(sdev)->port == port)
1502                         atomic_or(common_mask,
1503                                         &sdev_to_zfcp(sdev)->status);
1504         spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1505 }
1506
1507 /**
1508  * zfcp_erp_clear_port_status - clear port status bits
1509  * @port: adapter to change the status
1510  * @mask: status bits to change
1511  *
1512  * Changes in common status bits are propagated to attached LUNs.
1513  */
1514 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1515 {
1516         struct scsi_device *sdev;
1517         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1518         u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1519         unsigned long flags;
1520
1521         atomic_andnot(mask, &port->status);
1522
1523         if (!common_mask)
1524                 return;
1525
1526         if (clear_counter)
1527                 atomic_set(&port->erp_counter, 0);
1528
1529         spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1530         __shost_for_each_device(sdev, port->adapter->scsi_host)
1531                 if (sdev_to_zfcp(sdev)->port == port) {
1532                         atomic_andnot(common_mask,
1533                                           &sdev_to_zfcp(sdev)->status);
1534                         if (clear_counter)
1535                                 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1536                 }
1537         spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1538 }
1539
1540 /**
1541  * zfcp_erp_set_lun_status - set lun status bits
1542  * @sdev: SCSI device / lun to set the status bits
1543  * @mask: status bits to change
1544  */
1545 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1546 {
1547         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1548
1549         atomic_or(mask, &zfcp_sdev->status);
1550 }
1551
1552 /**
1553  * zfcp_erp_clear_lun_status - clear lun status bits
1554  * @sdev: SCSi device / lun to clear the status bits
1555  * @mask: status bits to change
1556  */
1557 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1558 {
1559         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1560
1561         atomic_andnot(mask, &zfcp_sdev->status);
1562
1563         if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1564                 atomic_set(&zfcp_sdev->erp_counter, 0);
1565 }
1566