5 files changed, 30 insertions, 73 deletions

diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index b67ce9354048..373d862c3f87 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -74,7 +74,8 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
                         igrab(inode);
                         reiserfs_warning(inode->i_sb,
                                          "pinning inode %lu because the "
-                                         "preallocation can't be freed");
+                                         "preallocation can't be freed",
+                                         inode->i_ino);
                         goto out;
                 }
         }
@@ -316,12 +317,11 @@ static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handl
                         /* area filled with zeroes, to supply as list of zero blocknumbers
                            We allocate it outside of loop just in case loop would spin for
                            several iterations. */
-                        char *zeros = kmalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC);      // We cannot insert more than MAX_ITEM_LEN bytes anyway.
+                        char *zeros = kzalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC);      // We cannot insert more than MAX_ITEM_LEN bytes anyway.
                         if (!zeros) {
                                 res = -ENOMEM;
                                 goto error_exit_free_blocks;
                         }
-                        memset(zeros, 0, to_paste * UNFM_P_SIZE);
                         do {
                                 to_paste =
                                     min_t(__u64, hole_size,
@@ -406,6 +406,8 @@ static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handl
                                    we restart it. This will also free the path. */
                                 if (journal_transaction_should_end
                                     (th, th->t_blocks_allocated)) {
+                                        inode->i_size = cpu_key_k_offset(&key) +
+                                                (to_paste << inode->i_blkbits);
                                         res =
                                             restart_transaction(th, inode,
                                                                 &path);
@@ -1044,6 +1046,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                         char *kaddr = kmap_atomic(prepared_pages[0], KM_USER0);
                         memset(kaddr, 0, from);
                         kunmap_atomic(kaddr, KM_USER0);
+                        flush_dcache_page(prepared_pages[0]);
                 }
                 if (to != PAGE_CACHE_SIZE) {    /* Last page needs to be partially zeroed */
                         char *kaddr =
@@ -1051,6 +1054,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                         KM_USER0);
                         memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
                         kunmap_atomic(kaddr, KM_USER0);
+                        flush_dcache_page(prepared_pages[num_pages - 1]);
                 }
 
                 /* Since all blocks are new - use already calculated value */
@@ -1184,6 +1188,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                         memset(kaddr + block_start, 0,
                                                from - block_start);
                                         kunmap_atomic(kaddr, KM_USER0);
+                                        flush_dcache_page(prepared_pages[0]);
                                         set_buffer_uptodate(bh);
                                 }
                         }
@@ -1221,6 +1226,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                                         KM_USER0);
                                         memset(kaddr + to, 0, block_end - to);
                                         kunmap_atomic(kaddr, KM_USER0);
+                                        flush_dcache_page(prepared_pages[num_pages - 1]);
                                         set_buffer_uptodate(bh);
                                 }
                         }
@@ -1306,56 +1312,8 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                         count = MAX_NON_LFS - (unsigned long)*ppos;
         }
 
-        if (file->f_flags & O_DIRECT) { // Direct IO needs treatment
-                ssize_t result, after_file_end = 0;
-                if ((*ppos + count >= inode->i_size)
-                    || (file->f_flags & O_APPEND)) {
-                        /* If we are appending a file, we need to put this savelink in here.
-                           If we will crash while doing direct io, finish_unfinished will
-                           cut the garbage from the file end. */
-                        reiserfs_write_lock(inode->i_sb);
-                        err =
-                            journal_begin(&th, inode->i_sb,
-                                          JOURNAL_PER_BALANCE_CNT);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        reiserfs_update_inode_transaction(inode);
-                        add_save_link(&th, inode, 1 /* Truncate */ );
-                        after_file_end = 1;
-                        err =
-                            journal_end(&th, inode->i_sb,
-                                        JOURNAL_PER_BALANCE_CNT);
-                        reiserfs_write_unlock(inode->i_sb);
-                        if (err)
-                                return err;
-                }
-                result = do_sync_write(file, buf, count, ppos);
-
-                if (after_file_end) {   /* Now update i_size and remove the savelink */
-                        struct reiserfs_transaction_handle th;
-                        reiserfs_write_lock(inode->i_sb);
-                        err = journal_begin(&th, inode->i_sb, 1);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        reiserfs_update_inode_transaction(inode);
-                        mark_inode_dirty(inode);
-                        err = journal_end(&th, inode->i_sb, 1);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        err = remove_save_link(inode, 1 /* truncate */ );
-                        reiserfs_write_unlock(inode->i_sb);
-                        if (err)
-                                return err;
-                }
-
-                return result;
-        }
+        if (file->f_flags & O_DIRECT)
+                return do_sync_write(file, buf, count, ppos);
 
         if (unlikely((ssize_t) count < 0))
                 return -EINVAL;
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 9c69bcacad22..254239e6f9e3 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -216,11 +216,12 @@ static int file_capable(struct inode *inode, long block)
         BUG_ON(!th->t_trans_id);
         BUG_ON(!th->t_refcount);
 
+        pathrelse(path);
+
         /* we cannot restart while nested */
         if (th->t_refcount > 1) {
                 return 0;
         }
-        pathrelse(path);
         reiserfs_update_sd(th, inode);
         err = journal_end(th, s, len);
         if (!err) {
@@ -928,15 +929,12 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
                         if (blocks_needed == 1) {
                                 un = &unf_single;
                         } else {
-                                un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC);      // We need to avoid scheduling.
+                                un = kzalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC);      // We need to avoid scheduling.
                                 if (!un) {
                                         un = &unf_single;
                                         blocks_needed = 1;
                                         max_to_insert = 0;
-                                } else
-                                        memset(un, 0,
-                                               UNFM_P_SIZE * min(blocks_needed,
-                                                                 max_to_insert));
+                                }
                         }
                         if (blocks_needed <= max_to_insert) {
                                 /* we are going to add target block to the file. Use allocated
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 85ce23268302..7280a23ef344 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -104,7 +104,7 @@ static int release_journal_dev(struct super_block *super,
                                struct reiserfs_journal *journal);
 static int dirty_one_transaction(struct super_block *s,
                                  struct reiserfs_journal_list *jl);
-static void flush_async_commits(void *p);
+static void flush_async_commits(struct work_struct *work);
 static void queue_log_writer(struct super_block *s);
 
 /* values for join in do_journal_begin_r */
@@ -1464,7 +1464,7 @@ static int flush_journal_list(struct super_block *s,
                 }
 
                 /* if someone has this block in a newer transaction, just make
-                 ** sure they are commited, and don't try writing it to disk
+                 ** sure they are committed, and don't try writing it to disk
                  */
                 if (pjl) {
                         if (atomic_read(&pjl->j_commit_left))
@@ -2836,7 +2836,8 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
         if (reiserfs_mounted_fs_count <= 1)
                 commit_wq = create_workqueue("reiserfs");
 
-        INIT_WORK(&journal->j_work, flush_async_commits, p_s_sb);
+        INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
+        journal->j_work_sb = p_s_sb;
         return 0;
       free_and_return:
         free_journal_ram(p_s_sb);
@@ -3384,7 +3385,7 @@ static int remove_from_transaction(struct super_block *p_s_sb,
 
 /*
 ** for any cnode in a journal list, it can only be dirtied of all the
-** transactions that include it are commited to disk.
+** transactions that include it are committed to disk.
 ** this checks through each transaction, and returns 1 if you are allowed to dirty,
 ** and 0 if you aren't
 **
@@ -3426,7 +3427,7 @@ static int can_dirty(struct reiserfs_journal_cnode *cn)
 }
 
 /* syncs the commit blocks, but does not force the real buffers to disk
-** will wait until the current transaction is done/commited before returning 
+** will wait until the current transaction is done/committed before returning 
 */
 int journal_end_sync(struct reiserfs_transaction_handle *th,
                      struct super_block *p_s_sb, unsigned long nblocks)
@@ -3447,10 +3448,11 @@ int journal_end_sync(struct reiserfs_transaction_handle *th,
 /*
 ** writeback the pending async commits to disk
 */
-static void flush_async_commits(void *p)
+static void flush_async_commits(struct work_struct *work)
 {
-        struct super_block *p_s_sb = p;
-        struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
+        struct reiserfs_journal *journal =
+                container_of(work, struct reiserfs_journal, j_work.work);
+        struct super_block *p_s_sb = journal->j_work_sb;
         struct reiserfs_journal_list *jl;
         struct list_head *entry;
 
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 17249994110f..7fb5fb036f90 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -490,13 +490,13 @@ static void reiserfs_put_super(struct super_block *s)
         return;
 }
 
-static kmem_cache_t *reiserfs_inode_cachep;
+static struct kmem_cache *reiserfs_inode_cachep;
 
 static struct inode *reiserfs_alloc_inode(struct super_block *sb)
 {
         struct reiserfs_inode_info *ei;
         ei = (struct reiserfs_inode_info *)
-            kmem_cache_alloc(reiserfs_inode_cachep, SLAB_KERNEL);
+            kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
         if (!ei)
                 return NULL;
         return &ei->vfs_inode;
@@ -507,7 +507,7 @@ static void reiserfs_destroy_inode(struct inode *inode)
         kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 }
 
-static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags)
 {
         struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
 
@@ -1549,13 +1549,12 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         struct reiserfs_sb_info *sbi;
         int errval = -EINVAL;
 
-        sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
+        sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
         if (!sbi) {
                 errval = -ENOMEM;
                 goto error;
         }
         s->s_fs_info = sbi;
-        memset(sbi, 0, sizeof(struct reiserfs_sb_info));
         /* Set default values for options: non-aggressive tails, RO on errors */
         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 7bdb0ed443e1..1e4d68590178 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -41,7 +41,7 @@
 #include <linux/reiserfs_xattr.h>
 #include <linux/reiserfs_acl.h>
 #include <asm/uaccess.h>
-#include <asm/checksum.h>
+#include <net/checksum.h>
 #include <linux/smp_lock.h>
 #include <linux/stat.h>
 #include <asm/semaphore.h>