staging: iio: Use kcalloc instead of kzalloc to allocate array
authorThomas Meyer <thomas@m3y3r.de>
Tue, 29 Nov 2011 21:08:00 +0000 (22:08 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Wed, 30 Nov 2011 10:37:33 +0000 (19:37 +0900)
The advantage of kcalloc is, that will prevent integer overflows which could
result from the multiplication of number of elements and size and it is also
a bit nicer to read.

The semantic patch that makes this change is available
in https://lkml.org/lkml/2011/11/25/107

Signed-off-by: Thomas Meyer <thomas@m3y3r.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/iio/accel/lis3l02dq_ring.c
drivers/staging/iio/adc/ad7280a.c
drivers/staging/iio/iio_simple_dummy.c
drivers/staging/iio/industrialio-buffer.c
drivers/staging/iio/industrialio-core.c
drivers/staging/iio/meter/ade7758_core.c

index 89527af..a900502 100644 (file)
@@ -93,8 +93,7 @@ static int lis3l02dq_read_all(struct iio_dev *indio_dev, u8 *rx_array)
        struct spi_message msg;
        int ret, i, j = 0;
 
-       xfers = kzalloc((buffer->scan_count) * 2
-                       * sizeof(*xfers), GFP_KERNEL);
+       xfers = kcalloc((buffer->scan_count) * 2, sizeof(*xfers), GFP_KERNEL);
        if (!xfers)
                return -ENOMEM;
 
index 1af4194..f70bff2 100644 (file)
@@ -488,8 +488,8 @@ static int ad7280_channel_init(struct ad7280_state *st)
 {
        int dev, ch, cnt;
 
-       st->channels = kzalloc(sizeof(*st->channels) *
-                               ((st->slave_num + 1) * 12 + 2), GFP_KERNEL);
+       st->channels = kcalloc((st->slave_num + 1) * 12 + 2,
+                              sizeof(*st->channels), GFP_KERNEL);
        if (st->channels == NULL)
                return -ENOMEM;
 
@@ -683,7 +683,7 @@ static irqreturn_t ad7280_event_handler(int irq, void *private)
        unsigned *channels;
        int i, ret;
 
-       channels = kzalloc(sizeof(*channels) * st->scan_cnt, GFP_KERNEL);
+       channels = kcalloc(st->scan_cnt, sizeof(*channels), GFP_KERNEL);
        if (channels == NULL)
                return IRQ_HANDLED;
 
index 228f991..e3a9457 100644 (file)
@@ -518,7 +518,8 @@ static __init int iio_dummy_init(void)
                return -EINVAL;
        }
        /* Fake a bus */
-       iio_dummy_devs = kzalloc(sizeof(*iio_dummy_devs)*instances, GFP_KERNEL);
+       iio_dummy_devs = kcalloc(instances, sizeof(*iio_dummy_devs),
+                                GFP_KERNEL);
        /* Here we have no actual device so call probe */
        for (i = 0; i < instances; i++) {
                ret = iio_dummy_probe(i);
index f757bb7..8c55980 100644 (file)
@@ -315,10 +315,9 @@ int iio_buffer_register(struct iio_dev *indio_dev,
                        attrcount += ret;
                }
                if (indio_dev->masklength && buffer->scan_mask == NULL) {
-                       buffer->scan_mask
-                               = kzalloc(sizeof(*buffer->scan_mask)*
-                                         BITS_TO_LONGS(indio_dev->masklength),
-                                         GFP_KERNEL);
+                       buffer->scan_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
+                                                   sizeof(*buffer->scan_mask),
+                                                   GFP_KERNEL);
                        if (buffer->scan_mask == NULL) {
                                ret = -ENOMEM;
                                goto error_cleanup_dynamic;
@@ -328,10 +327,9 @@ int iio_buffer_register(struct iio_dev *indio_dev,
 
        buffer->scan_el_group.name = iio_scan_elements_group_name;
 
-       buffer->scan_el_group.attrs
-               = kzalloc(sizeof(buffer->scan_el_group.attrs[0])*
-                         (attrcount + 1),
-                         GFP_KERNEL);
+       buffer->scan_el_group.attrs = kcalloc(attrcount + 1,
+                                             sizeof(buffer->scan_el_group.attrs[0]),
+                                             GFP_KERNEL);
        if (buffer->scan_el_group.attrs == NULL) {
                ret = -ENOMEM;
                goto error_free_scan_mask;
index 55c0b48..d8cd9e3 100644 (file)
@@ -669,10 +669,9 @@ static int iio_device_register_sysfs(struct iio_dev *indio_dev)
        if (indio_dev->name)
                attrcount++;
 
-       indio_dev->chan_attr_group.attrs
-               = kzalloc(sizeof(indio_dev->chan_attr_group.attrs[0])*
-                         (attrcount + 1),
-                         GFP_KERNEL);
+       indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1,
+                                                  sizeof(indio_dev->chan_attr_group.attrs[0]),
+                                                  GFP_KERNEL);
        if (indio_dev->chan_attr_group.attrs == NULL) {
                ret = -ENOMEM;
                goto error_clear_attrs;
@@ -965,10 +964,9 @@ static int iio_device_register_eventset(struct iio_dev *indio_dev)
        }
 
        indio_dev->event_interface->group.name = iio_event_group_name;
-       indio_dev->event_interface->group.attrs =
-               kzalloc(sizeof(indio_dev->event_interface->group.attrs[0])
-                       *(attrcount + 1),
-                       GFP_KERNEL);
+       indio_dev->event_interface->group.attrs = kcalloc(attrcount + 1,
+                                                         sizeof(indio_dev->event_interface->group.attrs[0]),
+                                                         GFP_KERNEL);
        if (indio_dev->event_interface->group.attrs == NULL) {
                ret = -ENOMEM;
                goto error_free_setup_event_lines;
index 348df97..9dc881f 100644 (file)
@@ -746,12 +746,12 @@ static int __devinit ade7758_probe(struct spi_device *spi)
        spi_set_drvdata(spi, indio_dev);
 
        /* Allocate the comms buffers */
-       st->rx = kzalloc(sizeof(*st->rx)*ADE7758_MAX_RX, GFP_KERNEL);
+       st->rx = kcalloc(ADE7758_MAX_RX, sizeof(*st->rx), GFP_KERNEL);
        if (st->rx == NULL) {
                ret = -ENOMEM;
                goto error_free_dev;
        }
-       st->tx = kzalloc(sizeof(*st->tx)*ADE7758_MAX_TX, GFP_KERNEL);
+       st->tx = kcalloc(ADE7758_MAX_TX, sizeof(*st->tx), GFP_KERNEL);
        if (st->tx == NULL) {
                ret = -ENOMEM;
                goto error_free_rx;