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_set_mask(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_set_mask(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_set_mask(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_set_mask(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_set_mask(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_set_mask(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_set_mask(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_clear_mask(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_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
 669
 670         for (retries = 7; retries; retries--) {
 671                 atomic_clear_mask(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_clear_mask(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_clear_mask(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, GFP_KERNEL))
 742                 return ZFCP_ERP_FAILED;
 743
 744         if (mempool_resize(act->adapter->pool.status_read_req,
 745                            act->adapter->stat_read_buf_num, GFP_KERNEL))
 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_clear_mask(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_clear_mask(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_set_mask(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 void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
 825 {
 826         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status);
 827 }
 828
 829 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 830 {
 831         struct zfcp_port *port = erp_action->port;
 832         int status = atomic_read(&port->status);
 833
 834         switch (erp_action->step) {
 835         case ZFCP_ERP_STEP_UNINITIALIZED:
 836                 zfcp_erp_port_strategy_clearstati(port);
 837                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
 838                     (status & ZFCP_STATUS_COMMON_OPEN))
 839                         return zfcp_erp_port_forced_strategy_close(erp_action);
 840                 else
 841                         return ZFCP_ERP_FAILED;
 842
 843         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 844                 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
 845                         return ZFCP_ERP_SUCCEEDED;
 846         }
 847         return ZFCP_ERP_FAILED;
 848 }
 849
 850 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
 851 {
 852         int retval;
 853
 854         retval = zfcp_fsf_close_port(erp_action);
 855         if (retval == -ENOMEM)
 856                 return ZFCP_ERP_NOMEM;
 857         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
 858         if (retval)
 859                 return ZFCP_ERP_FAILED;
 860         return ZFCP_ERP_CONTINUES;
 861 }
 862
 863 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
 864 {
 865         int retval;
 866
 867         retval = zfcp_fsf_open_port(erp_action);
 868         if (retval == -ENOMEM)
 869                 return ZFCP_ERP_NOMEM;
 870         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
 871         if (retval)
 872                 return ZFCP_ERP_FAILED;
 873         return ZFCP_ERP_CONTINUES;
 874 }
 875
 876 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
 877 {
 878         struct zfcp_adapter *adapter = act->adapter;
 879         struct zfcp_port *port = act->port;
 880
 881         if (port->wwpn != adapter->peer_wwpn) {
 882                 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
 883                 return ZFCP_ERP_FAILED;
 884         }
 885         port->d_id = adapter->peer_d_id;
 886         return zfcp_erp_port_strategy_open_port(act);
 887 }
 888
 889 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
 890 {
 891         struct zfcp_adapter *adapter = act->adapter;
 892         struct zfcp_port *port = act->port;
 893         int p_status = atomic_read(&port->status);
 894
 895         switch (act->step) {
 896         case ZFCP_ERP_STEP_UNINITIALIZED:
 897         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 898         case ZFCP_ERP_STEP_PORT_CLOSING:
 899                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 900                         return zfcp_erp_open_ptp_port(act);
 901                 if (!port->d_id) {
 902                         zfcp_fc_trigger_did_lookup(port);
 903                         return ZFCP_ERP_EXIT;
 904                 }
 905                 return zfcp_erp_port_strategy_open_port(act);
 906
 907         case ZFCP_ERP_STEP_PORT_OPENING:
 908                 /* D_ID might have changed during open */
 909                 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
 910                         if (!port->d_id) {
 911                                 zfcp_fc_trigger_did_lookup(port);
 912                                 return ZFCP_ERP_EXIT;
 913                         }
 914                         return ZFCP_ERP_SUCCEEDED;
 915                 }
 916                 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
 917                         port->d_id = 0;
 918                         return ZFCP_ERP_FAILED;
 919                 }
 920                 /* fall through otherwise */
 921         }
 922         return ZFCP_ERP_FAILED;
 923 }
 924
 925 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
 926 {
 927         struct zfcp_port *port = erp_action->port;
 928         int p_status = atomic_read(&port->status);
 929
 930         if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
 931             !(p_status & ZFCP_STATUS_COMMON_OPEN))
 932                 goto close_init_done;
 933
 934         switch (erp_action->step) {
 935         case ZFCP_ERP_STEP_UNINITIALIZED:
 936                 zfcp_erp_port_strategy_clearstati(port);
 937                 if (p_status & ZFCP_STATUS_COMMON_OPEN)
 938                         return zfcp_erp_port_strategy_close(erp_action);
 939                 break;
 940
 941         case ZFCP_ERP_STEP_PORT_CLOSING:
 942                 if (p_status & ZFCP_STATUS_COMMON_OPEN)
 943                         return ZFCP_ERP_FAILED;
 944                 break;
 945         }
 946
 947 close_init_done:
 948         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 949                 return ZFCP_ERP_EXIT;
 950
 951         return zfcp_erp_port_strategy_open_common(erp_action);
 952 }
 953
 954 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
 955 {
 956         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 957
 958         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
 959                           &zfcp_sdev->status);
 960 }
 961
 962 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
 963 {
 964         int retval = zfcp_fsf_close_lun(erp_action);
 965         if (retval == -ENOMEM)
 966                 return ZFCP_ERP_NOMEM;
 967         erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
 968         if (retval)
 969                 return ZFCP_ERP_FAILED;
 970         return ZFCP_ERP_CONTINUES;
 971 }
 972
 973 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
 974 {
 975         int retval = zfcp_fsf_open_lun(erp_action);
 976         if (retval == -ENOMEM)
 977                 return ZFCP_ERP_NOMEM;
 978         erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
 979         if (retval)
 980                 return  ZFCP_ERP_FAILED;
 981         return ZFCP_ERP_CONTINUES;
 982 }
 983
 984 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
 985 {
 986         struct scsi_device *sdev = erp_action->sdev;
 987         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 988
 989         switch (erp_action->step) {
 990         case ZFCP_ERP_STEP_UNINITIALIZED:
 991                 zfcp_erp_lun_strategy_clearstati(sdev);
 992                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
 993                         return zfcp_erp_lun_strategy_close(erp_action);
 994                 /* already closed, fall through */
 995         case ZFCP_ERP_STEP_LUN_CLOSING:
 996                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
 997                         return ZFCP_ERP_FAILED;
 998                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 999                         return ZFCP_ERP_EXIT;
1000                 return zfcp_erp_lun_strategy_open(erp_action);
1001
1002         case ZFCP_ERP_STEP_LUN_OPENING:
1003                 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1004                         return ZFCP_ERP_SUCCEEDED;
1005         }
1006         return ZFCP_ERP_FAILED;
1007 }
1008
1009 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
1010 {
1011         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1012
1013         switch (result) {
1014         case ZFCP_ERP_SUCCEEDED :
1015                 atomic_set(&zfcp_sdev->erp_counter, 0);
1016                 zfcp_erp_lun_unblock(sdev);
1017                 break;
1018         case ZFCP_ERP_FAILED :
1019                 atomic_inc(&zfcp_sdev->erp_counter);
1020                 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1021                         dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1022                                 "ERP failed for LUN 0x%016Lx on "
1023                                 "port 0x%016Lx\n",
1024                                 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1025                                 (unsigned long long)zfcp_sdev->port->wwpn);
1026                         zfcp_erp_set_lun_status(sdev,
1027                                                 ZFCP_STATUS_COMMON_ERP_FAILED);
1028                 }
1029                 break;
1030         }
1031
1032         if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1033                 zfcp_erp_lun_block(sdev, 0);
1034                 result = ZFCP_ERP_EXIT;
1035         }
1036         return result;
1037 }
1038
1039 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1040 {
1041         switch (result) {
1042         case ZFCP_ERP_SUCCEEDED :
1043                 atomic_set(&port->erp_counter, 0);
1044                 zfcp_erp_port_unblock(port);
1045                 break;
1046
1047         case ZFCP_ERP_FAILED :
1048                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1049                         zfcp_erp_port_block(port, 0);
1050                         result = ZFCP_ERP_EXIT;
1051                 }
1052                 atomic_inc(&port->erp_counter);
1053                 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1054                         dev_err(&port->adapter->ccw_device->dev,
1055                                 "ERP failed for remote port 0x%016Lx\n",
1056                                 (unsigned long long)port->wwpn);
1057                         zfcp_erp_set_port_status(port,
1058                                          ZFCP_STATUS_COMMON_ERP_FAILED);
1059                 }
1060                 break;
1061         }
1062
1063         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1064                 zfcp_erp_port_block(port, 0);
1065                 result = ZFCP_ERP_EXIT;
1066         }
1067         return result;
1068 }
1069
1070 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1071                                            int result)
1072 {
1073         switch (result) {
1074         case ZFCP_ERP_SUCCEEDED :
1075                 atomic_set(&adapter->erp_counter, 0);
1076                 zfcp_erp_adapter_unblock(adapter);
1077                 break;
1078
1079         case ZFCP_ERP_FAILED :
1080                 atomic_inc(&adapter->erp_counter);
1081                 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1082                         dev_err(&adapter->ccw_device->dev,
1083                                 "ERP cannot recover an error "
1084                                 "on the FCP device\n");
1085                         zfcp_erp_set_adapter_status(adapter,
1086                                             ZFCP_STATUS_COMMON_ERP_FAILED);
1087                 }
1088                 break;
1089         }
1090
1091         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1092                 zfcp_erp_adapter_block(adapter, 0);
1093                 result = ZFCP_ERP_EXIT;
1094         }
1095         return result;
1096 }
1097
1098 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1099                                           int result)
1100 {
1101         struct zfcp_adapter *adapter = erp_action->adapter;
1102         struct zfcp_port *port = erp_action->port;
1103         struct scsi_device *sdev = erp_action->sdev;
1104
1105         switch (erp_action->action) {
1106
1107         case ZFCP_ERP_ACTION_REOPEN_LUN:
1108                 result = zfcp_erp_strategy_check_lun(sdev, result);
1109                 break;
1110
1111         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1112         case ZFCP_ERP_ACTION_REOPEN_PORT:
1113                 result = zfcp_erp_strategy_check_port(port, result);
1114                 break;
1115
1116         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1117                 result = zfcp_erp_strategy_check_adapter(adapter, result);
1118                 break;
1119         }
1120         return result;
1121 }
1122
1123 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1124 {
1125         int status = atomic_read(target_status);
1126
1127         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1128             (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1129                 return 1; /* take it online */
1130
1131         if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1132             !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1133                 return 1; /* take it offline */
1134
1135         return 0;
1136 }
1137
1138 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1139 {
1140         int action = act->action;
1141         struct zfcp_adapter *adapter = act->adapter;
1142         struct zfcp_port *port = act->port;
1143         struct scsi_device *sdev = act->sdev;
1144         struct zfcp_scsi_dev *zfcp_sdev;
1145         u32 erp_status = act->status;
1146
1147         switch (action) {
1148         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1149                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1150                         _zfcp_erp_adapter_reopen(adapter,
1151                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
1152                                                  "ersscg1");
1153                         return ZFCP_ERP_EXIT;
1154                 }
1155                 break;
1156
1157         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1158         case ZFCP_ERP_ACTION_REOPEN_PORT:
1159                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1160                         _zfcp_erp_port_reopen(port,
1161                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1162                                               "ersscg2");
1163                         return ZFCP_ERP_EXIT;
1164                 }
1165                 break;
1166
1167         case ZFCP_ERP_ACTION_REOPEN_LUN:
1168                 zfcp_sdev = sdev_to_zfcp(sdev);
1169                 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1170                         _zfcp_erp_lun_reopen(sdev,
1171                                              ZFCP_STATUS_COMMON_ERP_FAILED,
1172                                              "ersscg3", 0);
1173                         return ZFCP_ERP_EXIT;
1174                 }
1175                 break;
1176         }
1177         return ret;
1178 }
1179
1180 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1181 {
1182         struct zfcp_adapter *adapter = erp_action->adapter;
1183         struct zfcp_scsi_dev *zfcp_sdev;
1184
1185         adapter->erp_total_count--;
1186         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1187                 adapter->erp_low_mem_count--;
1188                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1189         }
1190
1191         list_del(&erp_action->list);
1192         zfcp_dbf_rec_run("eractd1", erp_action);
1193
1194         switch (erp_action->action) {
1195         case ZFCP_ERP_ACTION_REOPEN_LUN:
1196                 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1197                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1198                                   &zfcp_sdev->status);
1199                 break;
1200
1201         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1202         case ZFCP_ERP_ACTION_REOPEN_PORT:
1203                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1204                                   &erp_action->port->status);
1205                 break;
1206
1207         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1208                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1209                                   &erp_action->adapter->status);
1210                 break;
1211         }
1212 }
1213
1214 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1215 {
1216         struct zfcp_adapter *adapter = act->adapter;
1217         struct zfcp_port *port = act->port;
1218         struct scsi_device *sdev = act->sdev;
1219
1220         switch (act->action) {
1221         case ZFCP_ERP_ACTION_REOPEN_LUN:
1222                 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1223                         scsi_device_put(sdev);
1224                 break;
1225
1226         case ZFCP_ERP_ACTION_REOPEN_PORT:
1227                 if (result == ZFCP_ERP_SUCCEEDED)
1228                         zfcp_scsi_schedule_rport_register(port);
1229                 /* fall through */
1230         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1231                 put_device(&port->dev);
1232                 break;
1233
1234         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1235                 if (result == ZFCP_ERP_SUCCEEDED) {
1236                         register_service_level(&adapter->service_level);
1237                         zfcp_fc_conditional_port_scan(adapter);
1238                         queue_work(adapter->work_queue, &adapter->ns_up_work);
1239                 } else
1240                         unregister_service_level(&adapter->service_level);
1241
1242                 kref_put(&adapter->ref, zfcp_adapter_release);
1243                 break;
1244         }
1245 }
1246
1247 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1248 {
1249         switch (erp_action->action) {
1250         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1251                 return zfcp_erp_adapter_strategy(erp_action);
1252         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1253                 return zfcp_erp_port_forced_strategy(erp_action);
1254         case ZFCP_ERP_ACTION_REOPEN_PORT:
1255                 return zfcp_erp_port_strategy(erp_action);
1256         case ZFCP_ERP_ACTION_REOPEN_LUN:
1257                 return zfcp_erp_lun_strategy(erp_action);
1258         }
1259         return ZFCP_ERP_FAILED;
1260 }
1261
1262 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1263 {
1264         int retval;
1265         unsigned long flags;
1266         struct zfcp_adapter *adapter = erp_action->adapter;
1267
1268         kref_get(&adapter->ref);
1269
1270         write_lock_irqsave(&adapter->erp_lock, flags);
1271         zfcp_erp_strategy_check_fsfreq(erp_action);
1272
1273         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1274                 zfcp_erp_action_dequeue(erp_action);
1275                 retval = ZFCP_ERP_DISMISSED;
1276                 goto unlock;
1277         }
1278
1279         if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1280                 retval = ZFCP_ERP_FAILED;
1281                 goto check_target;
1282         }
1283
1284         zfcp_erp_action_to_running(erp_action);
1285
1286         /* no lock to allow for blocking operations */
1287         write_unlock_irqrestore(&adapter->erp_lock, flags);
1288         retval = zfcp_erp_strategy_do_action(erp_action);
1289         write_lock_irqsave(&adapter->erp_lock, flags);
1290
1291         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1292                 retval = ZFCP_ERP_CONTINUES;
1293
1294         switch (retval) {
1295         case ZFCP_ERP_NOMEM:
1296                 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1297                         ++adapter->erp_low_mem_count;
1298                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1299                 }
1300                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1301                         _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1302                 else {
1303                         zfcp_erp_strategy_memwait(erp_action);
1304                         retval = ZFCP_ERP_CONTINUES;
1305                 }
1306                 goto unlock;
1307
1308         case ZFCP_ERP_CONTINUES:
1309                 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1310                         --adapter->erp_low_mem_count;
1311                         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1312                 }
1313                 goto unlock;
1314         }
1315
1316 check_target:
1317         retval = zfcp_erp_strategy_check_target(erp_action, retval);
1318         zfcp_erp_action_dequeue(erp_action);
1319         retval = zfcp_erp_strategy_statechange(erp_action, retval);
1320         if (retval == ZFCP_ERP_EXIT)
1321                 goto unlock;
1322         if (retval == ZFCP_ERP_SUCCEEDED)
1323                 zfcp_erp_strategy_followup_success(erp_action);
1324         if (retval == ZFCP_ERP_FAILED)
1325                 zfcp_erp_strategy_followup_failed(erp_action);
1326
1327  unlock:
1328         write_unlock_irqrestore(&adapter->erp_lock, flags);
1329
1330         if (retval != ZFCP_ERP_CONTINUES)
1331                 zfcp_erp_action_cleanup(erp_action, retval);
1332
1333         kref_put(&adapter->ref, zfcp_adapter_release);
1334         return retval;
1335 }
1336
1337 static int zfcp_erp_thread(void *data)
1338 {
1339         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1340         struct list_head *next;
1341         struct zfcp_erp_action *act;
1342         unsigned long flags;
1343
1344         for (;;) {
1345                 wait_event_interruptible(adapter->erp_ready_wq,
1346                            !list_empty(&adapter->erp_ready_head) ||
1347                            kthread_should_stop());
1348
1349                 if (kthread_should_stop())
1350                         break;
1351
1352                 write_lock_irqsave(&adapter->erp_lock, flags);
1353                 next = adapter->erp_ready_head.next;
1354                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1355
1356                 if (next != &adapter->erp_ready_head) {
1357                         act = list_entry(next, struct zfcp_erp_action, list);
1358
1359                         /* there is more to come after dismission, no notify */
1360                         if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1361                                 zfcp_erp_wakeup(adapter);
1362                 }
1363         }
1364
1365         return 0;
1366 }
1367
1368 /**
1369  * zfcp_erp_thread_setup - Start ERP thread for adapter
1370  * @adapter: Adapter to start the ERP thread for
1371  *
1372  * Returns 0 on success or error code from kernel_thread()
1373  */
1374 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1375 {
1376         struct task_struct *thread;
1377
1378         thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1379                              dev_name(&adapter->ccw_device->dev));
1380         if (IS_ERR(thread)) {
1381                 dev_err(&adapter->ccw_device->dev,
1382                         "Creating an ERP thread for the FCP device failed.\n");
1383                 return PTR_ERR(thread);
1384         }
1385
1386         adapter->erp_thread = thread;
1387         return 0;
1388 }
1389
1390 /**
1391  * zfcp_erp_thread_kill - Stop ERP thread.
1392  * @adapter: Adapter where the ERP thread should be stopped.
1393  *
1394  * The caller of this routine ensures that the specified adapter has
1395  * been shut down and that this operation has been completed. Thus,
1396  * there are no pending erp_actions which would need to be handled
1397  * here.
1398  */
1399 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1400 {
1401         kthread_stop(adapter->erp_thread);
1402         adapter->erp_thread = NULL;
1403         WARN_ON(!list_empty(&adapter->erp_ready_head));
1404         WARN_ON(!list_empty(&adapter->erp_running_head));
1405 }
1406
1407 /**
1408  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1409  * @adapter: adapter for which to wait for completion of its error recovery
1410  */
1411 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1412 {
1413         wait_event(adapter->erp_done_wqh,
1414                    !(atomic_read(&adapter->status) &
1415                         ZFCP_STATUS_ADAPTER_ERP_PENDING));
1416 }
1417
1418 /**
1419  * zfcp_erp_set_adapter_status - set adapter status bits
1420  * @adapter: adapter to change the status
1421  * @mask: status bits to change
1422  *
1423  * Changes in common status bits are propagated to attached ports and LUNs.
1424  */
1425 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1426 {
1427         struct zfcp_port *port;
1428         struct scsi_device *sdev;
1429         unsigned long flags;
1430         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1431
1432         atomic_set_mask(mask, &adapter->status);
1433
1434         if (!common_mask)
1435                 return;
1436
1437         read_lock_irqsave(&adapter->port_list_lock, flags);
1438         list_for_each_entry(port, &adapter->port_list, list)
1439                 atomic_set_mask(common_mask, &port->status);
1440         read_unlock_irqrestore(&adapter->port_list_lock, flags);
1441
1442         spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1443         __shost_for_each_device(sdev, adapter->scsi_host)
1444                 atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1445         spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1446 }
1447
1448 /**
1449  * zfcp_erp_clear_adapter_status - clear adapter status bits
1450  * @adapter: adapter to change the status
1451  * @mask: status bits to change
1452  *
1453  * Changes in common status bits are propagated to attached ports and LUNs.
1454  */
1455 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1456 {
1457         struct zfcp_port *port;
1458         struct scsi_device *sdev;
1459         unsigned long flags;
1460         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1461         u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1462
1463         atomic_clear_mask(mask, &adapter->status);
1464
1465         if (!common_mask)
1466                 return;
1467
1468         if (clear_counter)
1469                 atomic_set(&adapter->erp_counter, 0);
1470
1471         read_lock_irqsave(&adapter->port_list_lock, flags);
1472         list_for_each_entry(port, &adapter->port_list, list) {
1473                 atomic_clear_mask(common_mask, &port->status);
1474                 if (clear_counter)
1475                         atomic_set(&port->erp_counter, 0);
1476         }
1477         read_unlock_irqrestore(&adapter->port_list_lock, flags);
1478
1479         spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1480         __shost_for_each_device(sdev, adapter->scsi_host) {
1481                 atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
1482                 if (clear_counter)
1483                         atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1484         }
1485         spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1486 }
1487
1488 /**
1489  * zfcp_erp_set_port_status - set port status bits
1490  * @port: port to change the status
1491  * @mask: status bits to change
1492  *
1493  * Changes in common status bits are propagated to attached LUNs.
1494  */
1495 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1496 {
1497         struct scsi_device *sdev;
1498         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1499         unsigned long flags;
1500
1501         atomic_set_mask(mask, &port->status);
1502
1503         if (!common_mask)
1504                 return;
1505
1506         spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1507         __shost_for_each_device(sdev, port->adapter->scsi_host)
1508                 if (sdev_to_zfcp(sdev)->port == port)
1509                         atomic_set_mask(common_mask,
1510                                         &sdev_to_zfcp(sdev)->status);
1511         spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1512 }
1513
1514 /**
1515  * zfcp_erp_clear_port_status - clear port status bits
1516  * @port: adapter to change the status
1517  * @mask: status bits to change
1518  *
1519  * Changes in common status bits are propagated to attached LUNs.
1520  */
1521 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1522 {
1523         struct scsi_device *sdev;
1524         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1525         u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1526         unsigned long flags;
1527
1528         atomic_clear_mask(mask, &port->status);
1529
1530         if (!common_mask)
1531                 return;
1532
1533         if (clear_counter)
1534                 atomic_set(&port->erp_counter, 0);
1535
1536         spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1537         __shost_for_each_device(sdev, port->adapter->scsi_host)
1538                 if (sdev_to_zfcp(sdev)->port == port) {
1539                         atomic_clear_mask(common_mask,
1540                                           &sdev_to_zfcp(sdev)->status);
1541                         if (clear_counter)
1542                                 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1543                 }
1544         spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1545 }
1546
1547 /**
1548  * zfcp_erp_set_lun_status - set lun status bits
1549  * @sdev: SCSI device / lun to set the status bits
1550  * @mask: status bits to change
1551  */
1552 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1553 {
1554         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1555
1556         atomic_set_mask(mask, &zfcp_sdev->status);
1557 }
1558
1559 /**
1560  * zfcp_erp_clear_lun_status - clear lun status bits
1561  * @sdev: SCSi device / lun to clear the status bits
1562  * @mask: status bits to change
1563  */
1564 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1565 {
1566         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1567
1568         atomic_clear_mask(mask, &zfcp_sdev->status);
1569
1570         if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1571                 atomic_set(&zfcp_sdev->erp_counter, 0);
1572 }
1573