drivers/s390/scsi/zfcp_erp.c

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