Menu
▾
▴
[Scst-svn] SF.net SVN: scst: [154] trunk/scst
|
From: <vl...@us...> - 2007-07-31 14:22:50
|
Revision: 154
http://scst.svn.sourceforge.net/scst/?rev=154&view=rev
Author: vlnb
Date: 2007-07-31 07:21:46 -0700 (Tue, 31 Jul 2007)
Log Message:
-----------
- Device blocking cleanups and fixes
- tags logging made unsigned
Modified Paths:
--------------
trunk/scst/include/scsi_tgt.h
trunk/scst/src/dev_handlers/scst_vdisk.c
trunk/scst/src/scst_lib.c
trunk/scst/src/scst_priv.h
trunk/scst/src/scst_targ.c
Modified: trunk/scst/include/scsi_tgt.h
===================================================================
--- trunk/scst/include/scsi_tgt.h 2007-07-30 11:21:04 UTC (rev 153)
+++ trunk/scst/include/scsi_tgt.h 2007-07-31 14:21:46 UTC (rev 154)
@@ -951,9 +951,15 @@
/* 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.
* In this case alloc_data_buf() must be provided in the target driver
Modified: trunk/scst/src/dev_handlers/scst_vdisk.c
===================================================================
--- trunk/scst/src/dev_handlers/scst_vdisk.c 2007-07-30 11:21:04 UTC (rev 153)
+++ trunk/scst/src/dev_handlers/scst_vdisk.c 2007-07-31 14:21:46 UTC (rev 154)
@@ -657,7 +657,7 @@
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;
}
Modified: trunk/scst/src/scst_lib.c
===================================================================
--- trunk/scst/src/scst_lib.c 2007-07-30 11:21:04 UTC (rev 153)
+++ trunk/scst/src/scst_lib.c 2007-07-31 14:21:46 UTC (rev 154)
@@ -126,7 +126,7 @@
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 @@
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 @@
#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 @@
* !! 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,7 +2631,59 @@
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)
{
int res = 0;
@@ -2636,24 +2691,26 @@
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 @@
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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);
Modified: trunk/scst/src/scst_priv.h
===================================================================
--- trunk/scst/src/scst_priv.h 2007-07-30 11:21:04 UTC (rev 153)
+++ trunk/scst/src/scst_priv.h 2007-07-31 14:21:46 UTC (rev 154)
@@ -414,61 +414,43 @@
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);
-}
+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_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);
-}
-
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);
Modified: trunk/scst/src/scst_targ.c
===================================================================
--- trunk/scst/src/scst_targ.c 2007-07-30 11:21:04 UTC (rev 153)
+++ trunk/scst/src/scst_targ.c 2007-07-31 14:21:46 UTC (rev 154)
@@ -165,7 +165,7 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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,9 +1441,9 @@
}
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);
if (test_bit(SCST_TGT_DEV_RESERVED, &cmd->tgt_dev->tgt_dev_flags)) {
@@ -1478,9 +1480,7 @@
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 @@
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 @@
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 @@
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 @@
&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 @@
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 @@
}
cmd->dev->dev_reserved = 0;
}
- scst_unblock_dev(cmd->dev);
}
if (unlikely((cmd->cdb[0] == MODE_SELECT) ||
@@ -2248,7 +2246,6 @@
sizeof(scst_temp_UA), 1);
spin_unlock_bh(&scst_temp_UA_lock);
}
- scst_unblock_dev(cmd->dev);
}
out:
@@ -2258,7 +2255,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
* 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 @@
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 @@
}
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 @@
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 @@
/* 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) {
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
