Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[PATCH] serial: replace kmalloc+memset with kzalloc

Browse source 
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Burman Yan 2007-02-14 00:33:07 -08:00 committed by Linus Torvalds
parent 3689a0ec60
commit 8f31bb39ec
10 changed files with 18 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
drivers/serial/8250_acorn.c
View file

@ -47,11 +47,10 @@ serial_card_probe(struct expansion_card *ec, const struct ecard_id *id)
unsigned long bus_addr;
unsigned int i;
info = kmalloc(sizeof(struct serial_card_info), GFP_KERNEL);
info = kzalloc(sizeof(struct serial_card_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
memset(info, 0, sizeof(struct serial_card_info));
info->num_ports = type->num_ports;
bus_addr = ecard_resource_start(ec, type->type);

5
drivers/serial/8250_pci.c
View file

@ -1628,7 +1628,7 @@ pciserial_init_ports(struct pci_dev *dev, struct pciserial_board *board)
nr_ports = rc;
}
priv = kmalloc(sizeof(struct serial_private) +
priv = kzalloc(sizeof(struct serial_private) +
sizeof(unsigned int) * nr_ports,
GFP_KERNEL);
if (!priv) {
@ -1636,9 +1636,6 @@ pciserial_init_ports(struct pci_dev *dev, struct pciserial_board *board)
goto err_deinit;
}
memset(priv, 0, sizeof(struct serial_private) +
sizeof(unsigned int) * nr_ports);
priv->dev = dev;
priv->quirk = quirk;

4
drivers/serial/icom.c
View file

@ -1417,14 +1417,12 @@ static int __devinit icom_alloc_adapter(struct icom_adapter
struct list_head *tmp;
icom_adapter = (struct icom_adapter *)
kmalloc(sizeof(struct icom_adapter), GFP_KERNEL);
kzalloc(sizeof(struct icom_adapter), GFP_KERNEL);
if (!icom_adapter) {
return -ENOMEM;
}
memset(icom_adapter, 0, sizeof(struct icom_adapter));
list_for_each(tmp, &icom_adapter_head) {
cur_adapter_entry =
list_entry(tmp, struct icom_adapter,

6
drivers/serial/ioc3_serial.c
View file

@ -2019,13 +2019,12 @@ ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __FUNCTION__, is, idd));
card_ptr = kmalloc(sizeof(struct ioc3_card), GFP_KERNEL);
card_ptr = kzalloc(sizeof(struct ioc3_card), GFP_KERNEL);
if (!card_ptr) {
printk(KERN_WARNING "ioc3_attach_one"
": unable to get memory for the IOC3\n");
return -ENOMEM;
}
memset(card_ptr, 0, sizeof(struct ioc3_card));
idd->data[is->id] = card_ptr;
Submodule_slot = is->id;
@ -2040,13 +2039,12 @@ ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
/* Create port structures for each port */
for (phys_port = 0; phys_port < PORTS_PER_CARD; phys_port++) {
port = kmalloc(sizeof(struct ioc3_port), GFP_KERNEL);
port = kzalloc(sizeof(struct ioc3_port), GFP_KERNEL);
if (!port) {
printk(KERN_WARNING
"IOC3 serial memory not available for port\n");
goto out4;
}
memset(port, 0, sizeof(struct ioc3_port));
spin_lock_init(&port->ip_lock);
/* we need to remember the previous ones, to point back to

9
drivers/serial/ioc4_serial.c
View file

@ -1076,13 +1076,12 @@ static int inline ioc4_attach_local(struct ioc4_driver_data *idd)
/* Create port structures for each port */
for (port_number = 0; port_number < IOC4_NUM_SERIAL_PORTS;
port_number++) {
port = kmalloc(sizeof(struct ioc4_port), GFP_KERNEL);
port = kzalloc(sizeof(struct ioc4_port), GFP_KERNEL);
if (!port) {
printk(KERN_WARNING
"IOC4 serial memory not available for port\n");
return -ENOMEM;
}
memset(port, 0, sizeof(struct ioc4_port));
spin_lock_init(&port->ip_lock);
/* we need to remember the previous ones, to point back to
@ -2811,7 +2810,7 @@ ioc4_serial_attach_one(struct ioc4_driver_data *idd)
(void *)serial));
/* Get memory for the new card */
control = kmalloc(sizeof(struct ioc4_control), GFP_KERNEL);
control = kzalloc(sizeof(struct ioc4_control), GFP_KERNEL);
if (!control) {
printk(KERN_WARNING "ioc4_attach_one"
@ -2819,11 +2818,10 @@ ioc4_serial_attach_one(struct ioc4_driver_data *idd)
ret = -ENOMEM;
goto out2;
}
memset(control, 0, sizeof(struct ioc4_control));
idd->idd_serial_data = control;
/* Allocate the soft structure */
soft = kmalloc(sizeof(struct ioc4_soft), GFP_KERNEL);
soft = kzalloc(sizeof(struct ioc4_soft), GFP_KERNEL);
if (!soft) {
printk(KERN_WARNING
"ioc4 (%p): unable to get memory for the soft struct\n",
@ -2831,7 +2829,6 @@ ioc4_serial_attach_one(struct ioc4_driver_data *idd)
ret = -ENOMEM;
goto out3;
}
memset(soft, 0, sizeof(struct ioc4_soft));
spin_lock_init(&soft->is_ir_lock);
soft->is_ioc4_misc_addr = idd->idd_misc_regs;

8
drivers/serial/ip22zilog.c
View file

@ -922,13 +922,7 @@ static int zilog_irq = -1;
static void * __init alloc_one_table(unsigned long size)
{
void *ret;
ret = kmalloc(size, GFP_KERNEL);
if (ret != NULL)
memset(ret, 0, size);
return ret;
return kzalloc(size, GFP_KERNEL);
}
static void __init ip22zilog_alloc_tables(void)

6
drivers/serial/jsm/jsm_driver.c
View file

@ -71,14 +71,13 @@ static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
goto out_disable_device;
}
brd = kmalloc(sizeof(struct jsm_board), GFP_KERNEL);
brd = kzalloc(sizeof(struct jsm_board), GFP_KERNEL);
if (!brd) {
dev_err(&pdev->dev,
"memory allocation for board structure failed\n");
rc = -ENOMEM;
goto out_release_regions;
}
memset(brd, 0, sizeof(struct jsm_board));
/* store the info for the board we've found */
brd->boardnum = adapter_count++;
@ -152,7 +151,7 @@ static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
* Okay to malloc with GFP_KERNEL, we are not at interrupt
* context, and there are no locks held.
*/
brd->flipbuf = kmalloc(MYFLIPLEN, GFP_KERNEL);
brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
if (!brd->flipbuf) {
/* XXX: leaking all resources from jsm_tty_init and
jsm_uart_port_init here! */
@ -160,7 +159,6 @@ static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
retval = -ENOMEM;
goto out_free_irq;
}
memset(brd->flipbuf, 0, MYFLIPLEN);
pci_set_drvdata(pdev, brd);

12
drivers/serial/jsm/jsm_tty.c
View file

@ -194,31 +194,28 @@ static int jsm_tty_open(struct uart_port *port)
/* Drop locks, as malloc with GFP_KERNEL can sleep */
if (!channel->ch_rqueue) {
channel->ch_rqueue = (u8 *) kmalloc(RQUEUESIZE, GFP_KERNEL);
channel->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
if (!channel->ch_rqueue) {
jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
"unable to allocate read queue buf");
return -ENOMEM;
}
memset(channel->ch_rqueue, 0, RQUEUESIZE);
}
if (!channel->ch_equeue) {
channel->ch_equeue = (u8 *) kmalloc(EQUEUESIZE, GFP_KERNEL);
channel->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
if (!channel->ch_equeue) {
jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
"unable to allocate error queue buf");
return -ENOMEM;
}
memset(channel->ch_equeue, 0, EQUEUESIZE);
}
if (!channel->ch_wqueue) {
channel->ch_wqueue = (u8 *) kmalloc(WQUEUESIZE, GFP_KERNEL);
channel->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
if (!channel->ch_wqueue) {
jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
"unable to allocate write queue buf");
return -ENOMEM;
}
memset(channel->ch_wqueue, 0, WQUEUESIZE);
}
channel->ch_flags &= ~(CH_OPENING);
@ -392,13 +389,12 @@ int jsm_tty_init(struct jsm_board *brd)
* Okay to malloc with GFP_KERNEL, we are not at
* interrupt context, and there are no locks held.
*/
brd->channels[i] = kmalloc(sizeof(struct jsm_channel), GFP_KERNEL);
brd->channels[i] = kzalloc(sizeof(struct jsm_channel), GFP_KERNEL);
if (!brd->channels[i]) {
jsm_printk(CORE, ERR, &brd->pci_dev,
"%s:%d Unable to allocate memory for channel struct\n",
__FILE__, __LINE__);
}
memset(brd->channels[i], 0, sizeof(struct jsm_channel));
}
}

7
drivers/serial/serial_core.c
View file

@ -1523,9 +1523,8 @@ static struct uart_state *uart_get(struct uart_driver *drv, int line)
}
if (!state->info) {
state->info = kmalloc(sizeof(struct uart_info), GFP_KERNEL);
state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
if (state->info) {
memset(state->info, 0, sizeof(struct uart_info));
init_waitqueue_head(&state->info->open_wait);
init_waitqueue_head(&state->info->delta_msr_wait);
@ -2178,13 +2177,11 @@ int uart_register_driver(struct uart_driver *drv)
* Maybe we should be using a slab cache for this, especially if
* we have a large number of ports to handle.
*/
drv->state = kmalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
retval = -ENOMEM;
if (!drv->state)
goto out;
memset(drv->state, 0, sizeof(struct uart_state) * drv->nr);
normal = alloc_tty_driver(drv->nr);
if (!normal)
goto out;

3
drivers/serial/serial_cs.c
View file

@ -334,10 +334,9 @@ static int serial_probe(struct pcmcia_device *link)
DEBUG(0, "serial_attach()\n");
/* Create new serial device */
info = kmalloc(sizeof (*info), GFP_KERNEL);
info = kzalloc(sizeof (*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
memset(info, 0, sizeof (*info));
info->p_dev = link;
link->priv = info;