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