[SCSI] SCSI core kmalloc2kzalloc

Change the core SCSI code to use kzalloc rather than kmalloc+memset
where possible.

Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

15 files changed, 30 insertions, 59 deletions

diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 588107923499..ef57f253031c 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -306,10 +306,9 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
                 dump_stack();
         }
 
-        shost = kmalloc(sizeof(struct Scsi_Host) + privsize, gfp_mask);
+        shost = kzalloc(sizeof(struct Scsi_Host) + privsize, gfp_mask);
         if (!shost)
                 return NULL;
-        memset(shost, 0, sizeof(struct Scsi_Host) + privsize);
 
         spin_lock_init(&shost->default_lock);
         scsi_assign_lock(shost, &shost->default_lock);
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index c551bb84dbfb..11b27ba0cd41 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -136,9 +136,8 @@ struct scsi_request *scsi_allocate_request(struct scsi_device *sdev,
         const int size = offset + sizeof(struct request);
         struct scsi_request *sreq;
   
-        sreq = kmalloc(size, gfp_mask);
+        sreq = kzalloc(size, gfp_mask);
         if (likely(sreq != NULL)) {
-                memset(sreq, 0, size);
                 sreq->sr_request = (struct request *)(((char *)sreq) + offset);
                 sreq->sr_device = sdev;
                 sreq->sr_host = sdev->host;
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 0e529f8171c4..5a5d2af8ee43 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -1061,13 +1061,12 @@ static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
                 }
         }
         if (NULL == open_devip) { /* try and make a new one */
-                open_devip = kmalloc(sizeof(*open_devip),GFP_KERNEL);
+                open_devip = kzalloc(sizeof(*open_devip),GFP_KERNEL);
                 if (NULL == open_devip) {
                         printk(KERN_ERR "%s: out of memory at line %d\n",
                                 __FUNCTION__, __LINE__);
                         return NULL;
                 }
-                memset(open_devip, 0, sizeof(*open_devip));
                 open_devip->sdbg_host = sdbg_host;
                 list_add_tail(&open_devip->dev_list,
                 &sdbg_host->dev_info_list);
@@ -1814,7 +1813,7 @@ static int sdebug_add_adapter(void)
         struct sdebug_dev_info *sdbg_devinfo;
         struct list_head *lh, *lh_sf;
 
-        sdbg_host = kmalloc(sizeof(*sdbg_host),GFP_KERNEL);
+        sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
 
         if (NULL == sdbg_host) {
                 printk(KERN_ERR "%s: out of memory at line %d\n",
@@ -1822,19 +1821,17 @@ static int sdebug_add_adapter(void)
                 return -ENOMEM;
         }
 
-        memset(sdbg_host, 0, sizeof(*sdbg_host));
         INIT_LIST_HEAD(&sdbg_host->dev_info_list);
 
         devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
         for (k = 0; k < devs_per_host; k++) {
-                sdbg_devinfo = kmalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
+                sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo), GFP_KERNEL);
                 if (NULL == sdbg_devinfo) {
                         printk(KERN_ERR "%s: out of memory at line %d\n",
                                __FUNCTION__, __LINE__);
                         error = -ENOMEM;
                         goto clean;
                 }
-                memset(sdbg_devinfo, 0, sizeof(*sdbg_devinfo));
                 sdbg_devinfo->sdbg_host = sdbg_host;
                 list_add_tail(&sdbg_devinfo->dev_list,
                               &sdbg_host->dev_info_list);
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index 0bba7d8eebb0..36e930066649 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -241,10 +241,9 @@ int scsi_ioctl_send_command(struct scsi_device *sdev,
                 buf_needed = (buf_needed + 511) & ~511;
                 if (buf_needed > MAX_BUF)
                         buf_needed = MAX_BUF;
-                buf = kmalloc(buf_needed, gfp_mask);
+                buf = kzalloc(buf_needed, gfp_mask);
                 if (!buf)
                         return -ENOMEM;
-                memset(buf, 0, buf_needed);
                 if (inlen == 0) {
                         data_direction = DMA_FROM_DEVICE;
                 } else if (outlen == 0 ) {
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 4362dcde74af..1fe4fd83e305 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -286,13 +286,12 @@ int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
         int result;
         
         if (sshdr) {
-                sense = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
+                sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
                 if (!sense)
                         return DRIVER_ERROR << 24;
-                memset(sense, 0, SCSI_SENSE_BUFFERSIZE);
         }
         result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
-                                  sense, timeout, retries, 0);
+                              sense, timeout, retries, 0);
         if (sshdr)
                 scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);
 
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 5acb83ca5ae5..74863da1d630 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -205,12 +205,11 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
         int display_failure_msg = 1, ret;
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 
-        sdev = kmalloc(sizeof(*sdev) + shost->transportt->device_size,
+        sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
                        GFP_ATOMIC);
         if (!sdev)
                 goto out;
 
-        memset(sdev, 0, sizeof(*sdev));
         sdev->vendor = scsi_null_device_strs;
         sdev->model = scsi_null_device_strs;
         sdev->rev = scsi_null_device_strs;
@@ -334,12 +333,11 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         struct scsi_target *starget;
         struct scsi_target *found_target;
 
-        starget = kmalloc(size, GFP_KERNEL);
+        starget = kzalloc(size, GFP_KERNEL);
         if (!starget) {
                 printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__);
                 return NULL;
         }
-        memset(starget, 0, size);
         dev = &starget->dev;
         device_initialize(dev);
         starget->reap_ref = 1;
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index f2c9acf11bd0..56012b2694d2 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -1115,15 +1115,13 @@ static int fc_user_scan(struct Scsi_Host *shost, uint channel,
 struct scsi_transport_template *
 fc_attach_transport(struct fc_function_template *ft)
 {
-        struct fc_internal *i = kmalloc(sizeof(struct fc_internal),
-                                        GFP_KERNEL);
         int count;
+        struct fc_internal *i = kzalloc(sizeof(struct fc_internal),
+                                        GFP_KERNEL);
 
         if (unlikely(!i))
                 return NULL;
 
-        memset(i, 0, sizeof(struct fc_internal));
-
         i->t.target_attrs.ac.attrs = &i->starget_attrs[0];
         i->t.target_attrs.ac.class = &fc_transport_class.class;
         i->t.target_attrs.ac.match = fc_target_match;
@@ -1305,12 +1303,11 @@ fc_rport_create(struct Scsi_Host *shost, int channel,
         size_t size;
 
         size = (sizeof(struct fc_rport) + fci->f->dd_fcrport_size);
-        rport = kmalloc(size, GFP_KERNEL);
+        rport = kzalloc(size, GFP_KERNEL);
         if (unlikely(!rport)) {
                 printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__);
                 return NULL;
         }
-        memset(rport, 0, size);
 
         rport->maxframe_size = -1;
         rport->supported_classes = FC_COS_UNSPECIFIED;
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 71e54a64adca..2730d507e585 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -1117,10 +1117,9 @@ iscsi_register_transport(struct iscsi_transport *tt)
         if (priv)
                 return NULL;
 
-        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return NULL;
-        memset(priv, 0, sizeof(*priv));
         INIT_LIST_HEAD(&priv->list);
         priv->iscsi_transport = tt;
 
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 210dab5879fa..205542988e29 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -391,10 +391,9 @@ struct sas_phy *sas_phy_alloc(struct device *parent, int number)
         struct Scsi_Host *shost = dev_to_shost(parent);
         struct sas_phy *phy;
 
-        phy = kmalloc(sizeof(*phy), GFP_KERNEL);
+        phy = kzalloc(sizeof(*phy), GFP_KERNEL);
         if (!phy)
                 return NULL;
-        memset(phy, 0, sizeof(*phy));
 
         get_device(parent);
 
@@ -585,12 +584,11 @@ struct sas_rphy *sas_rphy_alloc(struct sas_phy *parent)
         struct Scsi_Host *shost = dev_to_shost(&parent->dev);
         struct sas_rphy *rphy;
 
-        rphy = kmalloc(sizeof(*rphy), GFP_KERNEL);
+        rphy = kzalloc(sizeof(*rphy), GFP_KERNEL);
         if (!rphy) {
                 put_device(&parent->dev);
                 return NULL;
         }
-        memset(rphy, 0, sizeof(*rphy));
 
         device_initialize(&rphy->dev);
         rphy->dev.parent = get_device(&parent->dev);
@@ -793,10 +791,9 @@ sas_attach_transport(struct sas_function_template *ft)
         struct sas_internal *i;
         int count;
 
-        i = kmalloc(sizeof(struct sas_internal), GFP_KERNEL);
+        i = kzalloc(sizeof(struct sas_internal), GFP_KERNEL);
         if (!i)
                 return NULL;
-        memset(i, 0, sizeof(struct sas_internal));
 
         i->t.user_scan = sas_user_scan;
 
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 7ee95eb83dda..a1e521b58b67 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -900,13 +900,11 @@ spi_dv_device(struct scsi_device *sdev)
         if (unlikely(scsi_device_get(sdev)))
                 return;
 
-        buffer = kmalloc(len, GFP_KERNEL);
+        buffer = kzalloc(len, GFP_KERNEL);
 
         if (unlikely(!buffer))
                 goto out_put;
 
-        memset(buffer, 0, len);
-
         /* We need to verify that the actual device will quiesce; the
          * later target quiesce is just a nice to have */
         if (unlikely(scsi_device_quiesce(sdev)))
@@ -1265,15 +1263,13 @@ static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
 struct scsi_transport_template *
 spi_attach_transport(struct spi_function_template *ft)
 {
-        struct spi_internal *i = kmalloc(sizeof(struct spi_internal),
-                                         GFP_KERNEL);
         int count = 0;
+        struct spi_internal *i = kzalloc(sizeof(struct spi_internal),
+                                         GFP_KERNEL);
+
         if (unlikely(!i))
                 return NULL;
 
-        memset(i, 0, sizeof(struct spi_internal));
-
-
         i->t.target_attrs.ac.class = &spi_transport_class.class;
         i->t.target_attrs.ac.attrs = &i->attrs[0];
         i->t.target_attrs.ac.match = spi_target_match;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 9d9872347f56..8ba2d988d051 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1517,11 +1517,10 @@ static int sd_probe(struct device *dev)
                                         "sd_attach\n"));
 
         error = -ENOMEM;
-        sdkp = kmalloc(sizeof(*sdkp), GFP_KERNEL);
+        sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
         if (!sdkp)
                 goto out;
 
-        memset (sdkp, 0, sizeof(*sdkp));
         kref_init(&sdkp->kref);
 
         gd = alloc_disk(16);
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 2a547538d444..ecf2f6010e76 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1361,7 +1361,7 @@ static int sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         void *old_sg_dev_arr = NULL;
         int k, error;
 
-        sdp = kmalloc(sizeof(Sg_device), GFP_KERNEL);
+        sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
         if (!sdp) {
                 printk(KERN_WARNING "kmalloc Sg_device failure\n");
                 return -ENOMEM;
@@ -1373,12 +1373,11 @@ static int sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
                 int tmp_dev_max = sg_nr_dev + SG_DEV_ARR_LUMP;
                 write_unlock_irqrestore(&sg_dev_arr_lock, iflags);
 
-                tmp_da = kmalloc(tmp_dev_max * sizeof(Sg_device *), GFP_KERNEL);
+                tmp_da = kzalloc(tmp_dev_max * sizeof(Sg_device *), GFP_KERNEL);
                 if (unlikely(!tmp_da))
                         goto expand_failed;
 
                 write_lock_irqsave(&sg_dev_arr_lock, iflags);
-                memset(tmp_da, 0, tmp_dev_max * sizeof(Sg_device *));
                 memcpy(tmp_da, sg_dev_arr, sg_dev_max * sizeof(Sg_device *));
                 old_sg_dev_arr = sg_dev_arr;
                 sg_dev_arr = tmp_da;
@@ -1391,7 +1390,6 @@ static int sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         if (unlikely(k >= SG_MAX_DEVS))
                 goto overflow;
 
-        memset(sdp, 0, sizeof(*sdp));
         SCSI_LOG_TIMEOUT(3, printk("sg_alloc: dev=%d \n", k));
         sprintf(disk->disk_name, "sg%d", k);
         disk->first_minor = k;
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 997f8e30509b..d8d12a1718bf 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -525,10 +525,9 @@ static int sr_probe(struct device *dev)
                 goto fail;
 
         error = -ENOMEM;
-        cd = kmalloc(sizeof(*cd), GFP_KERNEL);
+        cd = kzalloc(sizeof(*cd), GFP_KERNEL);
         if (!cd)
                 goto fail;
-        memset(cd, 0, sizeof(*cd));
 
         kref_init(&cd->kref);
 
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 5d02ff4db6cc..03fbc4b44473 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -44,11 +44,10 @@ static int sr_read_tochdr(struct cdrom_device_info *cdi,
         int result;
         unsigned char *buffer;
 
-        buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
+        buffer = kzalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
         if (!buffer)
                 return -ENOMEM;
 
-        memset(&cgc, 0, sizeof(struct packet_command));
         cgc.timeout = IOCTL_TIMEOUT;
         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
         cgc.cmd[8] = 12;                /* LSB of length */
@@ -74,11 +73,10 @@ static int sr_read_tocentry(struct cdrom_device_info *cdi,
         int result;
         unsigned char *buffer;
 
-        buffer = kmalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
+        buffer = kzalloc(32, GFP_KERNEL | SR_GFP_DMA(cd));
         if (!buffer)
                 return -ENOMEM;
 
-        memset(&cgc, 0, sizeof(struct packet_command));
         cgc.timeout = IOCTL_TIMEOUT;
         cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
         cgc.cmd[1] |= (tocentry->cdte_format == CDROM_MSF) ? 0x02 : 0;
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 7f96f33c1bb1..f0606da19d02 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3590,12 +3590,11 @@ static struct st_buffer *
 
         i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
                 max_sg * sizeof(struct st_buf_fragment);
-        tb = kmalloc(i, priority);
+        tb = kzalloc(i, priority);
         if (!tb) {
                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
                 return NULL;
         }
-        memset(tb, 0, i);
         tb->frp_segs = tb->orig_frp_segs = 0;
         tb->use_sg = max_sg;
         tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
@@ -3924,14 +3923,13 @@ static int st_probe(struct device *dev)
                         goto out_put_disk;
                 }
 
-                tmp_da = kmalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
+                tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
                 if (tmp_da == NULL) {
                         write_unlock(&st_dev_arr_lock);
                         printk(KERN_ERR "st: Can't extend device array.\n");
                         goto out_put_disk;
                 }
 
-                memset(tmp_da, 0, tmp_dev_max * sizeof(struct scsi_tape *));
                 if (scsi_tapes != NULL) {
                         memcpy(tmp_da, scsi_tapes,
                                st_dev_max * sizeof(struct scsi_tape *));
@@ -3948,13 +3946,12 @@ static int st_probe(struct device *dev)
         if (i >= st_dev_max)
                 panic("scsi_devices corrupt (st)");
 
-        tpnt = kmalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
+        tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
         if (tpnt == NULL) {
                 write_unlock(&st_dev_arr_lock);
                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
                 goto out_put_disk;
         }
-        memset(tpnt, 0, sizeof(struct scsi_tape));
         kref_init(&tpnt->kref);
         tpnt->disk = disk;
         sprintf(disk->disk_name, "st%d", i);