| Message ID | 20210723205840.299280-8-agruenba@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | gfs2: Fix mmap + page fault deadlocks | expand |
On Fri 23-07-21 22:58:40, Andreas Gruenbacher wrote: > Also disable page faults during direct I/O requests and implement the same kind > of retry logic as in the buffered I/O case. > > Direct I/O requests differ from buffered I/O requests in that they use > bio_iov_iter_get_pages for grabbing page references and faulting in pages > instead of triggering real page faults. Those manual page faults can be > disabled with the iocb->noio flag. > > Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com> > --- > fs/gfs2/file.c | 34 +++++++++++++++++++++++++++++++++- > 1 file changed, 33 insertions(+), 1 deletion(-) > > diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c > index f66ac7f56f6d..7986f3be69d2 100644 > --- a/fs/gfs2/file.c > +++ b/fs/gfs2/file.c > @@ -782,21 +782,41 @@ static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to, > struct file *file = iocb->ki_filp; > struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); > size_t count = iov_iter_count(to); > + size_t written = 0; > ssize_t ret; > > + /* > + * In this function, we disable page faults when we're holding the > + * inode glock while doing I/O. If a page fault occurs, we drop the > + * inode glock, fault in the pages manually, and then we retry. Other > + * than in gfs2_file_read_iter, iomap_dio_rw can trigger implicit as > + * well as manual page faults, and we need to disable both kinds > + * separately. > + */ > + > if (!count) > return 0; /* skip atime */ > > gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); > +retry: > ret = gfs2_glock_nq(gh); > if (ret) > goto out_uninit; > > + pagefault_disable(); Is there any use in pagefault_disable() here? iomap_dio_rw() should not trigger any page faults anyway, should it? Honza
On Mon 26-07-21 19:50:23, Andreas Grünbacher wrote: > Jan Kara <jack@suse.cz> schrieb am Mo., 26. Juli 2021, 19:10: > > > On Fri 23-07-21 22:58:40, Andreas Gruenbacher wrote: > > > Also disable page faults during direct I/O requests and implement the > > same kind > > > of retry logic as in the buffered I/O case. > > > > > > Direct I/O requests differ from buffered I/O requests in that they use > > > bio_iov_iter_get_pages for grabbing page references and faulting in pages > > > instead of triggering real page faults. Those manual page faults can be > > > disabled with the iocb->noio flag. > > > > > > Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com> > > > --- > > > fs/gfs2/file.c | 34 +++++++++++++++++++++++++++++++++- > > > 1 file changed, 33 insertions(+), 1 deletion(-) > > > > > > diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c > > > index f66ac7f56f6d..7986f3be69d2 100644 > > > --- a/fs/gfs2/file.c > > > +++ b/fs/gfs2/file.c > > > @@ -782,21 +782,41 @@ static ssize_t gfs2_file_direct_read(struct kiocb > > *iocb, struct iov_iter *to, > > > struct file *file = iocb->ki_filp; > > > struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); > > > size_t count = iov_iter_count(to); > > > + size_t written = 0; > > > ssize_t ret; > > > > > > + /* > > > + * In this function, we disable page faults when we're holding the > > > + * inode glock while doing I/O. If a page fault occurs, we drop > > the > > > + * inode glock, fault in the pages manually, and then we retry. > > Other > > > + * than in gfs2_file_read_iter, iomap_dio_rw can trigger implicit > > as > > > + * well as manual page faults, and we need to disable both kinds > > > + * separately. > > > + */ > > > + > > > if (!count) > > > return 0; /* skip atime */ > > > > > > gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); > > > +retry: > > > ret = gfs2_glock_nq(gh); > > > if (ret) > > > goto out_uninit; > > > > > > + pagefault_disable(); > > > > Is there any use in pagefault_disable() here? iomap_dio_rw() should not > > trigger any page faults anyway, should it? > > > > It can trigger physical page faults when reading from holes. Aha, good point. Maybe even worth a comment at this site? Thanks for explanation! Honza
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c index f66ac7f56f6d..7986f3be69d2 100644 --- a/fs/gfs2/file.c +++ b/fs/gfs2/file.c @@ -782,21 +782,41 @@ static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to, struct file *file = iocb->ki_filp; struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); size_t count = iov_iter_count(to); + size_t written = 0; ssize_t ret; + /* + * In this function, we disable page faults when we're holding the + * inode glock while doing I/O. If a page fault occurs, we drop the + * inode glock, fault in the pages manually, and then we retry. Other + * than in gfs2_file_read_iter, iomap_dio_rw can trigger implicit as + * well as manual page faults, and we need to disable both kinds + * separately. + */ + if (!count) return 0; /* skip atime */ gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); +retry: ret = gfs2_glock_nq(gh); if (ret) goto out_uninit; + pagefault_disable(); + to->noio = true; ret = iomap_dio_rw(iocb, to, &gfs2_iomap_ops, NULL, 0); + to->noio = false; + pagefault_enable(); + gfs2_glock_dq(gh); + if (ret > 0) + written += ret; + if (unlikely(ret == -EFAULT) && fault_in_iov_iter(to)) + goto retry; out_uninit: gfs2_holder_uninit(gh); - return ret; + return written ? written : ret; } static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from, @@ -809,6 +829,12 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from, loff_t offset = iocb->ki_pos; ssize_t ret; + /* + * In this function, we disable page faults when we're holding the + * inode glock while doing I/O. If a page fault occurs, we drop the + * inode glock, fault in the pages manually, and then we retry. + */ + /* * Deferred lock, even if its a write, since we do no allocation on * this path. All we need to change is the atime, and this lock mode @@ -818,6 +844,7 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from, * VFS does. */ gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); +retry: ret = gfs2_glock_nq(gh); if (ret) goto out_uninit; @@ -826,11 +853,16 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from, if (offset + len > i_size_read(&ip->i_inode)) goto out; + from->noio = true; ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL, 0); + from->noio = false; + if (ret == -ENOTBLK) ret = 0; out: gfs2_glock_dq(gh); + if (unlikely(ret == -EFAULT) && fault_in_iov_iter(from)) + goto retry; out_uninit: gfs2_holder_uninit(gh); return ret;
Also disable page faults during direct I/O requests and implement the same kind of retry logic as in the buffered I/O case. Direct I/O requests differ from buffered I/O requests in that they use bio_iov_iter_get_pages for grabbing page references and faulting in pages instead of triggering real page faults. Those manual page faults can be disabled with the iocb->noio flag. Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com> --- fs/gfs2/file.c | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-)