[PATCH] use kzalloc and kcalloc in core fs code
authorOliver Neukum <neukum@fachschaft.cup.uni-muenchen.de>
Sat, 25 Mar 2006 11:08:13 +0000 (03:08 -0800)
committerLinus Torvalds <torvalds@g5.osdl.org>
Sat, 25 Mar 2006 16:23:00 +0000 (08:23 -0800)
Signed-off-by: Oliver Neukum <oliver@neukum.name>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
fs/aio.c
fs/binfmt_elf.c
fs/bio.c
fs/char_dev.c
fs/compat.c
fs/exec.c
fs/pipe.c
fs/super.c

index aec2b1916d1b27e4bc9411212359801b8ba70386..e41e932ba489ff040fe9ed43385fc164a8dd6515 100644 (file)
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -122,10 +122,9 @@ static int aio_setup_ring(struct kioctx *ctx)
        info->nr = 0;
        info->ring_pages = info->internal_pages;
        if (nr_pages > AIO_RING_PAGES) {
-               info->ring_pages = kmalloc(sizeof(struct page *) * nr_pages, GFP_KERNEL);
+               info->ring_pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
                if (!info->ring_pages)
                        return -ENOMEM;
-               memset(info->ring_pages, 0, sizeof(struct page *) * nr_pages);
        }
 
        info->mmap_size = nr_pages * PAGE_SIZE;
index c2eac2a50bd266889786d9eb825fdb96fa1e2d19..61c21e7dc95d62b55225aa46c76ba2d661873c1d 100644 (file)
@@ -1465,12 +1465,11 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
                read_lock(&tasklist_lock);
                do_each_thread(g,p)
                        if (current->mm == p->mm && current != p) {
-                               tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);
+                               tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
                                if (!tmp) {
                                        read_unlock(&tasklist_lock);
                                        goto cleanup;
                                }
-                               memset(tmp, 0, sizeof(*tmp));
                                INIT_LIST_HEAD(&tmp->list);
                                tmp->thread = p;
                                list_add(&tmp->list, &thread_list);
index 0a8c59cb68f527fd98152d12a10ef1eb2e7f049c..73e664c01d30075064cc14b533d9d0d72b1d871f 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -636,12 +636,10 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
                return ERR_PTR(-ENOMEM);
 
        ret = -ENOMEM;
-       pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL);
+       pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
        if (!pages)
                goto out;
 
-       memset(pages, 0, nr_pages * sizeof(struct page *));
-
        for (i = 0; i < iov_count; i++) {
                unsigned long uaddr = (unsigned long)iov[i].iov_base;
                unsigned long len = iov[i].iov_len;
@@ -1186,12 +1184,11 @@ void bioset_free(struct bio_set *bs)
 
 struct bio_set *bioset_create(int bio_pool_size, int bvec_pool_size, int scale)
 {
-       struct bio_set *bs = kmalloc(sizeof(*bs), GFP_KERNEL);
+       struct bio_set *bs = kzalloc(sizeof(*bs), GFP_KERNEL);
 
        if (!bs)
                return NULL;
 
-       memset(bs, 0, sizeof(*bs));
        bs->bio_pool = mempool_create(bio_pool_size, mempool_alloc_slab,
                        mempool_free_slab, bio_slab);
 
index 5c36345c9bf78376b6996604d98aba2679d6ed09..8c6eb04d31e2ab9033a067fc42393d5fa8c38a60 100644 (file)
@@ -146,12 +146,10 @@ __register_chrdev_region(unsigned int major, unsigned int baseminor,
        int ret = 0;
        int i;
 
-       cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);
+       cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
        if (cd == NULL)
                return ERR_PTR(-ENOMEM);
 
-       memset(cd, 0, sizeof(struct char_device_struct));
-
        mutex_lock(&chrdevs_lock);
 
        /* temporary */
@@ -466,9 +464,8 @@ static struct kobj_type ktype_cdev_dynamic = {
 
 struct cdev *cdev_alloc(void)
 {
-       struct cdev *p = kmalloc(sizeof(struct cdev), GFP_KERNEL);
+       struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
        if (p) {
-               memset(p, 0, sizeof(struct cdev));
                p->kobj.ktype = &ktype_cdev_dynamic;
                INIT_LIST_HEAD(&p->list);
                kobject_init(&p->kobj);
index 263990ae409664351368369f926f0ae30ffc32ae..ef5a0771592d1a5d30d2cb9eb53799ed2c862520 100644 (file)
@@ -1476,10 +1476,9 @@ int compat_do_execve(char * filename,
        int i;
 
        retval = -ENOMEM;
-       bprm = kmalloc(sizeof(*bprm), GFP_KERNEL);
+       bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
        if (!bprm)
                goto out_ret;
-       memset(bprm, 0, sizeof(*bprm));
 
        file = open_exec(filename);
        retval = PTR_ERR(file);
index d8c477a56257d16d19a3f182309f9d26b1a4a1b0..995cba3c62b86fe51f7f21688892e534ce30e087 100644 (file)
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1143,10 +1143,9 @@ int do_execve(char * filename,
        int i;
 
        retval = -ENOMEM;
-       bprm = kmalloc(sizeof(*bprm), GFP_KERNEL);
+       bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
        if (!bprm)
                goto out_ret;
-       memset(bprm, 0, sizeof(*bprm));
 
        file = open_exec(filename);
        retval = PTR_ERR(file);
index 8aada8e426f44f12095b59810c5f270bc128f014..d976866a115b8e0b975e3cea3c7ccdecb74a6d12 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -662,10 +662,9 @@ struct inode* pipe_new(struct inode* inode)
 {
        struct pipe_inode_info *info;
 
-       info = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+       info = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
        if (!info)
                goto fail_page;
-       memset(info, 0, sizeof(*info));
        inode->i_pipe = info;
 
        init_waitqueue_head(PIPE_WAIT(*inode));
index 37554b8761829309b773e6f38b3a88e0be9ac761..8743e9bbb297e939563d5bd3ea8e7de9c2ae74ef 100644 (file)
@@ -55,11 +55,10 @@ DEFINE_SPINLOCK(sb_lock);
  */
 static struct super_block *alloc_super(void)
 {
-       struct super_block *s = kmalloc(sizeof(struct super_block),  GFP_USER);
+       struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
        static struct super_operations default_op;
 
        if (s) {
-               memset(s, 0, sizeof(struct super_block));
                if (security_sb_alloc(s)) {
                        kfree(s);
                        s = NULL;