root = scst_proc_get_tgt_root(templ);
if (root) {
p = scst_create_proc_entry(root, ISCSI_PROC_VERSION_NAME,
- &iscsi_version_proc_data);
+ &iscsi_version_proc_data);
if (p == NULL) {
PRINT_ERROR("Not enough memory to register "
"target driver %s entry %s in /proc",
/* create the proc file entry for the device */
iscsi_log_proc_data.data = (void *)templ->name;
p = scst_create_proc_entry(root, ISCSI_PROC_LOG_ENTRY_NAME,
- &iscsi_log_proc_data);
+ &iscsi_log_proc_data);
if (p == NULL) {
PRINT_ERROR("Not enough memory to register "
"target driver %s entry %s in /proc",
goto out;
for (i = 0; i < ARRAY_SIZE(iscsi_proc_entries); i++) {
- ent = create_proc_entry(iscsi_proc_entries[i].name, 0, proc_iscsi_dir);
+ ent = create_proc_entry(iscsi_proc_entries[i].name, 0,
+ proc_iscsi_dir);
if (ent)
ent->proc_fops = iscsi_proc_entries[i].fops;
else {
}
/* target_mutex supposed to be locked */
-static int iscsi_param_config(struct iscsi_target *target, void __user *ptr, int set)
+static int iscsi_param_config(struct iscsi_target *target, void __user *ptr,
+ int set)
{
int err;
struct iscsi_param_info info;
{
if (trace_flag & TRACE_D_IOV) {
int i;
- printk("%p, %zd\n", msg->msg_iov, msg->msg_iovlen);
+ printk(LOG_FLAG "%p, %zd\n", msg->msg_iov, msg->msg_iovlen);
for (i = 0; i < min_t(size_t, msg->msg_iovlen,
ISCSI_CONN_IOV_MAX); i++) {
- printk("%d: %p,%zd\n", i, msg->msg_iov[i].iov_base,
+ printk(LOG_FLAG "%d: %p,%zd\n",
+ i, msg->msg_iov[i].iov_base,
msg->msg_iov[i].iov_len);
}
}
if (ch < 0) {
while ((i % 16) != 0) {
- printk(" ");
+ printk(LOG_FLAG " ");
text[i] = ' ';
i++;
if ((i % 16) == 0)
- printk(" | %.16s |\n", text);
+ printk(LOG_FLAG " | %.16s |\n", text);
else if ((i % 4) == 0)
- printk(" |");
+ printk(LOG_FLAG " |");
}
i = 0;
return;
}
text[i] = (ch < 0x20 || (ch >= 0x80 && ch <= 0xa0)) ? ' ' : ch;
- printk(" %02x", ch);
+ printk(LOG_FLAG " %02x", ch);
i++;
if ((i % 16) == 0) {
- printk(" | %.16s |\n", text);
+ printk(LOG_FLAG " | %.16s |\n", text);
i = 0;
} else if ((i % 4) == 0)
- printk(" |");
+ printk(LOG_FLAG " |");
}
void iscsi_dump_pdu(struct iscsi_pdu *pdu)
int i;
buf = (void *)&pdu->bhs;
- printk("BHS: (%p,%zd)\n", buf, sizeof(pdu->bhs));
+ printk(LOG_FLAG "BHS: (%p,%zd)\n", buf, sizeof(pdu->bhs));
for (i = 0; i < sizeof(pdu->bhs); i++)
iscsi_dump_char(*buf++);
iscsi_dump_char(-1);
buf = (void *)pdu->ahs;
- printk("AHS: (%p,%d)\n", buf, pdu->ahssize);
+ printk(LOG_FLAG "AHS: (%p,%d)\n", buf, pdu->ahssize);
for (i = 0; i < pdu->ahssize; i++)
iscsi_dump_char(*buf++);
iscsi_dump_char(-1);
- printk("Data: (%d)\n", pdu->datasize);
+ printk(LOG_FLAG "Data: (%d)\n", pdu->datasize);
}
}
#endif /* CONFIG_SCST_DEBUG */
if (unlikely(time_after_eq(jiffies, wr_cmd->write_timeout))) {
if (!conn->closing) {
- PRINT_ERROR("Timeout sending data to initiator "
- "%s (SID %llx), closing connection",
+ PRINT_ERROR("Timeout sending data to initiator"
+ " %s (SID %llx), closing connection",
conn->session->initiator_name,
- (long long unsigned int)conn->session->sid);
+ (long long unsigned int)
+ conn->session->sid);
mark_conn_closed(conn);
}
} else {
}
/* target_mutex supposed to be locked */
-static int iscsi_conn_alloc(struct iscsi_session *session, struct conn_info *info)
+static int iscsi_conn_alloc(struct iscsi_session *session,
+ struct conn_info *info)
{
struct iscsi_conn *conn;
int res = 0;
void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn)
{
if (unlikely(current != conn->rd_task)) {
- printk(KERN_EMERG "conn %p rd_task != current %p (pid %d)\n", conn,
- current, current->pid);
+ printk(KERN_EMERG "conn %p rd_task != current %p (pid %d)\n",
+ conn, current, current->pid);
while (in_softirq())
local_bh_enable();
printk(KERN_EMERG "rd_state %x\n", conn->rd_state);
void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn)
{
if (unlikely(current != conn->wr_task)) {
- printk(KERN_EMERG "conn %p wr_task != current %p (pid %d)\n", conn,
- current, current->pid);
+ printk(KERN_EMERG "conn %p wr_task != current %p (pid %d)\n",
+ conn, current, current->pid);
while (in_softirq())
local_bh_enable();
printk(KERN_EMERG "wr_state %x\n", conn->wr_state);
/*
* iSCSI digest handling.
*
- * Copyright (C) 2004 - 2006 Xiranet Communications GmbH <arne.redlich@xiranet.com>
+ * Copyright (C) 2004 - 2006 Xiranet Communications GmbH
+ * <arne.redlich@xiranet.com>
* Copyright (C) 2007 - 2008 Vladislav Bolkhovitin
* Copyright (C) 2007 - 2008 CMS Distribution Limited
*
if (pad_bytes) {
u32 padding = 0;
/*
- * Digest includes also padding for aligned pdu length, hopefully
- * it is always filled with 0s in pdu (according to crypto/crc32c.c
+ * Digest includes also padding for aligned pdu length,
+ * hopefully it is always filled with 0s in pdu (according to
+ * crypto/crc32c.c
*/
crc = crc32c(crc, (u8 *)&padding, pad_bytes);
}
if (!skb)
return -ENOMEM;
- nlh = __nlmsg_put(skb, iscsid_pid, seq++, NLMSG_DONE, len - sizeof(*nlh), 0);
+ nlh = __nlmsg_put(skb, iscsid_pid, seq++, NLMSG_DONE,
+ len - sizeof(*nlh), 0);
memcpy(NLMSG_DATA(nlh), data, len);
req_cmnd_release_force(cmnd, ISCSI_FORCE_RELEASE_WRITE);
}
-struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *conn, struct iscsi_cmnd *parent)
+struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *conn,
+ struct iscsi_cmnd *parent)
{
struct iscsi_cmnd *cmnd;
if (unlikely(cmnd->tm_aborted)) {
TRACE_MGMT_DBG("Free aborted cmd %p (scst cmd %p, state %d, "
- "parent_req %p)", cmnd, cmnd->scst_cmd, cmnd->scst_state,
- cmnd->parent_req);
+ "parent_req %p)", cmnd, cmnd->scst_cmd,
+ cmnd->scst_state, cmnd->parent_req);
}
/* Catch users from cmd_list or rsp_cmd_list */
if (unlikely(cmnd->on_write_list || cmnd->on_written_list)) {
struct iscsi_scsi_cmd_hdr *req = cmnd_hdr(cmnd);
- PRINT_CRIT_ERROR("cmnd %p still on some list?, %x, %x, %x, %x, %x, %x, %x",
- cmnd, req->opcode, req->scb[0], req->flags, req->itt,
- be32_to_cpu(req->data_length),
+ PRINT_CRIT_ERROR("cmnd %p still on some list?, %x, %x, %x, "
+ "%x, %x, %x, %x", cmnd, req->opcode, req->scb[0],
+ req->flags, req->itt, be32_to_cpu(req->data_length),
req->cmd_sn, be32_to_cpu(cmnd->pdu.datasize));
if (unlikely(cmnd->parent_req)) {
struct iscsi_scsi_cmd_hdr *preq =
cmnd_hdr(cmnd->parent_req);
- PRINT_CRIT_ERROR("%p %x %u", preq, preq->opcode, preq->scb[0]);
+ PRINT_CRIT_ERROR("%p %x %u", preq, preq->opcode,
+ preq->scb[0]);
}
sBUG();
}
if (unlikely(cmnd->tm_aborted)) {
TRACE_MGMT_DBG("Done aborted cmd %p (scst cmd %p, state %d, "
- "parent_req %p)", cmnd, cmnd->scst_cmd, cmnd->scst_state,
- cmnd->parent_req);
+ "parent_req %p)", cmnd, cmnd->scst_cmd,
+ cmnd->scst_state, cmnd->parent_req);
}
EXTRACHECKS_BUG_ON(cmnd->on_rx_digest_list);
break;
}
default:
- PRINT_CRIT_ERROR("Unexpected cmnd scst state %d",
- cmnd->scst_state);
+ PRINT_CRIT_ERROR("Unexpected cmnd scst state "
+ "%d", cmnd->scst_state);
sBUG();
break;
}
}
spin_unlock_bh(&conn->write_list_lock);
- list_for_each_entry_safe(rsp, t, &cmds_list, write_list_entry) {
+ list_for_each_entry_safe(rsp, t, &cmds_list,
+ write_list_entry) {
TRACE_MGMT_DBG("Putting write rsp %p", rsp);
list_del(&rsp->write_list_entry);
cmnd_put(rsp);
again_rsp:
spin_lock_bh(&req->rsp_cmd_lock);
- list_for_each_entry_reverse(rsp, &req->rsp_cmd_list, rsp_cmd_list_entry) {
+ list_for_each_entry_reverse(rsp, &req->rsp_cmd_list,
+ rsp_cmd_list_entry) {
bool r;
if (rsp->force_cleanup_done)
* initiator sends cmd with the same ITT => this command will be
* erroneously rejected as a duplicate.
*/
- if ((flags & ISCSI_INIT_WRITE_REMOVE_HASH) && rsp->parent_req->hashed &&
+ if ((flags & ISCSI_INIT_WRITE_REMOVE_HASH) &&
+ rsp->parent_req->hashed &&
(rsp->parent_req->r2t_length == 0) &&
(rsp->parent_req->outstanding_r2t == 0))
cmnd_remove_hash(rsp->parent_req);
if (flags & ISCSI_INIT_WRITE_WAKE)
iscsi_make_conn_wr_active(conn);
+
+ return;
}
static void iscsi_cmnd_init_write(struct iscsi_cmnd *rsp, int flags)
LIST_HEAD(head);
if (unlikely(rsp->on_write_list)) {
- PRINT_CRIT_ERROR("cmd already on write list (%x %x %x %x %u %u "
- "%u %u %u %u %u %d %d",
+ PRINT_CRIT_ERROR("cmd already on write list (%x %x %x %x %u "
+ "%u %u %u %u %u %u %d %d",
cmnd_itt(rsp), cmnd_ttt(rsp), cmnd_opcode(rsp),
cmnd_scsicode(rsp), rsp->r2t_sn,
rsp->r2t_length, rsp->is_unsolicited_data,
}
list_add(&rsp->write_list_entry, &head);
iscsi_cmnds_init_write(&head, flags);
+ return;
}
static void iscsi_set_datasize(struct iscsi_cmnd *cmnd, u32 offset, u32 size)
while (i--)
*p++ = 0;
}
+ return;
}
static void send_data_rsp(struct iscsi_cmnd *req, u8 status, int send_status)
list_add_tail(&rsp->write_list_entry, &send);
}
iscsi_cmnds_init_write(&send, ISCSI_INIT_WRITE_REMOVE_HASH);
+ return;
}
static struct iscsi_cmnd *create_status_rsp(struct iscsi_cmnd *req, int status,
return -ISCSI_REASON_PROTOCOL_ERROR;
}
-static inline struct iscsi_cmnd *__cmnd_find_hash(struct iscsi_session *session,
- u32 itt, u32 ttt)
+static inline struct iscsi_cmnd *__cmnd_find_hash(
+ struct iscsi_session *session, u32 itt, u32 ttt)
{
struct list_head *head;
struct iscsi_cmnd *cmnd;
list_for_each_entry(cmnd, head, hash_list_entry) {
if (cmnd->pdu.bhs.itt == itt) {
- if ((ttt != ISCSI_RESERVED_TAG) && (ttt != cmnd->target_task_tag))
+ if (ttt != ISCSI_RESERVED_TAG &&
+ ttt != cmnd->target_task_tag)
continue;
return cmnd;
}
{
struct iscsi_conn *conn = cmnd->conn;
struct scatterlist *sg = cmnd->sg;
- char *addr;
+ char __user *addr;
u32 size;
int i;
if (unlikely(++i >= ISCSI_CONN_IOV_MAX)) {
PRINT_ERROR("Initiator %s violated negotiated "
"parameters by sending too much data (size "
- "left %d)", conn->session->initiator_name, size);
+ "left %d)", conn->session->initiator_name,
+ size);
mark_conn_closed(conn);
res = -EINVAL;
break;
} else {
err = cmnd_insert_hash(cmnd);
if (unlikely(err < 0)) {
- PRINT_ERROR("Can't insert in hash: ignore this request %x",
- cmnd_itt(cmnd));
+ PRINT_ERROR("Can't insert in hash: ignore this "
+ "request %x", cmnd_itt(cmnd));
goto out;
}
}
cmnd->sg = sg = scst_alloc(size, GFP_KERNEL,
&cmnd->sg_cnt);
if (sg == NULL) {
- TRACE(TRACE_OUT_OF_MEM, "Allocating buffer for "
- "%d NOP-Out payload failed", size);
+ TRACE(TRACE_OUT_OF_MEM, "Allocating buffer for"
+ " %d NOP-Out payload failed", size);
err = -ISCSI_REASON_OUT_OF_RESOURCES;
goto out;
}
dir = SCST_DATA_WRITE;
else
dir = SCST_DATA_NONE;
- scst_cmd_set_expected(scst_cmd, dir, be32_to_cpu(req_hdr->data_length));
+ scst_cmd_set_expected(scst_cmd, dir,
+ be32_to_cpu(req_hdr->data_length));
switch (req_hdr->flags & ISCSI_CMD_ATTR_MASK) {
case ISCSI_CMD_SIMPLE:
req->scst_state = ISCSI_CMD_STATE_RX_CMD;
scst_cmd_init_stage1_done(scst_cmd, SCST_CONTEXT_DIRECT, 0);
- wait_event(req->scst_waitQ, (req->scst_state != ISCSI_CMD_STATE_RX_CMD));
+ wait_event(req->scst_waitQ, req->scst_state != ISCSI_CMD_STATE_RX_CMD);
if (unlikely(req->scst_state != ISCSI_CMD_STATE_AFTER_PREPROC)) {
TRACE_DBG("req %p is in %x state", req, req->scst_state);
if (dir == SCST_DATA_WRITE) {
req->is_unsolicited_data = !(req_hdr->flags & ISCSI_CMD_FINAL);
- req->r2t_length = be32_to_cpu(req_hdr->data_length) - req->pdu.datasize;
+ req->r2t_length = be32_to_cpu(req_hdr->data_length) -
+ req->pdu.datasize;
if (req->r2t_length > 0)
req->data_waiting = 1;
}
req->pdu.datasize)) {
PRINT_ERROR("Initiator %s violated negotiated paremeters: "
"forbidden immediate data sent (ITT %x, op %x)",
- session->initiator_name, cmnd_itt(req), req_hdr->scb[0]);
+ session->initiator_name, cmnd_itt(req),
+ req_hdr->scb[0]);
res = -EINVAL;
goto out;
}
!(req_hdr->flags & ISCSI_CMD_FINAL))) {
PRINT_ERROR("Initiator %s violated negotiated paremeters: "
"initial R2T is required (ITT %x, op %x)",
- session->initiator_name, cmnd_itt(req), req_hdr->scb[0]);
+ session->initiator_name, cmnd_itt(req),
+ req_hdr->scb[0]);
res = -EINVAL;
goto out;
}
if (req->pdu.datasize) {
if (unlikely(dir != SCST_DATA_WRITE)) {
- PRINT_ERROR("pdu.datasize(%d) >0, but dir(%x) isn't WRITE",
- req->pdu.datasize, dir);
+ PRINT_ERROR("pdu.datasize(%d) >0, but dir(%x) isn't "
+ "WRITE", req->pdu.datasize, dir);
create_sense_rsp(req, ABORTED_COMMAND, 0xc, 0xc);
cmnd_reject_scsi_cmd(req);
} else
- res = cmnd_prepare_recv_pdu(conn, req, 0, req->pdu.datasize);
+ res = cmnd_prepare_recv_pdu(conn, req, 0,
+ req->pdu.datasize);
}
out:
/* Aborted commands will be freed in cmnd_rx_end() */
static int data_out_start(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
{
- struct iscsi_data_out_hdr *req_hdr = (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs;
+ struct iscsi_data_out_hdr *req_hdr =
+ (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs;
struct iscsi_cmnd *orig_req = NULL;
u32 offset = be32_to_cpu(req_hdr->buffer_offset);
int res = 0;
static void data_out_end(struct iscsi_cmnd *cmnd)
{
- struct iscsi_data_out_hdr *req_hdr = (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs;
+ struct iscsi_data_out_hdr *req_hdr =
+ (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs;
struct iscsi_cmnd *req;
sBUG_ON(cmnd == NULL);
if (unlikely(req->is_unsolicited_data)) {
PRINT_ERROR("Unexpected unsolicited data "
"(r2t_length %u, outstanding_r2t %d)",
- req->r2t_length, req->is_unsolicited_data);
+ req->r2t_length,
+ req->is_unsolicited_data);
mark_conn_closed(req->conn);
goto out_put;
}
if (cmnd->pdu.bhs.opcode & ISCSI_OP_IMMEDIATE) {
if (req_hdr->ref_cmd_sn != req_hdr->cmd_sn) {
- PRINT_ERROR("ABORT TASK: RefCmdSN(%u) != TM cmd "
- "CmdSN(%u) for immediate command %p",
- req_hdr->ref_cmd_sn, req_hdr->cmd_sn,
- cmnd);
+ PRINT_ERROR("ABORT TASK: RefCmdSN(%u) != TM "
+ "cmd CmdSN(%u) for immediate command "
+ "%p", req_hdr->ref_cmd_sn,
+ req_hdr->cmd_sn, cmnd);
err = ISCSI_RESPONSE_FUNCTION_REJECTED;
goto out_put;
}
mutex_lock(&target->target_mutex);
- list_for_each_entry(session, &target->session_list, session_list_entry) {
- list_for_each_entry(conn, &session->conn_list, conn_list_entry) {
+ list_for_each_entry(session, &target->session_list,
+ session_list_entry) {
+ list_for_each_entry(conn, &session->conn_list,
+ conn_list_entry) {
spin_lock_bh(&conn->cmd_list_lock);
- list_for_each_entry(cmnd, &conn->cmd_list, cmd_list_entry) {
+ list_for_each_entry(cmnd, &conn->cmd_list,
+ cmd_list_entry) {
if (cmnd == req)
continue;
if (all)
spin_unlock_bh(&conn->cmd_list_lock);
/* ToDo: this is racy for MC/S */
- TRACE_MGMT_DBG("Restarting data waiting cmd %p",
- cmnd);
+ TRACE_MGMT_DBG("Restarting data waiting cmd "
+ "%p", cmnd);
iscsi_fail_waiting_cmnd(cmnd);
cmnd_put(cmnd);
int rc, status, function = req_hdr->function & ISCSI_FUNCTION_MASK;
struct scst_rx_mgmt_params params;
- TRACE((function == ISCSI_FUNCTION_ABORT_TASK) ? TRACE_MGMT_MINOR : TRACE_MGMT,
+ TRACE((function == ISCSI_FUNCTION_ABORT_TASK) ?
+ TRACE_MGMT_MINOR : TRACE_MGMT,
"TM fn %d", function);
TRACE_MGMT_DBG("TM req %p, itt %x, rtt %x, sn %u, con %p", req,
cmnd->reject_reason);
switch (cmnd->reject_reason) {
default:
- PRINT_ERROR("Unexpected reject reason %d", cmnd->reject_reason);
+ PRINT_ERROR("Unexpected reject reason %d",
+ cmnd->reject_reason);
/* go through */
case ISCSI_REJECT_SCSI_CMD:
req_cmnd_release(cmnd);
oldfs = get_fs();
set_fs(get_ds());
- sock->ops->setsockopt(sock, SOL_TCP, TCP_CORK, (void *)&opt, sizeof(opt));
+ sock->ops->setsockopt(sock, SOL_TCP, TCP_CORK,
+ (void *)&opt, sizeof(opt));
set_fs(oldfs);
}
break;
case ISCSI_OP_SCSI_DATA_IN:
{
- struct iscsi_data_in_hdr *rsp = (struct iscsi_data_in_hdr *)&cmnd->pdu.bhs;
+ struct iscsi_data_in_hdr *rsp =
+ (struct iscsi_data_in_hdr *)&cmnd->pdu.bhs;
u32 offset = cpu_to_be32(rsp->buffer_offset);
cmnd_set_sn(cmnd, (rsp->flags & ISCSI_FLG_FINAL) ? 1 : 0);
u32 cmd_sn;
TRACE_DBG("%p:%x %u,%u",
- cmnd, cmnd_opcode(cmnd), cmnd->pdu.bhs.sn, session->exp_cmd_sn);
+ cmnd, cmnd_opcode(cmnd), cmnd->pdu.bhs.sn,
+ session->exp_cmd_sn);
iscsi_extracheck_is_rd_thread(cmnd->conn);
if (list_empty(&session->pending_list))
break;
- cmnd = list_entry(session->pending_list.next, struct iscsi_cmnd,
- pending_list_entry);
+ cmnd = list_entry(session->pending_list.next,
+ struct iscsi_cmnd,
+ pending_list_entry);
if (cmnd->pdu.bhs.sn != cmd_sn)
break;
spin_unlock(&session->sn_lock);
if (unlikely(drop)) {
- req_cmnd_release_force(cmnd, ISCSI_FORCE_RELEASE_WRITE);
+ req_cmnd_release_force(cmnd,
+ ISCSI_FORCE_RELEASE_WRITE);
goto out;
}
tm_clone->tm_aborted = 1;
tm_clone->pdu = cmnd->pdu;
- TRACE_MGMT_DBG("TM clone %p created", tm_clone);
+ TRACE_MGMT_DBG("TM clone %p created",
+ tm_clone);
iscsi_cmnd_exec(cmnd);
cmnd = tm_clone;
}
list_for_each(entry, &session->pending_list) {
- struct iscsi_cmnd *tmp = list_entry(entry, struct iscsi_cmnd,
- pending_list_entry);
+ struct iscsi_cmnd *tmp =
+ list_entry(entry, struct iscsi_cmnd,
+ pending_list_entry);
if (before(cmd_sn, tmp->pdu.bhs.sn))
break;
}
out_rejected:
switch (cmnd->reject_reason) {
default:
- PRINT_ERROR("Unexpected reject reason %d", cmnd->reject_reason);
+ PRINT_ERROR("Unexpected reject reason %d",
+ cmnd->reject_reason);
/* go through */
case ISCSI_REJECT_CMD:
case ISCSI_REJECT_DATA:
req->scst_state = ISCSI_CMD_STATE_PROCESSED;
req_cmnd_release_force(req, ISCSI_FORCE_RELEASE_WRITE);
} else
- iscsi_set_state_wake_up(req, ISCSI_CMD_STATE_PROCESSED);
+ iscsi_set_state_wake_up(req,
+ ISCSI_CMD_STATE_PROCESSED);
goto out;
}
req->sg_cnt);
if (unlikely((req->bufflen != 0) && !is_send_status)) {
- PRINT_CRIT_ERROR("%s", "Sending DATA without STATUS is unsupported");
+ PRINT_CRIT_ERROR("%s", "Sending DATA without STATUS is "
+ "unsupported");
scst_set_cmd_error(scst_cmd,
SCST_LOAD_SENSE(scst_sense_hardw_error));
sBUG();
if (is_send_status) {
rsp = create_status_rsp(req, status, sense,
sense_len);
- rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs;
+ rsp_hdr =
+ (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs;
resid = cmnd_read_size(req) - req->bufflen;
if (resid > 0) {
rsp_hdr->flags |=
ISCSI_FLG_RESIDUAL_UNDERFLOW;
- rsp_hdr->residual_count = cpu_to_be32(resid);
+ rsp_hdr->residual_count =
+ cpu_to_be32(resid);
} else if (resid < 0) {
rsp_hdr->flags |=
ISCSI_FLG_RESIDUAL_OVERFLOW;
- rsp_hdr->residual_count = cpu_to_be32(-resid);
+ rsp_hdr->residual_count =
+ cpu_to_be32(-resid);
}
iscsi_cmnd_init_write(rsp,
ISCSI_INIT_WRITE_REMOVE_HASH);
{
struct iscsi_cmnd *req = (struct iscsi_cmnd *)
scst_mgmt_cmd_get_tgt_priv(scst_mcmd);
- int status = iscsi_get_mgmt_response(scst_mgmt_cmd_get_status(scst_mcmd));
+ int status =
+ iscsi_get_mgmt_response(scst_mgmt_cmd_get_status(scst_mcmd));
TRACE_MGMT_DBG("req %p, scst_mcmd %p, fn %d, scst status %d",
req, scst_mcmd, scst_mgmt_cmd_get_fn(scst_mcmd),
ctr_major = register_chrdev(0, ctr_name, &ctr_fops);
if (ctr_major < 0) {
- PRINT_ERROR("failed to register the control device %d", ctr_major);
+ PRINT_ERROR("failed to register the control device %d",
+ ctr_major);
err = ctr_major;
goto out_callb;
}
struct task_struct *wr_task;
#endif
- /* All are unprotected, since accessed only from a single write thread */
+ /*
+ * All are unprotected, since accessed only from a single write
+ * thread.
+ */
struct iscsi_cmnd *write_cmnd;
struct iovec *write_iop;
int write_iop_used;
struct task_struct *rd_task;
#endif
- /* All are unprotected, since accessed only from a single read thread */
+ /*
+ * All are unprotected, since accessed only from a single read
+ * thread.
+ */
struct iscsi_cmnd *read_cmnd;
struct msghdr read_msg;
u32 read_size;
struct iscsi_target *target;
- struct list_head conn_list_entry; /* list entry in session conn_list */
+ struct list_head conn_list_entry; /* list entry in session conn_list */
/* Doesn't need any protection */
u16 cid;
unsigned int datasize;
};
-typedef void (iscsi_show_info_t)(struct seq_file *seq, struct iscsi_target *target);
+typedef void (iscsi_show_info_t)(struct seq_file *seq,
+ struct iscsi_target *target);
/* Command's states */
-#define ISCSI_CMD_STATE_NEW 0 /* New command and SCST processes it */
-#define ISCSI_CMD_STATE_RX_CMD 1 /* SCST processes cmd after scst_rx_cmd() */
-#define ISCSI_CMD_STATE_AFTER_PREPROC 2 /* The command returned from preprocessing_done() */
-#define ISCSI_CMD_STATE_RESTARTED 3 /* scst_restart_cmd() called and SCST processing it */
-#define ISCSI_CMD_STATE_PROCESSED 4 /* SCST done processing */
+
+/* New command and SCST processes it */
+#define ISCSI_CMD_STATE_NEW 0
+/* SCST processes cmd after scst_rx_cmd() */
+#define ISCSI_CMD_STATE_RX_CMD 1
+/* The command returned from preprocessing_done() */
+#define ISCSI_CMD_STATE_AFTER_PREPROC 2
+/* scst_restart_cmd() called and SCST processing it */
+#define ISCSI_CMD_STATE_RESTARTED 3
+/* SCST done processing */
+#define ISCSI_CMD_STATE_PROCESSED 4
/* Command's reject reasons */
#define ISCSI_REJECT_SCSI_CMD 1
unsigned int release_called:1;
#endif
- volatile unsigned int tm_aborted; /* it's async. with the above flags */
+ /* It's async. with the above flags */
+ volatile unsigned int tm_aborted;
struct list_head hash_list_entry;
extern int session_free(struct iscsi_session *session);
/* params.c */
-extern int iscsi_param_set(struct iscsi_target *, struct iscsi_param_info *, int);
+extern int iscsi_param_set(struct iscsi_target *, struct iscsi_param_info *,
+ int);
/* event.c */
extern int event_send(u32, u64, u32, u32, int);
extern int event_init(void);
extern void event_exit(void);
-#define get_pgcnt(size, offset) ((((size) + ((offset) & ~PAGE_MASK)) + PAGE_SIZE - 1) >> PAGE_SHIFT)
+#define get_pgcnt(size, offset) \
+ ((((size) + ((offset) & ~PAGE_MASK)) + PAGE_SIZE - 1) >> PAGE_SHIFT)
static inline void iscsi_cmnd_get_length(struct iscsi_pdu *pdu)
{
#define TRACE_D_DATA (TRACE_D_READ | TRACE_D_WRITE)
-#define TRACE_ALL_NO_DATA (TRACE_ALL & ~TRACE_D_IOV & ~TRACE_D_DUMP_PDU & ~TRACE_D_DATA)
+#define TRACE_ALL_NO_DATA \
+ (TRACE_ALL & ~TRACE_D_IOV & ~TRACE_D_DUMP_PDU & ~TRACE_D_DATA)
#ifdef CONFIG_SCST_DEBUG
#define ISCSI_DEFAULT_LOG_FLAGS (TRACE_FUNCTION | TRACE_LINE | TRACE_PID | \
}
spin_lock_bh(&cmnd->rsp_cmd_lock);
- list_for_each_entry(rsp, &cmnd->rsp_cmd_list, rsp_cmd_list_entry) {
- TRACE_CONN_CLOSE_DBG(" rsp %p, ref_cnt %d, net_ref_cnt %d, "
- "sg %p", rsp, atomic_read(&rsp->ref_cnt),
+ list_for_each_entry(rsp, &cmnd->rsp_cmd_list,
+ rsp_cmd_list_entry) {
+ TRACE_CONN_CLOSE_DBG(" rsp %p, ref_cnt %d, "
+ "net_ref_cnt %d, sg %p",
+ rsp, atomic_read(&rsp->ref_cnt),
atomic_read(&rsp->net_ref_cnt), rsp->sg);
if ((rsp->sg != cmnd->sg) && (rsp->sg != NULL)) {
continue;
for (i = 0; i < rsp->sg_cnt; i++) {
- struct page *page = sg_page(&rsp->sg[i]);
- TRACE_CONN_CLOSE_DBG(" page %p, net_priv %p, "
- "_count %d", page, page->net_priv,
+ struct page *page =
+ sg_page(&rsp->sg[i]);
+ TRACE_CONN_CLOSE_DBG(
+ " page %p, net_priv %p, "
+ "_count %d",
+ page, page->net_priv,
atomic_read(&page->_count));
if (page->net_priv != NULL) {
return;
}
+static void free_pending_commands(struct iscsi_conn *conn)
+{
+ struct iscsi_session *session = conn->session;
+ struct list_head *pending_list = &session->pending_list;
+ int req_freed;
+ struct iscsi_cmnd *cmnd;
+
+ spin_lock(&session->sn_lock);
+ do {
+ req_freed = 0;
+ list_for_each_entry(cmnd, pending_list, pending_list_entry) {
+ TRACE_CONN_CLOSE_DBG("Pending cmd %p"
+ "(conn %p, cmd_sn %u, exp_cmd_sn %u)",
+ cmnd, conn, cmnd->pdu.bhs.sn,
+ session->exp_cmd_sn);
+ if ((cmnd->conn == conn) &&
+ (session->exp_cmd_sn == cmnd->pdu.bhs.sn)) {
+ TRACE_CONN_CLOSE_DBG("Freeing pending cmd %p",
+ cmnd);
+
+ list_del(&cmnd->pending_list_entry);
+ cmnd->pending = 0;
+
+ session->exp_cmd_sn++;
+
+ spin_unlock(&session->sn_lock);
+
+ req_cmnd_release_force(cmnd, 0);
+
+ req_freed = 1;
+ spin_lock(&session->sn_lock);
+ break;
+ }
+ }
+ } while (req_freed);
+ spin_unlock(&session->sn_lock);
+}
+
+static void free_orphaned_pending_commands(struct iscsi_conn *conn)
+{
+ struct iscsi_session *session = conn->session;
+ struct list_head *pending_list = &session->pending_list;
+ int req_freed;
+ struct iscsi_cmnd *cmnd;
+
+ spin_lock(&session->sn_lock);
+ do {
+ req_freed = 0;
+ list_for_each_entry(cmnd, pending_list, pending_list_entry) {
+ TRACE_CONN_CLOSE_DBG("Pending cmd %p"
+ "(conn %p, cmd_sn %u, exp_cmd_sn %u)",
+ cmnd, conn, cmnd->pdu.bhs.sn,
+ session->exp_cmd_sn);
+ if (cmnd->conn == conn) {
+ PRINT_ERROR("Freeing orphaned pending cmd %p",
+ cmnd);
+
+ list_del(&cmnd->pending_list_entry);
+ cmnd->pending = 0;
+
+ if (session->exp_cmd_sn == cmnd->pdu.bhs.sn)
+ session->exp_cmd_sn++;
+
+ spin_unlock(&session->sn_lock);
+
+ req_cmnd_release_force(cmnd, 0);
+
+ req_freed = 1;
+ spin_lock(&session->sn_lock);
+ break;
+ }
+ }
+ } while (req_freed);
+ spin_unlock(&session->sn_lock);
+}
+
+#ifdef CONFIG_SCST_DEBUG
+static void trace_conn_close(struct iscsi_conn *conn)
+{
+ struct iscsi_cmnd *cmnd;
+#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
+ struct iscsi_cmnd *rsp;
+#endif
+
+#if 0
+ if (time_after(jiffies, start_waiting + 10*HZ))
+ trace_flag |= TRACE_CONN_OC_DBG;
+#endif
+
+ spin_lock_bh(&conn->cmd_list_lock);
+ list_for_each_entry(cmnd, &conn->cmd_list,
+ cmd_list_entry) {
+ TRACE_CONN_CLOSE_DBG(
+ "cmd %p, scst_state %x, scst_cmd state %d, "
+ "data_waiting %d, ref_cnt %d, sn %u, "
+ "parent_req %p, pending %d",
+ cmnd, cmnd->scst_state,
+ cmnd->scst_cmd ? cmnd->scst_cmd->state : -1,
+ cmnd->data_waiting, atomic_read(&cmnd->ref_cnt),
+ cmnd->pdu.bhs.sn, cmnd->parent_req, cmnd->pending);
+#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
+ TRACE_CONN_CLOSE_DBG("net_ref_cnt %d, sg %p",
+ atomic_read(&cmnd->net_ref_cnt),
+ cmnd->sg);
+ if (cmnd->sg != NULL) {
+ int i;
+ for (i = 0; i < cmnd->sg_cnt; i++) {
+ struct page *page = sg_page(&cmnd->sg[i]);
+ TRACE_CONN_CLOSE_DBG("page %p, "
+ "net_priv %p, _count %d",
+ page, page->net_priv,
+ atomic_read(&page->_count));
+ }
+ }
+
+ sBUG_ON(cmnd->parent_req != NULL);
+
+ spin_lock_bh(&cmnd->rsp_cmd_lock);
+ list_for_each_entry(rsp, &cmnd->rsp_cmd_list,
+ rsp_cmd_list_entry) {
+ TRACE_CONN_CLOSE_DBG(" rsp %p, "
+ "ref_cnt %d, net_ref_cnt %d, sg %p",
+ rsp, atomic_read(&rsp->ref_cnt),
+ atomic_read(&rsp->net_ref_cnt), rsp->sg);
+ if (rsp->sg != cmnd->sg && rsp->sg) {
+ int i;
+ for (i = 0; i < rsp->sg_cnt; i++) {
+ TRACE_CONN_CLOSE_DBG(" page %p, "
+ "net_priv %p, _count %d",
+ sg_page(&rsp->sg[i]),
+ sg_page(&rsp->sg[i])->net_priv,
+ atomic_read(&sg_page(&rsp->sg[i])->
+ _count));
+ }
+ }
+ }
+ spin_unlock_bh(&cmnd->rsp_cmd_lock);
+#endif /* CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION */
+ }
+ spin_unlock_bh(&conn->cmd_list_lock);
+}
+#else /* CONFIG_SCST_DEBUG */
+static void trace_conn_close(struct iscsi_conn *conn) {}
+#endif /* CONFIG_SCST_DEBUG */
+
/* No locks */
static void close_conn(struct iscsi_conn *conn)
{
/*
* We need to call scst_unregister_session() ASAP to make SCST start
- * stuck commands recovery.
+ * recovering stuck commands.
*
* ToDo: this is incompatible with MC/S
*/
/* ToDo: not the best way to wait */
while (atomic_read(&conn->conn_ref_cnt) != 0) {
- struct iscsi_cmnd *cmnd;
-
mutex_lock(&target->target_mutex);
spin_lock(&session->sn_lock);
- if ((session->tm_rsp != NULL) && (session->tm_rsp->conn == conn)) {
+ if (session->tm_rsp && session->tm_rsp->conn == conn) {
struct iscsi_cmnd *tm_rsp = session->tm_rsp;
TRACE(TRACE_MGMT_MINOR, "Dropping delayed TM rsp %p",
tm_rsp);
}
if (!list_empty(&session->pending_list)) {
- struct list_head *pending_list = &session->pending_list;
- int req_freed;
-
TRACE_CONN_CLOSE_DBG("Disposing pending commands on "
- "connection %p (conn_ref_cnt=%d)", conn,
+ "connection %p (conn_ref_cnt=%d)",
+ conn,
atomic_read(&conn->conn_ref_cnt));
/*
- * Such complicated approach currently isn't necessary,
- * but it will be necessary for MC/S, if we won't want
- * to reestablish the whole session on a connection
- * failure.
+ * Such complicated approach currently isn't really
+ * necessary, but it will be necessary for MC/S, if we
+ * won't want to reestablish the whole session on a
+ * connection failure.
*/
- spin_lock(&session->sn_lock);
- do {
- req_freed = 0;
- list_for_each_entry(cmnd, pending_list,
- pending_list_entry) {
- TRACE_CONN_CLOSE_DBG("Pending cmd %p"
- "(conn %p, cmd_sn %u, exp_cmd_sn %u)",
- cmnd, conn, cmnd->pdu.bhs.sn,
- session->exp_cmd_sn);
- if ((cmnd->conn == conn) &&
- (session->exp_cmd_sn == cmnd->pdu.bhs.sn)) {
- TRACE_CONN_CLOSE_DBG("Freeing pending cmd %p",
- cmnd);
-
- list_del(&cmnd->pending_list_entry);
- cmnd->pending = 0;
-
- session->exp_cmd_sn++;
-
- spin_unlock(&session->sn_lock);
-
- req_cmnd_release_force(cmnd, 0);
+ free_pending_commands(conn);
- req_freed = 1;
- spin_lock(&session->sn_lock);
- break;
- }
- }
- } while (req_freed);
- spin_unlock(&session->sn_lock);
-
- if (time_after(jiffies, start_waiting + CONN_PENDING_TIMEOUT)) {
+ if (time_after(jiffies,
+ start_waiting + CONN_PENDING_TIMEOUT)) {
if (!pending_reported) {
- TRACE_CONN_CLOSE("%s", "Pending wait time expired");
+ TRACE_CONN_CLOSE("%s",
+ "Pending wait time expired");
pending_reported = 1;
}
- spin_lock(&session->sn_lock);
- do {
- req_freed = 0;
- list_for_each_entry(cmnd, pending_list,
- pending_list_entry) {
- TRACE_CONN_CLOSE_DBG("Pending cmd %p"
- "(conn %p, cmd_sn %u, exp_cmd_sn %u)",
- cmnd, conn, cmnd->pdu.bhs.sn,
- session->exp_cmd_sn);
- if (cmnd->conn == conn) {
- PRINT_ERROR("Freeing orphaned "
- "pending cmd %p", cmnd);
-
- list_del(&cmnd->pending_list_entry);
- cmnd->pending = 0;
-
- if (session->exp_cmd_sn == cmnd->pdu.bhs.sn)
- session->exp_cmd_sn++;
-
- spin_unlock(&session->sn_lock);
-
- req_cmnd_release_force(cmnd, 0);
-
- req_freed = 1;
- spin_lock(&session->sn_lock);
- break;
- }
- }
- } while (req_freed);
- spin_unlock(&session->sn_lock);
+ free_orphaned_pending_commands(conn);
}
}
if (time_after(jiffies, start_waiting + CONN_WAIT_TIMEOUT) &&
!wait_expired) {
TRACE_CONN_CLOSE("Wait time expired (conn %p, "
- "sk_state %d)", conn, conn->sock->sk->sk_state);
+ "sk_state %d)",
+ conn, conn->sock->sk->sk_state);
conn->sock->ops->shutdown(conn->sock, SEND_SHUTDOWN);
wait_expired = 1;
shut_start_waiting = jiffies;
else
msleep(1000);
- TRACE_CONN_CLOSE_DBG("conn %p, conn_ref_cnt %d left, wr_state %d, "
- "exp_cmd_sn %u", conn, atomic_read(&conn->conn_ref_cnt),
+ TRACE_CONN_CLOSE_DBG("conn %p, conn_ref_cnt %d left, "
+ "wr_state %d, exp_cmd_sn %u",
+ conn, atomic_read(&conn->conn_ref_cnt),
conn->wr_state, session->exp_cmd_sn);
#ifdef CONFIG_SCST_DEBUG
- {
-#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
- struct iscsi_cmnd *rsp;
-#endif
-
-#if 0
- if (time_after(jiffies, start_waiting + 10*HZ))
- trace_flag |= TRACE_CONN_OC_DBG;
-#endif
-
- spin_lock_bh(&conn->cmd_list_lock);
- list_for_each_entry(cmnd, &conn->cmd_list, cmd_list_entry) {
- TRACE_CONN_CLOSE_DBG("cmd %p, scst_state %x, scst_cmd "
- "state %d, data_waiting %d, ref_cnt %d, sn %u, "
- "parent_req %p, pending %d", cmnd, cmnd->scst_state,
- (cmnd->scst_cmd != NULL) ? cmnd->scst_cmd->state : -1,
- cmnd->data_waiting, atomic_read(&cmnd->ref_cnt),
- cmnd->pdu.bhs.sn, cmnd->parent_req, cmnd->pending);
-#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
- TRACE_CONN_CLOSE_DBG("net_ref_cnt %d, sg %p",
- atomic_read(&cmnd->net_ref_cnt), cmnd->sg);
- if (cmnd->sg != NULL) {
- int i;
- for (i = 0; i < cmnd->sg_cnt; i++) {
- struct page *page = sg_page(&cmnd->sg[i]);
- TRACE_CONN_CLOSE_DBG("page %p, net_priv %p, _count %d",
- page, page->net_priv,
- atomic_read(&page->_count));
- }
- }
-
- sBUG_ON(cmnd->parent_req != NULL);
-
- spin_lock_bh(&cmnd->rsp_cmd_lock);
- list_for_each_entry(rsp, &cmnd->rsp_cmd_list, rsp_cmd_list_entry) {
- TRACE_CONN_CLOSE_DBG(" rsp %p, ref_cnt %d, net_ref_cnt %d, "
- "sg %p", rsp, atomic_read(&rsp->ref_cnt),
- atomic_read(&rsp->net_ref_cnt), rsp->sg);
- if ((rsp->sg != cmnd->sg) && (rsp->sg != NULL)) {
- int i;
- for (i = 0; i < rsp->sg_cnt; i++) {
- TRACE_CONN_CLOSE_DBG(" page %p, net_priv %p, "
- "_count %d", sg_page(&rsp->sg[i]),
- sg_page(&rsp->sg[i])->net_priv,
- atomic_read(&sg_page(&rsp->sg[i])->_count));
- }
- }
- }
- spin_unlock_bh(&cmnd->rsp_cmd_lock);
-#endif
- }
- spin_unlock_bh(&conn->cmd_list_lock);
- }
+ trace_conn_close(conn);
#endif
iscsi_check_closewait(conn);
}
msleep(50);
}
- TRACE_CONN_CLOSE("Notifying user space about closing connection %p", conn);
+ TRACE_CONN_CLOSE("Notifying user space about closing connection %p",
+ conn);
event_send(target->tid, session->sid, conn->cid, E_CONN_CLOSE, 0);
wait_for_completion(&session->unreg_compl);
return;
}
-static inline void iscsi_conn_init_read(struct iscsi_conn *conn, void *data, size_t len)
+static inline void iscsi_conn_init_read(struct iscsi_conn *conn, void *data,
+ size_t len)
{
len = (len + 3) & -4; /* XXX ??? */
conn->read_iov[0].iov_base = data;
conn->read_size = (len + 3) & -4;
}
-static void iscsi_conn_read_ahs(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
+static void iscsi_conn_read_ahs(struct iscsi_conn *conn,
+ struct iscsi_cmnd *cmnd)
{
/* ToDo: __GFP_NOFAIL ?? */
cmnd->pdu.ahs = kmalloc(cmnd->pdu.ahssize, __GFP_NOFAIL|GFP_KERNEL);
oldfs = get_fs();
set_fs(get_ds());
- res = sock_recvmsg(conn->sock, &msg, conn->read_size, MSG_DONTWAIT | MSG_NOSIGNAL);
+ res = sock_recvmsg(conn->sock, &msg, conn->read_size,
+ MSG_DONTWAIT | MSG_NOSIGNAL);
set_fs(oldfs);
if (res <= 0) {
case -EAGAIN:
case -ERESTARTSYS:
TRACE_DBG("EAGAIN or ERESTARTSYS (%d) received for "
- "conn %p", res, conn);
+ "conn %p", res, conn);
break;
default:
PRINT_ERROR("sock_recvmsg() failed: %d", res);
conn->read_size -= res;
if (conn->read_size) {
if (res >= first_len) {
- int done = 1 + ((res - first_len) >> PAGE_SHIFT);
+ int done =
+ 1 + ((res - first_len) >> PAGE_SHIFT);
conn->read_msg.msg_iov += done;
conn->read_msg.msg_iovlen -= done;
}
iscsi_conn_read_ahs(conn, cmnd);
conn->read_state = RX_AHS;
} else
- conn->read_state = hdigest ? RX_INIT_HDIGEST : RX_INIT_DATA;
+ conn->read_state =
+ hdigest ? RX_INIT_HDIGEST : RX_INIT_DATA;
if (conn->read_state != RX_AHS)
break;
cmnd_get(cmnd);
} else if (cmnd_opcode(cmnd) != ISCSI_OP_SCSI_DATA_OUT) {
/*
- * We could get here only for NOP-Out. ISCSI RFC doesn't
- * specify how to deal with digest errors in this case.
- * Is closing connection correct?
+ * We could get here only for NOP-Out. ISCSI RFC
+ * doesn't specify how to deal with digest errors in
+ * this case. Is closing connection correct?
*/
TRACE_DBG("cmnd %p, opcode %x: checking NOP RX "
"ddigest", cmnd, cmnd_opcode(cmnd));
{
TRACE_ENTRY();
- /* We delete/add to tail connections to maintain fairness between them */
+ /*
+ * We delete/add to tail connections to maintain fairness between them.
+ */
while (!list_empty(&iscsi_rd_list)) {
int rc, closed = 0;
mm_segment_t oldfs;
struct file *file;
struct socket *sock;
- ssize_t (*sock_sendpage)(struct socket *, struct page *, int, size_t, int);
+ ssize_t (*sock_sendpage)(struct socket *, struct page *, int, size_t,
+ int);
ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int);
struct iscsi_cmnd *write_cmnd = conn->write_cmnd;
struct iscsi_cmnd *ref_cmd;
if (sg_page(&sg[idx])->net_priv != NULL) {
if (sg_page(&sg[idx])->net_priv != ref_cmd) {
/*
- * This might happen if user space supplies
- * to scst_user the same pages in different
- * commands or in case of zero-copy FILEIO,
- * when several initiators request the same
+ * This might happen if user space
+ * supplies to scst_user the same
+ * pages in different commands or in
+ * case of zero-copy FILEIO, when
+ * several initiators request the same
* data simultaneously.
*/
TRACE_DBG("net_priv isn't NULL and != "
- "ref_cmd (write_cmnd %p, ref_cmd %p, "
- "sg %p, idx %d, page %p, net_priv %p)",
- write_cmnd, ref_cmd, sg, idx,
- sg_page(&sg[idx]),
- sg_page(&sg[idx])->net_priv);
+ "ref_cmd (write_cmnd %p, ref_cmd "
+ "%p, sg %p, idx %d, page %p, "
+ "net_priv %p)",
+ write_cmnd, ref_cmd, sg, idx,
+ sg_page(&sg[idx]),
+ sg_page(&sg[idx])->net_priv);
sendpage = sock_no_sendpage;
}
} else
sendsize = PAGE_SIZE - offset;
if (size <= sendsize) {
retry2:
- res = sendpage(sock, sg_page(&sg[idx]), offset, size, flags);
- TRACE_WRITE("Final %s %#Lx:%u: %d(%lu,%u,%u, cmd %p, page %p)",
- (sendpage != sock_no_sendpage) ? "sendpage" :
- "sock_no_sendpage",
+ res = sendpage(sock, sg_page(&sg[idx]), offset, size,
+ flags);
+ TRACE_WRITE("Final %s %#Lx:%u: %d(%lu,%u,%u, cmd %p, "
+ "page %p)", (sendpage != sock_no_sendpage) ?
+ "sendpage" : "sock_no_sendpage",
(long long unsigned int)conn->session->sid,
- conn->cid,
- res, sg_page(&sg[idx])->index, offset, size,
- write_cmnd, sg_page(&sg[idx]));
+ conn->cid, res, sg_page(&sg[idx])->index,
+ offset, size, write_cmnd, sg_page(&sg[idx]));
if (unlikely(res <= 0)) {
if (res == -EINTR)
goto retry2;
{
PRINT_ERROR("Sending data failed: initiator %s, "
"write_size %d, write_state %d, res %d",
- conn->session->initiator_name, conn->write_size,
+ conn->session->initiator_name,
+ conn->write_size,
conn->write_state, res);
}
conn->write_state = TX_END;
digest_tx_header(cmnd);
- sBUG_ON(conn->write_iop_used >= sizeof(conn->write_iov)/sizeof(conn->write_iov[0]));
+ sBUG_ON(conn->write_iop_used >=
+ sizeof(conn->write_iov)/sizeof(conn->write_iov[0]));
+
iop = &conn->write_iop[conn->write_iop_used];
conn->write_iop_used++;
iop->iov_base = &(cmnd->hdigest);
{
TRACE_ENTRY();
- /* We delete/add to tail connections to maintain fairness between them */
+ /*
+ * We delete/add to tail connections to maintain fairness between them.
+ */
while (!list_empty(&iscsi_wr_list)) {
int rc;
#include "iscsi.h"
#include "digest.h"
-#define CHECK_PARAM(info, iparam, word, min, max) \
-do { \
- if (!(info)->partial || ((info)->partial & 1 << key_##word)) \
- if ((iparam)[key_##word] < (min) || \
- (iparam)[key_##word] > (max)) { \
- PRINT_ERROR("%s: %u is out of range (%u %u)", \
- #word, (iparam)[key_##word], (min), (max)); \
- if ((iparam)[key_##word] < (min)) \
- (iparam)[key_##word] = (min); \
- else \
- (iparam)[key_##word] = (max); \
- } \
+#define CHECK_PARAM(info, iparam, word, min, max) \
+do { \
+ if (!(info)->partial || ((info)->partial & 1 << key_##word)) \
+ if ((iparam)[key_##word] < (min) || \
+ (iparam)[key_##word] > (max)) { \
+ PRINT_ERROR("%s: %u is out of range (%u %u)", \
+ #word, (iparam)[key_##word], (min), (max)); \
+ if ((iparam)[key_##word] < (min)) \
+ (iparam)[key_##word] = (min); \
+ else \
+ (iparam)[key_##word] = (max); \
+ } \
} while (0)
-#define SET_PARAM(param, info, iparam, word) \
-({ \
- int changed = 0; \
- if (!(info)->partial || ((info)->partial & 1 << key_##word)) { \
- if ((param)->word != (iparam)[key_##word]) \
- changed = 1; \
- (param)->word = (iparam)[key_##word]; \
- } \
- changed; \
+#define SET_PARAM(param, info, iparam, word) \
+({ \
+ int changed = 0; \
+ if (!(info)->partial || ((info)->partial & 1 << key_##word)) { \
+ if ((param)->word != (iparam)[key_##word]) \
+ changed = 1; \
+ (param)->word = (iparam)[key_##word]; \
+ } \
+ changed; \
})
-#define GET_PARAM(param, info, iparam, word) \
-do { \
- (iparam)[key_##word] = (param)->word; \
+#define GET_PARAM(param, info, iparam, word) \
+do { \
+ (iparam)[key_##word] = (param)->word; \
} while (0)
static const char *get_bool_name(int val)
{
PRINT_INFO("Negotiated parameters: InitialR2T %s, ImmediateData %s, "
"MaxConnections %d, MaxRecvDataSegmentLength %d, "
- "MaxXmitDataSegmentLength %d, ", get_bool_name(param->initial_r2t),
+ "MaxXmitDataSegmentLength %d, ",
+ get_bool_name(param->initial_r2t),
get_bool_name(param->immediate_data), param->max_connections,
param->max_recv_data_length, param->max_xmit_data_length);
PRINT_INFO(" MaxBurstLength %d, FirstBurstLength %d, "
param->default_wait_time, param->default_retain_time);
PRINT_INFO(" MaxOutstandingR2T %d, DataPDUInOrder %s, "
"DataSequenceInOrder %s, ErrorRecoveryLevel %d, ",
- param->max_outstanding_r2t, get_bool_name(param->data_pdu_inorder),
+ param->max_outstanding_r2t,
+ get_bool_name(param->data_pdu_inorder),
get_bool_name(param->data_sequence_inorder),
param->error_recovery_level);
PRINT_INFO(" HeaderDigest %s, DataDigest %s, OFMarker %s, "
"IFMarker %s, OFMarkInt %d, IFMarkInt %d",
get_digest_name(param->header_digest),
get_digest_name(param->data_digest),
- get_bool_name(param->ofmarker), get_bool_name(param->ifmarker),
+ get_bool_name(param->ofmarker),
+ get_bool_name(param->ifmarker),
param->ofmarkint, param->ifmarkint);
}
}
/* target_mutex supposed to be locked */
-static void sess_param_set(struct iscsi_sess_param *param, struct iscsi_param_info *info)
+static void sess_param_set(struct iscsi_sess_param *param,
+ struct iscsi_param_info *info)
{
u32 *iparam = info->session_param;
SET_PARAM(param, info, iparam, ifmarkint);
}
-static void sess_param_get(struct iscsi_sess_param *param, struct iscsi_param_info *info)
+static void sess_param_get(struct iscsi_sess_param *param,
+ struct iscsi_param_info *info)
{
u32 *iparam = info->session_param;
{
u32 *iparam = info->target_param;
- CHECK_PARAM(info, iparam, queued_cmnds, MIN_NR_QUEUED_CMNDS, MAX_NR_QUEUED_CMNDS);
+ CHECK_PARAM(info, iparam, queued_cmnds, MIN_NR_QUEUED_CMNDS,
+ MAX_NR_QUEUED_CMNDS);
}
/* target_mutex supposed to be locked */
-static void trgt_param_set(struct iscsi_target *target, struct iscsi_param_info *info)
+static void trgt_param_set(struct iscsi_target *target,
+ struct iscsi_param_info *info)
{
struct iscsi_trgt_param *param = &target->trgt_param;
u32 *iparam = info->target_param;
}
/* target_mutex supposed to be locked */
-static void trgt_param_get(struct iscsi_trgt_param *param, struct iscsi_param_info *info)
+static void trgt_param_get(struct iscsi_trgt_param *param,
+ struct iscsi_param_info *info)
{
u32 *iparam = info->target_param;
}
/* target_mutex supposed to be locked */
-static int trgt_param(struct iscsi_target *target, struct iscsi_param_info *info, int set)
+static int trgt_param(struct iscsi_target *target,
+ struct iscsi_param_info *info, int set)
{
if (set) {
struct iscsi_trgt_param *prm;
}
/* target_mutex supposed to be locked */
-static int sess_param(struct iscsi_target *target, struct iscsi_param_info *info, int set)
+static int sess_param(struct iscsi_target *target,
+ struct iscsi_param_info *info, int set)
{
struct iscsi_session *session = NULL;
struct iscsi_sess_param *param;
}
/* target_mutex supposed to be locked */
-int iscsi_param_set(struct iscsi_target *target, struct iscsi_param_info *info, int set)
+int iscsi_param_set(struct iscsi_target *target, struct iscsi_param_info *info,
+ int set)
{
int err;
{
struct iscsi_session *session;
- list_for_each_entry(session, &target->session_list, session_list_entry) {
+ list_for_each_entry(session, &target->session_list,
+ session_list_entry) {
if ((session->sid == sid) && !session->shutting_down)
return session;
}
}
/* target_mutex supposed to be locked */
-static int iscsi_session_alloc(struct iscsi_target *target, struct session_info *info)
+static int iscsi_session_alloc(struct iscsi_target *target,
+ struct session_info *info)
{
int err, i;
struct iscsi_session *session;
}
/* target_mutex supposed to be locked */
-static void iscsi_session_info_show(struct seq_file *seq, struct iscsi_target *target)
+static void iscsi_session_info_show(struct seq_file *seq,
+ struct iscsi_target *target)
{
struct iscsi_session *session;
- list_for_each_entry(session, &target->session_list, session_list_entry) {
+ list_for_each_entry(session, &target->session_list,
+ session_list_entry) {
seq_printf(seq, "\tsid:%llu initiator:%s shutting down %d\n",
(long long unsigned int)session->sid,
session->initiator_name,
return err;
}
+static void target_del_session(struct iscsi_target *target,
+ struct iscsi_session *session)
+{
+ TRACE_MGMT_DBG("Cleaning up session %p", session);
+ if (!list_empty(&session->conn_list)) {
+ struct iscsi_conn *conn, *tc;
+ list_for_each_entry_safe(conn, tc, &session->conn_list,
+ conn_list_entry) {
+ TRACE_MGMT_DBG("Mark conn %p closing", conn);
+ __mark_conn_closed(conn,
+ ISCSI_CONN_ACTIVE_CLOSE|ISCSI_CONN_DELETING);
+ }
+ } else {
+ TRACE_MGMT_DBG("Freeing session %p without connections",
+ session);
+ session_del(target, session->sid);
+ }
+}
+
void target_del_all(void)
{
struct iscsi_target *target, *t;
if (list_empty(&target_list))
break;
- list_for_each_entry_safe(target, t, &target_list, target_list_entry) {
+ list_for_each_entry_safe(target, t, &target_list,
+ target_list_entry) {
struct iscsi_session *session, *ts;
mutex_lock(&target->target_mutex);
if (!list_empty(&target->session_list)) {
- TRACE_MGMT_DBG("Cleaning up target %p", target);
- list_for_each_entry_safe(session, ts, &target->session_list,
+ TRACE_MGMT_DBG("Cleaning up target %p",
+ target);
+ list_for_each_entry_safe(session, ts,
+ &target->session_list,
session_list_entry) {
- TRACE_MGMT_DBG("Cleaning up session %p", session);
- if (!list_empty(&session->conn_list)) {
- struct iscsi_conn *conn, *tc;
- list_for_each_entry_safe(conn, tc,
- &session->conn_list,
- conn_list_entry) {
- TRACE_MGMT_DBG("Mark conn %p "
- "closing", conn);
- __mark_conn_closed(conn,
- ISCSI_CONN_ACTIVE_CLOSE|ISCSI_CONN_DELETING);
- }
- } else {
- TRACE_MGMT_DBG("Freeing session %p "
- "without connections", session);
- session_del(target, session->sid);
- }
+ target_del_session(target, session);
}
mutex_unlock(&target->target_mutex);
} else {
{
int res = cmd->atomic;
#ifdef CONFIG_SCST_EXTRACHECKS
- if (unlikely((in_atomic() || in_interrupt()) && !res)) {
+ if (unlikely((in_atomic() || in_interrupt() || irqs_disabled()) &&
+ !res)) {
printk(KERN_ERR "ERROR: atomic context and non-atomic cmd\n");
dump_stack();
cmd->atomic = 1;
http://git.etherboot.org / mirror / scst / .git / commitdiff