40 files changed, 192 insertions, 171 deletions

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 9f17b0cacdd0..6c78343cf690 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -110,7 +110,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 
         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
                 filemap_write_and_wait(inode->i_mapping);
-                invalidate_inode_pages(&inode->i_data);
+                invalidate_mapping_pages(&inode->i_data, 0, -1);
         }
 
         return res;
@@ -234,7 +234,7 @@ v9fs_file_write(struct file *filp, const char __user * data,
                 total += result;
         } while (count);
 
-                invalidate_inode_pages2(inode->i_mapping);
+        invalidate_inode_pages2(inode->i_mapping);
         return total;
 }
 
diff --git a/fs/Kconfig b/fs/Kconfig
index 5e8e9d9ccb33..11c59329ed06 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -674,12 +674,6 @@ config ZISOFS
           necessary to create such a filesystem.  Say Y here if you want to be
           able to read such compressed CD-ROMs.
 
-config ZISOFS_FS
-# for fs/nls/Config.in
-        tristate
-        depends on ZISOFS
-        default ISO9660_FS
-
 config UDF_FS
         tristate "UDF file system support"
         help
diff --git a/fs/aio.c b/fs/aio.c
index 55991e4132a7..0b4ee0a5c83e 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -132,7 +132,7 @@ static int aio_setup_ring(struct kioctx *ctx)
         dprintk("attempting mmap of %lu bytes\n", info->mmap_size);
         down_write(&ctx->mm->mmap_sem);
         info->mmap_base = do_mmap(NULL, 0, info->mmap_size, 
-                                  PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
+                                  PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE,
                                   0);
         if (IS_ERR((void *)info->mmap_base)) {
                 up_write(&ctx->mm->mmap_sem);
@@ -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/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index a4d933a51208..5810aa1339fd 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -372,7 +372,7 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm,
         down_write(&current->mm->mmap_sem);
         current->mm->start_brk = do_mmap(NULL, 0, stack_size,
                                          PROT_READ | PROT_WRITE | PROT_EXEC,
-                                         MAP_PRIVATE | MAP_ANON | MAP_GROWSDOWN,
+                                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_GROWSDOWN,
                                          0);
 
         if (IS_ERR_VALUE(current->mm->start_brk)) {
diff --git a/fs/buffer.c b/fs/buffer.c
index 1ad674fd348c..7ff6e9346fae 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -78,6 +78,7 @@ EXPORT_SYMBOL(__lock_buffer);
 
 void fastcall unlock_buffer(struct buffer_head *bh)
 {
+        smp_mb__before_clear_bit();
         clear_buffer_locked(bh);
         smp_mb__after_clear_bit();
         wake_up_bit(&bh->b_state, BH_Lock);
@@ -345,7 +346,7 @@ void invalidate_bdev(struct block_device *bdev, int destroy_dirty_buffers)
          * We really want to use invalidate_inode_pages2() for
          * that, but not until that's cleaned up.
          */
-        invalidate_inode_pages(mapping);
+        invalidate_mapping_pages(mapping, 0, -1);
 }
 
 /*
diff --git a/fs/coda/sysctl.c b/fs/coda/sysctl.c
index 1c82e9a7d7c8..db3b1a9c9a5b 100644
--- a/fs/coda/sysctl.c
+++ b/fs/coda/sysctl.c
@@ -15,6 +15,7 @@
 #include <linux/mm.h>
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/ctype.h>
@@ -84,15 +85,11 @@ static int do_reset_coda_cache_inv_stats( ctl_table * table, int write,
         return 0;
 }
 
-static int coda_vfs_stats_get_info( char * buffer, char ** start,
-                                    off_t offset, int length)
+static int proc_vfs_stats_show(struct seq_file *m, void *v)
 {
-        int len=0;
-        off_t begin;
         struct coda_vfs_stats * ps = & coda_vfs_stat;
   
-  /* this works as long as we are below 1024 characters! */
-        len += sprintf( buffer,
+        seq_printf(m,
                         "Coda VFS statistics\n"
                         "===================\n\n"
                         "File Operations:\n"
@@ -132,28 +129,14 @@ static int coda_vfs_stats_get_info( char * buffer, char ** start,
                         ps->rmdir,
                         ps->rename,
                         ps->permission); 
-
-        begin = offset;
-        *start = buffer + begin;
-        len -= begin;
-
-        if ( len > length )
-                len = length;
-        if ( len < 0 )
-                len = 0;
-
-        return len;
+        return 0;
 }
 
-static int coda_cache_inv_stats_get_info( char * buffer, char ** start,
-                                          off_t offset, int length)
+static int proc_cache_inv_stats_show(struct seq_file *m, void *v)
 {
-        int len=0;
-        off_t begin;
         struct coda_cache_inv_stats * ps = & coda_cache_inv_stat;
   
-        /* this works as long as we are below 1024 characters! */
-        len += sprintf( buffer,
+        seq_printf(m,
                         "Coda cache invalidation statistics\n"
                         "==================================\n\n"
                         "flush\t\t%9d\n"
@@ -170,19 +153,35 @@ static int coda_cache_inv_stats_get_info( char * buffer, char ** start,
                         ps->zap_vnode,
                         ps->purge_fid,
                         ps->replace );
-  
-        begin = offset;
-        *start = buffer + begin;
-        len -= begin;
+        return 0;
+}
 
-        if ( len > length )
-                len = length;
-        if ( len < 0 )
-                len = 0;
+static int proc_vfs_stats_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_vfs_stats_show, NULL);
+}
 
-        return len;
+static int proc_cache_inv_stats_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_cache_inv_stats_show, NULL);
 }
 
+static const struct file_operations proc_vfs_stats_fops = {
+        .owner          = THIS_MODULE,
+        .open           = proc_vfs_stats_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static const struct file_operations proc_cache_inv_stats_fops = {
+        .owner          = THIS_MODULE,
+        .open           = proc_cache_inv_stats_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static ctl_table coda_table[] = {
         {CODA_TIMEOUT, "timeout", &coda_timeout, sizeof(int), 0644, NULL, &proc_dointvec},
         {CODA_HARD, "hard", &coda_hard, sizeof(int), 0644, NULL, &proc_dointvec},
@@ -212,9 +211,6 @@ static struct proc_dir_entry* proc_fs_coda;
 
 #endif
 
-#define coda_proc_create(name,get_info) \
-        create_proc_info_entry(name, 0, proc_fs_coda, get_info)
-
 void coda_sysctl_init(void)
 {
         reset_coda_vfs_stats();
@@ -223,9 +219,15 @@ void coda_sysctl_init(void)
 #ifdef CONFIG_PROC_FS
         proc_fs_coda = proc_mkdir("coda", proc_root_fs);
         if (proc_fs_coda) {
+                struct proc_dir_entry *pde;
+
                 proc_fs_coda->owner = THIS_MODULE;
-                coda_proc_create("vfs_stats", coda_vfs_stats_get_info);
-                coda_proc_create("cache_inv_stats", coda_cache_inv_stats_get_info);
+                pde = create_proc_entry("vfs_stats", 0, proc_fs_coda);
+                if (pde)
+                        pde->proc_fops = &proc_vfs_stats_fops;
+                pde = create_proc_entry("cache_inv_stats", 0, proc_fs_coda);
+                if (pde)
+                        pde->proc_fops = &proc_cache_inv_stats_fops;
         }
 #endif
 
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/drop_caches.c b/fs/drop_caches.c
index 4e4762389bdc..03ea7696fe39 100644
--- a/fs/drop_caches.c
+++ b/fs/drop_caches.c
@@ -20,7 +20,7 @@ static void drop_pagecache_sb(struct super_block *sb)
         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
                 if (inode->i_state & (I_FREEING|I_WILL_FREE))
                         continue;
-                invalidate_inode_pages(inode->i_mapping);
+                invalidate_mapping_pages(inode->i_mapping, 0, -1);
         }
         spin_unlock(&inode_lock);
 }
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/ext2/dir.c b/fs/ext2/dir.c
index 0b02ba9642d2..e89bfc8cf957 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -368,6 +368,14 @@ struct ext2_dir_entry_2 * ext2_find_entry (struct inode * dir,
                 }
                 if (++n >= npages)
                         n = 0;
+                /* next page is past the blocks we've got */
+                if (unlikely(n > (dir->i_blocks >> (PAGE_CACHE_SHIFT - 9)))) {
+                        ext2_error(dir->i_sb, __FUNCTION__,
+                                "dir %lu size %lld exceeds block count %llu",
+                                dir->i_ino, dir->i_size,
+                                (unsigned long long)dir->i_blocks);
+                        goto out;
+                }
         } while (n != start);
 out:
         return NULL;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 6347c2dbdd81..daaa243eee9b 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -708,10 +708,14 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
                 set_opt(sbi->s_mount_opt, GRPID);
         if (def_mount_opts & EXT2_DEFM_UID16)
                 set_opt(sbi->s_mount_opt, NO_UID32);
+#ifdef CONFIG_EXT2_FS_XATTR
         if (def_mount_opts & EXT2_DEFM_XATTR_USER)
                 set_opt(sbi->s_mount_opt, XATTR_USER);
+#endif
+#ifdef CONFIG_EXT2_FS_POSIX_ACL
         if (def_mount_opts & EXT2_DEFM_ACL)
                 set_opt(sbi->s_mount_opt, POSIX_ACL);
+#endif
         
         if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
                 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index beaf25f5112f..8a824f4ce5c6 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -947,7 +947,7 @@ out:
 static int ext3_get_block(struct inode *inode, sector_t iblock,
                         struct buffer_head *bh_result, int create)
 {
-        handle_t *handle = journal_current_handle();
+        handle_t *handle = ext3_journal_current_handle();
         int ret = 0;
         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
 
@@ -1717,7 +1717,7 @@ static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
         /*
          * Reacquire the handle: ext3_get_block() can restart the transaction
          */
-        handle = journal_current_handle();
+        handle = ext3_journal_current_handle();
 
 out_stop:
         if (handle) {
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 4df39c4315e1..a8e89328e66d 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1618,21 +1618,6 @@ static int ext3_delete_entry (handle_t *handle,
         return -ENOENT;
 }
 
-/*
- * ext3_mark_inode_dirty is somewhat expensive, so unlike ext2 we
- * do not perform it in these functions.  We perform it at the call site,
- * if it is needed.
- */
-static inline void ext3_inc_count(handle_t *handle, struct inode *inode)
-{
-        inc_nlink(inode);
-}
-
-static inline void ext3_dec_count(handle_t *handle, struct inode *inode)
-{
-        drop_nlink(inode);
-}
-
 static int ext3_add_nondir(handle_t *handle,
                 struct dentry *dentry, struct inode *inode)
 {
@@ -1642,7 +1627,7 @@ static int ext3_add_nondir(handle_t *handle,
                 d_instantiate(dentry, inode);
                 return 0;
         }
-        ext3_dec_count(handle, inode);
+        drop_nlink(inode);
         iput(inode);
         return err;
 }
@@ -2163,7 +2148,7 @@ retry:
                 err = __page_symlink(inode, symname, l,
                                 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
                 if (err) {
-                        ext3_dec_count(handle, inode);
+                        drop_nlink(inode);
                         ext3_mark_inode_dirty(handle, inode);
                         iput (inode);
                         goto out_stop;
@@ -2191,6 +2176,12 @@ static int ext3_link (struct dentry * old_dentry,
 
         if (inode->i_nlink >= EXT3_LINK_MAX)
                 return -EMLINK;
+        /*
+         * Return -ENOENT if we've raced with unlink and i_nlink is 0.  Doing
+         * otherwise has the potential to corrupt the orphan inode list.
+         */
+        if (inode->i_nlink == 0)
+                return -ENOENT;
 
 retry:
         handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
@@ -2202,7 +2193,7 @@ retry:
                 handle->h_sync = 1;
 
         inode->i_ctime = CURRENT_TIME_SEC;
-        ext3_inc_count(handle, inode);
+        inc_nlink(inode);
         atomic_inc(&inode->i_count);
 
         err = ext3_add_nondir(handle, dentry, inode);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index b34886734a44..a0623a84a4b2 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1459,10 +1459,14 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                 set_opt(sbi->s_mount_opt, GRPID);
         if (def_mount_opts & EXT3_DEFM_UID16)
                 set_opt(sbi->s_mount_opt, NO_UID32);
+#ifdef CONFIG_EXT3_FS_XATTR
         if (def_mount_opts & EXT3_DEFM_XATTR_USER)
                 set_opt(sbi->s_mount_opt, XATTR_USER);
+#endif
+#ifdef CONFIG_EXT3_FS_POSIX_ACL
         if (def_mount_opts & EXT3_DEFM_ACL)
                 set_opt(sbi->s_mount_opt, POSIX_ACL);
+#endif
         if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
                 sbi->s_mount_opt |= EXT3_MOUNT_JOURNAL_DATA;
         else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
@@ -2344,6 +2348,22 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
                                 err = -EROFS;
                                 goto restore_opts;
                         }
+
+                        /*
+                         * If we have an unprocessed orphan list hanging
+                         * around from a previously readonly bdev mount,
+                         * require a full umount/remount for now.
+                         */
+                        if (es->s_last_orphan) {
+                                printk(KERN_WARNING "EXT3-fs: %s: couldn't "
+                                       "remount RDWR because of unprocessed "
+                                       "orphan inode list.  Please "
+                                       "umount/remount instead.\n",
+                                       sb->s_id);
+                                err = -EINVAL;
+                                goto restore_opts;
+                        }
+
                         /*
                          * Mounting a RDONLY partition read-write, so reread
                          * and store the current valid flag.  (It may have
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index a127cc03c9fa..fbff4b9e122a 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -946,7 +946,7 @@ out:
 static int ext4_get_block(struct inode *inode, sector_t iblock,
                         struct buffer_head *bh_result, int create)
 {
-        handle_t *handle = journal_current_handle();
+        handle_t *handle = ext4_journal_current_handle();
         int ret = 0;
         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
 
@@ -1716,7 +1716,7 @@ static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
         /*
          * Reacquire the handle: ext4_get_block() can restart the transaction
          */
-        handle = journal_current_handle();
+        handle = ext4_journal_current_handle();
 
 out_stop:
         if (handle) {
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index e5a74a5ac261..34b3448b40f9 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1616,21 +1616,6 @@ static int ext4_delete_entry (handle_t *handle,
         return -ENOENT;
 }
 
-/*
- * ext4_mark_inode_dirty is somewhat expensive, so unlike ext2 we
- * do not perform it in these functions.  We perform it at the call site,
- * if it is needed.
- */
-static inline void ext4_inc_count(handle_t *handle, struct inode *inode)
-{
-        inc_nlink(inode);
-}
-
-static inline void ext4_dec_count(handle_t *handle, struct inode *inode)
-{
-        drop_nlink(inode);
-}
-
 static int ext4_add_nondir(handle_t *handle,
                 struct dentry *dentry, struct inode *inode)
 {
@@ -1640,7 +1625,7 @@ static int ext4_add_nondir(handle_t *handle,
                 d_instantiate(dentry, inode);
                 return 0;
         }
-        ext4_dec_count(handle, inode);
+        drop_nlink(inode);
         iput(inode);
         return err;
 }
@@ -2161,7 +2146,7 @@ retry:
                 err = __page_symlink(inode, symname, l,
                                 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
                 if (err) {
-                        ext4_dec_count(handle, inode);
+                        drop_nlink(inode);
                         ext4_mark_inode_dirty(handle, inode);
                         iput (inode);
                         goto out_stop;
@@ -2189,6 +2174,12 @@ static int ext4_link (struct dentry * old_dentry,
 
         if (inode->i_nlink >= EXT4_LINK_MAX)
                 return -EMLINK;
+        /*
+         * Return -ENOENT if we've raced with unlink and i_nlink is 0.  Doing
+         * otherwise has the potential to corrupt the orphan inode list.
+         */
+        if (inode->i_nlink == 0)
+                return -ENOENT;
 
 retry:
         handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
@@ -2200,7 +2191,7 @@ retry:
                 handle->h_sync = 1;
 
         inode->i_ctime = CURRENT_TIME_SEC;
-        ext4_inc_count(handle, inode);
+        inc_nlink(inode);
         atomic_inc(&inode->i_count);
 
         err = ext4_add_nondir(handle, dentry, inode);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 486a641ca71b..c63a18b574dd 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1518,10 +1518,14 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                 set_opt(sbi->s_mount_opt, GRPID);
         if (def_mount_opts & EXT4_DEFM_UID16)
                 set_opt(sbi->s_mount_opt, NO_UID32);
+#ifdef CONFIG_EXT4DEV_FS_XATTR
         if (def_mount_opts & EXT4_DEFM_XATTR_USER)
                 set_opt(sbi->s_mount_opt, XATTR_USER);
+#endif
+#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
         if (def_mount_opts & EXT4_DEFM_ACL)
                 set_opt(sbi->s_mount_opt, POSIX_ACL);
+#endif
         if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
                 sbi->s_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
@@ -2419,6 +2423,22 @@ static int ext4_remount (struct super_block * sb, int * flags, char * data)
                                 err = -EROFS;
                                 goto restore_opts;
                         }
+
+                        /*
+                         * If we have an unprocessed orphan list hanging
+                         * around from a previously readonly bdev mount,
+                         * require a full umount/remount for now.
+                         */
+                        if (es->s_last_orphan) {
+                                printk(KERN_WARNING "EXT4-fs: %s: couldn't "
+                                       "remount RDWR because of unprocessed "
+                                       "orphan inode list.  Please "
+                                       "umount/remount instead.\n",
+                                       sb->s_id);
+                                err = -EINVAL;
+                                goto restore_opts;
+                        }
+
                         /*
                          * Mounting a RDONLY partition read-write, so reread
                          * and store the current valid flag.  (It may have
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index f63efe1337ec..2fd06927e851 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -69,7 +69,7 @@ void fuse_finish_open(struct inode *inode, struct file *file,
         if (outarg->open_flags & FOPEN_DIRECT_IO)
                 file->f_op = &fuse_direct_io_file_operations;
         if (!(outarg->open_flags & FOPEN_KEEP_CACHE))
-                invalidate_inode_pages(inode->i_mapping);
+                invalidate_mapping_pages(inode->i_mapping, 0, -1);
         ff->fh = outarg->fh;
         file->private_data = ff;
 }
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 12450d2b320e..220255110d76 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -112,7 +112,7 @@ void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
 {
         struct fuse_conn *fc = get_fuse_conn(inode);
         if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
-                invalidate_inode_pages(inode->i_mapping);
+                invalidate_mapping_pages(inode->i_mapping, 0, -1);
 
         inode->i_ino     = attr->ino;
         inode->i_mode    = (inode->i_mode & S_IFMT) + (attr->mode & 07777);
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/hfs/hfs.h b/fs/hfs/hfs.h
index 88099ab1a180..1445e3a56ed4 100644
--- a/fs/hfs/hfs.h
+++ b/fs/hfs/hfs.h
@@ -83,8 +83,6 @@
 
 /*======== HFS structures as they appear on the disk ========*/
 
-#define __packed __attribute__ ((packed))
-
 /* Pascal-style string of up to 31 characters */
 struct hfs_name {
         u8 len;
diff --git a/fs/hfsplus/hfsplus_raw.h b/fs/hfsplus/hfsplus_raw.h
index 49205531a500..fe99fe8db61a 100644
--- a/fs/hfsplus/hfsplus_raw.h
+++ b/fs/hfsplus/hfsplus_raw.h
@@ -15,8 +15,6 @@
 
 #include <linux/types.h>
 
-#define __packed __attribute__ ((packed))
-
 /* Some constants */
 #define HFSPLUS_SECTOR_SIZE        512
 #define HFSPLUS_SECTOR_SHIFT         9
diff --git a/fs/inode.c b/fs/inode.c
index bf21dc6d0dbd..e6d93070f140 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -414,7 +414,8 @@ static void prune_icache(int nr_to_scan)
                         __iget(inode);
                         spin_unlock(&inode_lock);
                         if (remove_inode_buffers(inode))
-                                reap += invalidate_inode_pages(&inode->i_data);
+                                reap += invalidate_mapping_pages(&inode->i_data,
+                                                                0, -1);
                         iput(inode);
                         spin_lock(&inode_lock);
 
@@ -709,7 +710,7 @@ EXPORT_SYMBOL(iunique);
 struct inode *igrab(struct inode *inode)
 {
         spin_lock(&inode_lock);
-        if (!(inode->i_state & (I_FREEING|I_WILL_FREE)))
+        if (!(inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)))
                 __iget(inode);
         else
                 /*
@@ -1160,11 +1161,9 @@ void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
         struct inode *inode = dentry->d_inode;
         struct timespec now;
 
-        if (IS_RDONLY(inode))
-                return;
         if (inode->i_flags & S_NOATIME)
                 return;
-        if (inode->i_sb->s_flags & MS_NOATIME)
+        if (IS_NOATIME(inode))
                 return;
         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
                 return;
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 43baa1afa021..6ee206688502 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -296,7 +296,7 @@ jffs_setattr(struct dentry *dentry, struct iattr *iattr)
                 inode->i_blocks = (inode->i_size + 511) >> 9;
 
                 if (len) {
-                        invalidate_inode_pages(inode->i_mapping);
+                        invalidate_mapping_pages(inode->i_mapping, 0, -1);
                 }
                 inode->i_ctime = CURRENT_TIME_SEC;
                 inode->i_mtime = inode->i_ctime;
@@ -1518,7 +1518,7 @@ jffs_file_write(struct file *filp, const char *buf, size_t count,
         }
         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
         mark_inode_dirty(inode);
-        invalidate_inode_pages(inode->i_mapping);
+        invalidate_mapping_pages(inode->i_mapping, 0, -1);
 
  out_isem:
         return err;
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/partitions/msdos.c b/fs/partitions/msdos.c
index d964d1f90dec..4ccec4cd1367 100644
--- a/fs/partitions/msdos.c
+++ b/fs/partitions/msdos.c
@@ -63,15 +63,25 @@ msdos_magic_present(unsigned char *p)
 #define AIX_LABEL_MAGIC4        0xC1
 static int aix_magic_present(unsigned char *p, struct block_device *bdev)
 {
+        struct partition *pt = (struct partition *) (p + 0x1be);
         Sector sect;
         unsigned char *d;
-        int ret = 0;
+        int slot, ret = 0;
 
-        if (p[0] != AIX_LABEL_MAGIC1 &&
-                p[1] != AIX_LABEL_MAGIC2 &&
-                p[2] != AIX_LABEL_MAGIC3 &&
-                p[3] != AIX_LABEL_MAGIC4)
+        if (!(p[0] == AIX_LABEL_MAGIC1 &&
+                p[1] == AIX_LABEL_MAGIC2 &&
+                p[2] == AIX_LABEL_MAGIC3 &&
+                p[3] == AIX_LABEL_MAGIC4))
                 return 0;
+        /* Assume the partition table is valid if Linux partitions exists */
+        for (slot = 1; slot <= 4; slot++, pt++) {
+                if (pt->sys_ind == LINUX_SWAP_PARTITION ||
+                        pt->sys_ind == LINUX_RAID_PARTITION ||
+                        pt->sys_ind == LINUX_DATA_PARTITION ||
+                        pt->sys_ind == LINUX_LVM_PARTITION ||
+                        is_extended_partition(pt))
+                        return 0;
+        }
         d = read_dev_sector(bdev, 7, &sect);
         if (d) {
                 if (d[0] == '_' && d[1] == 'L' && d[2] == 'V' && d[3] == 'M')
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 1a979ea3b379..7fb37d6f2864 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1810,17 +1810,21 @@ static int proc_base_fill_cache(struct file *filp, void *dirent, filldir_t filld
 static int proc_pid_io_accounting(struct task_struct *task, char *buffer)
 {
         return sprintf(buffer,
+#ifdef CONFIG_TASK_XACCT
                         "rchar: %llu\n"
                         "wchar: %llu\n"
                         "syscr: %llu\n"
                         "syscw: %llu\n"
+#endif
                         "read_bytes: %llu\n"
                         "write_bytes: %llu\n"
                         "cancelled_write_bytes: %llu\n",
+#ifdef CONFIG_TASK_XACCT
                         (unsigned long long)task->rchar,
                         (unsigned long long)task->wchar,
                         (unsigned long long)task->syscr,
                         (unsigned long long)task->syscw,
+#endif
                         (unsigned long long)task->ioac.read_bytes,
                         (unsigned long long)task->ioac.write_bytes,
                         (unsigned long long)task->ioac.cancelled_write_bytes);
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index b37ce33f67ea..5e2d4359c292 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -121,16 +121,11 @@ static int meminfo_read_proc(char *page, char **start, off_t off,
 {
         struct sysinfo i;
         int len;
-        unsigned long inactive;
-        unsigned long active;
-        unsigned long free;
         unsigned long committed;
         unsigned long allowed;
         struct vmalloc_info vmi;
         long cached;
 
-        get_zone_counts(&active, &inactive, &free);
-
 /*
  * display in kilobytes.
  */
@@ -187,8 +182,8 @@ static int meminfo_read_proc(char *page, char **start, off_t off,
                 K(i.bufferram),
                 K(cached),
                 K(total_swapcache_pages),
-                K(active),
-                K(inactive),
+                K(global_page_state(NR_ACTIVE)),
+                K(global_page_state(NR_INACTIVE)),
 #ifdef CONFIG_HIGHMEM
                 K(i.totalhigh),
                 K(i.freehigh),
@@ -672,7 +667,6 @@ void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 
 void __init proc_misc_init(void)
 {
-        struct proc_dir_entry *entry;
         static struct {
                 char *name;
                 int (*read_proc)(char*,char**,off_t,int,int*,void*);
@@ -700,9 +694,12 @@ void __init proc_misc_init(void)
 
         /* And now for trickier ones */
 #ifdef CONFIG_PRINTK
-        entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
-        if (entry)
-                entry->proc_fops = &proc_kmsg_operations;
+        {
+                struct proc_dir_entry *entry;
+                entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
+                if (entry)
+                        entry->proc_fops = &proc_kmsg_operations;
+        }
 #endif
         create_seq_entry("devices", 0, &proc_devinfo_operations);
         create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
@@ -743,8 +740,11 @@ void __init proc_misc_init(void)
                 proc_vmcore->proc_fops = &proc_vmcore_operations;
 #endif
 #ifdef CONFIG_MAGIC_SYSRQ
-        entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
-        if (entry)
-                entry->proc_fops = &proc_sysrq_trigger_operations;
+        {
+                struct proc_dir_entry *entry;
+                entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
+                if (entry)
+                        entry->proc_fops = &proc_sysrq_trigger_operations;
+        }
 #endif
 }
diff --git a/fs/ramfs/file-mmu.c b/fs/ramfs/file-mmu.c
index 54ebbc84207f..b935a3dd4b65 100644
--- a/fs/ramfs/file-mmu.c
+++ b/fs/ramfs/file-mmu.c
@@ -31,7 +31,7 @@ const struct address_space_operations ramfs_aops = {
         .readpage       = simple_readpage,
         .prepare_write  = simple_prepare_write,
         .commit_write   = simple_commit_write,
-        .set_page_dirty = __set_page_dirty_nobuffers,
+        .set_page_dirty = __set_page_dirty_no_writeback,
 };
 
 const struct file_operations ramfs_file_operations = {
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index e9d6c4733282..d05e09ac9a99 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -32,7 +32,7 @@ const struct address_space_operations ramfs_aops = {
         .readpage               = simple_readpage,
         .prepare_write          = simple_prepare_write,
         .commit_write           = simple_commit_write,
-        .set_page_dirty = __set_page_dirty_nobuffers,
+        .set_page_dirty         = __set_page_dirty_no_writeback,
 };
 
 const struct file_operations ramfs_file_operations = {
diff --git a/fs/read_write.c b/fs/read_write.c
index 707ac21700d3..bcb0ef2aae3d 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -274,9 +274,9 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
                                 ret = do_sync_read(file, buf, count, pos);
                         if (ret > 0) {
                                 fsnotify_access(file->f_path.dentry);
-                                current->rchar += ret;
+                                add_rchar(current, ret);
                         }
-                        current->syscr++;
+                        inc_syscr(current);
                 }
         }
 
@@ -332,9 +332,9 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
                                 ret = do_sync_write(file, buf, count, pos);
                         if (ret > 0) {
                                 fsnotify_modify(file->f_path.dentry);
-                                current->wchar += ret;
+                                add_wchar(current, ret);
                         }
-                        current->syscw++;
+                        inc_syscw(current);
                 }
         }
 
@@ -675,8 +675,8 @@ sys_readv(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
         }
 
         if (ret > 0)
-                current->rchar += ret;
-        current->syscr++;
+                add_rchar(current, ret);
+        inc_syscr(current);
         return ret;
 }
 
@@ -696,8 +696,8 @@ sys_writev(unsigned long fd, const struct iovec __user *vec, unsigned long vlen)
         }
 
         if (ret > 0)
-                current->wchar += ret;
-        current->syscw++;
+                add_wchar(current, ret);
+        inc_syscw(current);
         return ret;
 }
 
@@ -779,12 +779,12 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
         retval = in_file->f_op->sendfile(in_file, ppos, count, file_send_actor, out_file);
 
         if (retval > 0) {
-                current->rchar += retval;
-                current->wchar += retval;
+                add_rchar(current, retval);
+                add_wchar(current, retval);
         }
-        current->syscr++;
-        current->syscw++;
 
+        inc_syscr(current);
+        inc_syscw(current);
         if (*ppos > max)
                 retval = -EOVERFLOW;
 
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);