drivers/s390/scsi/zfcp_erp.c

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