4 files changed, 41 insertions, 42 deletions

diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 6c2d136561cb..03e4ca5624d6 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -13,14 +13,14 @@
 
 extern const struct reiserfs_key MIN_KEY;
 
-static int reiserfs_readdir(struct file *, void *, filldir_t);
+static int reiserfs_readdir(struct file *, struct dir_context *);
 static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
                               int datasync);
 
 const struct file_operations reiserfs_dir_operations = {
         .llseek = generic_file_llseek,
         .read = generic_read_dir,
-        .readdir = reiserfs_readdir,
+        .iterate = reiserfs_readdir,
         .fsync = reiserfs_dir_fsync,
         .unlocked_ioctl = reiserfs_ioctl,
 #ifdef CONFIG_COMPAT
@@ -50,18 +50,15 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
 
 #define store_ih(where,what) copy_item_head (where, what)
 
-static inline bool is_privroot_deh(struct dentry *dir,
-                                   struct reiserfs_de_head *deh)
+static inline bool is_privroot_deh(struct inode *dir, struct reiserfs_de_head *deh)
 {
-        struct dentry *privroot = REISERFS_SB(dir->d_sb)->priv_root;
-        return (dir == dir->d_parent && privroot->d_inode &&
+        struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root;
+        return (privroot->d_inode &&
                 deh->deh_objectid == INODE_PKEY(privroot->d_inode)->k_objectid);
 }
 
-int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
-                           filldir_t filldir, loff_t *pos)
+int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 {
-        struct inode *inode = dentry->d_inode;
         struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
         INITIALIZE_PATH(path_to_entry);
         struct buffer_head *bh;
@@ -81,7 +78,7 @@ int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
 
         /* form key for search the next directory entry using f_pos field of
            file structure */
-        make_cpu_key(&pos_key, inode, *pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);
+        make_cpu_key(&pos_key, inode, ctx->pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);
         next_pos = cpu_key_k_offset(&pos_key);
 
         path_to_entry.reada = PATH_READA;
@@ -126,7 +123,6 @@ int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
                              entry_num++, deh++) {
                                 int d_reclen;
                                 char *d_name;
-                                off_t d_off;
                                 ino_t d_ino;
 
                                 if (!de_visible(deh))
@@ -155,11 +151,10 @@ int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
                                 }
 
                                 /* Ignore the .reiserfs_priv entry */
-                                if (is_privroot_deh(dentry, deh))
+                                if (is_privroot_deh(inode, deh))
                                         continue;
 
-                                d_off = deh_offset(deh);
-                                *pos = d_off;
+                                ctx->pos = deh_offset(deh);
                                 d_ino = deh_objectid(deh);
                                 if (d_reclen <= 32) {
                                         local_buf = small_buf;
@@ -187,9 +182,9 @@ int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
                                  * the write lock here for other waiters
                                  */
                                 reiserfs_write_unlock(inode->i_sb);
-                                if (filldir
-                                    (dirent, local_buf, d_reclen, d_off, d_ino,
-                                     DT_UNKNOWN) < 0) {
+                                if (!dir_emit
+                                    (ctx, local_buf, d_reclen, d_ino,
+                                     DT_UNKNOWN)) {
                                         reiserfs_write_lock(inode->i_sb);
                                         if (local_buf != small_buf) {
                                                 kfree(local_buf);
@@ -237,7 +232,7 @@ int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
         }                       /* while */
 
 end:
-        *pos = next_pos;
+        ctx->pos = next_pos;
         pathrelse(&path_to_entry);
         reiserfs_check_path(&path_to_entry);
 out:
@@ -245,10 +240,9 @@ out:
         return ret;
 }
 
-static int reiserfs_readdir(struct file *file, void *dirent, filldir_t filldir)
+static int reiserfs_readdir(struct file *file, struct dir_context *ctx)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        return reiserfs_readdir_dentry(dentry, dirent, filldir, &file->f_pos);
+        return reiserfs_readdir_inode(file_inode(file), ctx);
 }
 
 /* compose directory item containing "." and ".." entries (entries are
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index f844533792ee..0048cc16a6a8 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2975,16 +2975,19 @@ static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
 }
 
 /* clm -- taken from fs/buffer.c:block_invalidate_page */
-static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
+static void reiserfs_invalidatepage(struct page *page, unsigned int offset,
+                                    unsigned int length)
 {
         struct buffer_head *head, *bh, *next;
         struct inode *inode = page->mapping->host;
         unsigned int curr_off = 0;
+        unsigned int stop = offset + length;
+        int partial_page = (offset || length < PAGE_CACHE_SIZE);
         int ret = 1;
 
         BUG_ON(!PageLocked(page));
 
-        if (offset == 0)
+        if (!partial_page)
                 ClearPageChecked(page);
 
         if (!page_has_buffers(page))
@@ -2996,6 +2999,9 @@ static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
                 unsigned int next_off = curr_off + bh->b_size;
                 next = bh->b_this_page;
 
+                if (next_off > stop)
+                        goto out;
+
                 /*
                  * is this block fully invalidated?
                  */
@@ -3014,7 +3020,7 @@ static void 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 (!partial_page && ret) {
                 ret = try_to_release_page(page, 0);
                 /* maybe should BUG_ON(!ret); - neilb */
         }
diff --git a/fs/reiserfs/reiserfs.h b/fs/reiserfs/reiserfs.h
index 157e474ab303..3df5ce6c724d 100644
--- a/fs/reiserfs/reiserfs.h
+++ b/fs/reiserfs/reiserfs.h
@@ -2709,7 +2709,7 @@ extern const struct inode_operations reiserfs_dir_inode_operations;
 extern const struct inode_operations reiserfs_symlink_inode_operations;
 extern const struct inode_operations reiserfs_special_inode_operations;
 extern const struct file_operations reiserfs_dir_operations;
-int reiserfs_readdir_dentry(struct dentry *, void *, filldir_t, loff_t *);
+int reiserfs_readdir_inode(struct inode *, struct dir_context *);
 
 /* tail_conversion.c */
 int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 821bcf70e467..c69cdd749f09 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -171,6 +171,7 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
  * modifying extended attributes. This includes operations such as permissions
  * or ownership changes, object deletions, etc. */
 struct reiserfs_dentry_buf {
+        struct dir_context ctx;
         struct dentry *xadir;
         int count;
         struct dentry *dentries[8];
@@ -223,9 +224,8 @@ static int reiserfs_for_each_xattr(struct inode *inode,
 {
         struct dentry *dir;
         int i, err = 0;
-        loff_t pos = 0;
         struct reiserfs_dentry_buf buf = {
-                .count = 0,
+                .ctx.actor = fill_with_dentries,
         };
 
         /* Skip out, an xattr has no xattrs associated with it */
@@ -249,29 +249,27 @@ static int reiserfs_for_each_xattr(struct inode *inode,
         reiserfs_write_lock(inode->i_sb);
 
         buf.xadir = dir;
-        err = reiserfs_readdir_dentry(dir, &buf, fill_with_dentries, &pos);
-        while ((err == 0 || err == -ENOSPC) && buf.count) {
-                err = 0;
-
-                for (i = 0; i < buf.count && buf.dentries[i]; i++) {
-                        int lerr = 0;
+        while (1) {
+                err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
+                if (err)
+                        break;
+                if (!buf.count)
+                        break;
+                for (i = 0; !err && i < buf.count && buf.dentries[i]; i++) {
                         struct dentry *dentry = buf.dentries[i];
 
-                        if (err == 0 && !S_ISDIR(dentry->d_inode->i_mode))
-                                lerr = action(dentry, data);
+                        if (!S_ISDIR(dentry->d_inode->i_mode))
+                                err = action(dentry, data);
 
                         dput(dentry);
                         buf.dentries[i] = NULL;
-                        err = lerr ?: err;
                 }
+                if (err)
+                        break;
                 buf.count = 0;
-                if (!err)
-                        err = reiserfs_readdir_dentry(dir, &buf,
-                                                      fill_with_dentries, &pos);
         }
         mutex_unlock(&dir->d_inode->i_mutex);
 
-        /* Clean up after a failed readdir */
         cleanup_dentry_buf(&buf);
 
         if (!err) {
@@ -800,6 +798,7 @@ int reiserfs_removexattr(struct dentry *dentry, const char *name)
 }
 
 struct listxattr_buf {
+        struct dir_context ctx;
         size_t size;
         size_t pos;
         char *buf;
@@ -845,8 +844,8 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
 {
         struct dentry *dir;
         int err = 0;
-        loff_t pos = 0;
         struct listxattr_buf buf = {
+                .ctx.actor = listxattr_filler,
                 .dentry = dentry,
                 .buf = buffer,
                 .size = buffer ? size : 0,
@@ -868,7 +867,7 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
         }
 
         mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
-        err = reiserfs_readdir_dentry(dir, &buf, listxattr_filler, &pos);
+        err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
         mutex_unlock(&dir->d_inode->i_mutex);
 
         if (!err)