Skip to contentSkip to conversation

ceph: invalidate pages when doing direct/sync writes

PATCH In review Luís Henriques 3 participants 9 messages Apr 7, 2022 – Apr 10, 2022 Ceph client

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/1 ceph: invalidate pages when doing direct/sync writes

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
 fs/ceph/file.c | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +14 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
 		return ret;
 
 	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
 	while ((len = iov_iter_count(from)) > 0) {
 		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
 			break;
 		}
 		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
 		pos += len;
 		written += len;
 		dout("sync_write written %d\n", written);
#1 lore raw
Quoted 37 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
  fs/ceph/file.c | 19 ++++++++++++++-----
  1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +0 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  		return ret;
 
  	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
  	while ((len = iov_iter_count(from)) > 0) {
  		size_t left;

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1941

Quoted 9 lines
fs/ceph/file.c +6 -0
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  			break;
  		}
  		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(

IMO we'd better use truncate_inode_pages_range() after write. The above means it's possibly will write the dirty pagecache back, which will overwrite and corrupt the disk data just wrote.

Though it seems impossible that these pagecaches will be marked dirty, but this call is misleading ?

-- Xiubo

Quoted 12 lines
fs/ceph/file.c +8 -0
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
  		pos += len;
  		written += len;
  		dout("sync_write written %d\n", written);
#2 lore raw
Quoted 35 lines · Xiubo Li
Quoted 34 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
  fs/ceph/file.c | 19 ++++++++++++++-----
  1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +0 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  		return ret;
 
  	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
Quoted 17 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1941

Quoted 12 lines
fs/ceph/file.c +6 -0
  	while ((len = iov_iter_count(from)) > 0) {
  		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  			break;
  		}
  		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(

IMO we'd better use truncate_inode_pages_range() after write. The above means it's possibly will write the dirty pagecache back, which will overwrite and corrupt the disk data just wrote.

I disagree. We call filemap_write_and_wait_range at the start of this, so any data that was dirty when we called write() will be written back before the sync write.

If we truncate the range, then we'll potentially lose writes that came in after write was issued but before truncate_inode_pages_range. I think we'd rather let what we just wrote be clobbered in this situation than lose a write altogether.

All of this is somewhat academic though. If you're mixing buffered and direct writes like this without some sort of locking, then you're just asking for trouble. The aim here is "sane behavior to the best of our ability", but we can't expect it to always be sane when people do insane things. ;)

Quoted 3 lines

Though it seems impossible that these pagecaches will be marked dirty, but this call is misleading ?

Not impossible at all. You can open a file O_DIRECT and then mmap the fd for PROT_WRITE (or just open the file a second time and do it).

We definitely recommend against mixing buffered and direct I/O, but nothing really prevents someone from doing it. If the user is properly using file locking, then there's really no reason it shouldn't work.

Quoted 14 lines
Quoted 13 lines
fs/ceph/file.c +8 -0
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
  		pos += len;
  		written += len;
  		dout("sync_write written %d\n", written);
Signature · 1 line
Jeff Layton <[email protected]>
#3 lore raw
Quoted 61 lines · Jeff Layton
Quoted 35 lines · Xiubo Li
Quoted 34 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
   fs/ceph/file.c | 19 ++++++++++++++-----
   1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +0 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   		return ret;
 
   	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
Quoted 16 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1941

Quoted 12 lines
fs/ceph/file.c +6 -0
   	while ((len = iov_iter_count(from)) > 0) {
   		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   			break;
   		}
   		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(

IMO we'd better use truncate_inode_pages_range() after write. The above means it's possibly will write the dirty pagecache back, which will overwrite and corrupt the disk data just wrote.

I disagree. We call filemap_write_and_wait_range at the start of this, so any data that was dirty when we called write() will be written back before the sync write.

If we truncate the range, then we'll potentially lose writes that came in after write was issued but before truncate_inode_pages_range. I think we'd rather let what we just wrote be clobbered in this situation than lose a write altogether.

Quoted 5 lines

All of this is somewhat academic though. If you're mixing buffered and direct writes like this without some sort of locking, then you're just asking for trouble. The aim here is "sane behavior to the best of our ability", but we can't expect it to always be sane when people do insane things. ;)

Just in the case Luis hit. Before writing the new data the mapping happen when reading the src in copy_from_usr(). So once the writing done the pagecache is caching the stale contents.

-- Xiubo

Quoted 22 lines
Quoted 3 lines

Though it seems impossible that these pagecaches will be marked dirty, but this call is misleading ?

Not impossible at all. You can open a file O_DIRECT and then mmap the fd for PROT_WRITE (or just open the file a second time and do it).

We definitely recommend against mixing buffered and direct I/O, but nothing really prevents someone from doing it. If the user is properly using file locking, then there's really no reason it shouldn't work.

Quoted 12 lines
Quoted 12 lines
fs/ceph/file.c +8 -0
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
   		pos += len;
   		written += len;
   		dout("sync_write written %d\n", written);
#4 lore raw
Quoted 68 lines · Xiubo Li
Quoted 61 lines · Jeff Layton
Quoted 35 lines · Xiubo Li
Quoted 34 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
   fs/ceph/file.c | 19 ++++++++++++++-----
   1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +0 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   		return ret;
 
   	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
Quoted 16 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1941

Quoted 12 lines
fs/ceph/file.c +6 -0
   	while ((len = iov_iter_count(from)) > 0) {
   		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   			break;
   		}
   		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(

IMO we'd better use truncate_inode_pages_range() after write. The above means it's possibly will write the dirty pagecache back, which will overwrite and corrupt the disk data just wrote.

I disagree. We call filemap_write_and_wait_range at the start of this, so any data that was dirty when we called write() will be written back before the sync write.

If we truncate the range, then we'll potentially lose writes that came in after write was issued but before truncate_inode_pages_range. I think we'd rather let what we just wrote be clobbered in this situation than lose a write altogether.

Quoted 5 lines

All of this is somewhat academic though. If you're mixing buffered and direct writes like this without some sort of locking, then you're just asking for trouble. The aim here is "sane behavior to the best of our ability", but we can't expect it to always be sane when people do insane things. ;)

Quoted 4 lines

Just in the case Luis hit. Before writing the new data the mapping happen when reading the src in copy_from_usr(). So once the writing done the pagecache is caching the stale contents.

Not just in that case.

You could have 2 unrelated processes, one doing DIO writes and one doing mmap writes. You're likely to end up with a mess unless you're very careful with what you're doing, but there should be some expectation that it will work if you serialize things correctly and/or have them writing to their own areas of the file, etc.

In any case, we'll never get perfect cache coherency, and I figure that until the write returns, what's in the pagecache ought to be considered valid.

Quoted 23 lines
Quoted 22 lines
Quoted 3 lines

Though it seems impossible that these pagecaches will be marked dirty, but this call is misleading ?

Not impossible at all. You can open a file O_DIRECT and then mmap the fd for PROT_WRITE (or just open the file a second time and do it).

We definitely recommend against mixing buffered and direct I/O, but nothing really prevents someone from doing it. If the user is properly using file locking, then there's really no reason it shouldn't work.

Quoted 12 lines
Quoted 12 lines
fs/ceph/file.c +8 -0
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
   		pos += len;
   		written += len;
   		dout("sync_write written %d\n", written);
Signature · 1 line
Jeff Layton <[email protected]>
#5 lore raw
Quoted 72 lines · Jeff Layton
Quoted 62 lines · Xiubo Li
Quoted 61 lines · Jeff Layton
Quoted 35 lines · Xiubo Li
Quoted 34 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
    fs/ceph/file.c | 19 ++++++++++++++-----
    1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +0 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
    		return ret;
 
    	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
Quoted 16 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1941

Quoted 12 lines
fs/ceph/file.c +6 -0
    	while ((len = iov_iter_count(from)) > 0) {
    		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
    			break;
    		}
    		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(

IMO we'd better use truncate_inode_pages_range() after write. The above means it's possibly will write the dirty pagecache back, which will overwrite and corrupt the disk data just wrote.

I disagree. We call filemap_write_and_wait_range at the start of this, so any data that was dirty when we called write() will be written back before the sync write.

If we truncate the range, then we'll potentially lose writes that came in after write was issued but before truncate_inode_pages_range. I think we'd rather let what we just wrote be clobbered in this situation than lose a write altogether.

Quoted 9 lines
Quoted 5 lines

All of this is somewhat academic though. If you're mixing buffered and direct writes like this without some sort of locking, then you're just asking for trouble. The aim here is "sane behavior to the best of our ability", but we can't expect it to always be sane when people do insane things. ;)

Just in the case Luis hit. Before writing the new data the mapping happen when reading the src in copy_from_usr(). So once the writing done the pagecache is caching the stale contents.

Quoted 7 lines

Not just in that case.

You could have 2 unrelated processes, one doing DIO writes and one doing mmap writes. You're likely to end up with a mess unless you're very careful with what you're doing, but there should be some expectation that it will work if you serialize things correctly and/or have them writing to their own areas of the file, etc.

For this case I checked the other use cases, they are seems will do:

filemap_invalidate_lock(inode->i_mapping);

write pagecache back;

invalidate the mapping and drop the pages;

do the IOs;

filemap_invalidate_unlock(inode->i_mapping);

The filemap_invalidate_lock could prevent the page fault to map them again during this.

Quoted 3 lines

In any case, we'll never get perfect cache coherency, and I figure that until the write returns, what's in the pagecache ought to be considered valid.

Okay, I am okay with this.

As my understanding is that we should make sure that the pagecache is always valid during the sync write, or if the pagecache will be revalidated it should just block the other processes to read from the mmap.

-- Xiubo

Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
Quoted 3 lines

Though it seems impossible that these pagecaches will be marked dirty, but this call is misleading ?

Not impossible at all. You can open a file O_DIRECT and then mmap the fd for PROT_WRITE (or just open the file a second time and do it).

We definitely recommend against mixing buffered and direct I/O, but nothing really prevents someone from doing it. If the user is properly using file locking, then there's really no reason it shouldn't work.

Quoted 12 lines
Quoted 12 lines
fs/ceph/file.c +8 -0
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;
+		}
    		pos += len;
    		written += len;
    		dout("sync_write written %d\n", written);
#6 lore raw
In reply to Luís Henriques
Quoted 43 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
  fs/ceph/file.c | 19 ++++++++++++++-----
  1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +3 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  		return ret;
 
  	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
  	while ((len = iov_iter_count(from)) > 0) {
  		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  			break;
  		}
  		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1948

Quoted 10 lines
fs/ceph/file.c +10 -0
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;

For this, IMO it's not safe. If we just ignore it the pagecache will still have invalid data.

I think what the 'ceph_direct_read_write()' does is more correct, it will make sure all the dirty pages are writeback from the pagecaches by using 'invalidate_inode_pages2_range()' without blocking and later will do the invalidate blocked by using 'truncate_inode_pages_range()' if some pages are not unmaped in 'invalidate_inode_pages2_range()' when EBUSY.

This can always be sure that the pagecache has no invalid data after write finishes. I think why it use the truncate helper here is because it's safe and there shouldn't have any buffer write happen for DIO ?

But from my understanding the 'ceph_direct_read_write()' is still buggy. What if the page fault happen just after 'truncate_inode_pages_range()' ? Will this happen ? Should we leave this to use the file lock to guarantee it in user space ?

Thought ?

-- Xiubo

Quoted 5 lines
fs/ceph/file.c +1 -0
+		}
  		pos += len;
  		written += len;
  		dout("sync_write written %d\n", written);
#7 lore raw
Quoted 49 lines · Xiubo Li
Quoted 48 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
  fs/ceph/file.c | 19 ++++++++++++++-----
  1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +8 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  		return ret;
 
  	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
  	while ((len = iov_iter_count(from)) > 0) {
  		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
  			break;
  		}
  		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(
+				inode->i_mapping,
+				pos >> PAGE_SHIFT,
Quoted 9 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1948

Quoted 5 lines
fs/ceph/file.c +5 -0
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;

For this, IMO it's not safe. If we just ignore it the pagecache will still have invalid data.

That data is not invalid. It's dirty data from a buffered write that raced with the DIO/sync write we're handling here. i.e. another write came in while we were already processing the DIO write, but after the point where we called filemap_write_and_wait.

When two write() calls to the same data are racing like that, the outcome is undefined. We can't be certain which one will prevail as the kernel could handle them in either order.

The good news with Ceph/RADOS is that you shouldn't end up with a torn write, unless the write happens to span multiple objects. Not much we can do about that though.

Quoted 6 lines

I think what the 'ceph_direct_read_write()' does is more correct, it will make sure all the dirty pages are writeback from the pagecaches by using 'invalidate_inode_pages2_range()' without blocking and later will do the invalidate blocked by using 'truncate_inode_pages_range()' if some pages are not unmaped in 'invalidate_inode_pages2_range()' when EBUSY.

I'm not convinced this is any better, and it's attempting to impose a deterministic outcome on a situation that is non-deterministic by nature.

Quoted 10 lines

This can always be sure that the pagecache has no invalid data after write finishes. I think why it use the truncate helper here is because it's safe and there shouldn't have any buffer write happen for DIO ?

But from my understanding the 'ceph_direct_read_write()' is still buggy. What if the page fault happen just after 'truncate_inode_pages_range()' ? Will this happen ? Should we leave this to use the file lock to guarantee it in user space ?

Thought ?

Again, we can't really predict what the outcome of two racing writes to the same area will do, so I don't see that there is a problem.

Signature · 1 line
Jeff Layton <[email protected]>
#8 lore raw
Quoted 58 lines · Jeff Layton
Quoted 48 lines · Xiubo Li
Quoted 47 lines · Luís Henriques

When doing a direct/sync write, we need to invalidate the page cache in the range being written to. If we don't do this, the cache will include invalid data as we just did a write that avoided the page cache.

---
   fs/ceph/file.c | 19 ++++++++++++++-----
   1 file changed, 14 insertions(+), 5 deletions(-)

Changes since v3:
- Dropped initial call to invalidate_inode_pages2_range()
- Added extra comment to document invalidation

Changes since v2:
- Invalidation needs to be done after a write

Changes since v1:
- Replaced truncate_inode_pages_range() by invalidate_inode_pages2_range
- Call fscache_invalidate with FSCACHE_INVAL_DIO_WRITE if we're doing DIO

fs/ceph/file.c +7 -5
index 5072570c2203..97f764b2fbdd 100644
@@ -1606,11 +1606,6 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   		return ret;
 
   	ceph_fscache_invalidate(inode, false);
-	ret = invalidate_inode_pages2_range(inode->i_mapping,
-					    pos >> PAGE_SHIFT,
-					    (pos + count - 1) >> PAGE_SHIFT);
-	if (ret < 0)
-		dout("invalidate_inode_pages2_range returned %d\n", ret);
 
   	while ((len = iov_iter_count(from)) > 0) {
   		size_t left;
@@ -1938,6 +1933,20 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
   			break;
   		}
   		ceph_clear_error_write(ci);
+
+		/*
+		 * we need to invalidate the page cache here, otherwise the
+		 * cache will include invalid data in direct/sync writes.
+		 */
+		ret = invalidate_inode_pages2_range(
+				inode->i_mapping,
Quoted 9 lines

fs/ceph/file.c ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos, · line 1948

Quoted 6 lines
fs/ceph/file.c +6 -0
+				pos >> PAGE_SHIFT,
+				(pos + len - 1) >> PAGE_SHIFT);
+		if (ret < 0) {
+			dout("invalidate_inode_pages2_range returned %d\n",
+			     ret);
+			ret = 0;

For this, IMO it's not safe. If we just ignore it the pagecache will still have invalid data.

Quoted 8 lines

That data is not invalid. It's dirty data from a buffered write that raced with the DIO/sync write we're handling here. i.e. another write came in while we were already processing the DIO write, but after the point where we called filemap_write_and_wait.

When two write() calls to the same data are racing like that, the outcome is undefined. We can't be certain which one will prevail as the kernel could handle them in either order.

Okay, I think you are right.

-- Xiubo

Quoted 28 lines

The good news with Ceph/RADOS is that you shouldn't end up with a torn write, unless the write happens to span multiple objects. Not much we can do about that though.

Quoted 6 lines

I think what the 'ceph_direct_read_write()' does is more correct, it will make sure all the dirty pages are writeback from the pagecaches by using 'invalidate_inode_pages2_range()' without blocking and later will do the invalidate blocked by using 'truncate_inode_pages_range()' if some pages are not unmaped in 'invalidate_inode_pages2_range()' when EBUSY.

I'm not convinced this is any better, and it's attempting to impose a deterministic outcome on a situation that is non-deterministic by nature.

Quoted 10 lines

This can always be sure that the pagecache has no invalid data after write finishes. I think why it use the truncate helper here is because it's safe and there shouldn't have any buffer write happen for DIO ?

But from my understanding the 'ceph_direct_read_write()' is still buggy. What if the page fault happen just after 'truncate_inode_pages_range()' ? Will this happen ? Should we leave this to use the file lock to guarantee it in user space ?

Thought ?

Again, we can't really predict what the outcome of two racing writes to the same area will do, so I don't see that there is a problem.