linux/drivers/s390/scsi/zfcp_erp.c
<<
>>
Prefs
   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
  21enum 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
  42enum 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
  51static 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
  57static 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
  67static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
  68{
  69        struct zfcp_adapter *adapter = act->adapter;
  70
  71        list_move(&act->list, &act->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
  77static 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
  84static 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
  92static 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
 107static 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
 121static 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
 161static 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
 213static 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
 281static 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
 318void 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
 339static 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 */
 355void 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 */
 375void 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 */
 388void 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
 394static 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
 400static 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 */
 416void 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
 427static 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 */
 443void 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
 453static 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
 459static 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 */
 479void 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 */
 497void 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 */
 513void 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
 528static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
 529{
 530        return (atomic_read(status) ^ mask) & mask;
 531}
 532
 533static 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
 541static 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
 549static 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
 559static 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
 565static 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 */
 599void 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 */
 616void 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
 630static 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
 637static 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
 644void 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
 658static 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
 669static 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
 681static 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
 699static 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
 717static 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
 731static 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
 741static 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
 784static void
 785zfcp_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
 791static 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
 817static enum zfcp_erp_act_result
 818zfcp_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
 870static 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
 900static 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
 916static 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
 938static 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
 957static 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
 972static 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
1000static 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
1014static 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
1028static 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
1041static 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
1083static 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
1111close_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
1118static 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
1126static 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
1138static 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
1150static 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
1183static 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
1220static 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
1258static 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
1292static 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
1317static 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
1332static 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
1375static 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 */
1413static 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
1468static 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
1509static 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
1525static 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
1586check_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
1607static int zfcp_erp_thread(void *data)
1608{
1609        struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1610        struct list_head *next;
1611        struct zfcp_erp_action *act;
1612        unsigned long flags;
1613
1614        for (;;) {
1615                wait_event_interruptible(adapter->erp_ready_wq,
1616                           !list_empty(&adapter->erp_ready_head) ||
1617                           kthread_should_stop());
1618
1619                if (kthread_should_stop())
1620                        break;
1621
1622                write_lock_irqsave(&adapter->erp_lock, flags);
1623                next = adapter->erp_ready_head.next;
1624                write_unlock_irqrestore(&adapter->erp_lock, flags);
1625
1626                if (next != &adapter->erp_ready_head) {
1627                        act = list_entry(next, struct zfcp_erp_action, list);
1628
1629                        /* there is more to come after dismission, no notify */
1630                        if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1631                                zfcp_erp_wakeup(adapter);
1632                }
1633        }
1634
1635        return 0;
1636}
1637
1638/**
1639 * zfcp_erp_thread_setup - Start ERP thread for adapter
1640 * @adapter: Adapter to start the ERP thread for
1641 *
1642 * Return: 0 on success, or error code from kthread_run().
1643 */
1644int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1645{
1646        struct task_struct *thread;
1647
1648        thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1649                             dev_name(&adapter->ccw_device->dev));
1650        if (IS_ERR(thread)) {
1651                dev_err(&adapter->ccw_device->dev,
1652                        "Creating an ERP thread for the FCP device failed.\n");
1653                return PTR_ERR(thread);
1654        }
1655
1656        adapter->erp_thread = thread;
1657        return 0;
1658}
1659
1660/**
1661 * zfcp_erp_thread_kill - Stop ERP thread.
1662 * @adapter: Adapter where the ERP thread should be stopped.
1663 *
1664 * The caller of this routine ensures that the specified adapter has
1665 * been shut down and that this operation has been completed. Thus,
1666 * there are no pending erp_actions which would need to be handled
1667 * here.
1668 */
1669void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1670{
1671        kthread_stop(adapter->erp_thread);
1672        adapter->erp_thread = NULL;
1673        WARN_ON(!list_empty(&adapter->erp_ready_head));
1674        WARN_ON(!list_empty(&adapter->erp_running_head));
1675}
1676
1677/**
1678 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1679 * @adapter: adapter for which to wait for completion of its error recovery
1680 */
1681void zfcp_erp_wait(struct zfcp_adapter *adapter)
1682{
1683        wait_event(adapter->erp_done_wqh,
1684                   !(atomic_read(&adapter->status) &
1685                        ZFCP_STATUS_ADAPTER_ERP_PENDING));
1686}
1687
1688/**
1689 * zfcp_erp_set_adapter_status - set adapter status bits
1690 * @adapter: adapter to change the status
1691 * @mask: status bits to change
1692 *
1693 * Changes in common status bits are propagated to attached ports and LUNs.
1694 */
1695void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1696{
1697        struct zfcp_port *port;
1698        struct scsi_device *sdev;
1699        unsigned long flags;
1700        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1701
1702        atomic_or(mask, &adapter->status);
1703
1704        if (!common_mask)
1705                return;
1706
1707        read_lock_irqsave(&adapter->port_list_lock, flags);
1708        list_for_each_entry(port, &adapter->port_list, list)
1709                atomic_or(common_mask, &port->status);
1710        read_unlock_irqrestore(&adapter->port_list_lock, flags);
1711
1712        /*
1713         * if `scsi_host` is missing, xconfig/xport data has never completed
1714         * yet, so we can't access it, but there are also no SDEVs yet
1715         */
1716        if (adapter->scsi_host == NULL)
1717                return;
1718
1719        spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1720        __shost_for_each_device(sdev, adapter->scsi_host)
1721                atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1722        spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1723}
1724
1725/**
1726 * zfcp_erp_clear_adapter_status - clear adapter status bits
1727 * @adapter: adapter to change the status
1728 * @mask: status bits to change
1729 *
1730 * Changes in common status bits are propagated to attached ports and LUNs.
1731 */
1732void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1733{
1734        struct zfcp_port *port;
1735        struct scsi_device *sdev;
1736        unsigned long flags;
1737        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1738        u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1739
1740        atomic_andnot(mask, &adapter->status);
1741
1742        if (!common_mask)
1743                return;
1744
1745        if (clear_counter)
1746                atomic_set(&adapter->erp_counter, 0);
1747
1748        read_lock_irqsave(&adapter->port_list_lock, flags);
1749        list_for_each_entry(port, &adapter->port_list, list) {
1750                atomic_andnot(common_mask, &port->status);
1751                if (clear_counter)
1752                        atomic_set(&port->erp_counter, 0);
1753        }
1754        read_unlock_irqrestore(&adapter->port_list_lock, flags);
1755
1756        /*
1757         * if `scsi_host` is missing, xconfig/xport data has never completed
1758         * yet, so we can't access it, but there are also no SDEVs yet
1759         */
1760        if (adapter->scsi_host == NULL)
1761                return;
1762
1763        spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1764        __shost_for_each_device(sdev, adapter->scsi_host) {
1765                atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1766                if (clear_counter)
1767                        atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1768        }
1769        spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1770}
1771
1772/**
1773 * zfcp_erp_set_port_status - set port status bits
1774 * @port: port to change the status
1775 * @mask: status bits to change
1776 *
1777 * Changes in common status bits are propagated to attached LUNs.
1778 */
1779void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1780{
1781        struct scsi_device *sdev;
1782        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1783        unsigned long flags;
1784
1785        atomic_or(mask, &port->status);
1786
1787        if (!common_mask)
1788                return;
1789
1790        spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1791        __shost_for_each_device(sdev, port->adapter->scsi_host)
1792                if (sdev_to_zfcp(sdev)->port == port)
1793                        atomic_or(common_mask,
1794                                        &sdev_to_zfcp(sdev)->status);
1795        spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1796}
1797
1798/**
1799 * zfcp_erp_clear_port_status - clear port status bits
1800 * @port: adapter to change the status
1801 * @mask: status bits to change
1802 *
1803 * Changes in common status bits are propagated to attached LUNs.
1804 */
1805void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1806{
1807        struct scsi_device *sdev;
1808        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1809        u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1810        unsigned long flags;
1811
1812        atomic_andnot(mask, &port->status);
1813
1814        if (!common_mask)
1815                return;
1816
1817        if (clear_counter)
1818                atomic_set(&port->erp_counter, 0);
1819
1820        spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1821        __shost_for_each_device(sdev, port->adapter->scsi_host)
1822                if (sdev_to_zfcp(sdev)->port == port) {
1823                        atomic_andnot(common_mask,
1824                                          &sdev_to_zfcp(sdev)->status);
1825                        if (clear_counter)
1826                                atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1827                }
1828        spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1829}
1830
1831/**
1832 * zfcp_erp_set_lun_status - set lun status bits
1833 * @sdev: SCSI device / lun to set the status bits
1834 * @mask: status bits to change
1835 */
1836void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1837{
1838        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1839
1840        atomic_or(mask, &zfcp_sdev->status);
1841}
1842
1843/**
1844 * zfcp_erp_clear_lun_status - clear lun status bits
1845 * @sdev: SCSi device / lun to clear the status bits
1846 * @mask: status bits to change
1847 */
1848void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1849{
1850        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1851
1852        atomic_andnot(mask, &zfcp_sdev->status);
1853
1854        if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1855                atomic_set(&zfcp_sdev->erp_counter, 0);
1856}
1857
1858/**
1859 * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
1860 * @adapter: Pointer to zfcp_adapter to reopen.
1861 * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
1862 */
1863void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
1864{
1865        zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
1866        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
1867        zfcp_erp_wait(adapter);
1868}
1869