11da177e4SLinus Torvalds /* 24a9d2d8bSAndreas Herrmann * This file is part of the zfcp device driver for 34a9d2d8bSAndreas Herrmann * FCP adapters for IBM System z9 and zSeries. 41da177e4SLinus Torvalds * 54a9d2d8bSAndreas Herrmann * (C) Copyright IBM Corp. 2002, 2006 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 81da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 91da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 101da177e4SLinus Torvalds * any later version. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, 131da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 141da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 151da177e4SLinus Torvalds * GNU General Public License for more details. 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 181da177e4SLinus Torvalds * along with this program; if not, write to the Free Software 191da177e4SLinus Torvalds * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 201da177e4SLinus Torvalds */ 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #define ZFCP_LOG_AREA ZFCP_LOG_AREA_ERP 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #include "zfcp_ext.h" 251da177e4SLinus Torvalds 2664b29a13SAndreas Herrmann static int zfcp_erp_adisc(struct zfcp_port *); 271da177e4SLinus Torvalds static void zfcp_erp_adisc_handler(unsigned long); 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int); 301da177e4SLinus Torvalds static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int); 311da177e4SLinus Torvalds static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int); 321da177e4SLinus Torvalds static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int); 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int); 351da177e4SLinus Torvalds static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int); 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds static void zfcp_erp_adapter_block(struct zfcp_adapter *, int); 381da177e4SLinus Torvalds static void zfcp_erp_adapter_unblock(struct zfcp_adapter *); 391da177e4SLinus Torvalds static void zfcp_erp_port_block(struct zfcp_port *, int); 401da177e4SLinus Torvalds static void zfcp_erp_port_unblock(struct zfcp_port *); 411da177e4SLinus Torvalds static void zfcp_erp_unit_block(struct zfcp_unit *, int); 421da177e4SLinus Torvalds static void zfcp_erp_unit_unblock(struct zfcp_unit *); 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds static int zfcp_erp_thread(void *); 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds static int zfcp_erp_strategy(struct zfcp_erp_action *); 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *); 491da177e4SLinus Torvalds static int zfcp_erp_strategy_memwait(struct zfcp_erp_action *); 501da177e4SLinus Torvalds static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *, int); 511da177e4SLinus Torvalds static int zfcp_erp_strategy_check_unit(struct zfcp_unit *, int); 521da177e4SLinus Torvalds static int zfcp_erp_strategy_check_port(struct zfcp_port *, int); 531da177e4SLinus Torvalds static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int); 541da177e4SLinus Torvalds static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *, 551da177e4SLinus Torvalds struct zfcp_port *, 561da177e4SLinus Torvalds struct zfcp_unit *, int); 571da177e4SLinus Torvalds static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32); 581da177e4SLinus Torvalds static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *, 591da177e4SLinus Torvalds struct zfcp_port *, 601da177e4SLinus Torvalds struct zfcp_unit *, int); 611da177e4SLinus Torvalds static int zfcp_erp_strategy_check_queues(struct zfcp_adapter *); 621da177e4SLinus Torvalds static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int); 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *); 651da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int); 661da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *); 67f6c0e7a7SAndreas Herrmann static void zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *); 68f6c0e7a7SAndreas Herrmann static void zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *); 691da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *); 701da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *); 711da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *); 721da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *); 73aef4a983SMaxim Shchetynin static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *); 741da177e4SLinus Torvalds static int zfcp_erp_adapter_strategy_open_fsf_statusread( 751da177e4SLinus Torvalds struct zfcp_erp_action *); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *); 781da177e4SLinus Torvalds static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *); 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds static int zfcp_erp_port_strategy(struct zfcp_erp_action *); 811da177e4SLinus Torvalds static int zfcp_erp_port_strategy_clearstati(struct zfcp_port *); 821da177e4SLinus Torvalds static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *); 831da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *); 841da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *); 851da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open_nameserver_wakeup( 861da177e4SLinus Torvalds struct zfcp_erp_action *); 871da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *); 881da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *); 891da177e4SLinus Torvalds static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *); 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds static int zfcp_erp_unit_strategy(struct zfcp_erp_action *); 921da177e4SLinus Torvalds static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *); 931da177e4SLinus Torvalds static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *); 941da177e4SLinus Torvalds static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *); 951da177e4SLinus Torvalds 96f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss_port(struct zfcp_port *); 97f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *); 98f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss(struct zfcp_erp_action *); 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *, 1011da177e4SLinus Torvalds struct zfcp_port *, struct zfcp_unit *); 1021da177e4SLinus Torvalds static int zfcp_erp_action_dequeue(struct zfcp_erp_action *); 1031da177e4SLinus Torvalds static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *, 1041da177e4SLinus Torvalds struct zfcp_port *, struct zfcp_unit *, 1051da177e4SLinus Torvalds int); 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static void zfcp_erp_action_ready(struct zfcp_erp_action *); 1081da177e4SLinus Torvalds static int zfcp_erp_action_exists(struct zfcp_erp_action *); 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *); 1111da177e4SLinus Torvalds static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *); 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static void zfcp_erp_memwait_handler(unsigned long); 1141da177e4SLinus Torvalds static void zfcp_erp_timeout_handler(unsigned long); 1151da177e4SLinus Torvalds static inline void zfcp_erp_timeout_init(struct zfcp_erp_action *); 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds /** 1181da177e4SLinus Torvalds * zfcp_fsf_request_timeout_handler - called if a request timed out 1191da177e4SLinus Torvalds * @data: pointer to adapter for handler function 1201da177e4SLinus Torvalds * 1211da177e4SLinus Torvalds * This function needs to be called if requests (ELS, Generic Service, 1221da177e4SLinus Torvalds * or SCSI commands) exceed a certain time limit. The assumption is 1231da177e4SLinus Torvalds * that after the time limit the adapter get stuck. So we trigger a reopen of 1241da177e4SLinus Torvalds * the adapter. This should not be used for error recovery, SCSI abort 1251da177e4SLinus Torvalds * commands and SCSI requests from SCSI mid-layer. 1261da177e4SLinus Torvalds */ 1271da177e4SLinus Torvalds void 1281da177e4SLinus Torvalds zfcp_fsf_request_timeout_handler(unsigned long data) 1291da177e4SLinus Torvalds { 1301da177e4SLinus Torvalds struct zfcp_adapter *adapter; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds adapter = (struct zfcp_adapter *) data; 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds zfcp_erp_adapter_reopen(adapter, 0); 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds 137f6c0e7a7SAndreas Herrmann /** 138f6c0e7a7SAndreas Herrmann * zfcp_fsf_scsi_er_timeout_handler - timeout handler for scsi eh tasks 1391da177e4SLinus Torvalds * 140f6c0e7a7SAndreas Herrmann * This function needs to be called whenever a SCSI error recovery 141f6c0e7a7SAndreas Herrmann * action (abort/reset) does not return. Re-opening the adapter means 142f6c0e7a7SAndreas Herrmann * that the abort/reset command can be returned by zfcp. It won't complete 143f6c0e7a7SAndreas Herrmann * via the adapter anymore (because qdio queues are closed). If ERP is 144f6c0e7a7SAndreas Herrmann * already running on this adapter it will be stopped. 1451da177e4SLinus Torvalds */ 146f6c0e7a7SAndreas Herrmann void zfcp_fsf_scsi_er_timeout_handler(unsigned long data) 1471da177e4SLinus Torvalds { 1481da177e4SLinus Torvalds struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 149f6c0e7a7SAndreas Herrmann unsigned long flags; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds ZFCP_LOG_NORMAL("warning: SCSI error recovery timed out. " 1521da177e4SLinus Torvalds "Restarting all operations on the adapter %s\n", 1531da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 1541da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 1, "eh_lmem_tout"); 1551da177e4SLinus Torvalds 156f6c0e7a7SAndreas Herrmann write_lock_irqsave(&adapter->erp_lock, flags); 157f6c0e7a7SAndreas Herrmann if (atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 158f6c0e7a7SAndreas Herrmann &adapter->status)) { 159f6c0e7a7SAndreas Herrmann zfcp_erp_modify_adapter_status(adapter, 160f6c0e7a7SAndreas Herrmann ZFCP_STATUS_COMMON_UNBLOCKED|ZFCP_STATUS_COMMON_OPEN, 161f6c0e7a7SAndreas Herrmann ZFCP_CLEAR); 162f6c0e7a7SAndreas Herrmann zfcp_erp_action_dismiss_adapter(adapter); 163f6c0e7a7SAndreas Herrmann write_unlock_irqrestore(&adapter->erp_lock, flags); 164f6c0e7a7SAndreas Herrmann /* dismiss all pending requests including requests for ERP */ 165f6c0e7a7SAndreas Herrmann zfcp_fsf_req_dismiss_all(adapter); 166f6c0e7a7SAndreas Herrmann adapter->fsf_req_seq_no = 0; 167f6c0e7a7SAndreas Herrmann } else 168f6c0e7a7SAndreas Herrmann write_unlock_irqrestore(&adapter->erp_lock, flags); 169f6c0e7a7SAndreas Herrmann zfcp_erp_adapter_reopen(adapter, 0); 1701da177e4SLinus Torvalds } 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* 1731da177e4SLinus Torvalds * function: 1741da177e4SLinus Torvalds * 1751da177e4SLinus Torvalds * purpose: called if an adapter failed, 1761da177e4SLinus Torvalds * initiates adapter recovery which is done 1771da177e4SLinus Torvalds * asynchronously 1781da177e4SLinus Torvalds * 179d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 1801da177e4SLinus Torvalds * <0 - failed to initiate action 1811da177e4SLinus Torvalds */ 1821da177e4SLinus Torvalds int 1831da177e4SLinus Torvalds zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds int retval; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_ro"); 1881da177e4SLinus Torvalds ZFCP_LOG_DEBUG("reopen adapter %s\n", 1891da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds zfcp_erp_adapter_block(adapter, clear_mask); 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 1941da177e4SLinus Torvalds ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n", 1951da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 1961da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_ro_f"); 1971da177e4SLinus Torvalds /* ensure propagation of failed status to new devices */ 1981da177e4SLinus Torvalds zfcp_erp_adapter_failed(adapter); 1991da177e4SLinus Torvalds retval = -EIO; 2001da177e4SLinus Torvalds goto out; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, 2031da177e4SLinus Torvalds adapter, NULL, NULL); 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds out: 2061da177e4SLinus Torvalds return retval; 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* 2101da177e4SLinus Torvalds * function: 2111da177e4SLinus Torvalds * 2121da177e4SLinus Torvalds * purpose: Wrappper for zfcp_erp_adapter_reopen_internal 2131da177e4SLinus Torvalds * used to ensure the correct locking 2141da177e4SLinus Torvalds * 215d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 2161da177e4SLinus Torvalds * <0 - failed to initiate action 2171da177e4SLinus Torvalds */ 2181da177e4SLinus Torvalds int 2191da177e4SLinus Torvalds zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask) 2201da177e4SLinus Torvalds { 2211da177e4SLinus Torvalds int retval; 2221da177e4SLinus Torvalds unsigned long flags; 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 2251da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 2261da177e4SLinus Torvalds retval = zfcp_erp_adapter_reopen_internal(adapter, clear_mask); 2271da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 2281da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds return retval; 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds int 2341da177e4SLinus Torvalds zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask) 2351da177e4SLinus Torvalds { 2361da177e4SLinus Torvalds int retval; 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds retval = zfcp_erp_adapter_reopen(adapter, 2391da177e4SLinus Torvalds ZFCP_STATUS_COMMON_RUNNING | 2401da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED | 2411da177e4SLinus Torvalds clear_mask); 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds return retval; 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds int 2471da177e4SLinus Torvalds zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask) 2481da177e4SLinus Torvalds { 2491da177e4SLinus Torvalds int retval; 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds retval = zfcp_erp_port_reopen(port, 2521da177e4SLinus Torvalds ZFCP_STATUS_COMMON_RUNNING | 2531da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED | 2541da177e4SLinus Torvalds clear_mask); 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds return retval; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds int 2601da177e4SLinus Torvalds zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask) 2611da177e4SLinus Torvalds { 2621da177e4SLinus Torvalds int retval; 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds retval = zfcp_erp_unit_reopen(unit, 2651da177e4SLinus Torvalds ZFCP_STATUS_COMMON_RUNNING | 2661da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED | 2671da177e4SLinus Torvalds clear_mask); 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds return retval; 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds /** 2741da177e4SLinus Torvalds * zfcp_erp_adisc - send ADISC ELS command 27564b29a13SAndreas Herrmann * @port: port structure 2761da177e4SLinus Torvalds */ 2771da177e4SLinus Torvalds int 27864b29a13SAndreas Herrmann zfcp_erp_adisc(struct zfcp_port *port) 2791da177e4SLinus Torvalds { 28064b29a13SAndreas Herrmann struct zfcp_adapter *adapter = port->adapter; 2811da177e4SLinus Torvalds struct zfcp_send_els *send_els; 2821da177e4SLinus Torvalds struct zfcp_ls_adisc *adisc; 2831da177e4SLinus Torvalds void *address = NULL; 2841da177e4SLinus Torvalds int retval = 0; 2851da177e4SLinus Torvalds struct timer_list *timer; 2861da177e4SLinus Torvalds 287ec4081c6SAndreas Herrmann send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC); 2881da177e4SLinus Torvalds if (send_els == NULL) 2891da177e4SLinus Torvalds goto nomem; 2901da177e4SLinus Torvalds 291ec4081c6SAndreas Herrmann send_els->req = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC); 2921da177e4SLinus Torvalds if (send_els->req == NULL) 2931da177e4SLinus Torvalds goto nomem; 2941da177e4SLinus Torvalds 295ec4081c6SAndreas Herrmann send_els->resp = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC); 2961da177e4SLinus Torvalds if (send_els->resp == NULL) 2971da177e4SLinus Torvalds goto nomem; 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds address = (void *) get_zeroed_page(GFP_ATOMIC); 3001da177e4SLinus Torvalds if (address == NULL) 3011da177e4SLinus Torvalds goto nomem; 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds zfcp_address_to_sg(address, send_els->req); 3041da177e4SLinus Torvalds address += PAGE_SIZE >> 1; 3051da177e4SLinus Torvalds zfcp_address_to_sg(address, send_els->resp); 3061da177e4SLinus Torvalds send_els->req_count = send_els->resp_count = 1; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds send_els->adapter = adapter; 30964b29a13SAndreas Herrmann send_els->port = port; 31064b29a13SAndreas Herrmann send_els->d_id = port->d_id; 3111da177e4SLinus Torvalds send_els->handler = zfcp_erp_adisc_handler; 3121da177e4SLinus Torvalds send_els->handler_data = (unsigned long) send_els; 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds adisc = zfcp_sg_to_address(send_els->req); 3151da177e4SLinus Torvalds send_els->ls_code = adisc->code = ZFCP_LS_ADISC; 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds send_els->req->length = sizeof(struct zfcp_ls_adisc); 3181da177e4SLinus Torvalds send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc); 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports 3211da177e4SLinus Torvalds without FC-AL-2 capability, so we don't set it */ 32213e1e1f0SAndreas Herrmann adisc->wwpn = fc_host_port_name(adapter->scsi_host); 32313e1e1f0SAndreas Herrmann adisc->wwnn = fc_host_node_name(adapter->scsi_host); 32413e1e1f0SAndreas Herrmann adisc->nport_id = fc_host_port_id(adapter->scsi_host); 3251da177e4SLinus Torvalds ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x " 3261da177e4SLinus Torvalds "(wwpn=0x%016Lx, wwnn=0x%016Lx, " 3271da177e4SLinus Torvalds "hard_nport_id=0x%08x, nport_id=0x%08x)\n", 32813e1e1f0SAndreas Herrmann adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn, 3291da177e4SLinus Torvalds (wwn_t) adisc->wwnn, adisc->hard_nport_id, 3301da177e4SLinus Torvalds adisc->nport_id); 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds timer = kmalloc(sizeof(struct timer_list), GFP_ATOMIC); 3331da177e4SLinus Torvalds if (!timer) 3341da177e4SLinus Torvalds goto nomem; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds init_timer(timer); 3371da177e4SLinus Torvalds timer->function = zfcp_fsf_request_timeout_handler; 3381da177e4SLinus Torvalds timer->data = (unsigned long) adapter; 3391da177e4SLinus Torvalds timer->expires = ZFCP_FSF_REQUEST_TIMEOUT; 3401da177e4SLinus Torvalds send_els->timer = timer; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds retval = zfcp_fsf_send_els(send_els); 3431da177e4SLinus Torvalds if (retval != 0) { 3441da177e4SLinus Torvalds ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port " 34564b29a13SAndreas Herrmann "0x%08x on adapter %s\n", send_els->d_id, 3461da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 3471da177e4SLinus Torvalds del_timer(send_els->timer); 3481da177e4SLinus Torvalds goto freemem; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds goto out; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds nomem: 3541da177e4SLinus Torvalds retval = -ENOMEM; 3551da177e4SLinus Torvalds freemem: 3561da177e4SLinus Torvalds if (address != NULL) 3571da177e4SLinus Torvalds __free_pages(send_els->req->page, 0); 3581da177e4SLinus Torvalds if (send_els != NULL) { 3591da177e4SLinus Torvalds kfree(send_els->timer); 3601da177e4SLinus Torvalds kfree(send_els->req); 3611da177e4SLinus Torvalds kfree(send_els->resp); 3621da177e4SLinus Torvalds kfree(send_els); 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds out: 3651da177e4SLinus Torvalds return retval; 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds /** 3701da177e4SLinus Torvalds * zfcp_erp_adisc_handler - handler for ADISC ELS command 3711da177e4SLinus Torvalds * @data: pointer to struct zfcp_send_els 3721da177e4SLinus Torvalds * 3731da177e4SLinus Torvalds * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered. 3741da177e4SLinus Torvalds */ 3751da177e4SLinus Torvalds void 3761da177e4SLinus Torvalds zfcp_erp_adisc_handler(unsigned long data) 3771da177e4SLinus Torvalds { 3781da177e4SLinus Torvalds struct zfcp_send_els *send_els; 3791da177e4SLinus Torvalds struct zfcp_port *port; 3801da177e4SLinus Torvalds struct zfcp_adapter *adapter; 38113e1e1f0SAndreas Herrmann u32 d_id; 3821da177e4SLinus Torvalds struct zfcp_ls_adisc_acc *adisc; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds send_els = (struct zfcp_send_els *) data; 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds del_timer(send_els->timer); 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds adapter = send_els->adapter; 38964b29a13SAndreas Herrmann port = send_els->port; 3901da177e4SLinus Torvalds d_id = send_els->d_id; 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds /* request rejected or timed out */ 3931da177e4SLinus Torvalds if (send_els->status != 0) { 3941da177e4SLinus Torvalds ZFCP_LOG_NORMAL("ELS request rejected/timed out, " 3951da177e4SLinus Torvalds "force physical port reopen " 3961da177e4SLinus Torvalds "(adapter %s, port d_id=0x%08x)\n", 3971da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter), d_id); 3981da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "forcreop"); 3991da177e4SLinus Torvalds if (zfcp_erp_port_forced_reopen(port, 0)) 4001da177e4SLinus Torvalds ZFCP_LOG_NORMAL("failed reopen of port " 4011da177e4SLinus Torvalds "(adapter %s, wwpn=0x%016Lx)\n", 4021da177e4SLinus Torvalds zfcp_get_busid_by_port(port), 4031da177e4SLinus Torvalds port->wwpn); 4041da177e4SLinus Torvalds goto out; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds adisc = zfcp_sg_to_address(send_els->resp); 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id " 4101da177e4SLinus Torvalds "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, " 4111da177e4SLinus Torvalds "hard_nport_id=0x%08x, nport_id=0x%08x)\n", 41213e1e1f0SAndreas Herrmann d_id, fc_host_port_id(adapter->scsi_host), 41313e1e1f0SAndreas Herrmann (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn, 41413e1e1f0SAndreas Herrmann adisc->hard_nport_id, adisc->nport_id); 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds /* set wwnn for port */ 4171da177e4SLinus Torvalds if (port->wwnn == 0) 4181da177e4SLinus Torvalds port->wwnn = adisc->wwnn; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds if (port->wwpn != adisc->wwpn) { 4211da177e4SLinus Torvalds ZFCP_LOG_NORMAL("d_id assignment changed, reopening " 4221da177e4SLinus Torvalds "port (adapter %s, wwpn=0x%016Lx, " 4231da177e4SLinus Torvalds "adisc_resp_wwpn=0x%016Lx)\n", 4241da177e4SLinus Torvalds zfcp_get_busid_by_port(port), 4251da177e4SLinus Torvalds port->wwpn, (wwn_t) adisc->wwpn); 4261da177e4SLinus Torvalds if (zfcp_erp_port_reopen(port, 0)) 4271da177e4SLinus Torvalds ZFCP_LOG_NORMAL("failed reopen of port " 4281da177e4SLinus Torvalds "(adapter %s, wwpn=0x%016Lx)\n", 4291da177e4SLinus Torvalds zfcp_get_busid_by_port(port), 4301da177e4SLinus Torvalds port->wwpn); 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds out: 4341da177e4SLinus Torvalds zfcp_port_put(port); 4351da177e4SLinus Torvalds __free_pages(send_els->req->page, 0); 4361da177e4SLinus Torvalds kfree(send_els->timer); 4371da177e4SLinus Torvalds kfree(send_els->req); 4381da177e4SLinus Torvalds kfree(send_els->resp); 4391da177e4SLinus Torvalds kfree(send_els); 4401da177e4SLinus Torvalds } 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds /** 4441da177e4SLinus Torvalds * zfcp_test_link - lightweight link test procedure 4451da177e4SLinus Torvalds * @port: port to be tested 4461da177e4SLinus Torvalds * 4471da177e4SLinus Torvalds * Test status of a link to a remote port using the ELS command ADISC. 4481da177e4SLinus Torvalds */ 4491da177e4SLinus Torvalds int 4501da177e4SLinus Torvalds zfcp_test_link(struct zfcp_port *port) 4511da177e4SLinus Torvalds { 4521da177e4SLinus Torvalds int retval; 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds zfcp_port_get(port); 45564b29a13SAndreas Herrmann retval = zfcp_erp_adisc(port); 4561da177e4SLinus Torvalds if (retval != 0) { 4571da177e4SLinus Torvalds zfcp_port_put(port); 4581da177e4SLinus Torvalds ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx " 4591da177e4SLinus Torvalds "on adapter %s\n ", port->wwpn, 4601da177e4SLinus Torvalds zfcp_get_busid_by_port(port)); 4611da177e4SLinus Torvalds retval = zfcp_erp_port_forced_reopen(port, 0); 4621da177e4SLinus Torvalds if (retval != 0) { 4631da177e4SLinus Torvalds ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx " 4641da177e4SLinus Torvalds "on adapter %s failed\n", port->wwpn, 4651da177e4SLinus Torvalds zfcp_get_busid_by_port(port)); 4661da177e4SLinus Torvalds retval = -EPERM; 4671da177e4SLinus Torvalds } 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds return retval; 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds /* 4751da177e4SLinus Torvalds * function: 4761da177e4SLinus Torvalds * 4771da177e4SLinus Torvalds * purpose: called if a port failed to be opened normally 4781da177e4SLinus Torvalds * initiates Forced Reopen recovery which is done 4791da177e4SLinus Torvalds * asynchronously 4801da177e4SLinus Torvalds * 481d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 4821da177e4SLinus Torvalds * <0 - failed to initiate action 4831da177e4SLinus Torvalds */ 4841da177e4SLinus Torvalds static int 4851da177e4SLinus Torvalds zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask) 4861da177e4SLinus Torvalds { 4871da177e4SLinus Torvalds int retval; 4881da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "pf_ro"); 4911da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n", 4941da177e4SLinus Torvalds port->wwpn, zfcp_get_busid_by_port(port)); 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds zfcp_erp_port_block(port, clear_mask); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 4991da177e4SLinus Torvalds ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx " 5001da177e4SLinus Torvalds "on adapter %s\n", port->wwpn, 5011da177e4SLinus Torvalds zfcp_get_busid_by_port(port)); 5021da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "pf_ro_f"); 5031da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 5041da177e4SLinus Torvalds retval = -EIO; 5051da177e4SLinus Torvalds goto out; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED, 5091da177e4SLinus Torvalds port->adapter, port, NULL); 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds out: 5121da177e4SLinus Torvalds return retval; 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds /* 5161da177e4SLinus Torvalds * function: 5171da177e4SLinus Torvalds * 5181da177e4SLinus Torvalds * purpose: Wrappper for zfcp_erp_port_forced_reopen_internal 5191da177e4SLinus Torvalds * used to ensure the correct locking 5201da177e4SLinus Torvalds * 521d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 5221da177e4SLinus Torvalds * <0 - failed to initiate action 5231da177e4SLinus Torvalds */ 5241da177e4SLinus Torvalds int 5251da177e4SLinus Torvalds zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask) 5261da177e4SLinus Torvalds { 5271da177e4SLinus Torvalds int retval; 5281da177e4SLinus Torvalds unsigned long flags; 5291da177e4SLinus Torvalds struct zfcp_adapter *adapter; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds adapter = port->adapter; 5321da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 5331da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 5341da177e4SLinus Torvalds retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask); 5351da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 5361da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds return retval; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds /* 5421da177e4SLinus Torvalds * function: 5431da177e4SLinus Torvalds * 5441da177e4SLinus Torvalds * purpose: called if a port is to be opened 5451da177e4SLinus Torvalds * initiates Reopen recovery which is done 5461da177e4SLinus Torvalds * asynchronously 5471da177e4SLinus Torvalds * 548d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 5491da177e4SLinus Torvalds * <0 - failed to initiate action 5501da177e4SLinus Torvalds */ 5511da177e4SLinus Torvalds static int 5521da177e4SLinus Torvalds zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask) 5531da177e4SLinus Torvalds { 5541da177e4SLinus Torvalds int retval; 5551da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_ro"); 5581da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n", 5611da177e4SLinus Torvalds port->wwpn, zfcp_get_busid_by_port(port)); 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds zfcp_erp_port_block(port, clear_mask); 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 5661da177e4SLinus Torvalds ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx " 5671da177e4SLinus Torvalds "on adapter %s\n", port->wwpn, 5681da177e4SLinus Torvalds zfcp_get_busid_by_port(port)); 5691da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_ro_f"); 5701da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 5711da177e4SLinus Torvalds /* ensure propagation of failed status to new devices */ 5721da177e4SLinus Torvalds zfcp_erp_port_failed(port); 5731da177e4SLinus Torvalds retval = -EIO; 5741da177e4SLinus Torvalds goto out; 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT, 5781da177e4SLinus Torvalds port->adapter, port, NULL); 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds out: 5811da177e4SLinus Torvalds return retval; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds /** 5851da177e4SLinus Torvalds * zfcp_erp_port_reopen - initiate reopen of a remote port 5861da177e4SLinus Torvalds * @port: port to be reopened 5871da177e4SLinus Torvalds * @clear_mask: specifies flags in port status to be cleared 5881da177e4SLinus Torvalds * Return: 0 on success, < 0 on error 5891da177e4SLinus Torvalds * 5901da177e4SLinus Torvalds * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures 5911da177e4SLinus Torvalds * correct locking. An error recovery task is initiated to do the reopen. 5921da177e4SLinus Torvalds * To wait for the completion of the reopen zfcp_erp_wait should be used. 5931da177e4SLinus Torvalds */ 5941da177e4SLinus Torvalds int 5951da177e4SLinus Torvalds zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask) 5961da177e4SLinus Torvalds { 5971da177e4SLinus Torvalds int retval; 5981da177e4SLinus Torvalds unsigned long flags; 5991da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 6021da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 6031da177e4SLinus Torvalds retval = zfcp_erp_port_reopen_internal(port, clear_mask); 6041da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 6051da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds return retval; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds /* 6111da177e4SLinus Torvalds * function: 6121da177e4SLinus Torvalds * 6131da177e4SLinus Torvalds * purpose: called if a unit is to be opened 6141da177e4SLinus Torvalds * initiates Reopen recovery which is done 6151da177e4SLinus Torvalds * asynchronously 6161da177e4SLinus Torvalds * 617d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 6181da177e4SLinus Torvalds * <0 - failed to initiate action 6191da177e4SLinus Torvalds */ 6201da177e4SLinus Torvalds static int 6211da177e4SLinus Torvalds zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask) 6221da177e4SLinus Torvalds { 6231da177e4SLinus Torvalds int retval; 6241da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_ro"); 6271da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 6281da177e4SLinus Torvalds ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx " 6291da177e4SLinus Torvalds "on adapter %s\n", unit->fcp_lun, 6301da177e4SLinus Torvalds unit->port->wwpn, zfcp_get_busid_by_unit(unit)); 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds zfcp_erp_unit_block(unit, clear_mask); 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) { 6351da177e4SLinus Torvalds ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx " 6361da177e4SLinus Torvalds "on port 0x%016Lx on adapter %s\n", 6371da177e4SLinus Torvalds unit->fcp_lun, unit->port->wwpn, 6381da177e4SLinus Torvalds zfcp_get_busid_by_unit(unit)); 6391da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_ro_f"); 6401da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 6411da177e4SLinus Torvalds sizeof (fcp_lun_t)); 6421da177e4SLinus Torvalds retval = -EIO; 6431da177e4SLinus Torvalds goto out; 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT, 6471da177e4SLinus Torvalds unit->port->adapter, unit->port, unit); 6481da177e4SLinus Torvalds out: 6491da177e4SLinus Torvalds return retval; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /** 6531da177e4SLinus Torvalds * zfcp_erp_unit_reopen - initiate reopen of a unit 6541da177e4SLinus Torvalds * @unit: unit to be reopened 6551da177e4SLinus Torvalds * @clear_mask: specifies flags in unit status to be cleared 6561da177e4SLinus Torvalds * Return: 0 on success, < 0 on error 6571da177e4SLinus Torvalds * 6581da177e4SLinus Torvalds * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct 6591da177e4SLinus Torvalds * locking. An error recovery task is initiated to do the reopen. 6601da177e4SLinus Torvalds * To wait for the completion of the reopen zfcp_erp_wait should be used. 6611da177e4SLinus Torvalds */ 6621da177e4SLinus Torvalds int 6631da177e4SLinus Torvalds zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask) 6641da177e4SLinus Torvalds { 6651da177e4SLinus Torvalds int retval; 6661da177e4SLinus Torvalds unsigned long flags; 6671da177e4SLinus Torvalds struct zfcp_adapter *adapter; 6681da177e4SLinus Torvalds struct zfcp_port *port; 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds port = unit->port; 6711da177e4SLinus Torvalds adapter = port->adapter; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 6741da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 6751da177e4SLinus Torvalds retval = zfcp_erp_unit_reopen_internal(unit, clear_mask); 6761da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 6771da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds return retval; 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds 682f6c0e7a7SAndreas Herrmann /** 683f6c0e7a7SAndreas Herrmann * zfcp_erp_adapter_block - mark adapter as blocked, block scsi requests 6841da177e4SLinus Torvalds */ 685f6c0e7a7SAndreas Herrmann static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask) 6861da177e4SLinus Torvalds { 6871da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_bl"); 6881da177e4SLinus Torvalds zfcp_erp_modify_adapter_status(adapter, 6891da177e4SLinus Torvalds ZFCP_STATUS_COMMON_UNBLOCKED | 6901da177e4SLinus Torvalds clear_mask, ZFCP_CLEAR); 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 693f6c0e7a7SAndreas Herrmann /** 694f6c0e7a7SAndreas Herrmann * zfcp_erp_adapter_unblock - mark adapter as unblocked, allow scsi requests 6951da177e4SLinus Torvalds */ 696f6c0e7a7SAndreas Herrmann static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter) 6971da177e4SLinus Torvalds { 6981da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_ubl"); 6991da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status); 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds /* 7031da177e4SLinus Torvalds * function: 7041da177e4SLinus Torvalds * 7051da177e4SLinus Torvalds * purpose: disable I/O, 7061da177e4SLinus Torvalds * return any open requests and clean them up, 7071da177e4SLinus Torvalds * aim: no pending and incoming I/O 7081da177e4SLinus Torvalds * 7091da177e4SLinus Torvalds * returns: 7101da177e4SLinus Torvalds */ 7111da177e4SLinus Torvalds static void 7121da177e4SLinus Torvalds zfcp_erp_port_block(struct zfcp_port *port, int clear_mask) 7131da177e4SLinus Torvalds { 7141da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "p_bl"); 7171da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 7181da177e4SLinus Torvalds zfcp_erp_modify_port_status(port, 7191da177e4SLinus Torvalds ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 7201da177e4SLinus Torvalds ZFCP_CLEAR); 7211da177e4SLinus Torvalds } 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds /* 7241da177e4SLinus Torvalds * function: 7251da177e4SLinus Torvalds * 7261da177e4SLinus Torvalds * purpose: enable I/O 7271da177e4SLinus Torvalds * 7281da177e4SLinus Torvalds * returns: 7291da177e4SLinus Torvalds */ 7301da177e4SLinus Torvalds static void 7311da177e4SLinus Torvalds zfcp_erp_port_unblock(struct zfcp_port *port) 7321da177e4SLinus Torvalds { 7331da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "p_ubl"); 7361da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 7371da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status); 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds /* 7411da177e4SLinus Torvalds * function: 7421da177e4SLinus Torvalds * 7431da177e4SLinus Torvalds * purpose: disable I/O, 7441da177e4SLinus Torvalds * return any open requests and clean them up, 7451da177e4SLinus Torvalds * aim: no pending and incoming I/O 7461da177e4SLinus Torvalds * 7471da177e4SLinus Torvalds * returns: 7481da177e4SLinus Torvalds */ 7491da177e4SLinus Torvalds static void 7501da177e4SLinus Torvalds zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask) 7511da177e4SLinus Torvalds { 7521da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "u_bl"); 7551da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 7561da177e4SLinus Torvalds zfcp_erp_modify_unit_status(unit, 7571da177e4SLinus Torvalds ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 7581da177e4SLinus Torvalds ZFCP_CLEAR); 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds /* 7621da177e4SLinus Torvalds * function: 7631da177e4SLinus Torvalds * 7641da177e4SLinus Torvalds * purpose: enable I/O 7651da177e4SLinus Torvalds * 7661da177e4SLinus Torvalds * returns: 7671da177e4SLinus Torvalds */ 7681da177e4SLinus Torvalds static void 7691da177e4SLinus Torvalds zfcp_erp_unit_unblock(struct zfcp_unit *unit) 7701da177e4SLinus Torvalds { 7711da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "u_ubl"); 7741da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 7751da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status); 7761da177e4SLinus Torvalds } 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds static void 7791da177e4SLinus Torvalds zfcp_erp_action_ready(struct zfcp_erp_action *erp_action) 7801da177e4SLinus Torvalds { 7811da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_ar"); 7841da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int)); 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds zfcp_erp_action_to_ready(erp_action); 7871da177e4SLinus Torvalds up(&adapter->erp_ready_sem); 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds /* 7911da177e4SLinus Torvalds * function: 7921da177e4SLinus Torvalds * 7931da177e4SLinus Torvalds * purpose: 7941da177e4SLinus Torvalds * 7951da177e4SLinus Torvalds * returns: <0 erp_action not found in any list 7961da177e4SLinus Torvalds * ZFCP_ERP_ACTION_READY erp_action is in ready list 7971da177e4SLinus Torvalds * ZFCP_ERP_ACTION_RUNNING erp_action is in running list 7981da177e4SLinus Torvalds * 7991da177e4SLinus Torvalds * locks: erp_lock must be held 8001da177e4SLinus Torvalds */ 8011da177e4SLinus Torvalds static int 8021da177e4SLinus Torvalds zfcp_erp_action_exists(struct zfcp_erp_action *erp_action) 8031da177e4SLinus Torvalds { 8041da177e4SLinus Torvalds int retval = -EINVAL; 8051da177e4SLinus Torvalds struct list_head *entry; 8061da177e4SLinus Torvalds struct zfcp_erp_action *entry_erp_action; 8071da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds /* search in running list */ 8101da177e4SLinus Torvalds list_for_each(entry, &adapter->erp_running_head) { 8111da177e4SLinus Torvalds entry_erp_action = 8121da177e4SLinus Torvalds list_entry(entry, struct zfcp_erp_action, list); 8131da177e4SLinus Torvalds if (entry_erp_action == erp_action) { 8141da177e4SLinus Torvalds retval = ZFCP_ERP_ACTION_RUNNING; 8151da177e4SLinus Torvalds goto out; 8161da177e4SLinus Torvalds } 8171da177e4SLinus Torvalds } 8181da177e4SLinus Torvalds /* search in ready list */ 8191da177e4SLinus Torvalds list_for_each(entry, &adapter->erp_ready_head) { 8201da177e4SLinus Torvalds entry_erp_action = 8211da177e4SLinus Torvalds list_entry(entry, struct zfcp_erp_action, list); 8221da177e4SLinus Torvalds if (entry_erp_action == erp_action) { 8231da177e4SLinus Torvalds retval = ZFCP_ERP_ACTION_READY; 8241da177e4SLinus Torvalds goto out; 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds } 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds out: 8291da177e4SLinus Torvalds return retval; 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds 8321da177e4SLinus Torvalds /* 8331da177e4SLinus Torvalds * purpose: checks current status of action (timed out, dismissed, ...) 8341da177e4SLinus Torvalds * and does appropriate preparations (dismiss fsf request, ...) 8351da177e4SLinus Torvalds * 8361da177e4SLinus Torvalds * locks: called under erp_lock (disabled interrupts) 8371da177e4SLinus Torvalds * 8381da177e4SLinus Torvalds * returns: 0 8391da177e4SLinus Torvalds */ 8401da177e4SLinus Torvalds static int 8411da177e4SLinus Torvalds zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action) 8421da177e4SLinus Torvalds { 8431da177e4SLinus Torvalds int retval = 0; 8443734d24bSAndreas Herrmann struct zfcp_fsf_req *fsf_req = NULL; 8451da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds if (erp_action->fsf_req) { 848fea9d6c7SVolker Sameske /* take lock to ensure that request is not deleted meanwhile */ 849fea9d6c7SVolker Sameske spin_lock(&adapter->req_list_lock); 850fea9d6c7SVolker Sameske if ((!zfcp_reqlist_ismember(adapter, 851fea9d6c7SVolker Sameske erp_action->fsf_req->req_id)) && 852fea9d6c7SVolker Sameske (fsf_req->erp_action == erp_action)) { 8531da177e4SLinus Torvalds /* fsf_req still exists */ 8541da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_ca_req"); 8551da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &fsf_req, 8561da177e4SLinus Torvalds sizeof (unsigned long)); 857fea9d6c7SVolker Sameske /* dismiss fsf_req of timed out/dismissed erp_action */ 8581da177e4SLinus Torvalds if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED | 8591da177e4SLinus Torvalds ZFCP_STATUS_ERP_TIMEDOUT)) { 8601da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, 8611da177e4SLinus Torvalds "a_ca_disreq"); 8621da177e4SLinus Torvalds fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 8651da177e4SLinus Torvalds ZFCP_LOG_NORMAL("error: erp step timed out " 8661da177e4SLinus Torvalds "(action=%d, fsf_req=%p)\n ", 8671da177e4SLinus Torvalds erp_action->action, 8681da177e4SLinus Torvalds erp_action->fsf_req); 8691da177e4SLinus Torvalds } 8701da177e4SLinus Torvalds /* 8711da177e4SLinus Torvalds * If fsf_req is neither dismissed nor completed 8721da177e4SLinus Torvalds * then keep it running asynchronously and don't mess 8731da177e4SLinus Torvalds * with the association of erp_action and fsf_req. 8741da177e4SLinus Torvalds */ 8751da177e4SLinus Torvalds if (fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED | 8761da177e4SLinus Torvalds ZFCP_STATUS_FSFREQ_DISMISSED)) { 8771da177e4SLinus Torvalds /* forget about association between fsf_req 8781da177e4SLinus Torvalds and erp_action */ 8791da177e4SLinus Torvalds fsf_req->erp_action = NULL; 8801da177e4SLinus Torvalds erp_action->fsf_req = NULL; 8811da177e4SLinus Torvalds } 8821da177e4SLinus Torvalds } else { 8831da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq"); 8841da177e4SLinus Torvalds /* 8851da177e4SLinus Torvalds * even if this fsf_req has gone, forget about 8861da177e4SLinus Torvalds * association between erp_action and fsf_req 8871da177e4SLinus Torvalds */ 8881da177e4SLinus Torvalds erp_action->fsf_req = NULL; 8891da177e4SLinus Torvalds } 890fea9d6c7SVolker Sameske spin_unlock(&adapter->req_list_lock); 8911da177e4SLinus Torvalds } else 8921da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq"); 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds return retval; 8951da177e4SLinus Torvalds } 8961da177e4SLinus Torvalds 897f6c0e7a7SAndreas Herrmann /** 898f6c0e7a7SAndreas Herrmann * zfcp_erp_async_handler_nolock - complete erp_action 8991da177e4SLinus Torvalds * 900f6c0e7a7SAndreas Herrmann * Used for normal completion, time-out, dismissal and failure after 901f6c0e7a7SAndreas Herrmann * low memory condition. 9021da177e4SLinus Torvalds */ 903f6c0e7a7SAndreas Herrmann static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action, 9041da177e4SLinus Torvalds unsigned long set_mask) 9051da177e4SLinus Torvalds { 9061da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) { 9091da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex"); 9101da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 2, &erp_action->action, 9111da177e4SLinus Torvalds sizeof (int)); 9121da177e4SLinus Torvalds if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT)) 9131da177e4SLinus Torvalds del_timer(&erp_action->timer); 9141da177e4SLinus Torvalds erp_action->status |= set_mask; 9151da177e4SLinus Torvalds zfcp_erp_action_ready(erp_action); 9161da177e4SLinus Torvalds } else { 9171da177e4SLinus Torvalds /* action is ready or gone - nothing to do */ 9181da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone"); 9191da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &erp_action->action, 9201da177e4SLinus Torvalds sizeof (int)); 921f6c0e7a7SAndreas Herrmann } 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds 924f6c0e7a7SAndreas Herrmann /** 925f6c0e7a7SAndreas Herrmann * zfcp_erp_async_handler - wrapper for erp_async_handler_nolock w/ locking 9261da177e4SLinus Torvalds */ 927f6c0e7a7SAndreas Herrmann void zfcp_erp_async_handler(struct zfcp_erp_action *erp_action, 9281da177e4SLinus Torvalds unsigned long set_mask) 9291da177e4SLinus Torvalds { 9301da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 9311da177e4SLinus Torvalds unsigned long flags; 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds write_lock_irqsave(&adapter->erp_lock, flags); 934f6c0e7a7SAndreas Herrmann zfcp_erp_async_handler_nolock(erp_action, set_mask); 9351da177e4SLinus Torvalds write_unlock_irqrestore(&adapter->erp_lock, flags); 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds /* 9391da177e4SLinus Torvalds * purpose: is called for erp_action which was slept waiting for 9401da177e4SLinus Torvalds * memory becoming avaliable, 9411da177e4SLinus Torvalds * will trigger that this action will be continued 9421da177e4SLinus Torvalds */ 9431da177e4SLinus Torvalds static void 9441da177e4SLinus Torvalds zfcp_erp_memwait_handler(unsigned long data) 9451da177e4SLinus Torvalds { 9461da177e4SLinus Torvalds struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data; 9471da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_mwh"); 9501da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds zfcp_erp_async_handler(erp_action, 0); 9531da177e4SLinus Torvalds } 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds /* 9561da177e4SLinus Torvalds * purpose: is called if an asynchronous erp step timed out, 9571da177e4SLinus Torvalds * action gets an appropriate flag and will be processed 9581da177e4SLinus Torvalds * accordingly 9591da177e4SLinus Torvalds */ 9601da177e4SLinus Torvalds static void 9611da177e4SLinus Torvalds zfcp_erp_timeout_handler(unsigned long data) 9621da177e4SLinus Torvalds { 9631da177e4SLinus Torvalds struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data; 9641da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_th"); 9671da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT); 9701da177e4SLinus Torvalds } 9711da177e4SLinus Torvalds 972f6c0e7a7SAndreas Herrmann /** 973f6c0e7a7SAndreas Herrmann * zfcp_erp_action_dismiss - dismiss an erp_action 9741da177e4SLinus Torvalds * 975f6c0e7a7SAndreas Herrmann * adapter->erp_lock must be held 976f6c0e7a7SAndreas Herrmann * 977f6c0e7a7SAndreas Herrmann * Dismissal of an erp_action is usually required if an erp_action of 978f6c0e7a7SAndreas Herrmann * higher priority is generated. 9791da177e4SLinus Torvalds */ 980f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action) 9811da177e4SLinus Torvalds { 9821da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_adis"); 9851da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED); 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds int 9911da177e4SLinus Torvalds zfcp_erp_thread_setup(struct zfcp_adapter *adapter) 9921da177e4SLinus Torvalds { 9931da177e4SLinus Torvalds int retval = 0; 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD); 9981da177e4SLinus Torvalds if (retval < 0) { 9991da177e4SLinus Torvalds ZFCP_LOG_NORMAL("error: creation of erp thread failed for " 10001da177e4SLinus Torvalds "adapter %s\n", 10011da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 10021da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_thset_fail"); 10031da177e4SLinus Torvalds } else { 10041da177e4SLinus Torvalds wait_event(adapter->erp_thread_wqh, 10051da177e4SLinus Torvalds atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 10061da177e4SLinus Torvalds &adapter->status)); 10071da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_thset_ok"); 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds return (retval < 0); 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds /* 10141da177e4SLinus Torvalds * function: 10151da177e4SLinus Torvalds * 10161da177e4SLinus Torvalds * purpose: 10171da177e4SLinus Torvalds * 10181da177e4SLinus Torvalds * returns: 10191da177e4SLinus Torvalds * 10201da177e4SLinus Torvalds * context: process (i.e. proc-fs or rmmod/insmod) 10211da177e4SLinus Torvalds * 10221da177e4SLinus Torvalds * note: The caller of this routine ensures that the specified 10231da177e4SLinus Torvalds * adapter has been shut down and that this operation 10241da177e4SLinus Torvalds * has been completed. Thus, there are no pending erp_actions 10251da177e4SLinus Torvalds * which would need to be handled here. 10261da177e4SLinus Torvalds */ 10271da177e4SLinus Torvalds int 10281da177e4SLinus Torvalds zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 10291da177e4SLinus Torvalds { 10301da177e4SLinus Torvalds int retval = 0; 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status); 10331da177e4SLinus Torvalds up(&adapter->erp_ready_sem); 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds wait_event(adapter->erp_thread_wqh, 10361da177e4SLinus Torvalds !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 10371da177e4SLinus Torvalds &adapter->status)); 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 10401da177e4SLinus Torvalds &adapter->status); 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_thki_ok"); 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds return retval; 10451da177e4SLinus Torvalds } 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds /* 10481da177e4SLinus Torvalds * purpose: is run as a kernel thread, 10491da177e4SLinus Torvalds * goes through list of error recovery actions of associated adapter 10501da177e4SLinus Torvalds * and delegates single action to execution 10511da177e4SLinus Torvalds * 10521da177e4SLinus Torvalds * returns: 0 10531da177e4SLinus Torvalds */ 10541da177e4SLinus Torvalds static int 10551da177e4SLinus Torvalds zfcp_erp_thread(void *data) 10561da177e4SLinus Torvalds { 10571da177e4SLinus Torvalds struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 10581da177e4SLinus Torvalds struct list_head *next; 10591da177e4SLinus Torvalds struct zfcp_erp_action *erp_action; 10601da177e4SLinus Torvalds unsigned long flags; 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter)); 10631da177e4SLinus Torvalds /* Block all signals */ 10641da177e4SLinus Torvalds siginitsetinv(¤t->blocked, 0); 10651da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 10661da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_th_run"); 10671da177e4SLinus Torvalds wake_up(&adapter->erp_thread_wqh); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 10701da177e4SLinus Torvalds &adapter->status)) { 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds write_lock_irqsave(&adapter->erp_lock, flags); 10731da177e4SLinus Torvalds next = adapter->erp_ready_head.prev; 10741da177e4SLinus Torvalds write_unlock_irqrestore(&adapter->erp_lock, flags); 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds if (next != &adapter->erp_ready_head) { 10771da177e4SLinus Torvalds erp_action = 10781da177e4SLinus Torvalds list_entry(next, struct zfcp_erp_action, list); 10791da177e4SLinus Torvalds /* 10801da177e4SLinus Torvalds * process action (incl. [re]moving it 10811da177e4SLinus Torvalds * from 'ready' queue) 10821da177e4SLinus Torvalds */ 10831da177e4SLinus Torvalds zfcp_erp_strategy(erp_action); 10841da177e4SLinus Torvalds } 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds /* 10871da177e4SLinus Torvalds * sleep as long as there is nothing to do, i.e. 10881da177e4SLinus Torvalds * no action in 'ready' queue to be processed and 10891da177e4SLinus Torvalds * thread is not to be killed 10901da177e4SLinus Torvalds */ 10911da177e4SLinus Torvalds down_interruptible(&adapter->erp_ready_sem); 10921da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_th_woken"); 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 10961da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_th_stop"); 10971da177e4SLinus Torvalds wake_up(&adapter->erp_thread_wqh); 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds return 0; 11001da177e4SLinus Torvalds } 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds /* 11031da177e4SLinus Torvalds * function: 11041da177e4SLinus Torvalds * 11051da177e4SLinus Torvalds * purpose: drives single error recovery action and schedules higher and 11061da177e4SLinus Torvalds * subordinate actions, if necessary 11071da177e4SLinus Torvalds * 11081da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 11091da177e4SLinus Torvalds * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd) 11101da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd) 11111da177e4SLinus Torvalds * ZFCP_ERP_EXIT - action finished (dequeued), offline 11121da177e4SLinus Torvalds * ZFCP_ERP_DISMISSED - action canceled (dequeued) 11131da177e4SLinus Torvalds */ 11141da177e4SLinus Torvalds static int 11151da177e4SLinus Torvalds zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 11161da177e4SLinus Torvalds { 11171da177e4SLinus Torvalds int retval = 0; 11181da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 11191da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 11201da177e4SLinus Torvalds struct zfcp_unit *unit = erp_action->unit; 11211da177e4SLinus Torvalds int action = erp_action->action; 11221da177e4SLinus Torvalds u32 status = erp_action->status; 11231da177e4SLinus Torvalds unsigned long flags; 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds /* serialise dismissing, timing out, moving, enqueueing */ 11261da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 11271da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds /* dequeue dismissed action and leave, if required */ 11301da177e4SLinus Torvalds retval = zfcp_erp_strategy_check_action(erp_action, retval); 11311da177e4SLinus Torvalds if (retval == ZFCP_ERP_DISMISSED) { 11321da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_st_dis1"); 11331da177e4SLinus Torvalds goto unlock; 11341da177e4SLinus Torvalds } 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds /* 11371da177e4SLinus Torvalds * move action to 'running' queue before processing it 11381da177e4SLinus Torvalds * (to avoid a race condition regarding moving the 11391da177e4SLinus Torvalds * action to the 'running' queue and back) 11401da177e4SLinus Torvalds */ 11411da177e4SLinus Torvalds zfcp_erp_action_to_running(erp_action); 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds /* 11441da177e4SLinus Torvalds * try to process action as far as possible, 11451da177e4SLinus Torvalds * no lock to allow for blocking operations (kmalloc, qdio, ...), 11461da177e4SLinus Torvalds * afterwards the lock is required again for the following reasons: 11471da177e4SLinus Torvalds * - dequeueing of finished action and enqueueing of 11481da177e4SLinus Torvalds * follow-up actions must be atomic so that any other 11491da177e4SLinus Torvalds * reopen-routine does not believe there is nothing to do 11501da177e4SLinus Torvalds * and that it is safe to enqueue something else, 11511da177e4SLinus Torvalds * - we want to force any control thread which is dismissing 11521da177e4SLinus Torvalds * actions to finish this before we decide about 11531da177e4SLinus Torvalds * necessary steps to be taken here further 11541da177e4SLinus Torvalds */ 11551da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 11561da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 11571da177e4SLinus Torvalds retval = zfcp_erp_strategy_do_action(erp_action); 11581da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 11591da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds /* 11621da177e4SLinus Torvalds * check for dismissed status again to avoid follow-up actions, 11631da177e4SLinus Torvalds * failing of targets and so on for dismissed actions 11641da177e4SLinus Torvalds */ 11651da177e4SLinus Torvalds retval = zfcp_erp_strategy_check_action(erp_action, retval); 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds switch (retval) { 11681da177e4SLinus Torvalds case ZFCP_ERP_DISMISSED: 11691da177e4SLinus Torvalds /* leave since this action has ridden to its ancestors */ 11701da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_st_dis2"); 11711da177e4SLinus Torvalds goto unlock; 11721da177e4SLinus Torvalds case ZFCP_ERP_NOMEM: 11731da177e4SLinus Torvalds /* no memory to continue immediately, let it sleep */ 11741da177e4SLinus Torvalds if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 11751da177e4SLinus Torvalds ++adapter->erp_low_mem_count; 11761da177e4SLinus Torvalds erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds /* This condition is true if there is no memory available 11791da177e4SLinus Torvalds for any erp_action on this adapter. This implies that there 11801da177e4SLinus Torvalds are no elements in the memory pool(s) left for erp_actions. 11811da177e4SLinus Torvalds This might happen if an erp_action that used a memory pool 11821da177e4SLinus Torvalds element was timed out. 11831da177e4SLinus Torvalds */ 11841da177e4SLinus Torvalds if (adapter->erp_total_count == adapter->erp_low_mem_count) { 11851da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem"); 11861da177e4SLinus Torvalds ZFCP_LOG_NORMAL("error: no mempool elements available, " 11871da177e4SLinus Torvalds "restarting I/O on adapter %s " 11881da177e4SLinus Torvalds "to free mempool\n", 11891da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 11901da177e4SLinus Torvalds zfcp_erp_adapter_reopen_internal(adapter, 0); 11911da177e4SLinus Torvalds } else { 11921da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_st_memw"); 11931da177e4SLinus Torvalds retval = zfcp_erp_strategy_memwait(erp_action); 11941da177e4SLinus Torvalds } 11951da177e4SLinus Torvalds goto unlock; 11961da177e4SLinus Torvalds case ZFCP_ERP_CONTINUES: 11971da177e4SLinus Torvalds /* leave since this action runs asynchronously */ 11981da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_st_cont"); 11991da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 12001da177e4SLinus Torvalds --adapter->erp_low_mem_count; 12011da177e4SLinus Torvalds erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds goto unlock; 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds /* ok, finished action (whatever its result is) */ 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds /* check for unrecoverable targets */ 12081da177e4SLinus Torvalds retval = zfcp_erp_strategy_check_target(erp_action, retval); 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds /* action must be dequeued (here to allow for further ones) */ 12111da177e4SLinus Torvalds zfcp_erp_action_dequeue(erp_action); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds /* 12141da177e4SLinus Torvalds * put this target through the erp mill again if someone has 12151da177e4SLinus Torvalds * requested to change the status of a target being online 12161da177e4SLinus Torvalds * to offline or the other way around 12171da177e4SLinus Torvalds * (old retval is preserved if nothing has to be done here) 12181da177e4SLinus Torvalds */ 12191da177e4SLinus Torvalds retval = zfcp_erp_strategy_statechange(action, status, adapter, 12201da177e4SLinus Torvalds port, unit, retval); 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds /* 12231da177e4SLinus Torvalds * leave if target is in permanent error state or if 12241da177e4SLinus Torvalds * action is repeated in order to process state change 12251da177e4SLinus Torvalds */ 12261da177e4SLinus Torvalds if (retval == ZFCP_ERP_EXIT) { 12271da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_st_exit"); 12281da177e4SLinus Torvalds goto unlock; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds /* trigger follow up actions */ 12321da177e4SLinus Torvalds zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval); 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds unlock: 12351da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 12361da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds if (retval != ZFCP_ERP_CONTINUES) 12391da177e4SLinus Torvalds zfcp_erp_action_cleanup(action, adapter, port, unit, retval); 12401da177e4SLinus Torvalds 12411da177e4SLinus Torvalds /* 12421da177e4SLinus Torvalds * a few tasks remain when the erp queues are empty 12431da177e4SLinus Torvalds * (don't do that if the last action evaluated was dismissed 12441da177e4SLinus Torvalds * since this clearly indicates that there is more to come) : 12451da177e4SLinus Torvalds * - close the name server port if it is open yet 12461da177e4SLinus Torvalds * (enqueues another [probably] final action) 12471da177e4SLinus Torvalds * - otherwise, wake up whoever wants to be woken when we are 12481da177e4SLinus Torvalds * done with erp 12491da177e4SLinus Torvalds */ 12501da177e4SLinus Torvalds if (retval != ZFCP_ERP_DISMISSED) 12511da177e4SLinus Torvalds zfcp_erp_strategy_check_queues(adapter); 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_st_done"); 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds return retval; 12561da177e4SLinus Torvalds } 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds /* 12591da177e4SLinus Torvalds * function: 12601da177e4SLinus Torvalds * 12611da177e4SLinus Torvalds * purpose: 12621da177e4SLinus Torvalds * 12631da177e4SLinus Torvalds * returns: ZFCP_ERP_DISMISSED - if action has been dismissed 12641da177e4SLinus Torvalds * retval - otherwise 12651da177e4SLinus Torvalds */ 12661da177e4SLinus Torvalds static int 12671da177e4SLinus Torvalds zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval) 12681da177e4SLinus Torvalds { 12691da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds zfcp_erp_strategy_check_fsfreq(erp_action); 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 12741da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 12751da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis"); 12761da177e4SLinus Torvalds zfcp_erp_action_dequeue(erp_action); 12771da177e4SLinus Torvalds retval = ZFCP_ERP_DISMISSED; 12781da177e4SLinus Torvalds } else 12791da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis"); 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds return retval; 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds static int 12851da177e4SLinus Torvalds zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 12861da177e4SLinus Torvalds { 12871da177e4SLinus Torvalds int retval = ZFCP_ERP_FAILED; 12881da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 12891da177e4SLinus Torvalds 12901da177e4SLinus Torvalds /* 12911da177e4SLinus Torvalds * try to execute/continue action as far as possible, 12921da177e4SLinus Torvalds * note: no lock in subsequent strategy routines 12931da177e4SLinus Torvalds * (this allows these routine to call schedule, e.g. 12941da177e4SLinus Torvalds * kmalloc with such flags or qdio_initialize & friends) 12951da177e4SLinus Torvalds * Note: in case of timeout, the seperate strategies will fail 12961da177e4SLinus Torvalds * anyhow. No need for a special action. Even worse, a nameserver 12971da177e4SLinus Torvalds * failure would not wake up waiting ports without the call. 12981da177e4SLinus Torvalds */ 12991da177e4SLinus Torvalds switch (erp_action->action) { 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 13021da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy(erp_action); 13031da177e4SLinus Torvalds break; 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 13061da177e4SLinus Torvalds retval = zfcp_erp_port_forced_strategy(erp_action); 13071da177e4SLinus Torvalds break; 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 13101da177e4SLinus Torvalds retval = zfcp_erp_port_strategy(erp_action); 13111da177e4SLinus Torvalds break; 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 13141da177e4SLinus Torvalds retval = zfcp_erp_unit_strategy(erp_action); 13151da177e4SLinus Torvalds break; 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds default: 13181da177e4SLinus Torvalds debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug"); 13191da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 1, &erp_action->action, 13201da177e4SLinus Torvalds sizeof (int)); 13211da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: unknown erp action requested on " 13221da177e4SLinus Torvalds "adapter %s (action=%d)\n", 13231da177e4SLinus Torvalds zfcp_get_busid_by_adapter(erp_action->adapter), 13241da177e4SLinus Torvalds erp_action->action); 13251da177e4SLinus Torvalds } 13261da177e4SLinus Torvalds 13271da177e4SLinus Torvalds return retval; 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds /* 13311da177e4SLinus Torvalds * function: 13321da177e4SLinus Torvalds * 13331da177e4SLinus Torvalds * purpose: triggers retry of this action after a certain amount of time 13341da177e4SLinus Torvalds * by means of timer provided by erp_action 13351da177e4SLinus Torvalds * 13361da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue 13371da177e4SLinus Torvalds */ 13381da177e4SLinus Torvalds static int 13391da177e4SLinus Torvalds zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action) 13401da177e4SLinus Torvalds { 13411da177e4SLinus Torvalds int retval = ZFCP_ERP_CONTINUES; 13421da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_mwinit"); 13451da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 13461da177e4SLinus Torvalds init_timer(&erp_action->timer); 13471da177e4SLinus Torvalds erp_action->timer.function = zfcp_erp_memwait_handler; 13481da177e4SLinus Torvalds erp_action->timer.data = (unsigned long) erp_action; 13491da177e4SLinus Torvalds erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT; 13501da177e4SLinus Torvalds add_timer(&erp_action->timer); 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds return retval; 13531da177e4SLinus Torvalds } 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds /* 13561da177e4SLinus Torvalds * function: zfcp_erp_adapter_failed 13571da177e4SLinus Torvalds * 13581da177e4SLinus Torvalds * purpose: sets the adapter and all underlying devices to ERP_FAILED 13591da177e4SLinus Torvalds * 13601da177e4SLinus Torvalds */ 13611da177e4SLinus Torvalds void 13621da177e4SLinus Torvalds zfcp_erp_adapter_failed(struct zfcp_adapter *adapter) 13631da177e4SLinus Torvalds { 13641da177e4SLinus Torvalds zfcp_erp_modify_adapter_status(adapter, 13651da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 13661da177e4SLinus Torvalds ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n", 13671da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 13681da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 2, "a_afail"); 13691da177e4SLinus Torvalds } 13701da177e4SLinus Torvalds 13711da177e4SLinus Torvalds /* 13721da177e4SLinus Torvalds * function: zfcp_erp_port_failed 13731da177e4SLinus Torvalds * 13741da177e4SLinus Torvalds * purpose: sets the port and all underlying devices to ERP_FAILED 13751da177e4SLinus Torvalds * 13761da177e4SLinus Torvalds */ 13771da177e4SLinus Torvalds void 13781da177e4SLinus Torvalds zfcp_erp_port_failed(struct zfcp_port *port) 13791da177e4SLinus Torvalds { 13801da177e4SLinus Torvalds zfcp_erp_modify_port_status(port, 13811da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 13841da177e4SLinus Torvalds ZFCP_LOG_NORMAL("port erp failed (adapter %s, " 13851da177e4SLinus Torvalds "port d_id=0x%08x)\n", 13861da177e4SLinus Torvalds zfcp_get_busid_by_port(port), port->d_id); 13871da177e4SLinus Torvalds else 13881da177e4SLinus Torvalds ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n", 13891da177e4SLinus Torvalds zfcp_get_busid_by_port(port), port->wwpn); 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds debug_text_event(port->adapter->erp_dbf, 2, "p_pfail"); 13921da177e4SLinus Torvalds debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t)); 13931da177e4SLinus Torvalds } 13941da177e4SLinus Torvalds 13951da177e4SLinus Torvalds /* 13961da177e4SLinus Torvalds * function: zfcp_erp_unit_failed 13971da177e4SLinus Torvalds * 13981da177e4SLinus Torvalds * purpose: sets the unit to ERP_FAILED 13991da177e4SLinus Torvalds * 14001da177e4SLinus Torvalds */ 14011da177e4SLinus Torvalds void 14021da177e4SLinus Torvalds zfcp_erp_unit_failed(struct zfcp_unit *unit) 14031da177e4SLinus Torvalds { 14041da177e4SLinus Torvalds zfcp_erp_modify_unit_status(unit, 14051da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 14061da177e4SLinus Torvalds 14071da177e4SLinus Torvalds ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx " 14081da177e4SLinus Torvalds " on adapter %s\n", unit->fcp_lun, 14091da177e4SLinus Torvalds unit->port->wwpn, zfcp_get_busid_by_unit(unit)); 14101da177e4SLinus Torvalds debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail"); 14111da177e4SLinus Torvalds debug_event(unit->port->adapter->erp_dbf, 2, 14121da177e4SLinus Torvalds &unit->fcp_lun, sizeof (fcp_lun_t)); 14131da177e4SLinus Torvalds } 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds /* 14161da177e4SLinus Torvalds * function: zfcp_erp_strategy_check_target 14171da177e4SLinus Torvalds * 14181da177e4SLinus Torvalds * purpose: increments the erp action count on the device currently in 14191da177e4SLinus Torvalds * recovery if the action failed or resets the count in case of 14201da177e4SLinus Torvalds * success. If a maximum count is exceeded the device is marked 14211da177e4SLinus Torvalds * as ERP_FAILED. 14221da177e4SLinus Torvalds * The 'blocked' state of a target which has been recovered 14231da177e4SLinus Torvalds * successfully is reset. 14241da177e4SLinus Torvalds * 14251da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (not considered) 14261da177e4SLinus Torvalds * ZFCP_ERP_SUCCEEDED - action finished successfully 14271da177e4SLinus Torvalds * ZFCP_ERP_EXIT - action failed and will not continue 14281da177e4SLinus Torvalds */ 14291da177e4SLinus Torvalds static int 14301da177e4SLinus Torvalds zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result) 14311da177e4SLinus Torvalds { 14321da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 14331da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 14341da177e4SLinus Torvalds struct zfcp_unit *unit = erp_action->unit; 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_stct_norm"); 14371da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 14381da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &result, sizeof (int)); 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds switch (erp_action->action) { 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 14431da177e4SLinus Torvalds result = zfcp_erp_strategy_check_unit(unit, result); 14441da177e4SLinus Torvalds break; 14451da177e4SLinus Torvalds 14461da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 14471da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 14481da177e4SLinus Torvalds result = zfcp_erp_strategy_check_port(port, result); 14491da177e4SLinus Torvalds break; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 14521da177e4SLinus Torvalds result = zfcp_erp_strategy_check_adapter(adapter, result); 14531da177e4SLinus Torvalds break; 14541da177e4SLinus Torvalds } 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds return result; 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds static int 14601da177e4SLinus Torvalds zfcp_erp_strategy_statechange(int action, 14611da177e4SLinus Torvalds u32 status, 14621da177e4SLinus Torvalds struct zfcp_adapter *adapter, 14631da177e4SLinus Torvalds struct zfcp_port *port, 14641da177e4SLinus Torvalds struct zfcp_unit *unit, int retval) 14651da177e4SLinus Torvalds { 14661da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_stsc"); 14671da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &action, sizeof (int)); 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds switch (action) { 14701da177e4SLinus Torvalds 14711da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 14721da177e4SLinus Torvalds if (zfcp_erp_strategy_statechange_detected(&adapter->status, 14731da177e4SLinus Torvalds status)) { 14741da177e4SLinus Torvalds zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED); 14751da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 14761da177e4SLinus Torvalds } 14771da177e4SLinus Torvalds break; 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 14801da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 14811da177e4SLinus Torvalds if (zfcp_erp_strategy_statechange_detected(&port->status, 14821da177e4SLinus Torvalds status)) { 14831da177e4SLinus Torvalds zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED); 14841da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 14851da177e4SLinus Torvalds } 14861da177e4SLinus Torvalds break; 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 14891da177e4SLinus Torvalds if (zfcp_erp_strategy_statechange_detected(&unit->status, 14901da177e4SLinus Torvalds status)) { 14911da177e4SLinus Torvalds zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 14921da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 14931da177e4SLinus Torvalds } 14941da177e4SLinus Torvalds break; 14951da177e4SLinus Torvalds } 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds return retval; 14981da177e4SLinus Torvalds } 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds static inline int 15011da177e4SLinus Torvalds zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status) 15021da177e4SLinus Torvalds { 15031da177e4SLinus Torvalds return 15041da177e4SLinus Torvalds /* take it online */ 15051da177e4SLinus Torvalds (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 15061da177e4SLinus Torvalds (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) || 15071da177e4SLinus Torvalds /* take it offline */ 15081da177e4SLinus Torvalds (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 15091da177e4SLinus Torvalds !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)); 15101da177e4SLinus Torvalds } 15111da177e4SLinus Torvalds 15121da177e4SLinus Torvalds static int 15131da177e4SLinus Torvalds zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result) 15141da177e4SLinus Torvalds { 15151da177e4SLinus Torvalds debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct"); 15161da177e4SLinus Torvalds debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun, 15171da177e4SLinus Torvalds sizeof (fcp_lun_t)); 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds switch (result) { 15201da177e4SLinus Torvalds case ZFCP_ERP_SUCCEEDED : 15211da177e4SLinus Torvalds atomic_set(&unit->erp_counter, 0); 15221da177e4SLinus Torvalds zfcp_erp_unit_unblock(unit); 15231da177e4SLinus Torvalds break; 15241da177e4SLinus Torvalds case ZFCP_ERP_FAILED : 15251da177e4SLinus Torvalds atomic_inc(&unit->erp_counter); 15261da177e4SLinus Torvalds if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) 15271da177e4SLinus Torvalds zfcp_erp_unit_failed(unit); 15281da177e4SLinus Torvalds break; 15291da177e4SLinus Torvalds case ZFCP_ERP_EXIT : 15301da177e4SLinus Torvalds /* nothing */ 15311da177e4SLinus Torvalds break; 15321da177e4SLinus Torvalds } 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) { 15351da177e4SLinus Torvalds zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */ 15361da177e4SLinus Torvalds result = ZFCP_ERP_EXIT; 15371da177e4SLinus Torvalds } 15381da177e4SLinus Torvalds 15391da177e4SLinus Torvalds return result; 15401da177e4SLinus Torvalds } 15411da177e4SLinus Torvalds 15421da177e4SLinus Torvalds static int 15431da177e4SLinus Torvalds zfcp_erp_strategy_check_port(struct zfcp_port *port, int result) 15441da177e4SLinus Torvalds { 15451da177e4SLinus Torvalds debug_text_event(port->adapter->erp_dbf, 5, "p_stct"); 15461da177e4SLinus Torvalds debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds switch (result) { 15491da177e4SLinus Torvalds case ZFCP_ERP_SUCCEEDED : 15501da177e4SLinus Torvalds atomic_set(&port->erp_counter, 0); 15511da177e4SLinus Torvalds zfcp_erp_port_unblock(port); 15521da177e4SLinus Torvalds break; 15531da177e4SLinus Torvalds case ZFCP_ERP_FAILED : 15541da177e4SLinus Torvalds atomic_inc(&port->erp_counter); 15551da177e4SLinus Torvalds if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) 15561da177e4SLinus Torvalds zfcp_erp_port_failed(port); 15571da177e4SLinus Torvalds break; 15581da177e4SLinus Torvalds case ZFCP_ERP_EXIT : 15591da177e4SLinus Torvalds /* nothing */ 15601da177e4SLinus Torvalds break; 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 15641da177e4SLinus Torvalds zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */ 15651da177e4SLinus Torvalds result = ZFCP_ERP_EXIT; 15661da177e4SLinus Torvalds } 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds return result; 15691da177e4SLinus Torvalds } 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds static int 15721da177e4SLinus Torvalds zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result) 15731da177e4SLinus Torvalds { 15741da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_stct"); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds switch (result) { 15771da177e4SLinus Torvalds case ZFCP_ERP_SUCCEEDED : 15781da177e4SLinus Torvalds atomic_set(&adapter->erp_counter, 0); 15791da177e4SLinus Torvalds zfcp_erp_adapter_unblock(adapter); 15801da177e4SLinus Torvalds break; 15811da177e4SLinus Torvalds case ZFCP_ERP_FAILED : 15821da177e4SLinus Torvalds atomic_inc(&adapter->erp_counter); 15831da177e4SLinus Torvalds if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) 15841da177e4SLinus Torvalds zfcp_erp_adapter_failed(adapter); 15851da177e4SLinus Torvalds break; 15861da177e4SLinus Torvalds case ZFCP_ERP_EXIT : 15871da177e4SLinus Torvalds /* nothing */ 15881da177e4SLinus Torvalds break; 15891da177e4SLinus Torvalds } 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 15921da177e4SLinus Torvalds zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */ 15931da177e4SLinus Torvalds result = ZFCP_ERP_EXIT; 15941da177e4SLinus Torvalds } 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds return result; 15971da177e4SLinus Torvalds } 15981da177e4SLinus Torvalds 15991da177e4SLinus Torvalds /* 16001da177e4SLinus Torvalds * function: 16011da177e4SLinus Torvalds * 16021da177e4SLinus Torvalds * purpose: remaining things in good cases, 16031da177e4SLinus Torvalds * escalation in bad cases 16041da177e4SLinus Torvalds * 16051da177e4SLinus Torvalds * returns: 16061da177e4SLinus Torvalds */ 16071da177e4SLinus Torvalds static int 16081da177e4SLinus Torvalds zfcp_erp_strategy_followup_actions(int action, 16091da177e4SLinus Torvalds struct zfcp_adapter *adapter, 16101da177e4SLinus Torvalds struct zfcp_port *port, 16111da177e4SLinus Torvalds struct zfcp_unit *unit, int status) 16121da177e4SLinus Torvalds { 16131da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_stfol"); 16141da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &action, sizeof (int)); 16151da177e4SLinus Torvalds 16161da177e4SLinus Torvalds /* initiate follow-up actions depending on success of finished action */ 16171da177e4SLinus Torvalds switch (action) { 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 16201da177e4SLinus Torvalds if (status == ZFCP_ERP_SUCCEEDED) 16211da177e4SLinus Torvalds zfcp_erp_port_reopen_all_internal(adapter, 0); 16221da177e4SLinus Torvalds else 16231da177e4SLinus Torvalds zfcp_erp_adapter_reopen_internal(adapter, 0); 16241da177e4SLinus Torvalds break; 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 16271da177e4SLinus Torvalds if (status == ZFCP_ERP_SUCCEEDED) 16281da177e4SLinus Torvalds zfcp_erp_port_reopen_internal(port, 0); 16291da177e4SLinus Torvalds else 16301da177e4SLinus Torvalds zfcp_erp_adapter_reopen_internal(adapter, 0); 16311da177e4SLinus Torvalds break; 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 16341da177e4SLinus Torvalds if (status == ZFCP_ERP_SUCCEEDED) 16351da177e4SLinus Torvalds zfcp_erp_unit_reopen_all_internal(port, 0); 16361da177e4SLinus Torvalds else 16371da177e4SLinus Torvalds zfcp_erp_port_forced_reopen_internal(port, 0); 16381da177e4SLinus Torvalds break; 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 16411da177e4SLinus Torvalds if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */ 16421da177e4SLinus Torvalds else 16431da177e4SLinus Torvalds zfcp_erp_port_reopen_internal(unit->port, 0); 16441da177e4SLinus Torvalds break; 16451da177e4SLinus Torvalds } 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds return 0; 16481da177e4SLinus Torvalds } 16491da177e4SLinus Torvalds 16501da177e4SLinus Torvalds static int 16511da177e4SLinus Torvalds zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter) 16521da177e4SLinus Torvalds { 16531da177e4SLinus Torvalds unsigned long flags; 16541da177e4SLinus Torvalds 16551da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 16561da177e4SLinus Torvalds read_lock(&adapter->erp_lock); 16571da177e4SLinus Torvalds if (list_empty(&adapter->erp_ready_head) && 16581da177e4SLinus Torvalds list_empty(&adapter->erp_running_head)) { 16591da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_cq_wake"); 16601da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 16611da177e4SLinus Torvalds &adapter->status); 16621da177e4SLinus Torvalds wake_up(&adapter->erp_done_wqh); 16631da177e4SLinus Torvalds } else 16641da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty"); 16651da177e4SLinus Torvalds read_unlock(&adapter->erp_lock); 16661da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 16671da177e4SLinus Torvalds 16681da177e4SLinus Torvalds return 0; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds /** 16721da177e4SLinus Torvalds * zfcp_erp_wait - wait for completion of error recovery on an adapter 16731da177e4SLinus Torvalds * @adapter: adapter for which to wait for completion of its error recovery 16741da177e4SLinus Torvalds * Return: 0 16751da177e4SLinus Torvalds */ 16761da177e4SLinus Torvalds int 16771da177e4SLinus Torvalds zfcp_erp_wait(struct zfcp_adapter *adapter) 16781da177e4SLinus Torvalds { 16791da177e4SLinus Torvalds int retval = 0; 16801da177e4SLinus Torvalds 16811da177e4SLinus Torvalds wait_event(adapter->erp_done_wqh, 16821da177e4SLinus Torvalds !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 16831da177e4SLinus Torvalds &adapter->status)); 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds return retval; 16861da177e4SLinus Torvalds } 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds void 16891da177e4SLinus Torvalds zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, 16901da177e4SLinus Torvalds u32 mask, int set_or_clear) 16911da177e4SLinus Torvalds { 16921da177e4SLinus Torvalds struct zfcp_port *port; 16931da177e4SLinus Torvalds u32 common_mask = mask & ZFCP_COMMON_FLAGS; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds if (set_or_clear == ZFCP_SET) { 16961da177e4SLinus Torvalds atomic_set_mask(mask, &adapter->status); 16971da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s"); 16981da177e4SLinus Torvalds } else { 16991da177e4SLinus Torvalds atomic_clear_mask(mask, &adapter->status); 17001da177e4SLinus Torvalds if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 17011da177e4SLinus Torvalds atomic_set(&adapter->erp_counter, 0); 17021da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c"); 17031da177e4SLinus Torvalds } 17041da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32)); 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds /* Deal with all underlying devices, only pass common_mask */ 17071da177e4SLinus Torvalds if (common_mask) 17081da177e4SLinus Torvalds list_for_each_entry(port, &adapter->port_list_head, list) 17091da177e4SLinus Torvalds zfcp_erp_modify_port_status(port, common_mask, 17101da177e4SLinus Torvalds set_or_clear); 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds /* 17141da177e4SLinus Torvalds * function: zfcp_erp_modify_port_status 17151da177e4SLinus Torvalds * 17161da177e4SLinus Torvalds * purpose: sets the port and all underlying devices to ERP_FAILED 17171da177e4SLinus Torvalds * 17181da177e4SLinus Torvalds */ 17191da177e4SLinus Torvalds void 17201da177e4SLinus Torvalds zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear) 17211da177e4SLinus Torvalds { 17221da177e4SLinus Torvalds struct zfcp_unit *unit; 17231da177e4SLinus Torvalds u32 common_mask = mask & ZFCP_COMMON_FLAGS; 17241da177e4SLinus Torvalds 17251da177e4SLinus Torvalds if (set_or_clear == ZFCP_SET) { 17261da177e4SLinus Torvalds atomic_set_mask(mask, &port->status); 17271da177e4SLinus Torvalds debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s"); 17281da177e4SLinus Torvalds } else { 17291da177e4SLinus Torvalds atomic_clear_mask(mask, &port->status); 17301da177e4SLinus Torvalds if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 17311da177e4SLinus Torvalds atomic_set(&port->erp_counter, 0); 17321da177e4SLinus Torvalds debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c"); 17331da177e4SLinus Torvalds } 17341da177e4SLinus Torvalds debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 17351da177e4SLinus Torvalds debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds /* Modify status of all underlying devices, only pass common mask */ 17381da177e4SLinus Torvalds if (common_mask) 17391da177e4SLinus Torvalds list_for_each_entry(unit, &port->unit_list_head, list) 17401da177e4SLinus Torvalds zfcp_erp_modify_unit_status(unit, common_mask, 17411da177e4SLinus Torvalds set_or_clear); 17421da177e4SLinus Torvalds } 17431da177e4SLinus Torvalds 17441da177e4SLinus Torvalds /* 17451da177e4SLinus Torvalds * function: zfcp_erp_modify_unit_status 17461da177e4SLinus Torvalds * 17471da177e4SLinus Torvalds * purpose: sets the unit to ERP_FAILED 17481da177e4SLinus Torvalds * 17491da177e4SLinus Torvalds */ 17501da177e4SLinus Torvalds void 17511da177e4SLinus Torvalds zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear) 17521da177e4SLinus Torvalds { 17531da177e4SLinus Torvalds if (set_or_clear == ZFCP_SET) { 17541da177e4SLinus Torvalds atomic_set_mask(mask, &unit->status); 17551da177e4SLinus Torvalds debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s"); 17561da177e4SLinus Torvalds } else { 17571da177e4SLinus Torvalds atomic_clear_mask(mask, &unit->status); 17581da177e4SLinus Torvalds if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) { 17591da177e4SLinus Torvalds atomic_set(&unit->erp_counter, 0); 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c"); 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun, 17641da177e4SLinus Torvalds sizeof (fcp_lun_t)); 17651da177e4SLinus Torvalds debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 17661da177e4SLinus Torvalds } 17671da177e4SLinus Torvalds 17681da177e4SLinus Torvalds /* 17691da177e4SLinus Torvalds * function: 17701da177e4SLinus Torvalds * 17711da177e4SLinus Torvalds * purpose: Wrappper for zfcp_erp_port_reopen_all_internal 17721da177e4SLinus Torvalds * used to ensure the correct locking 17731da177e4SLinus Torvalds * 1774d6e05edcSAndreas Mohr * returns: 0 - initiated action successfully 17751da177e4SLinus Torvalds * <0 - failed to initiate action 17761da177e4SLinus Torvalds */ 17771da177e4SLinus Torvalds int 17781da177e4SLinus Torvalds zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask) 17791da177e4SLinus Torvalds { 17801da177e4SLinus Torvalds int retval; 17811da177e4SLinus Torvalds unsigned long flags; 17821da177e4SLinus Torvalds 17831da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 17841da177e4SLinus Torvalds write_lock(&adapter->erp_lock); 17851da177e4SLinus Torvalds retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask); 17861da177e4SLinus Torvalds write_unlock(&adapter->erp_lock); 17871da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds return retval; 17901da177e4SLinus Torvalds } 17911da177e4SLinus Torvalds 17921da177e4SLinus Torvalds static int 17931da177e4SLinus Torvalds zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask) 17941da177e4SLinus Torvalds { 17951da177e4SLinus Torvalds int retval = 0; 17961da177e4SLinus Torvalds struct zfcp_port *port; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds list_for_each_entry(port, &adapter->port_list_head, list) 17991da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 18001da177e4SLinus Torvalds zfcp_erp_port_reopen_internal(port, clear_mask); 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds return retval; 18031da177e4SLinus Torvalds } 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds /* 18061da177e4SLinus Torvalds * function: 18071da177e4SLinus Torvalds * 18081da177e4SLinus Torvalds * purpose: 18091da177e4SLinus Torvalds * 18101da177e4SLinus Torvalds * returns: FIXME 18111da177e4SLinus Torvalds */ 18121da177e4SLinus Torvalds static int 18131da177e4SLinus Torvalds zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask) 18141da177e4SLinus Torvalds { 18151da177e4SLinus Torvalds int retval = 0; 18161da177e4SLinus Torvalds struct zfcp_unit *unit; 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds list_for_each_entry(unit, &port->unit_list_head, list) 18191da177e4SLinus Torvalds zfcp_erp_unit_reopen_internal(unit, clear_mask); 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds return retval; 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds 18241da177e4SLinus Torvalds /* 18251da177e4SLinus Torvalds * function: 18261da177e4SLinus Torvalds * 18271da177e4SLinus Torvalds * purpose: this routine executes the 'Reopen Adapter' action 18281da177e4SLinus Torvalds * (the entire action is processed synchronously, since 18291da177e4SLinus Torvalds * there are no actions which might be run concurrently 18301da177e4SLinus Torvalds * per definition) 18311da177e4SLinus Torvalds * 18321da177e4SLinus Torvalds * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 18331da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 18341da177e4SLinus Torvalds */ 18351da177e4SLinus Torvalds static int 18361da177e4SLinus Torvalds zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action) 18371da177e4SLinus Torvalds { 18381da177e4SLinus Torvalds int retval; 18391da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 18401da177e4SLinus Torvalds 18411da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_close(erp_action); 18421da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 18431da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 18441da177e4SLinus Torvalds else 18451da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_open(erp_action); 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "a_ast/ret"); 18481da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 18491da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds if (retval == ZFCP_ERP_FAILED) { 18521da177e4SLinus Torvalds ZFCP_LOG_INFO("Waiting to allow the adapter %s " 18531da177e4SLinus Torvalds "to recover itself\n", 18541da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 18551da177e4SLinus Torvalds msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME)); 18561da177e4SLinus Torvalds } 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds return retval; 18591da177e4SLinus Torvalds } 18601da177e4SLinus Torvalds 18611da177e4SLinus Torvalds /* 18621da177e4SLinus Torvalds * function: 18631da177e4SLinus Torvalds * 18641da177e4SLinus Torvalds * purpose: 18651da177e4SLinus Torvalds * 18661da177e4SLinus Torvalds * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 18671da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 18681da177e4SLinus Torvalds */ 18691da177e4SLinus Torvalds static int 18701da177e4SLinus Torvalds zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action) 18711da177e4SLinus Torvalds { 18721da177e4SLinus Torvalds int retval; 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, 18751da177e4SLinus Torvalds &erp_action->adapter->status); 18761da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_generic(erp_action, 1); 18771da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, 18781da177e4SLinus Torvalds &erp_action->adapter->status); 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds return retval; 18811da177e4SLinus Torvalds } 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds /* 18841da177e4SLinus Torvalds * function: 18851da177e4SLinus Torvalds * 18861da177e4SLinus Torvalds * purpose: 18871da177e4SLinus Torvalds * 18881da177e4SLinus Torvalds * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 18891da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 18901da177e4SLinus Torvalds */ 18911da177e4SLinus Torvalds static int 18921da177e4SLinus Torvalds zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action) 18931da177e4SLinus Torvalds { 18941da177e4SLinus Torvalds int retval; 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, 18971da177e4SLinus Torvalds &erp_action->adapter->status); 18981da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_generic(erp_action, 0); 18991da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, 19001da177e4SLinus Torvalds &erp_action->adapter->status); 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds return retval; 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds /* 19061da177e4SLinus Torvalds * function: zfcp_register_adapter 19071da177e4SLinus Torvalds * 19081da177e4SLinus Torvalds * purpose: allocate the irq associated with this devno and register 19091da177e4SLinus Torvalds * the FSF adapter with the SCSI stack 19101da177e4SLinus Torvalds * 19111da177e4SLinus Torvalds * returns: 19121da177e4SLinus Torvalds */ 19131da177e4SLinus Torvalds static int 19141da177e4SLinus Torvalds zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close) 19151da177e4SLinus Torvalds { 19161da177e4SLinus Torvalds int retval = ZFCP_ERP_SUCCEEDED; 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds if (close) 19191da177e4SLinus Torvalds goto close_only; 19201da177e4SLinus Torvalds 19211da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_open_qdio(erp_action); 19221da177e4SLinus Torvalds if (retval != ZFCP_ERP_SUCCEEDED) 19231da177e4SLinus Torvalds goto failed_qdio; 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds retval = zfcp_erp_adapter_strategy_open_fsf(erp_action); 19261da177e4SLinus Torvalds if (retval != ZFCP_ERP_SUCCEEDED) 19271da177e4SLinus Torvalds goto failed_openfcp; 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status); 19301da177e4SLinus Torvalds goto out; 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds close_only: 19331da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 19341da177e4SLinus Torvalds &erp_action->adapter->status); 19351da177e4SLinus Torvalds 19361da177e4SLinus Torvalds failed_openfcp: 19371da177e4SLinus Torvalds zfcp_erp_adapter_strategy_close_qdio(erp_action); 19381da177e4SLinus Torvalds zfcp_erp_adapter_strategy_close_fsf(erp_action); 19391da177e4SLinus Torvalds failed_qdio: 19401da177e4SLinus Torvalds out: 19411da177e4SLinus Torvalds return retval; 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds /* 19451da177e4SLinus Torvalds * function: zfcp_qdio_init 19461da177e4SLinus Torvalds * 19471da177e4SLinus Torvalds * purpose: setup QDIO operation for specified adapter 19481da177e4SLinus Torvalds * 19491da177e4SLinus Torvalds * returns: 0 - successful setup 19501da177e4SLinus Torvalds * !0 - failed setup 19511da177e4SLinus Torvalds */ 19521da177e4SLinus Torvalds int 19531da177e4SLinus Torvalds zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action) 19541da177e4SLinus Torvalds { 19551da177e4SLinus Torvalds int retval; 19561da177e4SLinus Torvalds int i; 19571da177e4SLinus Torvalds volatile struct qdio_buffer_element *sbale; 19581da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 19611da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on " 19621da177e4SLinus Torvalds "adapter %s\n", 19631da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 19641da177e4SLinus Torvalds goto failed_sanity; 19651da177e4SLinus Torvalds } 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds if (qdio_establish(&adapter->qdio_init_data) != 0) { 19681da177e4SLinus Torvalds ZFCP_LOG_INFO("error: establishment of QDIO queues failed " 19691da177e4SLinus Torvalds "on adapter %s\n", 19701da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 19711da177e4SLinus Torvalds goto failed_qdio_establish; 19721da177e4SLinus Torvalds } 19731da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_est"); 19741da177e4SLinus Torvalds 19751da177e4SLinus Torvalds if (qdio_activate(adapter->ccw_device, 0) != 0) { 19761da177e4SLinus Torvalds ZFCP_LOG_INFO("error: activation of QDIO queues failed " 19771da177e4SLinus Torvalds "on adapter %s\n", 19781da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 19791da177e4SLinus Torvalds goto failed_qdio_activate; 19801da177e4SLinus Torvalds } 19811da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_act"); 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds /* 19841da177e4SLinus Torvalds * put buffers into response queue, 19851da177e4SLinus Torvalds */ 19861da177e4SLinus Torvalds for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) { 19871da177e4SLinus Torvalds sbale = &(adapter->response_queue.buffer[i]->element[0]); 19881da177e4SLinus Torvalds sbale->length = 0; 19891da177e4SLinus Torvalds sbale->flags = SBAL_FLAGS_LAST_ENTRY; 19901da177e4SLinus Torvalds sbale->addr = 0; 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds 19931da177e4SLinus Torvalds ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " 19941da177e4SLinus Torvalds "queue_no=%i, index_in_queue=%i, count=%i)\n", 19951da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter), 19961da177e4SLinus Torvalds QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q); 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds retval = do_QDIO(adapter->ccw_device, 19991da177e4SLinus Torvalds QDIO_FLAG_SYNC_INPUT, 20001da177e4SLinus Torvalds 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL); 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds if (retval) { 20031da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n", 20041da177e4SLinus Torvalds retval); 20051da177e4SLinus Torvalds goto failed_do_qdio; 20061da177e4SLinus Torvalds } else { 20071da177e4SLinus Torvalds adapter->response_queue.free_index = 0; 20081da177e4SLinus Torvalds atomic_set(&adapter->response_queue.free_count, 0); 20091da177e4SLinus Torvalds ZFCP_LOG_DEBUG("%i buffers successfully enqueued to " 20101da177e4SLinus Torvalds "response queue\n", QDIO_MAX_BUFFERS_PER_Q); 20111da177e4SLinus Torvalds } 20121da177e4SLinus Torvalds /* set index of first avalable SBALS / number of available SBALS */ 20131da177e4SLinus Torvalds adapter->request_queue.free_index = 0; 20141da177e4SLinus Torvalds atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q); 20151da177e4SLinus Torvalds adapter->request_queue.distance_from_int = 0; 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds /* initialize waitqueue used to wait for free SBALs in requests queue */ 20181da177e4SLinus Torvalds init_waitqueue_head(&adapter->request_wq); 20191da177e4SLinus Torvalds 20201da177e4SLinus Torvalds /* ok, we did it - skip all cleanups for different failures */ 20211da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 20221da177e4SLinus Torvalds retval = ZFCP_ERP_SUCCEEDED; 20231da177e4SLinus Torvalds goto out; 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds failed_do_qdio: 20261da177e4SLinus Torvalds /* NOP */ 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds failed_qdio_activate: 20291da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_down1a"); 20301da177e4SLinus Torvalds while (qdio_shutdown(adapter->ccw_device, 20311da177e4SLinus Torvalds QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 20321da177e4SLinus Torvalds msleep(1000); 20331da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_down1b"); 20341da177e4SLinus Torvalds 20351da177e4SLinus Torvalds failed_qdio_establish: 20361da177e4SLinus Torvalds failed_sanity: 20371da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 20381da177e4SLinus Torvalds 20391da177e4SLinus Torvalds out: 20401da177e4SLinus Torvalds return retval; 20411da177e4SLinus Torvalds } 20421da177e4SLinus Torvalds 2043f6c0e7a7SAndreas Herrmann /** 2044f6c0e7a7SAndreas Herrmann * zfcp_erp_adapter_strategy_close_qdio - close qdio queues for an adapter 20451da177e4SLinus Torvalds */ 2046f6c0e7a7SAndreas Herrmann static void 20471da177e4SLinus Torvalds zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action) 20481da177e4SLinus Torvalds { 20491da177e4SLinus Torvalds int first_used; 20501da177e4SLinus Torvalds int used_count; 20511da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 20541da177e4SLinus Torvalds ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO " 20551da177e4SLinus Torvalds "queues on adapter %s\n", 20561da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 2057f6c0e7a7SAndreas Herrmann return; 20581da177e4SLinus Torvalds } 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds /* 20611da177e4SLinus Torvalds * Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that 20621da177e4SLinus Torvalds * do_QDIO won't be called while qdio_shutdown is in progress. 20631da177e4SLinus Torvalds */ 20641da177e4SLinus Torvalds write_lock_irq(&adapter->request_queue.queue_lock); 20651da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 20661da177e4SLinus Torvalds write_unlock_irq(&adapter->request_queue.queue_lock); 20671da177e4SLinus Torvalds 20681da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_down2a"); 20691da177e4SLinus Torvalds while (qdio_shutdown(adapter->ccw_device, 20701da177e4SLinus Torvalds QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 20711da177e4SLinus Torvalds msleep(1000); 20721da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "qdio_down2b"); 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds /* 20751da177e4SLinus Torvalds * First we had to stop QDIO operation. 20761da177e4SLinus Torvalds * Now it is safe to take the following actions. 20771da177e4SLinus Torvalds */ 20781da177e4SLinus Torvalds 20791da177e4SLinus Torvalds /* Cleanup only necessary when there are unacknowledged buffers */ 20801da177e4SLinus Torvalds if (atomic_read(&adapter->request_queue.free_count) 20811da177e4SLinus Torvalds < QDIO_MAX_BUFFERS_PER_Q) { 20821da177e4SLinus Torvalds first_used = (adapter->request_queue.free_index + 20831da177e4SLinus Torvalds atomic_read(&adapter->request_queue.free_count)) 20841da177e4SLinus Torvalds % QDIO_MAX_BUFFERS_PER_Q; 20851da177e4SLinus Torvalds used_count = QDIO_MAX_BUFFERS_PER_Q - 20861da177e4SLinus Torvalds atomic_read(&adapter->request_queue.free_count); 20871da177e4SLinus Torvalds zfcp_qdio_zero_sbals(adapter->request_queue.buffer, 20881da177e4SLinus Torvalds first_used, used_count); 20891da177e4SLinus Torvalds } 20901da177e4SLinus Torvalds adapter->response_queue.free_index = 0; 20911da177e4SLinus Torvalds atomic_set(&adapter->response_queue.free_count, 0); 20921da177e4SLinus Torvalds adapter->request_queue.free_index = 0; 20931da177e4SLinus Torvalds atomic_set(&adapter->request_queue.free_count, 0); 20941da177e4SLinus Torvalds adapter->request_queue.distance_from_int = 0; 20951da177e4SLinus Torvalds } 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds static int 20981da177e4SLinus Torvalds zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action) 20991da177e4SLinus Torvalds { 21002448c459SAndreas Herrmann int retval; 21011da177e4SLinus Torvalds 21022448c459SAndreas Herrmann retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action); 21032448c459SAndreas Herrmann if (retval == ZFCP_ERP_FAILED) 21042448c459SAndreas Herrmann return ZFCP_ERP_FAILED; 21052448c459SAndreas Herrmann 21062448c459SAndreas Herrmann retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); 21072448c459SAndreas Herrmann if (retval == ZFCP_ERP_FAILED) 2108aef4a983SMaxim Shchetynin return ZFCP_ERP_FAILED; 2109aef4a983SMaxim Shchetynin 2110aef4a983SMaxim Shchetynin return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action); 21111da177e4SLinus Torvalds } 21121da177e4SLinus Torvalds 21131da177e4SLinus Torvalds static int 21141da177e4SLinus Torvalds zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action) 21151da177e4SLinus Torvalds { 21161da177e4SLinus Torvalds int retval = ZFCP_ERP_SUCCEEDED; 21171da177e4SLinus Torvalds int retries; 211822753fa5SAndreas Herrmann int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP; 21191da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); 21221da177e4SLinus Torvalds 212322753fa5SAndreas Herrmann for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) { 21241da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 21251da177e4SLinus Torvalds &adapter->status); 21261da177e4SLinus Torvalds ZFCP_LOG_DEBUG("Doing exchange config data\n"); 21279f09c548SHeiko Carstens write_lock_irq(&adapter->erp_lock); 21281da177e4SLinus Torvalds zfcp_erp_action_to_running(erp_action); 21299f09c548SHeiko Carstens write_unlock_irq(&adapter->erp_lock); 21301da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 21311da177e4SLinus Torvalds if (zfcp_fsf_exchange_config_data(erp_action)) { 21321da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 21331da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf"); 21341da177e4SLinus Torvalds ZFCP_LOG_INFO("error: initiation of exchange of " 21351da177e4SLinus Torvalds "configuration data failed for " 21361da177e4SLinus Torvalds "adapter %s\n", 21371da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 21381da177e4SLinus Torvalds break; 21391da177e4SLinus Torvalds } 21401da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok"); 21411da177e4SLinus Torvalds ZFCP_LOG_DEBUG("Xchange underway\n"); 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds /* 21441da177e4SLinus Torvalds * Why this works: 21451da177e4SLinus Torvalds * Both the normal completion handler as well as the timeout 21461da177e4SLinus Torvalds * handler will do an 'up' when the 'exchange config data' 21471da177e4SLinus Torvalds * request completes or times out. Thus, the signal to go on 21481da177e4SLinus Torvalds * won't be lost utilizing this semaphore. 21491da177e4SLinus Torvalds * Furthermore, this 'adapter_reopen' action is 21501da177e4SLinus Torvalds * guaranteed to be the only action being there (highest action 21511da177e4SLinus Torvalds * which prevents other actions from being created). 21521da177e4SLinus Torvalds * Resulting from that, the wake signal recognized here 21531da177e4SLinus Torvalds * _must_ be the one belonging to the 'exchange config 21541da177e4SLinus Torvalds * data' request. 21551da177e4SLinus Torvalds */ 21561da177e4SLinus Torvalds down(&adapter->erp_ready_sem); 21571da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 21581da177e4SLinus Torvalds ZFCP_LOG_INFO("error: exchange of configuration data " 21591da177e4SLinus Torvalds "for adapter %s timed out\n", 21601da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds } 216322753fa5SAndreas Herrmann 216422753fa5SAndreas Herrmann if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 216522753fa5SAndreas Herrmann &adapter->status)) 216622753fa5SAndreas Herrmann break; 216722753fa5SAndreas Herrmann 21681da177e4SLinus Torvalds ZFCP_LOG_DEBUG("host connection still initialising... " 21691da177e4SLinus Torvalds "waiting and retrying...\n"); 21701da177e4SLinus Torvalds /* sleep a little bit before retry */ 217122753fa5SAndreas Herrmann msleep(jiffies_to_msecs(sleep)); 217222753fa5SAndreas Herrmann sleep *= 2; 21731da177e4SLinus Torvalds } 21741da177e4SLinus Torvalds 21751da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 21761da177e4SLinus Torvalds &adapter->status)) { 21771da177e4SLinus Torvalds ZFCP_LOG_INFO("error: exchange of configuration data for " 21781da177e4SLinus Torvalds "adapter %s failed\n", 21791da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 21801da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 21811da177e4SLinus Torvalds } 21821da177e4SLinus Torvalds 21831da177e4SLinus Torvalds return retval; 21841da177e4SLinus Torvalds } 21851da177e4SLinus Torvalds 2186aef4a983SMaxim Shchetynin static int 2187aef4a983SMaxim Shchetynin zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action) 2188aef4a983SMaxim Shchetynin { 21892448c459SAndreas Herrmann int ret; 21902f8f3ed5SAndreas Herrmann struct zfcp_adapter *adapter; 2191aef4a983SMaxim Shchetynin 21922f8f3ed5SAndreas Herrmann adapter = erp_action->adapter; 2193aef4a983SMaxim Shchetynin atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); 2194aef4a983SMaxim Shchetynin 21959f09c548SHeiko Carstens write_lock_irq(&adapter->erp_lock); 2196aef4a983SMaxim Shchetynin zfcp_erp_action_to_running(erp_action); 21979f09c548SHeiko Carstens write_unlock_irq(&adapter->erp_lock); 21982f8f3ed5SAndreas Herrmann 2199aef4a983SMaxim Shchetynin zfcp_erp_timeout_init(erp_action); 22002448c459SAndreas Herrmann ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL); 22012448c459SAndreas Herrmann if (ret == -EOPNOTSUPP) { 22022448c459SAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp"); 22032448c459SAndreas Herrmann return ZFCP_ERP_SUCCEEDED; 22042448c459SAndreas Herrmann } else if (ret) { 22052448c459SAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "a_xport_failed"); 22062448c459SAndreas Herrmann return ZFCP_ERP_FAILED; 2207aef4a983SMaxim Shchetynin } 22082448c459SAndreas Herrmann debug_text_event(adapter->erp_dbf, 6, "a_xport_ok"); 2209aef4a983SMaxim Shchetynin 22102f8f3ed5SAndreas Herrmann ret = ZFCP_ERP_SUCCEEDED; 2211aef4a983SMaxim Shchetynin down(&adapter->erp_ready_sem); 2212aef4a983SMaxim Shchetynin if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 22132f8f3ed5SAndreas Herrmann ZFCP_LOG_INFO("error: exchange port data timed out (adapter " 22142f8f3ed5SAndreas Herrmann "%s)\n", zfcp_get_busid_by_adapter(adapter)); 22152f8f3ed5SAndreas Herrmann ret = ZFCP_ERP_FAILED; 2216aef4a983SMaxim Shchetynin } 2217f6c0e7a7SAndreas Herrmann 2218f6c0e7a7SAndreas Herrmann /* don't treat as error for the sake of compatibility */ 2219f6c0e7a7SAndreas Herrmann if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status)) 2220f6c0e7a7SAndreas Herrmann ZFCP_LOG_INFO("warning: exchange port data failed (adapter " 22212f8f3ed5SAndreas Herrmann "%s\n", zfcp_get_busid_by_adapter(adapter)); 2222aef4a983SMaxim Shchetynin 22232f8f3ed5SAndreas Herrmann return ret; 2224aef4a983SMaxim Shchetynin } 2225aef4a983SMaxim Shchetynin 22261da177e4SLinus Torvalds static int 22271da177e4SLinus Torvalds zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action 22281da177e4SLinus Torvalds *erp_action) 22291da177e4SLinus Torvalds { 22301da177e4SLinus Torvalds int retval = ZFCP_ERP_SUCCEEDED; 22311da177e4SLinus Torvalds int temp_ret; 22321da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 22331da177e4SLinus Torvalds int i; 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds adapter->status_read_failed = 0; 22361da177e4SLinus Torvalds for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) { 22371da177e4SLinus Torvalds temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL); 22381da177e4SLinus Torvalds if (temp_ret < 0) { 22391da177e4SLinus Torvalds ZFCP_LOG_INFO("error: set-up of unsolicited status " 22401da177e4SLinus Torvalds "notification failed on adapter %s\n", 22411da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 22421da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 22431da177e4SLinus Torvalds i--; 22441da177e4SLinus Torvalds break; 22451da177e4SLinus Torvalds } 22461da177e4SLinus Torvalds } 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds return retval; 22491da177e4SLinus Torvalds } 22501da177e4SLinus Torvalds 2251f6c0e7a7SAndreas Herrmann /** 2252f6c0e7a7SAndreas Herrmann * zfcp_erp_adapter_strategy_close_fsf - stop FSF operations for an adapter 22531da177e4SLinus Torvalds */ 2254f6c0e7a7SAndreas Herrmann static void 22551da177e4SLinus Torvalds zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action) 22561da177e4SLinus Torvalds { 22571da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 22581da177e4SLinus Torvalds 22591da177e4SLinus Torvalds /* 22601da177e4SLinus Torvalds * wake waiting initiators of requests, 22611da177e4SLinus Torvalds * return SCSI commands (with error status), 22621da177e4SLinus Torvalds * clean up all requests (synchronously) 22631da177e4SLinus Torvalds */ 22641da177e4SLinus Torvalds zfcp_fsf_req_dismiss_all(adapter); 22651da177e4SLinus Torvalds /* reset FSF request sequence number */ 22661da177e4SLinus Torvalds adapter->fsf_req_seq_no = 0; 22671da177e4SLinus Torvalds /* all ports and units are closed */ 22681da177e4SLinus Torvalds zfcp_erp_modify_adapter_status(adapter, 22691da177e4SLinus Torvalds ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR); 22701da177e4SLinus Torvalds } 22711da177e4SLinus Torvalds 22721da177e4SLinus Torvalds /* 22731da177e4SLinus Torvalds * function: 22741da177e4SLinus Torvalds * 22751da177e4SLinus Torvalds * purpose: this routine executes the 'Reopen Physical Port' action 22761da177e4SLinus Torvalds * 22771da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 22781da177e4SLinus Torvalds * ZFCP_ERP_SUCCEEDED - action finished successfully 22791da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 22801da177e4SLinus Torvalds */ 22811da177e4SLinus Torvalds static int 22821da177e4SLinus Torvalds zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action) 22831da177e4SLinus Torvalds { 22841da177e4SLinus Torvalds int retval = ZFCP_ERP_FAILED; 22851da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 22861da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 22871da177e4SLinus Torvalds 22881da177e4SLinus Torvalds switch (erp_action->step) { 22891da177e4SLinus Torvalds 22901da177e4SLinus Torvalds /* 22911da177e4SLinus Torvalds * FIXME: 22921da177e4SLinus Torvalds * the ULP spec. begs for waiting for oustanding commands 22931da177e4SLinus Torvalds */ 22941da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNINITIALIZED: 22951da177e4SLinus Torvalds zfcp_erp_port_strategy_clearstati(port); 22961da177e4SLinus Torvalds /* 22971da177e4SLinus Torvalds * it would be sufficient to test only the normal open flag 22981da177e4SLinus Torvalds * since the phys. open flag cannot be set if the normal 22991da177e4SLinus Torvalds * open flag is unset - however, this is for readabilty ... 23001da177e4SLinus Torvalds */ 23011da177e4SLinus Torvalds if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN | 23021da177e4SLinus Torvalds ZFCP_STATUS_COMMON_OPEN), 23031da177e4SLinus Torvalds &port->status)) { 23041da177e4SLinus Torvalds ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 23051da177e4SLinus Torvalds "close physical\n", port->wwpn); 23061da177e4SLinus Torvalds retval = 23071da177e4SLinus Torvalds zfcp_erp_port_forced_strategy_close(erp_action); 23081da177e4SLinus Torvalds } else 23091da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 23101da177e4SLinus Torvalds break; 23111da177e4SLinus Torvalds 23121da177e4SLinus Torvalds case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 23131da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN, 23141da177e4SLinus Torvalds &port->status)) { 23151da177e4SLinus Torvalds ZFCP_LOG_DEBUG("close physical failed for port " 23161da177e4SLinus Torvalds "0x%016Lx\n", port->wwpn); 23171da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 23181da177e4SLinus Torvalds } else 23191da177e4SLinus Torvalds retval = ZFCP_ERP_SUCCEEDED; 23201da177e4SLinus Torvalds break; 23211da177e4SLinus Torvalds } 23221da177e4SLinus Torvalds 23231da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret"); 23241da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 23251da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 23261da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 23271da177e4SLinus Torvalds 23281da177e4SLinus Torvalds return retval; 23291da177e4SLinus Torvalds } 23301da177e4SLinus Torvalds 23311da177e4SLinus Torvalds /* 23321da177e4SLinus Torvalds * function: 23331da177e4SLinus Torvalds * 23341da177e4SLinus Torvalds * purpose: this routine executes the 'Reopen Port' action 23351da177e4SLinus Torvalds * 23361da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 23371da177e4SLinus Torvalds * ZFCP_ERP_SUCCEEDED - action finished successfully 23381da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 23391da177e4SLinus Torvalds */ 23401da177e4SLinus Torvalds static int 23411da177e4SLinus Torvalds zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 23421da177e4SLinus Torvalds { 23431da177e4SLinus Torvalds int retval = ZFCP_ERP_FAILED; 23441da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 23451da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 23461da177e4SLinus Torvalds 23471da177e4SLinus Torvalds switch (erp_action->step) { 23481da177e4SLinus Torvalds 23491da177e4SLinus Torvalds /* 23501da177e4SLinus Torvalds * FIXME: 23511da177e4SLinus Torvalds * the ULP spec. begs for waiting for oustanding commands 23521da177e4SLinus Torvalds */ 23531da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNINITIALIZED: 23541da177e4SLinus Torvalds zfcp_erp_port_strategy_clearstati(port); 23551da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 23561da177e4SLinus Torvalds ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 23571da177e4SLinus Torvalds "close\n", port->wwpn); 23581da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_close(erp_action); 23591da177e4SLinus Torvalds goto out; 23601da177e4SLinus Torvalds } /* else it's already closed, open it */ 23611da177e4SLinus Torvalds break; 23621da177e4SLinus Torvalds 23631da177e4SLinus Torvalds case ZFCP_ERP_STEP_PORT_CLOSING: 23641da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 23651da177e4SLinus Torvalds ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n", 23661da177e4SLinus Torvalds port->wwpn); 23671da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 23681da177e4SLinus Torvalds goto out; 23691da177e4SLinus Torvalds } /* else it's closed now, open it */ 23701da177e4SLinus Torvalds break; 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 23731da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 23741da177e4SLinus Torvalds else 23751da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open(erp_action); 23761da177e4SLinus Torvalds 23771da177e4SLinus Torvalds out: 23781da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "p_pst/ret"); 23791da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 23801da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 23811da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 23821da177e4SLinus Torvalds 23831da177e4SLinus Torvalds return retval; 23841da177e4SLinus Torvalds } 23851da177e4SLinus Torvalds 23861da177e4SLinus Torvalds static int 23871da177e4SLinus Torvalds zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action) 23881da177e4SLinus Torvalds { 23891da177e4SLinus Torvalds int retval; 23901da177e4SLinus Torvalds 23911da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, 23921da177e4SLinus Torvalds &erp_action->port->status)) 23931da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open_nameserver(erp_action); 23941da177e4SLinus Torvalds else 23951da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open_common(erp_action); 23961da177e4SLinus Torvalds 23971da177e4SLinus Torvalds return retval; 23981da177e4SLinus Torvalds } 23991da177e4SLinus Torvalds 24001da177e4SLinus Torvalds static int 24011da177e4SLinus Torvalds zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action) 24021da177e4SLinus Torvalds { 24031da177e4SLinus Torvalds int retval = 0; 24041da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 24051da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds switch (erp_action->step) { 24081da177e4SLinus Torvalds 24091da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNINITIALIZED: 24101da177e4SLinus Torvalds case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 24111da177e4SLinus Torvalds case ZFCP_ERP_STEP_PORT_CLOSING: 2412ad757cdfSAndreas Herrmann if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) { 24136f71d9bcS if (port->wwpn != adapter->peer_wwpn) { 24146f71d9bcS ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx " 24156f71d9bcS "on adapter %s.\nPeer WWPN " 24166f71d9bcS "0x%016Lx does not match\n", 24176f71d9bcS port->wwpn, 24186f71d9bcS zfcp_get_busid_by_adapter(adapter), 24196f71d9bcS adapter->peer_wwpn); 24206f71d9bcS zfcp_erp_port_failed(port); 24216f71d9bcS retval = ZFCP_ERP_FAILED; 24226f71d9bcS break; 24236f71d9bcS } 24246f71d9bcS port->d_id = adapter->peer_d_id; 24256f71d9bcS atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status); 24266f71d9bcS retval = zfcp_erp_port_strategy_open_port(erp_action); 24276f71d9bcS break; 24286f71d9bcS } 24291da177e4SLinus Torvalds if (!(adapter->nameserver_port)) { 24301da177e4SLinus Torvalds retval = zfcp_nameserver_enqueue(adapter); 24311da177e4SLinus Torvalds if (retval != 0) { 24321da177e4SLinus Torvalds ZFCP_LOG_NORMAL("error: nameserver port " 24331da177e4SLinus Torvalds "unavailable for adapter %s\n", 24341da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 24351da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 24361da177e4SLinus Torvalds break; 24371da177e4SLinus Torvalds } 24381da177e4SLinus Torvalds } 24391da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED, 24401da177e4SLinus Torvalds &adapter->nameserver_port->status)) { 24411da177e4SLinus Torvalds ZFCP_LOG_DEBUG("nameserver port is not open -> open " 24421da177e4SLinus Torvalds "nameserver port\n"); 24431da177e4SLinus Torvalds /* nameserver port may live again */ 24441da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, 24451da177e4SLinus Torvalds &adapter->nameserver_port->status); 24461da177e4SLinus Torvalds if (zfcp_erp_port_reopen(adapter->nameserver_port, 0) 24471da177e4SLinus Torvalds >= 0) { 24481da177e4SLinus Torvalds erp_action->step = 24491da177e4SLinus Torvalds ZFCP_ERP_STEP_NAMESERVER_OPEN; 24501da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 24511da177e4SLinus Torvalds } else 24521da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 24531da177e4SLinus Torvalds break; 24541da177e4SLinus Torvalds } 24551da177e4SLinus Torvalds /* else nameserver port is already open, fall through */ 24561da177e4SLinus Torvalds case ZFCP_ERP_STEP_NAMESERVER_OPEN: 24571da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, 24581da177e4SLinus Torvalds &adapter->nameserver_port->status)) { 24591da177e4SLinus Torvalds ZFCP_LOG_DEBUG("open failed for nameserver port\n"); 24601da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 24611da177e4SLinus Torvalds } else { 24621da177e4SLinus Torvalds ZFCP_LOG_DEBUG("nameserver port is open -> " 24631da177e4SLinus Torvalds "nameserver look-up for port 0x%016Lx\n", 24641da177e4SLinus Torvalds port->wwpn); 24651da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open_common_lookup 24661da177e4SLinus Torvalds (erp_action); 24671da177e4SLinus Torvalds } 24681da177e4SLinus Torvalds break; 24691da177e4SLinus Torvalds 24701da177e4SLinus Torvalds case ZFCP_ERP_STEP_NAMESERVER_LOOKUP: 24711da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) { 24721da177e4SLinus Torvalds if (atomic_test_mask 24731da177e4SLinus Torvalds (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) { 24741da177e4SLinus Torvalds ZFCP_LOG_DEBUG("nameserver look-up failed " 24751da177e4SLinus Torvalds "for port 0x%016Lx " 24761da177e4SLinus Torvalds "(misconfigured WWPN?)\n", 24771da177e4SLinus Torvalds port->wwpn); 24781da177e4SLinus Torvalds zfcp_erp_port_failed(port); 24791da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 24801da177e4SLinus Torvalds } else { 24811da177e4SLinus Torvalds ZFCP_LOG_DEBUG("nameserver look-up failed for " 24821da177e4SLinus Torvalds "port 0x%016Lx\n", port->wwpn); 24831da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 24841da177e4SLinus Torvalds } 24851da177e4SLinus Torvalds } else { 24861da177e4SLinus Torvalds ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> " 24871da177e4SLinus Torvalds "trying open\n", port->wwpn, port->d_id); 24881da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open_port(erp_action); 24891da177e4SLinus Torvalds } 24901da177e4SLinus Torvalds break; 24911da177e4SLinus Torvalds 24921da177e4SLinus Torvalds case ZFCP_ERP_STEP_PORT_OPENING: 24931da177e4SLinus Torvalds /* D_ID might have changed during open */ 24941da177e4SLinus Torvalds if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN | 24951da177e4SLinus Torvalds ZFCP_STATUS_PORT_DID_DID), 24961da177e4SLinus Torvalds &port->status)) { 24971da177e4SLinus Torvalds ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn); 24981da177e4SLinus Torvalds retval = ZFCP_ERP_SUCCEEDED; 24991da177e4SLinus Torvalds } else { 25001da177e4SLinus Torvalds ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n", 25011da177e4SLinus Torvalds port->wwpn); 25021da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 25031da177e4SLinus Torvalds } 25041da177e4SLinus Torvalds break; 25051da177e4SLinus Torvalds 25061da177e4SLinus Torvalds default: 25071da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 25081da177e4SLinus Torvalds erp_action->step); 25091da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 25101da177e4SLinus Torvalds } 25111da177e4SLinus Torvalds 25121da177e4SLinus Torvalds return retval; 25131da177e4SLinus Torvalds } 25141da177e4SLinus Torvalds 25151da177e4SLinus Torvalds static int 25161da177e4SLinus Torvalds zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action) 25171da177e4SLinus Torvalds { 25181da177e4SLinus Torvalds int retval; 25191da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 25201da177e4SLinus Torvalds 25211da177e4SLinus Torvalds switch (erp_action->step) { 25221da177e4SLinus Torvalds 25231da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNINITIALIZED: 25241da177e4SLinus Torvalds case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 25251da177e4SLinus Torvalds case ZFCP_ERP_STEP_PORT_CLOSING: 25261da177e4SLinus Torvalds ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n", 25271da177e4SLinus Torvalds port->wwpn, port->d_id); 25281da177e4SLinus Torvalds retval = zfcp_erp_port_strategy_open_port(erp_action); 25291da177e4SLinus Torvalds break; 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds case ZFCP_ERP_STEP_PORT_OPENING: 25321da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 25331da177e4SLinus Torvalds ZFCP_LOG_DEBUG("WKA port is open\n"); 25341da177e4SLinus Torvalds retval = ZFCP_ERP_SUCCEEDED; 25351da177e4SLinus Torvalds } else { 25361da177e4SLinus Torvalds ZFCP_LOG_DEBUG("open failed for WKA port\n"); 25371da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 25381da177e4SLinus Torvalds } 25391da177e4SLinus Torvalds /* this is needed anyway (dont care for retval of wakeup) */ 25401da177e4SLinus Torvalds ZFCP_LOG_DEBUG("continue other open port operations\n"); 25411da177e4SLinus Torvalds zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action); 25421da177e4SLinus Torvalds break; 25431da177e4SLinus Torvalds 25441da177e4SLinus Torvalds default: 25451da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 25461da177e4SLinus Torvalds erp_action->step); 25471da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 25481da177e4SLinus Torvalds } 25491da177e4SLinus Torvalds 25501da177e4SLinus Torvalds return retval; 25511da177e4SLinus Torvalds } 25521da177e4SLinus Torvalds 25531da177e4SLinus Torvalds /* 25541da177e4SLinus Torvalds * function: 25551da177e4SLinus Torvalds * 25561da177e4SLinus Torvalds * purpose: makes the erp thread continue with reopen (physical) port 25571da177e4SLinus Torvalds * actions which have been paused until the name server port 25581da177e4SLinus Torvalds * is opened (or failed) 25591da177e4SLinus Torvalds * 25601da177e4SLinus Torvalds * returns: 0 (a kind of void retval, its not used) 25611da177e4SLinus Torvalds */ 25621da177e4SLinus Torvalds static int 25631da177e4SLinus Torvalds zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action 25641da177e4SLinus Torvalds *ns_erp_action) 25651da177e4SLinus Torvalds { 25661da177e4SLinus Torvalds int retval = 0; 25671da177e4SLinus Torvalds unsigned long flags; 25681da177e4SLinus Torvalds struct zfcp_adapter *adapter = ns_erp_action->adapter; 25691da177e4SLinus Torvalds struct zfcp_erp_action *erp_action, *tmp; 25701da177e4SLinus Torvalds 25711da177e4SLinus Torvalds read_lock_irqsave(&adapter->erp_lock, flags); 25721da177e4SLinus Torvalds list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head, 25731da177e4SLinus Torvalds list) { 25741da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n"); 25751da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn, 25761da177e4SLinus Torvalds sizeof (wwn_t)); 25771da177e4SLinus Torvalds if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) { 25781da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w"); 25791da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, 25801da177e4SLinus Torvalds &erp_action->port->wwpn, sizeof (wwn_t)); 25811da177e4SLinus Torvalds if (atomic_test_mask( 25821da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ERP_FAILED, 25831da177e4SLinus Torvalds &adapter->nameserver_port->status)) 25841da177e4SLinus Torvalds zfcp_erp_port_failed(erp_action->port); 25851da177e4SLinus Torvalds zfcp_erp_action_ready(erp_action); 25861da177e4SLinus Torvalds } 25871da177e4SLinus Torvalds } 25881da177e4SLinus Torvalds read_unlock_irqrestore(&adapter->erp_lock, flags); 25891da177e4SLinus Torvalds 25901da177e4SLinus Torvalds return retval; 25911da177e4SLinus Torvalds } 25921da177e4SLinus Torvalds 25931da177e4SLinus Torvalds /* 25941da177e4SLinus Torvalds * function: 25951da177e4SLinus Torvalds * 25961da177e4SLinus Torvalds * purpose: 25971da177e4SLinus Torvalds * 25981da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 25991da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 26001da177e4SLinus Torvalds */ 26011da177e4SLinus Torvalds static int 26021da177e4SLinus Torvalds zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action) 26031da177e4SLinus Torvalds { 26041da177e4SLinus Torvalds int retval; 26051da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 26061da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 26071da177e4SLinus Torvalds 26081da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 26091da177e4SLinus Torvalds retval = zfcp_fsf_close_physical_port(erp_action); 26101da177e4SLinus Torvalds if (retval == -ENOMEM) { 26111da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem"); 26121da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 26131da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 26141da177e4SLinus Torvalds goto out; 26151da177e4SLinus Torvalds } 26161da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING; 26171da177e4SLinus Torvalds if (retval != 0) { 26181da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf"); 26191da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 26201da177e4SLinus Torvalds /* could not send 'open', fail */ 26211da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 26221da177e4SLinus Torvalds goto out; 26231da177e4SLinus Torvalds } 26241da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok"); 26251da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 26261da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 26271da177e4SLinus Torvalds out: 26281da177e4SLinus Torvalds return retval; 26291da177e4SLinus Torvalds } 26301da177e4SLinus Torvalds 26311da177e4SLinus Torvalds static int 26321da177e4SLinus Torvalds zfcp_erp_port_strategy_clearstati(struct zfcp_port *port) 26331da177e4SLinus Torvalds { 26341da177e4SLinus Torvalds int retval = 0; 26351da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 26361da177e4SLinus Torvalds 26371da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_pstclst"); 26381da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 26391da177e4SLinus Torvalds 26401da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 26411da177e4SLinus Torvalds ZFCP_STATUS_COMMON_CLOSING | 26421da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ACCESS_DENIED | 26431da177e4SLinus Torvalds ZFCP_STATUS_PORT_DID_DID | 26441da177e4SLinus Torvalds ZFCP_STATUS_PORT_PHYS_CLOSING | 26451da177e4SLinus Torvalds ZFCP_STATUS_PORT_INVALID_WWPN, 26461da177e4SLinus Torvalds &port->status); 26471da177e4SLinus Torvalds return retval; 26481da177e4SLinus Torvalds } 26491da177e4SLinus Torvalds 26501da177e4SLinus Torvalds /* 26511da177e4SLinus Torvalds * function: 26521da177e4SLinus Torvalds * 26531da177e4SLinus Torvalds * purpose: 26541da177e4SLinus Torvalds * 26551da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 26561da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 26571da177e4SLinus Torvalds */ 26581da177e4SLinus Torvalds static int 26591da177e4SLinus Torvalds zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action) 26601da177e4SLinus Torvalds { 26611da177e4SLinus Torvalds int retval; 26621da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 26631da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 26641da177e4SLinus Torvalds 26651da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 26661da177e4SLinus Torvalds retval = zfcp_fsf_close_port(erp_action); 26671da177e4SLinus Torvalds if (retval == -ENOMEM) { 26681da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem"); 26691da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 26701da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 26711da177e4SLinus Torvalds goto out; 26721da177e4SLinus Torvalds } 26731da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING; 26741da177e4SLinus Torvalds if (retval != 0) { 26751da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf"); 26761da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 26771da177e4SLinus Torvalds /* could not send 'close', fail */ 26781da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 26791da177e4SLinus Torvalds goto out; 26801da177e4SLinus Torvalds } 26811da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok"); 26821da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 26831da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 26841da177e4SLinus Torvalds out: 26851da177e4SLinus Torvalds return retval; 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds 26881da177e4SLinus Torvalds /* 26891da177e4SLinus Torvalds * function: 26901da177e4SLinus Torvalds * 26911da177e4SLinus Torvalds * purpose: 26921da177e4SLinus Torvalds * 26931da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 26941da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 26951da177e4SLinus Torvalds */ 26961da177e4SLinus Torvalds static int 26971da177e4SLinus Torvalds zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 26981da177e4SLinus Torvalds { 26991da177e4SLinus Torvalds int retval; 27001da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 27011da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 27021da177e4SLinus Torvalds 27031da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 27041da177e4SLinus Torvalds retval = zfcp_fsf_open_port(erp_action); 27051da177e4SLinus Torvalds if (retval == -ENOMEM) { 27061da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem"); 27071da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 27081da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 27091da177e4SLinus Torvalds goto out; 27101da177e4SLinus Torvalds } 27111da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_PORT_OPENING; 27121da177e4SLinus Torvalds if (retval != 0) { 27131da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_psto_opf"); 27141da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 27151da177e4SLinus Torvalds /* could not send 'open', fail */ 27161da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 27171da177e4SLinus Torvalds goto out; 27181da177e4SLinus Torvalds } 27191da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "p_psto_opok"); 27201da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 27211da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 27221da177e4SLinus Torvalds out: 27231da177e4SLinus Torvalds return retval; 27241da177e4SLinus Torvalds } 27251da177e4SLinus Torvalds 27261da177e4SLinus Torvalds /* 27271da177e4SLinus Torvalds * function: 27281da177e4SLinus Torvalds * 27291da177e4SLinus Torvalds * purpose: 27301da177e4SLinus Torvalds * 27311da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 27321da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 27331da177e4SLinus Torvalds */ 27341da177e4SLinus Torvalds static int 27351da177e4SLinus Torvalds zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action) 27361da177e4SLinus Torvalds { 27371da177e4SLinus Torvalds int retval; 27381da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 27391da177e4SLinus Torvalds struct zfcp_port *port = erp_action->port; 27401da177e4SLinus Torvalds 27411da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 27421da177e4SLinus Torvalds retval = zfcp_ns_gid_pn_request(erp_action); 27431da177e4SLinus Torvalds if (retval == -ENOMEM) { 27441da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem"); 27451da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 27461da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 27471da177e4SLinus Torvalds goto out; 27481da177e4SLinus Torvalds } 27491da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP; 27501da177e4SLinus Torvalds if (retval != 0) { 27511da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref"); 27521da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 27531da177e4SLinus Torvalds /* could not send nameserver request, fail */ 27541da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 27551da177e4SLinus Torvalds goto out; 27561da177e4SLinus Torvalds } 27571da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok"); 27581da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 27591da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 27601da177e4SLinus Torvalds out: 27611da177e4SLinus Torvalds return retval; 27621da177e4SLinus Torvalds } 27631da177e4SLinus Torvalds 27641da177e4SLinus Torvalds /* 27651da177e4SLinus Torvalds * function: 27661da177e4SLinus Torvalds * 27671da177e4SLinus Torvalds * purpose: this routine executes the 'Reopen Unit' action 27681da177e4SLinus Torvalds * currently no retries 27691da177e4SLinus Torvalds * 27701da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 27711da177e4SLinus Torvalds * ZFCP_ERP_SUCCEEDED - action finished successfully 27721da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 27731da177e4SLinus Torvalds */ 27741da177e4SLinus Torvalds static int 27751da177e4SLinus Torvalds zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action) 27761da177e4SLinus Torvalds { 27771da177e4SLinus Torvalds int retval = ZFCP_ERP_FAILED; 27781da177e4SLinus Torvalds struct zfcp_unit *unit = erp_action->unit; 27791da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 27801da177e4SLinus Torvalds 27811da177e4SLinus Torvalds switch (erp_action->step) { 27821da177e4SLinus Torvalds 27831da177e4SLinus Torvalds /* 27841da177e4SLinus Torvalds * FIXME: 27851da177e4SLinus Torvalds * the ULP spec. begs for waiting for oustanding commands 27861da177e4SLinus Torvalds */ 27871da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNINITIALIZED: 27881da177e4SLinus Torvalds zfcp_erp_unit_strategy_clearstati(unit); 27891da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 27901da177e4SLinus Torvalds ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> " 27911da177e4SLinus Torvalds "trying close\n", unit->fcp_lun); 27921da177e4SLinus Torvalds retval = zfcp_erp_unit_strategy_close(erp_action); 27931da177e4SLinus Torvalds break; 27941da177e4SLinus Torvalds } 27951da177e4SLinus Torvalds /* else it's already closed, fall through */ 27961da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNIT_CLOSING: 27971da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 27981da177e4SLinus Torvalds ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n", 27991da177e4SLinus Torvalds unit->fcp_lun); 28001da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 28011da177e4SLinus Torvalds } else { 28021da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 28031da177e4SLinus Torvalds retval = ZFCP_ERP_EXIT; 28041da177e4SLinus Torvalds else { 28051da177e4SLinus Torvalds ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> " 28061da177e4SLinus Torvalds "trying open\n", unit->fcp_lun); 28071da177e4SLinus Torvalds retval = 28081da177e4SLinus Torvalds zfcp_erp_unit_strategy_open(erp_action); 28091da177e4SLinus Torvalds } 28101da177e4SLinus Torvalds } 28111da177e4SLinus Torvalds break; 28121da177e4SLinus Torvalds 28131da177e4SLinus Torvalds case ZFCP_ERP_STEP_UNIT_OPENING: 28141da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 28151da177e4SLinus Torvalds ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n", 28161da177e4SLinus Torvalds unit->fcp_lun); 28171da177e4SLinus Torvalds retval = ZFCP_ERP_SUCCEEDED; 28181da177e4SLinus Torvalds } else { 28191da177e4SLinus Torvalds ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n", 28201da177e4SLinus Torvalds unit->fcp_lun); 28211da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 28221da177e4SLinus Torvalds } 28231da177e4SLinus Torvalds break; 28241da177e4SLinus Torvalds } 28251da177e4SLinus Torvalds 28261da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 3, "u_ust/ret"); 28271da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t)); 28281da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 28291da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 28301da177e4SLinus Torvalds return retval; 28311da177e4SLinus Torvalds } 28321da177e4SLinus Torvalds 28331da177e4SLinus Torvalds static int 28341da177e4SLinus Torvalds zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit) 28351da177e4SLinus Torvalds { 28361da177e4SLinus Torvalds int retval = 0; 28371da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 28381da177e4SLinus Torvalds 28391da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_ustclst"); 28401da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 28411da177e4SLinus Torvalds 28421da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 28431da177e4SLinus Torvalds ZFCP_STATUS_COMMON_CLOSING | 28441da177e4SLinus Torvalds ZFCP_STATUS_COMMON_ACCESS_DENIED | 28451da177e4SLinus Torvalds ZFCP_STATUS_UNIT_SHARED | 28461da177e4SLinus Torvalds ZFCP_STATUS_UNIT_READONLY, 28471da177e4SLinus Torvalds &unit->status); 28481da177e4SLinus Torvalds 28491da177e4SLinus Torvalds return retval; 28501da177e4SLinus Torvalds } 28511da177e4SLinus Torvalds 28521da177e4SLinus Torvalds /* 28531da177e4SLinus Torvalds * function: 28541da177e4SLinus Torvalds * 28551da177e4SLinus Torvalds * purpose: 28561da177e4SLinus Torvalds * 28571da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 28581da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 28591da177e4SLinus Torvalds */ 28601da177e4SLinus Torvalds static int 28611da177e4SLinus Torvalds zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action) 28621da177e4SLinus Torvalds { 28631da177e4SLinus Torvalds int retval; 28641da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 28651da177e4SLinus Torvalds struct zfcp_unit *unit = erp_action->unit; 28661da177e4SLinus Torvalds 28671da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 28681da177e4SLinus Torvalds retval = zfcp_fsf_close_unit(erp_action); 28691da177e4SLinus Torvalds if (retval == -ENOMEM) { 28701da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem"); 28711da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 28721da177e4SLinus Torvalds sizeof (fcp_lun_t)); 28731da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 28741da177e4SLinus Torvalds goto out; 28751da177e4SLinus Torvalds } 28761da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING; 28771da177e4SLinus Torvalds if (retval != 0) { 28781da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf"); 28791da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 28801da177e4SLinus Torvalds sizeof (fcp_lun_t)); 28811da177e4SLinus Torvalds /* could not send 'close', fail */ 28821da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 28831da177e4SLinus Torvalds goto out; 28841da177e4SLinus Torvalds } 28851da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok"); 28861da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 28871da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 28881da177e4SLinus Torvalds 28891da177e4SLinus Torvalds out: 28901da177e4SLinus Torvalds return retval; 28911da177e4SLinus Torvalds } 28921da177e4SLinus Torvalds 28931da177e4SLinus Torvalds /* 28941da177e4SLinus Torvalds * function: 28951da177e4SLinus Torvalds * 28961da177e4SLinus Torvalds * purpose: 28971da177e4SLinus Torvalds * 28981da177e4SLinus Torvalds * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 28991da177e4SLinus Torvalds * ZFCP_ERP_FAILED - action finished unsuccessfully 29001da177e4SLinus Torvalds */ 29011da177e4SLinus Torvalds static int 29021da177e4SLinus Torvalds zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action) 29031da177e4SLinus Torvalds { 29041da177e4SLinus Torvalds int retval; 29051da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 29061da177e4SLinus Torvalds struct zfcp_unit *unit = erp_action->unit; 29071da177e4SLinus Torvalds 29081da177e4SLinus Torvalds zfcp_erp_timeout_init(erp_action); 29091da177e4SLinus Torvalds retval = zfcp_fsf_open_unit(erp_action); 29101da177e4SLinus Torvalds if (retval == -ENOMEM) { 29111da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem"); 29121da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 29131da177e4SLinus Torvalds sizeof (fcp_lun_t)); 29141da177e4SLinus Torvalds retval = ZFCP_ERP_NOMEM; 29151da177e4SLinus Torvalds goto out; 29161da177e4SLinus Torvalds } 29171da177e4SLinus Torvalds erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING; 29181da177e4SLinus Torvalds if (retval != 0) { 29191da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf"); 29201da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 29211da177e4SLinus Torvalds sizeof (fcp_lun_t)); 29221da177e4SLinus Torvalds /* could not send 'open', fail */ 29231da177e4SLinus Torvalds retval = ZFCP_ERP_FAILED; 29241da177e4SLinus Torvalds goto out; 29251da177e4SLinus Torvalds } 29261da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok"); 29271da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 29281da177e4SLinus Torvalds retval = ZFCP_ERP_CONTINUES; 29291da177e4SLinus Torvalds out: 29301da177e4SLinus Torvalds return retval; 29311da177e4SLinus Torvalds } 29321da177e4SLinus Torvalds 29331da177e4SLinus Torvalds static inline void 29341da177e4SLinus Torvalds zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action) 29351da177e4SLinus Torvalds { 29361da177e4SLinus Torvalds init_timer(&erp_action->timer); 29371da177e4SLinus Torvalds erp_action->timer.function = zfcp_erp_timeout_handler; 29381da177e4SLinus Torvalds erp_action->timer.data = (unsigned long) erp_action; 29391da177e4SLinus Torvalds /* jiffies will be added in zfcp_fsf_req_send */ 29401da177e4SLinus Torvalds erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT; 29411da177e4SLinus Torvalds } 29421da177e4SLinus Torvalds 29431da177e4SLinus Torvalds /* 29441da177e4SLinus Torvalds * function: 29451da177e4SLinus Torvalds * 29461da177e4SLinus Torvalds * purpose: enqueue the specified error recovery action, if needed 29471da177e4SLinus Torvalds * 29481da177e4SLinus Torvalds * returns: 29491da177e4SLinus Torvalds */ 29501da177e4SLinus Torvalds static int 29511da177e4SLinus Torvalds zfcp_erp_action_enqueue(int action, 29521da177e4SLinus Torvalds struct zfcp_adapter *adapter, 29531da177e4SLinus Torvalds struct zfcp_port *port, struct zfcp_unit *unit) 29541da177e4SLinus Torvalds { 29551da177e4SLinus Torvalds int retval = 1; 29561da177e4SLinus Torvalds struct zfcp_erp_action *erp_action = NULL; 29571da177e4SLinus Torvalds int stronger_action = 0; 29581da177e4SLinus Torvalds u32 status = 0; 29591da177e4SLinus Torvalds 29601da177e4SLinus Torvalds /* 29611da177e4SLinus Torvalds * We need some rules here which check whether we really need 29621da177e4SLinus Torvalds * this action or whether we should just drop it. 29631da177e4SLinus Torvalds * E.g. if there is a unfinished 'Reopen Port' request then we drop a 29641da177e4SLinus Torvalds * 'Reopen Unit' request for an associated unit since we can't 29651da177e4SLinus Torvalds * satisfy this request now. A 'Reopen Port' action will trigger 29661da177e4SLinus Torvalds * 'Reopen Unit' actions when it completes. 29671da177e4SLinus Torvalds * Thus, there are only actions in the queue which can immediately be 29681da177e4SLinus Torvalds * executed. This makes the processing of the action queue more 29691da177e4SLinus Torvalds * efficient. 29701da177e4SLinus Torvalds */ 29711da177e4SLinus Torvalds 29721da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 29731da177e4SLinus Torvalds &adapter->status)) 29741da177e4SLinus Torvalds return -EIO; 29751da177e4SLinus Torvalds 29761da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &action, sizeof (int)); 29771da177e4SLinus Torvalds /* check whether we really need this */ 29781da177e4SLinus Torvalds switch (action) { 29791da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 29801da177e4SLinus Torvalds if (atomic_test_mask 29811da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) { 29821da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp"); 29831da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &port->wwpn, 29841da177e4SLinus Torvalds sizeof (wwn_t)); 29851da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &unit->fcp_lun, 29861da177e4SLinus Torvalds sizeof (fcp_lun_t)); 29871da177e4SLinus Torvalds goto out; 29881da177e4SLinus Torvalds } 29891da177e4SLinus Torvalds if (!atomic_test_mask 29901da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_RUNNING, &port->status) || 29911da177e4SLinus Torvalds atomic_test_mask 29921da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 29931da177e4SLinus Torvalds goto out; 29941da177e4SLinus Torvalds } 29951da177e4SLinus Torvalds if (!atomic_test_mask 29961da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) { 29971da177e4SLinus Torvalds stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT; 29981da177e4SLinus Torvalds unit = NULL; 29991da177e4SLinus Torvalds } 30001da177e4SLinus Torvalds /* fall through !!! */ 30011da177e4SLinus Torvalds 30021da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 30031da177e4SLinus Torvalds if (atomic_test_mask 30041da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) { 30051da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp"); 30061da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &port->wwpn, 30071da177e4SLinus Torvalds sizeof (wwn_t)); 30081da177e4SLinus Torvalds goto out; 30091da177e4SLinus Torvalds } 30101da177e4SLinus Torvalds /* fall through !!! */ 30111da177e4SLinus Torvalds 30121da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 30133734d24bSAndreas Herrmann if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 30143734d24bSAndreas Herrmann &port->status)) { 30153734d24bSAndreas Herrmann if (port->erp_action.action != 30161da177e4SLinus Torvalds ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) { 30173734d24bSAndreas Herrmann ZFCP_LOG_INFO("dropped erp action %i (port " 30183734d24bSAndreas Herrmann "0x%016Lx, action in use: %i)\n", 30193734d24bSAndreas Herrmann action, port->wwpn, 30203734d24bSAndreas Herrmann port->erp_action.action); 30213734d24bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 4, 30223734d24bSAndreas Herrmann "pf_actenq_drp"); 30233734d24bSAndreas Herrmann } else 30243734d24bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 4, 30253734d24bSAndreas Herrmann "pf_actenq_drpcp"); 30261da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &port->wwpn, 30271da177e4SLinus Torvalds sizeof (wwn_t)); 30281da177e4SLinus Torvalds goto out; 30291da177e4SLinus Torvalds } 30301da177e4SLinus Torvalds if (!atomic_test_mask 30311da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) || 30321da177e4SLinus Torvalds atomic_test_mask 30331da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 30341da177e4SLinus Torvalds goto out; 30351da177e4SLinus Torvalds } 30361da177e4SLinus Torvalds if (!atomic_test_mask 30371da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) { 30381da177e4SLinus Torvalds stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER; 30391da177e4SLinus Torvalds port = NULL; 30401da177e4SLinus Torvalds } 30411da177e4SLinus Torvalds /* fall through !!! */ 30421da177e4SLinus Torvalds 30431da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 30441da177e4SLinus Torvalds if (atomic_test_mask 30451da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) { 30461da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp"); 30471da177e4SLinus Torvalds goto out; 30481da177e4SLinus Torvalds } 30491da177e4SLinus Torvalds break; 30501da177e4SLinus Torvalds 30511da177e4SLinus Torvalds default: 30521da177e4SLinus Torvalds debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug"); 30531da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 1, &action, sizeof (int)); 30541da177e4SLinus Torvalds ZFCP_LOG_NORMAL("bug: unknown erp action requested " 30551da177e4SLinus Torvalds "on adapter %s (action=%d)\n", 30561da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter), action); 30571da177e4SLinus Torvalds goto out; 30581da177e4SLinus Torvalds } 30591da177e4SLinus Torvalds 30601da177e4SLinus Torvalds /* check whether we need something stronger first */ 30611da177e4SLinus Torvalds if (stronger_action) { 30621da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_actenq_str"); 30631da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &stronger_action, 30641da177e4SLinus Torvalds sizeof (int)); 30651da177e4SLinus Torvalds ZFCP_LOG_DEBUG("stronger erp action %d needed before " 30661da177e4SLinus Torvalds "erp action %d on adapter %s\n", 30671da177e4SLinus Torvalds stronger_action, action, 30681da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 30691da177e4SLinus Torvalds action = stronger_action; 30701da177e4SLinus Torvalds } 30711da177e4SLinus Torvalds 30721da177e4SLinus Torvalds /* mark adapter to have some error recovery pending */ 30731da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status); 30741da177e4SLinus Torvalds 30751da177e4SLinus Torvalds /* setup error recovery action */ 30761da177e4SLinus Torvalds switch (action) { 30771da177e4SLinus Torvalds 30781da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 30791da177e4SLinus Torvalds zfcp_unit_get(unit); 30801da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); 30811da177e4SLinus Torvalds erp_action = &unit->erp_action; 30821da177e4SLinus Torvalds if (!atomic_test_mask 30831da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_RUNNING, &unit->status)) 30841da177e4SLinus Torvalds status = ZFCP_STATUS_ERP_CLOSE_ONLY; 30851da177e4SLinus Torvalds break; 30861da177e4SLinus Torvalds 30871da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 30881da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 30891da177e4SLinus Torvalds zfcp_port_get(port); 30901da177e4SLinus Torvalds zfcp_erp_action_dismiss_port(port); 30911da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); 30921da177e4SLinus Torvalds erp_action = &port->erp_action; 30931da177e4SLinus Torvalds if (!atomic_test_mask 30941da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_RUNNING, &port->status)) 30951da177e4SLinus Torvalds status = ZFCP_STATUS_ERP_CLOSE_ONLY; 30961da177e4SLinus Torvalds break; 30971da177e4SLinus Torvalds 30981da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 30991da177e4SLinus Torvalds zfcp_adapter_get(adapter); 31001da177e4SLinus Torvalds zfcp_erp_action_dismiss_adapter(adapter); 31011da177e4SLinus Torvalds atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status); 31021da177e4SLinus Torvalds erp_action = &adapter->erp_action; 31031da177e4SLinus Torvalds if (!atomic_test_mask 31041da177e4SLinus Torvalds (ZFCP_STATUS_COMMON_RUNNING, &adapter->status)) 31051da177e4SLinus Torvalds status = ZFCP_STATUS_ERP_CLOSE_ONLY; 31061da177e4SLinus Torvalds break; 31071da177e4SLinus Torvalds } 31081da177e4SLinus Torvalds 31091da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_actenq"); 31101da177e4SLinus Torvalds 31111da177e4SLinus Torvalds memset(erp_action, 0, sizeof (struct zfcp_erp_action)); 31121da177e4SLinus Torvalds erp_action->adapter = adapter; 31131da177e4SLinus Torvalds erp_action->port = port; 31141da177e4SLinus Torvalds erp_action->unit = unit; 31151da177e4SLinus Torvalds erp_action->action = action; 31161da177e4SLinus Torvalds erp_action->status = status; 31171da177e4SLinus Torvalds 31181da177e4SLinus Torvalds ++adapter->erp_total_count; 31191da177e4SLinus Torvalds 31201da177e4SLinus Torvalds /* finally put it into 'ready' queue and kick erp thread */ 31211da177e4SLinus Torvalds list_add(&erp_action->list, &adapter->erp_ready_head); 31221da177e4SLinus Torvalds up(&adapter->erp_ready_sem); 31231da177e4SLinus Torvalds retval = 0; 31241da177e4SLinus Torvalds out: 31251da177e4SLinus Torvalds return retval; 31261da177e4SLinus Torvalds } 31271da177e4SLinus Torvalds 31281da177e4SLinus Torvalds static int 31291da177e4SLinus Torvalds zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 31301da177e4SLinus Torvalds { 31311da177e4SLinus Torvalds int retval = 0; 31321da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 31331da177e4SLinus Torvalds 31341da177e4SLinus Torvalds --adapter->erp_total_count; 31351da177e4SLinus Torvalds if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 31361da177e4SLinus Torvalds --adapter->erp_low_mem_count; 31371da177e4SLinus Torvalds erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 31381da177e4SLinus Torvalds } 31391da177e4SLinus Torvalds 31401da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 4, "a_actdeq"); 31411da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int)); 31421da177e4SLinus Torvalds list_del(&erp_action->list); 31431da177e4SLinus Torvalds switch (erp_action->action) { 31441da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 31451da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 31461da177e4SLinus Torvalds &erp_action->unit->status); 31471da177e4SLinus Torvalds break; 31481da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 31491da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 31501da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 31511da177e4SLinus Torvalds &erp_action->port->status); 31521da177e4SLinus Torvalds break; 31531da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 31541da177e4SLinus Torvalds atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 31551da177e4SLinus Torvalds &erp_action->adapter->status); 31561da177e4SLinus Torvalds break; 31571da177e4SLinus Torvalds default: 31581da177e4SLinus Torvalds /* bug */ 31591da177e4SLinus Torvalds break; 31601da177e4SLinus Torvalds } 31611da177e4SLinus Torvalds return retval; 31621da177e4SLinus Torvalds } 31631da177e4SLinus Torvalds 31641da177e4SLinus Torvalds /** 31651da177e4SLinus Torvalds * zfcp_erp_action_cleanup 31661da177e4SLinus Torvalds * 3167575c9687SAdrian Bunk * Register unit with scsi stack if appropriate and fix reference counts. 31681da177e4SLinus Torvalds * Note: Temporary units are not registered with scsi stack. 31691da177e4SLinus Torvalds */ 31701da177e4SLinus Torvalds static void 31711da177e4SLinus Torvalds zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter, 31721da177e4SLinus Torvalds struct zfcp_port *port, struct zfcp_unit *unit, 31731da177e4SLinus Torvalds int result) 31741da177e4SLinus Torvalds { 31751da177e4SLinus Torvalds switch (action) { 31761da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_UNIT: 31771da177e4SLinus Torvalds if ((result == ZFCP_ERP_SUCCEEDED) 31781da177e4SLinus Torvalds && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY, 31791da177e4SLinus Torvalds &unit->status)) 31803859f6a2SAndreas Herrmann && !unit->device 3181ad58f7dbSAndreas Herrmann && port->rport) { 3182ad58f7dbSAndreas Herrmann atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED, 3183ad58f7dbSAndreas Herrmann &unit->status); 3184ad58f7dbSAndreas Herrmann scsi_scan_target(&port->rport->dev, 0, 31853859f6a2SAndreas Herrmann port->rport->scsi_target_id, 3186ad58f7dbSAndreas Herrmann unit->scsi_lun, 0); 3187ad58f7dbSAndreas Herrmann } 31881da177e4SLinus Torvalds zfcp_unit_put(unit); 31891da177e4SLinus Torvalds break; 31901da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 31911da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_PORT: 3192338151e0SAndreas Herrmann if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN, 3193338151e0SAndreas Herrmann &port->status)) { 3194338151e0SAndreas Herrmann zfcp_port_put(port); 3195338151e0SAndreas Herrmann break; 3196338151e0SAndreas Herrmann } 3197338151e0SAndreas Herrmann 31983859f6a2SAndreas Herrmann if ((result == ZFCP_ERP_SUCCEEDED) 31993859f6a2SAndreas Herrmann && !port->rport) { 32003859f6a2SAndreas Herrmann struct fc_rport_identifiers ids; 32013859f6a2SAndreas Herrmann ids.node_name = port->wwnn; 32023859f6a2SAndreas Herrmann ids.port_name = port->wwpn; 32033859f6a2SAndreas Herrmann ids.port_id = port->d_id; 32043859f6a2SAndreas Herrmann ids.roles = FC_RPORT_ROLE_FCP_TARGET; 32053859f6a2SAndreas Herrmann port->rport = 32063859f6a2SAndreas Herrmann fc_remote_port_add(adapter->scsi_host, 0, &ids); 32073859f6a2SAndreas Herrmann if (!port->rport) 32083859f6a2SAndreas Herrmann ZFCP_LOG_NORMAL("failed registration of rport" 32093859f6a2SAndreas Herrmann "(adapter %s, wwpn=0x%016Lx)\n", 32103859f6a2SAndreas Herrmann zfcp_get_busid_by_port(port), 32113859f6a2SAndreas Herrmann port->wwpn); 321275bfc283SRalph Wuerthner else { 321361c41823SAndreas Herrmann scsi_flush_work(adapter->scsi_host); 321475bfc283SRalph Wuerthner port->rport->maxframe_size = port->maxframe_size; 321575bfc283SRalph Wuerthner port->rport->supported_classes = 321675bfc283SRalph Wuerthner port->supported_classes; 321775bfc283SRalph Wuerthner } 32183859f6a2SAndreas Herrmann } 3219338151e0SAndreas Herrmann if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) { 3220338151e0SAndreas Herrmann fc_remote_port_delete(port->rport); 3221338151e0SAndreas Herrmann port->rport = NULL; 3222338151e0SAndreas Herrmann } 32231da177e4SLinus Torvalds zfcp_port_put(port); 32241da177e4SLinus Torvalds break; 32251da177e4SLinus Torvalds case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3226338151e0SAndreas Herrmann if (result != ZFCP_ERP_SUCCEEDED) { 3227338151e0SAndreas Herrmann struct zfcp_port *port; 3228338151e0SAndreas Herrmann list_for_each_entry(port, &adapter->port_list_head, list) 3229338151e0SAndreas Herrmann if (port->rport && 3230338151e0SAndreas Herrmann !atomic_test_mask(ZFCP_STATUS_PORT_WKA, 3231338151e0SAndreas Herrmann &port->status)) { 3232338151e0SAndreas Herrmann fc_remote_port_delete(port->rport); 3233338151e0SAndreas Herrmann port->rport = NULL; 3234338151e0SAndreas Herrmann } 3235338151e0SAndreas Herrmann } 32361da177e4SLinus Torvalds zfcp_adapter_put(adapter); 32371da177e4SLinus Torvalds break; 32381da177e4SLinus Torvalds default: 32391da177e4SLinus Torvalds break; 32401da177e4SLinus Torvalds } 32411da177e4SLinus Torvalds } 32421da177e4SLinus Torvalds 32431da177e4SLinus Torvalds 3244f6c0e7a7SAndreas Herrmann void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter) 32451da177e4SLinus Torvalds { 32461da177e4SLinus Torvalds struct zfcp_port *port; 32471da177e4SLinus Torvalds 32481da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "a_actab"); 32491da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) 32501da177e4SLinus Torvalds zfcp_erp_action_dismiss(&adapter->erp_action); 32511da177e4SLinus Torvalds else 32521da177e4SLinus Torvalds list_for_each_entry(port, &adapter->port_list_head, list) 32531da177e4SLinus Torvalds zfcp_erp_action_dismiss_port(port); 32541da177e4SLinus Torvalds } 32551da177e4SLinus Torvalds 3256f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss_port(struct zfcp_port *port) 32571da177e4SLinus Torvalds { 32581da177e4SLinus Torvalds struct zfcp_unit *unit; 32591da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 32601da177e4SLinus Torvalds 32611da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "p_actab"); 32621da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 32631da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) 32641da177e4SLinus Torvalds zfcp_erp_action_dismiss(&port->erp_action); 32651da177e4SLinus Torvalds else 32661da177e4SLinus Torvalds list_for_each_entry(unit, &port->unit_list_head, list) 32671da177e4SLinus Torvalds zfcp_erp_action_dismiss_unit(unit); 32681da177e4SLinus Torvalds } 32691da177e4SLinus Torvalds 3270f6c0e7a7SAndreas Herrmann static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit) 32711da177e4SLinus Torvalds { 32721da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 32731da177e4SLinus Torvalds 32741da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 5, "u_actab"); 32751da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 32761da177e4SLinus Torvalds if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) 32771da177e4SLinus Torvalds zfcp_erp_action_dismiss(&unit->erp_action); 32781da177e4SLinus Torvalds } 32791da177e4SLinus Torvalds 32801da177e4SLinus Torvalds static inline void 32811da177e4SLinus Torvalds zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) 32821da177e4SLinus Torvalds { 32831da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 32841da177e4SLinus Torvalds 32851da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_toru"); 32861da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 32871da177e4SLinus Torvalds list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 32881da177e4SLinus Torvalds } 32891da177e4SLinus Torvalds 32901da177e4SLinus Torvalds static inline void 32911da177e4SLinus Torvalds zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action) 32921da177e4SLinus Torvalds { 32931da177e4SLinus Torvalds struct zfcp_adapter *adapter = erp_action->adapter; 32941da177e4SLinus Torvalds 32951da177e4SLinus Torvalds debug_text_event(adapter->erp_dbf, 6, "a_tore"); 32961da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 32971da177e4SLinus Torvalds list_move(&erp_action->list, &erp_action->adapter->erp_ready_head); 32981da177e4SLinus Torvalds } 32991da177e4SLinus Torvalds 3300d736a27bSAndreas Herrmann void 3301d736a27bSAndreas Herrmann zfcp_erp_port_boxed(struct zfcp_port *port) 3302d736a27bSAndreas Herrmann { 3303d736a27bSAndreas Herrmann struct zfcp_adapter *adapter = port->adapter; 3304d736a27bSAndreas Herrmann unsigned long flags; 3305d736a27bSAndreas Herrmann 3306d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "p_access_boxed"); 3307d736a27bSAndreas Herrmann debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3308d736a27bSAndreas Herrmann read_lock_irqsave(&zfcp_data.config_lock, flags); 3309d736a27bSAndreas Herrmann zfcp_erp_modify_port_status(port, 3310d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ACCESS_BOXED, 3311d736a27bSAndreas Herrmann ZFCP_SET); 3312d736a27bSAndreas Herrmann read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3313d736a27bSAndreas Herrmann zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED); 3314d736a27bSAndreas Herrmann } 3315d736a27bSAndreas Herrmann 3316d736a27bSAndreas Herrmann void 3317d736a27bSAndreas Herrmann zfcp_erp_unit_boxed(struct zfcp_unit *unit) 3318d736a27bSAndreas Herrmann { 3319d736a27bSAndreas Herrmann struct zfcp_adapter *adapter = unit->port->adapter; 3320d736a27bSAndreas Herrmann 3321d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "u_access_boxed"); 3322d736a27bSAndreas Herrmann debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3323d736a27bSAndreas Herrmann zfcp_erp_modify_unit_status(unit, 3324d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ACCESS_BOXED, 3325d736a27bSAndreas Herrmann ZFCP_SET); 3326d736a27bSAndreas Herrmann zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 3327d736a27bSAndreas Herrmann } 3328d736a27bSAndreas Herrmann 33291da177e4SLinus Torvalds void 33301da177e4SLinus Torvalds zfcp_erp_port_access_denied(struct zfcp_port *port) 33311da177e4SLinus Torvalds { 33321da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 33331da177e4SLinus Torvalds unsigned long flags; 33341da177e4SLinus Torvalds 3335d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "p_access_denied"); 33361da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 33371da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 3338d736a27bSAndreas Herrmann zfcp_erp_modify_port_status(port, 3339d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ERP_FAILED | 3340d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ACCESS_DENIED, 3341d736a27bSAndreas Herrmann ZFCP_SET); 33421da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 33431da177e4SLinus Torvalds } 33441da177e4SLinus Torvalds 33451da177e4SLinus Torvalds void 33461da177e4SLinus Torvalds zfcp_erp_unit_access_denied(struct zfcp_unit *unit) 33471da177e4SLinus Torvalds { 33481da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 33491da177e4SLinus Torvalds 3350d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "u_access_denied"); 33511da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3352d736a27bSAndreas Herrmann zfcp_erp_modify_unit_status(unit, 3353d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ERP_FAILED | 3354d736a27bSAndreas Herrmann ZFCP_STATUS_COMMON_ACCESS_DENIED, 3355d736a27bSAndreas Herrmann ZFCP_SET); 33561da177e4SLinus Torvalds } 33571da177e4SLinus Torvalds 33581da177e4SLinus Torvalds void 33591da177e4SLinus Torvalds zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter) 33601da177e4SLinus Torvalds { 33611da177e4SLinus Torvalds struct zfcp_port *port; 33621da177e4SLinus Torvalds unsigned long flags; 33631da177e4SLinus Torvalds 3364aef4a983SMaxim Shchetynin if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 3365aef4a983SMaxim Shchetynin return; 3366aef4a983SMaxim Shchetynin 3367d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "a_access_recover"); 336806506d00SAndreas Herrmann debug_event(adapter->erp_dbf, 3, zfcp_get_busid_by_adapter(adapter), 8); 33691da177e4SLinus Torvalds 33701da177e4SLinus Torvalds read_lock_irqsave(&zfcp_data.config_lock, flags); 33716f71d9bcS if (adapter->nameserver_port) 33726f71d9bcS zfcp_erp_port_access_changed(adapter->nameserver_port); 33731da177e4SLinus Torvalds list_for_each_entry(port, &adapter->port_list_head, list) 33741da177e4SLinus Torvalds if (port != adapter->nameserver_port) 33751da177e4SLinus Torvalds zfcp_erp_port_access_changed(port); 33761da177e4SLinus Torvalds read_unlock_irqrestore(&zfcp_data.config_lock, flags); 33771da177e4SLinus Torvalds } 33781da177e4SLinus Torvalds 33791da177e4SLinus Torvalds void 33801da177e4SLinus Torvalds zfcp_erp_port_access_changed(struct zfcp_port *port) 33811da177e4SLinus Torvalds { 33821da177e4SLinus Torvalds struct zfcp_adapter *adapter = port->adapter; 33831da177e4SLinus Torvalds struct zfcp_unit *unit; 33841da177e4SLinus Torvalds 3385d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "p_access_recover"); 33861da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 33871da177e4SLinus Torvalds 33881da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3389d736a27bSAndreas Herrmann &port->status) && 3390d736a27bSAndreas Herrmann !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 33911da177e4SLinus Torvalds &port->status)) { 33921da177e4SLinus Torvalds if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 33931da177e4SLinus Torvalds list_for_each_entry(unit, &port->unit_list_head, list) 33941da177e4SLinus Torvalds zfcp_erp_unit_access_changed(unit); 33951da177e4SLinus Torvalds return; 33961da177e4SLinus Torvalds } 33971da177e4SLinus Torvalds 33981da177e4SLinus Torvalds ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s " 33991da177e4SLinus Torvalds "(due to ACT update)\n", 34001da177e4SLinus Torvalds port->wwpn, zfcp_get_busid_by_adapter(adapter)); 34011da177e4SLinus Torvalds if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 34021da177e4SLinus Torvalds ZFCP_LOG_NORMAL("failed reopen of port" 34031da177e4SLinus Torvalds "(adapter %s, wwpn=0x%016Lx)\n", 34041da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter), port->wwpn); 34051da177e4SLinus Torvalds } 34061da177e4SLinus Torvalds 34071da177e4SLinus Torvalds void 34081da177e4SLinus Torvalds zfcp_erp_unit_access_changed(struct zfcp_unit *unit) 34091da177e4SLinus Torvalds { 34101da177e4SLinus Torvalds struct zfcp_adapter *adapter = unit->port->adapter; 34111da177e4SLinus Torvalds 3412d736a27bSAndreas Herrmann debug_text_event(adapter->erp_dbf, 3, "u_access_recover"); 34131da177e4SLinus Torvalds debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 34141da177e4SLinus Torvalds 3415d736a27bSAndreas Herrmann if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3416d736a27bSAndreas Herrmann &unit->status) && 3417d736a27bSAndreas Herrmann !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 3418d736a27bSAndreas Herrmann &unit->status)) 34191da177e4SLinus Torvalds return; 34201da177e4SLinus Torvalds 34211da177e4SLinus Torvalds ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx " 34221da177e4SLinus Torvalds " on adapter %s (due to ACT update)\n", 34231da177e4SLinus Torvalds unit->fcp_lun, unit->port->wwpn, 34241da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter)); 34251da177e4SLinus Torvalds if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 34261da177e4SLinus Torvalds ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, " 34271da177e4SLinus Torvalds "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n", 34281da177e4SLinus Torvalds zfcp_get_busid_by_adapter(adapter), 34291da177e4SLinus Torvalds unit->port->wwpn, unit->fcp_lun); 34301da177e4SLinus Torvalds } 34311da177e4SLinus Torvalds 34321da177e4SLinus Torvalds #undef ZFCP_LOG_AREA 3433