reiserfs: rename p_s_inode to inode

[linux-2.6-omap-h63xx.git] / fs / reiserfs / file.c

diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index a804903d31d1e336e73072a7e15453a3eac59ce1..a73579f66214fd1493bdc04f427ef6a01f37ff03 100644 (file)
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -20,14 +20,14 @@
 ** insertion/balancing, for files that are written in one write.
 ** It avoids unnecessary tail packings (balances) for files that are written in
 ** multiple writes and are small enough to have tails.
-** 
+**
 ** file_release is called by the VFS layer when the file is closed.  If
 ** this is the last open file descriptor, and the file
 ** small enough to have a tail, and the tail is currently in an
 ** unformatted node, the tail is converted back into a direct item.
-** 
+**
 ** We use reiserfs_truncate_file to pack the tail, since it already has
-** all the conditions coded.  
+** all the conditions coded.
 */
 static int reiserfs_file_release(struct inode *inode, struct file *filp)
 {
@@ -76,7 +76,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
                         * and let the admin know what is going on.
                         */
                        igrab(inode);
-                       reiserfs_warning(inode->i_sb,
+                       reiserfs_warning(inode->i_sb, "clm-9001",
                                         "pinning inode %lu because the "
                                         "preallocation can't be freed",
                                         inode->i_ino);
@@ -137,17 +137,17 @@ static void reiserfs_vfs_truncate_file(struct inode *inode)
 static int reiserfs_sync_file(struct file *p_s_filp,
                              struct dentry *p_s_dentry, int datasync)
 {
-       struct inode *p_s_inode = p_s_dentry->d_inode;
+       struct inode *inode = p_s_dentry->d_inode;
        int n_err;
        int barrier_done;
 
-       BUG_ON(!S_ISREG(p_s_inode->i_mode));
-       n_err = sync_mapping_buffers(p_s_inode->i_mapping);
-       reiserfs_write_lock(p_s_inode->i_sb);
-       barrier_done = reiserfs_commit_for_inode(p_s_inode);
-       reiserfs_write_unlock(p_s_inode->i_sb);
-       if (barrier_done != 1 && reiserfs_barrier_flush(p_s_inode->i_sb))
-               blkdev_issue_flush(p_s_inode->i_sb->s_bdev, NULL);
+       BUG_ON(!S_ISREG(inode->i_mode));
+       n_err = sync_mapping_buffers(inode->i_mapping);
+       reiserfs_write_lock(inode->i_sb);
+       barrier_done = reiserfs_commit_for_inode(inode);
+       reiserfs_write_unlock(inode->i_sb);
+       if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
+               blkdev_issue_flush(inode->i_sb->s_bdev, NULL);
        if (barrier_done < 0)
                return barrier_done;
        return (n_err < 0) ? -EIO : 0;
@@ -223,7 +223,7 @@ int reiserfs_commit_page(struct inode *inode, struct page *page,
 }
 
 /* Write @count bytes at position @ppos in a file indicated by @file
-   from the buffer @buf.  
+   from the buffer @buf.
 
    generic_file_write() is only appropriate for filesystems that are not seeking to optimize performance and want
    something simple that works.  It is not for serious use by general purpose filesystems, excepting the one that it was
@@ -296,6 +296,7 @@ const struct file_operations reiserfs_file_operations = {
        .aio_write = generic_file_aio_write,
        .splice_read = generic_file_splice_read,
        .splice_write = generic_file_splice_write,
+       .llseek = generic_file_llseek,
 };
 
 const struct inode_operations reiserfs_file_inode_operations = {