PCI: Remove unnecessary messages for memory allocation failures

Per ebfdc40969f2 ("checkpatch: attempt to find unnecessary 'out of memory'
messages"), when a memory allocation fails, the memory subsystem emits
generic "out of memory" messages (see slab_out_of_memory() for some of this
logging).  Therefore, additional error messages in the caller don't add
much value.

Remove messages that merely report "out of memory".

This preserves some messages that report additional information, e.g.,
allocation failures that mean we drop hotplug events.

This issue was detected by using the Coccinelle software.

Signed-off-by: Markus Elfring <elfring@users.sourceforge.net>
[bhelgaas: changelog, squash patches, make similar changes to acpiphp,
cpqphp, ibmphp, keep warning when dropping hotplug event]
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>

diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 5db6f1839dada041d5affbfedef46312360488e3..96f5b986454a04577c1f0af3ec823ccdaad8d122 100644 (file)
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -811,10 +811,8 @@ void acpiphp_enumerate_slots(struct pci_bus *bus)
 
        handle = adev->handle;
        bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
-       if (!bridge) {
-               acpi_handle_err(handle, "No memory for bridge object\n");
+       if (!bridge)
                return;
-       }
 
        INIT_LIST_HEAD(&bridge->slots);
        kref_init(&bridge->ref);

diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 70967ac75265471dacc098abebd319b2699ecef4..d28992788eaa84895e4247a35362eb4143b0dc12 100644 (file)
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -883,7 +883,6 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        ctrl = kzalloc(sizeof(struct controller), GFP_KERNEL);
        if (!ctrl) {
-               err("%s : out of memory\n", __func__);
                rc = -ENOMEM;
                goto err_disable_device;
        }

diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 73cf84645c826589314c65ffd4d933a876f09bd8..4f5c0b936797adeff09988cd49a5452256e314d4 100644 (file)
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -603,10 +603,8 @@ int ibmphp_update_slot_info(struct slot *slot_cur)
        u8 mode;
 
        info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
-       if (!info) {
-               err("out of system memory\n");
+       if (!info)
                return -ENOMEM;
-       }
 
        info->power_status = SLOT_PWRGD(slot_cur->status);
        info->attention_status = SLOT_ATTN(slot_cur->status,
@@ -734,14 +732,12 @@ static u8 bus_structure_fixup(u8 busno)
                return 1;
 
        bus = kmalloc(sizeof(*bus), GFP_KERNEL);
-       if (!bus) {
-               err("%s - out of memory\n", __func__);
+       if (!bus)
                return 1;
-       }
+
        dev = kmalloc(sizeof(*dev), GFP_KERNEL);
        if (!dev) {
                kfree(bus);
-               err("%s - out of memory\n", __func__);
                return 1;
        }
 
@@ -1101,7 +1097,6 @@ static int enable_slot(struct hotplug_slot *hs)
        if (!slot_cur->func) {
                /* We cannot do update_slot_info here, since no memory for
                 * kmalloc n.e.ways, and update_slot_info allocates some */
-               err("out of system memory\n");
                rc = -ENOMEM;
                goto error_power;
        }
@@ -1208,7 +1203,6 @@ int ibmphp_do_disable_slot(struct slot *slot_cur)
                /* We need this for functions that were there on bootup */
                slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
                if (!slot_cur->func) {
-                       err("out of system memory\n");
                        rc = -ENOMEM;
                        goto error;
                }
@@ -1306,7 +1300,6 @@ static int __init ibmphp_init(void)
 
        ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL);
        if (!ibmphp_pci_bus) {
-               err("out of memory\n");
                rc = -ENOMEM;
                goto exit;
        }

diff --git a/drivers/pci/hotplug/ibmphp_pci.c b/drivers/pci/hotplug/ibmphp_pci.c
index 25edd0b18b75186add7edf80fe274b4a93b36c8c..c7ce7d8cf9981fac81119996af0ae5f3e98587b0 100644 (file)
--- a/drivers/pci/hotplug/ibmphp_pci.c
+++ b/drivers/pci/hotplug/ibmphp_pci.c
@@ -167,10 +167,9 @@ int ibmphp_configure_card(struct pci_func *func, u8 slotno)
                                                goto error;
                                        }
                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
-                                       if (!newfunc) {
-                                               err("out of system memory\n");
+                                       if (!newfunc)
                                                return -ENOMEM;
-                                       }
+
                                        newfunc->busno = cur_func->busno;
                                        newfunc->device = device;
                                        cur_func->next = newfunc;
@@ -205,10 +204,9 @@ int ibmphp_configure_card(struct pci_func *func, u8 slotno)
                                        for (i = 0; i < 32; i++) {
                                                if (func->devices[i]) {
                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
-                                                       if (!newfunc) {
-                                                               err("out of system memory\n");
+                                                       if (!newfunc)
                                                                return -ENOMEM;
-                                                       }
+
                                                        newfunc->busno = sec_number;
                                                        newfunc->device = (u8) i;
                                                        for (j = 0; j < 4; j++)
@@ -233,10 +231,9 @@ int ibmphp_configure_card(struct pci_func *func, u8 slotno)
                                        }
 
                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
-                                       if (!newfunc) {
-                                               err("out of system memory\n");
+                                       if (!newfunc)
                                                return -ENOMEM;
-                                       }
+
                                        newfunc->busno = cur_func->busno;
                                        newfunc->device = device;
                                        for (j = 0; j < 4; j++)
@@ -279,10 +276,9 @@ int ibmphp_configure_card(struct pci_func *func, u8 slotno)
                                                if (func->devices[i]) {
                                                        debug("inside for loop, device is %x\n", i);
                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
-                                                       if (!newfunc) {
-                                                               err(" out of system memory\n");
+                                                       if (!newfunc)
                                                                return -ENOMEM;
-                                                       }
+
                                                        newfunc->busno = sec_number;
                                                        newfunc->device = (u8) i;
                                                        for (j = 0; j < 4; j++)
@@ -405,10 +401,9 @@ static int configure_device(struct pci_func *func)
 
                        io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 
-                       if (!io[count]) {
-                               err("out of system memory\n");
+                       if (!io[count])
                                return -ENOMEM;
-                       }
+
                        io[count]->type = IO;
                        io[count]->busno = func->busno;
                        io[count]->devfunc = PCI_DEVFN(func->device, func->function);
@@ -442,10 +437,9 @@ static int configure_device(struct pci_func *func)
                                debug("len[count] in PFMEM %x, count %d\n", len[count], count);
 
                                pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
-                               if (!pfmem[count]) {
-                                       err("out of system memory\n");
+                               if (!pfmem[count])
                                        return -ENOMEM;
-                               }
+
                                pfmem[count]->type = PFMEM;
                                pfmem[count]->busno = func->busno;
                                pfmem[count]->devfunc = PCI_DEVFN(func->device,
@@ -458,7 +452,6 @@ static int configure_device(struct pci_func *func)
                                } else {
                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                        if (!mem_tmp) {
-                                               err("out of system memory\n");
                                                kfree(pfmem[count]);
                                                return -ENOMEM;
                                        }
@@ -508,10 +501,9 @@ static int configure_device(struct pci_func *func)
                                debug("len[count] in Mem %x, count %d\n", len[count], count);
 
                                mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
-                               if (!mem[count]) {
-                                       err("out of system memory\n");
+                               if (!mem[count])
                                        return -ENOMEM;
-                               }
+
                                mem[count]->type = MEM;
                                mem[count]->busno = func->busno;
                                mem[count]->devfunc = PCI_DEVFN(func->device,
@@ -674,7 +666,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                        bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 
                        if (!bus_io[count]) {
-                               err("out of system memory\n");
                                retval = -ENOMEM;
                                goto error;
                        }
@@ -706,7 +697,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
 
                                bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                if (!bus_pfmem[count]) {
-                                       err("out of system memory\n");
                                        retval = -ENOMEM;
                                        goto error;
                                }
@@ -722,7 +712,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                                } else {
                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                        if (!mem_tmp) {
-                                               err("out of system memory\n");
                                                retval = -ENOMEM;
                                                goto error;
                                        }
@@ -763,7 +752,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
 
                                bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                if (!bus_mem[count]) {
-                                       err("out of system memory\n");
                                        retval = -ENOMEM;
                                        goto error;
                                }
@@ -834,7 +822,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                io = kzalloc(sizeof(*io), GFP_KERNEL);
 
                if (!io) {
-                       err("out of system memory\n");
                        retval = -ENOMEM;
                        goto error;
                }
@@ -856,7 +843,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                debug("it wants %x memory behind the bridge\n", amount_needed->mem);
                mem = kzalloc(sizeof(*mem), GFP_KERNEL);
                if (!mem) {
-                       err("out of system memory\n");
                        retval = -ENOMEM;
                        goto error;
                }
@@ -878,7 +864,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                debug("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
                pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
                if (!pfmem) {
-                       err("out of system memory\n");
                        retval = -ENOMEM;
                        goto error;
                }
@@ -893,7 +878,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                } else {
                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                        if (!mem_tmp) {
-                               err("out of system memory\n");
                                retval = -ENOMEM;
                                goto error;
                        }
@@ -924,7 +908,6 @@ static int configure_bridge(struct pci_func **func_passed, u8 slotno)
                if (!bus) {
                        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
                        if (!bus) {
-                               err("out of system memory\n");
                                retval = -ENOMEM;
                                goto error;
                        }
@@ -1652,10 +1635,9 @@ static int add_new_bus(struct bus_node *bus, struct resource_node *io, struct re
        }
        if (io) {
                io_range = kzalloc(sizeof(*io_range), GFP_KERNEL);
-               if (!io_range) {
-                       err("out of system memory\n");
+               if (!io_range)
                        return -ENOMEM;
-               }
+
                io_range->start = io->start;
                io_range->end = io->end;
                io_range->rangeno = 1;
@@ -1664,10 +1646,9 @@ static int add_new_bus(struct bus_node *bus, struct resource_node *io, struct re
        }
        if (mem) {
                mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL);
-               if (!mem_range) {
-                       err("out of system memory\n");
+               if (!mem_range)
                        return -ENOMEM;
-               }
+
                mem_range->start = mem->start;
                mem_range->end = mem->end;
                mem_range->rangeno = 1;
@@ -1676,10 +1657,9 @@ static int add_new_bus(struct bus_node *bus, struct resource_node *io, struct re
        }
        if (pfmem) {
                pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL);
-               if (!pfmem_range) {
-                       err("out of system memory\n");
+               if (!pfmem_range)
                        return -ENOMEM;
-               }
+
                pfmem_range->start = pfmem->start;
                pfmem_range->end = pfmem->end;
                pfmem_range->rangeno = 1;

diff --git a/drivers/pci/hotplug/ibmphp_res.c b/drivers/pci/hotplug/ibmphp_res.c
index aee6e41001e1950a5dcfdfb12d4357570b10ecea..b58a7a641e0eb2ef7df04011e585f334bfb1c42f 100644 (file)
--- a/drivers/pci/hotplug/ibmphp_res.c
+++ b/drivers/pci/hotplug/ibmphp_res.c
@@ -56,10 +56,8 @@ static struct bus_node * __init alloc_error_bus(struct ebda_pci_rsrc *curr, u8 b
        }
 
        newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
-       if (!newbus) {
-               err("out of system memory\n");
+       if (!newbus)
                return NULL;
-       }
 
        if (flag)
                newbus->busno = busno;
@@ -79,10 +77,9 @@ static struct resource_node * __init alloc_resources(struct ebda_pci_rsrc *curr)
        }
 
        rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
-       if (!rs) {
-               err("out of system memory\n");
+       if (!rs)
                return NULL;
-       }
+
        rs->busno = curr->bus_num;
        rs->devfunc = curr->dev_fun;
        rs->start = curr->start_addr;
@@ -99,10 +96,9 @@ static int __init alloc_bus_range(struct bus_node **new_bus, struct range_node *
 
        if (first_bus) {
                newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
-               if (!newbus) {
-                       err("out of system memory.\n");
+               if (!newbus)
                        return -ENOMEM;
-               }
+
                newbus->busno = curr->bus_num;
        } else {
                newbus = *new_bus;
@@ -123,7 +119,6 @@ static int __init alloc_bus_range(struct bus_node **new_bus, struct range_node *
        if (!newrange) {
                if (first_bus)
                        kfree(newbus);
-               err("out of system memory\n");
                return -ENOMEM;
        }
        newrange->start = curr->start_addr;
@@ -1707,10 +1702,9 @@ static int __init once_over(void)
                                bus_cur->firstPFMemFromMem = pfmem_cur;
 
                                mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
-                               if (!mem) {
-                                       err("out of system memory\n");
+                               if (!mem)
                                        return -ENOMEM;
-                               }
+
                                mem->type = MEM;
                                mem->busno = pfmem_cur->busno;
                                mem->devfunc = pfmem_cur->devfunc;
@@ -1989,10 +1983,9 @@ static int __init update_bridge_ranges(struct bus_node **bus)
 
                                                if ((start_address) && (start_address <= end_address)) {
                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
-                                                       if (!range) {
-                                                               err("out of system memory\n");
+                                                       if (!range)
                                                                return -ENOMEM;
-                                                       }
+
                                                        range->start = start_address;
                                                        range->end = end_address + 0xfff;
 
@@ -2016,7 +2009,6 @@ static int __init update_bridge_ranges(struct bus_node **bus)
                                                                io = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                if (!io) {
                                                                        kfree(range);
-                                                                       err("out of system memory\n");
                                                                        return -ENOMEM;
                                                                }
                                                                io->type = IO;
@@ -2038,10 +2030,9 @@ static int __init update_bridge_ranges(struct bus_node **bus)
                                                if ((start_address) && (start_address <= end_address)) {
 
                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
-                                                       if (!range) {
-                                                               err("out of system memory\n");
+                                                       if (!range)
                                                                return -ENOMEM;
-                                                       }
+
                                                        range->start = start_address;
                                                        range->end = end_address + 0xfffff;
 
@@ -2066,7 +2057,6 @@ static int __init update_bridge_ranges(struct bus_node **bus)
                                                                mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                if (!mem) {
                                                                        kfree(range);
-                                                                       err("out of system memory\n");
                                                                        return -ENOMEM;
                                                                }
                                                                mem->type = MEM;
@@ -2092,10 +2082,9 @@ static int __init update_bridge_ranges(struct bus_node **bus)
                                                if ((start_address) && (start_address <= end_address)) {
 
                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
-                                                       if (!range) {
-                                                               err("out of system memory\n");
+                                                       if (!range)
                                                                return -ENOMEM;
-                                                       }
+
                                                        range->start = start_address;
                                                        range->end = end_address + 0xfffff;
 
@@ -2119,7 +2108,6 @@ static int __init update_bridge_ranges(struct bus_node **bus)
                                                                pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                if (!pfmem) {
                                                                        kfree(range);
-                                                                       err("out of system memory\n");
                                                                        return -ENOMEM;
                                                                }
                                                                pfmem->type = PFMEM;

diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 7bab0606f1a9f1d04e9529a22b1354b1f73844c3..ed27635ec74078b99e745506bb48e87f4b1e00e2 100644 (file)
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -838,10 +838,9 @@ struct controller *pcie_init(struct pcie_device *dev)
        struct pci_dev *pdev = dev->port;
 
        ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
-       if (!ctrl) {
-               dev_err(&dev->device, "%s: Out of memory\n", __func__);
+       if (!ctrl)
                goto abort;
-       }
+
        ctrl->pcie = dev;
        pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap);
 

diff --git a/drivers/pci/hotplug/pnv_php.c b/drivers/pci/hotplug/pnv_php.c
index 74f6a17e46146f9dd1dffe86de3d002e26f0e1c3..318baa507364131f8ce69bc86c9f284abbbef307 100644 (file)
--- a/drivers/pci/hotplug/pnv_php.c
+++ b/drivers/pci/hotplug/pnv_php.c
@@ -266,7 +266,6 @@ static int pnv_php_add_devtree(struct pnv_php_slot *php_slot)
        fdt1 = kzalloc(0x10000, GFP_KERNEL);
        if (!fdt1) {
                ret = -ENOMEM;
-               dev_warn(&php_slot->pdev->dev, "Cannot alloc FDT blob\n");
                goto out;
        }
 
@@ -280,8 +279,6 @@ static int pnv_php_add_devtree(struct pnv_php_slot *php_slot)
        fdt = kzalloc(fdt_totalsize(fdt1), GFP_KERNEL);
        if (!fdt) {
                ret = -ENOMEM;
-               dev_warn(&php_slot->pdev->dev, "Cannot %d bytes memory\n",
-                        fdt_totalsize(fdt1));
                goto free_fdt1;
        }
 

diff --git a/drivers/pci/hotplug/shpchp_core.c b/drivers/pci/hotplug/shpchp_core.c
index 7bfb87bd2b7e0f68b41aab4ac0bf31dfe6a553ac..2f2b87acf17943146c78dcf7bf5be6c8736c97a5 100644 (file)
--- a/drivers/pci/hotplug/shpchp_core.c
+++ b/drivers/pci/hotplug/shpchp_core.c
@@ -305,10 +305,9 @@ static int shpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                return -ENODEV;
 
        ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
-       if (!ctrl) {
-               dev_err(&pdev->dev, "%s: Out of memory\n", __func__);
+       if (!ctrl)
                goto err_out_none;
-       }
+
        INIT_LIST_HEAD(&ctrl->slot_list);
 
        rc = shpc_init(ctrl, pdev);

diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index b1ad466199ad74d207b0c46c01c0d0d19adde44a..d131d29c4fdbb455323416a6ab6298e770cda2a3 100644 (file)
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -67,10 +67,8 @@ static int add_to_list(struct list_head *head,
        struct pci_dev_resource *tmp;
 
        tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
-       if (!tmp) {
-               pr_warn("add_to_list: kmalloc() failed!\n");
+       if (!tmp)
                return -ENOMEM;
-       }
 
        tmp->res = res;
        tmp->dev = dev;