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