Sanitize qnx4 fsync handling

* have directory operations use mark_buffer_dirty_inode(),
  so that sync_mapping_buffers() would get those.
* make qnx4_write_inode() honour its last argument.
* get rid of insane copies of very ancient "walk the indirect blocks"
  in qnx4/fsync - they never matched the actual fs layout and, fortunately,
  never'd been called.  Again, all this junk is not needed; ->fsync()
  should just do sync_mapping_buffers + sync_inode (and if we implement
  block allocation for qnx4, we'll need to use mark_buffer_dirty_inode()
  for extent blocks)

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/qnx4/Makefile b/fs/qnx4/Makefile
index 502d7fe98bab534592c16d79b5931c918abb9ce3..e4d408cc5473cf316dbf58fe04dc4e04cfca811e 100644 (file)
--- a/fs/qnx4/Makefile
+++ b/fs/qnx4/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_QNX4FS_FS) += qnx4.o
 
-qnx4-objs := inode.o dir.o namei.o file.o bitmap.o truncate.o fsync.o
+qnx4-objs := inode.o dir.o namei.o file.o bitmap.o truncate.o

diff --git a/fs/qnx4/dir.c b/fs/qnx4/dir.c
index ea9ffefb48add56ddace16e202e80d49b97859c5..ff6c1ba6c4e01b982caf95f8ad84620c2d682b80 100644 (file)
--- a/fs/qnx4/dir.c
+++ b/fs/qnx4/dir.c
@@ -84,7 +84,7 @@ const struct file_operations qnx4_dir_operations =
 {
        .read           = generic_read_dir,
        .readdir        = qnx4_readdir,
-       .fsync          = file_fsync,
+       .fsync          = simple_fsync,
 };
 
 const struct inode_operations qnx4_dir_inode_operations =

diff --git a/fs/qnx4/file.c b/fs/qnx4/file.c
index 867f42b02035dd6621f681a6730d90c2a3a3c4ae..e7033ea10e2fc7aac1fbf7837a195bbb81dab034 100644 (file)
--- a/fs/qnx4/file.c
+++ b/fs/qnx4/file.c
@@ -29,7 +29,7 @@ const struct file_operations qnx4_file_operations =
 #ifdef CONFIG_QNX4FS_RW
        .write          = do_sync_write,
        .aio_write      = generic_file_aio_write,
-       .fsync          = qnx4_sync_file,
+       .fsync          = simple_fsync,
 #endif
 };
 

diff --git a/fs/qnx4/fsync.c b/fs/qnx4/fsync.c
deleted file mode 100644 (file)
index aa3b195..0000000
--- a/fs/qnx4/fsync.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/* 
- * QNX4 file system, Linux implementation.
- * 
- * Version : 0.1
- * 
- * Using parts of the xiafs filesystem.
- * 
- * History :
- * 
- * 24-03-1998 by Richard Frowijn : first release.
- */
-
-#include <linux/errno.h>
-#include <linux/time.h>
-#include <linux/stat.h>
-#include <linux/fcntl.h>
-#include <linux/smp_lock.h>
-#include <linux/buffer_head.h>
-
-#include <linux/fs.h>
-#include <linux/qnx4_fs.h>
-
-#include <asm/system.h>
-
-/*
- * The functions for qnx4 fs file synchronization.
- */
-
-#ifdef CONFIG_QNX4FS_RW
-
-static int sync_block(struct inode *inode, unsigned short *block, int wait)
-{
-       struct buffer_head *bh;
-       unsigned short tmp;
-
-       if (!*block)
-               return 0;
-       tmp = *block;
-       bh = sb_find_get_block(inode->i_sb, *block);
-       if (!bh)
-               return 0;
-       if (*block != tmp) {
-               brelse(bh);
-               return 1;
-       }
-       if (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
-               brelse(bh);
-               return -1;
-       }
-       if (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
-               brelse(bh);
-               return 0;
-       }
-       ll_rw_block(WRITE, 1, &bh);
-       atomic_dec(&bh->b_count);
-       return 0;
-}
-
-#ifdef WTF
-static int sync_iblock(struct inode *inode, unsigned short *iblock,
-                      struct buffer_head **bh, int wait)
-{
-       int rc;
-       unsigned short tmp;
-
-       *bh = NULL;
-       tmp = *iblock;
-       if (!tmp)
-               return 0;
-       rc = sync_block(inode, iblock, wait);
-       if (rc)
-               return rc;
-       *bh = sb_bread(inode->i_sb, tmp);
-       if (tmp != *iblock) {
-               brelse(*bh);
-               *bh = NULL;
-               return 1;
-       }
-       if (!*bh)
-               return -1;
-       return 0;
-}
-#endif
-
-static int sync_direct(struct inode *inode, int wait)
-{
-       int i;
-       int rc, err = 0;
-
-       for (i = 0; i < 7; i++) {
-               rc = sync_block(inode,
-                               (unsigned short *) qnx4_raw_inode(inode)->di_first_xtnt.xtnt_blk + i, wait);
-               if (rc > 0)
-                       break;
-               if (rc)
-                       err = rc;
-       }
-       return err;
-}
-
-#ifdef WTF
-static int sync_indirect(struct inode *inode, unsigned short *iblock, int wait)
-{
-       int i;
-       struct buffer_head *ind_bh;
-       int rc, err = 0;
-
-       rc = sync_iblock(inode, iblock, &ind_bh, wait);
-       if (rc || !ind_bh)
-               return rc;
-
-       for (i = 0; i < 512; i++) {
-               rc = sync_block(inode,
-                               ((unsigned short *) ind_bh->b_data) + i,
-                               wait);
-               if (rc > 0)
-                       break;
-               if (rc)
-                       err = rc;
-       }
-       brelse(ind_bh);
-       return err;
-}
-
-static int sync_dindirect(struct inode *inode, unsigned short *diblock,
-                         int wait)
-{
-       int i;
-       struct buffer_head *dind_bh;
-       int rc, err = 0;
-
-       rc = sync_iblock(inode, diblock, &dind_bh, wait);
-       if (rc || !dind_bh)
-               return rc;
-
-       for (i = 0; i < 512; i++) {
-               rc = sync_indirect(inode,
-                               ((unsigned short *) dind_bh->b_data) + i,
-                                  wait);
-               if (rc > 0)
-                       break;
-               if (rc)
-                       err = rc;
-       }
-       brelse(dind_bh);
-       return err;
-}
-#endif
-
-int qnx4_sync_file(struct file *file, struct dentry *dentry, int unused)
-{
-        struct inode *inode = dentry->d_inode;
-       int wait, err = 0;
-        
-        (void) file;
-       if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
-             S_ISLNK(inode->i_mode)))
-               return -EINVAL;
-
-       lock_kernel();
-       for (wait = 0; wait <= 1; wait++) {
-               err |= sync_direct(inode, wait);
-       }
-       err |= qnx4_sync_inode(inode);
-       unlock_kernel();
-       return (err < 0) ? -EIO : 0;
-}
-
-#endif

diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 95c12fc613f1fb899fadbab11673d19d2fe71d19..40712867b8a874f9b4bca3df50faca3dc26e1292 100644 (file)
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -24,6 +24,7 @@
 #include <linux/smp_lock.h>
 #include <linux/pagemap.h>
 #include <linux/buffer_head.h>
+#include <linux/writeback.h>
 #include <linux/vfs.h>
 #include <asm/uaccess.h>
 
@@ -34,31 +35,6 @@ static const struct super_operations qnx4_sops;
 
 #ifdef CONFIG_QNX4FS_RW
 
-int qnx4_sync_inode(struct inode *inode)
-{
-       int err = 0;
-# if 0
-       struct buffer_head *bh;
-
-       bh = qnx4_update_inode(inode);
-       if (bh && buffer_dirty(bh))
-       {
-               sync_dirty_buffer(bh);
-               if (buffer_req(bh) && !buffer_uptodate(bh))
-               {
-                       printk ("IO error syncing qnx4 inode [%s:%08lx]\n",
-                               inode->i_sb->s_id, inode->i_ino);
-                       err = -1;
-               }
-               brelse (bh);
-       } else if (!bh) {
-               err = -1;
-       }
-# endif
-
-       return err;
-}
-
 static void qnx4_delete_inode(struct inode *inode)
 {
        QNX4DEBUG(("qnx4: deleting inode [%lu]\n", (unsigned long) inode->i_ino));
@@ -70,7 +46,7 @@ static void qnx4_delete_inode(struct inode *inode)
        unlock_kernel();
 }
 
-static int qnx4_write_inode(struct inode *inode, int unused)
+static int qnx4_write_inode(struct inode *inode, int do_sync)
 {
        struct qnx4_inode_entry *raw_inode;
        int block, ino;
@@ -107,6 +83,16 @@ static int qnx4_write_inode(struct inode *inode, int unused)
        raw_inode->di_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
        raw_inode->di_first_xtnt.xtnt_size = cpu_to_le32(inode->i_blocks);
        mark_buffer_dirty(bh);
+       if (do_sync) {
+               sync_dirty_buffer(bh);
+               if (buffer_req(bh) && !buffer_uptodate(bh)) {
+                       printk("qnx4: IO error syncing inode [%s:%08x]\n",
+                                       inode->i_sb->s_id, ino);
+                       brelse(bh);
+                       unlock_kernel();
+                       return -EIO;
+               }
+       }
        brelse(bh);
        unlock_kernel();
        return 0;

diff --git a/fs/qnx4/namei.c b/fs/qnx4/namei.c
index 775eed3a4085ffa793c7bd42ea1ad463a3c143f9..123270c537607396b579e25b53d15fb6b03da48e 100644 (file)
--- a/fs/qnx4/namei.c
+++ b/fs/qnx4/namei.c
@@ -187,7 +187,7 @@ int qnx4_rmdir(struct inode *dir, struct dentry *dentry)
        de->di_status = 0;
        memset(de->di_fname, 0, sizeof de->di_fname);
        de->di_mode = 0;
-       mark_buffer_dirty(bh);
+       mark_buffer_dirty_inode(bh, dir);
        clear_nlink(inode);
        mark_inode_dirty(inode);
        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
@@ -232,7 +232,7 @@ int qnx4_unlink(struct inode *dir, struct dentry *dentry)
        de->di_status = 0;
        memset(de->di_fname, 0, sizeof de->di_fname);
        de->di_mode = 0;
-       mark_buffer_dirty(bh);
+       mark_buffer_dirty_inode(bh, dir);
        dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
        mark_inode_dirty(dir);
        inode->i_ctime = dir->i_ctime;

diff --git a/include/linux/qnx4_fs.h b/include/linux/qnx4_fs.h
index 787d19ea9f46a35b4fcbd12e91b597e56587bccb..acbaec3524e09c129d7a3c1681823bf89d92b0ae 100644 (file)
--- a/include/linux/qnx4_fs.h
+++ b/include/linux/qnx4_fs.h
@@ -126,8 +126,6 @@ extern void qnx4_truncate(struct inode *inode);
 extern void qnx4_free_inode(struct inode *inode);
 extern int qnx4_unlink(struct inode *dir, struct dentry *dentry);
 extern int qnx4_rmdir(struct inode *dir, struct dentry *dentry);
-extern int qnx4_sync_file(struct file *file, struct dentry *dentry, int);
-extern int qnx4_sync_inode(struct inode *inode);
 
 static inline struct qnx4_sb_info *qnx4_sb(struct super_block *sb)
 {