lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[ALSA] Replace with kzalloc() - seq stuff

Browse Source 
ALSA sequencer,Instrument layer,ALSA<-OSS sequencer
Replace kcalloc(1,..) with kzalloc().

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai
2005-09-09 14:20:49 +02:00
committed by Jaroslav Kysela
parent ca2c096656
commit ecca82b4b4
22 changed files with 32 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sound/core/seq/instr/ainstr_gf1.c
View File

@@ -61,7 +61,7 @@ static int snd_seq_gf1_copy_wave_from_stream(snd_gf1_ops_t *ops,
return -EFAULT; return -EFAULT;
*data += sizeof(xp); *data += sizeof(xp);
*len -= sizeof(xp); *len -= sizeof(xp);
wp = kcalloc(1, sizeof(*wp), gfp_mask); wp = kzalloc(sizeof(*wp), gfp_mask);
if (wp == NULL) if (wp == NULL)
return -ENOMEM; return -ENOMEM;
wp->share_id[0] = le32_to_cpu(xp.share_id[0]); wp->share_id[0] = le32_to_cpu(xp.share_id[0]);

6
sound/core/seq/instr/ainstr_iw.c
View File

@@ -92,7 +92,7 @@ static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype,
points_size = (le16_to_cpu(rx.nattack) + le16_to_cpu(rx.nrelease)) * 2 * sizeof(__u16); points_size = (le16_to_cpu(rx.nattack) + le16_to_cpu(rx.nrelease)) * 2 * sizeof(__u16);
if (points_size > *len) if (points_size > *len)
return -EINVAL; return -EINVAL;
rp = kcalloc(1, sizeof(*rp) + points_size, gfp_mask); rp = kzalloc(sizeof(*rp) + points_size, gfp_mask);
if (rp == NULL) if (rp == NULL)
return -ENOMEM; return -ENOMEM;
rp->nattack = le16_to_cpu(rx.nattack); rp->nattack = le16_to_cpu(rx.nattack);
@@ -139,7 +139,7 @@ static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops,
return -EFAULT; return -EFAULT;
*data += sizeof(xp); *data += sizeof(xp);
*len -= sizeof(xp); *len -= sizeof(xp);
wp = kcalloc(1, sizeof(*wp), gfp_mask); wp = kzalloc(sizeof(*wp), gfp_mask);
if (wp == NULL) if (wp == NULL)
return -ENOMEM; return -ENOMEM;
wp->share_id[0] = le32_to_cpu(xp.share_id[0]); wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
@@ -273,7 +273,7 @@ static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr,
snd_seq_iwffff_instr_free(ops, ip, atomic); snd_seq_iwffff_instr_free(ops, ip, atomic);
return -EINVAL; return -EINVAL;
} }
lp = kcalloc(1, sizeof(*lp), gfp_mask); lp = kzalloc(sizeof(*lp), gfp_mask);
if (lp == NULL) { if (lp == NULL) {
snd_seq_iwffff_instr_free(ops, ip, atomic); snd_seq_iwffff_instr_free(ops, ip, atomic);
return -ENOMEM; return -ENOMEM;

2
sound/core/seq/oss/seq_oss_init.c
View File

@@ -193,7 +193,7 @@ snd_seq_oss_open(struct file *file, int level)
int i, rc; int i, rc;
seq_oss_devinfo_t *dp; seq_oss_devinfo_t *dp;
if ((dp = kcalloc(1, sizeof(*dp), GFP_KERNEL)) == NULL) { if ((dp = kzalloc(sizeof(*dp), GFP_KERNEL)) == NULL) {
snd_printk(KERN_ERR "can't malloc device info\n"); snd_printk(KERN_ERR "can't malloc device info\n");
return -ENOMEM; return -ENOMEM;
} }

6
sound/core/seq/oss/seq_oss_midi.c
View File

@@ -76,8 +76,8 @@ snd_seq_oss_midi_lookup_ports(int client)
snd_seq_client_info_t *clinfo; snd_seq_client_info_t *clinfo;
snd_seq_port_info_t *pinfo; snd_seq_port_info_t *pinfo;
clinfo = kcalloc(1, sizeof(*clinfo), GFP_KERNEL); clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL);
pinfo = kcalloc(1, sizeof(*pinfo), GFP_KERNEL); pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
if (! clinfo || ! pinfo) { if (! clinfo || ! pinfo) {
kfree(clinfo); kfree(clinfo);
kfree(pinfo); kfree(pinfo);
@@ -172,7 +172,7 @@ snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo)
/* /*
* allocate midi info record * allocate midi info record
*/ */
if ((mdev = kcalloc(1, sizeof(*mdev), GFP_KERNEL)) == NULL) { if ((mdev = kzalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
snd_printk(KERN_ERR "can't malloc midi info\n"); snd_printk(KERN_ERR "can't malloc midi info\n");
return -ENOMEM; return -ENOMEM;
} }

2
sound/core/seq/oss/seq_oss_readq.c
View File

@@ -46,7 +46,7 @@ snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen)
{ {
seq_oss_readq_t *q; seq_oss_readq_t *q;
if ((q = kcalloc(1, sizeof(*q), GFP_KERNEL)) == NULL) { if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) {
snd_printk(KERN_ERR "can't malloc read queue\n"); snd_printk(KERN_ERR "can't malloc read queue\n");
return NULL; return NULL;
} }

4
sound/core/seq/oss/seq_oss_synth.c
View File

@@ -103,7 +103,7 @@ snd_seq_oss_synth_register(snd_seq_device_t *dev)
snd_seq_oss_reg_t *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); snd_seq_oss_reg_t *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev);
unsigned long flags; unsigned long flags;
if ((rec = kcalloc(1, sizeof(*rec), GFP_KERNEL)) == NULL) { if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) {
snd_printk(KERN_ERR "can't malloc synth info\n"); snd_printk(KERN_ERR "can't malloc synth info\n");
return -ENOMEM; return -ENOMEM;
} }
@@ -499,7 +499,7 @@ snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_
sysex = dp->synths[dev].sysex; sysex = dp->synths[dev].sysex;
if (sysex == NULL) { if (sysex == NULL) {
sysex = kcalloc(1, sizeof(*sysex), GFP_KERNEL); sysex = kzalloc(sizeof(*sysex), GFP_KERNEL);
if (sysex == NULL) if (sysex == NULL)
return -ENOMEM; return -ENOMEM;
dp->synths[dev].sysex = sysex; dp->synths[dev].sysex = sysex;

2
sound/core/seq/oss/seq_oss_timer.c
View File

@@ -46,7 +46,7 @@ snd_seq_oss_timer_new(seq_oss_devinfo_t *dp)
{ {
seq_oss_timer_t *rec; seq_oss_timer_t *rec;
rec = kcalloc(1, sizeof(*rec), GFP_KERNEL); rec = kzalloc(sizeof(*rec), GFP_KERNEL);
if (rec == NULL) if (rec == NULL)
return NULL; return NULL;

2
sound/core/seq/oss/seq_oss_writeq.c
View File

@@ -38,7 +38,7 @@ snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen)
seq_oss_writeq_t *q; seq_oss_writeq_t *q;
snd_seq_client_pool_t pool; snd_seq_client_pool_t pool;
if ((q = kcalloc(1, sizeof(*q), GFP_KERNEL)) == NULL) if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL)
return NULL; return NULL;
q->dp = dp; q->dp = dp;
q->maxlen = maxlen; q->maxlen = maxlen;

2
sound/core/seq/seq_clientmgr.c
View File

@@ -203,7 +203,7 @@ static client_t *seq_create_client1(int client_index, int poolsize)
client_t *client; client_t *client;
/* init client data */ /* init client data */
client = kcalloc(1, sizeof(*client), GFP_KERNEL); client = kzalloc(sizeof(*client), GFP_KERNEL);
if (client == NULL) if (client == NULL)
return NULL; return NULL;
client->pool = snd_seq_pool_new(poolsize); client->pool = snd_seq_pool_new(poolsize);

2
sound/core/seq/seq_device.c
View File

@@ -200,7 +200,7 @@ int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize,
if (ops == NULL) if (ops == NULL)
return -ENOMEM; return -ENOMEM;
dev = kcalloc(1, sizeof(*dev)*2 + argsize, GFP_KERNEL); dev = kzalloc(sizeof(*dev)*2 + argsize, GFP_KERNEL);
if (dev == NULL) { if (dev == NULL) {
unlock_driver(ops); unlock_driver(ops);
return -ENOMEM; return -ENOMEM;

2
sound/core/seq/seq_dummy.c
View File

@@ -153,7 +153,7 @@ create_port(int idx, int type)
snd_seq_port_callback_t pcb; snd_seq_port_callback_t pcb;
snd_seq_dummy_port_t *rec; snd_seq_dummy_port_t *rec;
if ((rec = kcalloc(1, sizeof(*rec), GFP_KERNEL)) == NULL) if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
return NULL; return NULL;
rec->client = my_client; rec->client = my_client;

2
sound/core/seq/seq_fifo.c
View File

@@ -33,7 +33,7 @@ fifo_t *snd_seq_fifo_new(int poolsize)
{ {
fifo_t *f; fifo_t *f;
f = kcalloc(1, sizeof(*f), GFP_KERNEL); f = kzalloc(sizeof(*f), GFP_KERNEL);
if (f == NULL) { if (f == NULL) {
snd_printd("malloc failed for snd_seq_fifo_new() \n"); snd_printd("malloc failed for snd_seq_fifo_new() \n");
return NULL; return NULL;

4
sound/core/seq/seq_instr.c
View File

@@ -53,7 +53,7 @@ static snd_seq_kinstr_t *snd_seq_instr_new(int add_len, int atomic)
{ {
snd_seq_kinstr_t *instr; snd_seq_kinstr_t *instr;
instr = kcalloc(1, sizeof(snd_seq_kinstr_t) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL); instr = kzalloc(sizeof(snd_seq_kinstr_t) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL);
if (instr == NULL) if (instr == NULL)
return NULL; return NULL;
instr->add_len = add_len; instr->add_len = add_len;
@@ -77,7 +77,7 @@ snd_seq_kinstr_list_t *snd_seq_instr_list_new(void)
{ {
snd_seq_kinstr_list_t *list; snd_seq_kinstr_list_t *list;
list = kcalloc(1, sizeof(snd_seq_kinstr_list_t), GFP_KERNEL); list = kzalloc(sizeof(snd_seq_kinstr_list_t), GFP_KERNEL);
if (list == NULL) if (list == NULL)
return NULL; return NULL;
spin_lock_init(&list->lock); spin_lock_init(&list->lock);

2
sound/core/seq/seq_memory.c
View File

@@ -452,7 +452,7 @@ pool_t *snd_seq_pool_new(int poolsize)
pool_t *pool; pool_t *pool;
/* create pool block */ /* create pool block */
pool = kcalloc(1, sizeof(*pool), GFP_KERNEL); pool = kzalloc(sizeof(*pool), GFP_KERNEL);
if (pool == NULL) { if (pool == NULL) {
snd_printd("seq: malloc failed for pool\n"); snd_printd("seq: malloc failed for pool\n");
return NULL; return NULL;

2
sound/core/seq/seq_midi.c
View File

@@ -322,7 +322,7 @@ snd_seq_midisynth_register_port(snd_seq_device_t *dev)
client = synths[card->number]; client = synths[card->number];
if (client == NULL) { if (client == NULL) {
newclient = 1; newclient = 1;
client = kcalloc(1, sizeof(*client), GFP_KERNEL); client = kzalloc(sizeof(*client), GFP_KERNEL);
if (client == NULL) { if (client == NULL) {
up(&register_mutex); up(&register_mutex);
kfree(info); kfree(info);

2
sound/core/seq/seq_midi_event.c
View File

@@ -118,7 +118,7 @@ int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev)
snd_midi_event_t *dev; snd_midi_event_t *dev;
*rdev = NULL; *rdev = NULL;
dev = kcalloc(1, sizeof(*dev), GFP_KERNEL); dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (dev == NULL) if (dev == NULL)
return -ENOMEM; return -ENOMEM;
if (bufsize > 0) { if (bufsize > 0) {

4
sound/core/seq/seq_ports.c
View File

@@ -141,7 +141,7 @@ client_port_t *snd_seq_create_port(client_t *client, int port)
} }
/* create a new port */ /* create a new port */
new_port = kcalloc(1, sizeof(*new_port), GFP_KERNEL); new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
if (! new_port) { if (! new_port) {
snd_printd("malloc failed for registering client port\n"); snd_printd("malloc failed for registering client port\n");
return NULL; /* failure, out of memory */ return NULL; /* failure, out of memory */
@@ -488,7 +488,7 @@ int snd_seq_port_connect(client_t *connector,
unsigned long flags; unsigned long flags;
int exclusive; int exclusive;
subs = kcalloc(1, sizeof(*subs), GFP_KERNEL); subs = kzalloc(sizeof(*subs), GFP_KERNEL);
if (! subs) if (! subs)
return -ENOMEM; return -ENOMEM;

2
sound/core/seq/seq_prioq.c
View File

@@ -59,7 +59,7 @@ prioq_t *snd_seq_prioq_new(void)
{ {
prioq_t *f; prioq_t *f;
f = kcalloc(1, sizeof(*f), GFP_KERNEL); f = kzalloc(sizeof(*f), GFP_KERNEL);
if (f == NULL) { if (f == NULL) {
snd_printd("oops: malloc failed for snd_seq_prioq_new()\n"); snd_printd("oops: malloc failed for snd_seq_prioq_new()\n");
return NULL; return NULL;

2
sound/core/seq/seq_queue.c
View File

@@ -111,7 +111,7 @@ static queue_t *queue_new(int owner, int locked)
{ {
queue_t *q; queue_t *q;
q = kcalloc(1, sizeof(*q), GFP_KERNEL); q = kzalloc(sizeof(*q), GFP_KERNEL);
if (q == NULL) { if (q == NULL) {
snd_printd("malloc failed for snd_seq_queue_new()\n"); snd_printd("malloc failed for snd_seq_queue_new()\n");
return NULL; return NULL;

4
sound/core/seq/seq_system.c
View File

@@ -126,8 +126,8 @@ int __init snd_seq_system_client_init(void)
snd_seq_client_info_t *inf; snd_seq_client_info_t *inf;
snd_seq_port_info_t *port; snd_seq_port_info_t *port;
inf = kcalloc(1, sizeof(*inf), GFP_KERNEL); inf = kzalloc(sizeof(*inf), GFP_KERNEL);
port = kcalloc(1, sizeof(*port), GFP_KERNEL); port = kzalloc(sizeof(*port), GFP_KERNEL);
if (! inf || ! port) { if (! inf || ! port) {
kfree(inf); kfree(inf);
kfree(port); kfree(port);

2
sound/core/seq/seq_timer.c
View File

@@ -60,7 +60,7 @@ seq_timer_t *snd_seq_timer_new(void)
{ {
seq_timer_t *tmr; seq_timer_t *tmr;
tmr = kcalloc(1, sizeof(*tmr), GFP_KERNEL); tmr = kzalloc(sizeof(*tmr), GFP_KERNEL);
if (tmr == NULL) { if (tmr == NULL) {
snd_printd("malloc failed for snd_seq_timer_new() \n"); snd_printd("malloc failed for snd_seq_timer_new() \n");
return NULL; return NULL;

6
sound/core/seq/seq_virmidi.c
View File

@@ -205,7 +205,7 @@ static int snd_virmidi_input_open(snd_rawmidi_substream_t * substream)
snd_virmidi_t *vmidi; snd_virmidi_t *vmidi;
unsigned long flags; unsigned long flags;
vmidi = kcalloc(1, sizeof(*vmidi), GFP_KERNEL); vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
if (vmidi == NULL) if (vmidi == NULL)
return -ENOMEM; return -ENOMEM;
vmidi->substream = substream; vmidi->substream = substream;
@@ -233,7 +233,7 @@ static int snd_virmidi_output_open(snd_rawmidi_substream_t * substream)
snd_rawmidi_runtime_t *runtime = substream->runtime; snd_rawmidi_runtime_t *runtime = substream->runtime;
snd_virmidi_t *vmidi; snd_virmidi_t *vmidi;
vmidi = kcalloc(1, sizeof(*vmidi), GFP_KERNEL); vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
if (vmidi == NULL) if (vmidi == NULL)
return -ENOMEM; return -ENOMEM;
vmidi->substream = substream; vmidi->substream = substream;
@@ -508,7 +508,7 @@ int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi)
&rmidi)) < 0) &rmidi)) < 0)
return err; return err;
strcpy(rmidi->name, rmidi->id); strcpy(rmidi->name, rmidi->id);
rdev = kcalloc(1, sizeof(*rdev), GFP_KERNEL); rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
if (rdev == NULL) { if (rdev == NULL) {
snd_device_free(card, rmidi); snd_device_free(card, rmidi);
return -ENOMEM; return -ENOMEM;