Merge branch 'master'

11 files changed, 119 insertions, 171 deletions

diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index d71ac6579289..973c819f8033 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -18,7 +18,7 @@ static int reiserfs_readdir(struct file *, void *, filldir_t);
 static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
                               int datasync);
 
-struct file_operations reiserfs_dir_operations = {
+const struct file_operations reiserfs_dir_operations = {
         .read = generic_read_dir,
         .readdir = reiserfs_readdir,
         .fsync = reiserfs_dir_fsync,
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index be12879bb179..cf6e1cf40351 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -1532,7 +1532,7 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                 buf += write_bytes;
                 *ppos = pos += write_bytes;
                 count -= write_bytes;
-                balance_dirty_pages_ratelimited(inode->i_mapping);
+                balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
         }
 
         /* this is only true on error */
@@ -1546,10 +1546,10 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                 }
         }
 
-        if ((file->f_flags & O_SYNC) || IS_SYNC(inode))
-                res =
-                    generic_osync_inode(inode, file->f_mapping,
-                                        OSYNC_METADATA | OSYNC_DATA);
+        if (likely(res >= 0) &&
+            (unlikely((file->f_flags & O_SYNC) || IS_SYNC(inode))))
+                res = generic_osync_inode(inode, file->f_mapping,
+                                          OSYNC_METADATA | OSYNC_DATA);
 
         mutex_unlock(&inode->i_mutex);
         reiserfs_async_progress_wait(inode->i_sb);
@@ -1566,7 +1566,7 @@ static ssize_t reiserfs_aio_write(struct kiocb *iocb, const char __user * buf,
         return generic_file_aio_write(iocb, buf, count, pos);
 }
 
-struct file_operations reiserfs_file_operations = {
+const struct file_operations reiserfs_file_operations = {
         .read = generic_file_read,
         .write = reiserfs_file_write,
         .ioctl = reiserfs_ioctl,
@@ -1576,6 +1576,8 @@ struct file_operations reiserfs_file_operations = {
         .sendfile = generic_file_sendfile,
         .aio_read = generic_file_aio_read,
         .aio_write = reiserfs_aio_write,
+        .splice_read = generic_file_splice_read,
+        .splice_write = generic_file_splice_write,
 };
 
 struct inode_operations reiserfs_file_inode_operations = {
diff --git a/fs/reiserfs/fix_node.c b/fs/reiserfs/fix_node.c
index aa22588019ec..5600d3d60cf7 100644
--- a/fs/reiserfs/fix_node.c
+++ b/fs/reiserfs/fix_node.c
@@ -191,9 +191,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
                                                "vs-8045: create_virtual_node: rdkey %k, affected item==%d (mode==%c) Must be %c",
                                                key, vn->vn_affected_item_num,
                                                vn->vn_mode, M_DELETE);
-                        } else
-                                /* we can delete directory item, that has only one directory entry in it */
-                                ;
+                        }
                 }
 #endif
 
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index d60f6238c66a..9857e50f85e7 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -466,7 +466,6 @@ static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
    direct_IO request. */
 static int reiserfs_get_blocks_direct_io(struct inode *inode,
                                          sector_t iblock,
-                                         unsigned long max_blocks,
                                          struct buffer_head *bh_result,
                                          int create)
 {
@@ -2793,7 +2792,7 @@ static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
 }
 
 /* clm -- taken from fs/buffer.c:block_invalidate_page */
-static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
+static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
 {
         struct buffer_head *head, *bh, *next;
         struct inode *inode = page->mapping->host;
@@ -2832,10 +2831,12 @@ static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
          * The get_block cached value has been unconditionally invalidated,
          * so real IO is not possible anymore.
          */
-        if (!offset && ret)
+        if (!offset && ret) {
                 ret = try_to_release_page(page, 0);
+                /* maybe should BUG_ON(!ret); - neilb */
+        }
       out:
-        return ret;
+        return;
 }
 
 static int reiserfs_set_page_dirty(struct page *page)
diff --git a/fs/reiserfs/item_ops.c b/fs/reiserfs/item_ops.c
index e237cd668e5b..7a88adbceef6 100644
--- a/fs/reiserfs/item_ops.c
+++ b/fs/reiserfs/item_ops.c
@@ -275,7 +275,7 @@ static void indirect_print_item(struct item_head *ih, char *item)
         int j;
         __le32 *unp;
         __u32 prev = INT_MAX;
-        int num;
+        int num = 0;
 
         unp = (__le32 *) item;
 
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 5a9d2722fa0a..1b73529b8099 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -2227,6 +2227,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
         journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb);
         journal->j_last_flush_trans_id = trans_id;
         journal->j_trans_id = trans_id + 1;
+        /* check for trans_id overflow */
+        if (journal->j_trans_id == 0)
+                journal->j_trans_id = 10;
         brelse(c_bh);
         brelse(d_bh);
         kfree(log_blocks);
@@ -2450,6 +2453,9 @@ static int journal_read(struct super_block *p_s_sb)
                 journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
                 journal->j_trans_id =
                     le32_to_cpu(jh->j_last_flush_trans_id) + 1;
+                /* check for trans_id overflow */
+                if (journal->j_trans_id == 0)
+                        journal->j_trans_id = 10;
                 journal->j_last_flush_trans_id =
                     le32_to_cpu(jh->j_last_flush_trans_id);
                 journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
@@ -3873,8 +3879,8 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
         int cur_write_start = 0;        /* start index of current log write */
         int old_start;
         int i;
-        int flush = flags & FLUSH_ALL;
-        int wait_on_commit = flags & WAIT;
+        int flush;
+        int wait_on_commit;
         struct reiserfs_journal_list *jl, *temp_jl;
         struct list_head *entry, *safe;
         unsigned long jindex;
@@ -3884,6 +3890,13 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
         BUG_ON(th->t_refcount > 1);
         BUG_ON(!th->t_trans_id);
 
+        /* protect flush_older_commits from doing mistakes if the
+           transaction ID counter gets overflowed.  */
+        if (th->t_trans_id == ~0UL)
+                flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
+        flush = flags & FLUSH_ALL;
+        wait_on_commit = flags & WAIT;
+
         put_fs_excl();
         current->journal_info = th->t_handle_save;
         reiserfs_check_lock_depth(p_s_sb, "journal end");
@@ -4105,7 +4118,9 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
         journal->j_first = NULL;
         journal->j_len = 0;
         journal->j_trans_start_time = 0;
-        journal->j_trans_id++;
+        /* check for trans_id overflow */
+        if (++journal->j_trans_id == 0)
+                journal->j_trans_id = 10;
         journal->j_current_jl->j_trans_id = journal->j_trans_id;
         journal->j_must_wait = 0;
         journal->j_len_alloc = 0;
diff --git a/fs/reiserfs/prints.c b/fs/reiserfs/prints.c
index d55e164bd5c2..27bd3a1df2ad 100644
--- a/fs/reiserfs/prints.c
+++ b/fs/reiserfs/prints.c
@@ -143,7 +143,7 @@ static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
         char b[BDEVNAME_SIZE];
 
         sprintf(buf,
-                "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
+                "dev %s, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
                 bdevname(bh->b_bdev, b), bh->b_size,
                 (unsigned long long)bh->b_blocknr, atomic_read(&(bh->b_count)),
                 bh->b_state, bh->b_page,
@@ -601,8 +601,7 @@ void store_print_tb(struct tree_balance *tb)
                 tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
                 tb->tb_path->pos_in_item);
 
-        for (h = 0; h < sizeof(tb->insert_size) / sizeof(tb->insert_size[0]);
-             h++) {
+        for (h = 0; h < ARRAY_SIZE(tb->insert_size); h++) {
                 if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
                     tb->tb_path->path_length
                     && PATH_H_PATH_OFFSET(tb->tb_path,
@@ -658,15 +657,13 @@ void store_print_tb(struct tree_balance *tb)
 
         /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
         h = 0;
-        for (i = 0; i < sizeof(tb->FEB) / sizeof(tb->FEB[0]); i++)
+        for (i = 0; i < ARRAY_SIZE(tb->FEB); i++)
                 sprintf(print_tb_buf + strlen(print_tb_buf),
                         "%p (%llu %d)%s", tb->FEB[i],
                         tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
                         b_blocknr : 0ULL,
                         tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
-                        (i ==
-                         sizeof(tb->FEB) / sizeof(tb->FEB[0]) -
-                         1) ? "\n" : ", ");
+                        (i == ARRAY_SIZE(tb->FEB) - 1) ? "\n" : ", ");
 
         sprintf(print_tb_buf + strlen(print_tb_buf),
                 "======================== the end ====================================\n");
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index ef6caed9336b..731688e1cfe3 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -470,7 +470,7 @@ static int r_open(struct inode *inode, struct file *file)
         return ret;
 }
 
-static struct file_operations r_file_operations = {
+static const struct file_operations r_file_operations = {
         .open = r_open,
         .read = seq_read,
         .llseek = seq_lseek,
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index e2d08d7bcffc..d2b25e1ba6e9 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -981,6 +981,8 @@ static inline int prepare_for_direntry_item(struct path *path,
         return M_CUT;
 }
 
+#define JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD (2 * JOURNAL_PER_BALANCE_CNT + 1)
+
 /*  If the path points to a directory or direct item, calculate mode and the size cut, for balance.
     If the path points to an indirect item, remove some number of its unformatted nodes.
     In case of file truncate calculate whether this item must be deleted/truncated or last
@@ -1020,148 +1022,79 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
 
         /* Case of an indirect item. */
         {
-                int n_unfm_number,      /* Number of the item unformatted nodes. */
-                 n_counter, n_blk_size;
-                __le32 *p_n_unfm_pointer;       /* Pointer to the unformatted node number. */
-                __u32 tmp;
-                struct item_head s_ih;  /* Item header. */
-                char c_mode;    /* Returned mode of the balance. */
-                int need_research;
-
-                n_blk_size = p_s_sb->s_blocksize;
-
-                /* Search for the needed object indirect item until there are no unformatted nodes to be removed. */
-                do {
-                        need_research = 0;
-                        p_s_bh = PATH_PLAST_BUFFER(p_s_path);
-                        /* Copy indirect item header to a temp variable. */
-                        copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
-                        /* Calculate number of unformatted nodes in this item. */
-                        n_unfm_number = I_UNFM_NUM(&s_ih);
-
-                        RFALSE(!is_indirect_le_ih(&s_ih) || !n_unfm_number ||
-                               pos_in_item(p_s_path) + 1 != n_unfm_number,
-                               "PAP-5240: invalid item %h "
-                               "n_unfm_number = %d *p_n_pos_in_item = %d",
-                               &s_ih, n_unfm_number, pos_in_item(p_s_path));
-
-                        /* Calculate balance mode and position in the item to remove unformatted nodes. */
-                        if (n_new_file_length == max_reiserfs_offset(inode)) {  /* Case of delete. */
-                                pos_in_item(p_s_path) = 0;
-                                *p_n_cut_size = -(IH_SIZE + ih_item_len(&s_ih));
-                                c_mode = M_DELETE;
-                        } else {        /* Case of truncate. */
-                                if (n_new_file_length < le_ih_k_offset(&s_ih)) {
-                                        pos_in_item(p_s_path) = 0;
-                                        *p_n_cut_size =
-                                            -(IH_SIZE + ih_item_len(&s_ih));
-                                        c_mode = M_DELETE;      /* Delete this item. */
-                                } else {
-                                        /* indirect item must be truncated starting from *p_n_pos_in_item-th position */
-                                        pos_in_item(p_s_path) =
-                                            (n_new_file_length + n_blk_size -
-                                             le_ih_k_offset(&s_ih)) >> p_s_sb->
-                                            s_blocksize_bits;
-
-                                        RFALSE(pos_in_item(p_s_path) >
-                                               n_unfm_number,
-                                               "PAP-5250: invalid position in the item");
-
-                                        /* Either convert last unformatted node of indirect item to direct item or increase
-                                           its free space.  */
-                                        if (pos_in_item(p_s_path) ==
-                                            n_unfm_number) {
-                                                *p_n_cut_size = 0;      /* Nothing to cut. */
-                                                return M_CONVERT;       /* Maybe convert last unformatted node to the direct item. */
-                                        }
-                                        /* Calculate size to cut. */
-                                        *p_n_cut_size =
-                                            -(ih_item_len(&s_ih) -
-                                              pos_in_item(p_s_path) *
-                                              UNFM_P_SIZE);
-
-                                        c_mode = M_CUT; /* Cut from this indirect item. */
-                                }
-                        }
+            int blk_size = p_s_sb->s_blocksize;
+            struct item_head s_ih;
+            int need_re_search;
+            int delete = 0;
+            int result = M_CUT;
+            int pos = 0;
+
+            if ( n_new_file_length == max_reiserfs_offset (inode) ) {
+                /* prepare_for_delete_or_cut() is called by
+                 * reiserfs_delete_item() */
+                n_new_file_length = 0;
+                delete = 1;
+            }
+
+            do {
+                need_re_search = 0;
+                *p_n_cut_size = 0;
+                p_s_bh = PATH_PLAST_BUFFER(p_s_path);
+                copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
+                pos = I_UNFM_NUM(&s_ih);
 
-                        RFALSE(n_unfm_number <= pos_in_item(p_s_path),
-                               "PAP-5260: invalid position in the indirect item");
-
-                        /* pointers to be cut */
-                        n_unfm_number -= pos_in_item(p_s_path);
-                        /* Set pointer to the last unformatted node pointer that is to be cut. */
-                        p_n_unfm_pointer =
-                            (__le32 *) B_I_PITEM(p_s_bh,
-                                                 &s_ih) + I_UNFM_NUM(&s_ih) -
-                            1 - *p_n_removed;
-
-                        /* We go through the unformatted nodes pointers of the indirect
-                           item and look for the unformatted nodes in the cache. If we
-                           found some of them we free it, zero corresponding indirect item
-                           entry and log buffer containing that indirect item. For this we
-                           need to prepare last path element for logging. If some
-                           unformatted node has b_count > 1 we must not free this
-                           unformatted node since it is in use. */
-                        reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
-                        // note: path could be changed, first line in for loop takes care
-                        // of it
+                while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) {
+                    __u32 *unfm, block;
 
-                        for (n_counter = *p_n_removed;
-                             n_counter < n_unfm_number;
-                             n_counter++, p_n_unfm_pointer--) {
+                    /* Each unformatted block deletion may involve one additional
+                     * bitmap block into the transaction, thereby the initial
+                     * journal space reservation might not be enough. */
+                    if (!delete && (*p_n_cut_size) != 0 &&
+                        reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
+                        break;
+                    }
 
-                                cond_resched();
-                                if (item_moved(&s_ih, p_s_path)) {
-                                        need_research = 1;
-                                        break;
-                                }
-                                RFALSE(p_n_unfm_pointer <
-                                       (__le32 *) B_I_PITEM(p_s_bh, &s_ih)
-                                       || p_n_unfm_pointer >
-                                       (__le32 *) B_I_PITEM(p_s_bh,
-                                                            &s_ih) +
-                                       I_UNFM_NUM(&s_ih) - 1,
-                                       "vs-5265: pointer out of range");
-
-                                /* Hole, nothing to remove. */
-                                if (!get_block_num(p_n_unfm_pointer, 0)) {
-                                        (*p_n_removed)++;
-                                        continue;
-                                }
+                    unfm = (__u32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1;
+                    block = get_block_num(unfm, 0);
 
-                                (*p_n_removed)++;
+                    if (block != 0) {
+                        reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
+                        put_block_num(unfm, 0, 0);
+                        journal_mark_dirty (th, p_s_sb, p_s_bh);
+                        reiserfs_free_block(th, inode, block, 1);
+                    }
 
-                                tmp = get_block_num(p_n_unfm_pointer, 0);
-                                put_block_num(p_n_unfm_pointer, 0, 0);
-                                journal_mark_dirty(th, p_s_sb, p_s_bh);
-                                reiserfs_free_block(th, inode, tmp, 1);
-                                if (item_moved(&s_ih, p_s_path)) {
-                                        need_research = 1;
-                                        break;
-                                }
-                        }
+                    cond_resched();
 
-                        /* a trick.  If the buffer has been logged, this
-                         ** will do nothing.  If we've broken the loop without
-                         ** logging it, it will restore the buffer
-                         **
-                         */
-                        reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
-
-                        /* This loop can be optimized. */
-                } while ((*p_n_removed < n_unfm_number || need_research) &&
-                         search_for_position_by_key(p_s_sb, p_s_item_key,
-                                                    p_s_path) ==
-                         POSITION_FOUND);
-
-                RFALSE(*p_n_removed < n_unfm_number,
-                       "PAP-5310: indirect item is not found");
-                RFALSE(item_moved(&s_ih, p_s_path),
-                       "after while, comp failed, retry");
-
-                if (c_mode == M_CUT)
-                        pos_in_item(p_s_path) *= UNFM_P_SIZE;
-                return c_mode;
+                    if (item_moved (&s_ih, p_s_path))  {
+                        need_re_search = 1;
+                        break;
+                    }
+
+                    pos --;
+                    (*p_n_removed) ++;
+                    (*p_n_cut_size) -= UNFM_P_SIZE;
+
+                    if (pos == 0) {
+                        (*p_n_cut_size) -= IH_SIZE;
+                        result = M_DELETE;
+                        break;
+                    }
+                }
+                /* a trick.  If the buffer has been logged, this will do nothing.  If
+                ** we've broken the loop without logging it, it will restore the
+                ** buffer */
+                reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
+            } while (need_re_search &&
+                     search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) == POSITION_FOUND);
+            pos_in_item(p_s_path) = pos * UNFM_P_SIZE;
+
+            if (*p_n_cut_size == 0) {
+                /* Nothing were cut. maybe convert last unformatted node to the
+                 * direct item? */
+                result = M_CONVERT;
+            }
+            return result;
         }
 }
 
@@ -1948,7 +1881,8 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
                  ** sure the file is consistent before ending the current trans
                  ** and starting a new one
                  */
-                if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
+                if (journal_transaction_should_end(th, 0) ||
+                    reiserfs_transaction_free_space(th) <= JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
                         int orig_len_alloc = th->t_blocks_allocated;
                         decrement_counters_in_path(&s_search_path);
 
@@ -1962,7 +1896,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
                         if (err)
                                 goto out;
                         err = journal_begin(th, p_s_inode->i_sb,
-                                            JOURNAL_PER_BALANCE_CNT * 6);
+                                            JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD + JOURNAL_PER_BALANCE_CNT * 4) ;
                         if (err)
                                 goto out;
                         reiserfs_update_inode_transaction(p_s_inode);
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index d63da756eb49..cae2abbc0c71 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -521,7 +521,8 @@ static int init_inodecache(void)
         reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
                                                   sizeof(struct
                                                          reiserfs_inode_info),
-                                                  0, SLAB_RECLAIM_ACCOUNT,
+                                                  0, (SLAB_RECLAIM_ACCOUNT|
+                                                        SLAB_MEM_SPREAD),
                                                   init_once, NULL);
         if (reiserfs_inode_cachep == NULL)
                 return -ENOMEM;
@@ -684,14 +685,14 @@ static const arg_desc_t logging_mode[] = {
          (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},
         {"writeback", 1 << REISERFS_DATA_WRITEBACK,
          (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},
-        {NULL, 0}
+        {.value = NULL}
 };
 
 /* possible values for -o barrier= */
 static const arg_desc_t barrier_mode[] = {
         {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
         {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
-        {NULL, 0}
+        {.value = NULL}
 };
 
 /* possible values for "-o block-allocator=" and bits which are to be set in
@@ -889,7 +890,7 @@ static int reiserfs_parse_options(struct super_block *s, char *options,	/* strin
                 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
                 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 #endif
-                {"nolog",},     /* This is unsupported */
+                {.option_name = "nolog"},
                 {"replayonly",.setmask = 1 << REPLAYONLY},
                 {"block-allocator",.arg_required = 'a',.values = balloc},
                 {"data",.arg_required = 'd',.values = logging_mode},
@@ -907,7 +908,7 @@ static int reiserfs_parse_options(struct super_block *s, char *options,	/* strin
                 {"grpjquota",.arg_required =
                  'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
                 {"jqfmt",.arg_required = 'f',.values = NULL},
-                {NULL,}
+                {.option_name = NULL}
         };
 
         *blocks = 0;
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index ab8894c3b9e5..58c418fbca2c 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -182,7 +182,7 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
 {
         char *name, *value;
         struct posix_acl *acl, **p_acl;
-        size_t size;
+        int size;
         int retval;
         struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
 
@@ -206,7 +206,7 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
                 return posix_acl_dup(*p_acl);
 
         size = reiserfs_xattr_get(inode, name, NULL, 0);
-        if ((int)size < 0) {
+        if (size < 0) {
                 if (size == -ENODATA || size == -ENOSYS) {
                         *p_acl = ERR_PTR(-ENODATA);
                         return NULL;