Make O_SYNC handling use standard syncing path (version 4)
Subsystems (24)
Jan Kara
maintainercover Make O_SYNC handling use standard syncing path (version 4)
Hi,
here is a new version of my O_SYNC cleanup patches. There are two minor
changes since last time. XFS now uses filemap_write_and_wait() as Christoph asked and generic syncing function has been renamed to vfs_fsync_range() and the flags controling it are gone and it has just a single datasync flag as other syncing functions.
If noone objects, I think the patch series is ready to be put in linux-next.
Honza
Jan Kara
maintainerPATCH 1/16 vfs: Introduce filemap_fdatawait_range
This simple helper saves some filesystems conversion from byte offset to page numbers and also makes the fdata* interface more complete.
--- include/linux/fs.h | 2 ++ mm/filemap.c | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 0 deletions(-)
include/linux/fs.h +2 -0
@@ -2076,6 +2076,8 @@ extern int write_inode_now(struct inode *, int);extern int filemap_fdatawrite (struct address_space *);extern int filemap_flush (struct address_space *);extern int filemap_fdatawait (struct address_space *); +extern int filemap_fdatawait_range (struct address_space *,loff_t lstart, +loff_t lend);extern int filemap_write_and_wait (struct address_space *mapping);extern int filemap_write_and_wait_range (struct address_space *mapping,loff_t lstart,loff_t lend);
mm/filemap.c +20 -0
@@ -307,6 +307,26 @@ int wait_on_page_writeback_range(struct address_space *mapping, }/** +* filemap_fdatawait_range - wait for all under-writeback pages to complete in a given range +* @mapping: address space structure to wait for +* @start: offset in bytes where the range starts +* @end: offset in bytes where the range ends (inclusive) +* +* Walk the list of under-writeback pages of the given address space +* in the given range and wait for all of them. +* +* This is just a simple wrapper so that callers don't have to convert offsets +* to page indexes themselves +*/ +int filemap_fdatawait_range (struct address_space *mapping,loff_t start, +loff_t end) +{ +return wait_on_page_writeback_range (mapping, start >>PAGE_CACHE_SHIFT , + end >>PAGE_CACHE_SHIFT ); +} +EXPORT_SYMBOL (filemap_fdatawait_range); + +/** * sync_page_range - write and wait on all pages in the passed range * @inode: target inode * @mapping: target address_space
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 2/16 vfs: Export __generic_file_aio_write() and add some comments
In reply to Jan KaraRename __generic_file_aio_write_nolock() to __generic_file_aio_write(), add comments to write helpers explaining how they should be used and export __generic_file_aio_write() since it will be used by some filesystems.
--- include/linux/fs.h | 2 + mm/filemap.c | 57 +++++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 52 insertions(+), 7 deletions(-)
include/linux/fs.h +2 -0
@@ -2195,6 +2195,8 @@ extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);extern int file_read_actor (read_descriptor_t * desc,struct page *page,unsigned long offset,unsigned long size);int generic_write_checks (struct file *file,loff_t *pos,size_t *count,int isblk);extern ssize_t generic_file_aio_read (struct kiocb *,const struct iovec *,unsigned long ,loff_t ); +extern ssize_t __generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long , +loff_t *);extern ssize_t generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t );extern ssize_t generic_file_aio_write_nolock (struct kiocb *,const struct iovec *,unsigned long ,loff_t );
mm/filemap.c +50 -7
88 lines not on this page · raw message
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 3/16 vfs: Remove syncing from generic_file_direct_write() and generic_file_buffered_write()
In reply to Jan Karageneric_file_direct_write() and generic_file_buffered_write() called generic_osync_inode() if it was called on O_SYNC file or IS_SYNC inode. But this is superfluous since generic_file_aio_write() does the syncing as well. Also XFS and OCFS2 which call these functions directly handle syncing themselves. So let's have a single place where syncing happens:generic_file_aio_write().
We slightly change the behavior by syncing only the range of file to which the write happened for buffered writes but that should be all that is required.
--- mm/filemap.c | 35 ++++++----------------------------- 1 files changed, 6 insertions(+), 29 deletions(-)
mm/filemap.c +6 -29
@@ -2187,20 +2187,7 @@ generic_file_direct_write(struct kiocb *iocb, const struct iovec *iov, } *ppos = end; } - -/* -* Sync the fs metadata but not the minor inode changes and -* of course not the data as we did direct DMA for the IO. -* i_mutex is held, which protects generic_osync_inode() from -* livelocking. AIO O_DIRECT ops attempt to sync metadata here. -*/ out: -if ((written >=0 || written == -EIOCBQUEUED ) && - ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -int err =generic_osync_inode (inode, mapping,OSYNC_METADATA ); -if (err <0 ) - written = err; - }return written; }EXPORT_SYMBOL (generic_file_direct_write);
@@ -2332,8 +2319,6 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov, {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping; -const struct address_space_operations *a_ops = mapping->a_ops; -struct inode *inode = mapping->host;ssize_t status;struct iov_iter i;
@@ -2343,16 +2328,6 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,if (likely (status >=0 )) { written += status; *ppos = pos + status; - -/* -* For now, when the user asks for O_SYNC, we'll actually give -* O_DSYNC -*/ -if (unlikely ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -if (!a_ops->writepage || !is_sync_kiocb (iocb)) - status =generic_osync_inode (inode, mapping, -OSYNC_METADATA |OSYNC_DATA ); - } }/*
@@ -2514,11 +2489,12 @@ ssize_t generic_file_aio_write_nolock(struct kiocb *iocb, ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); -if (ret >0 && ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { +if ((ret >0 || ret == -EIOCBQUEUED ) && + ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) {ssize_t err; err =sync_page_range_nolock (inode, mapping, pos, ret); -if (err <0 ) +if (err <0 && ret >0 ) ret = err; }return ret;
@@ -2550,11 +2526,12 @@ ssize_t generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov, ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos);mutex_unlock (&inode->i_mutex); -if (ret >0 && ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { +if ((ret >0 || ret == -EIOCBQUEUED ) && + ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) {ssize_t err; err =sync_page_range (inode, mapping, pos, ret); -if (err <0 ) +if (err <0 && ret >0 ) ret = err; }return ret;
Signature · 6 lines
1.6.0.2 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Jan Kara
maintainerPATCH 4/16 pohmelfs: Use __generic_file_aio_write instead of generic_file_aio_write_nolock
In reply to Jan KaraUse new helper __generic_file_aio_write(). Since the fs takes care of syncing by itself afterwards, there are no more changes needed.
--- drivers/staging/pohmelfs/inode.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/staging/pohmelfs/inode.c +1 -1
@@ -921,7 +921,7 @@ ssize_t pohmelfs_write(struct file *file, const char __user *buf,if (ret) goto err_out_unlock; - ret =generic_file_aio_write_nolock (&kiocb, &iov,1 , pos); + ret =__generic_file_aio_write (&kiocb, &iov,1 , &kiocb.ki_pos); *ppos = kiocb.ki_pos;mutex_unlock (&inode->i_mutex);
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 5/16 ocfs2: Use __generic_file_aio_write instead of generic_file_aio_write_nolock
In reply to Jan KaraUse the new helper. We have to submit data pages ourselves in case of O_SYNC write because __generic_file_aio_write does not do it for us. OCFS2 developpers might think about moving the sync out of i_mutex which seems to be easily possible but that's out of scope of this patch.
--- fs/ocfs2/file.c | 22 ++++++++++++---------- 1 files changed, 12 insertions(+), 10 deletions(-)
fs/ocfs2/file.c +12 -10
@@ -1871,8 +1871,7 @@ relock: goto out_dio; } }else { - written =generic_file_aio_write_nolock (iocb, iov, nr_segs, - *ppos); + written =__generic_file_aio_write (iocb, iov, nr_segs, ppos); } out_dio:
@@ -1880,18 +1879,21 @@ out_dio:BUG_ON (ret == -EIOCBQUEUED && !(file->f_flags &O_DIRECT ));if ((file->f_flags &O_SYNC && !direct_io) ||IS_SYNC (inode)) { -/* -* The generic write paths have handled getting data -* to disk, but since we don't make use of the dirty -* inode list, a manual journal commit is necessary -* here. -*/ -if (old_size !=i_size_read (inode) || - old_clusters !=OCFS2_I (inode)->ip_clusters) { + ret =filemap_fdatawrite_range (file->f_mapping, pos, + pos + count -1 ); +if (ret <0 ) + written = ret; + +if (!ret && (old_size !=i_size_read (inode) || + old_clusters !=OCFS2_I (inode)->ip_clusters)) { ret =jbd2_journal_force_commit (osb->journal->j_journal);if (ret <0 ) written = ret; } + +if (!ret) + ret =filemap_fdatawait_range (file->f_mapping, pos, + pos + count -1 ); }/*
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 6/16 vfs: Rename generic_file_aio_write_nolock
In reply to Jan Karageneric_file_aio_write_nolock() is now used only by block devices and raw character device. Filesystems should use __generic_file_aio_write() in case generic_file_aio_write() doesn't suit them. So rename the function to device_aio_write().
--- drivers/char/raw.c | 2 +- fs/block_dev.c | 2 +- include/linux/fs.h | 4 ++-- mm/filemap.c | 9 ++++----- 4 files changed, 8 insertions(+), 9 deletions(-)
drivers/char/raw.c +1 -1
@@ -246,7 +246,7 @@ static const struct file_operations raw_fops = { .read = do_sync_read, .aio_read = generic_file_aio_read, .write = do_sync_write, - .aio_write = generic_file_aio_write_nolock, + .aio_write = device_aio_write, .open = raw_open, .release= raw_release, .ioctl = raw_ioctl,
fs/block_dev.c +1 -1
@@ -1436,7 +1436,7 @@ const struct file_operations def_blk_fops = { .read = do_sync_read, .write = do_sync_write, .aio_read = generic_file_aio_read, - .aio_write = generic_file_aio_write_nolock, + .aio_write = device_aio_write, .mmap = generic_file_mmap, .fsync = block_fsync, .unlocked_ioctl = block_ioctl,
include/linux/fs.h +2 -2
@@ -2198,8 +2198,8 @@ extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigextern ssize_t __generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t *);extern ssize_t generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t ); -extern ssize_t generic_file_aio_write_nolock (struct kiocb *,const struct iovec *, -unsigned long ,loff_t ); +extern ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos);extern ssize_t generic_file_direct_write (struct kiocb *,const struct iovec *,unsigned long *,loff_t ,loff_t *,size_t ,size_t ); extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
mm/filemap.c +4 -5
@@ -2462,9 +2462,8 @@ out: }EXPORT_SYMBOL (__generic_file_aio_write); -/** -* generic_file_aio_write_nolock - write data, usually to a device +* device_aio_write - write data * @iocb: IO state structure * @iov: vector with data to write * @nr_segs: number of segments in the vector
@@ -2477,8 +2476,8 @@ EXPORT_SYMBOL(__generic_file_aio_write);* do a write but already holds i_mutex, use __generic_file_aio_write() * directly and then sync the file like generic_file_aio_write(). */ -ssize_t generic_file_aio_write_nolock (struct kiocb *iocb, -const struct iovec *iov,unsigned long nr_segs,loff_t pos) +ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos) {struct file *file = iocb->ki_filp;struct address_space *mapping = file->f_mapping;
@@ -2499,7 +2498,7 @@ ssize_t generic_file_aio_write_nolock(struct kiocb *iocb, }return ret; } -EXPORT_SYMBOL (generic_file_aio_write_nolock); +EXPORT_SYMBOL (device_aio_write);/** * generic_file_aio_write - write data to a file
Signature · 1 line
1.6.0.2
Re: [PATCH 06/16] vfs: Rename generic_file_aio_write_nolock
Quoted 4 lines · Jan Kara
generic_file_aio_write_nolock()is now used only by block devices and raw character device. Filesystems should use__generic_file_aio_write()in casegeneric_file_aio_write()doesn't suit them. So rename the function todevice_aio_write().
I would recommend this one on top:
Move it to fs/block_dev.c, rename it to blkdev_aio_write, export it _GPL only and make it very clear it's only for block devices and raw.
And btw, I'm not actually sure it is the right thing for raw. Raw is supposed to do direct I/O only, and in fact forced O_DIRECT on. Because there are no holes it also can't fall back to direct I/O. So strictly
spreaking we could just use __generic_file_aio_write directly. That
is until we care about the hw disk caches..
drivers/char/raw.c +1 -1
@@ -246,7 +246,7 @@ static const struct file_operations raw_ .read = do_sync_read, .aio_read = generic_file_aio_read, .write = do_sync_write, - .aio_write = device_aio_write, + .aio_write = blkdev_aio_write, .open = raw_open, .release= raw_release, .ioctl = raw_ioctl,
fs/block_dev.c +28 -1
@@ -1405,6 +1405,33 @@ static long block_ioctl(struct file *fil }/* +* Write data to the block device. Only intended for the block device itself +* and the raw driver which basically is a fake block device. +* +* Does not take i_mutex for the write and thus is not for general purpose +* use. +*/ +ssize_t blkdev_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos) +{ +struct file *file = iocb->ki_filp; +ssize_t ret; + +BUG_ON (iocb->ki_pos != pos); + + ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); +if (ret >0 || ret == -EIOCBQUEUED ) { +ssize_t err; + + err =generic_write_sync (file, pos, ret); +if (err <0 && ret >0 ) + ret = err; + } +return ret; +} +EXPORT_SYMBOL_GPL (blkdev_aio_write); + +/* * Try to release a page associated with block device when the system * is under memory pressure. */
@@ -1436,7 +1463,7 @@ const struct file_operations def_blk_fop .read = do_sync_read, .write = do_sync_write, .aio_read = generic_file_aio_read, - .aio_write = device_aio_write, + .aio_write = blkdev_aio_write, .mmap = generic_file_mmap, .fsync = block_fsync, .unlocked_ioctl = block_ioctl,
include/linux/fs.h +4 -2
@@ -2196,8 +2196,6 @@ extern ssize_t generic_file_aio_read(strextern ssize_t __generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t *);extern ssize_t generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t ); -extern ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, -unsigned long nr_segs,loff_t pos);extern ssize_t generic_file_direct_write (struct kiocb *,const struct iovec *,unsigned long *,loff_t ,loff_t *,size_t ,size_t ); extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
@@ -2207,6 +2205,10 @@ extern ssize_t do_sync_write(struct fileextern int generic_segment_checks (const struct iovec *iov,unsigned long *nr_segs,size_t *count,int access_flags); +/* fs/block_dev.c */ +extern ssize_t blkdev_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos); +/* fs/splice.c */ extern ssize_t generic_file_splice_read (struct file *,loff_t *,struct pipe_inode_info *,size_t ,unsigned int );
mm/filemap.c +0 -35
@@ -2398,41 +2398,6 @@ out:EXPORT_SYMBOL (__generic_file_aio_write);/** -* device_aio_write - write data -* @iocb: IO state structure -* @iov: vector with data to write -* @nr_segs: number of segments in the vector -* @pos: position in file where to write -* -* This is a wrapper around __generic_file_aio_write() which takes care of -* syncing the file in case of O_SYNC file. It does not take i_mutex for the -* write itself but may do so during syncing. It is meant for users like block -* devices which do not need i_mutex during write. If your filesystem needs to -* do a write but already holds i_mutex, use __generic_file_aio_write() -* directly and then sync the file like generic_file_aio_write(). -*/ -ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, -unsigned long nr_segs,loff_t pos) -{ -struct file *file = iocb->ki_filp; -ssize_t ret; - -BUG_ON (iocb->ki_pos != pos); - - ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); - -if (ret >0 || ret == -EIOCBQUEUED ) { -ssize_t err; - - err =generic_write_sync (file, pos, ret); -if (err <0 && ret >0 ) - ret = err; - } -return ret; -} -EXPORT_SYMBOL (device_aio_write); - -/** * generic_file_aio_write - write data to a file * @iocb: IO state structure * @iov: vector with data to write
Jan Kara
maintainerRe: [PATCH 06/16] vfs: Rename generic_file_aio_write_nolock
Quoted 10 lines · Christoph Hellwig
Quoted 4 lines · Jan Kara
generic_file_aio_write_nolock()is now used only by block devices and raw character device. Filesystems should use__generic_file_aio_write()in casegeneric_file_aio_write()doesn't suit them. So rename the function todevice_aio_write().I would recommend this one on top:
Move it to
fs/block_dev.c, rename it toblkdev_aio_write, export it_GPLonly and make it very clear it's only for block devices and raw.
Yes, fine with me. I'll replace my patch with yours so that we don't
rename the function twice unnecessarily.
Quoted 5 lines
And btw, I'm not actually sure it is the right thing for raw. Raw is supposed to do direct I/O only, and in fact forced
O_DIRECTon. Because there are no holes it also can't fall back to direct I/O. So strictly
spreaking we could just use__generic_file_aio_writedirectly. That
is until we care about the hw disk caches..
I'm slightly confused with the above - probably you mean it cannot fall
back to buffered I/O and it could use generic_file_direct_write (because __generic_file_aio_write is just blkdev_aio_write without syncing in case of O_SYNC). The thing with using generic_file_direct_write() is that we'd have to duplicate checks in the beginning of __generic_file_aio_write() so I'm not sure the code will be cleaner in the end.
Honza
Quoted 132 lines
Signed-off-by Christoph Hellwig <[email protected]>Index:
linux-2.6/drivers/char/raw.c
===================================================================drivers/char/raw.c +1
-1@@ -246,7 +246,7 @@ static const struct file_operations raw_ .read = do_sync_read, .aio_read = generic_file_aio_read, .write = do_sync_write, - .aio_write = device_aio_write, + .aio_write = blkdev_aio_write, .open = raw_open, .release= raw_release, .ioctl = raw_ioctl,Index:
linux-2.6/fs/block_dev.c
===================================================================fs/block_dev.c +28
-1@@ -1405,6 +1405,33 @@ static long block_ioctl(struct file *fil }/* +* Write data to the block device. Only intended for the block device itself +* and the raw driver which basically is a fake block device. +* +* Does not take i_mutex for the write and thus is not for general purpose +* use. +*/ +ssize_t blkdev_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos) +{ +struct file *file = iocb->ki_filp; +ssize_t ret; + +BUG_ON (iocb->ki_pos != pos); + + ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); +if (ret >0 || ret == -EIOCBQUEUED ) { +ssize_t err; + + err =generic_write_sync (file, pos, ret); +if (err <0 && ret >0 ) + ret = err; + } +return ret; +} +EXPORT_SYMBOL_GPL (blkdev_aio_write); + +/* * Try to release a page associated with block device when the system * is under memory pressure. */ @@ -1436,7 +1463,7 @@ const struct file_operations def_blk_fop .read = do_sync_read, .write = do_sync_write, .aio_read = generic_file_aio_read, - .aio_write = device_aio_write, + .aio_write = blkdev_aio_write, .mmap = generic_file_mmap, .fsync = block_fsync, .unlocked_ioctl = block_ioctl,Index:
linux-2.6/include/linux/fs.h
===================================================================include/linux/fs.h +4
-2@@ -2196,8 +2196,6 @@ extern ssize_t generic_file_aio_read(strextern ssize_t __generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t *);extern ssize_t generic_file_aio_write (struct kiocb *,const struct iovec *,unsigned long ,loff_t ); -extern ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, -unsigned long nr_segs,loff_t pos);extern ssize_t generic_file_direct_write (struct kiocb *,const struct iovec *,unsigned long *,loff_t ,loff_t *,size_t ,size_t ); extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,@@ -2207,6 +2205,10 @@ extern ssize_t do_sync_write(struct fileextern int generic_segment_checks (const struct iovec *iov,unsigned long *nr_segs,size_t *count,int access_flags); +/* fs/block_dev.c */ +extern ssize_t blkdev_aio_write (struct kiocb *iocb,const struct iovec *iov, +unsigned long nr_segs,loff_t pos); +/* fs/splice.c */ extern ssize_t generic_file_splice_read (struct file *,loff_t *,struct pipe_inode_info *,size_t ,unsigned int );Index:
linux-2.6/mm/filemap.c
===================================================================mm/filemap.c +0
-35@@ -2398,41 +2398,6 @@ out:EXPORT_SYMBOL (__generic_file_aio_write);/** -* device_aio_write - write data -* @iocb: IO state structure -* @iov: vector with data to write -* @nr_segs: number of segments in the vector -* @pos: position in file where to write -* -* This is a wrapper around __generic_file_aio_write() which takes care of -* syncing the file in case of O_SYNC file. It does not take i_mutex for the -* write itself but may do so during syncing. It is meant for users like block -* devices which do not need i_mutex during write. If your filesystem needs to -* do a write but already holds i_mutex, use __generic_file_aio_write() -* directly and then sync the file like generic_file_aio_write(). -*/ -ssize_t device_aio_write (struct kiocb *iocb,const struct iovec *iov, -unsigned long nr_segs,loff_t pos) -{ -struct file *file = iocb->ki_filp; -ssize_t ret; - -BUG_ON (iocb->ki_pos != pos); - - ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); - -if (ret >0 || ret == -EIOCBQUEUED ) { -ssize_t err; - - err =generic_write_sync (file, pos, ret); -if (err <0 && ret >0 ) - ret = err; - } -return ret; -} -EXPORT_SYMBOL (device_aio_write); - -/** * generic_file_aio_write - write data to a file * @iocb: IO state structure * @iov: vector with data to write
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH 06/16] vfs: Rename generic_file_aio_write_nolock
Quoted 4 lines · Jan Kara
Quoted 2 lines
Move it to
fs/block_dev.c, rename it toblkdev_aio_write, export it_GPLonly and make it very clear it's only for block devices and raw.Yes, fine with me. I'll replace my patch with yours so that we don't
rename the function twice unnecessarily.
It's not a replacement, it's ontop of yours. But folding it into yours would make a lot of sense.
Quoted 9 lines
Quoted 5 lines
And btw, I'm not actually sure it is the right thing for raw. Raw is supposed to do direct I/O only, and in fact forced
O_DIRECTon. Because there are no holes it also can't fall back to direct I/O. So strictly
spreaking we could just use__generic_file_aio_writedirectly. That
is until we care about the hw disk caches..I'm slightly confused with the above - probably you mean it cannot fall
back to buffered I/O and it could usegeneric_file_direct_write(because__generic_file_aio_writeis justblkdev_aio_writewithout syncing in case ofO_SYNC).
It can not fall back to buffered I/O, yes. Any given that it does not not do buffered I/O and the block/raw device also doesn' have any inode metadata we could just use __generic_file_aio_write directly. That is until my patch to flush the disk cache in ->fsync goes in in which case we'll at least need that one again. But we might just be better off to opencode that instead of really using fsync - that avoids the superflous call to filemap_write_and_wait and performs the cache flush without i_mutex which we don't need.
That is the story for the block device, now the raw device is more difficult as I would be surprised if the user of it used fsync on it. Then again that would require us to find those users first, although they apparently exist as removal of this horrible raw device feature was vetoed by the big distros.
Jan Kara
maintainerPATCH 7/16 vfs: Introduce new helpers for syncing after writing to O_SYNC file or IS_SYNC inode
In reply to Jan KaraIntroduce new function for generic inode syncing (vfs_fsync_range) and use it from fsync() path. Introduce also new helper for syncing after a sync write (generic_write_sync) using the generic function.
Use these new helpers for syncing from generic VFS functions. This makes O_SYNC writes to block devices acquire i_mutex for syncing. If we really care about this, we can make block_fsync() drop the i_mutex and reacquire it before it returns.
--- fs/splice.c | 22 +++++--------------- fs/sync.c | 55 +++++++++++++++++++++++++++++++++++++++++++++------ include/linux/fs.h | 3 ++ mm/filemap.c | 18 +++++----------- 4 files changed, 63 insertions(+), 35 deletions(-)
fs/splice.c +6 -16
@@ -976,25 +976,15 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,if (ret >0 ) {unsigned long nr_pages; +int err; - *ppos += ret; nr_pages = (ret +PAGE_CACHE_SIZE -1 ) >>PAGE_CACHE_SHIFT ; -/* -* If file or inode is SYNC and we actually wrote some data, -* sync it. -*/ -if (unlikely ((out->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -int err; - -mutex_lock (&inode->i_mutex); - err =generic_osync_inode (inode, mapping, -OSYNC_METADATA |OSYNC_DATA ); -mutex_unlock (&inode->i_mutex); - -if (err) - ret = err; - } + err =generic_write_sync (out, *ppos, ret); +if (err) + ret = err; +else + *ppos += ret;balance_dirty_pages_ratelimited_nr (mapping, nr_pages); }
fs/sync.c +48 -7
92 lines not on this page · raw message
include/linux/fs.h +3 -0
@@ -2088,7 +2088,10 @@ extern int __filemap_fdatawrite_range(struct address_space *mapping,extern int filemap_fdatawrite_range (struct address_space *mapping,loff_t start,loff_t end); +extern int vfs_fsync_range (struct file *file,struct dentry *dentry, +loff_t start,loff_t end,int datasync);extern int vfs_fsync (struct file *file,struct dentry *dentry,int datasync); +extern int generic_write_sync (struct file *file,loff_t pos,loff_t count);extern void sync_supers (void );extern void emergency_sync (void );extern void emergency_remount (void );
mm/filemap.c +6 -12
@@ -39,11 +39,10 @@/* * FIXME: remove all knowledge of the buffer layer from the core VM */ -#include <linux/buffer_head.h> /* for generic_osync_inode */ +#include <linux/buffer_head.h> /* for try_to_free_buffers */ #include <asm/mman.h> -/* * Shared mappings implemented 30.11.1994. It's not fully working yet, * though.
@@ -2480,19 +2479,16 @@ ssize_t device_aio_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) {struct file *file = iocb->ki_filp; -struct address_space *mapping = file->f_mapping; -struct inode *inode = mapping->host;ssize_t ret;BUG_ON (iocb->ki_pos != pos); ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos); -if ((ret >0 || ret == -EIOCBQUEUED ) && - ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { +if (ret >0 || ret == -EIOCBQUEUED ) {ssize_t err; - err =sync_page_range_nolock (inode, mapping, pos, ret); + err =generic_write_sync (file, pos, ret);if (err <0 && ret >0 ) ret = err; }
@@ -2515,8 +2511,7 @@ ssize_t generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) {struct file *file = iocb->ki_filp; -struct address_space *mapping = file->f_mapping; -struct inode *inode = mapping->host; +struct inode *inode = file->f_mapping->host;ssize_t ret;BUG_ON (iocb->ki_pos != pos);
@@ -2525,11 +2520,10 @@ ssize_t generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov, ret =__generic_file_aio_write (iocb, iov, nr_segs, &iocb->ki_pos);mutex_unlock (&inode->i_mutex); -if ((ret >0 || ret == -EIOCBQUEUED ) && - ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { +if (ret >0 || ret == -EIOCBQUEUED ) {ssize_t err; - err =sync_page_range (inode, mapping, pos, ret); + err =generic_write_sync (file, pos, ret);if (err <0 && ret >0 ) ret = err; }
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 8/16 ext2: Update comment about generic_osync_inode
In reply to Jan KaraWe rely on generic_write_sync() now.
--- fs/ext2/inode.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
fs/ext2/inode.c +1 -1
@@ -482,7 +482,7 @@ static int ext2_alloc_branch(struct inode *inode,unlock_buffer (bh);mark_buffer_dirty_inode (bh, inode);/* We used to sync bh here if IS_SYNC(inode). -* But we now rely upon generic_osync_inode() +* But we now rely upon generic_write_sync() * and b_inode_buffers. But not for directories. */ if (S_ISDIR (inode->i_mode) &&IS_DIRSYNC (inode))
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 9/16 ext3: Remove syncing logic from ext3_file_write
In reply to Jan KaraSyncing is now properly done by generic_file_aio_write() so no special logic is needed in ext3.
--- fs/ext3/file.c | 61 +------------------------------------------------------- 1 files changed, 1 insertions(+), 60 deletions(-)
fs/ext3/file.c +1 -60
@@ -51,71 +51,12 @@ static int ext3_release_file (struct inode * inode, struct file * filp)return 0 ; } -static ssize_t -ext3_file_write (struct kiocb *iocb,const struct iovec *iov, -unsigned long nr_segs,loff_t pos) -{ -struct file *file = iocb->ki_filp; -struct inode *inode = file->f_path.dentry->d_inode; -ssize_t ret; -int err; - - ret =generic_file_aio_write (iocb, iov, nr_segs, pos); - -/* -* Skip flushing if there was an error, or if nothing was written. -*/ -if (ret <=0 ) -return ret; - -/* -* If the inode is IS_SYNC, or is O_SYNC and we are doing data -* journalling then we need to make sure that we force the transaction -* to disk to keep all metadata uptodate synchronously. -*/ -if (file->f_flags &O_SYNC ) { -/* -* If we are non-data-journaled, then the dirty data has -* already been flushed to backing store by generic_osync_inode, -* and the inode has been flushed too if there have been any -* modifications other than mere timestamp updates. -* -* Open question --- do we care about flushing timestamps too -* if the inode is IS_SYNC? -*/ -if (!ext3_should_journal_data (inode)) -return ret; - - goto force_commit; - } - -/* -* So we know that there has been no forced data flush. If the inode -* is marked IS_SYNC, we need to force one ourselves. -*/ -if (!IS_SYNC (inode)) -return ret; - -/* -* Open question #2 --- should we force data to disk here too? If we -* don't, the only impact is that data=writeback filesystems won't -* flush data to disk automatically on IS_SYNC, only metadata (but -* historically, that is what ext2 has done.) -*/ - -force_commit: - err =ext3_force_commit (inode->i_sb); -if (err) -return err; -return ret; -} -const struct file_operations ext3_file_operations = { .llseek = generic_file_llseek, .read = do_sync_read, .write = do_sync_write, .aio_read = generic_file_aio_read, - .aio_write = ext3_file_write, + .aio_write = generic_file_aio_write, .unlocked_ioctl = ext3_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = ext3_compat_ioctl,
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 10/16 ext4: Remove syncing logic from ext4_file_write
In reply to Jan KaraThe syncing is now properly handled by generic_file_aio_write() so no special ext4 code is needed.
--- fs/ext4/file.c | 53 ++--------------------------------------------------- 1 files changed, 2 insertions(+), 51 deletions(-)
fs/ext4/file.c +2 -51
@@ -58,10 +58,7 @@ static ssize_t ext4_file_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) { - struct file *file = iocb->ki_filp; -struct inode *inode = file->f_path.dentry->d_inode; -ssize_t ret; -int err; + struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;/* * If we have encountered a bitmap-format file, the size limit
@@ -81,53 +78,7 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov, } } - ret =generic_file_aio_write (iocb, iov, nr_segs, pos); -/* -* Skip flushing if there was an error, or if nothing was written. -*/ -if (ret <=0 ) -return ret; - -/* -* If the inode is IS_SYNC, or is O_SYNC and we are doing data -* journalling then we need to make sure that we force the transaction -* to disk to keep all metadata uptodate synchronously. -*/ -if (file->f_flags &O_SYNC ) { -/* -* If we are non-data-journaled, then the dirty data has -* already been flushed to backing store by generic_osync_inode, -* and the inode has been flushed too if there have been any -* modifications other than mere timestamp updates. -* -* Open question --- do we care about flushing timestamps too -* if the inode is IS_SYNC? -*/ -if (!ext4_should_journal_data (inode)) -return ret; - - goto force_commit; - } - -/* -* So we know that there has been no forced data flush. If the inode -* is marked IS_SYNC, we need to force one ourselves. -*/ -if (!IS_SYNC (inode)) -return ret; - -/* -* Open question #2 --- should we force data to disk here too? If we -* don't, the only impact is that data=writeback filesystems won't -* flush data to disk automatically on IS_SYNC, only metadata (but -* historically, that is what ext2 has done.) -*/ - -force_commit: - err =ext4_force_commit (inode->i_sb); -if (err) -return err; -return ret; +return generic_file_aio_write (iocb, iov, nr_segs, pos); }static struct vm_operations_struct ext4_file_vm_ops = {
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 11/16 ntfs: Use new syncing helpers and update comments
In reply to Jan KaraUse new syncing helpers in .write and .aio_write functions. Also remove superfluous syncing in ntfs_file_buffered_write() and update comments about generic_osync_inode().
--- fs/ntfs/file.c | 16 ++++------------ fs/ntfs/mft.c | 13 ++++++------- 2 files changed, 10 insertions(+), 19 deletions(-)
fs/ntfs/file.c +4 -12
@@ -2076,14 +2076,6 @@ err_out: *ppos = pos;if (cached_page)page_cache_release (cached_page); -/* For now, when the user asks for O_SYNC, we actually give O_DSYNC. */ -if (likely (!status)) { -if (unlikely ((file->f_flags &O_SYNC ) ||IS_SYNC (vi))) { -if (!mapping->a_ops->writepage || !is_sync_kiocb (iocb)) - status =generic_osync_inode (vi, mapping, -OSYNC_METADATA |OSYNC_DATA ); - } - }pagevec_lru_add_file (&lru_pvec); ntfs_debug("Done. Returning %s (written 0x%lx, status %li).", written ? "written" : "status", (unsigned long)written,
@@ -2145,8 +2137,8 @@ static ssize_t ntfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,mutex_lock (&inode->i_mutex); ret =ntfs_file_aio_write_nolock (iocb, iov, nr_segs, &iocb->ki_pos);mutex_unlock (&inode->i_mutex); -if (ret >0 && ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -int err =sync_page_range (inode, mapping, pos, ret); +if (ret >0 ) { +int err =generic_write_sync (file, pos, ret);if (err <0 ) ret = err; }
@@ -2173,8 +2165,8 @@ static ssize_t ntfs_file_writev(struct file *file, const struct iovec *iov,if (ret == -EIOCBQUEUED ) ret =wait_on_sync_kiocb (&kiocb);mutex_unlock (&inode->i_mutex); -if (ret >0 && ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -int err =sync_page_range (inode, mapping, *ppos - ret, ret); +if (ret >0 ) { +int err =generic_write_sync (file, *ppos - ret, ret);if (err <0 ) ret = err; }
fs/ntfs/mft.c +6 -7
@@ -384,13 +384,12 @@ unm_err_out:* it is dirty in the inode meta data rather than the data page cache of the * inode, and thus there are no data pages that need writing out. Therefore, a * full mark_inode_dirty() is overkill. A mark_inode_dirty_sync(), on the -* other hand, is not sufficient, because I_DIRTY_DATASYNC needs to be set to -* ensure ->write_inode is called from generic_osync_inode() and this needs to -* happen or the file data would not necessarily hit the device synchronously, -* even though the vfs inode has the O_SYNC flag set. Also, I_DIRTY_DATASYNC -* simply "feels" better than just I_DIRTY_SYNC, since the file data has not -* actually hit the block device yet, which is not what I_DIRTY_SYNC on its own -* would suggest. +* other hand, is not sufficient, because ->write_inode needs to be called even +* in case of fdatasync. This needs to happen or the file data would not +* necessarily hit the device synchronously, even though the vfs inode has the +* O_SYNC flag set. Also, I_DIRTY_DATASYNC simply "feels" better than just +* I_DIRTY_SYNC, since the file data has not actually hit the block device yet, +* which is not what I_DIRTY_SYNC on its own would suggest. */ void __mark_mft_record_dirty (ntfs_inode *ni) {
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 12/16 ocfs2: Update syncing after splicing to match generic version
In reply to Jan KaraUpdate ocfs2 specific splicing code to use generic syncing helper. The sync now does not happen under rw_lock because generic_write_sync() acquires i_mutex which ranks above rw_lock. That should not matter because standard fsync path does not hold it either.
--- fs/ocfs2/file.c | 27 ++++++--------------------- 1 files changed, 6 insertions(+), 21 deletions(-)
fs/ocfs2/file.c +6 -21
@@ -1993,31 +1993,16 @@ static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,if (ret >0 ) {unsigned long nr_pages; +int err; - *ppos += ret; nr_pages = (ret +PAGE_CACHE_SIZE -1 ) >>PAGE_CACHE_SHIFT ; -/* -* If file or inode is SYNC and we actually wrote some data, -* sync it. -*/ -if (unlikely ((out->f_flags &O_SYNC ) ||IS_SYNC (inode))) { -int err; - -mutex_lock (&inode->i_mutex); - err =ocfs2_rw_lock (inode,1 ); -if (err <0 ) { -mlog_errno (err); - }else { - err =generic_osync_inode (inode, mapping, -OSYNC_METADATA |OSYNC_DATA ); -ocfs2_rw_unlock (inode,1 ); - } -mutex_unlock (&inode->i_mutex); + err =generic_write_sync (out, *ppos, ret); +if (err) + ret = err; +else + *ppos += ret; -if (err) - ret = err; - }balance_dirty_pages_ratelimited_nr (mapping, nr_pages); }
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 13/16 xfs: Convert sync_page_range() to simple filemap_write_and_wait_range()
In reply to Jan KaraChristoph Hellwig says that it is enough for XFS to call filemap_write_and_wait_range() instead of sync_page_range() because we do all the metadata syncing when forcing the log.
--- fs/xfs/linux-2.6/xfs_lrw.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)
fs/xfs/linux-2.6/xfs_lrw.c +2 -1
@@ -817,7 +817,8 @@ write_retry:xfs_iunlock (xip, iolock);if (need_i_mutex)mutex_unlock (&inode->i_mutex); - error2 =sync_page_range (inode, mapping, pos, ret); + error2 =filemap_write_and_wait_range (mapping, pos, + pos + ret -1 );if (!error) error = error2;if (need_i_mutex)
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 14/16 pohmelfs: Use new syncing helper
In reply to Jan KaraUse new generic_write_sync() helper instead of sync_page_range().
--- drivers/staging/pohmelfs/inode.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-)
drivers/staging/pohmelfs/inode.c +2 -2
@@ -927,10 +927,10 @@ ssize_t pohmelfs_write(struct file *file, const char __user *buf,mutex_unlock (&inode->i_mutex);WARN_ON (ret <0 ); -if (ret >0 && ((file->f_flags &O_SYNC ) ||IS_SYNC (inode))) { +if (ret >0 ) {ssize_t err; - err =sync_page_range (inode, mapping, pos, ret); + err =generic_write_sync (file, pos, ret);if (err <0 ) ret = err;WARN_ON (ret <0 );
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 15/16 fat: Opencode sync_page_range_nolock()
In reply to Jan Karafat_cont_expand() is the only user of sync_page_range_nolock(). It's also the only user of generic_osync_inode() which does not have a file open. So opencode needed actions for FAT so that we can convert generic_osync_inode() to a standard syncing path.
Update a comment about generic_osync_inode().
--- fs/fat/file.c | 22 ++++++++++++++++++++-- fs/fat/misc.c | 4 ++-- 2 files changed, 22 insertions(+), 4 deletions(-)
fs/fat/file.c +20 -2
@@ -176,8 +176,26 @@ static int fat_cont_expand(struct inode *inode, loff_t size) inode->i_ctime = inode->i_mtime =CURRENT_TIME_SEC ;mark_inode_dirty (inode); -if (IS_SYNC (inode)) - err =sync_page_range_nolock (inode, mapping, start, count); +if (IS_SYNC (inode)) { +int err2; + +/* +* Opencode syncing since we don't have a file open to use +* standard fsync path. +*/ + err =filemap_fdatawrite_range (mapping, start, + start + count -1 ); + err2 =sync_mapping_buffers (mapping); +if (!err) + err = err2; + err2 =write_inode_now (inode,1 ); +if (!err) + err = err2; +if (!err) { + err =filemap_fdatawait_range (mapping, start, + start + count -1 ); + } + } out:return err; }
fs/fat/misc.c +2 -2
@@ -119,8 +119,8 @@ int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster)MSDOS_I (inode)->i_start = new_dclus;MSDOS_I (inode)->i_logstart = new_dclus;/* -* Since generic_osync_inode() synchronize later if -* this is not directory, we don't here. +* Since generic_write_sync() synchronizes regular files later, +* we sync here only directories. */ if (S_ISDIR (inode->i_mode) &&IS_DIRSYNC (inode)) { ret =fat_sync_inode (inode);
Signature · 1 line
1.6.0.2
Jan Kara
maintainerPATCH 16/16 vfs: Remove generic_osync_inode() and sync_page_range{_nolock}()
In reply to Jan KaraRemove these three functions since nobody uses them anymore.
--- fs/fs-writeback.c | 54 -------------------------------------- include/linux/fs.h | 5 --- include/linux/writeback.h | 4 --- mm/filemap.c | 64 --------------------------------------------- 4 files changed, 0 insertions(+), 127 deletions(-)
fs/fs-writeback.c +0 -54
@@ -737,57 +737,3 @@ int sync_inode(struct inode *inode, struct writeback_control *wbc)return ret; }EXPORT_SYMBOL (sync_inode); - -/** -* generic_osync_inode - flush all dirty data for a given inode to disk -* @inode: inode to write -* @mapping: the address_space that should be flushed -* @what: what to write and wait upon -* -* This can be called by file_write functions for files which have the -* O_SYNC flag set, to flush dirty writes to disk. -* -* @what is a bitmask, specifying which part of the inode's data should be -* written and waited upon. -* -* OSYNC_DATA: i_mapping's dirty data -* OSYNC_METADATA: the buffers at i_mapping->private_list -* OSYNC_INODE: the inode itself -*/ - -int generic_osync_inode (struct inode *inode,struct address_space *mapping,int what) -{ -int err =0 ; -int need_write_inode_now =0 ; -int err2; - -if (what &OSYNC_DATA ) - err =filemap_fdatawrite (mapping); -if (what & (OSYNC_METADATA |OSYNC_DATA )) { - err2 =sync_mapping_buffers (mapping); -if (!err) - err = err2; - } -if (what &OSYNC_DATA ) { - err2 =filemap_fdatawait (mapping); -if (!err) - err = err2; - } - -spin_lock (&inode_lock); -if ((inode->i_state &I_DIRTY ) && - ((what &OSYNC_INODE ) || (inode->i_state &I_DIRTY_DATASYNC ))) - need_write_inode_now =1 ; -spin_unlock (&inode_lock); - -if (need_write_inode_now) { - err2 =write_inode_now (inode,1 ); -if (!err) - err = err2; - } -else -inode_sync_wait (inode); - -return err; -} -EXPORT_SYMBOL (generic_osync_inode);
include/linux/fs.h +0 -5
@@ -1458,11 +1458,6 @@ int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);#define DT_SOCK 12#define DT_WHT 14 -#define OSYNC_METADATA (1<<0) -#define OSYNC_DATA (1<<1) -#define OSYNC_INODE (1<<2) -int generic_osync_inode (struct inode *,struct address_space *,int ); -/* * This is the "filldir" function type, used by readdir() to let * the kernel specify what kind of dirent layout it wants to have.
include/linux/writeback.h +0 -4
@@ -157,10 +157,6 @@ int write_cache_pages(struct address_space *mapping, struct writeback_control *wbc, writepage_t writepage, void *data);int do_writepages (struct address_space *mapping,struct writeback_control *wbc); -int sync_page_range (struct inode *inode,struct address_space *mapping, -loff_t pos,loff_t count); -int sync_page_range_nolock (struct inode *inode,struct address_space *mapping, -loff_t pos,loff_t count);void set_page_dirty_balance (struct page *page,int page_mkwrite);void writeback_set_ratelimit (void );
mm/filemap.c +0 -64
70 lines not on this page · raw message
Signature · 1 line
1.6.0.2
Quoted 5 lines · Jan Kara
Hi,
here is a new version of my
O_SYNCcleanup patches. There are two minor
changes since last time. XFS now usesfilemap_write_and_wait()as Christoph asked
The XFS tree now does this already, Idid it as part of the XFS-internal fsync/O_SYNC consolidation. I'll look into fixing the data writeout stuff ontop of you series, and after that XFS can use the generic helper, too.
Quoted 1 line
If noone objects, I think the patch series is ready to be put in linux-next.
I'll look through it, but in general the sooner we have this in -next, the better.
PATCH 1/1 fsync: wait for data writeout completion before calling ->fsync
In reply to Jan KaraI think we should add this one ontop:
Signature · 160 lines
Subject: [PATCH] fsync: wait for data writeout completion before calling ->fsync From: Christoph Hellwig <[email protected]> Currenly vfs_fsync(_range) first calls filemap_fdatawrite to write out the data, the calls into ->fsync to write out the metadata and then finally calls filemap_fdatawait to wait for the data I/O to complete. What sounds like a clever micro-optimization actually is nast trap for many filesystems. For many modern filesystems i_size or other inode information is only updated on I/O completion and we need to wait for I/O to finish before we can write out the metadata. For old fashionen filesystems that instanciate blocks during the actual write and also update the metadata at that point it opens up a large window were we could expose uninitialized blocks after a crash. While a few filesystems that need it already wait for the I/O to finish inside their ->fsync methods it is rather suboptimal as it is done under the i_mutex and also always for the whole file instead of just a part as we could do for O_SYNC handling. Here is a small audit of all fsync instances in the tree: - spufs_mfc_fsync: - ps3flash_fsync: - vol_cdev_fsync: - printer_fsync: - fb_deferred_io_fsync: - bad_file_fsync: - simple_sync_file: don't care - filesystems/drivers do't use the page cache or are purely in-memory. - simple_fsync: - file_fsync: - affs_file_fsync: - fat_file_fsync: - jfs_fsync: - ubifs_fsync: - reiserfs_dir_fsync: - reiserfs_sync_file: never touch pagecache themselves. We need to wait before if we do not want to expose stale data after an allocation. - afs_fsync: - fuse_fsync_common: do the waiting writeback itself in awkward ways, would benefit from proper semantics - block_fsync: Does a filemap_write_and_wait on the block device inode. Because we now have f_mapping that is the same inode we call it on in vfs_fsync. So just removing it and letting the VFS do the work in one go would be an improvement. - btrfs_sync_file: - cifs_fsync: - xfs_file_fsync: need the wait first and currently do it themselves. would benefit from doing it outside i_mutex. - coda_fsync: - ecryptfs_fsync: - exofs_file_fsync: - shm_fsync: only passes the fsync through to the lower layer - ext3_sync_file: doesn't seem to care, comments are confusing. - ext4_sync_file: would need the wait to work correctly for delalloc mode with late i_size updates. Otherwise the ext3 comment applies. currently implemens it's own writeback and wait in an odd way, could benefit from doing it properly. - gfs2_fsync: not needed for journaled data mode, but probably harmless there. Currently writes back data asynchronously itself. Needs some major audit. - hostfs_fsync: just calls fsync/datasync on the host FD. Without the wait before data might not even be inflight yet if we're unlucky. - hpfs_file_fsync: - ncp_fsync: no-ops. Dangerous before and after. - jffs2_fsync: just calls jffs2_flush_wbuf_gc, not sure how this relates to data. - nfs_fsync_dir: just increments stats, claims all directory operations are synchronous - nfs_file_fsync: only writes out data??? Looks very odd. - nilfs_sync_file: looks like it expects all data done, but not sure from the code - ntfs_dir_fsync: - ntfs_file_fsync: appear to do their own data writeback. Very convoluted code. - ocfs2_sync_file: does it's own data writeback, but no wait. probably needs the wait. - smb_fsync: according to a comment expects all pages written already, probably needs the wait before. This patch only changes vfs_fsync_range, removal of the wait in the methods that have it is left to the filesystem maintainers. Note that most filesystems really do need an audit for their fsync methods given the gems found in this very brief audit. Signed-off-by: Christoph Hellwig <[email protected]> Index: linux-2.6/fs/sync.c =================================================================== --- linux-2.6.orig/fs/sync.c 2009-09-02 15:03:41.073271287 -0300 +++ linux-2.6/fs/sync.c 2009-09-02 15:04:34.401269249 -0300 @@ -216,7 +216,7 @@ int vfs_fsync_range(struct file *file, s goto out; } - ret = filemap_fdatawrite_range(mapping, start, end); + ret = filemap_write_and_wait_range(mapping, start, end); /* * We need to protect against concurrent writers, which could cause @@ -228,9 +228,6 @@ int vfs_fsync_range(struct file *file, s ret = err; mutex_unlock(&mapping->host->i_mutex); - err = filemap_fdatawait_range(mapping, start, end); - if (!ret) - ret = err; out: return ret; }
Re: [PATCH] fsync: wait for data writeout completion before calling ->fsync
Quoted 3 lines · Christoph Hellwig
-
ocfs2_sync_file:does it's own data writeback, but no wait. probably needs the wait.
The journal force commit will wait in ordered mode. In
writeback mode we currently allow the usual writeback problem.
Joel
Signature · 9 lines
"There are some experiences in life which should not be demanded
twice from any man, and one of them is listening to the Brahms Requiem."
- George Bernard Shaw
Joel Becker
Principal Software Developer
Oracle
E-mail: [email protected]
Phone: (650) 506-8127Jan Kara
maintainerRe: [PATCH] fsync: wait for data writeout completion before calling ->fsync
In reply to Christoph HellwigQuoted 1 line · Christoph Hellwig
I think we should add this one ontop:
Agreed. Added to the series. I'll now push the whole series to linux-next
via my fs tree.
Honza
Quoted 162 lines
Signature · 140 lines
-- Subject: [PATCH] fsync: wait for data writeout completion before calling ->fsync From: Christoph Hellwig <[email protected]> Currenly vfs_fsync(_range) first calls filemap_fdatawrite to write out the data, the calls into ->fsync to write out the metadata and then finally calls filemap_fdatawait to wait for the data I/O to complete. What sounds like a clever micro-optimization actually is nast trap for many filesystems. For many modern filesystems i_size or other inode information is only updated on I/O completion and we need to wait for I/O to finish before we can write out the metadata. For old fashionen filesystems that instanciate blocks during the actual write and also update the metadata at that point it opens up a large window were we could expose uninitialized blocks after a crash. While a few filesystems that need it already wait for the I/O to finish inside their ->fsync methods it is rather suboptimal as it is done under the i_mutex and also always for the whole file instead of just a part as we could do for O_SYNC handling. Here is a small audit of all fsync instances in the tree: - spufs_mfc_fsync: - ps3flash_fsync: - vol_cdev_fsync: - printer_fsync: - fb_deferred_io_fsync: - bad_file_fsync: - simple_sync_file: don't care - filesystems/drivers do't use the page cache or are purely in-memory. - simple_fsync: - file_fsync: - affs_file_fsync: - fat_file_fsync: - jfs_fsync: - ubifs_fsync: - reiserfs_dir_fsync: - reiserfs_sync_file: never touch pagecache themselves. We need to wait before if we do not want to expose stale data after an allocation. - afs_fsync: - fuse_fsync_common: do the waiting writeback itself in awkward ways, would benefit from proper semantics - block_fsync: Does a filemap_write_and_wait on the block device inode. Because we now have f_mapping that is the same inode we call it on in vfs_fsync. So just removing it and letting the VFS do the work in one go would be an improvement. - btrfs_sync_file: - cifs_fsync: - xfs_file_fsync: need the wait first and currently do it themselves. would benefit from doing it outside i_mutex. - coda_fsync: - ecryptfs_fsync: - exofs_file_fsync: - shm_fsync: only passes the fsync through to the lower layer - ext3_sync_file: doesn't seem to care, comments are confusing. - ext4_sync_file: would need the wait to work correctly for delalloc mode with late i_size updates. Otherwise the ext3 comment applies. currently implemens it's own writeback and wait in an odd way, could benefit from doing it properly. - gfs2_fsync: not needed for journaled data mode, but probably harmless there. Currently writes back data asynchronously itself. Needs some major audit. - hostfs_fsync: just calls fsync/datasync on the host FD. Without the wait before data might not even be inflight yet if we're unlucky. - hpfs_file_fsync: - ncp_fsync: no-ops. Dangerous before and after. - jffs2_fsync: just calls jffs2_flush_wbuf_gc, not sure how this relates to data. - nfs_fsync_dir: just increments stats, claims all directory operations are synchronous - nfs_file_fsync: only writes out data??? Looks very odd. - nilfs_sync_file: looks like it expects all data done, but not sure from the code - ntfs_dir_fsync: - ntfs_file_fsync: appear to do their own data writeback. Very convoluted code. - ocfs2_sync_file: does it's own data writeback, but no wait. probably needs the wait. - smb_fsync: according to a comment expects all pages written already, probably needs the wait before. This patch only changes vfs_fsync_range, removal of the wait in the methods that have it is left to the filesystem maintainers. Note that most filesystems really do need an audit for their fsync methods given the gems found in this very brief audit. Signed-off-by: Christoph Hellwig <[email protected]> Index: linux-2.6/fs/sync.c ===================================================================fs/sync.c +1
-4@@ -216,7 +216,7 @@ int vfs_fsync_range(struct file *file, s goto out; } - ret =filemap_fdatawrite_range (mapping, start, end); + ret =filemap_write_and_wait_range (mapping, start, end);/* * We need to protect against concurrent writers, which could cause @@ -228,9 +228,6 @@ int vfs_fsync_range(struct file *file, s ret = err;mutex_unlock (&mapping->host->i_mutex); - err =filemap_fdatawait_range (mapping, start, end); -if (!ret) - ret = err; out:return ret; }
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH] fsync: wait for data writeout completion before calling ->fsync
Quoted 4 lines · Jan Kara
Quoted 1 line · Christoph Hellwig
I think we should add this one ontop:
Agreed. Added to the series. I'll now push the whole series to linux-next
via my fs tree.
Thanks. We do also need something similar in writeback_single_inode, but I'm not sure how to do that in a good way, and how fixing this now would interact with Jens' writeback changes. Probably makes sense to postpone it until 2.6.32 at least and possibly try to split data and metadata writeback fully.
[PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
In reply to Jan KaraWhile Linux provided an O_SYNC flag basically since day 1, it took until Linux 2.4.0-test12pre2 to actually get it implemented for filesystems, since that day we had generic_osync_around with only minor changes and the great "For now, when the user asks for O_SYNC, we'll actually give O_DSYNC" comment. This patch intends to actually give us real O_SYNC semantics in addition to the O_DSYNC semantics. After Jan's O_SYNC patches which are required before this patch it's actually surprisingly simple, we just need to figure out when to set the datasync flag to vfs_fsync_range and when not.
This patch renames the existing O_SYNC flag to O_DSYNC while keeping it's numerical value to keep binary compatibility, and adds a new real O_SYNC flag. To guarantee backwards compatiblity it is defined as expanding to both the O_DSYNC and the new additional binary flag (__O_SYNC) to make sure we are backwards-compatible when compiled against the new headers.
This also means that all places that don't care about the differences can just check O_DSYNC and get the right behaviour for O_SYNC, too - only places that actuall care need to check __O_SYNC in addition. Drivers and network filesystems have been updated in a fail safe way to always do the full sync magic if O_DSYNC is set. The few places setting O_SYNC for lower layers are kept that way for now to stay failsafe.
Note that Parisc really fucked up their headers as they already define a O_DSYNC that has always been a no-op. We try to repair it by using it for the new O_DSYNC and redefinining O_SYNC to send both the traditional O_SYNC numerical value _and_ the O_DSYNC one.
arch/x86/mm/pat.c +1 -1
@@ -541,7 +541,7 @@ int phys_mem_access_prot_allowed(structif (!range_is_allowed (pfn, size))return 0 ; -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) { flags = _PAGE_CACHE_UC_MINUS; }
drivers/char/mem.c +3 -3
@@ -44,7 +44,7 @@ static inline int uncached_access(struct {#if defined(CONFIG_IA64 )/* -* On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases. +* On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases. */ return !(efi_mem_attributes (addr) &EFI_MEMORY_WB );#elif defined(CONFIG_MIPS )
@@ -57,9 +57,9 @@ static inline int uncached_access(struct#else /* * Accessing memory above the top the kernel knows about or through a file pointer -* that was marked O_SYNC will be done non-cached. +* that was marked O_DSYNC will be done non-cached. */ -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);#endif
drivers/staging/me4000/me4000.c +2 -2
@@ -1985,8 +1985,8 @@ static ssize_t me4000_ao_write_cont(struspin_unlock_irqrestore (&ao_context->int_lock, flags); } -/* Wait until the state machine is stopped if O_SYNC is set */ -if (filep->f_flags &O_SYNC ) { +/* Wait until the state machine is stopped if O_DSYNC is set */ +if (filep->f_flags &O_DSYNC ) {while (inl (ao_context->status_reg) &ME4000_AO_STATUS_BIT_FSM ) {interruptible_sleep_on_timeout (&queue,1 );
drivers/usb/gadget/file_storage.c +1 -1
@@ -1713,7 +1713,7 @@ static int do_write(struct fsg_dev *fsg) }if (fsg->cmnd[1 ] &0x08 ) {// FUA spin_lock (&curlun->filp->f_lock); - curlun->filp->f_flags |=O_SYNC ; + curlun->filp->f_flags |=O_DSYNC ;spin_unlock (&curlun->filp->f_lock); } }
fs/afs/write.c +3 -2
@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags &O_SYNC ) ?0 :1 );if (ret <0 ) result = ret; }
fs/btrfs/file.c +2 -2
@@ -924,7 +924,7 @@ static ssize_t btrfs_file_write(struct funsigned long last_index;int will_write; - will_write = ((file->f_flags &O_SYNC ) ||IS_SYNC (inode) || + will_write = ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode) || (file->f_flags &O_DIRECT )); nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
@@ -1077,7 +1077,7 @@ out_nolock:if (err) num_written = err; -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) { trans =btrfs_start_transaction (root,1 ); ret =btrfs_log_dentry_safe (trans, root, file->f_dentry);
fs/cifs/dir.c +2 -1
@@ -214,7 +214,8 @@ int cifs_posix_open(char *full_path, str posix_flags |=SMB_O_TRUNC ;if (oflags &O_APPEND ) posix_flags |=SMB_O_APPEND ; -if (oflags &O_SYNC ) +/* be safe and imply O_SYNC for O_DSYNC */ +if (oflags &O_DSYNC ) posix_flags |=SMB_O_SYNC ;if (oflags &O_DIRECTORY ) posix_flags |=SMB_O_DIRECTORY ;
fs/cifs/file.c +4 -2
@@ -98,8 +98,10 @@ static inline fmode_t cifs_posix_convertreopening a file. They had their effect on the original open */ if (flags &O_APPEND ) posix_flags |= (fmode_t )O_APPEND ; -if (flags &O_SYNC ) - posix_flags |= (fmode_t )O_SYNC ; +if (flags &O_DSYNC ) + posix_flags |= (fmode_t )O_DSYNC ; +if (flags & __O_SYNC) + posix_flags |= (fmode_t )__O_SYNC;if (flags &O_DIRECTORY ) posix_flags |= (fmode_t )O_DIRECTORY ;if (flags &O_NOFOLLOW )
fs/namei.c +3 -0
@@ -1676,6 +1676,9 @@ struct file *do_filp_open(int dfd, constint will_write;int flag =open_to_namei_flags (open_flag); +if ((open_flag & __O_SYNC) && !(open_flag &O_DSYNC )) +return ERR_PTR (-EINVAL ); +if (!acc_mode) acc_mode =MAY_OPEN |ACC_MODE (flag);
fs/nfs/file.c +2 -2
@@ -535,7 +535,7 @@ static int nfs_need_sync_write(struct fi {struct nfs_open_context *ctx; -if (IS_SYNC (inode) || (filp->f_flags &O_SYNC )) +if (IS_SYNC (inode) || (filp->f_flags &O_DSYNC ))return 1 ; ctx =nfs_file_open_context (filp);if (test_bit (NFS_CONTEXT_ERROR_WRITE , &ctx->flags))
@@ -576,7 +576,7 @@ static ssize_t nfs_file_write(struct kionfs_add_stats (inode,NFSIOS_NORMALWRITTENBYTES , count); result =generic_file_aio_write (iocb, iov, nr_segs, pos); -/* Return error values for O_SYNC and IS_SYNC() */ +/* Return error values for O_DSYNC and IS_SYNC() */ if (result >=0 &&nfs_need_sync_write (iocb->ki_filp, inode)) {int err =nfs_do_fsync (nfs_file_open_context (iocb->ki_filp), inode);if (err <0 )
fs/nfs/write.c +1 -1
@@ -762,7 +762,7 @@ int nfs_updatepage(struct file *file, st*/ if (nfs_write_pageuptodate (page, inode) && inode->i_flock ==NULL && - !(file->f_flags &O_SYNC )) { + !(file->f_flags &O_DSYNC )) { count =max (count + offset,nfs_page_length (page)); offset =0 ; }
include/asm-generic/fcntl.h +21 -4
@@ -3,8 +3,6 @@#include <linux/types.h> -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_ACCMODE 00000003#define O_RDONLY 00000000#define O_WRONLY 00000001
@@ -27,8 +25,8 @@#ifndef O_NONBLOCK #define O_NONBLOCK 00004000#endif -#ifndef O_SYNC -#define O_SYNC 00010000 +#ifndef O_DSYNC +#define O_DSYNC 00010000/* used to be O_SYNC, see below */ #endif #ifndef FASYNC #define FASYNC 00020000/* fcntl, for BSD compatibility */
@@ -51,6 +49,25 @@#ifndef O_CLOEXEC #define O_CLOEXEC 02000000/* set close_on_exec */ #endif + +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#ifndef O_SYNC +#define __O_SYNC 04000000 +#define O_SYNC (__O_SYNC|O_DSYNC) +#endif +#ifndef O_NDELAY #define O_NDELAY O_NONBLOCK#endif
fs/ocfs2/file.c +1 -1
@@ -1878,7 +1878,7 @@ out_dio:/* buffered aio wouldn't have proper lock coverage today */ BUG_ON (ret == -EIOCBQUEUED && !(file->f_flags &O_DIRECT )); -if ((file->f_flags &O_SYNC && !direct_io) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC && !direct_io) ||IS_SYNC (inode)) { ret =filemap_fdatawrite_range (file->f_mapping, pos, pos + count -1 );if (ret <0 )
fs/ubifs/file.c +1 -1
@@ -1403,7 +1403,7 @@ static ssize_t ubifs_aio_write(struct kiif (ret <0 )return ret; -if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_SYNC )) { +if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_DSYNC )) { err =ubifs_sync_wbufs_by_inode (c, inode);if (err)return err;
fs/xfs/linux-2.6/xfs_lrw.c +1 -1
@@ -811,7 +811,7 @@ write_retry:XFS_STATS_ADD (xs_write_bytes, ret);/* Handle various SYNC-type writes */ -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) {int error2;xfs_iunlock (xip, iolock);
sound/core/rawmidi.c +1 -1
@@ -1258,7 +1258,7 @@ static ssize_t snd_rawmidi_write(structbreak ; count -= count1; } -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) {spin_lock_irq (&runtime->lock);while (runtime->avail != runtime->buffer_size) {wait_queue_t wait;
arch/alpha/include/asm/fcntl.h +16 -3
@@ -1,8 +1,6 @@#ifndef _ALPHA_FCNTL_H#define _ALPHA_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_CREAT 01000/* not fcntl */ #define O_TRUNC 02000/* not fcntl */ #define O_EXCL 04000/* not fcntl */
@@ -10,13 +8,28 @@#define O_NONBLOCK 00004#define O_APPEND 00010 -#define O_SYNC 040000 +#define O_DSYNC 040000/* used to be O_SYNC, see below */ #define O_DIRECTORY 0100000/* must be a directory */ #define O_NOFOLLOW 0200000/* don't follow links */ #define O_LARGEFILE 0400000/* will be set by the kernel on every open */ #define O_DIRECT 02000000/* direct disk access - should check with OSF/1 */ #define O_NOATIME 04000000#define O_CLOEXEC 010000000/* set close_on_exec */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 010000000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETLK 7#define F_SETLK 8
arch/blackfin/include/asm/fcntl.h +0 -2
@@ -1,8 +1,6 @@#ifndef _BFIN_FCNTL_H#define _BFIN_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_DIRECTORY 040000/* must be a directory */ #define O_NOFOLLOW 0100000/* don't follow links */ #define O_DIRECT 0200000/* direct disk access hint - currently ignored */
arch/mips/include/asm/fcntl.h +1 -1
@@ -10,7 +10,7 @@#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 000010/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x0080#define O_CREAT 0x0100/* not fcntl */ #define O_TRUNC 0x0200/* not fcntl */
arch/mips/kernel/kspd.c +1 -0
@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040 +/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080
arch/mips/lemote/lm2e/mem.c +1 -1
@@ -11,7 +11,7 @@/* override of arch/mips/mm/cache.c: __uncached_access */ int __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;/*
arch/mips/mm/cache.c +1 -1
@@ -194,7 +194,7 @@ void __devinit cpu_cache_init(void)int __weak __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);
arch/parisc/include/asm/fcntl.h +2 -3
@@ -1,14 +1,13 @@#ifndef _PARISC_FCNTL_H#define _PARISC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 000000010#define O_BLKSEEK 000000100/* HPUX only */ #define O_CREAT 000000400/* not fcntl */ #define O_EXCL 000002000/* not fcntl */ #define O_LARGEFILE 000004000 -#define O_SYNC 000100000 +#define __O_SYNC 000100000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_NONBLOCK 000200004/* HPUX has separate NDELAY & NONBLOCK */ #define O_NOCTTY 000400000/* not fcntl */ #define O_DSYNC 001000000/* HPUX only */
arch/sparc/include/asm/fcntl.h +16 -3
@@ -1,14 +1,12 @@#ifndef _SPARC_FCNTL_H#define _SPARC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 0x0008#define FASYNC 0x0040/* fcntl, for BSD compatibility */ #define O_CREAT 0x0200/* not fcntl */ #define O_TRUNC 0x0400/* not fcntl */ #define O_EXCL 0x0800/* not fcntl */ -#define O_SYNC 0x2000 +#define O_DSYNC 0x2000/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x4000#if defined(__sparc__) && defined(__arch64__)#define O_NDELAY 0x0004
@@ -20,6 +18,21 @@#define O_DIRECT 0x100000/* direct disk access hint */ #define O_NOATIME 0x200000#define O_CLOEXEC 0x400000 +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x800000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETOWN 5/* for sockets. */ #define F_SETOWN 6/* for sockets. */
fs/sync.c +3 -2
@@ -285,10 +285,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) { -if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags &O_SYNC ) ?1 :0 ); }EXPORT_SYMBOL (generic_write_sync);
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 8 lines · Christoph Hellwig
Index:
linux-2.6/fs/sync.c
===================================================================fs/sync.c +0
-0@@ -285,10 +285,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) {
fs/sync.c SYSCALL_DEFINE1(fdatasync, unsigned int, · line 295
Quoted 10 lines
fs/sync.c +3
-2-if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags &O_SYNC ) ?1 :0 ); }EXPORT_SYMBOL (generic_write_sync);
Shouldn't this be testing for
file->f_flags & __O_SYNC
?
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 9 lines · Trond Myklebust
fs/sync.c SYSCALL_DEFINE1(fdatasync, unsigned int, · line 294
Quoted 7 lines
fs/sync.c +2
-1return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags &O_SYNC ) ?1 :0 ); }EXPORT_SYMBOL (generic_write_sync);Shouldn't this be testing for
Quoted 3 lines
file->f_flags & __O_SYNC?
Doesn't matter, we check early in the open path that __O_SYNC is only set together with O_SYNC.
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 10 lines · Christoph Hellwig
Quoted 9 lines · Trond Myklebust
fs/sync.c SYSCALL_DEFINE1(fdatasync, unsigned int, · line 294
Quoted 7 lines
fs/sync.c +2
-1return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags &O_SYNC ) ?1 :0 ); }EXPORT_SYMBOL (generic_write_sync);Shouldn't this be testing for
Quoted 6 lines
Quoted 3 lines
file->f_flags & __O_SYNC?
Doesn't matter, we check early in the open path that
__O_SYNCis only set together withO_SYNC.
Right, but (file->f_flags & O_SYNC) will be non-zero even if only the O_DSYNC flag is set.
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 6 lines · Trond Myklebust
Quoted 3 lines
Doesn't matter, we check early in the open path that
__O_SYNCis only set together withO_SYNC.Right, but (
file->f_flags&O_SYNC) will be non-zero even if only theO_DSYNCflag is set.
Thanks, corrected.
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
In reply to Christoph Hellwiginclude/asm-generic/fcntl.h line 64
Quoted 12 lines · Christoph Hellwig
include/asm-generic/fcntl.h +12
-0+/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly.
Doesn't it make sense that applications that actually know what they are doing may want to start using __O_SYNC directly at some point in the future? It makes sense to code the kernel to handle both of these flags appropriately (i.e. if __O_SYNC is set, but O_DSYNC is not then treat this as the proper "O_SYNC").
arch/alpha/include/asm/fcntl.h line 31
Quoted 6 lines
Index:
linux-2.6/arch/alpha/include/asm/fcntl.h
===================================================================arch/alpha/include/asm/fcntl.h +1
-0#define O_CLOEXEC 010000000/* set close_on_exec */ +#define __O_SYNC 010000000
These two flags have the same value...
Cheers, Andreas
--
Andreas Dilger
Sr. Staff Engineer, Lustre Group
Sun Microsystems of Canada, Inc.
Re: [PATCH 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 7 lines · Andreas Dilger
Quoted 1 line
+ * Note:
__O_SYNCmust never be used directly.Doesn't it make sense that applications that actually know what they are doing may want to start using
__O_SYNCdirectly at some point in the future? It makes sense to code the kernel to handle both of these flags appropriately (i.e. if__O_SYNCis set, butO_DSYNCis not then treat this as the proper "O_SYNC").
What would be the benefit of that? Setting two bits vs one in a data structure is not going to make any difference, and the way it's done in this patch is actually much easier to implement in the kernel.
Quoted 8 lines
arch/alpha/include/asm/fcntl.h line 31
Quoted 6 lines
Index:
linux-2.6/arch/alpha/include/asm/fcntl.h
===================================================================arch/alpha/include/asm/fcntl.h +1
-0#define O_CLOEXEC 010000000/* set close_on_exec */ +#define __O_SYNC 010000000These two flags have the same value...
Thanks, corrected.
[PATCHv2 18/16] implement posix O_SYNC and O_DSYNC semantics
In reply to Christoph HellwigWhile Linux provided an O_SYNC flag basically since day 1, it took until Linux 2.4.0-test12pre2 to actually get it implemented for filesystems, since that day we had generic_osync_around with only minor changes and the great "For now, when the user asks for O_SYNC, we'll actually give O_DSYNC" comment. This patch intends to actually give us real O_SYNC semantics in addition to the O_DSYNC semantics. After Jan's O_SYNC patches which are required before this patch it's actually surprisingly simple, we just need to figure out when to set the datasync flag to vfs_fsync_range and when not.
This patch renames the existing O_SYNC flag to O_DSYNC while keeping it's numerical value to keep binary compatibility, and adds a new real O_SYNC flag. To guarantee backwards compatiblity it is defined as expanding to both the O_DSYNC and the new additional binary flag (__O_SYNC) to make sure we are backwards-compatible when compiled against the new headers.
This also means that all places that don't care about the differences can just check O_DSYNC and get the right behaviour for O_SYNC, too - only places that actuall care need to check __O_SYNC in addition. Drivers and network filesystems have been updated in a fail safe way to always do the full sync magic if O_DSYNC is set. The few places setting O_SYNC for lower layers are kept that way for now to stay failsafe.
Note that parisc really fucked up their headers as they already define a O_DSYNC that has always been a no-op. We try to repair it by using it for the new O_DSYNC and redefinining O_SYNC to send both the traditional O_SYNC numerical value _and_ the O_DSYNC one.
arch/x86/mm/pat.c +1 -1
@@ -541,7 +541,7 @@ int phys_mem_access_prot_allowed(structif (!range_is_allowed (pfn, size))return 0 ; -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) { flags = _PAGE_CACHE_UC_MINUS; }
drivers/char/mem.c +3 -3
@@ -44,7 +44,7 @@ static inline int uncached_access(struct {#if defined(CONFIG_IA64 )/* -* On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases. +* On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases. */ return !(efi_mem_attributes (addr) &EFI_MEMORY_WB );#elif defined(CONFIG_MIPS )
@@ -57,9 +57,9 @@ static inline int uncached_access(struct#else /* * Accessing memory above the top the kernel knows about or through a file pointer -* that was marked O_SYNC will be done non-cached. +* that was marked O_DSYNC will be done non-cached. */ -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);#endif
drivers/staging/me4000/me4000.c +2 -2
@@ -1985,8 +1985,8 @@ static ssize_t me4000_ao_write_cont(struspin_unlock_irqrestore (&ao_context->int_lock, flags); } -/* Wait until the state machine is stopped if O_SYNC is set */ -if (filep->f_flags &O_SYNC ) { +/* Wait until the state machine is stopped if O_DSYNC is set */ +if (filep->f_flags &O_DSYNC ) {while (inl (ao_context->status_reg) &ME4000_AO_STATUS_BIT_FSM ) {interruptible_sleep_on_timeout (&queue,1 );
drivers/usb/gadget/file_storage.c +1 -1
@@ -1713,7 +1713,7 @@ static int do_write(struct fsg_dev *fsg) }if (fsg->cmnd[1 ] &0x08 ) {// FUA spin_lock (&curlun->filp->f_lock); - curlun->filp->f_flags |=O_SYNC ; + curlun->filp->f_flags |=O_DSYNC ;spin_unlock (&curlun->filp->f_lock); } }
fs/afs/write.c +3 -2
@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags & __O_SYNC) ?0 :1 );if (ret <0 ) result = ret; }
fs/btrfs/file.c +2 -2
@@ -924,7 +924,7 @@ static ssize_t btrfs_file_write(struct funsigned long last_index;int will_write; - will_write = ((file->f_flags &O_SYNC ) ||IS_SYNC (inode) || + will_write = ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode) || (file->f_flags &O_DIRECT )); nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
@@ -1077,7 +1077,7 @@ out_nolock:if (err) num_written = err; -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) { trans =btrfs_start_transaction (root,1 ); ret =btrfs_log_dentry_safe (trans, root, file->f_dentry);
fs/cifs/dir.c +2 -1
@@ -214,7 +214,8 @@ int cifs_posix_open(char *full_path, str posix_flags |=SMB_O_TRUNC ;if (oflags &O_APPEND ) posix_flags |=SMB_O_APPEND ; -if (oflags &O_SYNC ) +/* be safe and imply O_SYNC for O_DSYNC */ +if (oflags &O_DSYNC ) posix_flags |=SMB_O_SYNC ;if (oflags &O_DIRECTORY ) posix_flags |=SMB_O_DIRECTORY ;
fs/cifs/file.c +4 -2
@@ -98,8 +98,10 @@ static inline fmode_t cifs_posix_convertreopening a file. They had their effect on the original open */ if (flags &O_APPEND ) posix_flags |= (fmode_t )O_APPEND ; -if (flags &O_SYNC ) - posix_flags |= (fmode_t )O_SYNC ; +if (flags &O_DSYNC ) + posix_flags |= (fmode_t )O_DSYNC ; +if (flags & __O_SYNC) + posix_flags |= (fmode_t )__O_SYNC;if (flags &O_DIRECTORY ) posix_flags |= (fmode_t )O_DIRECTORY ;if (flags &O_NOFOLLOW )
fs/namei.c +3 -0
@@ -1678,6 +1678,9 @@ struct file *do_filp_open(int dfd, constint will_write;int flag =open_to_namei_flags (open_flag); +if ((open_flag & __O_SYNC) && !(open_flag &O_DSYNC )) +return ERR_PTR (-EINVAL ); +if (!acc_mode) acc_mode =MAY_OPEN |ACC_MODE (flag);
fs/nfs/file.c +2 -2
@@ -535,7 +535,7 @@ static int nfs_need_sync_write(struct fi {struct nfs_open_context *ctx; -if (IS_SYNC (inode) || (filp->f_flags &O_SYNC )) +if (IS_SYNC (inode) || (filp->f_flags &O_DSYNC ))return 1 ; ctx =nfs_file_open_context (filp);if (test_bit (NFS_CONTEXT_ERROR_WRITE , &ctx->flags))
@@ -576,7 +576,7 @@ static ssize_t nfs_file_write(struct kionfs_add_stats (inode,NFSIOS_NORMALWRITTENBYTES , count); result =generic_file_aio_write (iocb, iov, nr_segs, pos); -/* Return error values for O_SYNC and IS_SYNC() */ +/* Return error values for O_DSYNC and IS_SYNC() */ if (result >=0 &&nfs_need_sync_write (iocb->ki_filp, inode)) {int err =nfs_do_fsync (nfs_file_open_context (iocb->ki_filp), inode);if (err <0 )
fs/nfs/write.c +1 -1
@@ -762,7 +762,7 @@ int nfs_updatepage(struct file *file, st*/ if (nfs_write_pageuptodate (page, inode) && inode->i_flock ==NULL && - !(file->f_flags &O_SYNC )) { + !(file->f_flags &O_DSYNC )) { count =max (count + offset,nfs_page_length (page)); offset =0 ; }
include/asm-generic/fcntl.h +21 -4
@@ -3,8 +3,6 @@#include <linux/types.h> -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_ACCMODE 00000003#define O_RDONLY 00000000#define O_WRONLY 00000001
@@ -27,8 +25,8 @@#ifndef O_NONBLOCK #define O_NONBLOCK 00004000#endif -#ifndef O_SYNC -#define O_SYNC 00010000 +#ifndef O_DSYNC +#define O_DSYNC 00010000/* used to be O_SYNC, see below */ #endif #ifndef FASYNC #define FASYNC 00020000/* fcntl, for BSD compatibility */
@@ -51,6 +49,25 @@#ifndef O_CLOEXEC #define O_CLOEXEC 02000000/* set close_on_exec */ #endif + +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#ifndef O_SYNC +#define __O_SYNC 04000000 +#define O_SYNC (__O_SYNC|O_DSYNC) +#endif +#ifndef O_NDELAY #define O_NDELAY O_NONBLOCK#endif
fs/ocfs2/file.c +1 -1
@@ -1878,7 +1878,7 @@ out_dio:/* buffered aio wouldn't have proper lock coverage today */ BUG_ON (ret == -EIOCBQUEUED && !(file->f_flags &O_DIRECT )); -if ((file->f_flags &O_SYNC && !direct_io) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC && !direct_io) ||IS_SYNC (inode)) { ret =filemap_fdatawrite_range (file->f_mapping, pos, pos + count -1 );if (ret <0 )
fs/ubifs/file.c +1 -1
@@ -1403,7 +1403,7 @@ static ssize_t ubifs_aio_write(struct kiif (ret <0 )return ret; -if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_SYNC )) { +if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_DSYNC )) { err =ubifs_sync_wbufs_by_inode (c, inode);if (err)return err;
fs/xfs/linux-2.6/xfs_lrw.c +1 -1
@@ -811,7 +811,7 @@ write_retry:XFS_STATS_ADD (xs_write_bytes, ret);/* Handle various SYNC-type writes */ -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) {int error2;xfs_iunlock (xip, iolock);
sound/core/rawmidi.c +1 -1
@@ -1258,7 +1258,7 @@ static ssize_t snd_rawmidi_write(structbreak ; count -= count1; } -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) {spin_lock_irq (&runtime->lock);while (runtime->avail != runtime->buffer_size) {wait_queue_t wait;
arch/alpha/include/asm/fcntl.h +16 -3
@@ -1,8 +1,6 @@#ifndef _ALPHA_FCNTL_H#define _ALPHA_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_CREAT 01000/* not fcntl */ #define O_TRUNC 02000/* not fcntl */ #define O_EXCL 04000/* not fcntl */
@@ -10,13 +8,28 @@#define O_NONBLOCK 00004#define O_APPEND 00010 -#define O_SYNC 040000 +#define O_DSYNC 040000/* used to be O_SYNC, see below */ #define O_DIRECTORY 0100000/* must be a directory */ #define O_NOFOLLOW 0200000/* don't follow links */ #define O_LARGEFILE 0400000/* will be set by the kernel on every open */ #define O_DIRECT 02000000/* direct disk access - should check with OSF/1 */ #define O_NOATIME 04000000#define O_CLOEXEC 010000000/* set close_on_exec */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 020000000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETLK 7#define F_SETLK 8
arch/blackfin/include/asm/fcntl.h +0 -2
@@ -1,8 +1,6 @@#ifndef _BFIN_FCNTL_H#define _BFIN_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_DIRECTORY 040000/* must be a directory */ #define O_NOFOLLOW 0100000/* don't follow links */ #define O_DIRECT 0200000/* direct disk access hint - currently ignored */
arch/mips/include/asm/fcntl.h +1 -1
@@ -10,7 +10,7 @@#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 000010/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x0080#define O_CREAT 0x0100/* not fcntl */ #define O_TRUNC 0x0200/* not fcntl */
arch/mips/kernel/kspd.c +1 -0
@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040 +/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080
arch/mips/lemote/lm2e/mem.c +1 -1
@@ -11,7 +11,7 @@/* override of arch/mips/mm/cache.c: __uncached_access */ int __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;/*
arch/mips/mm/cache.c +1 -1
@@ -194,7 +194,7 @@ void __devinit cpu_cache_init(void)int __weak __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);
arch/parisc/include/asm/fcntl.h +2 -3
@@ -1,14 +1,13 @@#ifndef _PARISC_FCNTL_H#define _PARISC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 000000010#define O_BLKSEEK 000000100/* HPUX only */ #define O_CREAT 000000400/* not fcntl */ #define O_EXCL 000002000/* not fcntl */ #define O_LARGEFILE 000004000 -#define O_SYNC 000100000 +#define __O_SYNC 000100000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_NONBLOCK 000200004/* HPUX has separate NDELAY & NONBLOCK */ #define O_NOCTTY 000400000/* not fcntl */ #define O_DSYNC 001000000/* HPUX only */
arch/sparc/include/asm/fcntl.h +16 -3
@@ -1,14 +1,12 @@#ifndef _SPARC_FCNTL_H#define _SPARC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 0x0008#define FASYNC 0x0040/* fcntl, for BSD compatibility */ #define O_CREAT 0x0200/* not fcntl */ #define O_TRUNC 0x0400/* not fcntl */ #define O_EXCL 0x0800/* not fcntl */ -#define O_SYNC 0x2000 +#define O_DSYNC 0x2000/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x4000#if defined(__sparc__) && defined(__arch64__)#define O_NDELAY 0x0004
@@ -20,6 +18,21 @@#define O_DIRECT 0x100000/* direct disk access hint */ #define O_NOATIME 0x200000#define O_CLOEXEC 0x400000 +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. + +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x800000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETOWN 5/* for sockets. */ #define F_SETOWN 6/* for sockets. */
fs/sync.c +3 -2
@@ -287,10 +287,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) { -if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags & __O_SYNC) ?1 :0 ); }EXPORT_SYMBOL (generic_write_sync);
Jan Kara
maintainerRe: [PATCHv2 18/16] implement posix O_SYNC and O_DSYNC semantics
Hi,
Quoted 24 lines · Christoph Hellwig
While Linux provided an
O_SYNCflag basically since day 1, it took until Linux 2.4.0-test12pre2 to actually get it implemented for filesystems, since that day we hadgeneric_osync_aroundwith only minor changes and the great "For now, when the user asks forO_SYNC, we'll actually giveO_DSYNC" comment. This patch intends to actually give us realO_SYNCsemantics in addition to theO_DSYNCsemantics. After Jan'sO_SYNCpatches which are required before this patch it's actually surprisingly simple, we just need to figure out when to set the datasync flag tovfs_fsync_rangeand when not.This patch renames the existing
O_SYNCflag toO_DSYNCwhile keeping it's numerical value to keep binary compatibility, and adds a new realO_SYNCflag. To guarantee backwards compatiblity it is defined as expanding to both theO_DSYNCand the new additional binary flag (__O_SYNC) to make sure we are backwards-compatible when compiled against the new headers.This also means that all places that don't care about the differences can just check
O_DSYNCand get the right behaviour forO_SYNC, too - only places that actuall care need to check__O_SYNCin addition. Drivers and network filesystems have been updated in a fail safe way to always do the full sync magic ifO_DSYNCis set. The few places settingO_SYNCfor lower layers are kept that way for now to stay failsafe.
Quoted 4 lines
Note that parisc really fucked up their headers as they already define a
O_DSYNCthat has always been a no-op. We try to repair it by using it for the newO_DSYNCand redefininingO_SYNCto send both the traditionalO_SYNCnumerical value _and_ theO_DSYNCone.
I've sent Linus a pull request without this patch (I have some comments
to it). When this patch is ready, you can merge it yourself or I can do it if you like.
Quoted 6 lines
Index:
linux-2.6/fs/afs/write.c
===================================================================fs/afs/write.c +0
-0@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }
fs/afs/write.c ssize_t afs_file_write(struct kiocb *ioc · line 700
Quoted 10 lines
fs/afs/write.c +3
-2/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags & __O_SYNC) ?0 :1 );if (ret <0 ) result = ret; }
This code can go away because generic_file_aio_write() already callsfsync()...
arch/mips/include/asm/fcntl.h line 13
Quoted 10 lines
Index:
linux-2.6/arch/mips/include/asm/fcntl.h
===================================================================arch/mips/include/asm/fcntl.h +1
-1@@ -10,7 +10,7 @@#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 000010/* used to be O_SYNC, see below */
The value used to be in hex, not in octal. Moreover I don't see O_SYNC
defined in the header now...
arch/mips/kernel/kspd.c static int sp_stopping = 0; · line 88
Quoted 12 lines
Index:
linux-2.6/arch/mips/kernel/kspd.c
===================================================================arch/mips/kernel/kspd.c +1
-0@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040 +/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080
Since noone uses MTSP_O_FSYNC and it's not exported, I guess it's your
choice ;). Looking at the code, it looks slightly incomplete - probably open_flags_table should contain all the MTSP_O_... flags but I don't really know.
Quoted 11 lines
Index:
linux-2.6/arch/parisc/include/asm/fcntl.h
===================================================================arch/parisc/include/asm/fcntl.h +0
-2@@ -1,14 +1,13 @@#ifndef _PARISC_FCNTL_H#define _PARISC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 000000010
arch/parisc/include/asm/fcntl.h line 13
Quoted 10 lines
arch/parisc/include/asm/fcntl.h +2
-1#define O_BLKSEEK 000000100/* HPUX only */ #define O_CREAT 000000400/* not fcntl */ #define O_EXCL 000002000/* not fcntl */ #define O_LARGEFILE 000004000 -#define O_SYNC 000100000 +#define __O_SYNC 000100000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_NONBLOCK 000200004/* HPUX has separate NDELAY & NONBLOCK */ #define O_NOCTTY 000400000/* not fcntl */ #define O_DSYNC 001000000/* HPUX only */
So for parisc, programs compiled against old headers will fail openO_SYNC because of the check in open() you've added will bail out with EINVAL. I don't like it but I'm not sure we can do better...
Quoted 5 lines
Index:
linux-2.6/fs/sync.c
===================================================================
fs/sync.c SYSCALL_DEFINE1(fdatasync, unsigned int, · line 294
Quoted 10 lines
fs/sync.c +3
-2@@ -287,10 +287,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) { -if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags & __O_SYNC) ?1 :0 );
The logic is inverted here, isn't it?
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCHv2 18/16] implement posix O_SYNC and O_DSYNC semantics
Quoted 3 lines · Jan Kara
I've sent Linus a pull request without this patch (I have some comments
to it). When this patch is ready, you can merge it yourself or I can do it if you like.
Yeah, much better anyway. I'll also post a O_RSYNC implementation later today.
Quoted 7 lines
Quoted 7 lines
Index:
linux-2.6/fs/afs/write.c
===================================================================fs/afs/write.c +0
-0@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }
Quoted 11 lines
fs/afs/write.c ssize_t afs_file_write(struct kiocb *ioc · line 700
Quoted 9 lines
fs/afs/write.c +3
-2/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags & __O_SYNC) ?0 :1 );if (ret <0 ) result = ret; }This code can go away because
generic_file_aio_write()already callsfsync()...
Yes, but that should be a separate patch.
Quoted 7 lines
Quoted 7 lines
Index:
linux-2.6/arch/mips/include/asm/fcntl.h
===================================================================arch/mips/include/asm/fcntl.h +0
-0@@ -10,7 +10,7 @@
Quoted 5 lines
arch/mips/include/asm/fcntl.h line 13
Quoted 3 lines
arch/mips/include/asm/fcntl.h +1
-1#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 000010/* used to be O_SYNC, see below */ The value used to be in hex, not in octal. Moreover I don't see
O_SYNC
defined in the header now...
Thanks, fixed up both bits.
Quoted 8 lines
Quoted 8 lines
Index:
linux-2.6/arch/mips/kernel/kspd.c
===================================================================arch/mips/kernel/kspd.c +0
-0@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040
Quoted 8 lines
arch/mips/kernel/kspd.c static int sp_stopping = 0; · line 88
Quoted 4 lines
arch/mips/kernel/kspd.c +1
-0+/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080Since noone uses
MTSP_O_FSYNCand it's not exported, I guess it's your
choice ;). Looking at the code, it looks slightly incomplete - probablyopen_flags_tableshould contain all theMTSP_O_... flags but I don't really know.
Yeah, I'll hope someone who knows this are better is going to chime in.
Quoted 3 lines
So for parisc, programs compiled against old headers will fail open
O_SYNCbecause of the check inopen()you've added will bail out with EINVAL. I don't like it but I'm not sure we can do better...
Hmm. let me thing about something for parisc.
Quoted 4 lines
Quoted 4 lines
arch/mips/kernel/kspd.c +0
-0@@ -287,10 +287,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) {
Quoted 8 lines
arch/mips/kernel/kspd.c SYSCALL_DEFINE1(fdatasync, unsigned int, · line 294
Quoted 7 lines
arch/mips/kernel/kspd.c +3
-2-if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags & __O_SYNC) ?1 :0 );The logic is inverted here, isn't it?
Yeah, already correct in my tree after I started to the barrier testing in qemu that noticed it.
PATCH 1/1 implement posix O_SYNC and O_DSYNC semantics
In reply to Jan KaraWhile Linux provided an O_SYNC flag basically since day 1, it took until Linux 2.4.0-test12pre2 to actually get it implemented for filesystems, since that day we had generic_osync_around with only minor changes and the great "For now, when the user asks for O_SYNC, we'll actually give O_DSYNC" comment. This patch intends to actually give us real O_SYNC semantics in addition to the O_DSYNC semantics. After Jan's O_SYNC patches which are required before this patch it's actually surprisingly simple, we just need to figure out when to set the datasync flag to vfs_fsync_range and when not.
This patch renames the existing O_SYNC flag to O_DSYNC while keeping it's numerical value to keep binary compatibility, and adds a new real O_SYNC flag. To guarantee backwards compatiblity it is defined as expanding to both the O_DSYNC and the new additional binary flag (__O_SYNC) to make sure we are backwards-compatible when compiled against the new headers.
This also means that all places that don't care about the differences can just check O_DSYNC and get the right behaviour for O_SYNC, too - only places that actuall care need to check __O_SYNC in addition. Drivers and network filesystems have been updated in a fail safe way to always do the full sync magic if O_DSYNC is set. The few places setting O_SYNC for lower layers are kept that way for now to stay failsafe.
We enforce that O_DSYNC is set when __O_SYNC is set early in the open path to make sure we always get these sane options.
Note that parisc really fucked up their headers as they already define a O_DSYNC that has always been a no-op. We try to repair it by using it for the new O_DSYNC and redefinining O_SYNC to send both the traditional O_SYNC numerical value _and_ the O_DSYNC one.
arch/x86/mm/pat.c +1 -1
@@ -541,7 +541,7 @@ int phys_mem_access_prot_allowed(structif (!range_is_allowed (pfn, size))return 0 ; -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) { flags = _PAGE_CACHE_UC_MINUS; }
drivers/char/mem.c +3 -3
@@ -44,7 +44,7 @@ static inline int uncached_access(struct {#if defined(CONFIG_IA64 )/* -* On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases. +* On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases. */ return !(efi_mem_attributes (addr) &EFI_MEMORY_WB );#elif defined(CONFIG_MIPS )
@@ -57,9 +57,9 @@ static inline int uncached_access(struct#else /* * Accessing memory above the top the kernel knows about or through a file pointer -* that was marked O_SYNC will be done non-cached. +* that was marked O_DSYNC will be done non-cached. */ -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);#endif
drivers/staging/me4000/me4000.c +2 -2
@@ -1985,8 +1985,8 @@ static ssize_t me4000_ao_write_cont(struspin_unlock_irqrestore (&ao_context->int_lock, flags); } -/* Wait until the state machine is stopped if O_SYNC is set */ -if (filep->f_flags &O_SYNC ) { +/* Wait until the state machine is stopped if O_DSYNC is set */ +if (filep->f_flags &O_DSYNC ) {while (inl (ao_context->status_reg) &ME4000_AO_STATUS_BIT_FSM ) {interruptible_sleep_on_timeout (&queue,1 );
drivers/usb/gadget/file_storage.c +1 -1
@@ -1713,7 +1713,7 @@ static int do_write(struct fsg_dev *fsg) }if (fsg->cmnd[1 ] &0x08 ) {// FUA spin_lock (&curlun->filp->f_lock); - curlun->filp->f_flags |=O_SYNC ; + curlun->filp->f_flags |=O_DSYNC ;spin_unlock (&curlun->filp->f_lock); } }
fs/afs/write.c +3 -2
@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags & __O_SYNC) ?0 :1 );if (ret <0 ) result = ret; }
fs/btrfs/file.c +2 -2
@@ -924,7 +924,7 @@ static ssize_t btrfs_file_write(struct funsigned long last_index;int will_write; - will_write = ((file->f_flags &O_SYNC ) ||IS_SYNC (inode) || + will_write = ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode) || (file->f_flags &O_DIRECT )); nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
@@ -1077,7 +1077,7 @@ out_nolock:if (err) num_written = err; -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) { trans =btrfs_start_transaction (root,1 ); ret =btrfs_log_dentry_safe (trans, root, file->f_dentry);
fs/cifs/dir.c +2 -1
@@ -214,7 +214,8 @@ int cifs_posix_open(char *full_path, str posix_flags |=SMB_O_TRUNC ;if (oflags &O_APPEND ) posix_flags |=SMB_O_APPEND ; -if (oflags &O_SYNC ) +/* be safe and imply O_SYNC for O_DSYNC */ +if (oflags &O_DSYNC ) posix_flags |=SMB_O_SYNC ;if (oflags &O_DIRECTORY ) posix_flags |=SMB_O_DIRECTORY ;
fs/cifs/file.c +4 -2
@@ -96,8 +96,10 @@ static inline fmode_t cifs_posix_convertreopening a file. They had their effect on the original open */ if (flags &O_APPEND ) posix_flags |= (fmode_t )O_APPEND ; -if (flags &O_SYNC ) - posix_flags |= (fmode_t )O_SYNC ; +if (flags &O_DSYNC ) + posix_flags |= (fmode_t )O_DSYNC ; +if (flags & __O_SYNC) + posix_flags |= (fmode_t )__O_SYNC;if (flags &O_DIRECTORY ) posix_flags |= (fmode_t )O_DIRECTORY ;if (flags &O_NOFOLLOW )
fs/namei.c +9 -0
@@ -1678,6 +1678,15 @@ struct file *do_filp_open(int dfd, constint will_write;int flag =open_to_namei_flags (open_flag); +/* +* O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only +* check for O_DSYNC if the need any syncing at all we enforce it's +* always set instead of having to deal with possibly weird behaviour +* for malicious applications setting only __O_SYNC. +*/ +if (open_flag & __O_SYNC) + open_flag |=O_DSYNC ; +if (!acc_mode) acc_mode =MAY_OPEN |ACC_MODE (flag);
fs/nfs/file.c +2 -2
@@ -580,7 +580,7 @@ static int nfs_need_sync_write(struct fi {struct nfs_open_context *ctx; -if (IS_SYNC (inode) || (filp->f_flags &O_SYNC )) +if (IS_SYNC (inode) || (filp->f_flags &O_DSYNC ))return 1 ; ctx =nfs_file_open_context (filp);if (test_bit (NFS_CONTEXT_ERROR_WRITE , &ctx->flags))
@@ -621,7 +621,7 @@ static ssize_t nfs_file_write(struct kionfs_add_stats (inode,NFSIOS_NORMALWRITTENBYTES , count); result =generic_file_aio_write (iocb, iov, nr_segs, pos); -/* Return error values for O_SYNC and IS_SYNC() */ +/* Return error values for O_DSYNC and IS_SYNC() */ if (result >=0 &&nfs_need_sync_write (iocb->ki_filp, inode)) {int err =nfs_do_fsync (nfs_file_open_context (iocb->ki_filp), inode);if (err <0 )
fs/nfs/write.c +1 -1
@@ -774,7 +774,7 @@ int nfs_updatepage(struct file *file, st*/ if (nfs_write_pageuptodate (page, inode) && inode->i_flock ==NULL && - !(file->f_flags &O_SYNC )) { + !(file->f_flags &O_DSYNC )) { count =max (count + offset,nfs_page_length (page)); offset =0 ; }
include/asm-generic/fcntl.h +21 -4
@@ -3,8 +3,6 @@#include <linux/types.h> -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_ACCMODE 00000003#define O_RDONLY 00000000#define O_WRONLY 00000001
@@ -27,8 +25,8 @@#ifndef O_NONBLOCK #define O_NONBLOCK 00004000#endif -#ifndef O_SYNC -#define O_SYNC 00010000 +#ifndef O_DSYNC +#define O_DSYNC 00010000/* used to be O_SYNC, see below */ #endif #ifndef FASYNC #define FASYNC 00020000/* fcntl, for BSD compatibility */
@@ -51,6 +49,25 @@#ifndef O_CLOEXEC #define O_CLOEXEC 02000000/* set close_on_exec */ #endif + +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#ifndef O_SYNC +#define __O_SYNC 04000000 +#define O_SYNC (__O_SYNC|O_DSYNC) +#endif +#ifndef O_NDELAY #define O_NDELAY O_NONBLOCK#endif
fs/ocfs2/file.c +1 -1
@@ -1878,7 +1878,7 @@ out_dio:/* buffered aio wouldn't have proper lock coverage today */ BUG_ON (ret == -EIOCBQUEUED && !(file->f_flags &O_DIRECT )); -if ((file->f_flags &O_SYNC && !direct_io) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC && !direct_io) ||IS_SYNC (inode)) { ret =filemap_fdatawrite_range (file->f_mapping, pos, pos + count -1 );if (ret <0 )
fs/ubifs/file.c +1 -1
@@ -1403,7 +1403,7 @@ static ssize_t ubifs_aio_write(struct kiif (ret <0 )return ret; -if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_SYNC )) { +if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_DSYNC )) { err =ubifs_sync_wbufs_by_inode (c, inode);if (err)return err;
fs/xfs/linux-2.6/xfs_lrw.c +1 -1
@@ -811,7 +811,7 @@ write_retry:XFS_STATS_ADD (xs_write_bytes, ret);/* Handle various SYNC-type writes */ -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) {int error2;xfs_iunlock (xip, iolock);
sound/core/rawmidi.c +1 -1
@@ -1258,7 +1258,7 @@ static ssize_t snd_rawmidi_write(structbreak ; count -= count1; } -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) {spin_lock_irq (&runtime->lock);while (runtime->avail != runtime->buffer_size) {wait_queue_t wait;
arch/alpha/include/asm/fcntl.h +16 -3
@@ -1,8 +1,6 @@#ifndef _ALPHA_FCNTL_H#define _ALPHA_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_CREAT 01000/* not fcntl */ #define O_TRUNC 02000/* not fcntl */ #define O_EXCL 04000/* not fcntl */
@@ -10,13 +8,28 @@#define O_NONBLOCK 00004#define O_APPEND 00010 -#define O_SYNC 040000 +#define O_DSYNC 040000/* used to be O_SYNC, see below */ #define O_DIRECTORY 0100000/* must be a directory */ #define O_NOFOLLOW 0200000/* don't follow links */ #define O_LARGEFILE 0400000/* will be set by the kernel on every open */ #define O_DIRECT 02000000/* direct disk access - should check with OSF/1 */ #define O_NOATIME 04000000#define O_CLOEXEC 010000000/* set close_on_exec */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 020000000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETLK 7#define F_SETLK 8
arch/blackfin/include/asm/fcntl.h +0 -2
@@ -1,8 +1,6 @@#ifndef _BFIN_FCNTL_H#define _BFIN_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_DIRECTORY 040000/* must be a directory */ #define O_NOFOLLOW 0100000/* don't follow links */ #define O_DIRECT 0200000/* direct disk access hint - currently ignored */
arch/mips/include/asm/fcntl.h +16 -1
@@ -10,7 +10,7 @@#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 0x0010/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x0080#define O_CREAT 0x0100/* not fcntl */ #define O_TRUNC 0x0200/* not fcntl */
@@ -18,6 +18,21 @@#define O_NOCTTY 0x0800/* not fcntl */ #define FASYNC 0x1000/* fcntl, for BSD compatibility */ #define O_LARGEFILE 0x2000/* allow large file opens */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x4000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_DIRECT 0x8000/* direct disk access hint */ #define F_GETLK 14
arch/mips/kernel/kspd.c +1 -0
@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040 +/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080
arch/mips/lemote/lm2e/mem.c +1 -1
@@ -11,7 +11,7 @@/* override of arch/mips/mm/cache.c: __uncached_access */ int __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;/*
arch/mips/mm/cache.c +1 -1
@@ -194,7 +194,7 @@ void __devinit cpu_cache_init(void)int __weak __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);
arch/parisc/include/asm/fcntl.h +2 -3
@@ -1,14 +1,13 @@#ifndef _PARISC_FCNTL_H#define _PARISC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 000000010#define O_BLKSEEK 000000100/* HPUX only */ #define O_CREAT 000000400/* not fcntl */ #define O_EXCL 000002000/* not fcntl */ #define O_LARGEFILE 000004000 -#define O_SYNC 000100000 +#define __O_SYNC 000100000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_NONBLOCK 000200004/* HPUX has separate NDELAY & NONBLOCK */ #define O_NOCTTY 000400000/* not fcntl */ #define O_DSYNC 001000000/* HPUX only */
arch/sparc/include/asm/fcntl.h +16 -3
@@ -1,14 +1,12 @@#ifndef _SPARC_FCNTL_H#define _SPARC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 0x0008#define FASYNC 0x0040/* fcntl, for BSD compatibility */ #define O_CREAT 0x0200/* not fcntl */ #define O_TRUNC 0x0400/* not fcntl */ #define O_EXCL 0x0800/* not fcntl */ -#define O_SYNC 0x2000 +#define O_DSYNC 0x2000/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x4000#if defined(__sparc__) && defined(__arch64__)#define O_NDELAY 0x0004
@@ -20,6 +18,21 @@#define O_DIRECT 0x100000/* direct disk access hint */ #define O_NOATIME 0x200000#define O_CLOEXEC 0x400000 +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x800000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETOWN 5/* for sockets. */ #define F_SETOWN 6/* for sockets. */
fs/sync.c +3 -2
@@ -287,10 +287,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) { -if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags & __O_SYNC) ?0 :1 ); }EXPORT_SYMBOL (generic_write_sync);
Re: [PATCH] implement posix O_SYNC and O_DSYNC semantics
Quoted 27 lines · Christoph Hellwig
While Linux provided an
O_SYNCflag basically since day 1, it took until Linux 2.4.0-test12pre2 to actually get it implemented for filesystems, since that day we hadgeneric_osync_aroundwith only minor changes and the great "For now, when the user asks forO_SYNC, we'll actually giveO_DSYNC" comment. This patch intends to actually give us realO_SYNCsemantics in addition to theO_DSYNCsemantics. After Jan'sO_SYNCpatches which are required before this patch it's actually surprisingly simple, we just need to figure out when to set the datasync flag tovfs_fsync_rangeand when not.This patch renames the existing
O_SYNCflag toO_DSYNCwhile keeping it's numerical value to keep binary compatibility, and adds a new realO_SYNCflag. To guarantee backwards compatiblity it is defined as expanding to both theO_DSYNCand the new additional binary flag (__O_SYNC) to make sure we are backwards-compatible when compiled against the new headers.This also means that all places that don't care about the differences can just check
O_DSYNCand get the right behaviour forO_SYNC, too - only places that actuall care need to check__O_SYNCin addition. Drivers and network filesystems have been updated in a fail safe way to always do the full sync magic ifO_DSYNCis set. The few places settingO_SYNCfor lower layers are kept that way for now to stay failsafe.We enforce that
O_DSYNCis set when__O_SYNCis set early in the open path to make sure we always get these sane options.
Quoted 8 lines
Note that parisc really fucked up their headers as they already define a
O_DSYNCthat has always been a no-op. We try to repair it by using it for the newO_DSYNCand redefininingO_SYNCto send both the traditionalO_SYNCnumerical value _and_ theO_DSYNCone.Signed-off-by Christoph Hellwig <[email protected]>Acked-by Trond Myklebust <[email protected]>
The patch looks fine now.
Quoted 502 lines
Index:
linux-2.6/arch/x86/mm/pat.c
===================================================================arch/x86/mm/pat.c +1
-1@@ -541,7 +541,7 @@ int phys_mem_access_prot_allowed(structif (!range_is_allowed (pfn, size))return 0 ; -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) { flags = _PAGE_CACHE_UC_MINUS; }Index:
linux-2.6/drivers/char/mem.c
===================================================================drivers/char/mem.c +3
-3@@ -44,7 +44,7 @@ static inline int uncached_access(struct {#if defined(CONFIG_IA64 )/* -* On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases. +* On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases. */ return !(efi_mem_attributes (addr) &EFI_MEMORY_WB );#elif defined(CONFIG_MIPS )@@ -57,9 +57,9 @@ static inline int uncached_access(struct#else /* * Accessing memory above the top the kernel knows about or through a file pointer -* that was marked O_SYNC will be done non-cached. +* that was marked O_DSYNC will be done non-cached. */ -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);#endif Index:
linux-2.6/drivers/staging/me4000/me4000.c
===================================================================drivers/staging/me4000/me4000.c +2
-2@@ -1985,8 +1985,8 @@ static ssize_t me4000_ao_write_cont(struspin_unlock_irqrestore (&ao_context->int_lock, flags); } -/* Wait until the state machine is stopped if O_SYNC is set */ -if (filep->f_flags &O_SYNC ) { +/* Wait until the state machine is stopped if O_DSYNC is set */ +if (filep->f_flags &O_DSYNC ) {while (inl (ao_context->status_reg) &ME4000_AO_STATUS_BIT_FSM ) {interruptible_sleep_on_timeout (&queue,1 );Index:
linux-2.6/drivers/usb/gadget/file_storage.c
===================================================================drivers/usb/gadget/file_storage.c +1
-1@@ -1713,7 +1713,7 @@ static int do_write(struct fsg_dev *fsg) }if (fsg->cmnd[1 ] &0x08 ) {// FUA spin_lock (&curlun->filp->f_lock); - curlun->filp->f_flags |=O_SYNC ; + curlun->filp->f_flags |=O_DSYNC ;spin_unlock (&curlun->filp->f_lock); } }Index:
linux-2.6/fs/afs/write.c
===================================================================fs/afs/write.c +3
-2@@ -692,8 +692,9 @@ ssize_t afs_file_write(struct kiocb *ioc }/* return error values for O_SYNC and IS_SYNC() */ -if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_SYNC ) { - ret =afs_fsync (iocb->ki_filp, dentry,1 ); +if (IS_SYNC (&vnode->vfs_inode) || iocb->ki_filp->f_flags &O_DSYNC ) { + ret =afs_fsync (iocb->ki_filp, dentry, + (iocb->ki_filp->f_flags & __O_SYNC) ?0 :1 );if (ret <0 ) result = ret; }Index:
linux-2.6/fs/btrfs/file.c
===================================================================fs/btrfs/file.c +2
-2@@ -924,7 +924,7 @@ static ssize_t btrfs_file_write(struct funsigned long last_index;int will_write; - will_write = ((file->f_flags &O_SYNC ) ||IS_SYNC (inode) || + will_write = ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode) || (file->f_flags &O_DIRECT )); nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,@@ -1077,7 +1077,7 @@ out_nolock:if (err) num_written = err; -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) { trans =btrfs_start_transaction (root,1 ); ret =btrfs_log_dentry_safe (trans, root, file->f_dentry);Index:
linux-2.6/fs/cifs/dir.c
===================================================================fs/cifs/dir.c +2
-1@@ -214,7 +214,8 @@ int cifs_posix_open(char *full_path, str posix_flags |=SMB_O_TRUNC ;if (oflags &O_APPEND ) posix_flags |=SMB_O_APPEND ; -if (oflags &O_SYNC ) +/* be safe and imply O_SYNC for O_DSYNC */ +if (oflags &O_DSYNC ) posix_flags |=SMB_O_SYNC ;if (oflags &O_DIRECTORY ) posix_flags |=SMB_O_DIRECTORY ;Index:
linux-2.6/fs/cifs/file.c
===================================================================fs/cifs/file.c +4
-2@@ -96,8 +96,10 @@ static inline fmode_t cifs_posix_convertreopening a file. They had their effect on the original open */ if (flags &O_APPEND ) posix_flags |= (fmode_t )O_APPEND ; -if (flags &O_SYNC ) - posix_flags |= (fmode_t )O_SYNC ; +if (flags &O_DSYNC ) + posix_flags |= (fmode_t )O_DSYNC ; +if (flags & __O_SYNC) + posix_flags |= (fmode_t )__O_SYNC;if (flags &O_DIRECTORY ) posix_flags |= (fmode_t )O_DIRECTORY ;if (flags &O_NOFOLLOW )Index:
linux-2.6/fs/namei.c
===================================================================fs/namei.c +9
-0@@ -1678,6 +1678,15 @@ struct file *do_filp_open(int dfd, constint will_write;int flag =open_to_namei_flags (open_flag); +/* +* O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only +* check for O_DSYNC if the need any syncing at all we enforce it's +* always set instead of having to deal with possibly weird behaviour +* for malicious applications setting only __O_SYNC. +*/ +if (open_flag & __O_SYNC) + open_flag |=O_DSYNC ; +if (!acc_mode) acc_mode =MAY_OPEN |ACC_MODE (flag);Index:
linux-2.6/fs/nfs/file.c
===================================================================fs/nfs/file.c +2
-2@@ -580,7 +580,7 @@ static int nfs_need_sync_write(struct fi {struct nfs_open_context *ctx; -if (IS_SYNC (inode) || (filp->f_flags &O_SYNC )) +if (IS_SYNC (inode) || (filp->f_flags &O_DSYNC ))return 1 ; ctx =nfs_file_open_context (filp);if (test_bit (NFS_CONTEXT_ERROR_WRITE , &ctx->flags))@@ -621,7 +621,7 @@ static ssize_t nfs_file_write(struct kionfs_add_stats (inode,NFSIOS_NORMALWRITTENBYTES , count); result =generic_file_aio_write (iocb, iov, nr_segs, pos); -/* Return error values for O_SYNC and IS_SYNC() */ +/* Return error values for O_DSYNC and IS_SYNC() */ if (result >=0 &&nfs_need_sync_write (iocb->ki_filp, inode)) {int err =nfs_do_fsync (nfs_file_open_context (iocb->ki_filp), inode);if (err <0 )Index:
linux-2.6/fs/nfs/write.c
===================================================================fs/nfs/write.c +1
-1@@ -774,7 +774,7 @@ int nfs_updatepage(struct file *file, st*/ if (nfs_write_pageuptodate (page, inode) && inode->i_flock ==NULL && - !(file->f_flags &O_SYNC )) { + !(file->f_flags &O_DSYNC )) { count =max (count + offset,nfs_page_length (page)); offset =0 ; }Index:
linux-2.6/include/asm-generic/fcntl.h
===================================================================include/asm-generic/fcntl.h +21
-4@@ -3,8 +3,6 @@#include <linux/types.h> -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_ACCMODE 00000003#define O_RDONLY 00000000#define O_WRONLY 00000001@@ -27,8 +25,8 @@#ifndef O_NONBLOCK #define O_NONBLOCK 00004000#endif -#ifndef O_SYNC -#define O_SYNC 00010000 +#ifndef O_DSYNC +#define O_DSYNC 00010000/* used to be O_SYNC, see below */ #endif #ifndef FASYNC #define FASYNC 00020000/* fcntl, for BSD compatibility */ @@ -51,6 +49,25 @@#ifndef O_CLOEXEC #define O_CLOEXEC 02000000/* set close_on_exec */ #endif + +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#ifndef O_SYNC +#define __O_SYNC 04000000 +#define O_SYNC (__O_SYNC|O_DSYNC) +#endif +#ifndef O_NDELAY #define O_NDELAY O_NONBLOCK#endif Index:
linux-2.6/fs/ocfs2/file.c
===================================================================fs/ocfs2/file.c +1
-1@@ -1878,7 +1878,7 @@ out_dio:/* buffered aio wouldn't have proper lock coverage today */ BUG_ON (ret == -EIOCBQUEUED && !(file->f_flags &O_DIRECT )); -if ((file->f_flags &O_SYNC && !direct_io) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC && !direct_io) ||IS_SYNC (inode)) { ret =filemap_fdatawrite_range (file->f_mapping, pos, pos + count -1 );if (ret <0 )Index:
linux-2.6/fs/ubifs/file.c
===================================================================fs/ubifs/file.c +1
-1@@ -1403,7 +1403,7 @@ static ssize_t ubifs_aio_write(struct kiif (ret <0 )return ret; -if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_SYNC )) { +if (ret >0 && (IS_SYNC (inode) || iocb->ki_filp->f_flags &O_DSYNC )) { err =ubifs_sync_wbufs_by_inode (c, inode);if (err)return err;Index:
linux-2.6/fs/xfs/linux-2.6/xfs_lrw.c
===================================================================fs/xfs/linux-2.6/xfs_lrw.c +1
-1@@ -811,7 +811,7 @@ write_retry:XFS_STATS_ADD (xs_write_bytes, ret);/* Handle various SYNC-type writes */ -if ((file->f_flags &O_SYNC ) ||IS_SYNC (inode)) { +if ((file->f_flags &O_DSYNC ) ||IS_SYNC (inode)) {int error2;xfs_iunlock (xip, iolock);Index:
linux-2.6/sound/core/rawmidi.c
===================================================================sound/core/rawmidi.c +1
-1@@ -1258,7 +1258,7 @@ static ssize_t snd_rawmidi_write(structbreak ; count -= count1; } -if (file->f_flags &O_SYNC ) { +if (file->f_flags &O_DSYNC ) {spin_lock_irq (&runtime->lock);while (runtime->avail != runtime->buffer_size) {wait_queue_t wait;Index:
linux-2.6/arch/alpha/include/asm/fcntl.h
===================================================================arch/alpha/include/asm/fcntl.h +16
-3@@ -1,8 +1,6 @@#ifndef _ALPHA_FCNTL_H#define _ALPHA_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_CREAT 01000/* not fcntl */ #define O_TRUNC 02000/* not fcntl */ #define O_EXCL 04000/* not fcntl */ @@ -10,13 +8,28 @@#define O_NONBLOCK 00004#define O_APPEND 00010 -#define O_SYNC 040000 +#define O_DSYNC 040000/* used to be O_SYNC, see below */ #define O_DIRECTORY 0100000/* must be a directory */ #define O_NOFOLLOW 0200000/* don't follow links */ #define O_LARGEFILE 0400000/* will be set by the kernel on every open */ #define O_DIRECT 02000000/* direct disk access - should check with OSF/1 */ #define O_NOATIME 04000000#define O_CLOEXEC 010000000/* set close_on_exec */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 020000000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETLK 7#define F_SETLK 8Index:
linux-2.6/arch/blackfin/include/asm/fcntl.h
===================================================================arch/blackfin/include/asm/fcntl.h +0
-2@@ -1,8 +1,6 @@#ifndef _BFIN_FCNTL_H#define _BFIN_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_DIRECTORY 040000/* must be a directory */ #define O_NOFOLLOW 0100000/* don't follow links */ #define O_DIRECT 0200000/* direct disk access hint - currently ignored */ Index:
linux-2.6/arch/mips/include/asm/fcntl.h
===================================================================arch/mips/include/asm/fcntl.h +16
-1@@ -10,7 +10,7 @@#define O_APPEND 0x0008 -#define O_SYNC 0x0010 +#define O_DSYNC 0x0010/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x0080#define O_CREAT 0x0100/* not fcntl */ #define O_TRUNC 0x0200/* not fcntl */ @@ -18,6 +18,21 @@#define O_NOCTTY 0x0800/* not fcntl */ #define FASYNC 0x1000/* fcntl, for BSD compatibility */ #define O_LARGEFILE 0x2000/* allow large file opens */ +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x4000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_DIRECT 0x8000/* direct disk access hint */ #define F_GETLK 14Index:
linux-2.6/arch/mips/kernel/kspd.c
===================================================================arch/mips/kernel/kspd.c +1
-0@@ -82,6 +82,7 @@ static int sp_stopping = 0;#define MTSP_O_SHLOCK 0x0010#define MTSP_O_EXLOCK 0x0020#define MTSP_O_ASYNC 0x0040 +/* XXX: check which of these is actually O_SYNC vs O_DSYNC */ #define MTSP_O_FSYNC O_SYNC#define MTSP_O_NOFOLLOW 0x0100#define MTSP_O_SYNC 0x0080Index:
linux-2.6/arch/mips/lemote/lm2e/mem.c
===================================================================arch/mips/lemote/lm2e/mem.c +1
-1@@ -11,7 +11,7 @@/* override of arch/mips/mm/cache.c: __uncached_access */ int __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;/* Index:
linux-2.6/arch/mips/mm/cache.c
===================================================================arch/mips/mm/cache.c +1
-1@@ -194,7 +194,7 @@ void __devinit cpu_cache_init(void)int __weak __uncached_access (struct file *file,unsigned long addr) { -if (file->f_flags &O_SYNC ) +if (file->f_flags &O_DSYNC )return 1 ;return addr >=__pa (high_memory);Index:
linux-2.6/arch/parisc/include/asm/fcntl.h
===================================================================arch/parisc/include/asm/fcntl.h +2
-3@@ -1,14 +1,13 @@#ifndef _PARISC_FCNTL_H#define _PARISC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 000000010#define O_BLKSEEK 000000100/* HPUX only */ #define O_CREAT 000000400/* not fcntl */ #define O_EXCL 000002000/* not fcntl */ #define O_LARGEFILE 000004000 -#define O_SYNC 000100000 +#define __O_SYNC 000100000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define O_NONBLOCK 000200004/* HPUX has separate NDELAY & NONBLOCK */ #define O_NOCTTY 000400000/* not fcntl */ #define O_DSYNC 001000000/* HPUX only */ Index:
linux-2.6/arch/sparc/include/asm/fcntl.h
===================================================================arch/sparc/include/asm/fcntl.h +16
-3@@ -1,14 +1,12 @@#ifndef _SPARC_FCNTL_H#define _SPARC_FCNTL_H -/* open/fcntl - O_SYNC is only implemented on blocks devices and on files -located on an ext2 file system */ #define O_APPEND 0x0008#define FASYNC 0x0040/* fcntl, for BSD compatibility */ #define O_CREAT 0x0200/* not fcntl */ #define O_TRUNC 0x0400/* not fcntl */ #define O_EXCL 0x0800/* not fcntl */ -#define O_SYNC 0x2000 +#define O_DSYNC 0x2000/* used to be O_SYNC, see below */ #define O_NONBLOCK 0x4000#if defined(__sparc__) && defined(__arch64__)#define O_NDELAY 0x0004@@ -20,6 +18,21 @@#define O_DIRECT 0x100000/* direct disk access hint */ #define O_NOATIME 0x200000#define O_CLOEXEC 0x400000 +/* +* Before Linux 2.6.32 only O_DSYNC semantics were implemented, but using +* the O_SYNC flag. We continue to use the existing numerical value +* for O_DSYNC semantics now, but using the correct symbolic name for it. +* This new value is used to request true Posix O_SYNC semantics. It is +* defined in this strange way to make sure applications compiled against +* new headers get at least O_DSYNC semantics on older kernels. +* +* This has the nice side-effect that we can simply test for O_DSYNC +* wherever we do not care if O_DSYNC or O_SYNC is used. +* +* Note: __O_SYNC must never be used directly. +*/ +#define __O_SYNC 0x800000 +#define O_SYNC (__O_SYNC|O_DSYNC)#define F_GETOWN 5/* for sockets. */ #define F_SETOWN 6/* for sockets. */ Index:
linux-2.6/fs/sync.c
===================================================================fs/sync.c +3
-2@@ -287,10 +287,11 @@ SYSCALL_DEFINE1(fdatasync, unsigned int,*/ int generic_write_sync (struct file *file,loff_t pos,loff_t count) { -if (!(file->f_flags &O_SYNC ) && !IS_SYNC (file->f_mapping->host)) +if (!(file->f_flags &O_DSYNC ) && !IS_SYNC (file->f_mapping->host))return 0 ;return vfs_fsync_range (file, file->f_path.dentry, pos, - pos + count -1 ,1 ); + pos + count -1 , + (file->f_flags & __O_SYNC) ?0 :1 ); }EXPORT_SYMBOL (generic_write_sync);
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH] implement posix O_SYNC and O_DSYNC semantics
In reply to Christoph HellwigQuoted 2 lines · Christoph Hellwig
Signed-off-by Christoph Hellwig<[email protected]>Acked-by Trond Myklebust<[email protected]>
Looks OK to me:
Signature · 1 line
➧ Ulrich Drepper ➧ Red Hat, Inc. ➧ 444 Castro St ➧ Mountain View, CA ❖
Re: [PATCH] implement posix O_SYNC and O_DSYNC semantics
Btw, a little update on O_RSYNC: I have a patch that should work, but surprisingly enough it doesn't. Seem like the O_ flags grew too large and somewhere in the middle they get truncated off. Here's what I have so far:
fs/splice.c +4 -0
@@ -501,6 +501,10 @@ ssize_t generic_file_splice_read(structif (unlikely (left < len)) len = left; + ret =generic_read_sync (in, *ppos, len); +if (ret) +return ret; + ret =__generic_file_splice_read (in, ppos, pipe, len, flags);if (ret >0 ) { *ppos += ret;
fs/sync.c +27 -0
@@ -295,6 +295,33 @@ int generic_write_sync(struct file *file }EXPORT_SYMBOL (generic_write_sync); +/** +* generic_read_sync - perform syncing befor +* @file: file to which the read happens +* @pos: offset where the read starts +* @count: length of the read +* +* This implements the O_RSYNC semantics: +* O_RSYNC on its own just means the data is successfully transferred to +* the calling process (always the case). +* +* O_RSYNC|O_DSYNC means that if a read request hits data that is currently +* in a cache and not yet on the medium, then the write to medium is +* successful before the read succeeds. +* +* O_RSYNC|O_SYNC means the same plus the integrity of file meta information +* (access time etc). +*/ +int generic_read_sync (struct file *file,loff_t pos,loff_t count) +{ +if (((file->f_flags & (O_RSYNC |O_DSYNC )) != (O_RSYNC |O_DSYNC ))) +return 0 ; +return vfs_fsync_range (file, file->f_path.dentry, pos, + pos + count -1 , + (file->f_flags & __O_SYNC) ?0 :1 ); +} +EXPORT_SYMBOL (generic_read_sync); +/* * sys_sync_file_range() permits finely controlled syncing over a segment of * a file in the range offset .. (offset+nbytes-1) inclusive. If nbytes is
include/asm-generic/fcntl.h +4 -0
@@ -68,6 +68,10 @@#define O_SYNC (__O_SYNC|O_DSYNC)#endif +#ifndef O_RSYNC +#define O_RSYNC 010000000 +#endif +#ifndef O_NDELAY #define O_NDELAY O_NONBLOCK#endif
include/linux/fs.h +1 -0
@@ -2097,6 +2097,7 @@ extern int vfs_fsync_range(struct file * loff_t start, loff_t end, int datasync);extern int vfs_fsync (struct file *file,struct dentry *dentry,int datasync);extern int generic_write_sync (struct file *file,loff_t pos,loff_t count); +extern int generic_read_sync (struct file *file,loff_t pos,loff_t count);extern void sync_supers (void );extern void emergency_sync (void );extern void emergency_remount (void );
mm/filemap.c +4 -0
@@ -1285,6 +1285,10 @@ generic_file_aio_read(struct kiocb *iocbif (retval)return retval; + retval =generic_read_sync (filp, pos, count); +if (retval) +return retval; +/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */ if (filp->f_flags &O_DIRECT ) {loff_t size;
arch/alpha/include/asm/fcntl.h +1 -0
@@ -30,6 +30,7 @@*/ #define __O_SYNC 020000000#define O_SYNC (__O_SYNC|O_DSYNC) +#define O_RSYNC 040000000#define F_GETLK 7#define F_SETLK 8
arch/mips/include/asm/fcntl.h +1 -0
@@ -34,6 +34,7 @@#define __O_SYNC 0x4000#define O_SYNC (__O_SYNC|O_DSYNC)#define O_DIRECT 0x8000/* direct disk access hint */ +#define O_DSYNC 0x10000#define F_GETLK 14#define F_SETLK 6
arch/parisc/include/asm/fcntl.h +1 -0
@@ -14,6 +14,7 @@#define O_RSYNC 002000000/* HPUX only */ #define O_NOATIME 004000000#define O_CLOEXEC 010000000/* set close_on_exec */ +#define O_RSYNC 020000000#define O_DIRECTORY 000010000/* must be a directory */ #define O_NOFOLLOW 000000200/* don't follow links */
arch/sparc/include/asm/fcntl.h +1 -0
@@ -33,6 +33,7 @@*/ #define __O_SYNC 0x800000#define O_SYNC (__O_SYNC|O_DSYNC) +#define O_RSYNC 0x1000000#define F_GETOWN 5/* for sockets. */ #define F_SETOWN 6/* for sockets. */
Re: [PATCH] implement posix O_SYNC and O_DSYNC semantics
In reply to Christoph HellwigQuoted 3 lines · Christoph Hellwig
Signed-off-by Christoph Hellwig <[email protected]>Acked-by Trond Myklebust <[email protected]>
Parisc bits look ok to me.