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