Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * zfcp device driver
0004  *
0005  * Error Recovery Procedures (ERP).
0006  *
0007  * Copyright IBM Corp. 2002, 2020
0008  */
0009 
0010 #define KMSG_COMPONENT "zfcp"
0011 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0012 
0013 #include <linux/kthread.h>
0014 #include <linux/bug.h>
0015 #include "zfcp_ext.h"
0016 #include "zfcp_reqlist.h"
0017 #include "zfcp_diag.h"
0018 
0019 #define ZFCP_MAX_ERPS                   3
0020 
0021 enum zfcp_erp_act_flags {
0022     ZFCP_STATUS_ERP_TIMEDOUT    = 0x10000000,
0023     ZFCP_STATUS_ERP_CLOSE_ONLY  = 0x01000000,
0024     ZFCP_STATUS_ERP_DISMISSED   = 0x00200000,
0025     ZFCP_STATUS_ERP_LOWMEM      = 0x00400000,
0026     ZFCP_STATUS_ERP_NO_REF      = 0x00800000,
0027 };
0028 
0029 /*
0030  * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
0031  * Used to indicate that an ERP action could not be set up despite a detected
0032  * need for some recovery.
0033  */
0034 #define ZFCP_ERP_ACTION_NONE        0xc0
0035 /*
0036  * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
0037  * Used to indicate that ERP not needed because the object has
0038  * ZFCP_STATUS_COMMON_ERP_FAILED.
0039  */
0040 #define ZFCP_ERP_ACTION_FAILED      0xe0
0041 
0042 enum zfcp_erp_act_result {
0043     ZFCP_ERP_SUCCEEDED = 0,
0044     ZFCP_ERP_FAILED    = 1,
0045     ZFCP_ERP_CONTINUES = 2,
0046     ZFCP_ERP_EXIT      = 3,
0047     ZFCP_ERP_DISMISSED = 4,
0048     ZFCP_ERP_NOMEM     = 5,
0049 };
0050 
0051 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
0052 {
0053     zfcp_erp_clear_adapter_status(adapter,
0054                        ZFCP_STATUS_COMMON_UNBLOCKED | mask);
0055 }
0056 
0057 static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)
0058 {
0059     struct zfcp_erp_action *curr_act;
0060 
0061     list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
0062         if (act == curr_act)
0063             return true;
0064     return false;
0065 }
0066 
0067 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
0068 {
0069     struct zfcp_adapter *adapter = act->adapter;
0070 
0071     list_move(&act->list, &adapter->erp_ready_head);
0072     zfcp_dbf_rec_run("erardy1", act);
0073     wake_up(&adapter->erp_ready_wq);
0074     zfcp_dbf_rec_run("erardy2", act);
0075 }
0076 
0077 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
0078 {
0079     act->status |= ZFCP_STATUS_ERP_DISMISSED;
0080     if (zfcp_erp_action_is_running(act))
0081         zfcp_erp_action_ready(act);
0082 }
0083 
0084 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
0085 {
0086     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
0087 
0088     if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
0089         zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
0090 }
0091 
0092 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
0093 {
0094     struct scsi_device *sdev;
0095 
0096     if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
0097         zfcp_erp_action_dismiss(&port->erp_action);
0098     else {
0099         spin_lock(port->adapter->scsi_host->host_lock);
0100         __shost_for_each_device(sdev, port->adapter->scsi_host)
0101             if (sdev_to_zfcp(sdev)->port == port)
0102                 zfcp_erp_action_dismiss_lun(sdev);
0103         spin_unlock(port->adapter->scsi_host->host_lock);
0104     }
0105 }
0106 
0107 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
0108 {
0109     struct zfcp_port *port;
0110 
0111     if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
0112         zfcp_erp_action_dismiss(&adapter->erp_action);
0113     else {
0114         read_lock(&adapter->port_list_lock);
0115         list_for_each_entry(port, &adapter->port_list, list)
0116             zfcp_erp_action_dismiss_port(port);
0117         read_unlock(&adapter->port_list_lock);
0118     }
0119 }
0120 
0121 static enum zfcp_erp_act_type zfcp_erp_handle_failed(
0122     enum zfcp_erp_act_type want, struct zfcp_adapter *adapter,
0123     struct zfcp_port *port, struct scsi_device *sdev)
0124 {
0125     enum zfcp_erp_act_type need = want;
0126     struct zfcp_scsi_dev *zsdev;
0127 
0128     switch (want) {
0129     case ZFCP_ERP_ACTION_REOPEN_LUN:
0130         zsdev = sdev_to_zfcp(sdev);
0131         if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
0132             need = 0;
0133         break;
0134     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
0135         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
0136             need = 0;
0137         break;
0138     case ZFCP_ERP_ACTION_REOPEN_PORT:
0139         if (atomic_read(&port->status) &
0140             ZFCP_STATUS_COMMON_ERP_FAILED) {
0141             need = 0;
0142             /* ensure propagation of failed status to new devices */
0143             zfcp_erp_set_port_status(
0144                 port, ZFCP_STATUS_COMMON_ERP_FAILED);
0145         }
0146         break;
0147     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
0148         if (atomic_read(&adapter->status) &
0149             ZFCP_STATUS_COMMON_ERP_FAILED) {
0150             need = 0;
0151             /* ensure propagation of failed status to new devices */
0152             zfcp_erp_set_adapter_status(
0153                 adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
0154         }
0155         break;
0156     }
0157 
0158     return need;
0159 }
0160 
0161 static enum zfcp_erp_act_type zfcp_erp_required_act(enum zfcp_erp_act_type want,
0162                  struct zfcp_adapter *adapter,
0163                  struct zfcp_port *port,
0164                  struct scsi_device *sdev)
0165 {
0166     enum zfcp_erp_act_type need = want;
0167     int l_status, p_status, a_status;
0168     struct zfcp_scsi_dev *zfcp_sdev;
0169 
0170     switch (want) {
0171     case ZFCP_ERP_ACTION_REOPEN_LUN:
0172         zfcp_sdev = sdev_to_zfcp(sdev);
0173         l_status = atomic_read(&zfcp_sdev->status);
0174         if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
0175             return 0;
0176         p_status = atomic_read(&port->status);
0177         if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
0178             p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
0179             return 0;
0180         if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
0181             need = ZFCP_ERP_ACTION_REOPEN_PORT;
0182         fallthrough;
0183     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
0184         p_status = atomic_read(&port->status);
0185         if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
0186             need = ZFCP_ERP_ACTION_REOPEN_PORT;
0187         fallthrough;
0188     case ZFCP_ERP_ACTION_REOPEN_PORT:
0189         p_status = atomic_read(&port->status);
0190         if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
0191             return 0;
0192         a_status = atomic_read(&adapter->status);
0193         if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
0194             a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
0195             return 0;
0196         if (p_status & ZFCP_STATUS_COMMON_NOESC)
0197             return need;
0198         if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
0199             need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
0200         fallthrough;
0201     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
0202         a_status = atomic_read(&adapter->status);
0203         if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
0204             return 0;
0205         if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
0206             !(a_status & ZFCP_STATUS_COMMON_OPEN))
0207             return 0; /* shutdown requested for closed adapter */
0208     }
0209 
0210     return need;
0211 }
0212 
0213 static struct zfcp_erp_action *zfcp_erp_setup_act(enum zfcp_erp_act_type need,
0214                           u32 act_status,
0215                           struct zfcp_adapter *adapter,
0216                           struct zfcp_port *port,
0217                           struct scsi_device *sdev)
0218 {
0219     struct zfcp_erp_action *erp_action;
0220     struct zfcp_scsi_dev *zfcp_sdev;
0221 
0222     if (WARN_ON_ONCE(need != ZFCP_ERP_ACTION_REOPEN_LUN &&
0223              need != ZFCP_ERP_ACTION_REOPEN_PORT &&
0224              need != ZFCP_ERP_ACTION_REOPEN_PORT_FORCED &&
0225              need != ZFCP_ERP_ACTION_REOPEN_ADAPTER))
0226         return NULL;
0227 
0228     switch (need) {
0229     case ZFCP_ERP_ACTION_REOPEN_LUN:
0230         zfcp_sdev = sdev_to_zfcp(sdev);
0231         if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
0232             if (scsi_device_get(sdev))
0233                 return NULL;
0234         atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
0235                 &zfcp_sdev->status);
0236         erp_action = &zfcp_sdev->erp_action;
0237         WARN_ON_ONCE(erp_action->port != port);
0238         WARN_ON_ONCE(erp_action->sdev != sdev);
0239         if (!(atomic_read(&zfcp_sdev->status) &
0240               ZFCP_STATUS_COMMON_RUNNING))
0241             act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
0242         break;
0243 
0244     case ZFCP_ERP_ACTION_REOPEN_PORT:
0245     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
0246         if (!get_device(&port->dev))
0247             return NULL;
0248         zfcp_erp_action_dismiss_port(port);
0249         atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
0250         erp_action = &port->erp_action;
0251         WARN_ON_ONCE(erp_action->port != port);
0252         WARN_ON_ONCE(erp_action->sdev != NULL);
0253         if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
0254             act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
0255         break;
0256 
0257     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
0258         kref_get(&adapter->ref);
0259         zfcp_erp_action_dismiss_adapter(adapter);
0260         atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
0261         erp_action = &adapter->erp_action;
0262         WARN_ON_ONCE(erp_action->port != NULL);
0263         WARN_ON_ONCE(erp_action->sdev != NULL);
0264         if (!(atomic_read(&adapter->status) &
0265               ZFCP_STATUS_COMMON_RUNNING))
0266             act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
0267         break;
0268     }
0269 
0270     WARN_ON_ONCE(erp_action->adapter != adapter);
0271     memset(&erp_action->list, 0, sizeof(erp_action->list));
0272     memset(&erp_action->timer, 0, sizeof(erp_action->timer));
0273     erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
0274     erp_action->fsf_req_id = 0;
0275     erp_action->type = need;
0276     erp_action->status = act_status;
0277 
0278     return erp_action;
0279 }
0280 
0281 static void zfcp_erp_action_enqueue(enum zfcp_erp_act_type want,
0282                     struct zfcp_adapter *adapter,
0283                     struct zfcp_port *port,
0284                     struct scsi_device *sdev,
0285                     char *dbftag, u32 act_status)
0286 {
0287     enum zfcp_erp_act_type need;
0288     struct zfcp_erp_action *act;
0289 
0290     need = zfcp_erp_handle_failed(want, adapter, port, sdev);
0291     if (!need) {
0292         need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
0293         goto out;
0294     }
0295 
0296     if (!adapter->erp_thread) {
0297         need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
0298         goto out;
0299     }
0300 
0301     need = zfcp_erp_required_act(want, adapter, port, sdev);
0302     if (!need)
0303         goto out;
0304 
0305     act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
0306     if (!act) {
0307         need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
0308         goto out;
0309     }
0310     atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
0311     ++adapter->erp_total_count;
0312     list_add_tail(&act->list, &adapter->erp_ready_head);
0313     wake_up(&adapter->erp_ready_wq);
0314  out:
0315     zfcp_dbf_rec_trig(dbftag, adapter, port, sdev, want, need);
0316 }
0317 
0318 void zfcp_erp_port_forced_no_port_dbf(char *dbftag,
0319                       struct zfcp_adapter *adapter,
0320                       u64 port_name, u32 port_id)
0321 {
0322     unsigned long flags;
0323     static /* don't waste stack */ struct zfcp_port tmpport;
0324 
0325     write_lock_irqsave(&adapter->erp_lock, flags);
0326     /* Stand-in zfcp port with fields just good enough for
0327      * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
0328      * Under lock because tmpport is static.
0329      */
0330     atomic_set(&tmpport.status, -1); /* unknown */
0331     tmpport.wwpn = port_name;
0332     tmpport.d_id = port_id;
0333     zfcp_dbf_rec_trig(dbftag, adapter, &tmpport, NULL,
0334               ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
0335               ZFCP_ERP_ACTION_NONE);
0336     write_unlock_irqrestore(&adapter->erp_lock, flags);
0337 }
0338 
0339 static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
0340                     int clear_mask, char *dbftag)
0341 {
0342     zfcp_erp_adapter_block(adapter, clear_mask);
0343     zfcp_scsi_schedule_rports_block(adapter);
0344 
0345     zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
0346                 adapter, NULL, NULL, dbftag, 0);
0347 }
0348 
0349 /**
0350  * zfcp_erp_adapter_reopen - Reopen adapter.
0351  * @adapter: Adapter to reopen.
0352  * @clear: Status flags to clear.
0353  * @dbftag: Tag for debug trace event.
0354  */
0355 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
0356                  char *dbftag)
0357 {
0358     unsigned long flags;
0359 
0360     zfcp_erp_adapter_block(adapter, clear);
0361     zfcp_scsi_schedule_rports_block(adapter);
0362 
0363     write_lock_irqsave(&adapter->erp_lock, flags);
0364     zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
0365                 NULL, NULL, dbftag, 0);
0366     write_unlock_irqrestore(&adapter->erp_lock, flags);
0367 }
0368 
0369 /**
0370  * zfcp_erp_adapter_shutdown - Shutdown adapter.
0371  * @adapter: Adapter to shut down.
0372  * @clear: Status flags to clear.
0373  * @dbftag: Tag for debug trace event.
0374  */
0375 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
0376                    char *dbftag)
0377 {
0378     int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
0379     zfcp_erp_adapter_reopen(adapter, clear | flags, dbftag);
0380 }
0381 
0382 /**
0383  * zfcp_erp_port_shutdown - Shutdown port
0384  * @port: Port to shut down.
0385  * @clear: Status flags to clear.
0386  * @dbftag: Tag for debug trace event.
0387  */
0388 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *dbftag)
0389 {
0390     int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
0391     zfcp_erp_port_reopen(port, clear | flags, dbftag);
0392 }
0393 
0394 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
0395 {
0396     zfcp_erp_clear_port_status(port,
0397                     ZFCP_STATUS_COMMON_UNBLOCKED | clear);
0398 }
0399 
0400 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
0401                      char *dbftag)
0402 {
0403     zfcp_erp_port_block(port, clear);
0404     zfcp_scsi_schedule_rport_block(port);
0405 
0406     zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
0407                 port->adapter, port, NULL, dbftag, 0);
0408 }
0409 
0410 /**
0411  * zfcp_erp_port_forced_reopen - Forced close of port and open again
0412  * @port: Port to force close and to reopen.
0413  * @clear: Status flags to clear.
0414  * @dbftag: Tag for debug trace event.
0415  */
0416 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
0417                  char *dbftag)
0418 {
0419     unsigned long flags;
0420     struct zfcp_adapter *adapter = port->adapter;
0421 
0422     write_lock_irqsave(&adapter->erp_lock, flags);
0423     _zfcp_erp_port_forced_reopen(port, clear, dbftag);
0424     write_unlock_irqrestore(&adapter->erp_lock, flags);
0425 }
0426 
0427 static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear,
0428                   char *dbftag)
0429 {
0430     zfcp_erp_port_block(port, clear);
0431     zfcp_scsi_schedule_rport_block(port);
0432 
0433     zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
0434                 port->adapter, port, NULL, dbftag, 0);
0435 }
0436 
0437 /**
0438  * zfcp_erp_port_reopen - trigger remote port recovery
0439  * @port: port to recover
0440  * @clear: flags in port status to be cleared
0441  * @dbftag: Tag for debug trace event.
0442  */
0443 void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *dbftag)
0444 {
0445     unsigned long flags;
0446     struct zfcp_adapter *adapter = port->adapter;
0447 
0448     write_lock_irqsave(&adapter->erp_lock, flags);
0449     _zfcp_erp_port_reopen(port, clear, dbftag);
0450     write_unlock_irqrestore(&adapter->erp_lock, flags);
0451 }
0452 
0453 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
0454 {
0455     zfcp_erp_clear_lun_status(sdev,
0456                   ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
0457 }
0458 
0459 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear,
0460                  char *dbftag, u32 act_status)
0461 {
0462     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
0463     struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
0464 
0465     zfcp_erp_lun_block(sdev, clear);
0466 
0467     zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
0468                 zfcp_sdev->port, sdev, dbftag, act_status);
0469 }
0470 
0471 /**
0472  * zfcp_erp_lun_reopen - initiate reopen of a LUN
0473  * @sdev: SCSI device / LUN to be reopened
0474  * @clear: specifies flags in LUN status to be cleared
0475  * @dbftag: Tag for debug trace event.
0476  *
0477  * Return: 0 on success, < 0 on error
0478  */
0479 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *dbftag)
0480 {
0481     unsigned long flags;
0482     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
0483     struct zfcp_port *port = zfcp_sdev->port;
0484     struct zfcp_adapter *adapter = port->adapter;
0485 
0486     write_lock_irqsave(&adapter->erp_lock, flags);
0487     _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
0488     write_unlock_irqrestore(&adapter->erp_lock, flags);
0489 }
0490 
0491 /**
0492  * zfcp_erp_lun_shutdown - Shutdown LUN
0493  * @sdev: SCSI device / LUN to shut down.
0494  * @clear: Status flags to clear.
0495  * @dbftag: Tag for debug trace event.
0496  */
0497 void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *dbftag)
0498 {
0499     int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
0500     zfcp_erp_lun_reopen(sdev, clear | flags, dbftag);
0501 }
0502 
0503 /**
0504  * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
0505  * @sdev: SCSI device / LUN to shut down.
0506  * @dbftag: Tag for debug trace event.
0507  *
0508  * Do not acquire a reference for the LUN when creating the ERP
0509  * action. It is safe, because this function waits for the ERP to
0510  * complete first. This allows to shutdown the LUN, even when the SCSI
0511  * device is in the state SDEV_DEL when scsi_device_get will fail.
0512  */
0513 void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *dbftag)
0514 {
0515     unsigned long flags;
0516     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
0517     struct zfcp_port *port = zfcp_sdev->port;
0518     struct zfcp_adapter *adapter = port->adapter;
0519     int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
0520 
0521     write_lock_irqsave(&adapter->erp_lock, flags);
0522     _zfcp_erp_lun_reopen(sdev, clear, dbftag, ZFCP_STATUS_ERP_NO_REF);
0523     write_unlock_irqrestore(&adapter->erp_lock, flags);
0524 
0525     zfcp_erp_wait(adapter);
0526 }
0527 
0528 static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
0529 {
0530     return (atomic_read(status) ^ mask) & mask;
0531 }
0532 
0533 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
0534 {
0535     if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
0536                        &adapter->status))
0537         zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
0538     atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
0539 }
0540 
0541 static void zfcp_erp_port_unblock(struct zfcp_port *port)
0542 {
0543     if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
0544                        &port->status))
0545         zfcp_dbf_rec_run("erpubl1", &port->erp_action);
0546     atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
0547 }
0548 
0549 static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
0550 {
0551     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
0552 
0553     if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
0554                        &zfcp_sdev->status))
0555         zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
0556     atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
0557 }
0558 
0559 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
0560 {
0561     list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
0562     zfcp_dbf_rec_run("erator1", erp_action);
0563 }
0564 
0565 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
0566 {
0567     struct zfcp_adapter *adapter = act->adapter;
0568     struct zfcp_fsf_req *req;
0569 
0570     if (!act->fsf_req_id)
0571         return;
0572 
0573     spin_lock(&adapter->req_list->lock);
0574     req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
0575     if (req && req->erp_action == act) {
0576         if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
0577                    ZFCP_STATUS_ERP_TIMEDOUT)) {
0578             req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
0579             zfcp_dbf_rec_run("erscf_1", act);
0580             /* lock-free concurrent access with
0581              * zfcp_erp_timeout_handler()
0582              */
0583             WRITE_ONCE(req->erp_action, NULL);
0584         }
0585         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
0586             zfcp_dbf_rec_run("erscf_2", act);
0587         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
0588             act->fsf_req_id = 0;
0589     } else
0590         act->fsf_req_id = 0;
0591     spin_unlock(&adapter->req_list->lock);
0592 }
0593 
0594 /**
0595  * zfcp_erp_notify - Trigger ERP action.
0596  * @erp_action: ERP action to continue.
0597  * @set_mask: ERP action status flags to set.
0598  */
0599 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
0600 {
0601     struct zfcp_adapter *adapter = erp_action->adapter;
0602     unsigned long flags;
0603 
0604     write_lock_irqsave(&adapter->erp_lock, flags);
0605     if (zfcp_erp_action_is_running(erp_action)) {
0606         erp_action->status |= set_mask;
0607         zfcp_erp_action_ready(erp_action);
0608     }
0609     write_unlock_irqrestore(&adapter->erp_lock, flags);
0610 }
0611 
0612 /**
0613  * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
0614  * @t: timer list entry embedded in zfcp FSF request
0615  */
0616 void zfcp_erp_timeout_handler(struct timer_list *t)
0617 {
0618     struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
0619     struct zfcp_erp_action *act;
0620 
0621     if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
0622         return;
0623     /* lock-free concurrent access with zfcp_erp_strategy_check_fsfreq() */
0624     act = READ_ONCE(fsf_req->erp_action);
0625     if (!act)
0626         return;
0627     zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
0628 }
0629 
0630 static void zfcp_erp_memwait_handler(struct timer_list *t)
0631 {
0632     struct zfcp_erp_action *act = from_timer(act, t, timer);
0633 
0634     zfcp_erp_notify(act, 0);
0635 }
0636 
0637 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
0638 {
0639     timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
0640     erp_action->timer.expires = jiffies + HZ;
0641     add_timer(&erp_action->timer);
0642 }
0643 
0644 void zfcp_erp_port_forced_reopen_all(struct zfcp_adapter *adapter,
0645                      int clear, char *dbftag)
0646 {
0647     unsigned long flags;
0648     struct zfcp_port *port;
0649 
0650     write_lock_irqsave(&adapter->erp_lock, flags);
0651     read_lock(&adapter->port_list_lock);
0652     list_for_each_entry(port, &adapter->port_list, list)
0653         _zfcp_erp_port_forced_reopen(port, clear, dbftag);
0654     read_unlock(&adapter->port_list_lock);
0655     write_unlock_irqrestore(&adapter->erp_lock, flags);
0656 }
0657 
0658 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
0659                       int clear, char *dbftag)
0660 {
0661     struct zfcp_port *port;
0662 
0663     read_lock(&adapter->port_list_lock);
0664     list_for_each_entry(port, &adapter->port_list, list)
0665         _zfcp_erp_port_reopen(port, clear, dbftag);
0666     read_unlock(&adapter->port_list_lock);
0667 }
0668 
0669 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
0670                      char *dbftag)
0671 {
0672     struct scsi_device *sdev;
0673 
0674     spin_lock(port->adapter->scsi_host->host_lock);
0675     __shost_for_each_device(sdev, port->adapter->scsi_host)
0676         if (sdev_to_zfcp(sdev)->port == port)
0677             _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
0678     spin_unlock(port->adapter->scsi_host->host_lock);
0679 }
0680 
0681 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
0682 {
0683     switch (act->type) {
0684     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
0685         _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
0686         break;
0687     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
0688         _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
0689         break;
0690     case ZFCP_ERP_ACTION_REOPEN_PORT:
0691         _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
0692         break;
0693     case ZFCP_ERP_ACTION_REOPEN_LUN:
0694         _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
0695         break;
0696     }
0697 }
0698 
0699 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
0700 {
0701     switch (act->type) {
0702     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
0703         _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
0704         break;
0705     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
0706         _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
0707         break;
0708     case ZFCP_ERP_ACTION_REOPEN_PORT:
0709         _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
0710         break;
0711     case ZFCP_ERP_ACTION_REOPEN_LUN:
0712         /* NOP */
0713         break;
0714     }
0715 }
0716 
0717 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
0718 {
0719     unsigned long flags;
0720 
0721     read_lock_irqsave(&adapter->erp_lock, flags);
0722     if (list_empty(&adapter->erp_ready_head) &&
0723         list_empty(&adapter->erp_running_head)) {
0724             atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
0725                       &adapter->status);
0726             wake_up(&adapter->erp_done_wqh);
0727     }
0728     read_unlock_irqrestore(&adapter->erp_lock, flags);
0729 }
0730 
0731 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
0732 {
0733     struct zfcp_port *port;
0734     port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
0735                  adapter->peer_d_id);
0736     if (IS_ERR(port)) /* error or port already attached */
0737         return;
0738     zfcp_erp_port_reopen(port, 0, "ereptp1");
0739 }
0740 
0741 static enum zfcp_erp_act_result zfcp_erp_adapter_strat_fsf_xconf(
0742     struct zfcp_erp_action *erp_action)
0743 {
0744     int retries;
0745     int sleep = 1;
0746     struct zfcp_adapter *adapter = erp_action->adapter;
0747 
0748     atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
0749 
0750     for (retries = 7; retries; retries--) {
0751         atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
0752                   &adapter->status);
0753         write_lock_irq(&adapter->erp_lock);
0754         zfcp_erp_action_to_running(erp_action);
0755         write_unlock_irq(&adapter->erp_lock);
0756         if (zfcp_fsf_exchange_config_data(erp_action)) {
0757             atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
0758                       &adapter->status);
0759             return ZFCP_ERP_FAILED;
0760         }
0761 
0762         wait_event(adapter->erp_ready_wq,
0763                !list_empty(&adapter->erp_ready_head));
0764         if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
0765             break;
0766 
0767         if (!(atomic_read(&adapter->status) &
0768               ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
0769             break;
0770 
0771         ssleep(sleep);
0772         sleep *= 2;
0773     }
0774 
0775     atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
0776               &adapter->status);
0777 
0778     if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
0779         return ZFCP_ERP_FAILED;
0780 
0781     return ZFCP_ERP_SUCCEEDED;
0782 }
0783 
0784 static void
0785 zfcp_erp_adapter_strategy_open_ptp_port(struct zfcp_adapter *const adapter)
0786 {
0787     if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
0788         zfcp_erp_enqueue_ptp_port(adapter);
0789 }
0790 
0791 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf_xport(
0792     struct zfcp_erp_action *act)
0793 {
0794     int ret;
0795     struct zfcp_adapter *adapter = act->adapter;
0796 
0797     write_lock_irq(&adapter->erp_lock);
0798     zfcp_erp_action_to_running(act);
0799     write_unlock_irq(&adapter->erp_lock);
0800 
0801     ret = zfcp_fsf_exchange_port_data(act);
0802     if (ret == -EOPNOTSUPP)
0803         return ZFCP_ERP_SUCCEEDED;
0804     if (ret)
0805         return ZFCP_ERP_FAILED;
0806 
0807     zfcp_dbf_rec_run("erasox1", act);
0808     wait_event(adapter->erp_ready_wq,
0809            !list_empty(&adapter->erp_ready_head));
0810     zfcp_dbf_rec_run("erasox2", act);
0811     if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
0812         return ZFCP_ERP_FAILED;
0813 
0814     return ZFCP_ERP_SUCCEEDED;
0815 }
0816 
0817 static enum zfcp_erp_act_result
0818 zfcp_erp_adapter_strategy_alloc_shost(struct zfcp_adapter *const adapter)
0819 {
0820     struct zfcp_diag_adapter_config_data *const config_data =
0821         &adapter->diagnostics->config_data;
0822     struct zfcp_diag_adapter_port_data *const port_data =
0823         &adapter->diagnostics->port_data;
0824     unsigned long flags;
0825     int rc;
0826 
0827     rc = zfcp_scsi_adapter_register(adapter);
0828     if (rc == -EEXIST)
0829         return ZFCP_ERP_SUCCEEDED;
0830     else if (rc)
0831         return ZFCP_ERP_FAILED;
0832 
0833     /*
0834      * We allocated the shost for the first time. Before it was NULL,
0835      * and so we deferred all updates in the xconf- and xport-data
0836      * handlers. We need to make up for that now, and make all the updates
0837      * that would have been done before.
0838      *
0839      * We can be sure that xconf- and xport-data succeeded, because
0840      * otherwise this function is not called. But they might have been
0841      * incomplete.
0842      */
0843 
0844     spin_lock_irqsave(&config_data->header.access_lock, flags);
0845     zfcp_scsi_shost_update_config_data(adapter, &config_data->data,
0846                        !!config_data->header.incomplete);
0847     spin_unlock_irqrestore(&config_data->header.access_lock, flags);
0848 
0849     if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
0850         spin_lock_irqsave(&port_data->header.access_lock, flags);
0851         zfcp_scsi_shost_update_port_data(adapter, &port_data->data);
0852         spin_unlock_irqrestore(&port_data->header.access_lock, flags);
0853     }
0854 
0855     /*
0856      * There is a remote possibility that the 'Exchange Port Data' request
0857      * reports a different connectivity status than 'Exchange Config Data'.
0858      * But any change to the connectivity status of the local optic that
0859      * happens after the initial xconf request is expected to be reported
0860      * to us, as soon as we post Status Read Buffers to the FCP channel
0861      * firmware after this function. So any resulting inconsistency will
0862      * only be momentary.
0863      */
0864     if (config_data->header.incomplete)
0865         zfcp_fsf_fc_host_link_down(adapter);
0866 
0867     return ZFCP_ERP_SUCCEEDED;
0868 }
0869 
0870 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf(
0871     struct zfcp_erp_action *act)
0872 {
0873     if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
0874         return ZFCP_ERP_FAILED;
0875 
0876     if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
0877         return ZFCP_ERP_FAILED;
0878 
0879     if (zfcp_erp_adapter_strategy_alloc_shost(act->adapter) ==
0880         ZFCP_ERP_FAILED)
0881         return ZFCP_ERP_FAILED;
0882 
0883     zfcp_erp_adapter_strategy_open_ptp_port(act->adapter);
0884 
0885     if (mempool_resize(act->adapter->pool.sr_data,
0886                act->adapter->stat_read_buf_num))
0887         return ZFCP_ERP_FAILED;
0888 
0889     if (mempool_resize(act->adapter->pool.status_read_req,
0890                act->adapter->stat_read_buf_num))
0891         return ZFCP_ERP_FAILED;
0892 
0893     atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
0894     if (zfcp_status_read_refill(act->adapter))
0895         return ZFCP_ERP_FAILED;
0896 
0897     return ZFCP_ERP_SUCCEEDED;
0898 }
0899 
0900 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
0901 {
0902     struct zfcp_adapter *adapter = act->adapter;
0903 
0904     /* close queues to ensure that buffers are not accessed by adapter */
0905     zfcp_qdio_close(adapter->qdio);
0906     zfcp_fsf_req_dismiss_all(adapter);
0907     adapter->fsf_req_seq_no = 0;
0908     zfcp_fc_wka_ports_force_offline(adapter->gs);
0909     /* all ports and LUNs are closed */
0910     zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
0911 
0912     atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
0913               ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
0914 }
0915 
0916 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open(
0917     struct zfcp_erp_action *act)
0918 {
0919     struct zfcp_adapter *adapter = act->adapter;
0920 
0921     if (zfcp_qdio_open(adapter->qdio)) {
0922         atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
0923                   ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
0924                   &adapter->status);
0925         return ZFCP_ERP_FAILED;
0926     }
0927 
0928     if (zfcp_erp_adapter_strategy_open_fsf(act)) {
0929         zfcp_erp_adapter_strategy_close(act);
0930         return ZFCP_ERP_FAILED;
0931     }
0932 
0933     atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
0934 
0935     return ZFCP_ERP_SUCCEEDED;
0936 }
0937 
0938 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy(
0939     struct zfcp_erp_action *act)
0940 {
0941     struct zfcp_adapter *adapter = act->adapter;
0942 
0943     if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
0944         zfcp_erp_adapter_strategy_close(act);
0945         if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
0946             return ZFCP_ERP_EXIT;
0947     }
0948 
0949     if (zfcp_erp_adapter_strategy_open(act)) {
0950         ssleep(8);
0951         return ZFCP_ERP_FAILED;
0952     }
0953 
0954     return ZFCP_ERP_SUCCEEDED;
0955 }
0956 
0957 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy_close(
0958     struct zfcp_erp_action *act)
0959 {
0960     int retval;
0961 
0962     retval = zfcp_fsf_close_physical_port(act);
0963     if (retval == -ENOMEM)
0964         return ZFCP_ERP_NOMEM;
0965     act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
0966     if (retval)
0967         return ZFCP_ERP_FAILED;
0968 
0969     return ZFCP_ERP_CONTINUES;
0970 }
0971 
0972 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy(
0973     struct zfcp_erp_action *erp_action)
0974 {
0975     struct zfcp_port *port = erp_action->port;
0976     int status = atomic_read(&port->status);
0977 
0978     switch (erp_action->step) {
0979     case ZFCP_ERP_STEP_UNINITIALIZED:
0980         if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
0981             (status & ZFCP_STATUS_COMMON_OPEN))
0982             return zfcp_erp_port_forced_strategy_close(erp_action);
0983         else
0984             return ZFCP_ERP_FAILED;
0985 
0986     case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
0987         if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
0988             return ZFCP_ERP_SUCCEEDED;
0989         break;
0990     case ZFCP_ERP_STEP_PORT_CLOSING:
0991     case ZFCP_ERP_STEP_PORT_OPENING:
0992     case ZFCP_ERP_STEP_LUN_CLOSING:
0993     case ZFCP_ERP_STEP_LUN_OPENING:
0994         /* NOP */
0995         break;
0996     }
0997     return ZFCP_ERP_FAILED;
0998 }
0999 
1000 static enum zfcp_erp_act_result zfcp_erp_port_strategy_close(
1001     struct zfcp_erp_action *erp_action)
1002 {
1003     int retval;
1004 
1005     retval = zfcp_fsf_close_port(erp_action);
1006     if (retval == -ENOMEM)
1007         return ZFCP_ERP_NOMEM;
1008     erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
1009     if (retval)
1010         return ZFCP_ERP_FAILED;
1011     return ZFCP_ERP_CONTINUES;
1012 }
1013 
1014 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_port(
1015     struct zfcp_erp_action *erp_action)
1016 {
1017     int retval;
1018 
1019     retval = zfcp_fsf_open_port(erp_action);
1020     if (retval == -ENOMEM)
1021         return ZFCP_ERP_NOMEM;
1022     erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
1023     if (retval)
1024         return ZFCP_ERP_FAILED;
1025     return ZFCP_ERP_CONTINUES;
1026 }
1027 
1028 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
1029 {
1030     struct zfcp_adapter *adapter = act->adapter;
1031     struct zfcp_port *port = act->port;
1032 
1033     if (port->wwpn != adapter->peer_wwpn) {
1034         zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
1035         return ZFCP_ERP_FAILED;
1036     }
1037     port->d_id = adapter->peer_d_id;
1038     return zfcp_erp_port_strategy_open_port(act);
1039 }
1040 
1041 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_common(
1042     struct zfcp_erp_action *act)
1043 {
1044     struct zfcp_adapter *adapter = act->adapter;
1045     struct zfcp_port *port = act->port;
1046     int p_status = atomic_read(&port->status);
1047 
1048     switch (act->step) {
1049     case ZFCP_ERP_STEP_UNINITIALIZED:
1050     case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1051     case ZFCP_ERP_STEP_PORT_CLOSING:
1052         if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
1053             return zfcp_erp_open_ptp_port(act);
1054         if (!port->d_id) {
1055             zfcp_fc_trigger_did_lookup(port);
1056             return ZFCP_ERP_EXIT;
1057         }
1058         return zfcp_erp_port_strategy_open_port(act);
1059 
1060     case ZFCP_ERP_STEP_PORT_OPENING:
1061         /* D_ID might have changed during open */
1062         if (p_status & ZFCP_STATUS_COMMON_OPEN) {
1063             if (!port->d_id) {
1064                 zfcp_fc_trigger_did_lookup(port);
1065                 return ZFCP_ERP_EXIT;
1066             }
1067             return ZFCP_ERP_SUCCEEDED;
1068         }
1069         if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
1070             port->d_id = 0;
1071             return ZFCP_ERP_FAILED;
1072         }
1073         /* no early return otherwise, continue after switch case */
1074         break;
1075     case ZFCP_ERP_STEP_LUN_CLOSING:
1076     case ZFCP_ERP_STEP_LUN_OPENING:
1077         /* NOP */
1078         break;
1079     }
1080     return ZFCP_ERP_FAILED;
1081 }
1082 
1083 static enum zfcp_erp_act_result zfcp_erp_port_strategy(
1084     struct zfcp_erp_action *erp_action)
1085 {
1086     struct zfcp_port *port = erp_action->port;
1087     int p_status = atomic_read(&port->status);
1088 
1089     if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
1090         !(p_status & ZFCP_STATUS_COMMON_OPEN))
1091         goto close_init_done;
1092 
1093     switch (erp_action->step) {
1094     case ZFCP_ERP_STEP_UNINITIALIZED:
1095         if (p_status & ZFCP_STATUS_COMMON_OPEN)
1096             return zfcp_erp_port_strategy_close(erp_action);
1097         break;
1098 
1099     case ZFCP_ERP_STEP_PORT_CLOSING:
1100         if (p_status & ZFCP_STATUS_COMMON_OPEN)
1101             return ZFCP_ERP_FAILED;
1102         break;
1103     case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1104     case ZFCP_ERP_STEP_PORT_OPENING:
1105     case ZFCP_ERP_STEP_LUN_CLOSING:
1106     case ZFCP_ERP_STEP_LUN_OPENING:
1107         /* NOP */
1108         break;
1109     }
1110 
1111 close_init_done:
1112     if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1113         return ZFCP_ERP_EXIT;
1114 
1115     return zfcp_erp_port_strategy_open_common(erp_action);
1116 }
1117 
1118 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
1119 {
1120     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1121 
1122     atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
1123               &zfcp_sdev->status);
1124 }
1125 
1126 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_close(
1127     struct zfcp_erp_action *erp_action)
1128 {
1129     int retval = zfcp_fsf_close_lun(erp_action);
1130     if (retval == -ENOMEM)
1131         return ZFCP_ERP_NOMEM;
1132     erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
1133     if (retval)
1134         return ZFCP_ERP_FAILED;
1135     return ZFCP_ERP_CONTINUES;
1136 }
1137 
1138 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_open(
1139     struct zfcp_erp_action *erp_action)
1140 {
1141     int retval = zfcp_fsf_open_lun(erp_action);
1142     if (retval == -ENOMEM)
1143         return ZFCP_ERP_NOMEM;
1144     erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
1145     if (retval)
1146         return  ZFCP_ERP_FAILED;
1147     return ZFCP_ERP_CONTINUES;
1148 }
1149 
1150 static enum zfcp_erp_act_result zfcp_erp_lun_strategy(
1151     struct zfcp_erp_action *erp_action)
1152 {
1153     struct scsi_device *sdev = erp_action->sdev;
1154     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1155 
1156     switch (erp_action->step) {
1157     case ZFCP_ERP_STEP_UNINITIALIZED:
1158         zfcp_erp_lun_strategy_clearstati(sdev);
1159         if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1160             return zfcp_erp_lun_strategy_close(erp_action);
1161         /* already closed */
1162         fallthrough;
1163     case ZFCP_ERP_STEP_LUN_CLOSING:
1164         if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1165             return ZFCP_ERP_FAILED;
1166         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1167             return ZFCP_ERP_EXIT;
1168         return zfcp_erp_lun_strategy_open(erp_action);
1169 
1170     case ZFCP_ERP_STEP_LUN_OPENING:
1171         if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1172             return ZFCP_ERP_SUCCEEDED;
1173         break;
1174     case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1175     case ZFCP_ERP_STEP_PORT_CLOSING:
1176     case ZFCP_ERP_STEP_PORT_OPENING:
1177         /* NOP */
1178         break;
1179     }
1180     return ZFCP_ERP_FAILED;
1181 }
1182 
1183 static enum zfcp_erp_act_result zfcp_erp_strategy_check_lun(
1184     struct scsi_device *sdev, enum zfcp_erp_act_result result)
1185 {
1186     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1187 
1188     switch (result) {
1189     case ZFCP_ERP_SUCCEEDED :
1190         atomic_set(&zfcp_sdev->erp_counter, 0);
1191         zfcp_erp_lun_unblock(sdev);
1192         break;
1193     case ZFCP_ERP_FAILED :
1194         atomic_inc(&zfcp_sdev->erp_counter);
1195         if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1196             dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1197                 "ERP failed for LUN 0x%016Lx on "
1198                 "port 0x%016Lx\n",
1199                 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1200                 (unsigned long long)zfcp_sdev->port->wwpn);
1201             zfcp_erp_set_lun_status(sdev,
1202                         ZFCP_STATUS_COMMON_ERP_FAILED);
1203         }
1204         break;
1205     case ZFCP_ERP_CONTINUES:
1206     case ZFCP_ERP_EXIT:
1207     case ZFCP_ERP_DISMISSED:
1208     case ZFCP_ERP_NOMEM:
1209         /* NOP */
1210         break;
1211     }
1212 
1213     if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1214         zfcp_erp_lun_block(sdev, 0);
1215         result = ZFCP_ERP_EXIT;
1216     }
1217     return result;
1218 }
1219 
1220 static enum zfcp_erp_act_result zfcp_erp_strategy_check_port(
1221     struct zfcp_port *port, enum zfcp_erp_act_result result)
1222 {
1223     switch (result) {
1224     case ZFCP_ERP_SUCCEEDED :
1225         atomic_set(&port->erp_counter, 0);
1226         zfcp_erp_port_unblock(port);
1227         break;
1228 
1229     case ZFCP_ERP_FAILED :
1230         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1231             zfcp_erp_port_block(port, 0);
1232             result = ZFCP_ERP_EXIT;
1233         }
1234         atomic_inc(&port->erp_counter);
1235         if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1236             dev_err(&port->adapter->ccw_device->dev,
1237                 "ERP failed for remote port 0x%016Lx\n",
1238                 (unsigned long long)port->wwpn);
1239             zfcp_erp_set_port_status(port,
1240                      ZFCP_STATUS_COMMON_ERP_FAILED);
1241         }
1242         break;
1243     case ZFCP_ERP_CONTINUES:
1244     case ZFCP_ERP_EXIT:
1245     case ZFCP_ERP_DISMISSED:
1246     case ZFCP_ERP_NOMEM:
1247         /* NOP */
1248         break;
1249     }
1250 
1251     if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1252         zfcp_erp_port_block(port, 0);
1253         result = ZFCP_ERP_EXIT;
1254     }
1255     return result;
1256 }
1257 
1258 static enum zfcp_erp_act_result zfcp_erp_strategy_check_adapter(
1259     struct zfcp_adapter *adapter, enum zfcp_erp_act_result result)
1260 {
1261     switch (result) {
1262     case ZFCP_ERP_SUCCEEDED :
1263         atomic_set(&adapter->erp_counter, 0);
1264         zfcp_erp_adapter_unblock(adapter);
1265         break;
1266 
1267     case ZFCP_ERP_FAILED :
1268         atomic_inc(&adapter->erp_counter);
1269         if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1270             dev_err(&adapter->ccw_device->dev,
1271                 "ERP cannot recover an error "
1272                 "on the FCP device\n");
1273             zfcp_erp_set_adapter_status(adapter,
1274                         ZFCP_STATUS_COMMON_ERP_FAILED);
1275         }
1276         break;
1277     case ZFCP_ERP_CONTINUES:
1278     case ZFCP_ERP_EXIT:
1279     case ZFCP_ERP_DISMISSED:
1280     case ZFCP_ERP_NOMEM:
1281         /* NOP */
1282         break;
1283     }
1284 
1285     if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1286         zfcp_erp_adapter_block(adapter, 0);
1287         result = ZFCP_ERP_EXIT;
1288     }
1289     return result;
1290 }
1291 
1292 static enum zfcp_erp_act_result zfcp_erp_strategy_check_target(
1293     struct zfcp_erp_action *erp_action, enum zfcp_erp_act_result result)
1294 {
1295     struct zfcp_adapter *adapter = erp_action->adapter;
1296     struct zfcp_port *port = erp_action->port;
1297     struct scsi_device *sdev = erp_action->sdev;
1298 
1299     switch (erp_action->type) {
1300 
1301     case ZFCP_ERP_ACTION_REOPEN_LUN:
1302         result = zfcp_erp_strategy_check_lun(sdev, result);
1303         break;
1304 
1305     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1306     case ZFCP_ERP_ACTION_REOPEN_PORT:
1307         result = zfcp_erp_strategy_check_port(port, result);
1308         break;
1309 
1310     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1311         result = zfcp_erp_strategy_check_adapter(adapter, result);
1312         break;
1313     }
1314     return result;
1315 }
1316 
1317 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1318 {
1319     int status = atomic_read(target_status);
1320 
1321     if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1322         (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1323         return 1; /* take it online */
1324 
1325     if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1326         !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1327         return 1; /* take it offline */
1328 
1329     return 0;
1330 }
1331 
1332 static enum zfcp_erp_act_result zfcp_erp_strategy_statechange(
1333     struct zfcp_erp_action *act, enum zfcp_erp_act_result result)
1334 {
1335     enum zfcp_erp_act_type type = act->type;
1336     struct zfcp_adapter *adapter = act->adapter;
1337     struct zfcp_port *port = act->port;
1338     struct scsi_device *sdev = act->sdev;
1339     struct zfcp_scsi_dev *zfcp_sdev;
1340     u32 erp_status = act->status;
1341 
1342     switch (type) {
1343     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1344         if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1345             _zfcp_erp_adapter_reopen(adapter,
1346                          ZFCP_STATUS_COMMON_ERP_FAILED,
1347                          "ersscg1");
1348             return ZFCP_ERP_EXIT;
1349         }
1350         break;
1351 
1352     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1353     case ZFCP_ERP_ACTION_REOPEN_PORT:
1354         if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1355             _zfcp_erp_port_reopen(port,
1356                           ZFCP_STATUS_COMMON_ERP_FAILED,
1357                           "ersscg2");
1358             return ZFCP_ERP_EXIT;
1359         }
1360         break;
1361 
1362     case ZFCP_ERP_ACTION_REOPEN_LUN:
1363         zfcp_sdev = sdev_to_zfcp(sdev);
1364         if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1365             _zfcp_erp_lun_reopen(sdev,
1366                          ZFCP_STATUS_COMMON_ERP_FAILED,
1367                          "ersscg3", 0);
1368             return ZFCP_ERP_EXIT;
1369         }
1370         break;
1371     }
1372     return result;
1373 }
1374 
1375 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1376 {
1377     struct zfcp_adapter *adapter = erp_action->adapter;
1378     struct zfcp_scsi_dev *zfcp_sdev;
1379 
1380     adapter->erp_total_count--;
1381     if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1382         adapter->erp_low_mem_count--;
1383         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1384     }
1385 
1386     list_del(&erp_action->list);
1387     zfcp_dbf_rec_run("eractd1", erp_action);
1388 
1389     switch (erp_action->type) {
1390     case ZFCP_ERP_ACTION_REOPEN_LUN:
1391         zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1392         atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1393                   &zfcp_sdev->status);
1394         break;
1395 
1396     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1397     case ZFCP_ERP_ACTION_REOPEN_PORT:
1398         atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1399                   &erp_action->port->status);
1400         break;
1401 
1402     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1403         atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1404                   &erp_action->adapter->status);
1405         break;
1406     }
1407 }
1408 
1409 /**
1410  * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1411  * @port: zfcp_port whose fc_rport we should try to unblock
1412  */
1413 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
1414 {
1415     unsigned long flags;
1416     struct zfcp_adapter *adapter = port->adapter;
1417     int port_status;
1418     struct Scsi_Host *shost = adapter->scsi_host;
1419     struct scsi_device *sdev;
1420 
1421     write_lock_irqsave(&adapter->erp_lock, flags);
1422     port_status = atomic_read(&port->status);
1423     if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED)    == 0 ||
1424         (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
1425                 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
1426         /* new ERP of severity >= port triggered elsewhere meanwhile or
1427          * local link down (adapter erp_failed but not clear unblock)
1428          */
1429         zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
1430         write_unlock_irqrestore(&adapter->erp_lock, flags);
1431         return;
1432     }
1433     spin_lock(shost->host_lock);
1434     __shost_for_each_device(sdev, shost) {
1435         struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
1436         int lun_status;
1437 
1438         if (sdev->sdev_state == SDEV_DEL ||
1439             sdev->sdev_state == SDEV_CANCEL)
1440             continue;
1441         if (zsdev->port != port)
1442             continue;
1443         /* LUN under port of interest */
1444         lun_status = atomic_read(&zsdev->status);
1445         if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
1446             continue; /* unblock rport despite failed LUNs */
1447         /* LUN recovery not given up yet [maybe follow-up pending] */
1448         if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1449             (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
1450             /* LUN blocked:
1451              * not yet unblocked [LUN recovery pending]
1452              * or meanwhile blocked [new LUN recovery triggered]
1453              */
1454             zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
1455             spin_unlock(shost->host_lock);
1456             write_unlock_irqrestore(&adapter->erp_lock, flags);
1457             return;
1458         }
1459     }
1460     /* now port has no child or all children have completed recovery,
1461      * and no ERP of severity >= port was meanwhile triggered elsewhere
1462      */
1463     zfcp_scsi_schedule_rport_register(port);
1464     spin_unlock(shost->host_lock);
1465     write_unlock_irqrestore(&adapter->erp_lock, flags);
1466 }
1467 
1468 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act,
1469                     enum zfcp_erp_act_result result)
1470 {
1471     struct zfcp_adapter *adapter = act->adapter;
1472     struct zfcp_port *port = act->port;
1473     struct scsi_device *sdev = act->sdev;
1474 
1475     switch (act->type) {
1476     case ZFCP_ERP_ACTION_REOPEN_LUN:
1477         if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1478             scsi_device_put(sdev);
1479         zfcp_erp_try_rport_unblock(port);
1480         break;
1481 
1482     case ZFCP_ERP_ACTION_REOPEN_PORT:
1483         /* This switch case might also happen after a forced reopen
1484          * was successfully done and thus overwritten with a new
1485          * non-forced reopen at `ersfs_2'. In this case, we must not
1486          * do the clean-up of the non-forced version.
1487          */
1488         if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
1489             if (result == ZFCP_ERP_SUCCEEDED)
1490                 zfcp_erp_try_rport_unblock(port);
1491         fallthrough;
1492     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1493         put_device(&port->dev);
1494         break;
1495 
1496     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1497         if (result == ZFCP_ERP_SUCCEEDED) {
1498             register_service_level(&adapter->service_level);
1499             zfcp_fc_conditional_port_scan(adapter);
1500             queue_work(adapter->work_queue, &adapter->ns_up_work);
1501         } else
1502             unregister_service_level(&adapter->service_level);
1503 
1504         kref_put(&adapter->ref, zfcp_adapter_release);
1505         break;
1506     }
1507 }
1508 
1509 static enum zfcp_erp_act_result zfcp_erp_strategy_do_action(
1510     struct zfcp_erp_action *erp_action)
1511 {
1512     switch (erp_action->type) {
1513     case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1514         return zfcp_erp_adapter_strategy(erp_action);
1515     case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1516         return zfcp_erp_port_forced_strategy(erp_action);
1517     case ZFCP_ERP_ACTION_REOPEN_PORT:
1518         return zfcp_erp_port_strategy(erp_action);
1519     case ZFCP_ERP_ACTION_REOPEN_LUN:
1520         return zfcp_erp_lun_strategy(erp_action);
1521     }
1522     return ZFCP_ERP_FAILED;
1523 }
1524 
1525 static enum zfcp_erp_act_result zfcp_erp_strategy(
1526     struct zfcp_erp_action *erp_action)
1527 {
1528     enum zfcp_erp_act_result result;
1529     unsigned long flags;
1530     struct zfcp_adapter *adapter = erp_action->adapter;
1531 
1532     kref_get(&adapter->ref);
1533 
1534     write_lock_irqsave(&adapter->erp_lock, flags);
1535     zfcp_erp_strategy_check_fsfreq(erp_action);
1536 
1537     if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1538         zfcp_erp_action_dequeue(erp_action);
1539         result = ZFCP_ERP_DISMISSED;
1540         goto unlock;
1541     }
1542 
1543     if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1544         result = ZFCP_ERP_FAILED;
1545         goto check_target;
1546     }
1547 
1548     zfcp_erp_action_to_running(erp_action);
1549 
1550     /* no lock to allow for blocking operations */
1551     write_unlock_irqrestore(&adapter->erp_lock, flags);
1552     result = zfcp_erp_strategy_do_action(erp_action);
1553     write_lock_irqsave(&adapter->erp_lock, flags);
1554 
1555     if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1556         result = ZFCP_ERP_CONTINUES;
1557 
1558     switch (result) {
1559     case ZFCP_ERP_NOMEM:
1560         if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1561             ++adapter->erp_low_mem_count;
1562             erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1563         }
1564         if (adapter->erp_total_count == adapter->erp_low_mem_count)
1565             _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1566         else {
1567             zfcp_erp_strategy_memwait(erp_action);
1568             result = ZFCP_ERP_CONTINUES;
1569         }
1570         goto unlock;
1571 
1572     case ZFCP_ERP_CONTINUES:
1573         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1574             --adapter->erp_low_mem_count;
1575             erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1576         }
1577         goto unlock;
1578     case ZFCP_ERP_SUCCEEDED:
1579     case ZFCP_ERP_FAILED:
1580     case ZFCP_ERP_EXIT:
1581     case ZFCP_ERP_DISMISSED:
1582         /* NOP */
1583         break;
1584     }
1585 
1586 check_target:
1587     result = zfcp_erp_strategy_check_target(erp_action, result);
1588     zfcp_erp_action_dequeue(erp_action);
1589     result = zfcp_erp_strategy_statechange(erp_action, result);
1590     if (result == ZFCP_ERP_EXIT)
1591         goto unlock;
1592     if (result == ZFCP_ERP_SUCCEEDED)
1593         zfcp_erp_strategy_followup_success(erp_action);
1594     if (result == ZFCP_ERP_FAILED)
1595         zfcp_erp_strategy_followup_failed(erp_action);
1596 
1597  unlock:
1598     write_unlock_irqrestore(&adapter->erp_lock, flags);
1599 
1600     if (result != ZFCP_ERP_CONTINUES)
1601         zfcp_erp_action_cleanup(erp_action, result);
1602 
1603     kref_put(&adapter->ref, zfcp_adapter_release);
1604     return result;
1605 }
1606 
1607 static int zfcp_erp_thread(void *data)
1608 {
1609     struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1610     struct zfcp_erp_action *act;
1611     unsigned long flags;
1612 
1613     for (;;) {
1614         wait_event_interruptible(adapter->erp_ready_wq,
1615                !list_empty(&adapter->erp_ready_head) ||
1616                kthread_should_stop());
1617 
1618         if (kthread_should_stop())
1619             break;
1620 
1621         write_lock_irqsave(&adapter->erp_lock, flags);
1622         act = list_first_entry_or_null(&adapter->erp_ready_head,
1623                            struct zfcp_erp_action, list);
1624         write_unlock_irqrestore(&adapter->erp_lock, flags);
1625 
1626         if (act) {
1627             /* there is more to come after dismission, no notify */
1628             if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1629                 zfcp_erp_wakeup(adapter);
1630         }
1631     }
1632 
1633     return 0;
1634 }
1635 
1636 /**
1637  * zfcp_erp_thread_setup - Start ERP thread for adapter
1638  * @adapter: Adapter to start the ERP thread for
1639  *
1640  * Return: 0 on success, or error code from kthread_run().
1641  */
1642 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1643 {
1644     struct task_struct *thread;
1645 
1646     thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1647                  dev_name(&adapter->ccw_device->dev));
1648     if (IS_ERR(thread)) {
1649         dev_err(&adapter->ccw_device->dev,
1650             "Creating an ERP thread for the FCP device failed.\n");
1651         return PTR_ERR(thread);
1652     }
1653 
1654     adapter->erp_thread = thread;
1655     return 0;
1656 }
1657 
1658 /**
1659  * zfcp_erp_thread_kill - Stop ERP thread.
1660  * @adapter: Adapter where the ERP thread should be stopped.
1661  *
1662  * The caller of this routine ensures that the specified adapter has
1663  * been shut down and that this operation has been completed. Thus,
1664  * there are no pending erp_actions which would need to be handled
1665  * here.
1666  */
1667 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1668 {
1669     kthread_stop(adapter->erp_thread);
1670     adapter->erp_thread = NULL;
1671     WARN_ON(!list_empty(&adapter->erp_ready_head));
1672     WARN_ON(!list_empty(&adapter->erp_running_head));
1673 }
1674 
1675 /**
1676  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1677  * @adapter: adapter for which to wait for completion of its error recovery
1678  */
1679 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1680 {
1681     wait_event(adapter->erp_done_wqh,
1682            !(atomic_read(&adapter->status) &
1683             ZFCP_STATUS_ADAPTER_ERP_PENDING));
1684 }
1685 
1686 /**
1687  * zfcp_erp_set_adapter_status - set adapter status bits
1688  * @adapter: adapter to change the status
1689  * @mask: status bits to change
1690  *
1691  * Changes in common status bits are propagated to attached ports and LUNs.
1692  */
1693 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1694 {
1695     struct zfcp_port *port;
1696     struct scsi_device *sdev;
1697     unsigned long flags;
1698     u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1699 
1700     atomic_or(mask, &adapter->status);
1701 
1702     if (!common_mask)
1703         return;
1704 
1705     read_lock_irqsave(&adapter->port_list_lock, flags);
1706     list_for_each_entry(port, &adapter->port_list, list)
1707         atomic_or(common_mask, &port->status);
1708     read_unlock_irqrestore(&adapter->port_list_lock, flags);
1709 
1710     /*
1711      * if `scsi_host` is missing, xconfig/xport data has never completed
1712      * yet, so we can't access it, but there are also no SDEVs yet
1713      */
1714     if (adapter->scsi_host == NULL)
1715         return;
1716 
1717     spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1718     __shost_for_each_device(sdev, adapter->scsi_host)
1719         atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1720     spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1721 }
1722 
1723 /**
1724  * zfcp_erp_clear_adapter_status - clear adapter status bits
1725  * @adapter: adapter to change the status
1726  * @mask: status bits to change
1727  *
1728  * Changes in common status bits are propagated to attached ports and LUNs.
1729  */
1730 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1731 {
1732     struct zfcp_port *port;
1733     struct scsi_device *sdev;
1734     unsigned long flags;
1735     u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1736     u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1737 
1738     atomic_andnot(mask, &adapter->status);
1739 
1740     if (!common_mask)
1741         return;
1742 
1743     if (clear_counter)
1744         atomic_set(&adapter->erp_counter, 0);
1745 
1746     read_lock_irqsave(&adapter->port_list_lock, flags);
1747     list_for_each_entry(port, &adapter->port_list, list) {
1748         atomic_andnot(common_mask, &port->status);
1749         if (clear_counter)
1750             atomic_set(&port->erp_counter, 0);
1751     }
1752     read_unlock_irqrestore(&adapter->port_list_lock, flags);
1753 
1754     /*
1755      * if `scsi_host` is missing, xconfig/xport data has never completed
1756      * yet, so we can't access it, but there are also no SDEVs yet
1757      */
1758     if (adapter->scsi_host == NULL)
1759         return;
1760 
1761     spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1762     __shost_for_each_device(sdev, adapter->scsi_host) {
1763         atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1764         if (clear_counter)
1765             atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1766     }
1767     spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1768 }
1769 
1770 /**
1771  * zfcp_erp_set_port_status - set port status bits
1772  * @port: port to change the status
1773  * @mask: status bits to change
1774  *
1775  * Changes in common status bits are propagated to attached LUNs.
1776  */
1777 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1778 {
1779     struct scsi_device *sdev;
1780     u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1781     unsigned long flags;
1782 
1783     atomic_or(mask, &port->status);
1784 
1785     if (!common_mask)
1786         return;
1787 
1788     spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1789     __shost_for_each_device(sdev, port->adapter->scsi_host)
1790         if (sdev_to_zfcp(sdev)->port == port)
1791             atomic_or(common_mask,
1792                     &sdev_to_zfcp(sdev)->status);
1793     spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1794 }
1795 
1796 /**
1797  * zfcp_erp_clear_port_status - clear port status bits
1798  * @port: adapter to change the status
1799  * @mask: status bits to change
1800  *
1801  * Changes in common status bits are propagated to attached LUNs.
1802  */
1803 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1804 {
1805     struct scsi_device *sdev;
1806     u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1807     u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1808     unsigned long flags;
1809 
1810     atomic_andnot(mask, &port->status);
1811 
1812     if (!common_mask)
1813         return;
1814 
1815     if (clear_counter)
1816         atomic_set(&port->erp_counter, 0);
1817 
1818     spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1819     __shost_for_each_device(sdev, port->adapter->scsi_host)
1820         if (sdev_to_zfcp(sdev)->port == port) {
1821             atomic_andnot(common_mask,
1822                       &sdev_to_zfcp(sdev)->status);
1823             if (clear_counter)
1824                 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1825         }
1826     spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1827 }
1828 
1829 /**
1830  * zfcp_erp_set_lun_status - set lun status bits
1831  * @sdev: SCSI device / lun to set the status bits
1832  * @mask: status bits to change
1833  */
1834 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1835 {
1836     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1837 
1838     atomic_or(mask, &zfcp_sdev->status);
1839 }
1840 
1841 /**
1842  * zfcp_erp_clear_lun_status - clear lun status bits
1843  * @sdev: SCSi device / lun to clear the status bits
1844  * @mask: status bits to change
1845  */
1846 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1847 {
1848     struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1849 
1850     atomic_andnot(mask, &zfcp_sdev->status);
1851 
1852     if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1853         atomic_set(&zfcp_sdev->erp_counter, 0);
1854 }
1855 
1856 /**
1857  * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
1858  * @adapter: Pointer to zfcp_adapter to reopen.
1859  * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
1860  */
1861 void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
1862 {
1863     zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
1864     zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
1865     zfcp_erp_wait(adapter);
1866 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!