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