mirrors/scst
1
0
Fork 0
mirror of https://github.com/SCST-project/scst.git synced 2026-05-19 11:41:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Device blocking cleanups and fixes

Browse Source 
- tags logging made unsigned 


git-svn-id: http://svn.code.sf.net/p/scst/svn/trunk@154 d57e44dd-8a1f-0410-8b47-8ef2f437770f
This commit is contained in:
Vladislav Bolkhovitin
2007-07-31 14:21:46 +00:00
parent b28d1b9905
commit 10f17420b5
5 changed files with 149 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
scst/include/scsi_tgt.h
View File

@@ -951,8 +951,14 @@ struct scst_cmd
/* Set if cmd is being retried */
unsigned int retry:1;
/* Set if the device should be unblock after cmd's finish */
unsigned int blocking:1;
/* Set if the device was blocked by scst_inc_on_dev_cmd() (for debug) */
unsigned int inc_blocking:1;
/* Set if the device should be unblocked after cmd's finish */
unsigned int needs_unblocking:1;
/* Set if scst_dec_on_dev_cmd() call is needed on the cmd's finish */
unsigned int dec_on_dev_needed:1;
/*
* Set if the target driver wants to alloc data buffers on its own.

2
scst/src/dev_handlers/scst_vdisk.c
View File

@@ -657,7 +657,7 @@ static int vdisk_do_job(struct scst_cmd *cmd)
if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) {
TRACE_MGMT_DBG("Flag ABORTED set for "
"cmd %p (tag %lld), skipping", cmd, cmd->tag);
"cmd %p (tag %llu), skipping", cmd, cmd->tag);
goto done_uncompl;
}

95
scst/src/scst_lib.c
View File

@@ -126,7 +126,7 @@ void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len)
l += cmd->sg[i].length;
if (l >= resp_data_len) {
int left = resp_data_len - (l - cmd->sg[i].length);
TRACE(TRACE_SG|TRACE_MEMORY, "cmd %p (tag %lld), "
TRACE(TRACE_SG|TRACE_MEMORY, "cmd %p (tag %llu), "
"resp_data_len %d, i %d, cmd->sg[i].length %d, "
"left %d", cmd, cmd->tag, resp_data_len, i,
cmd->sg[i].length, left);
@@ -1199,12 +1199,15 @@ void scst_free_cmd(struct scst_cmd *cmd)
TRACE_ENTRY();
TRACE_DBG("Freeing cmd %p (tag %Lu)", cmd, cmd->tag);
if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) {
TRACE_MGMT_DBG("Freeing aborted cmd %p (scst_cmd_count %d)",
cmd, atomic_read(&scst_cmd_count));
}
sBUG_ON(cmd->blocking);
sBUG_ON(cmd->inc_blocking || cmd->needs_unblocking ||
cmd->dec_on_dev_needed);
#if defined(EXTRACHECKS) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
if (cmd->scsi_req) {
@@ -1267,7 +1270,7 @@ void scst_free_cmd(struct scst_cmd *cmd)
#endif
if (unlikely(cmd->out_of_sn)) {
TRACE_SN("Out of SN cmd %p (tag %lld, sn %ld), "
TRACE_SN("Out of SN cmd %p (tag %llu, sn %ld), "
"destroy=%d", cmd, cmd->tag, cmd->sn, destroy);
destroy = test_and_set_bit(SCST_CMD_CAN_BE_DESTROYED,
&cmd->cmd_flags);
@@ -2536,7 +2539,7 @@ restart:
* !! sn_slot and sn_cmd_list_entry, could be !!
* !! already destroyed !!
*/
TRACE_SN("cmd %p (tag %lld) with skipped sn %ld found",
TRACE_SN("cmd %p (tag %llu) with skipped sn %ld found",
cmd, cmd->tag, cmd->sn);
tgt_dev->def_cmd_count--;
list_del(&cmd->sn_cmd_list_entry);
@@ -2628,6 +2631,58 @@ struct scst_thr_data_hdr *scst_find_thr_data(struct scst_tgt_dev *tgt_dev)
return res;
}
/* dev_lock supposed to be held and BH disabled */
void __scst_block_dev(struct scst_device *dev)
{
dev->block_count++;
smp_mb();
TRACE_MGMT_DBG("Device BLOCK(new %d), dev %p", dev->block_count, dev);
}
/* No locks */
void scst_block_dev(struct scst_device *dev, int outstanding)
{
spin_lock_bh(&dev->dev_lock);
__scst_block_dev(dev);
spin_unlock_bh(&dev->dev_lock);
TRACE_MGMT_DBG("Waiting during blocking outstanding %d (on_dev_count "
"%d)", outstanding, atomic_read(&dev->on_dev_count));
wait_event(dev->on_dev_waitQ,
atomic_read(&dev->on_dev_count) <= outstanding);
TRACE_MGMT_DBG("%s", "wait_event() returned");
}
/* No locks */
void scst_block_dev_cmd(struct scst_cmd *cmd, int outstanding)
{
sBUG_ON(cmd->needs_unblocking);
cmd->needs_unblocking = 1;
TRACE_MGMT_DBG("Needs unblocking cmd %p (tag %llu)", cmd, cmd->tag);
scst_block_dev(cmd->dev, outstanding);
}
/* No locks */
void scst_unblock_dev(struct scst_device *dev)
{
spin_lock_bh(&dev->dev_lock);
TRACE_MGMT_DBG("Device UNBLOCK(new %d), dev %p",
dev->block_count-1, dev);
if (--dev->block_count == 0)
scst_unblock_cmds(dev);
spin_unlock_bh(&dev->dev_lock);
sBUG_ON(dev->block_count < 0);
}
/* No locks */
void scst_unblock_dev_cmd(struct scst_cmd *cmd)
{
scst_unblock_dev(cmd->dev);
cmd->needs_unblocking = 0;
}
/* No locks */
int scst_inc_on_dev_cmd(struct scst_cmd *cmd)
{
@@ -2636,24 +2691,26 @@ int scst_inc_on_dev_cmd(struct scst_cmd *cmd)
TRACE_ENTRY();
sBUG_ON(cmd->blocking);
sBUG_ON(cmd->inc_blocking || cmd->dec_on_dev_needed);
atomic_inc(&dev->on_dev_count);
cmd->dec_on_dev_needed = 1;
TRACE_DBG("New on_dev_count %d", atomic_read(&dev->on_dev_count));
#ifdef STRICT_SERIALIZING
spin_lock_bh(&dev->dev_lock);
if (test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))
goto out_unlock;
if (dev->block_count > 0) {
scst_dec_on_dev_cmd(cmd, 0);
TRACE_MGMT_DBG("Delaying cmd %p due to blocking or serializing"
"(tag %lld, dev %p)", cmd, cmd->tag, dev);
scst_dec_on_dev_cmd(cmd);
TRACE_MGMT_DBG("Delaying cmd %p due to blocking or strict "
"serializing (tag %llu, dev %p)", cmd, cmd->tag, dev);
list_add_tail(&cmd->blocked_cmd_list_entry,
&dev->blocked_cmd_list);
res = 1;
} else {
__scst_block_dev(dev);
cmd->blocking = 1;
cmd->inc_blocking = 1;
}
spin_unlock_bh(&dev->dev_lock);
goto out;
@@ -2665,9 +2722,9 @@ repeat:
goto out_unlock;
barrier(); /* to reread block_count */
if (dev->block_count > 0) {
scst_dec_on_dev_cmd(cmd, 0);
scst_dec_on_dev_cmd(cmd);
TRACE_MGMT_DBG("Delaying cmd %p due to blocking or "
"serializing (tag %lld, dev %p)", cmd,
"serializing (tag %llu, dev %p)", cmd,
cmd->tag, dev);
list_add_tail(&cmd->blocked_cmd_list_entry,
&dev->blocked_cmd_list);
@@ -2684,11 +2741,11 @@ repeat:
spin_lock_bh(&dev->dev_lock);
barrier(); /* to reread block_count */
if (dev->block_count == 0) {
TRACE_MGMT_DBG("cmd %p (tag %lld), blocking further "
TRACE_MGMT_DBG("cmd %p (tag %llu), blocking further "
"cmds due to serializing (dev %p)", cmd,
cmd->tag, dev);
__scst_block_dev(dev);
cmd->blocking = 1;
cmd->inc_blocking = 1;
} else {
spin_unlock_bh(&dev->dev_lock);
TRACE_MGMT_DBG("Somebody blocked the device, "
@@ -2960,7 +3017,7 @@ static void tm_dbg_delay_cmd(struct scst_cmd *cmd)
case TM_DBG_STATE_ABORT:
if (tm_dbg_delayed_cmds_count == 0) {
unsigned long d = 58*HZ + (scst_random() % (4*HZ));
TRACE_MGMT_DBG("STATE ABORT: delaying cmd %p (tag %lld) "
TRACE_MGMT_DBG("STATE ABORT: delaying cmd %p (tag %llu) "
"for %ld.%ld seconds (%ld HZ), "
"tm_dbg_on_state_passes=%d", cmd, cmd->tag,
d/HZ, (d%HZ)*100/HZ, d, tm_dbg_on_state_passes);
@@ -2970,7 +3027,7 @@ static void tm_dbg_delay_cmd(struct scst_cmd *cmd)
#endif
} else {
TRACE_MGMT_DBG("Delaying another timed cmd %p "
"(tag %lld), delayed_cmds_count=%d, "
"(tag %llu), delayed_cmds_count=%d, "
"tm_dbg_on_state_passes=%d", cmd, cmd->tag,
tm_dbg_delayed_cmds_count,
tm_dbg_on_state_passes);
@@ -2982,7 +3039,7 @@ static void tm_dbg_delay_cmd(struct scst_cmd *cmd)
case TM_DBG_STATE_RESET:
case TM_DBG_STATE_OFFLINE:
TRACE_MGMT_DBG("STATE RESET/OFFLINE: delaying cmd %p "
"(tag %lld), delayed_cmds_count=%d, "
"(tag %llu), delayed_cmds_count=%d, "
"tm_dbg_on_state_passes=%d", cmd, cmd->tag,
tm_dbg_delayed_cmds_count, tm_dbg_on_state_passes);
tm_dbg_flags.tm_dbg_blocked = 1;
@@ -3008,7 +3065,7 @@ void tm_dbg_check_released_cmds(void)
spin_lock_irq(&scst_tm_dbg_lock);
list_for_each_entry_safe_reverse(cmd, tc,
&tm_dbg_delayed_cmd_list, cmd_list_entry) {
TRACE_MGMT_DBG("Releasing timed cmd %p (tag %lld), "
TRACE_MGMT_DBG("Releasing timed cmd %p (tag %llu), "
"delayed_cmds_count=%d", cmd, cmd->tag,
tm_dbg_delayed_cmds_count);
spin_lock(&cmd->cmd_lists->cmd_list_lock);
@@ -3070,7 +3127,7 @@ int tm_dbg_check_cmd(struct scst_cmd *cmd)
if (cmd->tm_dbg_delayed) {
spin_lock_irqsave(&scst_tm_dbg_lock, flags);
TRACE_MGMT_DBG("Processing delayed cmd %p (tag %lld), "
TRACE_MGMT_DBG("Processing delayed cmd %p (tag %llu), "
"delayed_cmds_count=%d", cmd, cmd->tag,
tm_dbg_delayed_cmds_count);
@@ -3108,7 +3165,7 @@ void tm_dbg_release_cmd(struct scst_cmd *cmd)
cmd_list_entry) {
if (c == cmd) {
TRACE_MGMT_DBG("Abort request for "
"delayed cmd %p (tag=%lld), moving it to "
"delayed cmd %p (tag=%llu), moving it to "
"active cmd list (delayed_cmds_count=%d)",
c, c->tag, tm_dbg_delayed_cmds_count);
spin_lock(&cmd->cmd_lists->cmd_list_lock);

58
scst/src/scst_priv.h
View File

@@ -414,61 +414,43 @@ static inline int scst_is_implicit_hq(struct scst_cmd *cmd)
extern int scst_inc_on_dev_cmd(struct scst_cmd *cmd);
extern void scst_unblock_cmds(struct scst_device *dev);
static inline void __scst_block_dev(struct scst_device *dev)
{
dev->block_count++;
smp_mb();
TRACE_MGMT_DBG("Device BLOCK(%d), dev %p", dev->block_count, dev);
}
static inline void scst_block_dev(struct scst_device *dev,
int outstanding)
{
spin_lock_bh(&dev->dev_lock);
__scst_block_dev(dev);
spin_unlock_bh(&dev->dev_lock);
TRACE_MGMT_DBG("Waiting during blocking outstanding %d (on_dev_count "
"%d)", outstanding, atomic_read(&dev->on_dev_count));
wait_event(dev->on_dev_waitQ,
atomic_read(&dev->on_dev_count) <= outstanding);
TRACE_MGMT_DBG("%s", "wait_event() returned");
}
static inline void scst_unblock_dev(struct scst_device *dev)
{
spin_lock_bh(&dev->dev_lock);
TRACE_MGMT_DBG("Device UNBLOCK(%d), dev %p",
dev->block_count-1, dev);
if (--dev->block_count == 0)
scst_unblock_cmds(dev);
spin_unlock_bh(&dev->dev_lock);
}
extern void __scst_block_dev(struct scst_device *dev);
extern void scst_block_dev(struct scst_device *dev, int outstanding);
extern void scst_block_dev_cmd(struct scst_cmd *cmd, int outstanding);
extern void scst_unblock_dev(struct scst_device *dev);
extern void scst_unblock_dev_cmd(struct scst_cmd *cmd);
static inline void __scst_dec_on_dev_cmd(struct scst_device *dev,
int cmd_blocking)
int unblock_dev)
{
if (cmd_blocking)
if (unblock_dev)
scst_unblock_dev(dev);
atomic_dec(&dev->on_dev_count);
smp_mb__after_atomic_dec();
TRACE_DBG("New on_dev_count %d", atomic_read(&dev->on_dev_count));
sBUG_ON(atomic_read(&dev->on_dev_count) < 0);
if (unlikely(dev->block_count != 0))
wake_up_all(&dev->on_dev_waitQ);
}
static inline int scst_dec_on_dev_cmd(struct scst_cmd *cmd, int defer)
static inline int scst_pre_dec_on_dev_cmd(struct scst_cmd *cmd)
{
int cmd_blocking = cmd->blocking;
int cmd_blocking = cmd->inc_blocking;
if (cmd_blocking) {
TRACE_MGMT_DBG("cmd %p (tag %lld): unblocking dev %p", cmd,
TRACE_MGMT_DBG("cmd %p (tag %llu): unblocking dev %p", cmd,
cmd->tag, cmd->dev);
cmd->blocking = 0;
cmd->inc_blocking = 0;
}
if (!defer)
__scst_dec_on_dev_cmd(cmd->dev, cmd_blocking);
cmd->dec_on_dev_needed = 0;
return cmd_blocking;
}
static inline void scst_dec_on_dev_cmd(struct scst_cmd *cmd)
{
int cmd_blocking = scst_pre_dec_on_dev_cmd(cmd);
__scst_dec_on_dev_cmd(cmd->dev, cmd_blocking);
}
static inline void __scst_get(int barrier)
{
atomic_inc(&scst_cmd_count);

83
scst/src/scst_targ.c
View File

@@ -165,7 +165,7 @@ void scst_cmd_init_done(struct scst_cmd *cmd, int pref_context)
TRACE_ENTRY();
TRACE_DBG("Preferred context: %d (cmd %p)", pref_context, cmd);
TRACE(TRACE_SCSI, "tag=%lld, lun=%Ld, CDB len=%d", cmd->tag,
TRACE(TRACE_SCSI, "tag=%llu, lun=%Ld, CDB len=%d", cmd->tag,
(uint64_t)cmd->lun, cmd->cdb_len);
TRACE_BUFF_FLAG(TRACE_SCSI|TRACE_RECV_BOT, "Recieving CDB",
cmd->cdb, cmd->cdb_len);
@@ -700,7 +700,7 @@ void scst_restart_cmd(struct scst_cmd *cmd, int status, int pref_context)
TRACE_ENTRY();
TRACE_DBG("Preferred context: %d", pref_context);
TRACE_DBG("tag=%lld, status=%#x", scst_cmd_get_tag(cmd), status);
TRACE_DBG("tag=%llu, status=%#x", scst_cmd_get_tag(cmd), status);
#ifdef EXTRACHECKS
if (in_irq() && ((pref_context == SCST_CONTEXT_DIRECT) ||
@@ -950,7 +950,7 @@ void scst_rx_data(struct scst_cmd *cmd, int status, int pref_context)
TRACE_ENTRY();
TRACE_DBG("Preferred context: %d", pref_context);
TRACE(TRACE_SCSI, "tag=%lld status=%#x", scst_cmd_get_tag(cmd), status);
TRACE(TRACE_SCSI, "tag=%llu status=%#x", scst_cmd_get_tag(cmd), status);
#ifdef EXTRACHECKS
if (in_irq() && ((pref_context == SCST_CONTEXT_DIRECT) ||
@@ -1095,7 +1095,9 @@ static void scst_do_cmd_done(struct scst_cmd *cmd, int result,
cmd->completed = 1;
scst_dec_on_dev_cmd(cmd, 0);
if (likely(cmd->host_status != DID_RESET) &&
likely(!SCST_SENSE_VALID(cmd->sense_buffer)))
scst_dec_on_dev_cmd(cmd);
type = cmd->dev->handler->type;
if ((cmd->cdb[0] == MODE_SENSE || cmd->cdb[0] == MODE_SENSE_10) &&
@@ -1218,7 +1220,8 @@ static void scst_cmd_done_local(struct scst_cmd *cmd, int next_state)
{
TRACE_ENTRY();
scst_dec_on_dev_cmd(cmd, 0);
if (likely(!SCST_SENSE_VALID(cmd->sense_buffer)))
scst_dec_on_dev_cmd(cmd);
if (cmd->inc_expected_sn_on_done)
scst_inc_check_expected_sn(cmd);
@@ -1383,8 +1386,7 @@ static int scst_pre_select(struct scst_cmd *cmd)
goto out;
}
scst_block_dev(cmd->dev, 1);
/* Device will be unblocked in scst_done_cmd_check() */
scst_block_dev_cmd(cmd, 1);
if (test_bit(SCST_TGT_DEV_UA_PENDING, &cmd->tgt_dev->tgt_dev_flags)) {
int rc = scst_set_pending_UA(cmd);
@@ -1439,8 +1441,8 @@ static int scst_reserve_local(struct scst_cmd *cmd)
}
dev = cmd->dev;
scst_block_dev(dev, 1);
/* Device will be unblocked in scst_done_cmd_check() */
scst_block_dev_cmd(cmd, 1);
spin_lock_bh(&dev->dev_lock);
@@ -1478,9 +1480,7 @@ static int scst_release_local(struct scst_cmd *cmd)
dev = cmd->dev;
scst_block_dev(dev, 1);
cmd->blocking = 1;
TRACE_MGMT_DBG("Blocking cmd %p (tag %lld)", cmd, cmd->tag);
scst_block_dev_cmd(cmd, 1);
spin_lock_bh(&dev->dev_lock);
@@ -1867,7 +1867,7 @@ static int scst_send_to_midlev(struct scst_cmd *cmd)
TRACE_DBG("%s", "scst_do_send_to_midlev() requested "
"thread context, rescheduling");
res = SCST_CMD_STATE_RES_NEED_THREAD;
scst_dec_on_dev_cmd(cmd, 0);
scst_dec_on_dev_cmd(cmd);
goto out_dec_cmd_count;
} else {
sBUG_ON(rc != SCST_EXEC_COMPLETED);
@@ -1887,7 +1887,7 @@ static int scst_send_to_midlev(struct scst_cmd *cmd)
scst_cmd_put(cmd);
goto exec;
} else {
scst_dec_on_dev_cmd(cmd, 0);
scst_dec_on_dev_cmd(cmd);
scst_cmd_put(cmd);
goto out_unplug;
}
@@ -1905,10 +1905,10 @@ static int scst_send_to_midlev(struct scst_cmd *cmd)
if ((cmd->sn != expected_sn) || test_bit(SCST_TGT_DEV_HQ_ACTIVE,
&tgt_dev->tgt_dev_flags)) {
/* We are under IRQ lock, but dev->dev_lock is BH one */
int cmd_blocking = scst_dec_on_dev_cmd(cmd, 1);
int cmd_blocking = scst_pre_dec_on_dev_cmd(cmd);
if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) {
/* Necessary to allow aborting out of sn cmds */
TRACE_MGMT_DBG("Aborting out of sn cmd %p (tag %lld)",
TRACE_MGMT_DBG("Aborting out of sn cmd %p (tag %llu)",
cmd, cmd->tag);
tgt_dev->def_cmd_count--;
cmd->state = SCST_CMD_STATE_DEV_DONE;
@@ -1954,7 +1954,7 @@ exec:
&tgt_dev->hq_cmd_list);
spin_unlock_irq(&tgt_dev->sn_lock);
}
scst_dec_on_dev_cmd(cmd, 0);
scst_dec_on_dev_cmd(cmd);
if (count != 0)
goto out_unplug;
else
@@ -2025,20 +2025,19 @@ static int scst_check_sense(struct scst_cmd *cmd)
spin_unlock_bh(&dev->dev_lock);
}
if (sense_valid) {
if (unlikely(sense_valid)) {
TRACE_BUFF_FLAG(TRACE_SCSI, "Sense", cmd->sense_buffer,
sizeof(cmd->sense_buffer));
sizeof(cmd->sense_buffer));
/* Check Unit Attention Sense Key */
if (cmd->sense_buffer[2] == UNIT_ATTENTION) {
if (cmd->sense_buffer[12] == SCST_SENSE_ASC_UA_RESET) {
if (dbl_ua_possible)
{
if (dbl_ua_possible) {
if (ua_sent) {
TRACE(TRACE_MGMT, "%s",
"Double UA detected");
/* Do retry */
TRACE(TRACE_MGMT, "Retrying cmd %p "
"(tag %lld)", cmd, cmd->tag);
"(tag %llu)", cmd, cmd->tag);
cmd->status = 0;
cmd->msg_status = 0;
cmd->host_status = DID_OK;
@@ -2223,7 +2222,6 @@ static int scst_done_cmd_check(struct scst_cmd *cmd, int *pres)
}
cmd->dev->dev_reserved = 0;
}
scst_unblock_dev(cmd->dev);
}
if (unlikely((cmd->cdb[0] == MODE_SELECT) ||
@@ -2248,7 +2246,6 @@ static int scst_done_cmd_check(struct scst_cmd *cmd, int *pres)
sizeof(scst_temp_UA), 1);
spin_unlock_bh(&scst_temp_UA_lock);
}
scst_unblock_dev(cmd->dev);
}
out:
@@ -2258,7 +2255,7 @@ out:
static int scst_dev_done(struct scst_cmd *cmd)
{
int res = SCST_CMD_STATE_RES_CONT_SAME;
int res = SCST_CMD_STATE_RES_CONT_SAME, rc;
int state;
int atomic = scst_cmd_atomic(cmd);
@@ -2273,7 +2270,15 @@ static int scst_dev_done(struct scst_cmd *cmd)
goto out;
}
if (scst_done_cmd_check(cmd, &res))
rc = scst_done_cmd_check(cmd, &res);
if (cmd->needs_unblocking)
scst_unblock_dev_cmd(cmd);
if (unlikely(cmd->dec_on_dev_needed))
scst_dec_on_dev_cmd(cmd);
if (rc)
goto out;
state = SCST_CMD_STATE_XMIT_RESP;
@@ -2373,13 +2378,13 @@ static int scst_xmit_response(struct scst_cmd *cmd)
if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) {
if (test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags)) {
TRACE_MGMT_DBG("Flag ABORTED OTHER set for cmd %p "
"(tag %lld), returning TASK ABORTED", cmd, cmd->tag);
"(tag %llu), returning TASK ABORTED", cmd, cmd->tag);
scst_set_cmd_error_status(cmd, SAM_STAT_TASK_ABORTED);
}
}
if (unlikely(test_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags))) {
TRACE_MGMT_DBG("Flag NO_RESP set for cmd %p (tag %lld), skipping",
TRACE_MGMT_DBG("Flag NO_RESP set for cmd %p (tag %llu), skipping",
cmd, cmd->tag);
cmd->state = SCST_CMD_STATE_FINISHED;
res = SCST_CMD_STATE_RES_CONT_SAME;
@@ -2393,7 +2398,7 @@ static int scst_xmit_response(struct scst_cmd *cmd)
res = SCST_CMD_STATE_RES_NEED_THREAD;
goto out;
}
TRACE_MGMT_DBG("Delaying cmd %p (tag %lld) for 1 second",
TRACE_MGMT_DBG("Delaying cmd %p (tag %llu) for 1 second",
cmd, cmd->tag);
schedule_timeout_uninterruptible(HZ);
}
@@ -2746,7 +2751,7 @@ restart:
goto restart;
}
} else {
TRACE_MGMT_DBG("Aborting not inited cmd %p (tag %lld)",
TRACE_MGMT_DBG("Aborting not inited cmd %p (tag %llu)",
cmd, cmd->tag);
cmd->state = SCST_CMD_STATE_XMIT_RESP;
}
@@ -2866,7 +2871,7 @@ void scst_process_active_cmd(struct scst_cmd *cmd, int context)
case SCST_CMD_STATE_SEND_TO_MIDLEV:
if (tm_dbg_check_cmd(cmd) != 0) {
res = SCST_CMD_STATE_RES_CONT_NEXT;
TRACE_MGMT_DBG("Skipping cmd %p (tag %lld), "
TRACE_MGMT_DBG("Skipping cmd %p (tag %llu), "
"because of TM DBG delay", cmd,
cmd->tag);
break;
@@ -3094,7 +3099,7 @@ void scst_complete_cmd_mgmt(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd)
spin_lock_irq(&scst_mcmd_lock);
TRACE_MGMT_DBG("cmd %p completed (tag %lld, mcmd %p, "
TRACE_MGMT_DBG("cmd %p completed (tag %llu, mcmd %p, "
"mcmd->cmd_wait_count %d)", cmd, cmd->tag, mcmd,
mcmd->cmd_wait_count);
@@ -3172,7 +3177,7 @@ void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
{
TRACE_ENTRY();
TRACE(TRACE_MGMT, "Aborting cmd %p (tag %lld)", cmd, cmd->tag);
TRACE(TRACE_MGMT, "Aborting cmd %p (tag %llu)", cmd, cmd->tag);
if (other_ini) {
set_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags);
@@ -3204,12 +3209,12 @@ void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
* we must wait here to be sure that we won't receive
* double commands with the same tag.
*/
TRACE(TRACE_MGMT, "cmd %p (tag %lld) being executed/"
TRACE(TRACE_MGMT, "cmd %p (tag %llu) being executed/"
"xmitted (state %d), deferring ABORT...", cmd,
cmd->tag, cmd->state);
#ifdef EXTRACHECKS
if (cmd->mgmt_cmnd) {
printk(KERN_ALERT "cmd %p (tag %lld, state %d) "
printk(KERN_ALERT "cmd %p (tag %llu, state %d) "
"has non-NULL mgmt_cmnd %p!!! Current "
"mcmd %p\n", cmd, cmd->tag, cmd->state,
cmd->mgmt_cmnd, mcmd);
@@ -3400,7 +3405,7 @@ static int scst_mgmt_cmd_init(struct scst_mgmt_cmd *mcmd)
cmd = __scst_find_cmd_by_tag(sess, mcmd->tag);
if (cmd == NULL) {
TRACE(TRACE_MGMT, "ABORT TASK failed: command for "
"tag %lld not found", mcmd->tag);
"tag %llu not found", mcmd->tag);
mcmd->status = SCST_MGMT_STATUS_TASK_NOT_EXIST;
mcmd->state = SCST_MGMT_CMD_STATE_DONE;
spin_unlock_irq(&sess->sess_list_lock);
@@ -3408,7 +3413,7 @@ static int scst_mgmt_cmd_init(struct scst_mgmt_cmd *mcmd)
}
scst_cmd_get(cmd);
spin_unlock_irq(&sess->sess_list_lock);
TRACE(TRACE_MGMT, "Cmd %p for tag %lld (sn %ld) found, "
TRACE(TRACE_MGMT, "Cmd %p for tag %llu (sn %ld) found, "
"aborting it", cmd, mcmd->tag, cmd->sn);
mcmd->cmd_to_abort = cmd;
scst_abort_cmd(cmd, mcmd, 0, 1);
@@ -4084,7 +4089,7 @@ int scst_rx_mgmt_fn_tag(struct scst_session *sess, int fn, uint64_t tag,
mcmd->tag = tag;
TRACE(TRACE_MGMT, "sess=%p, tag=%lld", sess, mcmd->tag);
TRACE(TRACE_MGMT, "sess=%p, tag=%llu", sess, mcmd->tag);
if (scst_post_rx_mgmt_cmd(sess, mcmd) != 0)
goto out_free;
@@ -4462,7 +4467,7 @@ struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess, uint64_t tag)
/* ToDo: hash list */
TRACE_DBG("%s (sess=%p, tag=%lld)", "Searching in search cmd list",
TRACE_DBG("%s (sess=%p, tag=%llu)", "Searching in search cmd list",
sess, tag);
list_for_each_entry(cmd, &sess->search_cmd_list,
search_cmd_list_entry) {