[PATCH] PCI: kzalloc() conversion in drivers/pci

this patch converts drivers/pci to kzalloc usage.
Compile tested with allyes config.

Signed-off-by: Eric Sesterhenn <snakebyte@gmx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 21 insertions, 42 deletions

diff --git a/drivers/pci/hotplug/ibmphp_pci.c b/drivers/pci/hotplug/ibmphp_pci.c
index 155133fe5c12..97753ddcd856 100644
--- a/drivers/pci/hotplug/ibmphp_pci.c
+++ b/drivers/pci/hotplug/ibmphp_pci.c
@@ -164,12 +164,11 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                 cleanup_count = 6;
                                                 goto error;
                                         }
-                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                         if (!newfunc) {
                                                 err ("out of system memory\n");
                                                 return -ENOMEM;
                                         }
-                                        memset (newfunc, 0, sizeof (struct pci_func));
                                         newfunc->busno = cur_func->busno;
                                         newfunc->device = device;
                                         cur_func->next = newfunc;
@@ -203,12 +202,11 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                         flag = FALSE;
                                         for (i = 0; i < 32; i++) {
                                                 if (func->devices[i]) {
-                                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                                         if (!newfunc) {
                                                                 err ("out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (newfunc, 0, sizeof (struct pci_func));
                                                         newfunc->busno = sec_number;
                                                         newfunc->device = (u8) i;
                                                         for (j = 0; j < 4; j++)
@@ -232,12 +230,11 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                 }
                                         }
 
-                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                         if (!newfunc) {
                                                 err ("out of system memory\n");
                                                 return -ENOMEM;
                                         }
-                                        memset (newfunc, 0, sizeof (struct pci_func));
                                         newfunc->busno = cur_func->busno;
                                         newfunc->device = device;
                                         for (j = 0; j < 4; j++)
@@ -279,12 +276,11 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                         for (i = 0; i < 32; i++) {
                                                 if (func->devices[i]) {
                                                         debug ("inside for loop, device is %x\n", i);
-                                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                                         if (!newfunc) {
                                                                 err (" out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (newfunc, 0, sizeof (struct pci_func));
                                                         newfunc->busno = sec_number;
                                                         newfunc->device = (u8) i;
                                                         for (j = 0; j < 4; j++)
@@ -405,13 +401,12 @@ static int configure_device (struct pci_func *func)
 
                         debug ("len[count] in IO %x, count %d\n", len[count], count);
 
-                        io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                        io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 
                         if (!io[count]) {
                                 err ("out of system memory\n");
                                 return -ENOMEM;
                         }
-                        memset (io[count], 0, sizeof (struct resource_node));
                         io[count]->type = IO;
                         io[count]->busno = func->busno;
                         io[count]->devfunc = PCI_DEVFN(func->device, func->function);
@@ -444,12 +439,11 @@ static int configure_device (struct pci_func *func)
 
                                 debug ("len[count] in PFMEM %x, count %d\n", len[count], count);
 
-                                pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!pfmem[count]) {
                                         err ("out of system memory\n");
                                         return -ENOMEM;
                                 }
-                                memset (pfmem[count], 0, sizeof (struct resource_node));
                                 pfmem[count]->type = PFMEM;
                                 pfmem[count]->busno = func->busno;
                                 pfmem[count]->devfunc = PCI_DEVFN(func->device,
@@ -460,13 +454,12 @@ static int configure_device (struct pci_func *func)
                                         ibmphp_add_resource (pfmem[count]);
                                         func->pfmem[count] = pfmem[count];
                                 } else {
-                                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                         if (!mem_tmp) {
                                                 err ("out of system memory\n");
                                                 kfree (pfmem[count]);
                                                 return -ENOMEM;
                                         }
-                                        memset (mem_tmp, 0, sizeof (struct resource_node));
                                         mem_tmp->type = MEM;
                                         mem_tmp->busno = pfmem[count]->busno;
                                         mem_tmp->devfunc = pfmem[count]->devfunc;
@@ -512,12 +505,11 @@ static int configure_device (struct pci_func *func)
 
                                 debug ("len[count] in Mem %x, count %d\n", len[count], count);
 
-                                mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!mem[count]) {
                                         err ("out of system memory\n");
                                         return -ENOMEM;
                                 }
-                                memset (mem[count], 0, sizeof (struct resource_node));
                                 mem[count]->type = MEM;
                                 mem[count]->busno = func->busno;
                                 mem[count]->devfunc = PCI_DEVFN(func->device,
@@ -677,14 +669,13 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                         debug ("len[count] in IO = %x\n", len[count]);
 
-                        bus_io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                        bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                 
                         if (!bus_io[count]) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (bus_io[count], 0, sizeof (struct resource_node));
                         bus_io[count]->type = IO;
                         bus_io[count]->busno = func->busno;
                         bus_io[count]->devfunc = PCI_DEVFN(func->device,
@@ -711,13 +702,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                                 debug ("len[count] in PFMEM = %x\n", len[count]);
 
-                                bus_pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!bus_pfmem[count]) {
                                         err ("out of system memory\n");
                                         retval = -ENOMEM;
                                         goto error;
                                 }
-                                memset (bus_pfmem[count], 0, sizeof (struct resource_node));
                                 bus_pfmem[count]->type = PFMEM;
                                 bus_pfmem[count]->busno = func->busno;
                                 bus_pfmem[count]->devfunc = PCI_DEVFN(func->device,
@@ -728,13 +718,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                                         ibmphp_add_resource (bus_pfmem[count]);
                                         func->pfmem[count] = bus_pfmem[count];
                                 } else {
-                                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                         if (!mem_tmp) {
                                                 err ("out of system memory\n");
                                                 retval = -ENOMEM;
                                                 goto error;
                                         }
-                                        memset (mem_tmp, 0, sizeof (struct resource_node));
                                         mem_tmp->type = MEM;
                                         mem_tmp->busno = bus_pfmem[count]->busno;
                                         mem_tmp->devfunc = bus_pfmem[count]->devfunc;
@@ -770,13 +759,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                                 debug ("len[count] in Memory is %x\n", len[count]);
 
-                                bus_mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!bus_mem[count]) {
                                         err ("out of system memory\n");
                                         retval = -ENOMEM;
                                         goto error;
                                 }
-                                memset (bus_mem[count], 0, sizeof (struct resource_node));
                                 bus_mem[count]->type = MEM;
                                 bus_mem[count]->busno = func->busno;
                                 bus_mem[count]->devfunc = PCI_DEVFN(func->device,
@@ -841,14 +829,13 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                 flag_io = TRUE;
         } else {
                 debug ("it wants %x IO behind the bridge\n", amount_needed->io);
-                io = kmalloc(sizeof(*io), GFP_KERNEL);
+                io = kzalloc(sizeof(*io), GFP_KERNEL);
                 
                 if (!io) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (io, 0, sizeof (struct resource_node));
                 io->type = IO;
                 io->busno = func->busno;
                 io->devfunc = PCI_DEVFN(func->device, func->function);
@@ -865,13 +852,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                 flag_mem = TRUE;
         } else {
                 debug ("it wants %x memory behind the bridge\n", amount_needed->mem);
-                mem = kmalloc(sizeof(*mem), GFP_KERNEL);
+                mem = kzalloc(sizeof(*mem), GFP_KERNEL);
                 if (!mem) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (mem, 0, sizeof (struct resource_node));
                 mem->type = MEM;
                 mem->busno = func->busno;
                 mem->devfunc = PCI_DEVFN(func->device, func->function);
@@ -888,13 +874,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                 flag_pfmem = TRUE;
         } else {
                 debug ("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
-                pfmem = kmalloc(sizeof(*pfmem), GFP_KERNEL);
+                pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
                 if (!pfmem) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (pfmem, 0, sizeof (struct resource_node));
                 pfmem->type = PFMEM;
                 pfmem->busno = func->busno;
                 pfmem->devfunc = PCI_DEVFN(func->device, func->function);
@@ -904,13 +889,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                         ibmphp_add_resource (pfmem);
                         flag_pfmem = TRUE;
                 } else {
-                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                         if (!mem_tmp) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (mem_tmp, 0, sizeof (struct resource_node));
                         mem_tmp->type = MEM;
                         mem_tmp->busno = pfmem->busno;
                         mem_tmp->devfunc = pfmem->devfunc;
@@ -936,13 +920,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                  */
                 bus = ibmphp_find_res_bus (sec_number);
                 if (!bus) {
-                        bus = kmalloc(sizeof(*bus), GFP_KERNEL);
+                        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
                         if (!bus) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (bus, 0, sizeof (struct bus_node));
                         bus->busno = sec_number;
                         debug ("b4 adding new bus\n");
                         rc = add_new_bus (bus, io, mem, pfmem, func->busno);
@@ -1111,10 +1094,9 @@ static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno)
         };
         struct res_needed *amount;
 
-        amount = kmalloc(sizeof(*amount), GFP_KERNEL);
+        amount = kzalloc(sizeof(*amount), GFP_KERNEL);
         if (amount == NULL)
                 return NULL;
-        memset (amount, 0, sizeof (struct res_needed));
 
         ibmphp_pci_bus->number = busno;
 
@@ -1672,12 +1654,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 list_add (&bus->bus_list, &cur_bus->bus_list);
         }
         if (io) {
-                io_range = kmalloc(sizeof(*io_range), GFP_KERNEL);
+                io_range = kzalloc(sizeof(*io_range), GFP_KERNEL);
                 if (!io_range) {
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (io_range, 0, sizeof (struct range_node));
                 io_range->start = io->start;
                 io_range->end = io->end;
                 io_range->rangeno = 1;
@@ -1685,12 +1666,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 bus->rangeIO = io_range;
         }
         if (mem) {
-                mem_range = kmalloc(sizeof(*mem_range), GFP_KERNEL);
+                mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL);
                 if (!mem_range) {
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (mem_range, 0, sizeof (struct range_node));
                 mem_range->start = mem->start;
                 mem_range->end = mem->end;
                 mem_range->rangeno = 1;
@@ -1698,12 +1678,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 bus->rangeMem = mem_range;
         }
         if (pfmem) {
-                pfmem_range = kmalloc(sizeof(*pfmem_range), GFP_KERNEL);
+                pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL);
                 if (!pfmem_range) {     
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (pfmem_range, 0, sizeof (struct range_node));
                 pfmem_range->start = pfmem->start;
                 pfmem_range->end = pfmem->end;
                 pfmem_range->rangeno = 1;