1867 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * zfcp device driver4 *5 * Error Recovery Procedures (ERP).6 *7 * Copyright IBM Corp. 2002, 20208 */9 10#define KMSG_COMPONENT "zfcp"11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt12 13#include <linux/kthread.h>14#include <linux/bug.h>15#include "zfcp_ext.h"16#include "zfcp_reqlist.h"17#include "zfcp_diag.h"18 19#define ZFCP_MAX_ERPS 320 21enum zfcp_erp_act_flags {22 ZFCP_STATUS_ERP_TIMEDOUT = 0x10000000,23 ZFCP_STATUS_ERP_CLOSE_ONLY = 0x01000000,24 ZFCP_STATUS_ERP_DISMISSED = 0x00200000,25 ZFCP_STATUS_ERP_LOWMEM = 0x00400000,26 ZFCP_STATUS_ERP_NO_REF = 0x00800000,27};28 29/*30 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.31 * Used to indicate that an ERP action could not be set up despite a detected32 * need for some recovery.33 */34#define ZFCP_ERP_ACTION_NONE 0xc035/*36 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.37 * Used to indicate that ERP not needed because the object has38 * ZFCP_STATUS_COMMON_ERP_FAILED.39 */40#define ZFCP_ERP_ACTION_FAILED 0xe041 42enum zfcp_erp_act_result {43 ZFCP_ERP_SUCCEEDED = 0,44 ZFCP_ERP_FAILED = 1,45 ZFCP_ERP_CONTINUES = 2,46 ZFCP_ERP_EXIT = 3,47 ZFCP_ERP_DISMISSED = 4,48 ZFCP_ERP_NOMEM = 5,49};50 51static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)52{53 zfcp_erp_clear_adapter_status(adapter,54 ZFCP_STATUS_COMMON_UNBLOCKED | mask);55}56 57static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)58{59 struct zfcp_erp_action *curr_act;60 61 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)62 if (act == curr_act)63 return true;64 return false;65}66 67static void zfcp_erp_action_ready(struct zfcp_erp_action *act)68{69 struct zfcp_adapter *adapter = act->adapter;70 71 list_move(&act->list, &adapter->erp_ready_head);72 zfcp_dbf_rec_run("erardy1", act);73 wake_up(&adapter->erp_ready_wq);74 zfcp_dbf_rec_run("erardy2", act);75}76 77static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)78{79 act->status |= ZFCP_STATUS_ERP_DISMISSED;80 if (zfcp_erp_action_is_running(act))81 zfcp_erp_action_ready(act);82}83 84static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)85{86 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);87 88 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)89 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);90}91 92static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)93{94 struct scsi_device *sdev;95 96 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)97 zfcp_erp_action_dismiss(&port->erp_action);98 else {99 spin_lock(port->adapter->scsi_host->host_lock);100 __shost_for_each_device(sdev, port->adapter->scsi_host)101 if (sdev_to_zfcp(sdev)->port == port)102 zfcp_erp_action_dismiss_lun(sdev);103 spin_unlock(port->adapter->scsi_host->host_lock);104 }105}106 107static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)108{109 struct zfcp_port *port;110 111 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)112 zfcp_erp_action_dismiss(&adapter->erp_action);113 else {114 read_lock(&adapter->port_list_lock);115 list_for_each_entry(port, &adapter->port_list, list)116 zfcp_erp_action_dismiss_port(port);117 read_unlock(&adapter->port_list_lock);118 }119}120 121static enum zfcp_erp_act_type zfcp_erp_handle_failed(122 enum zfcp_erp_act_type want, struct zfcp_adapter *adapter,123 struct zfcp_port *port, struct scsi_device *sdev)124{125 enum zfcp_erp_act_type need = want;126 struct zfcp_scsi_dev *zsdev;127 128 switch (want) {129 case ZFCP_ERP_ACTION_REOPEN_LUN:130 zsdev = sdev_to_zfcp(sdev);131 if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)132 need = 0;133 break;134 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:135 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)136 need = 0;137 break;138 case ZFCP_ERP_ACTION_REOPEN_PORT:139 if (atomic_read(&port->status) &140 ZFCP_STATUS_COMMON_ERP_FAILED) {141 need = 0;142 /* ensure propagation of failed status to new devices */143 zfcp_erp_set_port_status(144 port, ZFCP_STATUS_COMMON_ERP_FAILED);145 }146 break;147 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:148 if (atomic_read(&adapter->status) &149 ZFCP_STATUS_COMMON_ERP_FAILED) {150 need = 0;151 /* ensure propagation of failed status to new devices */152 zfcp_erp_set_adapter_status(153 adapter, ZFCP_STATUS_COMMON_ERP_FAILED);154 }155 break;156 }157 158 return need;159}160 161static enum zfcp_erp_act_type zfcp_erp_required_act(enum zfcp_erp_act_type want,162 struct zfcp_adapter *adapter,163 struct zfcp_port *port,164 struct scsi_device *sdev)165{166 enum zfcp_erp_act_type need = want;167 int l_status, p_status, a_status;168 struct zfcp_scsi_dev *zfcp_sdev;169 170 switch (want) {171 case ZFCP_ERP_ACTION_REOPEN_LUN:172 zfcp_sdev = sdev_to_zfcp(sdev);173 l_status = atomic_read(&zfcp_sdev->status);174 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)175 return 0;176 p_status = atomic_read(&port->status);177 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||178 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)179 return 0;180 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))181 need = ZFCP_ERP_ACTION_REOPEN_PORT;182 fallthrough;183 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:184 p_status = atomic_read(&port->status);185 if (!(p_status & ZFCP_STATUS_COMMON_OPEN))186 need = ZFCP_ERP_ACTION_REOPEN_PORT;187 fallthrough;188 case ZFCP_ERP_ACTION_REOPEN_PORT:189 p_status = atomic_read(&port->status);190 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)191 return 0;192 a_status = atomic_read(&adapter->status);193 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||194 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)195 return 0;196 if (p_status & ZFCP_STATUS_COMMON_NOESC)197 return need;198 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))199 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;200 fallthrough;201 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:202 a_status = atomic_read(&adapter->status);203 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)204 return 0;205 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&206 !(a_status & ZFCP_STATUS_COMMON_OPEN))207 return 0; /* shutdown requested for closed adapter */208 }209 210 return need;211}212 213static struct zfcp_erp_action *zfcp_erp_setup_act(enum zfcp_erp_act_type need,214 u32 act_status,215 struct zfcp_adapter *adapter,216 struct zfcp_port *port,217 struct scsi_device *sdev)218{219 struct zfcp_erp_action *erp_action;220 struct zfcp_scsi_dev *zfcp_sdev;221 222 if (WARN_ON_ONCE(need != ZFCP_ERP_ACTION_REOPEN_LUN &&223 need != ZFCP_ERP_ACTION_REOPEN_PORT &&224 need != ZFCP_ERP_ACTION_REOPEN_PORT_FORCED &&225 need != ZFCP_ERP_ACTION_REOPEN_ADAPTER))226 return NULL;227 228 switch (need) {229 case ZFCP_ERP_ACTION_REOPEN_LUN:230 zfcp_sdev = sdev_to_zfcp(sdev);231 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))232 if (scsi_device_get(sdev))233 return NULL;234 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,235 &zfcp_sdev->status);236 erp_action = &zfcp_sdev->erp_action;237 WARN_ON_ONCE(erp_action->port != port);238 WARN_ON_ONCE(erp_action->sdev != sdev);239 if (!(atomic_read(&zfcp_sdev->status) &240 ZFCP_STATUS_COMMON_RUNNING))241 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;242 break;243 244 case ZFCP_ERP_ACTION_REOPEN_PORT:245 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:246 if (!get_device(&port->dev))247 return NULL;248 zfcp_erp_action_dismiss_port(port);249 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);250 erp_action = &port->erp_action;251 WARN_ON_ONCE(erp_action->port != port);252 WARN_ON_ONCE(erp_action->sdev != NULL);253 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))254 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;255 break;256 257 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:258 kref_get(&adapter->ref);259 zfcp_erp_action_dismiss_adapter(adapter);260 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);261 erp_action = &adapter->erp_action;262 WARN_ON_ONCE(erp_action->port != NULL);263 WARN_ON_ONCE(erp_action->sdev != NULL);264 if (!(atomic_read(&adapter->status) &265 ZFCP_STATUS_COMMON_RUNNING))266 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;267 break;268 }269 270 WARN_ON_ONCE(erp_action->adapter != adapter);271 memset(&erp_action->list, 0, sizeof(erp_action->list));272 memset(&erp_action->timer, 0, sizeof(erp_action->timer));273 erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;274 erp_action->fsf_req_id = 0;275 erp_action->type = need;276 erp_action->status = act_status;277 278 return erp_action;279}280 281static void zfcp_erp_action_enqueue(enum zfcp_erp_act_type want,282 struct zfcp_adapter *adapter,283 struct zfcp_port *port,284 struct scsi_device *sdev,285 char *dbftag, u32 act_status)286{287 enum zfcp_erp_act_type need;288 struct zfcp_erp_action *act;289 290 need = zfcp_erp_handle_failed(want, adapter, port, sdev);291 if (!need) {292 need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */293 goto out;294 }295 296 if (!adapter->erp_thread) {297 need = ZFCP_ERP_ACTION_NONE; /* marker for trace */298 goto out;299 }300 301 need = zfcp_erp_required_act(want, adapter, port, sdev);302 if (!need)303 goto out;304 305 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);306 if (!act) {307 need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */308 goto out;309 }310 atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);311 ++adapter->erp_total_count;312 list_add_tail(&act->list, &adapter->erp_ready_head);313 wake_up(&adapter->erp_ready_wq);314 out:315 zfcp_dbf_rec_trig(dbftag, adapter, port, sdev, want, need);316}317 318void zfcp_erp_port_forced_no_port_dbf(char *dbftag,319 struct zfcp_adapter *adapter,320 u64 port_name, u32 port_id)321{322 unsigned long flags;323 static /* don't waste stack */ struct zfcp_port tmpport;324 325 write_lock_irqsave(&adapter->erp_lock, flags);326 /* Stand-in zfcp port with fields just good enough for327 * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().328 * Under lock because tmpport is static.329 */330 atomic_set(&tmpport.status, -1); /* unknown */331 tmpport.wwpn = port_name;332 tmpport.d_id = port_id;333 zfcp_dbf_rec_trig(dbftag, adapter, &tmpport, NULL,334 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,335 ZFCP_ERP_ACTION_NONE);336 write_unlock_irqrestore(&adapter->erp_lock, flags);337}338 339static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,340 int clear_mask, char *dbftag)341{342 zfcp_erp_adapter_block(adapter, clear_mask);343 zfcp_scsi_schedule_rports_block(adapter);344 345 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,346 adapter, NULL, NULL, dbftag, 0);347}348 349/**350 * zfcp_erp_adapter_reopen - Reopen adapter.351 * @adapter: Adapter to reopen.352 * @clear: Status flags to clear.353 * @dbftag: Tag for debug trace event.354 */355void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,356 char *dbftag)357{358 unsigned long flags;359 360 zfcp_erp_adapter_block(adapter, clear);361 zfcp_scsi_schedule_rports_block(adapter);362 363 write_lock_irqsave(&adapter->erp_lock, flags);364 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,365 NULL, NULL, dbftag, 0);366 write_unlock_irqrestore(&adapter->erp_lock, flags);367}368 369/**370 * zfcp_erp_adapter_shutdown - Shutdown adapter.371 * @adapter: Adapter to shut down.372 * @clear: Status flags to clear.373 * @dbftag: Tag for debug trace event.374 */375void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,376 char *dbftag)377{378 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;379 zfcp_erp_adapter_reopen(adapter, clear | flags, dbftag);380}381 382/**383 * zfcp_erp_port_shutdown - Shutdown port384 * @port: Port to shut down.385 * @clear: Status flags to clear.386 * @dbftag: Tag for debug trace event.387 */388void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *dbftag)389{390 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;391 zfcp_erp_port_reopen(port, clear | flags, dbftag);392}393 394static void zfcp_erp_port_block(struct zfcp_port *port, int clear)395{396 zfcp_erp_clear_port_status(port,397 ZFCP_STATUS_COMMON_UNBLOCKED | clear);398}399 400static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,401 char *dbftag)402{403 zfcp_erp_port_block(port, clear);404 zfcp_scsi_schedule_rport_block(port);405 406 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,407 port->adapter, port, NULL, dbftag, 0);408}409 410/**411 * zfcp_erp_port_forced_reopen - Forced close of port and open again412 * @port: Port to force close and to reopen.413 * @clear: Status flags to clear.414 * @dbftag: Tag for debug trace event.415 */416void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,417 char *dbftag)418{419 unsigned long flags;420 struct zfcp_adapter *adapter = port->adapter;421 422 write_lock_irqsave(&adapter->erp_lock, flags);423 _zfcp_erp_port_forced_reopen(port, clear, dbftag);424 write_unlock_irqrestore(&adapter->erp_lock, flags);425}426 427static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear,428 char *dbftag)429{430 zfcp_erp_port_block(port, clear);431 zfcp_scsi_schedule_rport_block(port);432 433 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,434 port->adapter, port, NULL, dbftag, 0);435}436 437/**438 * zfcp_erp_port_reopen - trigger remote port recovery439 * @port: port to recover440 * @clear: flags in port status to be cleared441 * @dbftag: Tag for debug trace event.442 */443void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *dbftag)444{445 unsigned long flags;446 struct zfcp_adapter *adapter = port->adapter;447 448 write_lock_irqsave(&adapter->erp_lock, flags);449 _zfcp_erp_port_reopen(port, clear, dbftag);450 write_unlock_irqrestore(&adapter->erp_lock, flags);451}452 453static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)454{455 zfcp_erp_clear_lun_status(sdev,456 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);457}458 459static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear,460 char *dbftag, u32 act_status)461{462 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);463 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;464 465 zfcp_erp_lun_block(sdev, clear);466 467 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,468 zfcp_sdev->port, sdev, dbftag, act_status);469}470 471/**472 * zfcp_erp_lun_reopen - initiate reopen of a LUN473 * @sdev: SCSI device / LUN to be reopened474 * @clear: specifies flags in LUN status to be cleared475 * @dbftag: Tag for debug trace event.476 *477 * Return: 0 on success, < 0 on error478 */479void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *dbftag)480{481 unsigned long flags;482 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);483 struct zfcp_port *port = zfcp_sdev->port;484 struct zfcp_adapter *adapter = port->adapter;485 486 write_lock_irqsave(&adapter->erp_lock, flags);487 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);488 write_unlock_irqrestore(&adapter->erp_lock, flags);489}490 491/**492 * zfcp_erp_lun_shutdown - Shutdown LUN493 * @sdev: SCSI device / LUN to shut down.494 * @clear: Status flags to clear.495 * @dbftag: Tag for debug trace event.496 */497void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *dbftag)498{499 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;500 zfcp_erp_lun_reopen(sdev, clear | flags, dbftag);501}502 503/**504 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion505 * @sdev: SCSI device / LUN to shut down.506 * @dbftag: Tag for debug trace event.507 *508 * Do not acquire a reference for the LUN when creating the ERP509 * action. It is safe, because this function waits for the ERP to510 * complete first. This allows to shutdown the LUN, even when the SCSI511 * device is in the state SDEV_DEL when scsi_device_get will fail.512 */513void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *dbftag)514{515 unsigned long flags;516 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);517 struct zfcp_port *port = zfcp_sdev->port;518 struct zfcp_adapter *adapter = port->adapter;519 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;520 521 write_lock_irqsave(&adapter->erp_lock, flags);522 _zfcp_erp_lun_reopen(sdev, clear, dbftag, ZFCP_STATUS_ERP_NO_REF);523 write_unlock_irqrestore(&adapter->erp_lock, flags);524 525 zfcp_erp_wait(adapter);526}527 528static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)529{530 return (atomic_read(status) ^ mask) & mask;531}532 533static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)534{535 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,536 &adapter->status))537 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);538 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);539}540 541static void zfcp_erp_port_unblock(struct zfcp_port *port)542{543 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,544 &port->status))545 zfcp_dbf_rec_run("erpubl1", &port->erp_action);546 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);547}548 549static void zfcp_erp_lun_unblock(struct scsi_device *sdev)550{551 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);552 553 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,554 &zfcp_sdev->status))555 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);556 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);557}558 559static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)560{561 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);562 zfcp_dbf_rec_run("erator1", erp_action);563}564 565static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)566{567 struct zfcp_adapter *adapter = act->adapter;568 struct zfcp_fsf_req *req;569 570 if (!act->fsf_req_id)571 return;572 573 spin_lock(&adapter->req_list->lock);574 req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);575 if (req && req->erp_action == act) {576 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |577 ZFCP_STATUS_ERP_TIMEDOUT)) {578 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;579 zfcp_dbf_rec_run("erscf_1", act);580 /* lock-free concurrent access with581 * zfcp_erp_timeout_handler()582 */583 WRITE_ONCE(req->erp_action, NULL);584 }585 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)586 zfcp_dbf_rec_run("erscf_2", act);587 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)588 act->fsf_req_id = 0;589 } else590 act->fsf_req_id = 0;591 spin_unlock(&adapter->req_list->lock);592}593 594/**595 * zfcp_erp_notify - Trigger ERP action.596 * @erp_action: ERP action to continue.597 * @set_mask: ERP action status flags to set.598 */599void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)600{601 struct zfcp_adapter *adapter = erp_action->adapter;602 unsigned long flags;603 604 write_lock_irqsave(&adapter->erp_lock, flags);605 if (zfcp_erp_action_is_running(erp_action)) {606 erp_action->status |= set_mask;607 zfcp_erp_action_ready(erp_action);608 }609 write_unlock_irqrestore(&adapter->erp_lock, flags);610}611 612/**613 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request614 * @t: timer list entry embedded in zfcp FSF request615 */616void zfcp_erp_timeout_handler(struct timer_list *t)617{618 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);619 struct zfcp_erp_action *act;620 621 if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)622 return;623 /* lock-free concurrent access with zfcp_erp_strategy_check_fsfreq() */624 act = READ_ONCE(fsf_req->erp_action);625 if (!act)626 return;627 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);628}629 630static void zfcp_erp_memwait_handler(struct timer_list *t)631{632 struct zfcp_erp_action *act = from_timer(act, t, timer);633 634 zfcp_erp_notify(act, 0);635}636 637static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)638{639 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);640 erp_action->timer.expires = jiffies + HZ;641 add_timer(&erp_action->timer);642}643 644void zfcp_erp_port_forced_reopen_all(struct zfcp_adapter *adapter,645 int clear, char *dbftag)646{647 unsigned long flags;648 struct zfcp_port *port;649 650 write_lock_irqsave(&adapter->erp_lock, flags);651 read_lock(&adapter->port_list_lock);652 list_for_each_entry(port, &adapter->port_list, list)653 _zfcp_erp_port_forced_reopen(port, clear, dbftag);654 read_unlock(&adapter->port_list_lock);655 write_unlock_irqrestore(&adapter->erp_lock, flags);656}657 658static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,659 int clear, char *dbftag)660{661 struct zfcp_port *port;662 663 read_lock(&adapter->port_list_lock);664 list_for_each_entry(port, &adapter->port_list, list)665 _zfcp_erp_port_reopen(port, clear, dbftag);666 read_unlock(&adapter->port_list_lock);667}668 669static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,670 char *dbftag)671{672 struct scsi_device *sdev;673 674 spin_lock(port->adapter->scsi_host->host_lock);675 __shost_for_each_device(sdev, port->adapter->scsi_host)676 if (sdev_to_zfcp(sdev)->port == port)677 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);678 spin_unlock(port->adapter->scsi_host->host_lock);679}680 681static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)682{683 switch (act->type) {684 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:685 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");686 break;687 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:688 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");689 break;690 case ZFCP_ERP_ACTION_REOPEN_PORT:691 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");692 break;693 case ZFCP_ERP_ACTION_REOPEN_LUN:694 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);695 break;696 }697}698 699static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)700{701 switch (act->type) {702 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:703 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");704 break;705 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:706 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");707 break;708 case ZFCP_ERP_ACTION_REOPEN_PORT:709 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");710 break;711 case ZFCP_ERP_ACTION_REOPEN_LUN:712 /* NOP */713 break;714 }715}716 717static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)718{719 unsigned long flags;720 721 read_lock_irqsave(&adapter->erp_lock, flags);722 if (list_empty(&adapter->erp_ready_head) &&723 list_empty(&adapter->erp_running_head)) {724 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,725 &adapter->status);726 wake_up(&adapter->erp_done_wqh);727 }728 read_unlock_irqrestore(&adapter->erp_lock, flags);729}730 731static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)732{733 struct zfcp_port *port;734 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,735 adapter->peer_d_id);736 if (IS_ERR(port)) /* error or port already attached */737 return;738 zfcp_erp_port_reopen(port, 0, "ereptp1");739}740 741static enum zfcp_erp_act_result zfcp_erp_adapter_strat_fsf_xconf(742 struct zfcp_erp_action *erp_action)743{744 int retries;745 int sleep = 1;746 struct zfcp_adapter *adapter = erp_action->adapter;747 748 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);749 750 for (retries = 7; retries; retries--) {751 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,752 &adapter->status);753 write_lock_irq(&adapter->erp_lock);754 zfcp_erp_action_to_running(erp_action);755 write_unlock_irq(&adapter->erp_lock);756 if (zfcp_fsf_exchange_config_data(erp_action)) {757 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,758 &adapter->status);759 return ZFCP_ERP_FAILED;760 }761 762 wait_event(adapter->erp_ready_wq,763 !list_empty(&adapter->erp_ready_head));764 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)765 break;766 767 if (!(atomic_read(&adapter->status) &768 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))769 break;770 771 ssleep(sleep);772 sleep *= 2;773 }774 775 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,776 &adapter->status);777 778 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))779 return ZFCP_ERP_FAILED;780 781 return ZFCP_ERP_SUCCEEDED;782}783 784static void785zfcp_erp_adapter_strategy_open_ptp_port(struct zfcp_adapter *const adapter)786{787 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)788 zfcp_erp_enqueue_ptp_port(adapter);789}790 791static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf_xport(792 struct zfcp_erp_action *act)793{794 int ret;795 struct zfcp_adapter *adapter = act->adapter;796 797 write_lock_irq(&adapter->erp_lock);798 zfcp_erp_action_to_running(act);799 write_unlock_irq(&adapter->erp_lock);800 801 ret = zfcp_fsf_exchange_port_data(act);802 if (ret == -EOPNOTSUPP)803 return ZFCP_ERP_SUCCEEDED;804 if (ret)805 return ZFCP_ERP_FAILED;806 807 zfcp_dbf_rec_run("erasox1", act);808 wait_event(adapter->erp_ready_wq,809 !list_empty(&adapter->erp_ready_head));810 zfcp_dbf_rec_run("erasox2", act);811 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)812 return ZFCP_ERP_FAILED;813 814 return ZFCP_ERP_SUCCEEDED;815}816 817static enum zfcp_erp_act_result818zfcp_erp_adapter_strategy_alloc_shost(struct zfcp_adapter *const adapter)819{820 struct zfcp_diag_adapter_config_data *const config_data =821 &adapter->diagnostics->config_data;822 struct zfcp_diag_adapter_port_data *const port_data =823 &adapter->diagnostics->port_data;824 unsigned long flags;825 int rc;826 827 rc = zfcp_scsi_adapter_register(adapter);828 if (rc == -EEXIST)829 return ZFCP_ERP_SUCCEEDED;830 else if (rc)831 return ZFCP_ERP_FAILED;832 833 /*834 * We allocated the shost for the first time. Before it was NULL,835 * and so we deferred all updates in the xconf- and xport-data836 * handlers. We need to make up for that now, and make all the updates837 * that would have been done before.838 *839 * We can be sure that xconf- and xport-data succeeded, because840 * otherwise this function is not called. But they might have been841 * incomplete.842 */843 844 spin_lock_irqsave(&config_data->header.access_lock, flags);845 zfcp_scsi_shost_update_config_data(adapter, &config_data->data,846 !!config_data->header.incomplete);847 spin_unlock_irqrestore(&config_data->header.access_lock, flags);848 849 if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {850 spin_lock_irqsave(&port_data->header.access_lock, flags);851 zfcp_scsi_shost_update_port_data(adapter, &port_data->data);852 spin_unlock_irqrestore(&port_data->header.access_lock, flags);853 }854 855 /*856 * There is a remote possibility that the 'Exchange Port Data' request857 * reports a different connectivity status than 'Exchange Config Data'.858 * But any change to the connectivity status of the local optic that859 * happens after the initial xconf request is expected to be reported860 * to us, as soon as we post Status Read Buffers to the FCP channel861 * firmware after this function. So any resulting inconsistency will862 * only be momentary.863 */864 if (config_data->header.incomplete)865 zfcp_fsf_fc_host_link_down(adapter);866 867 return ZFCP_ERP_SUCCEEDED;868}869 870static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf(871 struct zfcp_erp_action *act)872{873 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)874 return ZFCP_ERP_FAILED;875 876 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)877 return ZFCP_ERP_FAILED;878 879 if (zfcp_erp_adapter_strategy_alloc_shost(act->adapter) ==880 ZFCP_ERP_FAILED)881 return ZFCP_ERP_FAILED;882 883 zfcp_erp_adapter_strategy_open_ptp_port(act->adapter);884 885 if (mempool_resize(act->adapter->pool.sr_data,886 act->adapter->stat_read_buf_num))887 return ZFCP_ERP_FAILED;888 889 if (mempool_resize(act->adapter->pool.status_read_req,890 act->adapter->stat_read_buf_num))891 return ZFCP_ERP_FAILED;892 893 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);894 if (zfcp_status_read_refill(act->adapter))895 return ZFCP_ERP_FAILED;896 897 return ZFCP_ERP_SUCCEEDED;898}899 900static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)901{902 struct zfcp_adapter *adapter = act->adapter;903 904 /* close queues to ensure that buffers are not accessed by adapter */905 zfcp_qdio_close(adapter->qdio);906 zfcp_fsf_req_dismiss_all(adapter);907 adapter->fsf_req_seq_no = 0;908 zfcp_fc_wka_ports_force_offline(adapter->gs);909 /* all ports and LUNs are closed */910 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);911 912 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |913 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);914}915 916static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open(917 struct zfcp_erp_action *act)918{919 struct zfcp_adapter *adapter = act->adapter;920 921 if (zfcp_qdio_open(adapter->qdio)) {922 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |923 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,924 &adapter->status);925 return ZFCP_ERP_FAILED;926 }927 928 if (zfcp_erp_adapter_strategy_open_fsf(act)) {929 zfcp_erp_adapter_strategy_close(act);930 return ZFCP_ERP_FAILED;931 }932 933 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);934 935 return ZFCP_ERP_SUCCEEDED;936}937 938static enum zfcp_erp_act_result zfcp_erp_adapter_strategy(939 struct zfcp_erp_action *act)940{941 struct zfcp_adapter *adapter = act->adapter;942 943 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {944 zfcp_erp_adapter_strategy_close(act);945 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)946 return ZFCP_ERP_EXIT;947 }948 949 if (zfcp_erp_adapter_strategy_open(act)) {950 ssleep(8);951 return ZFCP_ERP_FAILED;952 }953 954 return ZFCP_ERP_SUCCEEDED;955}956 957static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy_close(958 struct zfcp_erp_action *act)959{960 int retval;961 962 retval = zfcp_fsf_close_physical_port(act);963 if (retval == -ENOMEM)964 return ZFCP_ERP_NOMEM;965 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;966 if (retval)967 return ZFCP_ERP_FAILED;968 969 return ZFCP_ERP_CONTINUES;970}971 972static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy(973 struct zfcp_erp_action *erp_action)974{975 struct zfcp_port *port = erp_action->port;976 int status = atomic_read(&port->status);977 978 switch (erp_action->step) {979 case ZFCP_ERP_STEP_UNINITIALIZED:980 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&981 (status & ZFCP_STATUS_COMMON_OPEN))982 return zfcp_erp_port_forced_strategy_close(erp_action);983 else984 return ZFCP_ERP_FAILED;985 986 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:987 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))988 return ZFCP_ERP_SUCCEEDED;989 break;990 case ZFCP_ERP_STEP_PORT_CLOSING:991 case ZFCP_ERP_STEP_PORT_OPENING:992 case ZFCP_ERP_STEP_LUN_CLOSING:993 case ZFCP_ERP_STEP_LUN_OPENING:994 /* NOP */995 break;996 }997 return ZFCP_ERP_FAILED;998}999 1000static 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 1014static 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 1028static 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 1041static 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 1083static 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 1111close_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 1118static 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 1126static 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 1138static 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 1150static 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 1183static 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 1220static 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 1258static 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 1292static 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 1317static 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 1332static 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 1375static 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 recovery1411 * @port: zfcp_port whose fc_rport we should try to unblock1412 */1413static 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 or1427 * 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 elsewhere1462 */1463 zfcp_scsi_schedule_rport_register(port);1464 spin_unlock(shost->host_lock);1465 write_unlock_irqrestore(&adapter->erp_lock, flags);1466}1467 1468static 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 reopen1484 * was successfully done and thus overwritten with a new1485 * non-forced reopen at `ersfs_2'. In this case, we must not1486 * 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 } else1502 unregister_service_level(&adapter->service_level);1503 1504 kref_put(&adapter->ref, zfcp_adapter_release);1505 break;1506 }1507}1508 1509static 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 1525static 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 1586check_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 1607static 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 adapter1638 * @adapter: Adapter to start the ERP thread for1639 *1640 * Return: 0 on success, or error code from kthread_run().1641 */1642int 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 has1663 * been shut down and that this operation has been completed. Thus,1664 * there are no pending erp_actions which would need to be handled1665 * here.1666 */1667void 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 adapter1677 * @adapter: adapter for which to wait for completion of its error recovery1678 */1679void 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 bits1688 * @adapter: adapter to change the status1689 * @mask: status bits to change1690 *1691 * Changes in common status bits are propagated to attached ports and LUNs.1692 */1693void 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 completed1712 * yet, so we can't access it, but there are also no SDEVs yet1713 */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 bits1725 * @adapter: adapter to change the status1726 * @mask: status bits to change1727 *1728 * Changes in common status bits are propagated to attached ports and LUNs.1729 */1730void 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 completed1756 * yet, so we can't access it, but there are also no SDEVs yet1757 */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 bits1772 * @port: port to change the status1773 * @mask: status bits to change1774 *1775 * Changes in common status bits are propagated to attached LUNs.1776 */1777void 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 bits1798 * @port: adapter to change the status1799 * @mask: status bits to change1800 *1801 * Changes in common status bits are propagated to attached LUNs.1802 */1803void 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 bits1831 * @sdev: SCSI device / lun to set the status bits1832 * @mask: status bits to change1833 */1834void 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 bits1843 * @sdev: SCSi device / lun to clear the status bits1844 * @mask: status bits to change1845 */1846void 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 */1861void 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}1867