microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

orangefs: Convert launder_page to launder_folio 

OrangeFS launders its pages from a number of locations, so add a
small amount of folio usage to its callers where it makes sense.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Tested-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Acked-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Tested-by: Mike Marshall <hubcap@omnibond.com> # orangefs
Tested-by: David Howells <dhowells@redhat.com> # afs
This commit is contained in:
Matthew Wilcox (Oracle) 2022-02-09 20:21:58 +00:00
Родитель 15a30ab2b3
Коммит eabf038f4e
1 изменённых файлов: 36 добавлений и 33 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

69
fs/orangefs/inode.c
Просмотреть файл

@ -243,7 +243,7 @@ static int orangefs_writepages(struct address_space *mapping,
return ret; return ret;
} }
static int orangefs_launder_page(struct page *); static int orangefs_launder_folio(struct folio *);
static void orangefs_readahead(struct readahead_control *rac) static void orangefs_readahead(struct readahead_control *rac)
{ {
@ -290,14 +290,15 @@ static void orangefs_readahead(struct readahead_control *rac)
static int orangefs_readpage(struct file *file, struct page *page) static int orangefs_readpage(struct file *file, struct page *page)
{ {
struct folio *folio = page_folio(page);
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
struct iov_iter iter; struct iov_iter iter;
struct bio_vec bv; struct bio_vec bv;
ssize_t ret; ssize_t ret;
loff_t off; /* offset into this page */ loff_t off; /* offset into this page */
if (PageDirty(page)) if (folio_test_dirty(folio))
orangefs_launder_page(page); orangefs_launder_folio(folio);
off = page_offset(page); off = page_offset(page);
bv.bv_page = page; bv.bv_page = page;
@ -330,6 +331,7 @@ static int orangefs_write_begin(struct file *file,
void **fsdata) void **fsdata)
{ {
struct orangefs_write_range *wr; struct orangefs_write_range *wr;
struct folio *folio;
struct page *page; struct page *page;
pgoff_t index; pgoff_t index;
int ret; int ret;
@ -341,27 +343,28 @@ static int orangefs_write_begin(struct file *file,
return -ENOMEM; return -ENOMEM;
*pagep = page; *pagep = page;
folio = page_folio(page);
if (PageDirty(page) && !PagePrivate(page)) { if (folio_test_dirty(folio) && !folio_test_private(folio)) {
/* /*
* Should be impossible. If it happens, launder the page * Should be impossible. If it happens, launder the page
* since we don't know what's dirty. This will WARN in * since we don't know what's dirty. This will WARN in
* orangefs_writepage_locked. * orangefs_writepage_locked.
*/ */
ret = orangefs_launder_page(page); ret = orangefs_launder_folio(folio);
if (ret) if (ret)
return ret; return ret;
} }
if (PagePrivate(page)) { if (folio_test_private(folio)) {
struct orangefs_write_range *wr; struct orangefs_write_range *wr;
wr = (struct orangefs_write_range *)page_private(page); wr = folio_get_private(folio);
if (wr->pos + wr->len == pos && if (wr->pos + wr->len == pos &&
uid_eq(wr->uid, current_fsuid()) && uid_eq(wr->uid, current_fsuid()) &&
gid_eq(wr->gid, current_fsgid())) { gid_eq(wr->gid, current_fsgid())) {
wr->len += len; wr->len += len;
goto okay; goto okay;
} else { } else {
ret = orangefs_launder_page(page); ret = orangefs_launder_folio(folio);
if (ret) if (ret)
return ret; return ret;
} }
@ -375,7 +378,7 @@ static int orangefs_write_begin(struct file *file,
wr->len = len; wr->len = len;
wr->uid = current_fsuid(); wr->uid = current_fsuid();
wr->gid = current_fsgid(); wr->gid = current_fsgid();
attach_page_private(page, wr); folio_attach_private(folio, wr);
okay: okay:
return 0; return 0;
} }
@ -481,7 +484,7 @@ static void orangefs_invalidate_folio(struct folio *folio,
* Thus the following runs if wr was modified above. * Thus the following runs if wr was modified above.
*/ */
orangefs_launder_page(&folio->page); orangefs_launder_folio(folio);
} }
static int orangefs_releasepage(struct page *page, gfp_t foo) static int orangefs_releasepage(struct page *page, gfp_t foo)
@ -494,17 +497,17 @@ static void orangefs_freepage(struct page *page)
kfree(detach_page_private(page)); kfree(detach_page_private(page));
} }
static int orangefs_launder_page(struct page *page) static int orangefs_launder_folio(struct folio *folio)
{ {
int r = 0; int r = 0;
struct writeback_control wbc = { struct writeback_control wbc = {
.sync_mode = WB_SYNC_ALL, .sync_mode = WB_SYNC_ALL,
.nr_to_write = 0, .nr_to_write = 0,
}; };
wait_on_page_writeback(page); folio_wait_writeback(folio);
if (clear_page_dirty_for_io(page)) { if (folio_clear_dirty_for_io(folio)) {
r = orangefs_writepage_locked(page, &wbc); r = orangefs_writepage_locked(&folio->page, &wbc);
end_page_writeback(page); folio_end_writeback(folio);
} }
return r; return r;
} }
@ -637,13 +640,13 @@ static const struct address_space_operations orangefs_address_operations = {
.invalidate_folio = orangefs_invalidate_folio, .invalidate_folio = orangefs_invalidate_folio,
.releasepage = orangefs_releasepage, .releasepage = orangefs_releasepage,
.freepage = orangefs_freepage, .freepage = orangefs_freepage,
.launder_page = orangefs_launder_page, .launder_folio = orangefs_launder_folio,
.direct_IO = orangefs_direct_IO, .direct_IO = orangefs_direct_IO,
}; };
vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf) vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
{ {
struct page *page = vmf->page; struct folio *folio = page_folio(vmf->page);
struct inode *inode = file_inode(vmf->vma->vm_file); struct inode *inode = file_inode(vmf->vma->vm_file);
struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
unsigned long *bitlock = &orangefs_inode->bitlock; unsigned long *bitlock = &orangefs_inode->bitlock;
@ -657,27 +660,27 @@ vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
goto out; goto out;
} }
lock_page(page); folio_lock(folio);
if (PageDirty(page) && !PagePrivate(page)) { if (folio_test_dirty(folio) && !folio_test_private(folio)) {
/* /*
* Should be impossible. If it happens, launder the page * Should be impossible. If it happens, launder the folio
* since we don't know what's dirty. This will WARN in * since we don't know what's dirty. This will WARN in
* orangefs_writepage_locked. * orangefs_writepage_locked.
*/ */
if (orangefs_launder_page(page)) { if (orangefs_launder_folio(folio)) {
ret = VM_FAULT_LOCKED|VM_FAULT_RETRY; ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
goto out; goto out;
} }
} }
if (PagePrivate(page)) { if (folio_test_private(folio)) {
wr = (struct orangefs_write_range *)page_private(page); wr = folio_get_private(folio);
if (uid_eq(wr->uid, current_fsuid()) && if (uid_eq(wr->uid, current_fsuid()) &&
gid_eq(wr->gid, current_fsgid())) { gid_eq(wr->gid, current_fsgid())) {
wr->pos = page_offset(page); wr->pos = page_offset(vmf->page);
wr->len = PAGE_SIZE; wr->len = PAGE_SIZE;
goto okay; goto okay;
} else { } else {
if (orangefs_launder_page(page)) { if (orangefs_launder_folio(folio)) {
ret = VM_FAULT_LOCKED|VM_FAULT_RETRY; ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
goto out; goto out;
} }
@ -688,27 +691,27 @@ vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
ret = VM_FAULT_LOCKED|VM_FAULT_RETRY; ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
goto out; goto out;
} }
wr->pos = page_offset(page); wr->pos = page_offset(vmf->page);
wr->len = PAGE_SIZE; wr->len = PAGE_SIZE;
wr->uid = current_fsuid(); wr->uid = current_fsuid();
wr->gid = current_fsgid(); wr->gid = current_fsgid();
attach_page_private(page, wr); folio_attach_private(folio, wr);
okay: okay:
file_update_time(vmf->vma->vm_file); file_update_time(vmf->vma->vm_file);
if (page->mapping != inode->i_mapping) { if (folio->mapping != inode->i_mapping) {
unlock_page(page); folio_unlock(folio);
ret = VM_FAULT_LOCKED|VM_FAULT_NOPAGE; ret = VM_FAULT_LOCKED|VM_FAULT_NOPAGE;
goto out; goto out;
} }
/* /*
* We mark the page dirty already here so that when freeze is in * We mark the folio dirty already here so that when freeze is in
* progress, we are guaranteed that writeback during freezing will * progress, we are guaranteed that writeback during freezing will
* see the dirty page and writeprotect it again. * see the dirty folio and writeprotect it again.
*/ */
set_page_dirty(page); folio_mark_dirty(folio);
wait_for_stable_page(page); folio_wait_stable(folio);
ret = VM_FAULT_LOCKED; ret = VM_FAULT_LOCKED;
out: out:
sb_end_pagefault(inode->i_sb); sb_end_pagefault(inode->i_sb);