"port 0x%016Lx\n", port->wwpn);
zfcp_erp_port_reopen(port,
ZFCP_STATUS_COMMON_ERP_FAILED,
- 82, (u64)fsf_req);
+ 82, fsf_req);
continue;
}
status_buffer->d_id,
zfcp_get_busid_by_adapter(adapter));
} else {
- zfcp_erp_port_forced_reopen(port, 0, 83, (u64)fsf_req);
+ zfcp_erp_port_forced_reopen(port, 0, 83, fsf_req);
}
}
status_buffer->d_id,
zfcp_get_busid_by_adapter(adapter));
} else {
- zfcp_erp_port_forced_reopen(port, 0, 84, (u64)fsf_req);
+ zfcp_erp_port_forced_reopen(port, 0, 84, fsf_req);
}
}
BUG_ON(!zfcp_reqlist_isempty(adapter));
adapter->req_no = 0;
- zfcp_erp_modify_adapter_status(adapter, 10, 0,
+ zfcp_erp_modify_adapter_status(adapter, 10, NULL,
ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
- zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85, 0);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
+ NULL);
zfcp_erp_wait(adapter);
goto out;
down(&zfcp_data.config_sema);
adapter = dev_get_drvdata(&ccw_device->dev);
- zfcp_erp_adapter_shutdown(adapter, 0, 86, 0);
+ zfcp_erp_adapter_shutdown(adapter, 0, 86, NULL);
zfcp_erp_wait(adapter);
zfcp_erp_thread_kill(adapter);
up(&zfcp_data.config_sema);
case CIO_GONE:
ZFCP_LOG_NORMAL("adapter %s: device gone\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 87, 0);
+ zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
break;
case CIO_NO_PATH:
ZFCP_LOG_NORMAL("adapter %s: no path\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 88, 0);
+ zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
break;
case CIO_OPER:
ZFCP_LOG_NORMAL("adapter %s: operational again\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_modify_adapter_status(adapter, 11, 0,
+ zfcp_erp_modify_adapter_status(adapter, 11, NULL,
ZFCP_STATUS_COMMON_RUNNING,
ZFCP_SET);
- zfcp_erp_adapter_reopen(adapter,
- ZFCP_STATUS_COMMON_ERP_FAILED, 89, 0);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
+ 89, NULL);
break;
}
zfcp_erp_wait(adapter);
down(&zfcp_data.config_sema);
adapter = dev_get_drvdata(&cdev->dev);
- zfcp_erp_adapter_shutdown(adapter, 0, 90, 0);
+ zfcp_erp_adapter_shutdown(adapter, 0, 90, NULL);
zfcp_erp_wait(adapter);
up(&zfcp_data.config_sema);
}
spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
}
-static void zfcp_rec_dbf_event_target(u8 id2, u64 ref,
+static void zfcp_rec_dbf_event_target(u8 id2, void *ref,
struct zfcp_adapter *adapter,
atomic_t *status, atomic_t *erp_count,
u64 wwpn, u32 d_id, u64 fcp_lun)
memset(r, 0, sizeof(*r));
r->id = ZFCP_REC_DBF_ID_TARGET;
r->id2 = id2;
- r->u.target.ref = ref;
+ r->u.target.ref = (unsigned long)ref;
r->u.target.status = atomic_read(status);
r->u.target.wwpn = wwpn;
r->u.target.d_id = d_id;
* @ref: additional reference (e.g. request)
* @adapter: adapter
*/
-void zfcp_rec_dbf_event_adapter(u8 id, u64 ref, struct zfcp_adapter *adapter)
+void zfcp_rec_dbf_event_adapter(u8 id, void *ref, struct zfcp_adapter *adapter)
{
zfcp_rec_dbf_event_target(id, ref, adapter, &adapter->status,
&adapter->erp_counter, 0, 0, 0);
* @ref: additional reference (e.g. request)
* @port: port
*/
-void zfcp_rec_dbf_event_port(u8 id, u64 ref, struct zfcp_port *port)
+void zfcp_rec_dbf_event_port(u8 id, void *ref, struct zfcp_port *port)
{
struct zfcp_adapter *adapter = port->adapter;
* @ref: additional reference (e.g. request)
* @unit: unit
*/
-void zfcp_rec_dbf_event_unit(u8 id, u64 ref, struct zfcp_unit *unit)
+void zfcp_rec_dbf_event_unit(u8 id, void *ref, struct zfcp_unit *unit)
{
struct zfcp_port *port = unit->port;
struct zfcp_adapter *adapter = port->adapter;
* @port: port
* @unit: unit
*/
-void zfcp_rec_dbf_event_trigger(u8 id2, u64 ref, u8 want, u8 need, u64 action,
- struct zfcp_adapter *adapter,
+void zfcp_rec_dbf_event_trigger(u8 id2, void *ref, u8 want, u8 need,
+ void *action, struct zfcp_adapter *adapter,
struct zfcp_port *port, struct zfcp_unit *unit)
{
struct zfcp_rec_dbf_record *r = &adapter->rec_dbf_buf;
memset(r, 0, sizeof(*r));
r->id = ZFCP_REC_DBF_ID_TRIGGER;
r->id2 = id2;
- r->u.trigger.ref = ref;
+ r->u.trigger.ref = (unsigned long)ref;
r->u.trigger.want = want;
r->u.trigger.need = need;
- r->u.trigger.action = action;
+ r->u.trigger.action = (unsigned long)action;
r->u.trigger.as = atomic_read(&adapter->status);
if (port) {
r->u.trigger.ps = atomic_read(&port->status);
memset(r, 0, sizeof(*r));
r->id = ZFCP_REC_DBF_ID_ACTION;
r->id2 = id2;
- r->u.action.action = (u64)erp_action;
+ r->u.action.action = (unsigned long)erp_action;
r->u.action.status = erp_action->status;
r->u.action.step = erp_action->step;
- r->u.action.fsf_req = (u64)erp_action->fsf_req;
+ r->u.action.fsf_req = (unsigned long)erp_action->fsf_req;
debug_event(adapter->rec_dbf, 4, r, sizeof(*r));
spin_unlock_irqrestore(&adapter->rec_dbf_lock, flags);
}
static void zfcp_erp_adisc_handler(unsigned long);
static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int, u8,
- u64);
+ void *);
static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int, u8,
- u64);
-static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int, u8, u64);
-static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int, u8, u64);
+ void *);
+static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int, u8, void *);
+static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int, u8, void *);
static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int, u8,
- u64);
-static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int, u8, u64);
+ void *);
+static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int, u8,
+ void *);
static void zfcp_erp_adapter_block(struct zfcp_adapter *, int);
static void zfcp_erp_adapter_unblock(struct zfcp_adapter *);
static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *,
struct zfcp_port *, struct zfcp_unit *,
- u8 id, u64 ref);
+ u8 id, void *ref);
static int zfcp_erp_action_dequeue(struct zfcp_erp_action *);
static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *,
struct zfcp_port *, struct zfcp_unit *,
/* reset FSF request sequence number */
adapter->fsf_req_seq_no = 0;
/* all ports and units are closed */
- zfcp_erp_modify_adapter_status(adapter, 24, 0,
+ zfcp_erp_modify_adapter_status(adapter, 24, NULL,
ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
}
static void zfcp_fsf_request_timeout_handler(unsigned long data)
{
struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
- zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62, 0);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62,
+ NULL);
}
void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, unsigned long timeout)
* <0 - failed to initiate action
*/
static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter,
- int clear_mask, u8 id, u64 ref)
+ int clear_mask, u8 id, void *ref)
{
int retval;
ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n",
zfcp_get_busid_by_adapter(adapter));
/* ensure propagation of failed status to new devices */
- zfcp_erp_adapter_failed(adapter, 13, 0);
+ zfcp_erp_adapter_failed(adapter, 13, NULL);
retval = -EIO;
goto out;
}
* <0 - failed to initiate action
*/
int zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask,
- u8 id, u64 ref)
+ u8 id, void *ref)
{
int retval;
unsigned long flags;
}
int zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask,
- u8 id, u64 ref)
+ u8 id, void *ref)
{
int retval;
}
int zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask, u8 id,
- u64 ref)
+ void *ref)
{
int retval;
}
int zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask, u8 id,
- u64 ref)
+ void *ref)
{
int retval;
"force physical port reopen "
"(adapter %s, port d_id=0x%06x)\n",
zfcp_get_busid_by_adapter(adapter), d_id);
- if (zfcp_erp_port_forced_reopen(port, 0, 63, 0))
+ if (zfcp_erp_port_forced_reopen(port, 0, 63, NULL))
ZFCP_LOG_NORMAL("failed reopen of port "
"(adapter %s, wwpn=0x%016Lx)\n",
zfcp_get_busid_by_port(port),
"adisc_resp_wwpn=0x%016Lx)\n",
zfcp_get_busid_by_port(port),
port->wwpn, (wwn_t) adisc->wwpn);
- if (zfcp_erp_port_reopen(port, 0, 64, 0))
+ if (zfcp_erp_port_reopen(port, 0, 64, NULL))
ZFCP_LOG_NORMAL("failed reopen of port "
"(adapter %s, wwpn=0x%016Lx)\n",
zfcp_get_busid_by_port(port),
ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx "
"on adapter %s\n ", port->wwpn,
zfcp_get_busid_by_port(port));
- retval = zfcp_erp_port_forced_reopen(port, 0, 65, 0);
+ retval = zfcp_erp_port_forced_reopen(port, 0, 65, NULL);
if (retval != 0) {
ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx "
"on adapter %s failed\n", port->wwpn,
* <0 - failed to initiate action
*/
static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port,
- int clear_mask, u8 id, u64 ref)
+ int clear_mask, u8 id,
+ void *ref)
{
int retval;
* <0 - failed to initiate action
*/
int zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask, u8 id,
- u64 ref)
+ void *ref)
{
int retval;
unsigned long flags;
* <0 - failed to initiate action
*/
static int zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask,
- u8 id, u64 ref)
+ u8 id, void *ref)
{
int retval;
"on adapter %s\n", port->wwpn,
zfcp_get_busid_by_port(port));
/* ensure propagation of failed status to new devices */
- zfcp_erp_port_failed(port, 14, 0);
+ zfcp_erp_port_failed(port, 14, NULL);
retval = -EIO;
goto out;
}
* correct locking. An error recovery task is initiated to do the reopen.
* To wait for the completion of the reopen zfcp_erp_wait should be used.
*/
-int zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask, u8 id, u64 ref)
+int zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask, u8 id,
+ void *ref)
{
int retval;
unsigned long flags;
* <0 - failed to initiate action
*/
static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask,
- u8 id, u64 ref)
+ u8 id, void *ref)
{
int retval;
struct zfcp_adapter *adapter = unit->port->adapter;
* locking. An error recovery task is initiated to do the reopen.
* To wait for the completion of the reopen zfcp_erp_wait should be used.
*/
-int zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask, u8 id, u64 ref)
+int zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask, u8 id,
+ void *ref)
{
int retval;
unsigned long flags;
*/
static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
{
- zfcp_erp_modify_adapter_status(adapter, 15, 0,
+ zfcp_erp_modify_adapter_status(adapter, 15, NULL,
ZFCP_STATUS_COMMON_UNBLOCKED |
clear_mask, ZFCP_CLEAR);
}
{
if (atomic_test_and_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
&adapter->status))
- zfcp_rec_dbf_event_adapter(16, 0, adapter);
+ zfcp_rec_dbf_event_adapter(16, NULL, adapter);
}
/*
static void
zfcp_erp_port_block(struct zfcp_port *port, int clear_mask)
{
- zfcp_erp_modify_port_status(port, 17, 0,
+ zfcp_erp_modify_port_status(port, 17, NULL,
ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
ZFCP_CLEAR);
}
{
if (atomic_test_and_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
&port->status))
- zfcp_rec_dbf_event_port(18, 0, port);
+ zfcp_rec_dbf_event_port(18, NULL, port);
}
/*
static void
zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
{
- zfcp_erp_modify_unit_status(unit, 19, 0,
+ zfcp_erp_modify_unit_status(unit, 19, NULL,
ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
ZFCP_CLEAR);
}
{
if (atomic_test_and_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
&unit->status))
- zfcp_rec_dbf_event_unit(20, 0, unit);
+ zfcp_rec_dbf_event_unit(20, NULL, unit);
}
static void
"restarting I/O on adapter %s "
"to free mempool\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_reopen_internal(adapter, 0, 66, 0);
+ zfcp_erp_adapter_reopen_internal(adapter, 0, 66, NULL);
} else {
retval = zfcp_erp_strategy_memwait(erp_action);
}
*
*/
void
-zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, u64 ref)
+zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, void *ref)
{
zfcp_erp_modify_adapter_status(adapter, id, ref,
ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
*
*/
void
-zfcp_erp_port_failed(struct zfcp_port *port, u8 id, u64 ref)
+zfcp_erp_port_failed(struct zfcp_port *port, u8 id, void *ref)
{
zfcp_erp_modify_port_status(port, id, ref,
ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
*
*/
void
-zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, u64 ref)
+zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, void *ref)
{
zfcp_erp_modify_unit_status(unit, id, ref,
ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
status)) {
zfcp_erp_adapter_reopen_internal(adapter,
ZFCP_STATUS_COMMON_ERP_FAILED,
- 67, 0);
+ 67, NULL);
retval = ZFCP_ERP_EXIT;
}
break;
status)) {
zfcp_erp_port_reopen_internal(port,
ZFCP_STATUS_COMMON_ERP_FAILED,
- 68, 0);
+ 68, NULL);
retval = ZFCP_ERP_EXIT;
}
break;
status)) {
zfcp_erp_unit_reopen_internal(unit,
ZFCP_STATUS_COMMON_ERP_FAILED,
- 69, 0);
+ 69, NULL);
retval = ZFCP_ERP_EXIT;
}
break;
case ZFCP_ERP_FAILED :
atomic_inc(&unit->erp_counter);
if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
- zfcp_erp_unit_failed(unit, 21, 0);
+ zfcp_erp_unit_failed(unit, 21, NULL);
break;
case ZFCP_ERP_EXIT :
/* nothing */
case ZFCP_ERP_FAILED :
atomic_inc(&port->erp_counter);
if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
- zfcp_erp_port_failed(port, 22, 0);
+ zfcp_erp_port_failed(port, 22, NULL);
break;
case ZFCP_ERP_EXIT :
/* nothing */
case ZFCP_ERP_FAILED :
atomic_inc(&adapter->erp_counter);
if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS)
- zfcp_erp_adapter_failed(adapter, 23, 0);
+ zfcp_erp_adapter_failed(adapter, 23, NULL);
break;
case ZFCP_ERP_EXIT :
/* nothing */
case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
if (status == ZFCP_ERP_SUCCEEDED)
- zfcp_erp_port_reopen_all_internal(adapter, 0, 70, 0);
+ zfcp_erp_port_reopen_all_internal(adapter, 0, 70, NULL);
else
- zfcp_erp_adapter_reopen_internal(adapter, 0, 71, 0);
+ zfcp_erp_adapter_reopen_internal(adapter, 0, 71, NULL);
break;
case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
if (status == ZFCP_ERP_SUCCEEDED)
- zfcp_erp_port_reopen_internal(port, 0, 72, 0);
+ zfcp_erp_port_reopen_internal(port, 0, 72, NULL);
else
- zfcp_erp_adapter_reopen_internal(adapter, 0, 73, 0);
+ zfcp_erp_adapter_reopen_internal(adapter, 0, 73, NULL);
break;
case ZFCP_ERP_ACTION_REOPEN_PORT:
if (status == ZFCP_ERP_SUCCEEDED)
- zfcp_erp_unit_reopen_all_internal(port, 0, 74, 0);
+ zfcp_erp_unit_reopen_all_internal(port, 0, 74, NULL);
else
- zfcp_erp_port_forced_reopen_internal(port, 0, 75, 0);
+ zfcp_erp_port_forced_reopen_internal(port, 0, 75, NULL);
break;
case ZFCP_ERP_ACTION_REOPEN_UNIT:
/* Nothing to do if status == ZFCP_ERP_SUCCEEDED */
if (status != ZFCP_ERP_SUCCEEDED)
- zfcp_erp_port_reopen_internal(unit->port, 0, 76, 0);
+ zfcp_erp_port_reopen_internal(unit->port, 0, 76, NULL);
break;
}
}
void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, u8 id,
- u64 ref, u32 mask, int set_or_clear)
+ void *ref, u32 mask, int set_or_clear)
{
struct zfcp_port *port;
u32 changed, common_mask = mask & ZFCP_COMMON_FLAGS;
* purpose: sets the port and all underlying devices to ERP_FAILED
*
*/
-void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, u64 ref,
+void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, void *ref,
u32 mask, int set_or_clear)
{
struct zfcp_unit *unit;
* purpose: sets the unit to ERP_FAILED
*
*/
-void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, u64 ref,
+void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, void *ref,
u32 mask, int set_or_clear)
{
u32 changed;
* <0 - failed to initiate action
*/
int zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask,
- u8 id, u64 ref)
+ u8 id, void *ref)
{
int retval;
unsigned long flags;
}
static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter,
- int clear_mask, u8 id, u64 ref)
+ int clear_mask, u8 id, void *ref)
{
int retval = 0;
struct zfcp_port *port;
* returns: FIXME
*/
static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port,
- int clear_mask, u8 id, u64 ref)
+ int clear_mask, u8 id, void *ref)
{
int retval = 0;
struct zfcp_unit *unit;
port->wwpn,
zfcp_get_busid_by_adapter(adapter),
adapter->peer_wwpn);
- zfcp_erp_port_failed(port, 25, 0);
+ zfcp_erp_port_failed(port, 25, NULL);
retval = ZFCP_ERP_FAILED;
break;
}
atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
&adapter->nameserver_port->status);
if (zfcp_erp_port_reopen(adapter->nameserver_port, 0,
- 77, (u64)erp_action) >= 0) {
+ 77, erp_action) >= 0) {
erp_action->step =
ZFCP_ERP_STEP_NAMESERVER_OPEN;
retval = ZFCP_ERP_CONTINUES;
"for port 0x%016Lx "
"(misconfigured WWPN?)\n",
port->wwpn);
- zfcp_erp_port_failed(port, 26, 0);
+ zfcp_erp_port_failed(port, 26, NULL);
retval = ZFCP_ERP_EXIT;
} else {
ZFCP_LOG_DEBUG("nameserver look-up failed for "
if (atomic_test_mask(
ZFCP_STATUS_COMMON_ERP_FAILED,
&adapter->nameserver_port->status))
- zfcp_erp_port_failed(erp_action->port, 27, 0);
+ zfcp_erp_port_failed(erp_action->port, 27,
+ NULL);
zfcp_erp_action_ready(erp_action);
}
}
*/
static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
struct zfcp_port *port,
- struct zfcp_unit *unit, u8 id, u64 ref)
+ struct zfcp_unit *unit, u8 id, void *ref)
{
int retval = 1, need = want;
struct zfcp_erp_action *erp_action = NULL;
zfcp_rec_dbf_event_thread(1, adapter, 0);
retval = 0;
out:
- zfcp_rec_dbf_event_trigger(id, ref, want, need, (u64)erp_action,
+ zfcp_rec_dbf_event_trigger(id, ref, want, need, erp_action,
adapter, port, unit);
return retval;
}
zfcp_rec_dbf_event_action(146, erp_action);
}
-void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, u64 ref)
+void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref)
{
unsigned long flags;
zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
}
-void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, u64 ref)
+void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref)
{
zfcp_erp_modify_unit_status(unit, id, ref,
ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
}
-void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, u64 ref)
+void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref)
{
unsigned long flags;
read_unlock_irqrestore(&zfcp_data.config_lock, flags);
}
-void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, u64 ref)
+void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref)
{
zfcp_erp_modify_unit_status(unit, id, ref,
ZFCP_STATUS_COMMON_ERP_FAILED |
}
void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id,
- u64 ref)
+ void *ref)
{
struct zfcp_port *port;
unsigned long flags;
read_unlock_irqrestore(&zfcp_data.config_lock, flags);
}
-void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id, u64 ref)
+void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id, void *ref)
{
struct zfcp_adapter *adapter = port->adapter;
struct zfcp_unit *unit;
zfcp_get_busid_by_adapter(adapter), port->wwpn);
}
-void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id, u64 ref)
+void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id, void *ref)
{
struct zfcp_adapter *adapter = unit->port->adapter;
extern struct fc_function_template zfcp_transport_functions;
/******************************** ERP ****************************************/
-extern void zfcp_erp_modify_adapter_status(struct zfcp_adapter *, u8, u64, u32,
- int);
-extern int zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, u8, u64);
-extern int zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, u8, u64);
-extern void zfcp_erp_adapter_failed(struct zfcp_adapter *, u8, u64);
-
-extern void zfcp_erp_modify_port_status(struct zfcp_port *, u8, u64, u32, int);
-extern int zfcp_erp_port_reopen(struct zfcp_port *, int, u8, u64);
-extern int zfcp_erp_port_shutdown(struct zfcp_port *, int, u8, u64);
-extern int zfcp_erp_port_forced_reopen(struct zfcp_port *, int, u8, u64);
-extern void zfcp_erp_port_failed(struct zfcp_port *, u8, u64);
-extern int zfcp_erp_port_reopen_all(struct zfcp_adapter *, int, u8, u64);
-
-extern void zfcp_erp_modify_unit_status(struct zfcp_unit *, u8, u64, u32, int);
-extern int zfcp_erp_unit_reopen(struct zfcp_unit *, int, u8, u64);
-extern int zfcp_erp_unit_shutdown(struct zfcp_unit *, int, u8, u64);
-extern void zfcp_erp_unit_failed(struct zfcp_unit *, u8, u64);
+extern void zfcp_erp_modify_adapter_status(struct zfcp_adapter *, u8, void *,
+ u32, int);
+extern int zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, u8, void *);
+extern int zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, u8, void *);
+extern void zfcp_erp_adapter_failed(struct zfcp_adapter *, u8, void *);
+
+extern void zfcp_erp_modify_port_status(struct zfcp_port *, u8, void *, u32,
+ int);
+extern int zfcp_erp_port_reopen(struct zfcp_port *, int, u8, void *);
+extern int zfcp_erp_port_shutdown(struct zfcp_port *, int, u8, void *);
+extern int zfcp_erp_port_forced_reopen(struct zfcp_port *, int, u8, void *);
+extern void zfcp_erp_port_failed(struct zfcp_port *, u8, void *);
+extern int zfcp_erp_port_reopen_all(struct zfcp_adapter *, int, u8, void *);
+
+extern void zfcp_erp_modify_unit_status(struct zfcp_unit *, u8, void *, u32,
+ int);
+extern int zfcp_erp_unit_reopen(struct zfcp_unit *, int, u8, void *);
+extern int zfcp_erp_unit_shutdown(struct zfcp_unit *, int, u8, void *);
+extern void zfcp_erp_unit_failed(struct zfcp_unit *, u8, void *);
extern int zfcp_erp_thread_setup(struct zfcp_adapter *);
extern int zfcp_erp_thread_kill(struct zfcp_adapter *);
extern int zfcp_test_link(struct zfcp_port *);
-extern void zfcp_erp_port_boxed(struct zfcp_port *, u8 id, u64 ref);
-extern void zfcp_erp_unit_boxed(struct zfcp_unit *, u8 id, u64 ref);
-extern void zfcp_erp_port_access_denied(struct zfcp_port *, u8 id, u64 ref);
-extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, u8 id, u64 ref);
-extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, u8, u64);
-extern void zfcp_erp_port_access_changed(struct zfcp_port *, u8, u64);
-extern void zfcp_erp_unit_access_changed(struct zfcp_unit *, u8, u64);
+extern void zfcp_erp_port_boxed(struct zfcp_port *, u8 id, void *ref);
+extern void zfcp_erp_unit_boxed(struct zfcp_unit *, u8 id, void *ref);
+extern void zfcp_erp_port_access_denied(struct zfcp_port *, u8 id, void *ref);
+extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, u8 id, void *ref);
+extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, u8, void *);
+extern void zfcp_erp_port_access_changed(struct zfcp_port *, u8, void *);
+extern void zfcp_erp_unit_access_changed(struct zfcp_unit *, u8, void *);
/******************************** AUX ****************************************/
extern void zfcp_rec_dbf_event_thread(u8 id, struct zfcp_adapter *adapter,
int lock);
-extern void zfcp_rec_dbf_event_adapter(u8 id, u64 ref, struct zfcp_adapter *);
-extern void zfcp_rec_dbf_event_port(u8 id, u64 ref, struct zfcp_port *port);
-extern void zfcp_rec_dbf_event_unit(u8 id, u64 ref, struct zfcp_unit *unit);
-extern void zfcp_rec_dbf_event_trigger(u8 id, u64 ref, u8 want, u8 need,
- u64 action, struct zfcp_adapter *,
+extern void zfcp_rec_dbf_event_adapter(u8 id, void *ref, struct zfcp_adapter *);
+extern void zfcp_rec_dbf_event_port(u8 id, void *ref, struct zfcp_port *port);
+extern void zfcp_rec_dbf_event_unit(u8 id, void *ref, struct zfcp_unit *unit);
+extern void zfcp_rec_dbf_event_trigger(u8 id, void *ref, u8 want, u8 need,
+ void *action, struct zfcp_adapter *,
struct zfcp_port *, struct zfcp_unit *);
extern void zfcp_rec_dbf_event_action(u8 id, struct zfcp_erp_action *);
zfcp_get_busid_by_adapter(adapter),
prot_status_qual->version_error.fsf_version,
ZFCP_QTCB_VERSION);
- zfcp_erp_adapter_shutdown(adapter, 0, 117, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 117, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
qtcb->prefix.req_seq_no,
zfcp_get_busid_by_adapter(adapter),
prot_status_qual->sequence_error.exp_req_seq_no);
- zfcp_erp_adapter_reopen(adapter, 0, 98, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 98, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY;
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"that used on adapter %s. "
"Stopping all operations on this adapter.\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 118, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 118, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
*(unsigned long long*)
(&qtcb->bottom.support.req_handle),
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 78, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 78, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
zfcp_fsf_link_down_info_eval(fsf_req, 37,
&prot_status_qual->link_down_info);
/* FIXME: reopening adapter now? better wait for link up */
- zfcp_erp_adapter_reopen(adapter, 0, 79, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 79, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"Re-starting operations on this adapter.\n",
zfcp_get_busid_by_adapter(adapter));
/* All ports should be marked as ready to run again */
- zfcp_erp_modify_adapter_status(adapter, 28,
- 0, ZFCP_STATUS_COMMON_RUNNING,
+ zfcp_erp_modify_adapter_status(adapter, 28, NULL,
+ ZFCP_STATUS_COMMON_RUNNING,
ZFCP_SET);
zfcp_erp_adapter_reopen(adapter,
ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
| ZFCP_STATUS_COMMON_ERP_FAILED,
- 99, (u64)fsf_req);
+ 99, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"Restarting all operations on this "
"adapter.\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_reopen(adapter, 0, 100, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 100, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY;
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"(debug info 0x%x).\n",
zfcp_get_busid_by_adapter(adapter),
qtcb->prefix.prot_status);
- zfcp_erp_adapter_shutdown(adapter, 0, 119, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 119, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}
"(debug info 0x%x).\n",
zfcp_get_busid_by_adapter(fsf_req->adapter),
fsf_req->qtcb->header.fsf_command);
- zfcp_erp_adapter_shutdown(fsf_req->adapter, 0, 120,
- (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(fsf_req->adapter, 0, 120, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"problem on the adapter %s "
"Stopping all operations on this adapter. ",
zfcp_get_busid_by_adapter(fsf_req->adapter));
- zfcp_erp_adapter_shutdown(fsf_req->adapter, 0, 121,
- (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(fsf_req->adapter, 0, 121, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
case FSF_SQ_ULP_PROGRAMMING_ERROR:
link_down->vendor_specific_code);
out:
- zfcp_erp_adapter_failed(adapter, id, (u64)fsf_req);
+ zfcp_erp_adapter_failed(adapter, id, fsf_req);
}
/*
switch (status_buffer->status_subtype) {
case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT:
- zfcp_erp_port_reopen(port, 0, 101, (u64)fsf_req);
+ zfcp_erp_port_reopen(port, 0, 101, fsf_req);
break;
case FSF_STATUS_READ_SUB_ERROR_PORT:
- zfcp_erp_port_shutdown(port, 0, 122, (u64)fsf_req);
+ zfcp_erp_port_shutdown(port, 0, 122, fsf_req);
break;
default:
"Restarting operations on this adapter\n",
zfcp_get_busid_by_adapter(adapter));
/* All ports should be marked as ready to run again */
- zfcp_erp_modify_adapter_status(adapter, 30, 0,
+ zfcp_erp_modify_adapter_status(adapter, 30, NULL,
ZFCP_STATUS_COMMON_RUNNING,
ZFCP_SET);
zfcp_erp_adapter_reopen(adapter,
ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
| ZFCP_STATUS_COMMON_ERP_FAILED,
- 102, (u64)fsf_req);
+ 102, fsf_req);
break;
case FSF_STATUS_READ_NOTIFICATION_LOST:
if (status_buffer->status_subtype &
FSF_STATUS_READ_SUB_ACT_UPDATED)
- zfcp_erp_adapter_access_changed(adapter, 135,
- (u64)fsf_req);
+ zfcp_erp_adapter_access_changed(adapter, 135, fsf_req);
break;
case FSF_STATUS_READ_CFDC_UPDATED:
ZFCP_LOG_NORMAL("CFDC has been updated on the adapter %s\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_access_changed(adapter, 136, (u64)fsf_req);
+ zfcp_erp_adapter_access_changed(adapter, 136, fsf_req);
break;
case FSF_STATUS_READ_CFDC_HARDENED:
ZFCP_LOG_INFO("restart adapter %s due to status read "
"buffer shortage\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_reopen(adapter, 0, 103, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 103, fsf_req);
}
}
out:
sizeof (union fsf_status_qual));
/* Let's hope this sorts out the mess */
zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104,
- (u64)new_fsf_req);
+ new_fsf_req);
new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}
break;
fsf_status_qual,
sizeof (union fsf_status_qual));
/* Let's hope this sorts out the mess */
- zfcp_erp_port_reopen(unit->port, 0, 105,
- (u64)new_fsf_req);
+ zfcp_erp_port_reopen(unit->port, 0, 105, new_fsf_req);
new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}
break;
ZFCP_LOG_INFO("Remote port 0x%016Lx on adapter %s needs to "
"be reopened\n", unit->port->wwpn,
zfcp_get_busid_by_unit(unit));
- zfcp_erp_port_boxed(unit->port, 47, (u64)new_fsf_req);
+ zfcp_erp_port_boxed(unit->port, 47, new_fsf_req);
new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
| ZFCP_STATUS_FSFREQ_RETRY;
break;
"to be reopened\n",
unit->fcp_lun, unit->port->wwpn,
zfcp_get_busid_by_unit(unit));
- zfcp_erp_unit_boxed(unit, 48, (u64)new_fsf_req);
+ zfcp_erp_unit_boxed(unit, 48, new_fsf_req);
new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
| ZFCP_STATUS_FSFREQ_RETRY;
break;
zfcp_get_busid_by_port(port),
ZFCP_FC_SERVICE_CLASS_DEFAULT);
/* stop operation for this adapter */
- zfcp_erp_adapter_shutdown(adapter, 0, 123, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 123, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
break;
}
}
- zfcp_erp_port_access_denied(port, 55, (u64)fsf_req);
+ zfcp_erp_port_access_denied(port, 55, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(adapter, 0, 106, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 106, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_LOG_INFO("port needs to be reopened "
"(adapter %s, port d_id=0x%06x)\n",
zfcp_get_busid_by_port(port), port->d_id);
- zfcp_erp_port_boxed(port, 49, (u64)fsf_req);
+ zfcp_erp_port_boxed(port, 49, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
| ZFCP_STATUS_FSFREQ_RETRY;
break;
zfcp_get_busid_by_adapter(adapter),
ZFCP_FC_SERVICE_CLASS_DEFAULT);
/* stop operation for this adapter */
- zfcp_erp_adapter_shutdown(adapter, 0, 124, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 124, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
}
}
if (port != NULL)
- zfcp_erp_port_access_denied(port, 56, (u64)fsf_req);
+ zfcp_erp_port_access_denied(port, 56, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"versions in comparison to this device "
"driver (try updated device driver)\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 125, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 125, fsf_req);
return -EIO;
}
if (ZFCP_QTCB_VERSION > bottom->high_qtcb_version) {
"versions than this device driver uses"
"(consider a microcode upgrade)\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 126, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 126, fsf_req);
return -EIO;
}
return 0;
"topology detected at adapter %s "
"unsupported, shutting down adapter\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 127, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 127, fsf_req);
return -EIO;
case FC_PORTTYPE_NPORT:
ZFCP_LOG_NORMAL("Switched fabric fibrechannel "
"of a type known to the zfcp "
"driver, shutting down adapter\n",
zfcp_get_busid_by_adapter(adapter));
- zfcp_erp_adapter_shutdown(adapter, 0, 128, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 128, fsf_req);
return -EIO;
}
bottom = &qtcb->bottom.config;
bottom->max_qtcb_size,
zfcp_get_busid_by_adapter(adapter),
sizeof(struct fsf_qtcb));
- zfcp_erp_adapter_shutdown(adapter, 0, 129, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 129, fsf_req);
return -EIO;
}
atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
&qtcb->header.fsf_status_qual.link_down_info);
break;
default:
- zfcp_erp_adapter_shutdown(adapter, 0, 130, (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(adapter, 0, 130, fsf_req);
return -EIO;
}
return 0;
break;
}
}
- zfcp_erp_port_access_denied(port, 57, (u64)fsf_req);
+ zfcp_erp_port_access_denied(port, 57, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"The remote port 0x%016Lx on adapter %s "
"could not be opened. Disabling it.\n",
port->wwpn, zfcp_get_busid_by_port(port));
- zfcp_erp_port_failed(port, 31, (u64)fsf_req);
+ zfcp_erp_port_failed(port, 31, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"Disabling it.\n",
port->wwpn,
zfcp_get_busid_by_port(port));
- zfcp_erp_port_failed(port, 32, (u64)fsf_req);
+ zfcp_erp_port_failed(port, 32, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
default:
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &fsf_req->qtcb->header.fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(port->adapter, 0, 107, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(port->adapter, 0, 107, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_LOG_TRACE("remote port 0x016%Lx on adapter %s closed, "
"port handle 0x%x\n", port->wwpn,
zfcp_get_busid_by_port(port), port->handle);
- zfcp_erp_modify_port_status(port, 33, (u64)fsf_req,
+ zfcp_erp_modify_port_status(port, 33, fsf_req,
ZFCP_STATUS_COMMON_OPEN,
ZFCP_CLEAR);
retval = 0;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(port->adapter, 0, 108, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(port->adapter, 0, 108, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
break;
}
}
- zfcp_erp_port_access_denied(port, 58, (u64)fsf_req);
+ zfcp_erp_port_access_denied(port, 58, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"to close it physically.\n",
port->wwpn,
zfcp_get_busid_by_port(port));
- zfcp_erp_port_boxed(port, 50, (u64)fsf_req);
+ zfcp_erp_port_boxed(port, 50, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
ZFCP_STATUS_FSFREQ_RETRY;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109,
- (u64)fsf_req);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
break;
}
}
- zfcp_erp_unit_access_denied(unit, 59, (u64)fsf_req);
+ zfcp_erp_unit_access_denied(unit, 59, fsf_req);
atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter %s "
"needs to be reopened\n",
unit->port->wwpn, zfcp_get_busid_by_unit(unit));
- zfcp_erp_port_boxed(unit->port, 51, (u64)fsf_req);
+ zfcp_erp_port_boxed(unit->port, 51, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
ZFCP_STATUS_FSFREQ_RETRY;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_unit_access_denied(unit, 60, (u64)fsf_req);
+ zfcp_erp_unit_access_denied(unit, 60, fsf_req);
atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
unit->fcp_lun,
unit->port->wwpn,
zfcp_get_busid_by_unit(unit));
- zfcp_erp_unit_failed(unit, 34, (u64)fsf_req);
+ zfcp_erp_unit_failed(unit, 34, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
if (exclusive && !readwrite) {
ZFCP_LOG_NORMAL("exclusive access of read-only "
"unit not supported\n");
- zfcp_erp_unit_failed(unit, 35, (u64)fsf_req);
+ zfcp_erp_unit_failed(unit, 35, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
- zfcp_erp_unit_shutdown(unit, 0, 80,
- (u64)fsf_req);
+ zfcp_erp_unit_shutdown(unit, 0, 80, fsf_req);
} else if (!exclusive && readwrite) {
ZFCP_LOG_NORMAL("shared access of read-write "
"unit not supported\n");
- zfcp_erp_unit_failed(unit, 36, (u64)fsf_req);
+ zfcp_erp_unit_failed(unit, 36, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
- zfcp_erp_unit_shutdown(unit, 0, 81,
- (u64)fsf_req);
+ zfcp_erp_unit_shutdown(unit, 0, 81, fsf_req);
}
}
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &fsf_req->qtcb->header.fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110,
- (u64)fsf_req);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &fsf_req->qtcb->header.fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_port_reopen(unit->port, 0, 111, (u64)fsf_req);
+ zfcp_erp_port_reopen(unit->port, 0, 111, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
"needs to be reopened\n",
unit->port->wwpn,
zfcp_get_busid_by_unit(unit));
- zfcp_erp_port_boxed(unit->port, 52, (u64)fsf_req);
+ zfcp_erp_port_boxed(unit->port, 52, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
ZFCP_STATUS_FSFREQ_RETRY;
break;
zfcp_get_busid_by_unit(unit),
unit->port->wwpn,
unit->fcp_lun);
- zfcp_erp_unit_shutdown(unit, 0, 131, (u64)fsf_req);
+ zfcp_erp_unit_shutdown(unit, 0, 131, fsf_req);
retval = -EINVAL;
}
goto no_fit;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112,
- (u64)fsf_req);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_port_reopen(unit->port, 0, 113, (u64)fsf_req);
+ zfcp_erp_port_reopen(unit->port, 0, 113, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_adapter_reopen(unit->port->adapter, 0, 114,
- (u64)fsf_req);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0, 114, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
zfcp_get_busid_by_unit(unit),
ZFCP_FC_SERVICE_CLASS_DEFAULT);
/* stop operation for this adapter */
- zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 132,
- (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 132, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
(char *) &header->fsf_status_qual,
sizeof (union fsf_status_qual));
- zfcp_erp_port_reopen(unit->port, 0, 115, (u64)fsf_req);
+ zfcp_erp_port_reopen(unit->port, 0, 115, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
break;
}
}
- zfcp_erp_unit_access_denied(unit, 61, (u64)fsf_req);
+ zfcp_erp_unit_access_denied(unit, 61, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
zfcp_get_busid_by_unit(unit),
fsf_req->qtcb->bottom.io.data_direction);
/* stop operation for this adapter */
- zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133,
- (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
zfcp_get_busid_by_unit(unit),
fsf_req->qtcb->bottom.io.fcp_cmnd_length);
/* stop operation for this adapter */
- zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134,
- (u64)fsf_req);
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
break;
ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter %s "
"needs to be reopened\n",
unit->port->wwpn, zfcp_get_busid_by_unit(unit));
- zfcp_erp_port_boxed(unit->port, 53, (u64)fsf_req);
+ zfcp_erp_port_boxed(unit->port, 53, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
ZFCP_STATUS_FSFREQ_RETRY;
break;
"wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
zfcp_get_busid_by_unit(unit),
unit->port->wwpn, unit->fcp_lun);
- zfcp_erp_unit_boxed(unit, 54, (u64)fsf_req);
+ zfcp_erp_unit_boxed(unit, 54, fsf_req);
fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
| ZFCP_STATUS_FSFREQ_RETRY;
break;
req_queue->free_index -= fsf_req->sbal_number;
req_queue->free_index += QDIO_MAX_BUFFERS_PER_Q;
req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
- zfcp_erp_adapter_reopen(adapter, 0, 116, (u64)fsf_req);
+ zfcp_erp_adapter_reopen(adapter, 0, 116, fsf_req);
} else {
req_queue->distance_from_int = new_distance_from_int;
/*
*/
zfcp_erp_adapter_reopen(adapter,
ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
- ZFCP_STATUS_COMMON_ERP_FAILED, 140, 0);
+ ZFCP_STATUS_COMMON_ERP_FAILED, 140,
+ NULL);
}
return retval;
}
atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
sdpnt->hostdata = NULL;
unit->device = NULL;
- zfcp_erp_unit_failed(unit, 12, 0);
+ zfcp_erp_unit_failed(unit, 12, NULL);
zfcp_unit_put(unit);
} else
ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
unit->fcp_lun, unit->port->wwpn,
zfcp_get_busid_by_adapter(unit->port->adapter));
- zfcp_erp_adapter_reopen(adapter, 0, 141, (u64)scpnt);
+ zfcp_erp_adapter_reopen(adapter, 0, 141, scpnt);
zfcp_erp_wait(adapter);
return SUCCESS;
retval = 0;
- zfcp_erp_port_reopen(port, 0, 91, 0);
+ zfcp_erp_port_reopen(port, 0, 91, NULL);
zfcp_erp_wait(port->adapter);
zfcp_port_put(port);
out:
goto out;
}
- zfcp_erp_port_shutdown(port, 0, 92, 0);
+ zfcp_erp_port_shutdown(port, 0, 92, NULL);
zfcp_erp_wait(adapter);
zfcp_port_put(port);
zfcp_port_dequeue(port);
goto out;
}
- zfcp_erp_modify_adapter_status(adapter, 44, 0,
+ zfcp_erp_modify_adapter_status(adapter, 44, NULL,
ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
- zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 93, 0);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 93,
+ NULL);
zfcp_erp_wait(adapter);
out:
up(&zfcp_data.config_sema);
retval = 0;
- zfcp_erp_unit_reopen(unit, 0, 94, 0);
+ zfcp_erp_unit_reopen(unit, 0, 94, NULL);
zfcp_erp_wait(unit->port->adapter);
zfcp_unit_put(unit);
out:
goto out;
}
- zfcp_erp_unit_shutdown(unit, 0, 95, 0);
+ zfcp_erp_unit_shutdown(unit, 0, 95, NULL);
zfcp_erp_wait(unit->port->adapter);
zfcp_unit_put(unit);
zfcp_unit_dequeue(unit);
goto out;
}
- zfcp_erp_modify_port_status(port, 45, 0,
+ zfcp_erp_modify_port_status(port, 45, NULL,
ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
- zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 96, 0);
+ zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 96, NULL);
zfcp_erp_wait(port->adapter);
out:
up(&zfcp_data.config_sema);
goto out;
}
- zfcp_erp_modify_unit_status(unit, 46, 0,
+ zfcp_erp_modify_unit_status(unit, 46, NULL,
ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
- zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, 97, 0);
+ zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, 97, NULL);
zfcp_erp_wait(unit->port->adapter);
out:
up(&zfcp_data.config_sema);
git.openpandora.org / pandora-kernel.git / commitdiff