[SCSI] zfcp: Use common FC kmem_cache for GPN_FT request

Switch the allocation of the GPN_FT request data to the FC kmem_cache
and remove the zfcp_gpn kmem_cache.

Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: Steffen Maier <maier@linux.vnet.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>

diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 6d2beb6ad9ee95398af5460fc9cc093051778978..324fb1aab6f521f2eb08c20baa029f2b9d7e4b64 100644 (file)
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -122,11 +122,6 @@ static int __init zfcp_module_init(void)
 {
        int retval = -ENOMEM;
 
-       zfcp_data.gpn_ft_cache = zfcp_cache_hw_align("zfcp_gpn",
-                                       sizeof(struct zfcp_fc_gpn_ft_req));
-       if (!zfcp_data.gpn_ft_cache)
-               goto out;
-
        zfcp_data.qtcb_cache = zfcp_cache_hw_align("zfcp_qtcb",
                                        sizeof(struct fsf_qtcb));
        if (!zfcp_data.qtcb_cache)
@@ -171,8 +166,6 @@ out_transport:
 out_fc_cache:
        kmem_cache_destroy(zfcp_data.qtcb_cache);
 out_qtcb_cache:
-       kmem_cache_destroy(zfcp_data.gpn_ft_cache);
-out:
        return retval;
 }
 
@@ -185,7 +178,6 @@ static void __exit zfcp_module_exit(void)
        fc_release_transport(zfcp_data.scsi_transport_template);
        kmem_cache_destroy(zfcp_fc_req_cache);
        kmem_cache_destroy(zfcp_data.qtcb_cache);
-       kmem_cache_destroy(zfcp_data.gpn_ft_cache);
 }
 
 module_exit(zfcp_module_exit);

diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index dbf59108e1f418e0dd953a5a4df1608c425888ca..d7e2534ed66ecde175038fa8d6696a1ae418fce3 100644 (file)
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -317,7 +317,6 @@ struct zfcp_fsf_req {
 struct zfcp_data {
        struct scsi_host_template scsi_host_template;
        struct scsi_transport_template *scsi_transport_template;
-       struct kmem_cache       *gpn_ft_cache;
        struct kmem_cache       *qtcb_cache;
 };
 

diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 9824556033491493359ef5151557f47290732f5d..c839a3b6879dfaa64024a54bd18326eb1d396ead 100644 (file)
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -528,68 +528,42 @@ void zfcp_fc_test_link(struct zfcp_port *port)
                put_device(&port->dev);
 }
 
-static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num)
+static struct zfcp_fc_req *zfcp_alloc_sg_env(int buf_num)
 {
-       struct scatterlist *sg = &gpn_ft->sg_req;
-
-       kmem_cache_free(zfcp_data.gpn_ft_cache, sg_virt(sg));
-       zfcp_sg_free_table(gpn_ft->sg_resp, buf_num);
-
-       kfree(gpn_ft);
-}
-
-static struct zfcp_fc_gpn_ft *zfcp_alloc_sg_env(int buf_num)
-{
-       struct zfcp_fc_gpn_ft *gpn_ft;
-       struct zfcp_fc_gpn_ft_req *req;
+       struct zfcp_fc_req *fc_req;
 
-       gpn_ft = kzalloc(sizeof(*gpn_ft), GFP_KERNEL);
-       if (!gpn_ft)
+       fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
+       if (!fc_req)
                return NULL;
 
-       req = kmem_cache_zalloc(zfcp_data.gpn_ft_cache, GFP_KERNEL);
-       if (!req) {
-               kfree(gpn_ft);
-               gpn_ft = NULL;
-               goto out;
+       if (zfcp_sg_setup_table(&fc_req->sg_rsp, buf_num)) {
+               kmem_cache_free(zfcp_fc_req_cache, fc_req);
+               return NULL;
        }
-       sg_init_one(&gpn_ft->sg_req, req, sizeof(*req));
 
-       if (zfcp_sg_setup_table(gpn_ft->sg_resp, buf_num)) {
-               zfcp_free_sg_env(gpn_ft, buf_num);
-               gpn_ft = NULL;
-       }
-out:
-       return gpn_ft;
-}
+       sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req,
+                   sizeof(struct zfcp_fc_gpn_ft_req));
 
+       return fc_req;
+}
 
-static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
+static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req,
                               struct zfcp_adapter *adapter, int max_bytes)
 {
-       struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
-       struct zfcp_fc_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
+       struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+       struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req;
        DECLARE_COMPLETION_ONSTACK(completion);
        int ret;
 
-       /* prepare CT IU for GPN_FT */
-       req->ct_hdr.ct_rev = FC_CT_REV;
-       req->ct_hdr.ct_fs_type = FC_FST_DIR;
-       req->ct_hdr.ct_fs_subtype = FC_NS_SUBTYPE;
-       req->ct_hdr.ct_options = 0;
-       req->ct_hdr.ct_cmd = FC_NS_GPN_FT;
-       req->ct_hdr.ct_mr_size = max_bytes / 4;
-       req->gpn_ft.fn_domain_id_scope = 0;
-       req->gpn_ft.fn_area_id_scope = 0;
+       zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes);
        req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
 
-       /* prepare zfcp_send_ct */
-       ct->handler = zfcp_fc_complete;
-       ct->handler_data = &completion;
-       ct->req = &gpn_ft->sg_req;
-       ct->resp = gpn_ft->sg_resp;
+       ct_els->handler = zfcp_fc_complete;
+       ct_els->handler_data = &completion;
+       ct_els->req = &fc_req->sg_req;
+       ct_els->resp = &fc_req->sg_rsp;
 
-       ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct, NULL,
+       ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
                               ZFCP_FC_CTELS_TMO);
        if (!ret)
                wait_for_completion(&completion);
@@ -610,11 +584,11 @@ static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
        list_move_tail(&port->list, lh);
 }
 
-static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
+static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
                               struct zfcp_adapter *adapter, int max_entries)
 {
-       struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
-       struct scatterlist *sg = gpn_ft->sg_resp;
+       struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+       struct scatterlist *sg = &fc_req->sg_rsp;
        struct fc_ct_hdr *hdr = sg_virt(sg);
        struct fc_gpn_ft_resp *acc = sg_virt(sg);
        struct zfcp_port *port, *tmp;
@@ -623,7 +597,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
        u32 d_id;
        int ret = 0, x, last = 0;
 
-       if (ct->status)
+       if (ct_els->status)
                return -EIO;
 
        if (hdr->ct_cmd != FC_FS_ACC) {
@@ -687,7 +661,7 @@ void zfcp_fc_scan_ports(struct work_struct *work)
        struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
                                                    scan_work);
        int ret, i;
-       struct zfcp_fc_gpn_ft *gpn_ft;
+       struct zfcp_fc_req *fc_req;
        int chain, max_entries, buf_num, max_bytes;
 
        chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
@@ -702,21 +676,22 @@ void zfcp_fc_scan_ports(struct work_struct *work)
        if (zfcp_fc_wka_port_get(&adapter->gs->ds))
                return;
 
-       gpn_ft = zfcp_alloc_sg_env(buf_num);
-       if (!gpn_ft)
+       fc_req = zfcp_alloc_sg_env(buf_num);
+       if (!fc_req)
                goto out;
 
        for (i = 0; i < 3; i++) {
-               ret = zfcp_fc_send_gpn_ft(gpn_ft, adapter, max_bytes);
+               ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes);
                if (!ret) {
-                       ret = zfcp_fc_eval_gpn_ft(gpn_ft, adapter, max_entries);
+                       ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries);
                        if (ret == -EAGAIN)
                                ssleep(1);
                        else
                                break;
                }
        }
-       zfcp_free_sg_env(gpn_ft, buf_num);
+       zfcp_sg_free_table(&fc_req->sg_rsp, buf_num);
+       kmem_cache_free(zfcp_fc_req_cache, fc_req);
 out:
        zfcp_fc_wka_port_put(&adapter->gs->ds);
 }

diff --git a/drivers/s390/scsi/zfcp_fc.h b/drivers/s390/scsi/zfcp_fc.h
index 200fe2501332a9a4d7039a330289da47f6a1e07c..2066f9d9ceb5fdddc228788ebf650acf25768305 100644 (file)
--- a/drivers/s390/scsi/zfcp_fc.h
+++ b/drivers/s390/scsi/zfcp_fc.h
@@ -83,28 +83,6 @@ struct zfcp_fc_gpn_ft_req {
        struct fc_ns_gid_ft     gpn_ft;
 } __packed;
 
-/**
- * struct zfcp_fc_gpn_ft_resp - container for ct header plus gpn_ft response
- * @ct_hdr: FC GS common transport header
- * @gpn_ft: Array of gpn_ft response data to fill one memory page
- */
-struct zfcp_fc_gpn_ft_resp {
-       struct fc_ct_hdr        ct_hdr;
-       struct fc_gpn_ft_resp   gpn_ft[ZFCP_FC_GPN_FT_ENT_PAGE];
-} __packed;
-
-/**
- * struct zfcp_fc_gpn_ft - zfcp data for gpn_ft request
- * @ct: data passed to zfcp_fsf for issuing fsf request
- * @sg_req: scatter list entry for gpn_ft request
- * @sg_resp: scatter list entries for gpn_ft responses (per memory page)
- */
-struct zfcp_fc_gpn_ft {
-       struct zfcp_fsf_ct_els ct;
-       struct scatterlist sg_req;
-       struct scatterlist sg_resp[ZFCP_FC_GPN_FT_NUM_BUFS];
-};
-
 /**
  * struct zfcp_fc_req - Container for FC ELS and CT requests sent from zfcp
  * @ct_els: data required for issuing fsf command
@@ -125,6 +103,10 @@ struct zfcp_fc_req {
                        struct zfcp_fc_gid_pn_req       req;
                        struct zfcp_fc_gid_pn_rsp       rsp;
                } gid_pn;
+               struct {
+                       struct scatterlist sg_rsp2[ZFCP_FC_GPN_FT_NUM_BUFS - 1];
+                       struct zfcp_fc_gpn_ft_req       req;
+               } gpn_ft;
        } u;
 };