drivers/s390/scsi/zfcp_erp.c

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