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