diff options
author | Panagiotis Issaris <takis@issaris.org> | 2006-07-21 17:51:30 -0400 |
---|---|---|
committer | David S. Miller <davem@davemloft.net> | 2006-07-21 17:51:30 -0400 |
commit | 0da974f4f303a6842516b764507e3c0a03f41e5a (patch) | |
tree | 8872aec792f02040269c6769dd1009b20f71d186 /net/irda | |
parent | a0ee7c70b22f78593957f99faa06acb4747b8bc0 (diff) |
[NET]: Conversions from kmalloc+memset to k(z|c)alloc.
Signed-off-by: Panagiotis Issaris <takis@issaris.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'net/irda')
-rw-r--r-- | net/irda/ircomm/ircomm_core.c | 4 | ||||
-rw-r--r-- | net/irda/ircomm/ircomm_tty.c | 3 | ||||
-rw-r--r-- | net/irda/irda_device.c | 4 | ||||
-rw-r--r-- | net/irda/irias_object.c | 24 | ||||
-rw-r--r-- | net/irda/irlap.c | 6 | ||||
-rw-r--r-- | net/irda/irlap_frame.c | 3 | ||||
-rw-r--r-- | net/irda/irlmp.c | 9 | ||||
-rw-r--r-- | net/irda/irnet/irnet_ppp.c | 3 | ||||
-rw-r--r-- | net/irda/irttp.c | 9 |
9 files changed, 21 insertions, 44 deletions
diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c index 9c4a902a9dba..ad6b6af3dd97 100644 --- a/net/irda/ircomm/ircomm_core.c +++ b/net/irda/ircomm/ircomm_core.c | |||
@@ -115,12 +115,10 @@ struct ircomm_cb *ircomm_open(notify_t *notify, __u8 service_type, int line) | |||
115 | 115 | ||
116 | IRDA_ASSERT(ircomm != NULL, return NULL;); | 116 | IRDA_ASSERT(ircomm != NULL, return NULL;); |
117 | 117 | ||
118 | self = kmalloc(sizeof(struct ircomm_cb), GFP_ATOMIC); | 118 | self = kzalloc(sizeof(struct ircomm_cb), GFP_ATOMIC); |
119 | if (self == NULL) | 119 | if (self == NULL) |
120 | return NULL; | 120 | return NULL; |
121 | 121 | ||
122 | memset(self, 0, sizeof(struct ircomm_cb)); | ||
123 | |||
124 | self->notify = *notify; | 122 | self->notify = *notify; |
125 | self->magic = IRCOMM_MAGIC; | 123 | self->magic = IRCOMM_MAGIC; |
126 | 124 | ||
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c index cde3b84d4a0e..3bcdb467efc5 100644 --- a/net/irda/ircomm/ircomm_tty.c +++ b/net/irda/ircomm/ircomm_tty.c | |||
@@ -379,12 +379,11 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) | |||
379 | self = hashbin_lock_find(ircomm_tty, line, NULL); | 379 | self = hashbin_lock_find(ircomm_tty, line, NULL); |
380 | if (!self) { | 380 | if (!self) { |
381 | /* No, so make new instance */ | 381 | /* No, so make new instance */ |
382 | self = kmalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL); | 382 | self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL); |
383 | if (self == NULL) { | 383 | if (self == NULL) { |
384 | IRDA_ERROR("%s(), kmalloc failed!\n", __FUNCTION__); | 384 | IRDA_ERROR("%s(), kmalloc failed!\n", __FUNCTION__); |
385 | return -ENOMEM; | 385 | return -ENOMEM; |
386 | } | 386 | } |
387 | memset(self, 0, sizeof(struct ircomm_tty_cb)); | ||
388 | 387 | ||
389 | self->magic = IRCOMM_TTY_MAGIC; | 388 | self->magic = IRCOMM_TTY_MAGIC; |
390 | self->flow = FLOW_STOP; | 389 | self->flow = FLOW_STOP; |
diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c index ba40e5495f58..7e7a31798d8d 100644 --- a/net/irda/irda_device.c +++ b/net/irda/irda_device.c | |||
@@ -401,12 +401,10 @@ dongle_t *irda_device_dongle_init(struct net_device *dev, int type) | |||
401 | } | 401 | } |
402 | 402 | ||
403 | /* Allocate dongle info for this instance */ | 403 | /* Allocate dongle info for this instance */ |
404 | dongle = kmalloc(sizeof(dongle_t), GFP_KERNEL); | 404 | dongle = kzalloc(sizeof(dongle_t), GFP_KERNEL); |
405 | if (!dongle) | 405 | if (!dongle) |
406 | goto out; | 406 | goto out; |
407 | 407 | ||
408 | memset(dongle, 0, sizeof(dongle_t)); | ||
409 | |||
410 | /* Bind the registration info to this particular instance */ | 408 | /* Bind the registration info to this particular instance */ |
411 | dongle->issue = reg; | 409 | dongle->issue = reg; |
412 | dongle->dev = dev; | 410 | dongle->dev = dev; |
diff --git a/net/irda/irias_object.c b/net/irda/irias_object.c index 82e665c79991..a154b1d71c0f 100644 --- a/net/irda/irias_object.c +++ b/net/irda/irias_object.c | |||
@@ -82,13 +82,12 @@ struct ias_object *irias_new_object( char *name, int id) | |||
82 | 82 | ||
83 | IRDA_DEBUG( 4, "%s()\n", __FUNCTION__); | 83 | IRDA_DEBUG( 4, "%s()\n", __FUNCTION__); |
84 | 84 | ||
85 | obj = kmalloc(sizeof(struct ias_object), GFP_ATOMIC); | 85 | obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC); |
86 | if (obj == NULL) { | 86 | if (obj == NULL) { |
87 | IRDA_WARNING("%s(), Unable to allocate object!\n", | 87 | IRDA_WARNING("%s(), Unable to allocate object!\n", |
88 | __FUNCTION__); | 88 | __FUNCTION__); |
89 | return NULL; | 89 | return NULL; |
90 | } | 90 | } |
91 | memset(obj, 0, sizeof( struct ias_object)); | ||
92 | 91 | ||
93 | obj->magic = IAS_OBJECT_MAGIC; | 92 | obj->magic = IAS_OBJECT_MAGIC; |
94 | obj->name = strndup(name, IAS_MAX_CLASSNAME); | 93 | obj->name = strndup(name, IAS_MAX_CLASSNAME); |
@@ -346,13 +345,12 @@ void irias_add_integer_attrib(struct ias_object *obj, char *name, int value, | |||
346 | IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;); | 345 | IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;); |
347 | IRDA_ASSERT(name != NULL, return;); | 346 | IRDA_ASSERT(name != NULL, return;); |
348 | 347 | ||
349 | attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC); | 348 | attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC); |
350 | if (attrib == NULL) { | 349 | if (attrib == NULL) { |
351 | IRDA_WARNING("%s: Unable to allocate attribute!\n", | 350 | IRDA_WARNING("%s: Unable to allocate attribute!\n", |
352 | __FUNCTION__); | 351 | __FUNCTION__); |
353 | return; | 352 | return; |
354 | } | 353 | } |
355 | memset(attrib, 0, sizeof( struct ias_attrib)); | ||
356 | 354 | ||
357 | attrib->magic = IAS_ATTRIB_MAGIC; | 355 | attrib->magic = IAS_ATTRIB_MAGIC; |
358 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); | 356 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); |
@@ -382,13 +380,12 @@ void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets, | |||
382 | IRDA_ASSERT(name != NULL, return;); | 380 | IRDA_ASSERT(name != NULL, return;); |
383 | IRDA_ASSERT(octets != NULL, return;); | 381 | IRDA_ASSERT(octets != NULL, return;); |
384 | 382 | ||
385 | attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC); | 383 | attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC); |
386 | if (attrib == NULL) { | 384 | if (attrib == NULL) { |
387 | IRDA_WARNING("%s: Unable to allocate attribute!\n", | 385 | IRDA_WARNING("%s: Unable to allocate attribute!\n", |
388 | __FUNCTION__); | 386 | __FUNCTION__); |
389 | return; | 387 | return; |
390 | } | 388 | } |
391 | memset(attrib, 0, sizeof( struct ias_attrib)); | ||
392 | 389 | ||
393 | attrib->magic = IAS_ATTRIB_MAGIC; | 390 | attrib->magic = IAS_ATTRIB_MAGIC; |
394 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); | 391 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); |
@@ -416,13 +413,12 @@ void irias_add_string_attrib(struct ias_object *obj, char *name, char *value, | |||
416 | IRDA_ASSERT(name != NULL, return;); | 413 | IRDA_ASSERT(name != NULL, return;); |
417 | IRDA_ASSERT(value != NULL, return;); | 414 | IRDA_ASSERT(value != NULL, return;); |
418 | 415 | ||
419 | attrib = kmalloc(sizeof( struct ias_attrib), GFP_ATOMIC); | 416 | attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC); |
420 | if (attrib == NULL) { | 417 | if (attrib == NULL) { |
421 | IRDA_WARNING("%s: Unable to allocate attribute!\n", | 418 | IRDA_WARNING("%s: Unable to allocate attribute!\n", |
422 | __FUNCTION__); | 419 | __FUNCTION__); |
423 | return; | 420 | return; |
424 | } | 421 | } |
425 | memset(attrib, 0, sizeof( struct ias_attrib)); | ||
426 | 422 | ||
427 | attrib->magic = IAS_ATTRIB_MAGIC; | 423 | attrib->magic = IAS_ATTRIB_MAGIC; |
428 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); | 424 | attrib->name = strndup(name, IAS_MAX_ATTRIBNAME); |
@@ -443,12 +439,11 @@ struct ias_value *irias_new_integer_value(int integer) | |||
443 | { | 439 | { |
444 | struct ias_value *value; | 440 | struct ias_value *value; |
445 | 441 | ||
446 | value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC); | 442 | value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC); |
447 | if (value == NULL) { | 443 | if (value == NULL) { |
448 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); | 444 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); |
449 | return NULL; | 445 | return NULL; |
450 | } | 446 | } |
451 | memset(value, 0, sizeof(struct ias_value)); | ||
452 | 447 | ||
453 | value->type = IAS_INTEGER; | 448 | value->type = IAS_INTEGER; |
454 | value->len = 4; | 449 | value->len = 4; |
@@ -469,12 +464,11 @@ struct ias_value *irias_new_string_value(char *string) | |||
469 | { | 464 | { |
470 | struct ias_value *value; | 465 | struct ias_value *value; |
471 | 466 | ||
472 | value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC); | 467 | value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC); |
473 | if (value == NULL) { | 468 | if (value == NULL) { |
474 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); | 469 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); |
475 | return NULL; | 470 | return NULL; |
476 | } | 471 | } |
477 | memset( value, 0, sizeof( struct ias_value)); | ||
478 | 472 | ||
479 | value->type = IAS_STRING; | 473 | value->type = IAS_STRING; |
480 | value->charset = CS_ASCII; | 474 | value->charset = CS_ASCII; |
@@ -495,12 +489,11 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len) | |||
495 | { | 489 | { |
496 | struct ias_value *value; | 490 | struct ias_value *value; |
497 | 491 | ||
498 | value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC); | 492 | value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC); |
499 | if (value == NULL) { | 493 | if (value == NULL) { |
500 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); | 494 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); |
501 | return NULL; | 495 | return NULL; |
502 | } | 496 | } |
503 | memset(value, 0, sizeof(struct ias_value)); | ||
504 | 497 | ||
505 | value->type = IAS_OCT_SEQ; | 498 | value->type = IAS_OCT_SEQ; |
506 | /* Check length */ | 499 | /* Check length */ |
@@ -522,12 +515,11 @@ struct ias_value *irias_new_missing_value(void) | |||
522 | { | 515 | { |
523 | struct ias_value *value; | 516 | struct ias_value *value; |
524 | 517 | ||
525 | value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC); | 518 | value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC); |
526 | if (value == NULL) { | 519 | if (value == NULL) { |
527 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); | 520 | IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__); |
528 | return NULL; | 521 | return NULL; |
529 | } | 522 | } |
530 | memset(value, 0, sizeof(struct ias_value)); | ||
531 | 523 | ||
532 | value->type = IAS_MISSING; | 524 | value->type = IAS_MISSING; |
533 | value->len = 0; | 525 | value->len = 0; |
diff --git a/net/irda/irlap.c b/net/irda/irlap.c index 9199c124d200..e7852a07495e 100644 --- a/net/irda/irlap.c +++ b/net/irda/irlap.c | |||
@@ -116,11 +116,10 @@ struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos, | |||
116 | IRDA_DEBUG(4, "%s()\n", __FUNCTION__); | 116 | IRDA_DEBUG(4, "%s()\n", __FUNCTION__); |
117 | 117 | ||
118 | /* Initialize the irlap structure. */ | 118 | /* Initialize the irlap structure. */ |
119 | self = kmalloc(sizeof(struct irlap_cb), GFP_KERNEL); | 119 | self = kzalloc(sizeof(struct irlap_cb), GFP_KERNEL); |
120 | if (self == NULL) | 120 | if (self == NULL) |
121 | return NULL; | 121 | return NULL; |
122 | 122 | ||
123 | memset(self, 0, sizeof(struct irlap_cb)); | ||
124 | self->magic = LAP_MAGIC; | 123 | self->magic = LAP_MAGIC; |
125 | 124 | ||
126 | /* Make a binding between the layers */ | 125 | /* Make a binding between the layers */ |
@@ -1222,7 +1221,7 @@ static int irlap_seq_open(struct inode *inode, struct file *file) | |||
1222 | { | 1221 | { |
1223 | struct seq_file *seq; | 1222 | struct seq_file *seq; |
1224 | int rc = -ENOMEM; | 1223 | int rc = -ENOMEM; |
1225 | struct irlap_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL); | 1224 | struct irlap_iter_state *s = kzalloc(sizeof(*s), GFP_KERNEL); |
1226 | 1225 | ||
1227 | if (!s) | 1226 | if (!s) |
1228 | goto out; | 1227 | goto out; |
@@ -1238,7 +1237,6 @@ static int irlap_seq_open(struct inode *inode, struct file *file) | |||
1238 | 1237 | ||
1239 | seq = file->private_data; | 1238 | seq = file->private_data; |
1240 | seq->private = s; | 1239 | seq->private = s; |
1241 | memset(s, 0, sizeof(*s)); | ||
1242 | out: | 1240 | out: |
1243 | return rc; | 1241 | return rc; |
1244 | out_kfree: | 1242 | out_kfree: |
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c index fa5c144ecc0b..ccb983bf0f4a 100644 --- a/net/irda/irlap_frame.c +++ b/net/irda/irlap_frame.c | |||
@@ -422,11 +422,10 @@ static void irlap_recv_discovery_xid_rsp(struct irlap_cb *self, | |||
422 | return; | 422 | return; |
423 | } | 423 | } |
424 | 424 | ||
425 | if ((discovery = kmalloc(sizeof(discovery_t), GFP_ATOMIC)) == NULL) { | 425 | if ((discovery = kzalloc(sizeof(discovery_t), GFP_ATOMIC)) == NULL) { |
426 | IRDA_WARNING("%s: kmalloc failed!\n", __FUNCTION__); | 426 | IRDA_WARNING("%s: kmalloc failed!\n", __FUNCTION__); |
427 | return; | 427 | return; |
428 | } | 428 | } |
429 | memset(discovery, 0, sizeof(discovery_t)); | ||
430 | 429 | ||
431 | discovery->data.daddr = info->daddr; | 430 | discovery->data.daddr = info->daddr; |
432 | discovery->data.saddr = self->saddr; | 431 | discovery->data.saddr = self->saddr; |
diff --git a/net/irda/irlmp.c b/net/irda/irlmp.c index 5ee79462b30a..c440913dee14 100644 --- a/net/irda/irlmp.c +++ b/net/irda/irlmp.c | |||
@@ -78,10 +78,9 @@ int __init irlmp_init(void) | |||
78 | { | 78 | { |
79 | IRDA_DEBUG(1, "%s()\n", __FUNCTION__); | 79 | IRDA_DEBUG(1, "%s()\n", __FUNCTION__); |
80 | /* Initialize the irlmp structure. */ | 80 | /* Initialize the irlmp structure. */ |
81 | irlmp = kmalloc( sizeof(struct irlmp_cb), GFP_KERNEL); | 81 | irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL); |
82 | if (irlmp == NULL) | 82 | if (irlmp == NULL) |
83 | return -ENOMEM; | 83 | return -ENOMEM; |
84 | memset(irlmp, 0, sizeof(struct irlmp_cb)); | ||
85 | 84 | ||
86 | irlmp->magic = LMP_MAGIC; | 85 | irlmp->magic = LMP_MAGIC; |
87 | 86 | ||
@@ -160,12 +159,11 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid) | |||
160 | return NULL; | 159 | return NULL; |
161 | 160 | ||
162 | /* Allocate new instance of a LSAP connection */ | 161 | /* Allocate new instance of a LSAP connection */ |
163 | self = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC); | 162 | self = kzalloc(sizeof(struct lsap_cb), GFP_ATOMIC); |
164 | if (self == NULL) { | 163 | if (self == NULL) { |
165 | IRDA_ERROR("%s: can't allocate memory\n", __FUNCTION__); | 164 | IRDA_ERROR("%s: can't allocate memory\n", __FUNCTION__); |
166 | return NULL; | 165 | return NULL; |
167 | } | 166 | } |
168 | memset(self, 0, sizeof(struct lsap_cb)); | ||
169 | 167 | ||
170 | self->magic = LMP_LSAP_MAGIC; | 168 | self->magic = LMP_LSAP_MAGIC; |
171 | self->slsap_sel = slsap_sel; | 169 | self->slsap_sel = slsap_sel; |
@@ -288,12 +286,11 @@ void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify) | |||
288 | /* | 286 | /* |
289 | * Allocate new instance of a LSAP connection | 287 | * Allocate new instance of a LSAP connection |
290 | */ | 288 | */ |
291 | lap = kmalloc(sizeof(struct lap_cb), GFP_KERNEL); | 289 | lap = kzalloc(sizeof(struct lap_cb), GFP_KERNEL); |
292 | if (lap == NULL) { | 290 | if (lap == NULL) { |
293 | IRDA_ERROR("%s: unable to kmalloc\n", __FUNCTION__); | 291 | IRDA_ERROR("%s: unable to kmalloc\n", __FUNCTION__); |
294 | return; | 292 | return; |
295 | } | 293 | } |
296 | memset(lap, 0, sizeof(struct lap_cb)); | ||
297 | 294 | ||
298 | lap->irlap = irlap; | 295 | lap->irlap = irlap; |
299 | lap->magic = LMP_LAP_MAGIC; | 296 | lap->magic = LMP_LAP_MAGIC; |
diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c index e53bf9e0053e..a1e502ff9070 100644 --- a/net/irda/irnet/irnet_ppp.c +++ b/net/irda/irnet/irnet_ppp.c | |||
@@ -476,11 +476,10 @@ dev_irnet_open(struct inode * inode, | |||
476 | #endif /* SECURE_DEVIRNET */ | 476 | #endif /* SECURE_DEVIRNET */ |
477 | 477 | ||
478 | /* Allocate a private structure for this IrNET instance */ | 478 | /* Allocate a private structure for this IrNET instance */ |
479 | ap = kmalloc(sizeof(*ap), GFP_KERNEL); | 479 | ap = kzalloc(sizeof(*ap), GFP_KERNEL); |
480 | DABORT(ap == NULL, -ENOMEM, FS_ERROR, "Can't allocate struct irnet...\n"); | 480 | DABORT(ap == NULL, -ENOMEM, FS_ERROR, "Can't allocate struct irnet...\n"); |
481 | 481 | ||
482 | /* initialize the irnet structure */ | 482 | /* initialize the irnet structure */ |
483 | memset(ap, 0, sizeof(*ap)); | ||
484 | ap->file = file; | 483 | ap->file = file; |
485 | 484 | ||
486 | /* PPP channel setup */ | 485 | /* PPP channel setup */ |
diff --git a/net/irda/irttp.c b/net/irda/irttp.c index 7a3ccb8a6698..42acf1cde737 100644 --- a/net/irda/irttp.c +++ b/net/irda/irttp.c | |||
@@ -85,10 +85,9 @@ static pi_param_info_t param_info = { pi_major_call_table, 1, 0x0f, 4 }; | |||
85 | */ | 85 | */ |
86 | int __init irttp_init(void) | 86 | int __init irttp_init(void) |
87 | { | 87 | { |
88 | irttp = kmalloc(sizeof(struct irttp_cb), GFP_KERNEL); | 88 | irttp = kzalloc(sizeof(struct irttp_cb), GFP_KERNEL); |
89 | if (irttp == NULL) | 89 | if (irttp == NULL) |
90 | return -ENOMEM; | 90 | return -ENOMEM; |
91 | memset(irttp, 0, sizeof(struct irttp_cb)); | ||
92 | 91 | ||
93 | irttp->magic = TTP_MAGIC; | 92 | irttp->magic = TTP_MAGIC; |
94 | 93 | ||
@@ -390,12 +389,11 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify) | |||
390 | return NULL; | 389 | return NULL; |
391 | } | 390 | } |
392 | 391 | ||
393 | self = kmalloc(sizeof(struct tsap_cb), GFP_ATOMIC); | 392 | self = kzalloc(sizeof(struct tsap_cb), GFP_ATOMIC); |
394 | if (self == NULL) { | 393 | if (self == NULL) { |
395 | IRDA_DEBUG(0, "%s(), unable to kmalloc!\n", __FUNCTION__); | 394 | IRDA_DEBUG(0, "%s(), unable to kmalloc!\n", __FUNCTION__); |
396 | return NULL; | 395 | return NULL; |
397 | } | 396 | } |
398 | memset(self, 0, sizeof(struct tsap_cb)); | ||
399 | spin_lock_init(&self->lock); | 397 | spin_lock_init(&self->lock); |
400 | 398 | ||
401 | /* Initialise todo timer */ | 399 | /* Initialise todo timer */ |
@@ -1877,7 +1875,7 @@ static int irttp_seq_open(struct inode *inode, struct file *file) | |||
1877 | int rc = -ENOMEM; | 1875 | int rc = -ENOMEM; |
1878 | struct irttp_iter_state *s; | 1876 | struct irttp_iter_state *s; |
1879 | 1877 | ||
1880 | s = kmalloc(sizeof(*s), GFP_KERNEL); | 1878 | s = kzalloc(sizeof(*s), GFP_KERNEL); |
1881 | if (!s) | 1879 | if (!s) |
1882 | goto out; | 1880 | goto out; |
1883 | 1881 | ||
@@ -1887,7 +1885,6 @@ static int irttp_seq_open(struct inode *inode, struct file *file) | |||
1887 | 1885 | ||
1888 | seq = file->private_data; | 1886 | seq = file->private_data; |
1889 | seq->private = s; | 1887 | seq->private = s; |
1890 | memset(s, 0, sizeof(*s)); | ||
1891 | out: | 1888 | out: |
1892 | return rc; | 1889 | return rc; |
1893 | out_kfree: | 1890 | out_kfree: |