drivers/s390/scsi/zfcp_erp.c

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