staging: Remove unnecessary OOM messages

alloc failures already get standardized OOM
messages and a dump_stack.

For the affected mallocs around these OOM messages:

Converted kzallocs with multiplies to kcalloc.
Converted kmallocs with multiplies to kmalloc_array.
Converted a kmalloc/strlen/strncpy to kstrdup.
Moved a spin_lock below a removed OOM message and
removed a now unnecessary spin_unlock.
Neatened alignment and whitespace.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/asus_oled/asus_oled.c b/drivers/staging/asus_oled/asus_oled.c
index 00185478647a57ad30dee40cd3dbc0964bfbc415..d0a5a28a8fe22598e760788a63b257f5f0cc93c9 100644 (file)
--- a/drivers/staging/asus_oled/asus_oled.c
+++ b/drivers/staging/asus_oled/asus_oled.c
@@ -164,11 +164,8 @@ static void enable_oled(struct asus_oled_dev *odev, uint8_t enabl)
        struct asus_oled_packet *packet;
 
        packet = kzalloc(sizeof(struct asus_oled_packet), GFP_KERNEL);
-
-       if (!packet) {
-               dev_err(&odev->udev->dev, "out of memory\n");
+       if (!packet)
                return;
-       }
 
        setup_packet_header(packet, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00);
 
@@ -323,11 +320,8 @@ static void send_data(struct asus_oled_dev *odev)
        struct asus_oled_packet *packet;
 
        packet = kzalloc(sizeof(struct asus_oled_packet), GFP_KERNEL);
-
-       if (!packet) {
-               dev_err(&odev->udev->dev, "out of memory\n");
+       if (!packet)
                return;
-       }
 
        if (odev->pack_mode == PACK_MODE_G1) {
                /* When sending roll-mode data the display updated only
@@ -665,11 +659,8 @@ static int asus_oled_probe(struct usb_interface *interface,
        }
 
        odev = kzalloc(sizeof(struct asus_oled_dev), GFP_KERNEL);
-
-       if (odev == NULL) {
-               dev_err(&interface->dev, "Out of memory\n");
+       if (odev == NULL)
                return -ENOMEM;
-       }
 
        odev->udev = usb_get_dev(udev);
        odev->pic_mode = ASUS_OLED_STATIC;

diff --git a/drivers/staging/bcm/InterfaceInit.c b/drivers/staging/bcm/InterfaceInit.c
index eb246430b320df5e351e6e9d8bce4dff390e3224..79058ce5b332b00cd344c33d8cba05e3a5f6a134 100644 (file)
--- a/drivers/staging/bcm/InterfaceInit.c
+++ b/drivers/staging/bcm/InterfaceInit.c
@@ -190,9 +190,9 @@ static int usbbcm_device_probe(struct usb_interface *intf, const struct usb_devi
        }
 
        /* Allocate interface adapter structure */
-       psIntfAdapter = kzalloc(sizeof(struct bcm_interface_adapter), GFP_KERNEL);
+       psIntfAdapter = kzalloc(sizeof(struct bcm_interface_adapter),
+                               GFP_KERNEL);
        if (psIntfAdapter == NULL) {
-               dev_err(&udev->dev, DRV_NAME ": no memory for Interface adapter\n");
                AdapterFree(psAdapter);
                return -ENOMEM;
        }
@@ -564,11 +564,8 @@ static int InterfaceAdapterInit(struct bcm_interface_adapter *psIntfAdapter)
                        psIntfAdapter->sIntrIn.int_in_interval = endpoint->bInterval;
                        psIntfAdapter->sIntrIn.int_in_buffer =
                                                kmalloc(buffer_size, GFP_KERNEL);
-                       if (!psIntfAdapter->sIntrIn.int_in_buffer) {
-                               dev_err(&psIntfAdapter->udev->dev,
-                                       "could not allocate interrupt_in_buffer\n");
+                       if (!psIntfAdapter->sIntrIn.int_in_buffer)
                                return -EINVAL;
-                       }
                }
 
                if (!psIntfAdapter->sIntrOut.int_out_endpointAddr && bcm_usb_endpoint_is_int_out(endpoint)) {
@@ -587,11 +584,8 @@ static int InterfaceAdapterInit(struct bcm_interface_adapter *psIntfAdapter)
                                psIntfAdapter->sIntrOut.int_out_endpointAddr = endpoint->bEndpointAddress;
                                psIntfAdapter->sIntrOut.int_out_interval = endpoint->bInterval;
                                psIntfAdapter->sIntrOut.int_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
-                               if (!psIntfAdapter->sIntrOut.int_out_buffer) {
-                                       dev_err(&psIntfAdapter->udev->dev,
-                                               "could not allocate interrupt_out_buffer\n");
+                               if (!psIntfAdapter->sIntrOut.int_out_buffer)
                                        return -EINVAL;
-                               }
                        }
                }
        }

diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c
index 60bed3e90fb835e7e69fc2897b6131e6b417bbce..254131d8be5ffea67d89cc669f6648d3e79f0173 100644 (file)
--- a/drivers/staging/ced1401/usb1401.c
+++ b/drivers/staging/ced1401/usb1401.c
@@ -1391,10 +1391,8 @@ static int ced_probe(struct usb_interface *interface,
 
        // allocate memory for our device extension and initialize it
        pdx = kzalloc(sizeof(*pdx), GFP_KERNEL);
-       if (!pdx) {
-               dev_err(&interface->dev, "Out of memory\n");
+       if (!pdx)
                goto error;
-       }
 
        for (i = 0; i < MAX_TRANSAREAS; ++i)    // Initialise the wait queues
        {

diff --git a/drivers/staging/comedi/drivers.c b/drivers/staging/comedi/drivers.c
index e57e661e1251909b46f3f2a567e02d0a2a077084..64be7c5e891e77855d99c7ec46fa1c85742378bf 100644 (file)
--- a/drivers/staging/comedi/drivers.c
+++ b/drivers/staging/comedi/drivers.c
@@ -203,10 +203,9 @@ static int __comedi_device_postconfig_async(struct comedi_device *dev,
        }
 
        async = kzalloc(sizeof(*async), GFP_KERNEL);
-       if (!async) {
-               dev_warn(dev->class_dev, "failed to allocate async struct\n");
+       if (!async)
                return -ENOMEM;
-       }
+
        init_waitqueue_head(&async->wait_head);
        async->subdevice = s;
        s->async = async;

diff --git a/drivers/staging/comedi/drivers/amplc_dio200.c b/drivers/staging/comedi/drivers/amplc_dio200.c
index b30d1a05c33cd3d07e9a9593d87fc805743e72a7..7c53dea12c7670fa015b0bf2b5ff1782606b5c3e 100644 (file)
--- a/drivers/staging/comedi/drivers/amplc_dio200.c
+++ b/drivers/staging/comedi/drivers/amplc_dio200.c
@@ -1105,10 +1105,9 @@ dio200_subdev_intr_init(struct comedi_device *dev, struct comedi_subdevice *s,
        struct dio200_subdev_intr *subpriv;
 
        subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
-       if (!subpriv) {
-               dev_err(dev->class_dev, "error! out of memory!\n");
+       if (!subpriv)
                return -ENOMEM;
-       }
+
        subpriv->ofs = offset;
        subpriv->valid_isns = valid_isns;
        spin_lock_init(&subpriv->spinlock);
@@ -1444,10 +1443,8 @@ dio200_subdev_8254_init(struct comedi_device *dev, struct comedi_subdevice *s,
        unsigned int chan;
 
        subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
-       if (!subpriv) {
-               dev_err(dev->class_dev, "error! out of memory!\n");
+       if (!subpriv)
                return -ENOMEM;
-       }
 
        s->private = subpriv;
        s->type = COMEDI_SUBD_COUNTER;

diff --git a/drivers/staging/comedi/drivers/comedi_bond.c b/drivers/staging/comedi/drivers/comedi_bond.c
index 31515999bb97e47b153c4848d192a62321cc3084..1bb53816eca3ef80e67d12f73ca43ba01559f470 100644 (file)
--- a/drivers/staging/comedi/drivers/comedi_bond.c
+++ b/drivers/staging/comedi/drivers/comedi_bond.c
@@ -245,10 +245,9 @@ static int doDevConfig(struct comedi_device *dev, struct comedi_devconfig *it)
                                return 0;
                        }
                        bdev = kmalloc(sizeof(*bdev), GFP_KERNEL);
-                       if (!bdev) {
-                               dev_err(dev->class_dev, "Out of memory\n");
+                       if (!bdev)
                                return 0;
-                       }
+
                        bdev->dev = d;
                        bdev->minor = minor;
                        bdev->subdev = sdev;

diff --git a/drivers/staging/comedi/drivers/dt9812.c b/drivers/staging/comedi/drivers/dt9812.c
index fc5b30c70737be9687f94048c603a3bfbf538df4..192cf088f834a07c2388b50f0cc357e9f9298d36 100644 (file)
--- a/drivers/staging/comedi/drivers/dt9812.c
+++ b/drivers/staging/comedi/drivers/dt9812.c
@@ -702,10 +702,9 @@ static int dt9812_probe(struct usb_interface *interface,
 
        /* allocate memory for our device state and initialize it */
        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-       if (dev == NULL) {
-               dev_err(&interface->dev, "Out of memory\n");
+       if (dev == NULL)
                goto error;
-       }
+
        kref_init(&dev->kref);
 
        dev->udev = usb_get_dev(interface_to_usbdev(interface));

diff --git a/drivers/staging/comedi/drivers/ni_labpc.c b/drivers/staging/comedi/drivers/ni_labpc.c
index f851c54b0c33a8fda045ad12dac335e54f14e8d9..f957b8859b3d05873305e053a25cce3f8ed3aed7 100644 (file)
--- a/drivers/staging/comedi/drivers/ni_labpc.c
+++ b/drivers/staging/comedi/drivers/ni_labpc.c
@@ -570,13 +570,11 @@ int labpc_common_attach(struct comedi_device *dev, unsigned long iobase,
                return -EINVAL;
        } else if (dma_chan) {
                /* allocate dma buffer */
-               devpriv->dma_buffer =
-                   kmalloc(dma_buffer_size, GFP_KERNEL | GFP_DMA);
-               if (devpriv->dma_buffer == NULL) {
-                       dev_err(dev->class_dev,
-                               "failed to allocate dma buffer\n");
+               devpriv->dma_buffer = kmalloc(dma_buffer_size,
+                                             GFP_KERNEL | GFP_DMA);
+               if (devpriv->dma_buffer == NULL)
                        return -ENOMEM;
-               }
+
                if (request_dma(dma_chan, DRV_NAME)) {
                        dev_err(dev->class_dev,
                                "failed to allocate dma channel %u\n",

diff --git a/drivers/staging/comedi/drivers/pcmuio.c b/drivers/staging/comedi/drivers/pcmuio.c
index 71ef3f90bc98baf53e3e3a83a7259337547b09b9..433270ceda4f05ae2bf5b25dab7e5f3d58406a91 100644 (file)
--- a/drivers/staging/comedi/drivers/pcmuio.c
+++ b/drivers/staging/comedi/drivers/pcmuio.c
@@ -838,14 +838,11 @@ static int pcmuio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 
        chans_left = CHANS_PER_ASIC * board->num_asics;
        n_subdevs = CALC_N_SUBDEVS(chans_left);
-       devpriv->sprivs =
-           kcalloc(n_subdevs, sizeof(struct pcmuio_subdev_private),
-                   GFP_KERNEL);
-       if (!devpriv->sprivs) {
-               dev_warn(dev->class_dev,
-                        "cannot allocate subdevice private data structures\n");
+       devpriv->sprivs = kcalloc(n_subdevs,
+                                 sizeof(struct pcmuio_subdev_private),
+                                 GFP_KERNEL);
+       if (!devpriv->sprivs)
                return -ENOMEM;
-       }
 
        ret = comedi_alloc_subdevices(dev, n_subdevs);
        if (ret)

diff --git a/drivers/staging/comedi/drivers/unioxx5.c b/drivers/staging/comedi/drivers/unioxx5.c
index c9ded938314fc019c4588637488b53d16ae818e8..74b974bf10324ae96cfc52ca78707409b757321f 100644 (file)
--- a/drivers/staging/comedi/drivers/unioxx5.c
+++ b/drivers/staging/comedi/drivers/unioxx5.c
@@ -380,12 +380,8 @@ static int __unioxx5_subdev_init(struct comedi_subdevice *subdev,
        }
 
        usp = kzalloc(sizeof(*usp), GFP_KERNEL);
-
-       if (usp == NULL) {
-               dev_err(subdev->class_dev,
-                       "comedi%d: error! --> out of memory!\n", minor);
+       if (usp == NULL)
                return -1;
-       }
 
        usp->usp_iobase = subdev_iobase;
        dev_info(subdev->class_dev, "comedi%d: |", minor);

diff --git a/drivers/staging/comedi/drivers/usbdux.c b/drivers/staging/comedi/drivers/usbdux.c
index 7c2f8568ebb3e933a68db492c01d925a0c3f6084..1a0062a04456c54c517acc7d73454014555a7611 100644 (file)
--- a/drivers/staging/comedi/drivers/usbdux.c
+++ b/drivers/staging/comedi/drivers/usbdux.c
@@ -2445,8 +2445,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
        /* create space for the commands of the DA converter */
        usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
        if (!usbduxsub[index].dac_commands) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "error alloc space for dac commands\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2454,8 +2452,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
        /* create space for the commands going to the usb device */
        usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
        if (!usbduxsub[index].dux_commands) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "error alloc space for dux commands\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2463,8 +2459,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
        /* create space for the in buffer and set it to zero */
        usbduxsub[index].inBuffer = kzalloc(SIZEINBUF, GFP_KERNEL);
        if (!(usbduxsub[index].inBuffer)) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "could not alloc space for inBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2472,8 +2466,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
        /* create space of the instruction buffer */
        usbduxsub[index].insnBuffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
        if (!(usbduxsub[index].insnBuffer)) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "could not alloc space for insnBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2481,8 +2473,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
        /* create space for the outbuffer */
        usbduxsub[index].outBuffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
        if (!(usbduxsub[index].outBuffer)) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "could not alloc space for outBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2504,10 +2494,9 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL;
 
        usbduxsub[index].urbIn =
-           kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfInBuffers,
-                   GFP_KERNEL);
+               kcalloc(usbduxsub[index].numOfInBuffers, sizeof(struct urb *),
+                       GFP_KERNEL);
        if (!(usbduxsub[index].urbIn)) {
-               dev_err(dev, "comedi_: usbdux: Could not alloc. urbIn array\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2532,8 +2521,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbIn[i]->transfer_buffer =
                    kzalloc(SIZEINBUF, GFP_KERNEL);
                if (!(usbduxsub[index].urbIn[i]->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbdux%d: "
-                               "could not alloc. transb.\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;
@@ -2552,11 +2539,9 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL;
 
        usbduxsub[index].urbOut =
-           kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfOutBuffers,
-                   GFP_KERNEL);
+               kcalloc(usbduxsub[index].numOfOutBuffers, sizeof(struct urb *),
+                       GFP_KERNEL);
        if (!(usbduxsub[index].urbOut)) {
-               dev_err(dev, "comedi_: usbdux: "
-                       "Could not alloc. urbOut array\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2581,8 +2566,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbOut[i]->transfer_buffer =
                    kzalloc(SIZEOUTBUF, GFP_KERNEL);
                if (!(usbduxsub[index].urbOut[i]->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbdux%d: "
-                               "could not alloc. transb.\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;
@@ -2617,8 +2600,6 @@ static int usbdux_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbPwm->transfer_buffer =
                    kzalloc(usbduxsub[index].sizePwmBuf, GFP_KERNEL);
                if (!(usbduxsub[index].urbPwm->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbdux%d: "
-                               "could not alloc. transb. for pwm\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;

diff --git a/drivers/staging/comedi/drivers/usbduxfast.c b/drivers/staging/comedi/drivers/usbduxfast.c
index 0f6187f96caa8028757632d3bb27379b66405ccc..4bf5dd094dc9da043b2aea8302c6638e229cf926 100644 (file)
--- a/drivers/staging/comedi/drivers/usbduxfast.c
+++ b/drivers/staging/comedi/drivers/usbduxfast.c
@@ -1556,8 +1556,6 @@ static int usbduxfast_usb_probe(struct usb_interface *uinterf,
        usbduxfastsub[index].dux_commands = kmalloc(SIZEOFDUXBUFFER,
                                                    GFP_KERNEL);
        if (!usbduxfastsub[index].dux_commands) {
-               dev_err(&uinterf->dev,
-                       "error alloc space for dac commands\n");
                tidy_up(&(usbduxfastsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -1565,8 +1563,6 @@ static int usbduxfast_usb_probe(struct usb_interface *uinterf,
        /* create space of the instruction buffer */
        usbduxfastsub[index].insnBuffer = kmalloc(SIZEINSNBUF, GFP_KERNEL);
        if (!usbduxfastsub[index].insnBuffer) {
-               dev_err(&uinterf->dev,
-                       "could not alloc space for insnBuffer\n");
                tidy_up(&(usbduxfastsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -1592,8 +1588,6 @@ static int usbduxfast_usb_probe(struct usb_interface *uinterf,
        }
        usbduxfastsub[index].transfer_buffer = kmalloc(SIZEINBUF, GFP_KERNEL);
        if (!usbduxfastsub[index].transfer_buffer) {
-               dev_err(&uinterf->dev,
-                       "usbduxfast%d: could not alloc. transb.\n", index);
                tidy_up(&(usbduxfastsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;

diff --git a/drivers/staging/comedi/drivers/usbduxsigma.c b/drivers/staging/comedi/drivers/usbduxsigma.c
index dc6b0174ad71b4e827ce20499462fa827c516a81..d066351a71b2793d4f1ad60dd27e8db7dd0ea0e7 100644 (file)
--- a/drivers/staging/comedi/drivers/usbduxsigma.c
+++ b/drivers/staging/comedi/drivers/usbduxsigma.c
@@ -2431,8 +2431,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        /* create space for the commands of the DA converter */
        usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
        if (!usbduxsub[index].dac_commands) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "error alloc space for dac commands\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2440,8 +2438,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        /* create space for the commands going to the usb device */
        usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
        if (!usbduxsub[index].dux_commands) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "error alloc space for dux commands\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2449,8 +2445,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        /* create space for the in buffer and set it to zero */
        usbduxsub[index].inBuffer = kzalloc(SIZEINBUF, GFP_KERNEL);
        if (!(usbduxsub[index].inBuffer)) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "could not alloc space for inBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2458,8 +2452,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        /* create space of the instruction buffer */
        usbduxsub[index].insnBuffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
        if (!(usbduxsub[index].insnBuffer)) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "could not alloc space for insnBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2467,8 +2459,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        /* create space for the outbuffer */
        usbduxsub[index].outBuffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
        if (!(usbduxsub[index].outBuffer)) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "could not alloc space for outBuffer\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2489,12 +2479,10 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        else
                usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL;
 
-       usbduxsub[index].urbIn =
-           kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfInBuffers,
-                   GFP_KERNEL);
+       usbduxsub[index].urbIn = kcalloc(usbduxsub[index].numOfInBuffers,
+                                        sizeof(struct urb *),
+                                        GFP_KERNEL);
        if (!(usbduxsub[index].urbIn)) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "Could not alloc. urbIn array\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2519,8 +2507,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbIn[i]->transfer_buffer =
                    kzalloc(SIZEINBUF, GFP_KERNEL);
                if (!(usbduxsub[index].urbIn[i]->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbduxsigma%d: "
-                               "could not alloc. transb.\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;
@@ -2539,12 +2525,9 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
        else
                usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL;
 
-       usbduxsub[index].urbOut =
-           kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfOutBuffers,
-                   GFP_KERNEL);
+       usbduxsub[index].urbOut = kcalloc(usbduxsub[index].numOfOutBuffers,
+                                         sizeof(struct urb *), GFP_KERNEL);
        if (!(usbduxsub[index].urbOut)) {
-               dev_err(dev, "comedi_: usbduxsigma: "
-                       "Could not alloc. urbOut array\n");
                tidy_up(&(usbduxsub[index]));
                up(&start_stop_sem);
                return -ENOMEM;
@@ -2569,8 +2552,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbOut[i]->transfer_buffer =
                    kzalloc(SIZEOUTBUF, GFP_KERNEL);
                if (!(usbduxsub[index].urbOut[i]->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbduxsigma%d: "
-                               "could not alloc. transb.\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;
@@ -2606,8 +2587,6 @@ static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
                usbduxsub[index].urbPwm->transfer_buffer =
                    kzalloc(usbduxsub[index].sizePwmBuf, GFP_KERNEL);
                if (!(usbduxsub[index].urbPwm->transfer_buffer)) {
-                       dev_err(dev, "comedi_: usbduxsigma%d: "
-                               "could not alloc. transb. for pwm\n", index);
                        tidy_up(&(usbduxsub[index]));
                        up(&start_stop_sem);
                        return -ENOMEM;

diff --git a/drivers/staging/cptm1217/clearpad_tm1217.c b/drivers/staging/cptm1217/clearpad_tm1217.c
index a49b0da60049eb05043e7f5129e90a46b40a6621..31fb5d31bb3addacf373aeb8ed9d002e26a2dc85 100644 (file)
--- a/drivers/staging/cptm1217/clearpad_tm1217.c
+++ b/drivers/staging/cptm1217/clearpad_tm1217.c
@@ -421,11 +421,8 @@ static int cp_tm1217_probe(struct i2c_client *client,
        pdata = client->dev.platform_data;
 
        ts = kzalloc(sizeof(struct cp_tm1217_device), GFP_KERNEL);
-       if (!ts) {
-               dev_err(&client->dev,
-                       "cp_tm1217: Private Device Struct alloc failed\n");
+       if (!ts)
                return -ENOMEM;
-       }
 
        ts->client = client;
        ts->dev = &client->dev;

diff --git a/drivers/staging/et131x/et131x.c b/drivers/staging/et131x/et131x.c
index 4a7c302666ce9d5509e1ea19f58a651ddf3ac835..ebf5e49628784fa993533605392ab504163e85ff 100644 (file)
--- a/drivers/staging/et131x/et131x.c
+++ b/drivers/staging/et131x/et131x.c
@@ -2462,11 +2462,8 @@ static int et131x_init_recv(struct et131x_adapter *adapter)
        /* Setup each RFD */
        for (rfdct = 0; rfdct < rx_ring->num_rfd; rfdct++) {
                rfd = kzalloc(sizeof(struct rfd), GFP_ATOMIC | GFP_DMA);
-
-               if (!rfd) {
-                       dev_err(&adapter->pdev->dev, "Couldn't alloc RFD\n");
+               if (!rfd)
                        return -ENOMEM;
-               }
 
                rfd->skb = NULL;
 
@@ -2814,12 +2811,10 @@ static int et131x_tx_dma_memory_alloc(struct et131x_adapter *adapter)
        struct tx_ring *tx_ring = &adapter->tx_ring;
 
        /* Allocate memory for the TCB's (Transmit Control Block) */
-       adapter->tx_ring.tcb_ring =
-               kcalloc(NUM_TCB, sizeof(struct tcb), GFP_ATOMIC | GFP_DMA);
-       if (!adapter->tx_ring.tcb_ring) {
-               dev_err(&adapter->pdev->dev, "Cannot alloc memory for TCBs\n");
+       adapter->tx_ring.tcb_ring = kcalloc(NUM_TCB, sizeof(struct tcb),
+                                           GFP_ATOMIC | GFP_DMA);
+       if (!adapter->tx_ring.tcb_ring)
                return -ENOMEM;
-       }
 
        desc_size = (sizeof(struct tx_desc) * NUM_DESC_PER_RING_TX);
        tx_ring->tx_desc_ring =
@@ -4895,11 +4890,10 @@ static int et131x_pci_setup(struct pci_dev *pdev,
        adapter->mii_bus->read = et131x_mdio_read;
        adapter->mii_bus->write = et131x_mdio_write;
        adapter->mii_bus->reset = et131x_mdio_reset;
-       adapter->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
-       if (!adapter->mii_bus->irq) {
-               dev_err(&pdev->dev, "mii_bus irq allocation failed\n");
+       adapter->mii_bus->irq = kmalloc_array(PHY_MAX_ADDR, sizeof(int),
+                                             GFP_KERNEL);
+       if (!adapter->mii_bus->irq)
                goto err_mdio_free;
-       }
 
        for (ii = 0; ii < PHY_MAX_ADDR; ii++)
                adapter->mii_bus->irq[ii] = PHY_POLL;

diff --git a/drivers/staging/frontier/alphatrack.c b/drivers/staging/frontier/alphatrack.c
index 33085782689ed8c5a82f426bf7f088d974811ad8..ea9362d7e589b14c2b236bbe10ef688409ff965c 100644 (file)
--- a/drivers/staging/frontier/alphatrack.c
+++ b/drivers/staging/frontier/alphatrack.c
@@ -678,10 +678,9 @@ static int usb_alphatrack_probe(struct usb_interface *intf,
        /* allocate memory for our device state and initialize it */
 
        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-       if (dev == NULL) {
-               dev_err(&intf->dev, "Out of memory\n");
+       if (dev == NULL)
                goto exit;
-       }
+
        mutex_init(&dev->mtx);
        dev->intf = intf;
        init_waitqueue_head(&dev->read_wait);
@@ -721,28 +720,21 @@ static int usb_alphatrack_probe(struct usb_interface *intf,
 
        /* FIXME - there are more usb_alloc routines for dma correctness.
           Needed? */
-       dev->ring_buffer =
-           kmalloc((true_size * sizeof(struct alphatrack_icmd)), GFP_KERNEL);
-
-       if (!dev->ring_buffer) {
-               dev_err(&intf->dev,
-                       "Couldn't allocate input ring_buffer of size %d\n",
-                       true_size);
+       dev->ring_buffer = kmalloc_array(true_size,
+                                        sizeof(struct alphatrack_icmd),
+                                        GFP_KERNEL);
+       if (!dev->ring_buffer)
                goto error;
-       }
 
-       dev->interrupt_in_buffer =
-           kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
-
-       if (!dev->interrupt_in_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n");
+       dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size,
+                                          GFP_KERNEL);
+       if (!dev->interrupt_in_buffer)
                goto error;
-       }
+
        dev->oldi_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
-       if (!dev->oldi_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate old buffer\n");
+       if (!dev->oldi_buffer)
                goto error;
-       }
+
        dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!dev->interrupt_in_urb) {
                dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n");
@@ -764,20 +756,17 @@ static int usb_alphatrack_probe(struct usb_interface *intf,
        true_size = min(write_buffer_size, WRITE_BUFFER_SIZE);
 
        dev->interrupt_out_buffer =
-           kmalloc(true_size * dev->interrupt_out_endpoint_size, GFP_KERNEL);
-
-       if (!dev->interrupt_out_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n");
+               kmalloc_array(true_size,
+                             dev->interrupt_out_endpoint_size,
+                             GFP_KERNEL);
+       if (!dev->interrupt_out_buffer)
                goto error;
-       }
-
-       dev->write_buffer =
-           kmalloc(true_size * sizeof(struct alphatrack_ocmd), GFP_KERNEL);
 
-       if (!dev->write_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate write_buffer\n");
+       dev->write_buffer = kmalloc_array(true_size,
+                                         sizeof(struct alphatrack_ocmd),
+                                         GFP_KERNEL);
+       if (!dev->write_buffer)
                goto error;
-       }
 
        dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!dev->interrupt_out_urb) {

diff --git a/drivers/staging/frontier/tranzport.c b/drivers/staging/frontier/tranzport.c
index 5196a4e053e6f96d8112677ee89db5f7e53e9bd2..04b5e66d986162250d377de896d2202b9fbeb49f 100644 (file)
--- a/drivers/staging/frontier/tranzport.c
+++ b/drivers/staging/frontier/tranzport.c
@@ -803,10 +803,9 @@ static int usb_tranzport_probe(struct usb_interface *intf,
        /* allocate memory for our device state and initialize it */
 
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-       if (dev == NULL) {
-               dev_err(&intf->dev, "Out of memory\n");
+       if (dev == NULL)
                goto exit;
-       }
+
        mutex_init(&dev->mtx);
        dev->intf = intf;
        init_waitqueue_head(&dev->read_wait);
@@ -848,18 +847,14 @@ static int usb_tranzport_probe(struct usb_interface *intf,
 
        dev->ring_buffer =
            kmalloc((true_size * sizeof(struct tranzport_cmd)) + 8, GFP_KERNEL);
-
-       if (!dev->ring_buffer) {
-               dev_err(&intf->dev,
-                       "Couldn't allocate ring_buffer size %d\n", true_size);
+       if (!dev->ring_buffer)
                goto error;
-       }
+
        dev->interrupt_in_buffer =
            kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
-       if (!dev->interrupt_in_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n");
+       if (!dev->interrupt_in_buffer)
                goto error;
-       }
+
        dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!dev->interrupt_in_urb) {
                dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n");
@@ -875,12 +870,11 @@ static int usb_tranzport_probe(struct usb_interface *intf,
                         "Interrupt out endpoint size is not 8!)\n");
 
        dev->interrupt_out_buffer =
-           kmalloc(write_buffer_size * dev->interrupt_out_endpoint_size,
-                   GFP_KERNEL);
-       if (!dev->interrupt_out_buffer) {
-               dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n");
+               kmalloc_array(write_buffer_size,
+                             dev->interrupt_out_endpoint_size, GFP_KERNEL);
+       if (!dev->interrupt_out_buffer)
                goto error;
-       }
+
        dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!dev->interrupt_out_urb) {
                dev_err(&intf->dev, "Couldn't allocate interrupt_out_urb\n");

diff --git a/drivers/staging/ft1000/ft1000-usb/ft1000_usb.c b/drivers/staging/ft1000/ft1000-usb/ft1000_usb.c
index 1bf3792ffebeac87ce433d2db690347d8d7758d6..614db55a817116156d4137f74ad3ec354262dcb8 100644 (file)
--- a/drivers/staging/ft1000/ft1000-usb/ft1000_usb.c
+++ b/drivers/staging/ft1000/ft1000-usb/ft1000_usb.c
@@ -68,11 +68,8 @@ static int ft1000_probe(struct usb_interface *interface,
        const struct firmware *dsp_fw;
 
        ft1000dev = kzalloc(sizeof(struct ft1000_usb), GFP_KERNEL);
-
-       if (!ft1000dev) {
-               pr_err("out of memory allocating device structure\n");
+       if (!ft1000dev)
                return -ENOMEM;
-       }
 
        dev = interface_to_usbdev(interface);
        DEBUG("ft1000_probe: usb device descriptor info:\n");

diff --git a/drivers/staging/gdm72xx/gdm_sdio.c b/drivers/staging/gdm72xx/gdm_sdio.c
index 8b8ed981d102bbbe3f8e35c07cf993dbc2f0c62f..695762b0e942c9782155d430d2b14f399e450f21 100644 (file)
--- a/drivers/staging/gdm72xx/gdm_sdio.c
+++ b/drivers/staging/gdm72xx/gdm_sdio.c
@@ -156,10 +156,8 @@ static int init_sdio(struct sdiowm_dev *sdev)
        spin_lock_init(&tx->lock);
 
        tx->sdu_buf = kmalloc(SDU_TX_BUF_SIZE, GFP_KERNEL);
-       if (tx->sdu_buf == NULL) {
-               dev_err(&sdev->func->dev, "Failed to allocate SDU tx buffer.\n");
+       if (tx->sdu_buf == NULL)
                goto fail;
-       }
 
        for (i = 0; i < MAX_NR_SDU_BUF; i++) {
                t = alloc_tx_struct(tx);
@@ -185,10 +183,8 @@ static int init_sdio(struct sdiowm_dev *sdev)
        }
 
        rx->rx_buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
-       if (rx->rx_buf == NULL) {
-               dev_err(&sdev->func->dev, "Failed to allocate rx buffer.\n");
+       if (rx->rx_buf == NULL)
                goto fail;
-       }
 
        return 0;
 

diff --git a/drivers/staging/gdm72xx/sdio_boot.c b/drivers/staging/gdm72xx/sdio_boot.c
index 6291829dcdcc89007bdf6b1a54b0dc080cef064d..93046dda78f0c2e72d99e30a5b48cea5065c81b3 100644 (file)
--- a/drivers/staging/gdm72xx/sdio_boot.c
+++ b/drivers/staging/gdm72xx/sdio_boot.c
@@ -72,10 +72,8 @@ static int download_image(struct sdio_func *func, const char *img_name)
        }
 
        buf = kmalloc(DOWNLOAD_SIZE + TYPE_A_HEADER_SIZE, GFP_KERNEL);
-       if (buf == NULL) {
-               dev_err(&func->dev, "Error: kmalloc\n");
+       if (buf == NULL)
                return -ENOMEM;
-       }
 
        img_len = firm->size;
 
@@ -141,11 +139,8 @@ int sdio_boot(struct sdio_func *func)
        const char *rfs_name = FW_DIR FW_RFS;
 
        tx_buf = kmalloc(YMEM0_SIZE, GFP_KERNEL);
-       if (tx_buf == NULL) {
-               dev_err(&func->dev, "Error: kmalloc: %s %d\n",
-                       __func__, __LINE__);
+       if (tx_buf == NULL)
                return -ENOMEM;
-       }
 
        ret = download_image(func, krn_name);
        if (ret)

diff --git a/drivers/staging/gdm72xx/usb_boot.c b/drivers/staging/gdm72xx/usb_boot.c
index 3e2103ae4eaefdeb66a6ebc58450fff28d037173..0d45eb680be51ff23bed9ba853d0cbf0c1479656 100644 (file)
--- a/drivers/staging/gdm72xx/usb_boot.c
+++ b/drivers/staging/gdm72xx/usb_boot.c
@@ -158,10 +158,8 @@ int usb_boot(struct usb_device *usbdev, u16 pid)
        }
 
        tx_buf = kmalloc(DOWNLOAD_SIZE, GFP_KERNEL);
-       if (tx_buf == NULL) {
-               dev_err(&usbdev->dev, "Error: kmalloc\n");
+       if (tx_buf == NULL)
                return -ENOMEM;
-       }
 
        if (firm->size < sizeof(hdr)) {
                dev_err(&usbdev->dev, "Cannot read the image info.\n");
@@ -301,10 +299,8 @@ static int em_download_image(struct usb_device *usbdev, const char *img_name,
        }
 
        buf = kmalloc(DOWNLOAD_CHUCK + pad_size, GFP_KERNEL);
-       if (buf == NULL) {
-               dev_err(&usbdev->dev, "Error: kmalloc\n");
+       if (buf == NULL)
                return -ENOMEM;
-       }
 
        strcpy(buf+pad_size, type_string);
        ret = gdm_wibro_send(usbdev, buf, strlen(type_string)+pad_size);

diff --git a/drivers/staging/iio/accel/lis3l02dq_ring.c b/drivers/staging/iio/accel/lis3l02dq_ring.c
index 6861877c39143fda93d462e1932821e9544c4d00..e676403ea3ea6cbc3dff62d7a720d6786314e474 100644 (file)
--- a/drivers/staging/iio/accel/lis3l02dq_ring.c
+++ b/drivers/staging/iio/accel/lis3l02dq_ring.c
@@ -140,11 +140,8 @@ static irqreturn_t lis3l02dq_trigger_handler(int irq, void *p)
        char *data;
 
        data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
-       if (data == NULL) {
-               dev_err(indio_dev->dev.parent,
-                       "memory alloc failed in buffer bh");
+       if (data == NULL)
                goto done;
-       }
 
        if (!bitmap_empty(indio_dev->active_scan_mask, indio_dev->masklength))
                len = lis3l02dq_get_buffer_element(indio_dev, data);

diff --git a/drivers/staging/keucr/usb.c b/drivers/staging/keucr/usb.c
index 4dec93d046fae3e82f12ef52ce911cd2ca945449..f656f8aeeda31117003eace68b9eb6f9564d37d5 100644 (file)
--- a/drivers/staging/keucr/usb.c
+++ b/drivers/staging/keucr/usb.c
@@ -266,10 +266,9 @@ static int associate_dev(struct us_data *us, struct usb_interface *intf)
        }
 
        us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
-       if (!us->sensebuf) {
-               pr_info("Sense buffer allocation failed\n");
+       if (!us->sensebuf)
                return -ENOMEM;
-       }
+
        return 0;
 }
 

diff --git a/drivers/staging/line6/driver.c b/drivers/staging/line6/driver.c
index 9f9a21a7413929fa6721efa29f0c1933c9b87a18..6252aca828662101a835e6945208323c7e54ef71 100644 (file)
--- a/drivers/staging/line6/driver.c
+++ b/drivers/staging/line6/driver.c
@@ -233,11 +233,8 @@ int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer,
 
        /* create message: */
        msg = kmalloc(sizeof(struct message), GFP_ATOMIC);
-
-       if (msg == NULL) {
-               dev_err(line6->ifcdev, "Out of memory\n");
+       if (msg == NULL)
                return -ENOMEM;
-       }
 
        /* create URB: */
        urb = usb_alloc_urb(0, GFP_ATOMIC);
@@ -300,10 +297,8 @@ char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2,
 {
        char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC);
 
-       if (!buffer) {
-               dev_err(line6->ifcdev, "out of memory\n");
+       if (!buffer)
                return NULL;
-       }
 
        buffer[0] = LINE6_SYSEX_BEGIN;
        memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));
@@ -403,11 +398,8 @@ int line6_send_program(struct usb_line6 *line6, u8 value)
        int partial;
 
        buffer = kmalloc(2, GFP_KERNEL);
-
-       if (!buffer) {
-               dev_err(line6->ifcdev, "out of memory\n");
+       if (!buffer)
                return -ENOMEM;
-       }
 
        buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;
        buffer[1] = value;
@@ -435,11 +427,8 @@ int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value)
        int partial;
 
        buffer = kmalloc(3, GFP_KERNEL);
-
-       if (!buffer) {
-               dev_err(line6->ifcdev, "out of memory\n");
+       if (!buffer)
                return -ENOMEM;
-       }
 
        buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;
        buffer[1] = param;
@@ -834,9 +823,7 @@ static int line6_probe(struct usb_interface *interface,
        }
 
        line6 = kzalloc(size, GFP_KERNEL);
-
        if (line6 == NULL) {
-               dev_err(&interface->dev, "Out of memory\n");
                ret = -ENODEV;
                goto err_put;
        }
@@ -875,18 +862,14 @@ static int line6_probe(struct usb_interface *interface,
                /* initialize USB buffers: */
                line6->buffer_listen =
                    kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
-
                if (line6->buffer_listen == NULL) {
-                       dev_err(&interface->dev, "Out of memory\n");
                        ret = -ENOMEM;
                        goto err_destruct;
                }
 
                line6->buffer_message =
                    kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
-
                if (line6->buffer_message == NULL) {
-                       dev_err(&interface->dev, "Out of memory\n");
                        ret = -ENOMEM;
                        goto err_destruct;
                }

diff --git a/drivers/staging/line6/pcm.c b/drivers/staging/line6/pcm.c
index 17969c656648ee8c8c8b0c20356e95d3370e5bed..02f77d74809f3d15572c82ad44b79ebac2dc33b0 100644 (file)
--- a/drivers/staging/line6/pcm.c
+++ b/drivers/staging/line6/pcm.c
@@ -121,10 +121,7 @@ int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int channels)
                        line6pcm->buffer_in =
                                kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
                                        line6pcm->max_packet_size, GFP_KERNEL);
-
                        if (!line6pcm->buffer_in) {
-                               dev_err(line6pcm->line6->ifcdev,
-                                       "cannot malloc capture buffer\n");
                                err = -ENOMEM;
                                goto pcm_acquire_error;
                        }
@@ -160,10 +157,7 @@ int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int channels)
                        line6pcm->buffer_out =
                                kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
                                        line6pcm->max_packet_size, GFP_KERNEL);
-
                        if (!line6pcm->buffer_out) {
-                               dev_err(line6pcm->line6->ifcdev,
-                                       "cannot malloc playback buffer\n");
                                err = -ENOMEM;
                                goto pcm_acquire_error;
                        }

diff --git a/drivers/staging/omapdrm/omap_connector.c b/drivers/staging/omapdrm/omap_connector.c
index 4cc9ee733c5fb4a80c656ad978ca6a349e07b8dc..8979c80adb5febac4e5a49c1ed3fd4480ea1930f 100644 (file)
--- a/drivers/staging/omapdrm/omap_connector.c
+++ b/drivers/staging/omapdrm/omap_connector.c
@@ -261,10 +261,8 @@ struct drm_connector *omap_connector_init(struct drm_device *dev,
        omap_dss_get_device(dssdev);
 
        omap_connector = kzalloc(sizeof(struct omap_connector), GFP_KERNEL);
-       if (!omap_connector) {
-               dev_err(dev->dev, "could not allocate connector\n");
+       if (!omap_connector)
                goto fail;
-       }
 
        omap_connector->dssdev = dssdev;
        omap_connector->encoder = encoder;

diff --git a/drivers/staging/omapdrm/omap_crtc.c b/drivers/staging/omapdrm/omap_crtc.c
index 5c6ed6040eff572a384659561e1fdbaf427c883c..32109c09357c8c544abb6cb1ef991843d4b0d53d 100644 (file)
--- a/drivers/staging/omapdrm/omap_crtc.c
+++ b/drivers/staging/omapdrm/omap_crtc.c
@@ -601,11 +601,8 @@ struct drm_crtc *omap_crtc_init(struct drm_device *dev,
        DBG("%s", channel_names[channel]);
 
        omap_crtc = kzalloc(sizeof(*omap_crtc), GFP_KERNEL);
-
-       if (!omap_crtc) {
-               dev_err(dev->dev, "could not allocate CRTC\n");
+       if (!omap_crtc)
                goto fail;
-       }
 
        crtc = &omap_crtc->base;
 

diff --git a/drivers/staging/omapdrm/omap_dmm_tiler.c b/drivers/staging/omapdrm/omap_dmm_tiler.c
index 3910215371053037aff61580939cd8596298e9eb..9b794c933c811dde3289f760be63bf1e026cd71c 100644 (file)
--- a/drivers/staging/omapdrm/omap_dmm_tiler.c
+++ b/drivers/staging/omapdrm/omap_dmm_tiler.c
@@ -581,10 +581,8 @@ static int omap_dmm_probe(struct platform_device *dev)
        struct resource *mem;
 
        omap_dmm = kzalloc(sizeof(*omap_dmm), GFP_KERNEL);
-       if (!omap_dmm) {
-               dev_err(&dev->dev, "failed to allocate driver data section\n");
+       if (!omap_dmm)
                goto fail;
-       }
 
        /* initialize lists */
        INIT_LIST_HEAD(&omap_dmm->alloc_head);
@@ -681,11 +679,9 @@ static int omap_dmm_probe(struct platform_device *dev)
        }
 
        /* alloc engines */
-       omap_dmm->engines = kzalloc(
-                       omap_dmm->num_engines * sizeof(struct refill_engine),
-                       GFP_KERNEL);
+       omap_dmm->engines = kcalloc(omap_dmm->num_engines,
+                                   sizeof(struct refill_engine), GFP_KERNEL);
        if (!omap_dmm->engines) {
-               dev_err(&dev->dev, "could not allocate engines\n");
                ret = -ENOMEM;
                goto fail;
        }
@@ -702,10 +698,9 @@ static int omap_dmm_probe(struct platform_device *dev)
                list_add(&omap_dmm->engines[i].idle_node, &omap_dmm->idle_head);
        }
 
-       omap_dmm->tcm = kzalloc(omap_dmm->num_lut * sizeof(*omap_dmm->tcm),
+       omap_dmm->tcm = kcalloc(omap_dmm->num_lut, sizeof(*omap_dmm->tcm),
                                GFP_KERNEL);
        if (!omap_dmm->tcm) {
-               dev_err(&dev->dev, "failed to allocate lut ptrs\n");
                ret = -ENOMEM;
                goto fail;
        }

diff --git a/drivers/staging/omapdrm/omap_drv.c b/drivers/staging/omapdrm/omap_drv.c
index d246f8543d2ee20b8fe5df7a9386d969da1dba95..480dc343446cc59aca8d6101684ac574e69a5459 100644 (file)
--- a/drivers/staging/omapdrm/omap_drv.c
+++ b/drivers/staging/omapdrm/omap_drv.c
@@ -335,10 +335,8 @@ static int dev_load(struct drm_device *dev, unsigned long flags)
        DBG("load: dev=%p", dev);
 
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv) {
-               dev_err(dev->dev, "could not allocate priv\n");
+       if (!priv)
                return -ENOMEM;
-       }
 
        priv->omaprev = pdata->omaprev;
 

diff --git a/drivers/staging/omapdrm/omap_encoder.c b/drivers/staging/omapdrm/omap_encoder.c
index e053160d2db38c9fd6d77bea4971e22635ef18ad..25fc0c7b4f6dd314a1155e8394b888347555b0e0 100644 (file)
--- a/drivers/staging/omapdrm/omap_encoder.c
+++ b/drivers/staging/omapdrm/omap_encoder.c
@@ -147,10 +147,8 @@ struct drm_encoder *omap_encoder_init(struct drm_device *dev,
        struct omap_encoder *omap_encoder;
 
        omap_encoder = kzalloc(sizeof(*omap_encoder), GFP_KERNEL);
-       if (!omap_encoder) {
-               dev_err(dev->dev, "could not allocate encoder\n");
+       if (!omap_encoder)
                goto fail;
-       }
 
        omap_encoder->dssdev = dssdev;
 

diff --git a/drivers/staging/omapdrm/omap_fb.c b/drivers/staging/omapdrm/omap_fb.c
index 09028e9c1093e247476d4be7fa7684395bede40f..bb4969942148e67d785b48126d515220c9689d81 100644 (file)
--- a/drivers/staging/omapdrm/omap_fb.c
+++ b/drivers/staging/omapdrm/omap_fb.c
@@ -418,7 +418,6 @@ struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev,
 
        omap_fb = kzalloc(sizeof(*omap_fb), GFP_KERNEL);
        if (!omap_fb) {
-               dev_err(dev->dev, "could not allocate fb\n");
                ret = -ENOMEM;
                goto fail;
        }

diff --git a/drivers/staging/omapdrm/omap_fbdev.c b/drivers/staging/omapdrm/omap_fbdev.c
index 8a027bb77d97c8c3fe04a6e0398c8e74aced86ae..70f2d6ed2ed37a9ec0060fbb8dd9370d50b71b9e 100644 (file)
--- a/drivers/staging/omapdrm/omap_fbdev.c
+++ b/drivers/staging/omapdrm/omap_fbdev.c
@@ -348,10 +348,8 @@ struct drm_fb_helper *omap_fbdev_init(struct drm_device *dev)
        int ret = 0;
 
        fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
-       if (!fbdev) {
-               dev_err(dev->dev, "could not allocate fbdev\n");
+       if (!fbdev)
                goto fail;
-       }
 
        INIT_WORK(&fbdev->work, pan_worker);
 

diff --git a/drivers/staging/omapdrm/omap_gem.c b/drivers/staging/omapdrm/omap_gem.c
index f9297eb2599eb0525f0f456bf39d58dff90c11f8..518d03d4d4f3ea91aa985f990a0bfd52a2dcc109 100644 (file)
--- a/drivers/staging/omapdrm/omap_gem.c
+++ b/drivers/staging/omapdrm/omap_gem.c
@@ -1402,10 +1402,8 @@ struct drm_gem_object *omap_gem_new(struct drm_device *dev,
        }
 
        omap_obj = kzalloc(sizeof(*omap_obj), GFP_KERNEL);
-       if (!omap_obj) {
-               dev_err(dev->dev, "could not allocate GEM object\n");
+       if (!omap_obj)
                goto fail;
-       }
 
        list_add(&omap_obj->mm_list, &priv->obj_list);
 
@@ -1461,11 +1459,9 @@ void omap_gem_init(struct drm_device *dev)
                return;
        }
 
-       usergart = kzalloc(3 * sizeof(*usergart), GFP_KERNEL);
-       if (!usergart) {
-               dev_warn(dev->dev, "could not allocate usergart\n");
+       usergart = kcalloc(3, sizeof(*usergart), GFP_KERNEL);
+       if (!usergart)
                return;
-       }
 
        /* reserve 4k aligned/wide regions for userspace mappings: */
        for (i = 0; i < ARRAY_SIZE(fmts); i++) {

diff --git a/drivers/staging/omapdrm/omap_plane.c b/drivers/staging/omapdrm/omap_plane.c
index bb989d7f026dcafd62f1aba1f5d1877ea34d3d9b..c063476db3bb23397f686af3048ab2bf3cddc344 100644 (file)
--- a/drivers/staging/omapdrm/omap_plane.c
+++ b/drivers/staging/omapdrm/omap_plane.c
@@ -390,10 +390,8 @@ struct drm_plane *omap_plane_init(struct drm_device *dev,
        DBG("%s: priv=%d", plane_names[id], private_plane);
 
        omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
-       if (!omap_plane) {
-               dev_err(dev->dev, "could not allocate plane\n");
+       if (!omap_plane)
                goto fail;
-       }
 
        ret = kfifo_alloc(&omap_plane->unpin_fifo, 16, GFP_KERNEL);
        if (ret) {

diff --git a/drivers/staging/rtl8187se/ieee80211/ieee80211_module.c b/drivers/staging/rtl8187se/ieee80211/ieee80211_module.c
index 4358c4b0ca60b5b55dfc87e96d3869386c42cf2e..07a1fbb6678e94c0ea6662cf7103d7814fc60751 100644 (file)
--- a/drivers/staging/rtl8187se/ieee80211/ieee80211_module.c
+++ b/drivers/staging/rtl8187se/ieee80211/ieee80211_module.c
@@ -68,10 +68,8 @@ static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
        ieee->networks = kcalloc(
                MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
                GFP_KERNEL);
-       if (!ieee->networks) {
-               netdev_warn(ieee->dev,  "Out of memory allocating beacons\n");
+       if (!ieee->networks)
                return -ENOMEM;
-       }
 
        return 0;
 }

diff --git a/drivers/staging/rtl8187se/ieee80211/ieee80211_rx.c b/drivers/staging/rtl8187se/ieee80211/ieee80211_rx.c
index 446f15ec639684424f25219787556688b4cb3df4..e30315997bbe522835e89beb7299529d2b9d4830 100644 (file)
--- a/drivers/staging/rtl8187se/ieee80211/ieee80211_rx.c
+++ b/drivers/staging/rtl8187se/ieee80211/ieee80211_rx.c
@@ -408,11 +408,9 @@ static int is_duplicate_packet(struct ieee80211_device *ieee,
        //      if (memcmp(entry->mac, mac, ETH_ALEN)){
                if (p == &ieee->ibss_mac_hash[index]) {
                        entry = kmalloc(sizeof(struct ieee_ibss_seq), GFP_ATOMIC);
-                       if (!entry) {
-                               netdev_warn(ieee->dev,
-                                           "Cannot malloc new mac entry\n");
+                       if (!entry)
                                return 0;
-                       }
+
                        memcpy(entry->mac, mac, ETH_ALEN);
                        entry->seq_num[tid] = seq;
                        entry->frag_num[tid] = frag;

diff --git a/drivers/staging/sbe-2t3e3/dc.c b/drivers/staging/sbe-2t3e3/dc.c
index daadd6ea4978fffc0c7ee0a3dec3ececbcddbc8a..f207b9e015cec162a10a5a63b72c0bc970e66de2 100644 (file)
--- a/drivers/staging/sbe-2t3e3/dc.c
+++ b/drivers/staging/sbe-2t3e3/dc.c
@@ -315,20 +315,17 @@ static int dc_init_descriptor_list(struct channel *sc)
        struct sk_buff *m;
 
        if (sc->ether.rx_ring == NULL)
-               sc->ether.rx_ring = kzalloc(SBE_2T3E3_RX_DESC_RING_SIZE *
+               sc->ether.rx_ring = kcalloc(SBE_2T3E3_RX_DESC_RING_SIZE,
                                            sizeof(t3e3_rx_desc_t), GFP_KERNEL);
-       if (sc->ether.rx_ring == NULL) {
-               dev_err(&sc->pdev->dev, "SBE 2T3E3: no buffer space for RX ring\n");
+       if (sc->ether.rx_ring == NULL)
                return -ENOMEM;
-       }
 
        if (sc->ether.tx_ring == NULL)
-               sc->ether.tx_ring = kzalloc(SBE_2T3E3_TX_DESC_RING_SIZE *
+               sc->ether.tx_ring = kcalloc(SBE_2T3E3_TX_DESC_RING_SIZE,
                                            sizeof(t3e3_tx_desc_t), GFP_KERNEL);
        if (sc->ether.tx_ring == NULL) {
                kfree(sc->ether.rx_ring);
                sc->ether.rx_ring = NULL;
-               dev_err(&sc->pdev->dev, "SBE 2T3E3: no buffer space for RX ring\n");
                return -ENOMEM;
        }
 

diff --git a/drivers/staging/sbe-2t3e3/module.c b/drivers/staging/sbe-2t3e3/module.c
index ae7af397a99249de4a3ccace32c8f13df85496ce..0e32be5c2471279b3aee8bd22788e1cef8dd9c8a 100644 (file)
--- a/drivers/staging/sbe-2t3e3/module.c
+++ b/drivers/staging/sbe-2t3e3/module.c
@@ -154,11 +154,10 @@ static int t3e3_init_card(struct pci_dev *pdev, const struct pci_device_id *ent)
                /* holds the reference for pdev1 */
        }
 
-       card = kzalloc(sizeof(struct card) + channels * sizeof(struct channel), GFP_KERNEL);
-       if (!card) {
-               dev_err(&pdev->dev, "Out of memory\n");
+       card = kzalloc(sizeof(struct card) + channels * sizeof(struct channel),
+                      GFP_KERNEL);
+       if (!card)
                return -ENOBUFS;
-       }
 
        spin_lock_init(&card->bootrom_lock);
        card->bootrom_addr = pci_resource_start(pdev, 0);

diff --git a/drivers/staging/sep/sep_crypto.c b/drivers/staging/sep/sep_crypto.c
index 861588f57d2bb38ecd1568bf87b1be718412603c..cd3bb39e42556477d66c7b098e42711cd2f41d7e 100644 (file)
--- a/drivers/staging/sep/sep_crypto.c
+++ b/drivers/staging/sep/sep_crypto.c
@@ -178,11 +178,9 @@ static struct scatterlist *sep_alloc_sg_buf(
                nbr_pages += 1;
        }
 
-       sg = kmalloc((sizeof(struct scatterlist) * nbr_pages), GFP_ATOMIC);
-       if (!sg) {
-               dev_warn(&sep->pdev->dev, "Cannot allocate page for new sg\n");
+       sg = kmalloc_array(nbr_pages, sizeof(struct scatterlist), GFP_ATOMIC);
+       if (!sg)
                return NULL;
-       }
 
        sg_init_table(sg, nbr_pages);
 

diff --git a/drivers/staging/sep/sep_main.c b/drivers/staging/sep/sep_main.c
index 15c6e3d9437c13668a61b6532af418c78f194696..30e8d25113e4ab09cf331c6859f8493b521c417d 100644 (file)
--- a/drivers/staging/sep/sep_main.c
+++ b/drivers/staging/sep/sep_main.c
@@ -219,12 +219,8 @@ static int sep_allocate_dmatables_region(struct sep_device *sep,
        dev_dbg(&sep->pdev->dev, "[PID%d] oldlen = 0x%08X\n", current->pid,
                                dma_ctx->dmatables_len);
        tmp_region = kzalloc(new_len + dma_ctx->dmatables_len, GFP_KERNEL);
-       if (!tmp_region) {
-               dev_warn(&sep->pdev->dev,
-                        "[PID%d] no mem for dma tables region\n",
-                               current->pid);
+       if (!tmp_region)
                return -ENOMEM;
-       }
 
        /* Were there any previous tables that need to be preserved ? */
        if (*dmatables_region) {
@@ -1245,27 +1241,23 @@ static int sep_lock_user_pages(struct sep_device *sep,
                                        current->pid, num_pages);
 
        /* Allocate array of pages structure pointers */
-       page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
+       page_array = kmalloc_array(num_pages, sizeof(struct page *),
+                                  GFP_ATOMIC);
        if (!page_array) {
                error = -ENOMEM;
                goto end_function;
        }
-       map_array = kmalloc(sizeof(struct sep_dma_map) * num_pages, GFP_ATOMIC);
+
+       map_array = kmalloc_array(num_pages, sizeof(struct sep_dma_map),
+                                 GFP_ATOMIC);
        if (!map_array) {
-               dev_warn(&sep->pdev->dev,
-                        "[PID%d] kmalloc for map_array failed\n",
-                               current->pid);
                error = -ENOMEM;
                goto end_function_with_error1;
        }
 
-       lli_array = kmalloc(sizeof(struct sep_lli_entry) * num_pages,
-               GFP_ATOMIC);
-
+       lli_array = kmalloc_array(num_pages, sizeof(struct sep_lli_entry),
+                                 GFP_ATOMIC);
        if (!lli_array) {
-               dev_warn(&sep->pdev->dev,
-                        "[PID%d] kmalloc for lli_array failed\n",
-                               current->pid);
                error = -ENOMEM;
                goto end_function_with_error2;
        }
@@ -1448,15 +1440,10 @@ static int sep_lli_table_secure_dma(struct sep_device *sep,
        dev_dbg(&sep->pdev->dev, "[PID%d] num_pages is (hex) %x\n",
                current->pid, num_pages);
 
-       lli_array = kmalloc(sizeof(struct sep_lli_entry) * num_pages,
-               GFP_ATOMIC);
-
-       if (!lli_array) {
-               dev_warn(&sep->pdev->dev,
-                       "[PID%d] kmalloc for lli_array failed\n",
-                       current->pid);
+       lli_array = kmalloc_array(num_pages, sizeof(struct sep_lli_entry),
+                                 GFP_ATOMIC);
+       if (!lli_array)
                return -ENOMEM;
-       }
 
        /*
         * Fill the lli_array
@@ -3419,11 +3406,9 @@ static ssize_t sep_create_dcb_dmatables_context(struct sep_device *sep,
                goto end_function;
        }
 
-       dcb_args = kzalloc(num_dcbs * sizeof(struct build_dcb_struct),
+       dcb_args = kcalloc(num_dcbs, sizeof(struct build_dcb_struct),
                           GFP_KERNEL);
        if (!dcb_args) {
-               dev_warn(&sep->pdev->dev, "[PID%d] no memory for dcb args\n",
-                        current->pid);
                error = -ENOMEM;
                goto end_function;
        }
@@ -3610,9 +3595,6 @@ static ssize_t sep_create_msgarea_context(struct sep_device *sep,
        /* Allocate thread-specific memory for message buffer */
        *msg_region = kzalloc(msg_len, GFP_KERNEL);
        if (!(*msg_region)) {
-               dev_warn(&sep->pdev->dev,
-                        "[PID%d] no mem for msgarea context\n",
-                        current->pid);
                error = -ENOMEM;
                goto end_function;
        }
@@ -4133,8 +4115,6 @@ static int sep_probe(struct pci_dev *pdev,
        /* Allocate the sep_device structure for this device */
        sep_dev = kzalloc(sizeof(struct sep_device), GFP_ATOMIC);
        if (sep_dev == NULL) {
-               dev_warn(&pdev->dev,
-                       "can't kmalloc the sep_device structure\n");
                error = -ENOMEM;
                goto end_function_disable_device;
        }

diff --git a/drivers/staging/speakup/selection.c b/drivers/staging/speakup/selection.c
index d6558faea3e037ab94033b6fb723ff35f947c156..822ac3d24788f19f9c47b2d3bf6b8397960abf1e 100644 (file)
--- a/drivers/staging/speakup/selection.c
+++ b/drivers/staging/speakup/selection.c
@@ -95,7 +95,6 @@ int speakup_set_selection(struct tty_struct *tty)
        /* Allocate a new buffer before freeing the old one ... */
        bp = kmalloc((sel_end-sel_start)/2+1, GFP_ATOMIC);
        if (!bp) {
-               dev_warn(tty->dev, "selection: kmalloc() failed\n");
                speakup_clear_selection();
                return -ENOMEM;
        }

diff --git a/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c b/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
index 299f5181019988f2b9c329333e6e7a65bf4605f4..6a21f67af086f47d969b8d096d64b9fdf1d61b7b 100644 (file)
--- a/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
+++ b/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c
@@ -742,13 +742,9 @@ static int synaptics_rmi4_i2c_query_device(struct synaptics_rmi4_data *pdata)
                        case SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM:
                                if (rmi_fd.intr_src_count) {
                                        rfi = kmalloc(sizeof(*rfi),
-                                                               GFP_KERNEL);
-                                       if (!rfi) {
-                                               dev_err(&client->dev,
-                                                       "%s:kmalloc failed\n",
-                                                               __func__);
-                                                       return -ENOMEM;
-                                       }
+                                                     GFP_KERNEL);
+                                       if (!rfi)
+                                               return -ENOMEM;
                                        retval = synpatics_rmi4_touchpad_detect
                                                                (pdata, rfi,
                                                                &rmi_fd,
@@ -900,12 +896,10 @@ static int synaptics_rmi4_probe
        }
 
        /* Allocate and initialize the instance data for this client */
-       rmi4_data = kzalloc(sizeof(struct synaptics_rmi4_data) * 2,
-                                                       GFP_KERNEL);
-       if (!rmi4_data) {
-               dev_err(&client->dev, "%s: no memory allocated\n", __func__);
+       rmi4_data = kcalloc(2, sizeof(struct synaptics_rmi4_data),
+                           GFP_KERNEL);
+       if (!rmi4_data)
                return -ENOMEM;
-       }
 
        rmi4_data->input_dev = input_allocate_device();
        if (rmi4_data->input_dev == NULL) {

diff --git a/drivers/staging/tidspbridge/pmgr/dspapi.c b/drivers/staging/tidspbridge/pmgr/dspapi.c
index 5a18a9417ac27081a38948006fe6c179a1750dbf..70db4ff99ec6f160ebfaf3cb75e598b46c81c5a8 100644 (file)
--- a/drivers/staging/tidspbridge/pmgr/dspapi.c
+++ b/drivers/staging/tidspbridge/pmgr/dspapi.c
@@ -1543,7 +1543,7 @@ u32 strmwrap_free_buffer(union trapped_args *args, void *pr_ctxt)
        if (num_bufs > MAX_BUFS)
                return -EINVAL;
 
-       ap_buffer = kmalloc((num_bufs * sizeof(u8 *)), GFP_KERNEL);
+       ap_buffer = kmalloc_array(num_bufs, sizeof(u8 *), GFP_KERNEL);
        if (ap_buffer == NULL)
                return -ENOMEM;
 

diff --git a/drivers/staging/tidspbridge/rmgr/proc.c b/drivers/staging/tidspbridge/rmgr/proc.c
index e1bdf6eacb3a4996afeef38e3fc1ffcd4e82caba..0df55bd5bde48bbb2fd8f9a96349f3fb463b9b57 100644 (file)
--- a/drivers/staging/tidspbridge/rmgr/proc.c
+++ b/drivers/staging/tidspbridge/rmgr/proc.c
@@ -119,16 +119,14 @@ static struct dmm_map_object *add_mapping_info(struct process_context *pr_ctxt,
                                                dsp_addr, size);
 
        map_obj = kzalloc(sizeof(struct dmm_map_object), GFP_KERNEL);
-       if (!map_obj) {
-               pr_err("%s: kzalloc failed\n", __func__);
+       if (!map_obj)
                return NULL;
-       }
+
        INIT_LIST_HEAD(&map_obj->link);
 
        map_obj->pages = kcalloc(num_usr_pgs, sizeof(struct page *),
-                                                       GFP_KERNEL);
+                                GFP_KERNEL);
        if (!map_obj->pages) {
-               pr_err("%s: kzalloc failed\n", __func__);
                kfree(map_obj);
                return NULL;
        }
@@ -693,7 +691,6 @@ static int memory_give_ownership(struct dmm_map_object *map_obj,
 
        sg = kcalloc(num_pages, sizeof(*sg), GFP_KERNEL);
        if (!sg) {
-               pr_err("%s: kcalloc failed\n", __func__);
                ret = -ENOMEM;
                goto out;
        }
@@ -1227,12 +1224,8 @@ int proc_load(void *hprocessor, const s32 argc_index,
                                (p_proc_object->bridge_context, &brd_state))) {
                        pr_info("%s: Processor Loaded %s\n", __func__, pargv0);
                        kfree(drv_datap->base_img);
-                       drv_datap->base_img = kmalloc(strlen(pargv0) + 1,
-                                                               GFP_KERNEL);
-                       if (drv_datap->base_img)
-                               strncpy(drv_datap->base_img, pargv0,
-                                                       strlen(pargv0) + 1);
-                       else
+                       drv_datap->base_img = kstrdup(pargv0, GFP_KERNEL);
+                       if (!drv_datap->base_img)
                                status = -ENOMEM;
                }
        }

diff --git a/drivers/staging/usbip/stub_dev.c b/drivers/staging/usbip/stub_dev.c
index d36c69e16d366aabfc9cc2bb82769bda7a11d192..ca5de9de3fe04e7251dd38b1f06d464f1b0324ea 100644 (file)
--- a/drivers/staging/usbip/stub_dev.c
+++ b/drivers/staging/usbip/stub_dev.c
@@ -286,10 +286,8 @@ static struct stub_device *stub_device_alloc(struct usb_device *udev,
 
        /* yes, it's a new device */
        sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL);
-       if (!sdev) {
-               dev_err(&interface->dev, "no memory for stub_device\n");
+       if (!sdev)
                return NULL;
-       }
 
        sdev->interface = usb_get_intf(interface);
        sdev->udev = usb_get_dev(udev);

diff --git a/drivers/staging/usbip/stub_rx.c b/drivers/staging/usbip/stub_rx.c
index e7458e1ad15118f13ccd49c798c132f01cb709d5..715e8a79fb4e846895594cb5a3d3bdc4283dcce5 100644 (file)
--- a/drivers/staging/usbip/stub_rx.c
+++ b/drivers/staging/usbip/stub_rx.c
@@ -485,7 +485,6 @@ static void stub_recv_cmd_submit(struct stub_device *sdev,
                        kzalloc(pdu->u.cmd_submit.transfer_buffer_length,
                                GFP_KERNEL);
                if (!priv->urb->transfer_buffer) {
-                       dev_err(&sdev->interface->dev, "malloc x_buff\n");
                        usbip_event_add(ud, SDEV_EVENT_ERROR_MALLOC);
                        return;
                }

diff --git a/drivers/staging/usbip/stub_tx.c b/drivers/staging/usbip/stub_tx.c
index 513961fef0551e517d270c8bf60f8d6537e94b4d..cd5326ae38cc907a17b4d21c440f2df73649a1de 100644 (file)
--- a/drivers/staging/usbip/stub_tx.c
+++ b/drivers/staging/usbip/stub_tx.c
@@ -42,7 +42,6 @@ void stub_enqueue_ret_unlink(struct stub_device *sdev, __u32 seqnum,
 
        unlink = kzalloc(sizeof(struct stub_unlink), GFP_ATOMIC);
        if (!unlink) {
-               dev_err(&sdev->interface->dev, "alloc stub_unlink\n");
                usbip_event_add(&sdev->ud, VDEV_EVENT_ERROR_MALLOC);
                return;
        }

diff --git a/drivers/staging/usbip/vhci_hcd.c b/drivers/staging/usbip/vhci_hcd.c
index 216648d3c8fa7648c1358900c63d5d3569f9773c..f1ca08478da8717910df803e59318479e58d1590 100644 (file)
--- a/drivers/staging/usbip/vhci_hcd.c
+++ b/drivers/staging/usbip/vhci_hcd.c
@@ -434,16 +434,13 @@ static void vhci_tx_urb(struct urb *urb)
        }
 
        priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
-
-       spin_lock(&vdev->priv_lock);
-
        if (!priv) {
-               dev_err(&urb->dev->dev, "malloc vhci_priv\n");
-               spin_unlock(&vdev->priv_lock);
                usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
                return;
        }
 
+       spin_lock(&vdev->priv_lock);
+
        priv->seqnum = atomic_inc_return(&the_controller->seqnum);
        if (priv->seqnum == 0xffff)
                dev_info(&urb->dev->dev, "seqnum max\n");
@@ -684,7 +681,6 @@ static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                /* setup CMD_UNLINK pdu */
                unlink = kzalloc(sizeof(struct vhci_unlink), GFP_ATOMIC);
                if (!unlink) {
-                       pr_err("malloc vhci_unlink\n");
                        spin_unlock(&vdev->priv_lock);
                        spin_unlock(&the_controller->lock);
                        usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);

diff --git a/drivers/staging/vme/devices/vme_pio2_core.c b/drivers/staging/vme/devices/vme_pio2_core.c
index bf73ba26e88aee484b21dc5aeff7b661c07f0c90..fd19c257f53320a779d0ec3713c89c342b713cae 100644 (file)
--- a/drivers/staging/vme/devices/vme_pio2_core.c
+++ b/drivers/staging/vme/devices/vme_pio2_core.c
@@ -222,7 +222,6 @@ static int pio2_probe(struct vme_dev *vdev)
 
        card = kzalloc(sizeof(struct pio2_card), GFP_KERNEL);
        if (card == NULL) {
-               dev_err(&vdev->dev, "Unable to allocate card structure\n");
                retval = -ENOMEM;
                goto err_struct;
        }

diff --git a/drivers/staging/vme/devices/vme_pio2_gpio.c b/drivers/staging/vme/devices/vme_pio2_gpio.c
index 69d880517e07b7eb2acfae78317addeb8b121303..2a2d920d980bf62a33ae1a4ccb0193289c110f4e 100644 (file)
--- a/drivers/staging/vme/devices/vme_pio2_gpio.c
+++ b/drivers/staging/vme/devices/vme_pio2_gpio.c
@@ -192,10 +192,8 @@ int pio2_gpio_init(struct pio2_card *card)
        char *label;
 
        label = kmalloc(PIO2_NUM_CHANNELS, GFP_KERNEL);
-       if (label == NULL) {
-               dev_err(&card->vdev->dev, "Unable to allocate GPIO label\n");
+       if (label == NULL)
                return -ENOMEM;
-       }
 
        sprintf(label, "%s@%s", driver_name, dev_name(&card->vdev->dev));
        card->gc.label = label;

diff --git a/drivers/staging/vme/devices/vme_user.c b/drivers/staging/vme/devices/vme_user.c
index 4ef852c4c4e112f04bf1d99dcc18b074034a4925..57474cff51f0f81b3ab01ed7cf6e3444da8588dc 100644 (file)
--- a/drivers/staging/vme/devices/vme_user.c
+++ b/drivers/staging/vme/devices/vme_user.c
@@ -761,8 +761,6 @@ static int vme_user_probe(struct vme_dev *vdev)
                image[i].size_buf = PCI_BUF_SIZE;
                image[i].kern_buf = kmalloc(image[i].size_buf, GFP_KERNEL);
                if (image[i].kern_buf == NULL) {
-                       dev_warn(&vdev->dev,
-                                "Unable to allocate memory for master window buffers\n");
                        err = -ENOMEM;
                        goto err_master_buf;
                }

diff --git a/drivers/staging/zcache/zcache-main.c b/drivers/staging/zcache/zcache-main.c
index c1ac905759bdfccc2777193032a0c65da059b58b..f3204aca6f9c52a0a2a3beed82cfcbfcfc6bec8d 100644 (file)
--- a/drivers/staging/zcache/zcache-main.c
+++ b/drivers/staging/zcache/zcache-main.c
@@ -1304,10 +1304,8 @@ int zcache_new_pool(uint16_t cli_id, uint32_t flags)
                goto out;
        atomic_inc(&cli->refcount);
        pool = kmalloc(sizeof(struct tmem_pool), GFP_ATOMIC);
-       if (pool == NULL) {
-               pr_info("%s: pool creation failed: out of memory\n", namestr);
+       if (pool == NULL)
                goto out;
-       }
 
        for (poolid = 0; poolid < MAX_POOLS_PER_CLIENT; poolid++)
                if (cli->tmem_pools[poolid] == NULL)
@@ -1380,10 +1378,9 @@ int zcache_autocreate_pool(unsigned int cli_id, unsigned int pool_id, bool eph)
                goto out;
        }
        pool = kmalloc(sizeof(struct tmem_pool), GFP_KERNEL);
-       if (pool == NULL) {
-               pr_info("%s: pool creation failed: out of memory\n", namestr);
+       if (pool == NULL)
                goto out;
-       }
+
        atomic_set(&pool->refcount, 0);
        pool->client = cli;
        pool->pool_id = pool_id;

diff --git a/drivers/staging/zram/zram_drv.c b/drivers/staging/zram/zram_drv.c
index 6094e80aac10941db6e7eb5b8f08aef92464efa8..5918fd7d7e36942ff813e4f7399907fe3e194cb2 100644 (file)
--- a/drivers/staging/zram/zram_drv.c
+++ b/drivers/staging/zram/zram_drv.c
@@ -246,7 +246,6 @@ static int zram_bvec_write(struct zram *zram, struct bio_vec *bvec, u32 index,
                 */
                uncmem = kmalloc(PAGE_SIZE, GFP_NOIO);
                if (!uncmem) {
-                       pr_info("Error allocating temp memory!\n");
                        ret = -ENOMEM;
                        goto out;
                }
@@ -517,10 +516,8 @@ struct zram_meta *zram_meta_alloc(u64 disksize)
                goto out;
 
        meta->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
-       if (!meta->compress_workmem) {
-               pr_err("Error allocating compressor working memory!\n");
+       if (!meta->compress_workmem)
                goto free_meta;
-       }
 
        meta->compress_buffer =
                (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1);