19 files changed, 61 insertions, 59 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index 276ff3baaafe..8cd2417a14db 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -1198,13 +1198,16 @@ config EFS_FS
 
 config JFFS_FS
         tristate "Journalling Flash File System (JFFS) support"
-        depends on MTD && BLOCK
+        depends on MTD && BLOCK && BROKEN
         help
           JFFS is the Journalling Flash File System developed by Axis
           Communications in Sweden, aimed at providing a crash/powerdown-safe
           file system for disk-less embedded devices. Further information is
           available at (<http://developer.axis.com/software/jffs/>).
 
+          NOTE: This filesystem is deprecated and is scheduled for removal in
+          2.6.21.  See Documentation/feature-removal-schedule.txt
+
 config JFFS_FS_VERBOSE
         int "JFFS debugging verbosity (0 = quiet, 3 = noisy)"
         depends on JFFS_FS
diff --git a/fs/aio.c b/fs/aio.c
index 5f577a63bdf0..ee20fc4240e0 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -599,9 +599,6 @@ static void use_mm(struct mm_struct *mm)
  *      by the calling kernel thread
  *      (Note: this routine is intended to be called only
  *      from a kernel thread context)
- *
- * Comments: Called with ctx->ctx_lock held. This nests
- * task_lock instead ctx_lock.
  */
 static void unuse_mm(struct mm_struct *mm)
 {
@@ -850,14 +847,16 @@ static void aio_kick_handler(struct work_struct *work)
 {
         struct kioctx *ctx = container_of(work, struct kioctx, wq.work);
         mm_segment_t oldfs = get_fs();
+        struct mm_struct *mm;
         int requeue;
 
         set_fs(USER_DS);
         use_mm(ctx->mm);
         spin_lock_irq(&ctx->ctx_lock);
         requeue =__aio_run_iocbs(ctx);
-        unuse_mm(ctx->mm);
+        mm = ctx->mm;
         spin_unlock_irq(&ctx->ctx_lock);
+        unuse_mm(mm);
         set_fs(oldfs);
         /*
          * we're in a worker thread already, don't use queue_delayed_work,
diff --git a/fs/buffer.c b/fs/buffer.c
index d1f1b54d3108..263f88e4dffb 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2834,7 +2834,7 @@ int try_to_free_buffers(struct page *page)
         int ret = 0;
 
         BUG_ON(!PageLocked(page));
-        if (PageWriteback(page))
+        if (PageDirty(page) || PageWriteback(page))
                 return 0;
 
         if (mapping == NULL) {          /* can this still happen? */
@@ -2845,22 +2845,6 @@ int try_to_free_buffers(struct page *page)
         spin_lock(&mapping->private_lock);
         ret = drop_buffers(page, &buffers_to_free);
         spin_unlock(&mapping->private_lock);
-        if (ret) {
-                /*
-                 * If the filesystem writes its buffers by hand (eg ext3)
-                 * then we can have clean buffers against a dirty page.  We
-                 * clean the page here; otherwise later reattachment of buffers
-                 * could encounter a non-uptodate page, which is unresolvable.
-                 * This only applies in the rare case where try_to_free_buffers
-                 * succeeds but the page is not freed.
-                 *
-                 * Also, during truncate, discard_buffer will have marked all
-                 * the page's buffers clean.  We discover that here and clean
-                 * the page also.
-                 */
-                if (test_clear_page_dirty(page))
-                        task_io_account_cancelled_write(PAGE_CACHE_SIZE);
-        }
 out:
         if (buffers_to_free) {
                 struct buffer_head *bh = buffers_to_free;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 0f05cab5d24a..8a49b2e77d37 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1245,14 +1245,21 @@ retry:
                                 wait_on_page_writeback(page);
 
                         if (PageWriteback(page) ||
-                                        !test_clear_page_dirty(page)) {
+                                        !clear_page_dirty_for_io(page)) {
                                 unlock_page(page);
                                 break;
                         }
 
+                        /*
+                         * This actually clears the dirty bit in the radix tree.
+                         * See cifs_writepage() for more commentary.
+                         */
+                        set_page_writeback(page);
+
                         if (page_offset(page) >= mapping->host->i_size) {
                                 done = 1;
                                 unlock_page(page);
+                                end_page_writeback(page);
                                 break;
                         }
 
@@ -1316,6 +1323,7 @@ retry:
                                         SetPageError(page);
                                 kunmap(page);
                                 unlock_page(page);
+                                end_page_writeback(page);
                                 page_cache_release(page);
                         }
                         if ((wbc->nr_to_write -= n_iov) <= 0)
@@ -1352,11 +1360,23 @@ static int cifs_writepage(struct page* page, struct writeback_control *wbc)
         if (!PageUptodate(page)) {
                 cFYI(1, ("ppw - page not up to date"));
         }
-        
+
+        /*
+         * Set the "writeback" flag, and clear "dirty" in the radix tree.
+         *
+         * A writepage() implementation always needs to do either this,
+         * or re-dirty the page with "redirty_page_for_writepage()" in
+         * the case of a failure.
+         *
+         * Just unlocking the page will cause the radix tree tag-bits
+         * to fail to update with the state of the page correctly.
+         */
+        set_page_writeback(page);               
         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
         unlock_page(page);
-        page_cache_release(page);       
+        end_page_writeback(page);
+        page_cache_release(page);
         FreeXid(xid);
         return rc;
 }
diff --git a/fs/dlm/lowcomms-tcp.c b/fs/dlm/lowcomms-tcp.c
index 8f2791fc8447..9be3a440c42a 100644
--- a/fs/dlm/lowcomms-tcp.c
+++ b/fs/dlm/lowcomms-tcp.c
@@ -143,7 +143,7 @@ static DECLARE_WAIT_QUEUE_HEAD(lowcomms_recv_waitq);
 /* An array of pointers to connections, indexed by NODEID */
 static struct connection **connections;
 static DECLARE_MUTEX(connections_lock);
-static kmem_cache_t *con_cache;
+static struct kmem_cache *con_cache;
 static int conn_array_size;
 
 /* List of sockets that have reads pending */
diff --git a/fs/file.c b/fs/file.c
index 857fa49e984c..c5575de01113 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -206,7 +206,7 @@ static int expand_fdtable(struct files_struct *files, int nr)
                 copy_fdtable(new_fdt, cur_fdt);
                 rcu_assign_pointer(files->fdt, new_fdt);
                 if (cur_fdt->max_fds > NR_OPEN_DEFAULT)
-                        call_rcu(&cur_fdt->rcu, free_fdtable_rcu);
+                        free_fdtable(cur_fdt);
         } else {
                 /* Somebody else expanded, so undo our attempt */
                 free_fdarr(new_fdt);
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 1387749201b3..f63efe1337ec 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -483,10 +483,8 @@ static int fuse_commit_write(struct file *file, struct page *page,
                         i_size_write(inode, pos);
                 spin_unlock(&fc->lock);
 
-                if (offset == 0 && to == PAGE_CACHE_SIZE) {
-                        clear_page_dirty(page);
+                if (offset == 0 && to == PAGE_CACHE_SIZE)
                         SetPageUptodate(page);
-                }
         }
         fuse_invalidate_attr(inode);
         return err;
diff --git a/fs/gfs2/Kconfig b/fs/gfs2/Kconfig
index c0791cbacad9..6a2ffa2db14f 100644
--- a/fs/gfs2/Kconfig
+++ b/fs/gfs2/Kconfig
@@ -34,7 +34,9 @@ config GFS2_FS_LOCKING_NOLOCK
 
 config GFS2_FS_LOCKING_DLM
         tristate "GFS2 DLM locking module"
-        depends on GFS2_FS
+        depends on GFS2_FS && NET && INET && (IPV6 || IPV6=n)
+        select IP_SCTP if DLM_SCTP
+        select CONFIGFS_FS
         select DLM
         help
         Multiple node locking module for GFS2
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index ed2c22340ad7..4f4cd132b571 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -176,7 +176,7 @@ static int hugetlbfs_commit_write(struct file *file,
 
 static void truncate_huge_page(struct page *page)
 {
-        clear_page_dirty(page);
+        cancel_dirty_page(page, /* No IO accounting for huge pages? */0);
         ClearPageUptodate(page);
         remove_from_page_cache(page);
         put_page(page);
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 10be51290a27..be4648bc7a2f 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -248,8 +248,12 @@ write_out_data:
                                 bufs = 0;
                                 goto write_out_data;
                         }
-                }
-                else {
+                } else if (!locked && buffer_locked(bh)) {
+                        __journal_file_buffer(jh, commit_transaction,
+                                                BJ_Locked);
+                        jbd_unlock_bh_state(bh);
+                        put_bh(bh);
+                } else {
                         BUFFER_TRACE(bh, "writeout complete: unfile");
                         __journal_unfile_buffer(jh);
                         jbd_unlock_bh_state(bh);
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index b1a1c7296014..ceaf03b94935 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -764,22 +764,9 @@ void release_metapage(struct metapage * mp)
         } else if (mp->lsn)     /* discard_metapage doesn't remove it */
                 remove_from_logsync(mp);
 
-#if MPS_PER_PAGE == 1
-        /*
-         * If we know this is the only thing in the page, we can throw
-         * the page out of the page cache.  If pages are larger, we
-         * don't want to do this.
-         */
-
-        /* Retest mp->count since we may have released page lock */
-        if (test_bit(META_discard, &mp->flag) && !mp->count) {
-                clear_page_dirty(page);
-                ClearPageUptodate(page);
-        }
-#else
         /* Try to keep metapages from using up too much memory */
         drop_metapage(page, mp);
-#endif
+
         unlock_page(page);
         page_cache_release(page);
 }
diff --git a/fs/pipe.c b/fs/pipe.c
index 9a06e8e48e8d..68090e84f589 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -935,8 +935,9 @@ struct file *create_write_pipe(void)
 
 void free_write_pipe(struct file *f)
 {
-        mntput(f->f_path.mnt);
+        free_pipe_info(f->f_dentry->d_inode);
         dput(f->f_path.dentry);
+        mntput(f->f_path.mnt);
         put_filp(f);
 }
 
@@ -994,6 +995,8 @@ int do_pipe(int *fd)
  err_fdr:
         put_unused_fd(fdr);
  err_read_pipe:
+        dput(fr->f_dentry);
+        mntput(fr->f_vfsmnt);
         put_filp(fr);
  err_write_pipe:
         free_write_pipe(fw);
diff --git a/fs/ramfs/file-mmu.c b/fs/ramfs/file-mmu.c
index 0947fb57dcf3..54ebbc84207f 100644
--- a/fs/ramfs/file-mmu.c
+++ b/fs/ramfs/file-mmu.c
@@ -25,11 +25,13 @@
  */
 
 #include <linux/fs.h>
+#include <linux/mm.h>
 
 const struct address_space_operations ramfs_aops = {
         .readpage       = simple_readpage,
         .prepare_write  = simple_prepare_write,
-        .commit_write   = simple_commit_write
+        .commit_write   = simple_commit_write,
+        .set_page_dirty = __set_page_dirty_nobuffers,
 };
 
 const struct file_operations ramfs_file_operations = {
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index 61cbe1ef06b9..e9d6c4733282 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -11,6 +11,7 @@
 
 #include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/mm.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
 #include <linux/init.h>
@@ -30,7 +31,8 @@ static int ramfs_nommu_setattr(struct dentry *, struct iattr *);
 const struct address_space_operations ramfs_aops = {
         .readpage               = simple_readpage,
         .prepare_write          = simple_prepare_write,
-        .commit_write           = simple_commit_write
+        .commit_write           = simple_commit_write,
+        .set_page_dirty = __set_page_dirty_nobuffers,
 };
 
 const struct file_operations ramfs_file_operations = {
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index 47e7027ea39f..afb21ea45302 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -1459,7 +1459,7 @@ static void unmap_buffers(struct page *page, loff_t pos)
                                 bh = next;
                         } while (bh != head);
                         if (PAGE_SIZE == bh->b_size) {
-                                clear_page_dirty(page);
+                                cancel_dirty_page(page, PAGE_CACHE_SIZE);
                         }
                 }
         }
diff --git a/fs/stack.c b/fs/stack.c
index 5ddbc34535f9..8ffb880d2f46 100644
--- a/fs/stack.c
+++ b/fs/stack.c
@@ -34,7 +34,5 @@ void fsstack_copy_attr_all(struct inode *dest, const struct inode *src,
         dest->i_ctime = src->i_ctime;
         dest->i_blkbits = src->i_blkbits;
         dest->i_flags = src->i_flags;
-
-        fsstack_copy_inode_size(dest, src);
 }
 EXPORT_SYMBOL_GPL(fsstack_copy_attr_all);
diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index dc9e7dc07fb7..6f9707a1b954 100644
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -528,9 +528,6 @@ static struct file_system_type v7_fs_type = {
         .fs_flags       = FS_REQUIRES_DEV,
 };
 
-extern int sysv_init_icache(void) __init;
-extern void sysv_destroy_icache(void);
-
 static int __init init_sysv_fs(void)
 {
         int error;
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index 9dcc82120935..dcb18b2171fe 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -143,6 +143,9 @@ extern int sysv_sync_inode(struct inode *);
 extern int sysv_sync_file(struct file *, struct dentry *, int);
 extern void sysv_set_inode(struct inode *, dev_t);
 extern int sysv_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+extern int sysv_init_icache(void);
+extern void sysv_destroy_icache(void);
+
 
 /* dir.c */
 extern struct sysv_dir_entry *sysv_find_entry(struct dentry *, struct page **);
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index b56eb754e2d2..7b54461695e2 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -341,9 +341,9 @@ xfs_start_page_writeback(
 {
         ASSERT(PageLocked(page));
         ASSERT(!PageWriteback(page));
-        set_page_writeback(page);
         if (clear_dirty)
-                clear_page_dirty(page);
+                clear_page_dirty_for_io(page);
+        set_page_writeback(page);
         unlock_page(page);
         if (!buffers) {
                 end_page_writeback(page);