The patch below fixes many checkpatch warnings triggered by the iSCSI kernel
authorvlnb <vlnb@d57e44dd-8a1f-0410-8b47-8ef2f437770f>
Wed, 12 Nov 2008 18:49:18 +0000 (18:49 +0000)
committervlnb <vlnb@d57e44dd-8a1f-0410-8b47-8ef2f437770f>
Wed, 12 Nov 2008 18:49:18 +0000 (18:49 +0000)
code, mainly about lines that exceeded 80 columns. As you can see in the patch
below most lines that were too long have been split, but some code has also
been moved into helper functions in order to keep the code readable. No
functionality has been changed.

This patch has been verified as follows:
- Reread the patch carefully.
- Verified that the iSCSI target kernel module still loads.
- Verified the output generated by scripts/run-regression-tests -k 2.6.27.5.

Signed-off-by: Bart Van Assche <bart.vanassche@gmail.com>
with some modifications

git-svn-id: https://scst.svn.sourceforge.net/svnroot/scst/trunk@569 d57e44dd-8a1f-0410-8b47-8ef2f437770f

12 files changed:
iscsi-scst/kernel/config.c
iscsi-scst/kernel/conn.c
iscsi-scst/kernel/digest.c
iscsi-scst/kernel/event.c
iscsi-scst/kernel/iscsi.c
iscsi-scst/kernel/iscsi.h
iscsi-scst/kernel/iscsi_dbg.h
iscsi-scst/kernel/nthread.c
iscsi-scst/kernel/param.c
iscsi-scst/kernel/session.c
iscsi-scst/kernel/target.c
scst/include/scst.h

index b682370..e132e3e 100644 (file)
@@ -113,7 +113,7 @@ static __init int iscsi_proc_log_entry_build(struct scst_tgt_template *templ)
        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",
@@ -126,7 +126,7 @@ static __init int iscsi_proc_log_entry_build(struct scst_tgt_template *templ)
                /* 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",
@@ -209,7 +209,8 @@ int __init iscsi_procfs_init(void)
                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 {
@@ -344,7 +345,8 @@ static int del_session(struct iscsi_target *target, void __user *ptr)
 }
 
 /* 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;
@@ -545,10 +547,11 @@ void iscsi_dump_iov(struct msghdr *msg)
 {
        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);
                }
        }
@@ -561,26 +564,26 @@ static void iscsi_dump_char(int ch)
 
        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)
@@ -590,18 +593,18 @@ 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 */
index d4fb407..03596af 100644 (file)
@@ -251,10 +251,11 @@ static void conn_rsp_timer_fn(unsigned long arg)
 
                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 {
@@ -349,7 +350,8 @@ int conn_free(struct iscsi_conn *conn)
 }
 
 /* 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;
@@ -452,8 +454,8 @@ int conn_del(struct iscsi_session *session, struct conn_info *info)
 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);
@@ -466,8 +468,8 @@ void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn)
 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);
index ec322d8..105151b 100644 (file)
@@ -1,7 +1,8 @@
 /*
  *  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
  *
@@ -81,8 +82,9 @@ static u32 evaluate_crc32_from_sg(struct scatterlist *sg, int total,
        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);
        }
index ac99037..3bbeded 100644 (file)
@@ -96,7 +96,8 @@ static int notify(void *data, int len, gfp_t gfp_mask)
        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);
 
index 28d8075..c8d5554 100644 (file)
@@ -126,7 +126,8 @@ static inline void iscsi_fail_waiting_cmnd(struct iscsi_cmnd *cmnd)
        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;
 
@@ -170,8 +171,8 @@ static void cmnd_free(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 */
@@ -182,15 +183,16 @@ static void cmnd_free(struct iscsi_cmnd *cmnd)
        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();
        }
@@ -205,8 +207,8 @@ void cmnd_done(struct iscsi_cmnd *cmnd)
 
        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);
@@ -255,8 +257,8 @@ void cmnd_done(struct iscsi_cmnd *cmnd)
                                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;
                        }
@@ -336,7 +338,8 @@ void req_cmnd_release_force(struct iscsi_cmnd *req, int flags)
                }
                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);
@@ -345,7 +348,8 @@ void req_cmnd_release_force(struct iscsi_cmnd *req, int flags)
 
 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)
@@ -511,7 +515,8 @@ static void iscsi_cmnds_init_write(struct list_head *send, int flags)
         * 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);
@@ -544,6 +549,8 @@ static void iscsi_cmnds_init_write(struct list_head *send, int flags)
 
        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)
@@ -551,8 +558,8 @@ 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,
@@ -563,6 +570,7 @@ static void iscsi_cmnd_init_write(struct iscsi_cmnd *rsp, int flags)
        }
        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)
@@ -578,6 +586,7 @@ 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)
@@ -645,6 +654,7 @@ 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,
@@ -813,8 +823,8 @@ static int check_cmd_sn(struct iscsi_cmnd *cmnd)
        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;
@@ -823,7 +833,8 @@ static inline struct iscsi_cmnd *__cmnd_find_hash(struct iscsi_session *session,
 
        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;
                }
@@ -925,7 +936,7 @@ static void cmnd_prepare_get_rejected_cmd_data(struct iscsi_cmnd *cmnd)
 {
        struct iscsi_conn *conn = cmnd->conn;
        struct scatterlist *sg = cmnd->sg;
-       char *addr;
+       char __user *addr;
        u32 size;
        int i;
 
@@ -1061,7 +1072,8 @@ static int cmnd_prepare_recv_pdu(struct iscsi_conn *conn,
                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;
@@ -1211,8 +1223,8 @@ static int noop_out_start(struct iscsi_cmnd *cmnd)
        } 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;
                }
        }
@@ -1228,8 +1240,8 @@ static int noop_out_start(struct iscsi_cmnd *cmnd)
                        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;
                        }
@@ -1332,7 +1344,8 @@ static int scsi_cmnd_start(struct iscsi_cmnd *req)
                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:
@@ -1365,7 +1378,7 @@ static int scsi_cmnd_start(struct iscsi_cmnd *req)
        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);
@@ -1396,7 +1409,8 @@ static int scsi_cmnd_start(struct iscsi_cmnd *req)
 
        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;
        }
@@ -1418,7 +1432,8 @@ static int scsi_cmnd_start(struct iscsi_cmnd *req)
                     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;
        }
@@ -1427,19 +1442,21 @@ static int scsi_cmnd_start(struct iscsi_cmnd *req)
                     !(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() */
@@ -1449,7 +1466,8 @@ out:
 
 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;
@@ -1513,7 +1531,8 @@ out_reject:
 
 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);
@@ -1549,7 +1568,8 @@ static void data_out_end(struct iscsi_cmnd *cmnd)
                        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;
                        }
@@ -1644,10 +1664,10 @@ static int cmnd_abort(struct iscsi_cmnd *req)
 
                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;
                        }
@@ -1702,10 +1722,13 @@ static int target_abort(struct iscsi_cmnd *req, int all)
 
        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)
@@ -1771,8 +1794,8 @@ again:
                                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);
@@ -1801,7 +1824,8 @@ static void execute_task_management(struct iscsi_cmnd *req)
        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,
@@ -2046,7 +2070,8 @@ out_rejected:
                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);
@@ -2089,7 +2114,8 @@ static void set_cork(struct socket *sock, int on)
 
        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);
 }
 
@@ -2127,7 +2153,8 @@ void cmnd_tx_start(struct iscsi_cmnd *cmnd)
                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);
@@ -2201,7 +2228,8 @@ static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
        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);
 
@@ -2242,8 +2270,9 @@ static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
 
                        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;
 
@@ -2290,7 +2319,8 @@ static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
                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;
                }
 
@@ -2306,7 +2336,8 @@ static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
                                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;
@@ -2315,8 +2346,9 @@ static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
                }
 
                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;
                }
@@ -2436,7 +2468,8 @@ out:
 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:
@@ -2576,7 +2609,8 @@ static int iscsi_xmit_response(struct scst_cmd *scst_cmd)
                        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;
        }
@@ -2609,7 +2643,8 @@ static int iscsi_xmit_response(struct scst_cmd *scst_cmd)
                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();
@@ -2631,16 +2666,19 @@ static int iscsi_xmit_response(struct scst_cmd *scst_cmd)
                        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);
@@ -2810,7 +2848,8 @@ static void iscsi_task_mgmt_fn_done(struct scst_mgmt_cmd *scst_mcmd)
 {
        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),
@@ -2924,7 +2963,8 @@ static int __init iscsi_init(void)
 
        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;
        }
index bbfa594..ea00443 100644 (file)
@@ -164,7 +164,10 @@ struct iscsi_conn {
        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;
@@ -199,7 +202,10 @@ struct iscsi_conn {
        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;
@@ -208,7 +214,7 @@ struct iscsi_conn {
 
        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;
@@ -221,14 +227,21 @@ struct iscsi_pdu {
        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
@@ -263,7 +276,8 @@ struct iscsi_cmnd {
        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;
 
@@ -393,14 +407,16 @@ extern int session_del(struct iscsi_target *, u64);
 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)
 {
index 40bfb00..b442d9c 100644 (file)
@@ -30,7 +30,8 @@
 
 #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 | \
index 6515479..f9408e4 100644 (file)
@@ -117,9 +117,11 @@ again:
                }
 
                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)) {
@@ -129,9 +131,12 @@ again:
                                        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) {
@@ -178,6 +183,151 @@ static void iscsi_unreg_cmds_done_fn(struct scst_session *scst_sess)
        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)
 {
@@ -211,7 +361,7 @@ 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
         */
@@ -230,11 +380,9 @@ static void close_conn(struct iscsi_conn *conn)
 
        /* 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);
@@ -251,86 +399,28 @@ static void close_conn(struct iscsi_conn *conn)
                }
 
                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);
                        }
                }
 
@@ -340,7 +430,8 @@ static void close_conn(struct iscsi_conn *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;
@@ -362,63 +453,12 @@ static void close_conn(struct iscsi_conn *conn)
                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);
        }
@@ -444,7 +484,8 @@ static void close_conn(struct iscsi_conn *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);
@@ -494,7 +535,8 @@ static void start_close_conn(struct iscsi_conn *conn)
        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;
@@ -504,7 +546,8 @@ static inline void iscsi_conn_init_read(struct iscsi_conn *conn, void *data, siz
        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);
@@ -548,7 +591,8 @@ static int do_recv(struct iscsi_conn *conn, int state)
 
        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) {
@@ -556,7 +600,7 @@ static int do_recv(struct iscsi_conn *conn, int state)
                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);
@@ -575,7 +619,8 @@ static int do_recv(struct iscsi_conn *conn, int state)
                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;
                        }
@@ -637,7 +682,8 @@ static int recv(struct iscsi_conn *conn)
                        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;
@@ -700,9 +746,9 @@ static int recv(struct iscsi_conn *conn)
                        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));
@@ -770,7 +816,9 @@ static void scst_do_job_rd(void)
 {
        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;
@@ -929,7 +977,8 @@ static int write_data(struct iscsi_conn *conn)
        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;
@@ -1064,18 +1113,20 @@ static int write_data(struct iscsi_conn *conn)
                        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
@@ -1086,14 +1137,14 @@ static int write_data(struct iscsi_conn *conn)
                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;
@@ -1195,7 +1246,8 @@ static int exit_tx(struct iscsi_conn *conn, int res)
                {
                        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;
@@ -1239,7 +1291,9 @@ static void init_tx_hdigest(struct iscsi_cmnd *cmnd)
 
        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);
@@ -1362,7 +1416,9 @@ static void scst_do_job_wr(void)
 {
        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;
index fef754f..6afdae3 100644 (file)
 #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)
@@ -68,7 +68,8 @@ static void log_params(struct iscsi_sess_param *param)
 {
        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, "
@@ -77,14 +78,16 @@ static void log_params(struct iscsi_sess_param *param)
                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);
 }
 
@@ -110,7 +113,8 @@ static void sess_param_check(struct iscsi_param_info *info)
 }
 
 /* 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;
 
@@ -135,7 +139,8 @@ static void sess_param_set(struct iscsi_sess_param *param, struct iscsi_param_in
        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;
 
@@ -165,11 +170,13 @@ static void trgt_param_check(struct iscsi_param_info *info)
 {
        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;
@@ -178,7 +185,8 @@ static void trgt_param_set(struct iscsi_target *target, struct iscsi_param_info
 }
 
 /* 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;
 
@@ -186,7 +194,8 @@ static void trgt_param_get(struct iscsi_trgt_param *param, struct iscsi_param_in
 }
 
 /* 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;
@@ -203,7 +212,8 @@ static int trgt_param(struct iscsi_target *target, struct iscsi_param_info *info
 }
 
 /* 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;
@@ -237,7 +247,8 @@ out:
 }
 
 /* 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;
 
index a9f6da2..d13526c 100644 (file)
@@ -21,7 +21,8 @@ struct iscsi_session *session_lookup(struct iscsi_target *target, u64 sid)
 {
        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;
        }
@@ -29,7 +30,8 @@ struct iscsi_session *session_lookup(struct iscsi_target *target, u64 sid)
 }
 
 /* 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;
@@ -173,11 +175,13 @@ int session_del(struct iscsi_target *target, u64 sid)
 }
 
 /* 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,
index 19f7b81..dd1648e 100644 (file)
@@ -215,6 +215,25 @@ out:
        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;
@@ -230,29 +249,17 @@ void target_del_all(void)
                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 {
index 0ef7835..c3b4430 100644 (file)
@@ -2043,7 +2043,8 @@ static inline int scst_cmd_atomic(struct scst_cmd *cmd)
 {
        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;