target: Follow up core updates from AGrover and HCH (round 4)

This patch contains the squashed version of forth round series cleanups
from Andy and Christoph following the post heavy lifting in the preceeding:
'Eliminate usage of struct se_mem' and 'Make all control CDBs scatter-gather'
changes.  This also includes a conversion of target core and the v3.0
mainline fabric modules (loopback and tcm_fc) to use pr_debug and the
CONFIG_DYNAMIC_DEBUG infrastructure!

These have been squashed into this third and final round for v3.1.

target: Remove ifdeffed code in t_g_process_write
target: Remove direct ramdisk code
target: Rename task_sg_num to task_sg_nents
target: Remove custom debug macros for pr_debug. Use pr_err().
target: Remove custom debug macros in mainline fabrics
target: Set WSNZ=1 in block limits VPD. Abort if WRITE_SAME sectors = 0
target: Remove transport do_se_mem_map callback
target: Further simplify transport_free_pages
target: Redo task allocation return value handling
target: Remove extra parentheses
target: change alloc_task call to take *cdb, not *cmd

(nab: Fix bogus struct file assignments in fd_do_readv and fd_do_writev)

Signed-off-by: Andy Grover <agrover@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

5 files changed, 45 insertions, 75 deletions

diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index 8d26779e440c..f7fff7ed63c3 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -23,30 +23,6 @@
 #define FT_TPG_NAMELEN 32       /* max length of TPG name */
 #define FT_LUN_NAMELEN 32       /* max length of LUN name */
 
-/*
- * Debug options.
- */
-#define FT_DEBUG_CONF   0x01    /* configuration messages */
-#define FT_DEBUG_SESS   0x02    /* session messages */
-#define FT_DEBUG_TM     0x04    /* TM operations */
-#define FT_DEBUG_IO     0x08    /* I/O commands */
-#define FT_DEBUG_DATA   0x10    /* Data transfer */
-
-extern unsigned int ft_debug_logging;   /* debug options */
-
-#define FT_DEBUG(mask, fmt, args...)                                    \
-        do {                                                            \
-                if (ft_debug_logging & (mask))                          \
-                        printk(KERN_INFO "tcm_fc: %s: " fmt,            \
-                                __func__, ##args);                      \
-        } while (0)
-
-#define FT_CONF_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_CONF, fmt, ##args)
-#define FT_SESS_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_SESS, fmt, ##args)
-#define FT_TM_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_TM, fmt, ##args)
-#define FT_IO_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_IO, fmt, ##args)
-#define FT_DATA_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_DATA, fmt, ##args)
-
 struct ft_transport_id {
         __u8    format;
         __u8    __resvd1[7];
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 9365e53947ad..a9e9a31da11d 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -62,22 +62,19 @@ void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
         struct scatterlist *sg;
         int count;
 
-        if (!(ft_debug_logging & FT_DEBUG_IO))
-                return;
-
         se_cmd = &cmd->se_cmd;
-        printk(KERN_INFO "%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
+        pr_debug("%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
                 caller, cmd, cmd->state, cmd->sess, cmd->seq, se_cmd);
-        printk(KERN_INFO "%s: cmd %p cdb %p\n",
+        pr_debug("%s: cmd %p cdb %p\n",
                 caller, cmd, cmd->cdb);
-        printk(KERN_INFO "%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
+        pr_debug("%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
 
-        printk(KERN_INFO "%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
+        pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
                 caller, cmd, se_cmd->t_data_nents,
                se_cmd->data_length, se_cmd->se_cmd_flags);
 
         for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, count)
-                printk(KERN_INFO "%s: cmd %p sg %p page %p "
+                pr_debug("%s: cmd %p sg %p page %p "
                         "len 0x%x off 0x%x\n",
                         caller, cmd, sg,
                         sg_page(sg), sg->length, sg->offset);
@@ -85,7 +82,7 @@ void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
         sp = cmd->seq;
         if (sp) {
                 ep = fc_seq_exch(sp);
-                printk(KERN_INFO "%s: cmd %p sid %x did %x "
+                pr_debug("%s: cmd %p sid %x did %x "
                         "ox_id %x rx_id %x seq_id %x e_stat %x\n",
                         caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid,
                         sp->id, ep->esb_stat);
@@ -321,7 +318,7 @@ static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
         case FC_RCTL_DD_SOL_CTL:        /* transfer ready */
         case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
         default:
-                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                pr_debug("%s: unhandled frame r_ctl %x\n",
                        __func__, fh->fh_r_ctl);
                 fc_frame_free(fp);
                 transport_generic_free_cmd(&cmd->se_cmd, 0, 0);
@@ -346,7 +343,7 @@ static void ft_send_resp_status(struct fc_lport *lport,
         struct fcp_resp_rsp_info *info;
 
         fh = fc_frame_header_get(rx_fp);
-        FT_IO_DBG("FCP error response: did %x oxid %x status %x code %x\n",
+        pr_debug("FCP error response: did %x oxid %x status %x code %x\n",
                   ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code);
         len = sizeof(*fcp);
         if (status == SAM_STAT_GOOD)
@@ -416,15 +413,15 @@ static void ft_send_tm(struct ft_cmd *cmd)
                  * FCP4r01 indicates having a combination of
                  * tm_flags set is invalid.
                  */
-                FT_TM_DBG("invalid FCP tm_flags %x\n", fcp->fc_tm_flags);
+                pr_debug("invalid FCP tm_flags %x\n", fcp->fc_tm_flags);
                 ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID);
                 return;
         }
 
-        FT_TM_DBG("alloc tm cmd fn %d\n", tm_func);
+        pr_debug("alloc tm cmd fn %d\n", tm_func);
         tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func);
         if (!tmr) {
-                FT_TM_DBG("alloc failed\n");
+                pr_debug("alloc failed\n");
                 ft_send_resp_code(cmd, FCP_TMF_FAILED);
                 return;
         }
@@ -439,7 +436,7 @@ static void ft_send_tm(struct ft_cmd *cmd)
                          * since "unable to  handle TMR request because failed
                          * to get to LUN"
                          */
-                        FT_TM_DBG("Failed to get LUN for TMR func %d, "
+                        pr_debug("Failed to get LUN for TMR func %d, "
                                   "se_cmd %p, unpacked_lun %d\n",
                                   tm_func, &cmd->se_cmd, cmd->lun);
                         ft_dump_cmd(cmd, __func__);
@@ -490,7 +487,7 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
                 code = FCP_TMF_FAILED;
                 break;
         }
-        FT_TM_DBG("tmr fn %d resp %d fcp code %d\n",
+        pr_debug("tmr fn %d resp %d fcp code %d\n",
                   tmr->function, tmr->response, code);
         ft_send_resp_code(cmd, code);
         return 0;
@@ -518,7 +515,7 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp)
         return;
 
 busy:
-        FT_IO_DBG("cmd or seq allocation failure - sending BUSY\n");
+        pr_debug("cmd or seq allocation failure - sending BUSY\n");
         ft_send_resp_status(lport, fp, SAM_STAT_BUSY, 0);
         fc_frame_free(fp);
         ft_sess_put(sess);              /* undo get from lookup */
@@ -543,7 +540,7 @@ void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp)
         case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
         case FC_RCTL_ELS4_REQ:          /* SRR, perhaps */
         default:
-                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                pr_debug("%s: unhandled frame r_ctl %x\n",
                        __func__, fh->fh_r_ctl);
                 fc_frame_free(fp);
                 ft_sess_put(sess);      /* undo get from lookup */
@@ -642,7 +639,7 @@ static void ft_send_cmd(struct ft_cmd *cmd)
 
         ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb);
 
-        FT_IO_DBG("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret);
+        pr_debug("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret);
         ft_dump_cmd(cmd, __func__);
 
         if (ret == -ENOMEM) {
@@ -672,7 +669,7 @@ err:
  */
 static void ft_exec_req(struct ft_cmd *cmd)
 {
-        FT_IO_DBG("cmd state %x\n", cmd->state);
+        pr_debug("cmd state %x\n", cmd->state);
         switch (cmd->state) {
         case FC_CMD_ST_NEW:
                 ft_send_cmd(cmd);
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index ec9e40dc4514..d63e3dd3b180 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -106,7 +106,7 @@ static ssize_t ft_parse_wwn(const char *name, u64 *wwn, int strict)
         }
         err = 4;
 fail:
-        FT_CONF_DBG("err %u len %zu pos %u byte %u\n",
+        pr_debug("err %u len %zu pos %u byte %u\n",
                     err, cp - name, pos, byte);
         return -1;
 }
@@ -216,7 +216,7 @@ static struct se_node_acl *ft_add_acl(
         u64 wwpn;
         u32 q_depth;
 
-        FT_CONF_DBG("add acl %s\n", name);
+        pr_debug("add acl %s\n", name);
         tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
 
         if (ft_parse_wwn(name, &wwpn, 1) < 0)
@@ -239,11 +239,11 @@ static void ft_del_acl(struct se_node_acl *se_acl)
         struct ft_node_acl *acl = container_of(se_acl,
                                 struct ft_node_acl, se_node_acl);
 
-        FT_CONF_DBG("del acl %s\n",
+        pr_debug("del acl %s\n",
                 config_item_name(&se_acl->acl_group.cg_item));
 
         tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
-        FT_CONF_DBG("del acl %p se_acl %p tpg %p se_tpg %p\n",
+        pr_debug("del acl %p se_acl %p tpg %p se_tpg %p\n",
                     acl, se_acl, tpg, &tpg->se_tpg);
 
         core_tpg_del_initiator_node_acl(&tpg->se_tpg, se_acl, 1);
@@ -260,11 +260,11 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
         spin_lock_bh(&se_tpg->acl_node_lock);
         list_for_each_entry(se_acl, &se_tpg->acl_node_list, acl_list) {
                 acl = container_of(se_acl, struct ft_node_acl, se_node_acl);
-                FT_CONF_DBG("acl %p port_name %llx\n",
+                pr_debug("acl %p port_name %llx\n",
                         acl, (unsigned long long)acl->node_auth.port_name);
                 if (acl->node_auth.port_name == rdata->ids.port_name ||
                     acl->node_auth.node_name == rdata->ids.node_name) {
-                        FT_CONF_DBG("acl %p port_name %llx matched\n", acl,
+                        pr_debug("acl %p port_name %llx matched\n", acl,
                                     (unsigned long long)rdata->ids.port_name);
                         found = acl;
                         /* XXX need to hold onto ACL */
@@ -281,10 +281,10 @@ struct se_node_acl *ft_tpg_alloc_fabric_acl(struct se_portal_group *se_tpg)
 
         acl = kzalloc(sizeof(*acl), GFP_KERNEL);
         if (!acl) {
-                printk(KERN_ERR "Unable to allocate struct ft_node_acl\n");
+                pr_err("Unable to allocate struct ft_node_acl\n");
                 return NULL;
         }
-        FT_CONF_DBG("acl %p\n", acl);
+        pr_debug("acl %p\n", acl);
         return &acl->se_node_acl;
 }
 
@@ -294,7 +294,7 @@ static void ft_tpg_release_fabric_acl(struct se_portal_group *se_tpg,
         struct ft_node_acl *acl = container_of(se_acl,
                                 struct ft_node_acl, se_node_acl);
 
-        FT_CONF_DBG(KERN_INFO "acl %p\n", acl);
+        pr_debug("acl %p\n", acl);
         kfree(acl);
 }
 
@@ -311,7 +311,7 @@ static struct se_portal_group *ft_add_tpg(
         unsigned long index;
         int ret;
 
-        FT_CONF_DBG("tcm_fc: add tpg %s\n", name);
+        pr_debug("tcm_fc: add tpg %s\n", name);
 
         /*
          * Name must be "tpgt_" followed by the index.
@@ -354,7 +354,7 @@ static void ft_del_tpg(struct se_portal_group *se_tpg)
 {
         struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
 
-        FT_CONF_DBG("del tpg %s\n",
+        pr_debug("del tpg %s\n",
                     config_item_name(&tpg->se_tpg.tpg_group.cg_item));
 
         kthread_stop(tpg->thread);
@@ -412,7 +412,7 @@ static struct se_wwn *ft_add_lport(
         struct ft_lport_acl *old_lacl;
         u64 wwpn;
 
-        FT_CONF_DBG("add lport %s\n", name);
+        pr_debug("add lport %s\n", name);
         if (ft_parse_wwn(name, &wwpn, 1) < 0)
                 return NULL;
         lacl = kzalloc(sizeof(*lacl), GFP_KERNEL);
@@ -441,7 +441,7 @@ static void ft_del_lport(struct se_wwn *wwn)
         struct ft_lport_acl *lacl = container_of(wwn,
                                 struct ft_lport_acl, fc_lport_wwn);
 
-        FT_CONF_DBG("del lport %s\n",
+        pr_debug("del lport %s\n",
                         config_item_name(&wwn->wwn_group.cg_item));
         mutex_lock(&ft_lport_lock);
         list_del(&lacl->list);
@@ -581,7 +581,7 @@ int ft_register_configfs(void)
          */
         fabric = target_fabric_configfs_init(THIS_MODULE, "fc");
         if (IS_ERR(fabric)) {
-                printk(KERN_INFO "%s: target_fabric_configfs_init() failed!\n",
+                pr_err("%s: target_fabric_configfs_init() failed!\n",
                        __func__);
                 return PTR_ERR(fabric);
         }
@@ -608,11 +608,8 @@ int ft_register_configfs(void)
          */
         ret = target_fabric_configfs_register(fabric);
         if (ret < 0) {
-                FT_CONF_DBG("target_fabric_configfs_register() for"
+                pr_debug("target_fabric_configfs_register() for"
                             " FC Target failed!\n");
-                printk(KERN_INFO
-                       "%s: target_fabric_configfs_register() failed!\n",
-                       __func__);
                 target_fabric_configfs_free(fabric);
                 return -1;
         }
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index 3563a9029c4a..11e6483fc127 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -39,6 +39,7 @@
 #include <linux/configfs.h>
 #include <linux/ctype.h>
 #include <linux/hash.h>
+#include <linux/ratelimit.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
@@ -176,8 +177,7 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
                 error = lport->tt.seq_send(lport, cmd->seq, fp);
                 if (error) {
                         /* XXX For now, initiator will retry */
-                        if (printk_ratelimit())
-                                printk(KERN_ERR "%s: Failed to send frame %p, "
+                        pr_err_ratelimited("%s: Failed to send frame %p, "
                                                 "xid <0x%x>, remaining %zu, "
                                                 "lso_max <0x%x>\n",
                                                 __func__, fp, ep->xid,
@@ -222,7 +222,7 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
          */
         buf = fc_frame_payload_get(fp, 1);
         if (cmd->was_ddp_setup && buf) {
-                printk(KERN_INFO "%s: When DDP was setup, not expected to"
+                pr_debug("%s: When DDP was setup, not expected to"
                                  "receive frame with payload, Payload shall be"
                                  "copied directly to buffer instead of coming "
                                  "via. legacy receive queues\n", __func__);
@@ -260,7 +260,7 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
                          * this point, but just in case if required in future
                          * for debugging or any other purpose
                          */
-                        printk(KERN_ERR "%s: Received frame with TSI bit not"
+                        pr_err("%s: Received frame with TSI bit not"
                                         " being SET, dropping the frame, "
                                         "cmd->sg <%p>, cmd->sg_cnt <0x%x>\n",
                                         __func__, cmd->sg, cmd->sg_cnt);
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
index 7491e21cc6ae..fbcbb3d1d06b 100644
--- a/drivers/target/tcm_fc/tfc_sess.c
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -198,13 +198,13 @@ static struct ft_sess *ft_sess_get(struct fc_lport *lport, u32 port_id)
                 if (sess->port_id == port_id) {
                         kref_get(&sess->kref);
                         rcu_read_unlock();
-                        FT_SESS_DBG("port_id %x found %p\n", port_id, sess);
+                        pr_debug("port_id %x found %p\n", port_id, sess);
                         return sess;
                 }
         }
 out:
         rcu_read_unlock();
-        FT_SESS_DBG("port_id %x not found\n", port_id);
+        pr_debug("port_id %x not found\n", port_id);
         return NULL;
 }
 
@@ -240,7 +240,7 @@ static struct ft_sess *ft_sess_create(struct ft_tport *tport, u32 port_id,
         hlist_add_head_rcu(&sess->hash, head);
         tport->sess_count++;
 
-        FT_SESS_DBG("port_id %x sess %p\n", port_id, sess);
+        pr_debug("port_id %x sess %p\n", port_id, sess);
 
         transport_register_session(&tport->tpg->se_tpg, &acl->se_node_acl,
                                    sess->se_sess, sess);
@@ -314,7 +314,7 @@ int ft_sess_shutdown(struct se_session *se_sess)
 {
         struct ft_sess *sess = se_sess->fabric_sess_ptr;
 
-        FT_SESS_DBG("port_id %x\n", sess->port_id);
+        pr_debug("port_id %x\n", sess->port_id);
         return 1;
 }
 
@@ -335,7 +335,7 @@ void ft_sess_close(struct se_session *se_sess)
                 mutex_unlock(&ft_lport_lock);
                 return;
         }
-        FT_SESS_DBG("port_id %x\n", port_id);
+        pr_debug("port_id %x\n", port_id);
         ft_sess_unhash(sess);
         mutex_unlock(&ft_lport_lock);
         transport_deregister_session_configfs(se_sess);
@@ -348,7 +348,7 @@ void ft_sess_stop(struct se_session *se_sess, int sess_sleep, int conn_sleep)
 {
         struct ft_sess *sess = se_sess->fabric_sess_ptr;
 
-        FT_SESS_DBG("port_id %x\n", sess->port_id);
+        pr_debug("port_id %x\n", sess->port_id);
 }
 
 int ft_sess_logged_in(struct se_session *se_sess)
@@ -458,7 +458,7 @@ static int ft_prli(struct fc_rport_priv *rdata, u32 spp_len,
         mutex_lock(&ft_lport_lock);
         ret = ft_prli_locked(rdata, spp_len, rspp, spp);
         mutex_unlock(&ft_lport_lock);
-        FT_SESS_DBG("port_id %x flags %x ret %x\n",
+        pr_debug("port_id %x flags %x ret %x\n",
                rdata->ids.port_id, rspp ? rspp->spp_flags : 0, ret);
         return ret;
 }
@@ -518,11 +518,11 @@ static void ft_recv(struct fc_lport *lport, struct fc_frame *fp)
         struct ft_sess *sess;
         u32 sid = fc_frame_sid(fp);
 
-        FT_SESS_DBG("sid %x\n", sid);
+        pr_debug("sid %x\n", sid);
 
         sess = ft_sess_get(lport, sid);
         if (!sess) {
-                FT_SESS_DBG("sid %x sess lookup failed\n", sid);
+                pr_debug("sid %x sess lookup failed\n", sid);
                 /* TBD XXX - if FCP_CMND, send PRLO */
                 fc_frame_free(fp);
                 return;