14 files changed, 17 insertions, 36 deletions

diff --git a/fs/aio.c b/fs/aio.c
index ee662589e5ec..0b4ee0a5c83e 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -211,11 +211,10 @@ static struct kioctx *ioctx_alloc(unsigned nr_events)
         if ((unsigned long)nr_events > aio_max_nr)
                 return ERR_PTR(-EAGAIN);
 
-        ctx = kmem_cache_alloc(kioctx_cachep, GFP_KERNEL);
+        ctx = kmem_cache_zalloc(kioctx_cachep, GFP_KERNEL);
         if (!ctx)
                 return ERR_PTR(-ENOMEM);
 
-        memset(ctx, 0, sizeof(*ctx));
         ctx->max_reqs = nr_events;
         mm = ctx->mm = current->mm;
         atomic_inc(&mm->mm_count);
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 1814ba446809..9371ee209954 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -72,11 +72,10 @@ static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent * pare
 {
         struct configfs_dirent * sd;
 
-        sd = kmem_cache_alloc(configfs_dir_cachep, GFP_KERNEL);
+        sd = kmem_cache_zalloc(configfs_dir_cachep, GFP_KERNEL);
         if (!sd)
                 return NULL;
 
-        memset(sd, 0, sizeof(*sd));
         atomic_set(&sd->s_count, 1);
         INIT_LIST_HEAD(&sd->s_links);
         INIT_LIST_HEAD(&sd->s_children);
diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
index 5352b03ff5aa..f858fef6e41c 100644
--- a/fs/dlm/memory.c
+++ b/fs/dlm/memory.c
@@ -76,9 +76,7 @@ struct dlm_lkb *allocate_lkb(struct dlm_ls *ls)
 {
         struct dlm_lkb *lkb;
 
-        lkb = kmem_cache_alloc(lkb_cache, GFP_KERNEL);
-        if (lkb)
-                memset(lkb, 0, sizeof(*lkb));
+        lkb = kmem_cache_zalloc(lkb_cache, GFP_KERNEL);
         return lkb;
 }
 
diff --git a/fs/dquot.c b/fs/dquot.c
index 0952cc474d9a..a561fb29e203 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -600,11 +600,10 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
 {
         struct dquot *dquot;
 
-        dquot = kmem_cache_alloc(dquot_cachep, GFP_NOFS);
+        dquot = kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
         if(!dquot)
                 return NODQUOT;
 
-        memset((caddr_t)dquot, 0, sizeof(struct dquot));
         mutex_init(&dquot->dq_lock);
         INIT_LIST_HEAD(&dquot->dq_free);
         INIT_LIST_HEAD(&dquot->dq_inuse);
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index a86a55ccf874..75bbfae55081 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1332,13 +1332,13 @@ int ecryptfs_write_headers(struct dentry *ecryptfs_dentry,
                 goto out;
         }
         /* Released in this function */
-        page_virt = kmem_cache_alloc(ecryptfs_header_cache_0, GFP_USER);
+        page_virt = kmem_cache_zalloc(ecryptfs_header_cache_0, GFP_USER);
         if (!page_virt) {
                 ecryptfs_printk(KERN_ERR, "Out of memory\n");
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(page_virt, 0, PAGE_CACHE_SIZE);
+
         rc = ecryptfs_write_headers_virt(page_virt, crypt_stat,
                                          ecryptfs_dentry);
         if (unlikely(rc)) {
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index c5a2e5298f15..779c3477d93c 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -251,7 +251,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
         int lower_flags;
 
         /* Released in ecryptfs_release or end of function if failure */
-        file_info = kmem_cache_alloc(ecryptfs_file_info_cache, GFP_KERNEL);
+        file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
         ecryptfs_set_file_private(file, file_info);
         if (!file_info) {
                 ecryptfs_printk(KERN_ERR,
@@ -259,7 +259,6 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(file_info, 0, sizeof(*file_info));
         lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
         crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
         mount_crypt_stat = &ecryptfs_superblock_to_private(
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 11f5e5076aef..d4f02f3e18d7 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -361,8 +361,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 goto out;
         }
         /* Released in this function */
-        page_virt =
-            (char *)kmem_cache_alloc(ecryptfs_header_cache_2,
+        page_virt = kmem_cache_zalloc(ecryptfs_header_cache_2,
                                      GFP_USER);
         if (!page_virt) {
                 rc = -ENOMEM;
@@ -370,7 +369,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                                 "Cannot ecryptfs_kmalloc a page\n");
                 goto out_dput;
         }
-        memset(page_virt, 0, PAGE_CACHE_SIZE);
+
         rc = ecryptfs_read_header_region(page_virt, lower_dentry, nd->mnt);
         crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
         if (!ECRYPTFS_CHECK_FLAG(crypt_stat->flags, ECRYPTFS_POLICY_APPLIED))
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index 745c0f1bfbbd..80bccd5ff8e6 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -207,14 +207,12 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
          * at end of function upon failure */
         auth_tok_list_item =
-            kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
+            kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
         if (!auth_tok_list_item) {
                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(auth_tok_list_item, 0,
-               sizeof(struct ecryptfs_auth_tok_list_item));
         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
 
         /* check for body size - one to two bytes */
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index d0541ae8faba..fe41ab1566ee 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -378,15 +378,13 @@ ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
 
         /* Released in ecryptfs_put_super() */
         ecryptfs_set_superblock_private(sb,
-                                        kmem_cache_alloc(ecryptfs_sb_info_cache,
+                                        kmem_cache_zalloc(ecryptfs_sb_info_cache,
                                                          GFP_KERNEL));
         if (!ecryptfs_superblock_to_private(sb)) {
                 ecryptfs_printk(KERN_WARNING, "Out of memory\n");
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(ecryptfs_superblock_to_private(sb), 0,
-               sizeof(struct ecryptfs_sb_info));
         sb->s_op = &ecryptfs_sops;
         /* Released through deactivate_super(sb) from get_sb_nodev */
         sb->s_root = d_alloc(NULL, &(const struct qstr) {
@@ -402,7 +400,7 @@ ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
         /* Released in d_release when dput(sb->s_root) is called */
         /* through deactivate_super(sb) from get_sb_nodev() */
         ecryptfs_set_dentry_private(sb->s_root,
-                                    kmem_cache_alloc(ecryptfs_dentry_info_cache,
+                                    kmem_cache_zalloc(ecryptfs_dentry_info_cache,
                                                      GFP_KERNEL));
         if (!ecryptfs_dentry_to_private(sb->s_root)) {
                 ecryptfs_printk(KERN_ERR,
@@ -410,8 +408,6 @@ ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(ecryptfs_dentry_to_private(sb->s_root), 0,
-               sizeof(struct ecryptfs_dentry_info));
         rc = 0;
 out:
         /* Should be able to rely on deactivate_super called from
diff --git a/fs/exec.c b/fs/exec.c
index 11fe93f7363c..7e36c6f6f538 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -405,12 +405,10 @@ int setup_arg_pages(struct linux_binprm *bprm,
                 bprm->loader += stack_base;
         bprm->exec += stack_base;
 
-        mpnt = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
+        mpnt = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
         if (!mpnt)
                 return -ENOMEM;
 
-        memset(mpnt, 0, sizeof(*mpnt));
-
         down_write(&mm->mmap_sem);
         {
                 mpnt->vm_mm = mm;
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 0e34d9918973..e62d4f620c58 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -282,8 +282,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
                 return;
         }
 
-        bd = kmem_cache_alloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),
-        memset(bd, 0, sizeof(struct gfs2_bufdata));
+        bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),
         bd->bd_bh = bh;
         bd->bd_gl = gl;
 
diff --git a/fs/namespace.c b/fs/namespace.c
index 5ef336c1103c..fd999cab7b57 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -53,9 +53,8 @@ static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry)
 
 struct vfsmount *alloc_vfsmnt(const char *name)
 {
-        struct vfsmount *mnt = kmem_cache_alloc(mnt_cache, GFP_KERNEL);
+        struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
         if (mnt) {
-                memset(mnt, 0, sizeof(struct vfsmount));
                 atomic_set(&mnt->mnt_count, 1);
                 INIT_LIST_HEAD(&mnt->mnt_hash);
                 INIT_LIST_HEAD(&mnt->mnt_child);
diff --git a/fs/smbfs/request.c b/fs/smbfs/request.c
index a4bcae8a9aff..42261dbdf60f 100644
--- a/fs/smbfs/request.c
+++ b/fs/smbfs/request.c
@@ -61,7 +61,7 @@ static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
         struct smb_request *req;
         unsigned char *buf = NULL;
 
-        req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
+        req = kmem_cache_zalloc(req_cachep, GFP_KERNEL);
         VERBOSE("allocating request: %p\n", req);
         if (!req)
                 goto out;
@@ -74,7 +74,6 @@ static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
                 }
         }
 
-        memset(req, 0, sizeof(struct smb_request));
         req->rq_buffer = buf;
         req->rq_bufsize = bufsize;
         req->rq_server = server;
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 9dcdf556c99c..9e95e7abaf69 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -37,11 +37,10 @@ static struct sysfs_dirent * __sysfs_new_dirent(void * element)
 {
         struct sysfs_dirent * sd;
 
-        sd = kmem_cache_alloc(sysfs_dir_cachep, GFP_KERNEL);
+        sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
         if (!sd)
                 return NULL;
 
-        memset(sd, 0, sizeof(*sd));
         atomic_set(&sd->s_count, 1);
         atomic_set(&sd->s_event, 1);
         INIT_LIST_HEAD(&sd->s_children);