19 files changed, 69 insertions, 92 deletions

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 06db79d05c12..6046239465a1 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1251,6 +1251,7 @@ struct kmem_cache *ecryptfs_header_cache_2;
 /**
  * ecryptfs_write_headers_virt
  * @page_virt: The virtual address to write the headers to
+ * @max: The size of memory allocated at page_virt
  * @size: Set to the number of bytes written by this function
  * @crypt_stat: The cryptographic context
  * @ecryptfs_dentry: The eCryptfs dentry
@@ -1278,7 +1279,8 @@ struct kmem_cache *ecryptfs_header_cache_2;
  *
  * Returns zero on success
  */
-static int ecryptfs_write_headers_virt(char *page_virt, size_t *size,
+static int ecryptfs_write_headers_virt(char *page_virt, size_t max,
+                                       size_t *size,
                                        struct ecryptfs_crypt_stat *crypt_stat,
                                        struct dentry *ecryptfs_dentry)
 {
@@ -1296,7 +1298,7 @@ static int ecryptfs_write_headers_virt(char *page_virt, size_t *size,
         offset += written;
         rc = ecryptfs_generate_key_packet_set((page_virt + offset), crypt_stat,
                                               ecryptfs_dentry, &written,
-                                              PAGE_CACHE_SIZE - offset);
+                                              max - offset);
         if (rc)
                 ecryptfs_printk(KERN_WARNING, "Error generating key packet "
                                 "set; rc = [%d]\n", rc);
@@ -1368,14 +1370,14 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry)
                 goto out;
         }
         /* Released in this function */
-        virt = kzalloc(crypt_stat->num_header_bytes_at_front, GFP_KERNEL);
+        virt = (char *)get_zeroed_page(GFP_KERNEL);
         if (!virt) {
                 printk(KERN_ERR "%s: Out of memory\n", __func__);
                 rc = -ENOMEM;
                 goto out;
         }
-        rc = ecryptfs_write_headers_virt(virt, &size, crypt_stat,
-                                         ecryptfs_dentry);
+        rc = ecryptfs_write_headers_virt(virt, PAGE_CACHE_SIZE, &size,
+                                         crypt_stat, ecryptfs_dentry);
         if (unlikely(rc)) {
                 printk(KERN_ERR "%s: Error whilst writing headers; rc = [%d]\n",
                        __func__, rc);
@@ -1393,8 +1395,7 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry)
                 goto out_free;
         }
 out_free:
-        memset(virt, 0, crypt_stat->num_header_bytes_at_front);
-        kfree(virt);
+        free_page((unsigned long)virt);
 out:
         return rc;
 }
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 18eaa78ecb4e..e5717a4fae67 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -281,7 +281,8 @@ void ext3_abort (struct super_block * sb, const char * function,
         EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
         sb->s_flags |= MS_RDONLY;
         EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
-        journal_abort(EXT3_SB(sb)->s_journal, -EIO);
+        if (EXT3_SB(sb)->s_journal)
+                journal_abort(EXT3_SB(sb)->s_journal, -EIO);
 }
 
 void ext3_warning (struct super_block * sb, const char * function,
@@ -390,11 +391,14 @@ static void ext3_put_super (struct super_block * sb)
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         struct ext3_super_block *es = sbi->s_es;
-        int i;
+        int i, err;
 
         ext3_xattr_put_super(sb);
-        if (journal_destroy(sbi->s_journal) < 0)
+        err = journal_destroy(sbi->s_journal);
+        sbi->s_journal = NULL;
+        if (err < 0)
                 ext3_abort(sb, __func__, "Couldn't clean up the journal");
+
         if (!(sb->s_flags & MS_RDONLY)) {
                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
                 es->s_state = cpu_to_le16(sbi->s_mount_state);
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index b9821be709bd..d2003cdc36aa 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -589,21 +589,23 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
         return;
 }
 
-int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
-                                                s64 nblocks)
+/**
+ * ext4_has_free_blocks()
+ * @sbi:        in-core super block structure.
+ * @nblocks:    number of needed blocks
+ *
+ * Check if filesystem has nblocks free & available for allocation.
+ * On success return 1, return 0 on failure.
+ */
+int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks)
 {
-        s64 free_blocks, dirty_blocks;
-        s64 root_blocks = 0;
+        s64 free_blocks, dirty_blocks, root_blocks;
         struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
         struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
 
         free_blocks  = percpu_counter_read_positive(fbc);
         dirty_blocks = percpu_counter_read_positive(dbc);
-
-        if (!capable(CAP_SYS_RESOURCE) &&
-                sbi->s_resuid != current->fsuid &&
-                (sbi->s_resgid == 0 || !in_group_p(sbi->s_resgid)))
-                root_blocks = ext4_r_blocks_count(sbi->s_es);
+        root_blocks = ext4_r_blocks_count(sbi->s_es);
 
         if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
                                                 EXT4_FREEBLOCKS_WATERMARK) {
@@ -616,57 +618,32 @@ int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
                 }
         }
         /* Check whether we have space after
-         * accounting for current dirty blocks
+         * accounting for current dirty blocks & root reserved blocks.
          */
-        if (free_blocks < ((root_blocks + nblocks) + dirty_blocks))
-                /* we don't have free space */
-                return -ENOSPC;
+        if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))
+                return 1;
+
+        /* Hm, nope.  Are (enough) root reserved blocks available? */
+        if (sbi->s_resuid == current->fsuid ||
+            ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
+            capable(CAP_SYS_RESOURCE)) {
+                if (free_blocks >= (nblocks + dirty_blocks))
+                        return 1;
+        }
 
-        /* Add the blocks to nblocks */
-        percpu_counter_add(dbc, nblocks);
         return 0;
 }
 
-/**
- * ext4_has_free_blocks()
- * @sbi:        in-core super block structure.
- * @nblocks:    number of neeed blocks
- *
- * Check if filesystem has free blocks available for allocation.
- * Return the number of blocks avaible for allocation for this request
- * On success, return nblocks
- */
-ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi,
+int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
                                                 s64 nblocks)
 {
-        s64 free_blocks, dirty_blocks;
-        s64 root_blocks = 0;
-        struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
-        struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
-
-        free_blocks  = percpu_counter_read_positive(fbc);
-        dirty_blocks = percpu_counter_read_positive(dbc);
-
-        if (!capable(CAP_SYS_RESOURCE) &&
-                sbi->s_resuid != current->fsuid &&
-                (sbi->s_resgid == 0 || !in_group_p(sbi->s_resgid)))
-                root_blocks = ext4_r_blocks_count(sbi->s_es);
-
-        if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
-                                                EXT4_FREEBLOCKS_WATERMARK) {
-                free_blocks  = percpu_counter_sum(fbc);
-                dirty_blocks = percpu_counter_sum(dbc);
-        }
-        if (free_blocks <= (root_blocks + dirty_blocks))
-                /* we don't have free space */
+        if (ext4_has_free_blocks(sbi, nblocks)) {
+                percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks);
                 return 0;
-
-        if (free_blocks - (root_blocks + dirty_blocks) < nblocks)
-                return free_blocks - (root_blocks + dirty_blocks);
-        return nblocks;
+        } else
+                return -ENOSPC;
 }
 
-
 /**
  * ext4_should_retry_alloc()
  * @sb:                 super block
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 4880cc3e6727..b0537c827024 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1003,8 +1003,7 @@ extern ext4_fsblk_t ext4_new_blocks(handle_t *handle, struct inode *inode,
                                         ext4_lblk_t iblock, ext4_fsblk_t goal,
                                         unsigned long *count, int *errp);
 extern int ext4_claim_free_blocks(struct ext4_sb_info *sbi, s64 nblocks);
-extern ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi,
-                                         s64 nblocks);
+extern int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks);
 extern void ext4_free_blocks(handle_t *handle, struct inode *inode,
                         ext4_fsblk_t block, unsigned long count, int metadata);
 extern void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index bdddea14e782..994859df010e 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -333,7 +333,8 @@ void ext4_abort(struct super_block *sb, const char *function,
         EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
         sb->s_flags |= MS_RDONLY;
         EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
-        jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
+        if (EXT4_SB(sb)->s_journal)
+                jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
 }
 
 void ext4_warning(struct super_block *sb, const char *function,
@@ -442,14 +443,16 @@ static void ext4_put_super(struct super_block *sb)
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_super_block *es = sbi->s_es;
-        int i;
+        int i, err;
 
         ext4_mb_release(sb);
         ext4_ext_release(sb);
         ext4_xattr_put_super(sb);
-        if (jbd2_journal_destroy(sbi->s_journal) < 0)
-                ext4_abort(sb, __func__, "Couldn't clean up the journal");
+        err = jbd2_journal_destroy(sbi->s_journal);
         sbi->s_journal = NULL;
+        if (err < 0)
+                ext4_abort(sb, __func__, "Couldn't clean up the journal");
+
         if (!(sb->s_flags & MS_RDONLY)) {
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                 es->s_state = cpu_to_le16(sbi->s_mount_state);
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 19eafbe3c379..2b2eec1283bf 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -175,7 +175,7 @@ static ssize_t fat_direct_IO(int rw, struct kiocb *iocb,
 
         if (rw == WRITE) {
                 /*
-                 * FIXME: blockdev_direct_IO() doesn't use ->prepare_write(),
+                 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
                  * so we need to update the ->mmu_private to block boundary.
                  *
                  * But we must fill the remaining area or hole by nul for
diff --git a/fs/file_table.c b/fs/file_table.c
index efc06faede6c..5ad0eca6eea2 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -269,6 +269,10 @@ void __fput(struct file *file)
         eventpoll_release(file);
         locks_remove_flock(file);
 
+        if (unlikely(file->f_flags & FASYNC)) {
+                if (file->f_op && file->f_op->fasync)
+                        file->f_op->fasync(-1, file, 0);
+        }
         if (file->f_op && file->f_op->release)
                 file->f_op->release(inode, file);
         security_file_free(file);
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 87250b6a8682..b72361479be2 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -1056,7 +1056,6 @@ static int fuse_dev_release(struct inode *inode, struct file *file)
                 end_requests(fc, &fc->pending);
                 end_requests(fc, &fc->processing);
                 spin_unlock(&fc->lock);
-                fasync_helper(-1, file, 0, &fc->fasync);
                 fuse_conn_put(fc);
         }
 
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index d85c7d931cdf..d367e9b92862 100644
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -537,9 +537,6 @@ static int inotify_release(struct inode *ignored, struct file *file)
                 inotify_dev_event_dequeue(dev);
         mutex_unlock(&dev->ev_mutex);
 
-        if (file->f_flags & FASYNC)
-                inotify_fasync(-1, file, 0);
-
         /* free this device: the put matching the get in inotify_init() */
         put_inotify_dev(dev);
 
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index d15cd6e7251e..60d4c32c8808 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -860,7 +860,6 @@ out:
  * int journal_get_undo_access() - Notify intent to modify metadata with non-rewindable consequences
  * @handle: transaction
  * @bh: buffer to undo
- * @credits: store the number of taken credits here (if not NULL)
  *
  * Sometimes there is a need to distinguish between metadata which has
  * been committed to disk and that which has not.  The ext3fs code uses
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 8b119e16aa36..ebc667bc54a8 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -974,6 +974,9 @@ restart_loop:
         journal->j_committing_transaction = NULL;
         spin_unlock(&journal->j_state_lock);
 
+        if (journal->j_commit_callback)
+                journal->j_commit_callback(journal, commit_transaction);
+
         if (commit_transaction->t_checkpoint_list == NULL &&
             commit_transaction->t_checkpoint_io_list == NULL) {
                 __jbd2_journal_drop_transaction(journal, commit_transaction);
@@ -995,11 +998,8 @@ restart_loop:
         }
         spin_unlock(&journal->j_list_lock);
 
-        if (journal->j_commit_callback)
-                journal->j_commit_callback(journal, commit_transaction);
-
         trace_mark(jbd2_end_commit, "dev %s transaction %d head %d",
-                   journal->j_devname, commit_transaction->t_tid,
+                   journal->j_devname, journal->j_commit_sequence,
                    journal->j_tail_sequence);
         jbd_debug(1, "JBD: commit %d complete, head %d\n",
                   journal->j_commit_sequence, journal->j_tail_sequence);
diff --git a/fs/libfs.c b/fs/libfs.c
index 74688598bcf7..e960a8321902 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -814,7 +814,7 @@ EXPORT_SYMBOL(simple_getattr);
 EXPORT_SYMBOL(simple_link);
 EXPORT_SYMBOL(simple_lookup);
 EXPORT_SYMBOL(simple_pin_fs);
-EXPORT_SYMBOL(simple_prepare_write);
+EXPORT_UNUSED_SYMBOL(simple_prepare_write);
 EXPORT_SYMBOL(simple_readpage);
 EXPORT_SYMBOL(simple_release_fs);
 EXPORT_SYMBOL(simple_rename);
diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c
index 014f6ce48172..4dfdcbc6bf68 100644
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -434,6 +434,7 @@ nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
          * reclaim all locks we hold on this server.
          */
         memset(&saddr, 0, sizeof(saddr));
+        saddr.sin_family = AF_INET;
         saddr.sin_addr.s_addr = argp->addr;
         nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state);
 
diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c
index 548b0bb2b84d..3ca89e2a9381 100644
--- a/fs/lockd/svcproc.c
+++ b/fs/lockd/svcproc.c
@@ -466,6 +466,7 @@ nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
          * reclaim all locks we hold on this server.
          */
         memset(&saddr, 0, sizeof(saddr));
+        saddr.sin_family = AF_INET;
         saddr.sin_addr.s_addr = argp->addr;
         nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state);
 
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index dc52793ff8f8..d22eb383e1cf 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -908,21 +908,16 @@ static int nfs_size_need_update(const struct inode *inode, const struct nfs_fatt
         return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
 }
 
-static unsigned long nfs_attr_generation_counter;
+static atomic_long_t nfs_attr_generation_counter;
 
 static unsigned long nfs_read_attr_generation_counter(void)
 {
-        smp_rmb();
-        return nfs_attr_generation_counter;
+        return atomic_long_read(&nfs_attr_generation_counter);
 }
 
 unsigned long nfs_inc_attr_generation_counter(void)
 {
-        unsigned long ret;
-        smp_rmb();
-        ret = ++nfs_attr_generation_counter;
-        smp_wmb();
-        return ret;
+        return atomic_long_inc_return(&nfs_attr_generation_counter);
 }
 
 void nfs_fattr_init(struct nfs_fattr *fattr)
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 0bc56f6d9276..848a03e83a42 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -1912,6 +1912,7 @@ static int nfsd_buffered_readdir(struct file *file, filldir_t func,
                         de = (struct buffered_dirent *)((char *)de + reclen);
                 }
                 offset = vfs_llseek(file, 0, SEEK_CUR);
+                cdp->err = nfserr_eof;
                 if (!buf.full)
                         break;
         }
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 8d3225a78073..7efe937a415f 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -679,8 +679,7 @@ leave:
 
 /* Some parts of this taken from generic_cont_expand, which turned out
  * to be too fragile to do exactly what we need without us having to
- * worry about recursive locking in ->prepare_write() and
- * ->commit_write(). */
+ * worry about recursive locking in ->write_begin() and ->write_end(). */
 static int ocfs2_write_zero_page(struct inode *inode,
                                  u64 size)
 {
diff --git a/fs/pipe.c b/fs/pipe.c
index fcba6542b8d0..7aea8b89baac 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -717,14 +717,12 @@ pipe_rdwr_fasync(int fd, struct file *filp, int on)
 static int
 pipe_read_release(struct inode *inode, struct file *filp)
 {
-        pipe_read_fasync(-1, filp, 0);
         return pipe_release(inode, 1, 0);
 }
 
 static int
 pipe_write_release(struct inode *inode, struct file *filp)
 {
-        pipe_write_fasync(-1, filp, 0);
         return pipe_release(inode, 0, 1);
 }
 
@@ -733,7 +731,6 @@ pipe_rdwr_release(struct inode *inode, struct file *filp)
 {
         int decr, decw;
 
-        pipe_rdwr_fasync(-1, filp, 0);
         decr = (filp->f_mode & FMODE_READ) != 0;
         decw = (filp->f_mode & FMODE_WRITE) != 0;
         return pipe_release(inode, decr, decw);
diff --git a/fs/splice.c b/fs/splice.c
index a1e701c27156..1abab5cee4ba 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -731,8 +731,8 @@ ssize_t splice_from_pipe(struct pipe_inode_info *pipe, struct file *out,
         };
 
         /*
-         * The actor worker might be calling ->prepare_write and
-         * ->commit_write. Most of the time, these expect i_mutex to
+         * The actor worker might be calling ->write_begin and
+         * ->write_end. Most of the time, these expect i_mutex to
          * be held. Since this may result in an ABBA deadlock with
          * pipe->inode, we have to order lock acquiry here.
          */