github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-22 06:01:53 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

vfs-6.15-rc1.orangefs

Browse Source 
-----BEGIN PGP SIGNATURE-----
 
 iHUEABYKAB0WIQRAhzRXHqcMeLMyaSiRxhvAZXjcogUCZ90sOwAKCRCRxhvAZXjc
 or8RAQCmNnIcN0ARuJqJkgdi0BgGBCHX29y/xdYUXjNSidOozwD/bZijiIocowfo
 Nw5qT/QgMUtJk/O0df2nsp360AODtAo=
 =VrN4
 -----END PGP SIGNATURE-----

Merge tag 'vfs-6.15-rc1.orangefs' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs

Pull vfs orangefs updates from Christian Brauner:
 "This contains the work to remove orangefs_writepage() and partially
  convert it to folios.

  A few regular bugfixes are included as well"

* tag 'vfs-6.15-rc1.orangefs' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
  orangefs: Convert orangefs_writepages to contain an array of folios
  orangefs: Simplify bvec setup in orangefs_writepages_work()
  orangefs: Unify error & success paths in orangefs_writepages_work()
  orangefs: Pass mapping to orangefs_writepages_work()
  orangefs: Convert orangefs_writepage_locked() to take a folio
  orangefs: Remove orangefs_writepage()
  orangefs: make open_for_read and open_for_write boolean
  orangefs: Move s_kmod_keyword_mask_map to orangefs-debugfs.c
  orangefs: Do not truncate file size
This commit is contained in:
Linus Torvalds 2025-03-24 13:17:54 -07:00
commit d41066dd76
4 changed files with 109 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/orangefs/file.c
View File

@ -57,8 +57,8 @@ ssize_t wait_for_direct_io(enum ORANGEFS_io_type type, struct inode *inode,
int buffer_index;
ssize_t ret;
size_t copy_amount;
int open_for_read;
int open_for_write;
bool open_for_read;
bool open_for_write;
new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO);
if (!new_op)

149
fs/orangefs/inode.c
View File

@ -16,22 +16,22 @@
#include "orangefs-kernel.h"
#include "orangefs-bufmap.h"
static int orangefs_writepage_locked(struct page *page,
struct writeback_control *wbc)
static int orangefs_writepage_locked(struct folio *folio,
struct writeback_control *wbc)
{
struct inode *inode = page->mapping->host;
struct inode *inode = folio->mapping->host;
struct orangefs_write_range *wr = NULL;
struct iov_iter iter;
struct bio_vec bv;
size_t len, wlen;
size_t wlen;
ssize_t ret;
loff_t off;
loff_t len, off;
set_page_writeback(page);
folio_start_writeback(folio);
len = i_size_read(inode);
if (PagePrivate(page)) {
wr = (struct orangefs_write_range *)page_private(page);
if (folio->private) {
wr = folio->private;
WARN_ON(wr->pos >= len);
off = wr->pos;
if (off + wr->len > len)
@ -40,36 +40,27 @@ static int orangefs_writepage_locked(struct page *page,
wlen = wr->len;
} else {
WARN_ON(1);
off = page_offset(page);
if (off + PAGE_SIZE > len)
off = folio_pos(folio);
wlen = folio_size(folio);
if (wlen > len - off)
wlen = len - off;
else
wlen = PAGE_SIZE;
}
/* Should've been handled in orangefs_invalidate_folio. */
WARN_ON(off == len || off + wlen > len);
WARN_ON(wlen == 0);
bvec_set_page(&bv, page, wlen, off % PAGE_SIZE);
bvec_set_folio(&bv, folio, wlen, offset_in_folio(folio, off));
iov_iter_bvec(&iter, ITER_SOURCE, &bv, 1, wlen);
ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, wlen,
len, wr, NULL, NULL);
if (ret < 0) {
mapping_set_error(page->mapping, ret);
mapping_set_error(folio->mapping, ret);
} else {
ret = 0;
}
kfree(detach_page_private(page));
return ret;
}
static int orangefs_writepage(struct page *page, struct writeback_control *wbc)
{
int ret;
ret = orangefs_writepage_locked(page, wbc);
unlock_page(page);
end_page_writeback(page);
kfree(folio_detach_private(folio));
return ret;
}
@ -79,33 +70,33 @@ struct orangefs_writepages {
kuid_t uid;
kgid_t gid;
int maxpages;
int npages;
struct page **pages;
int nfolios;
struct address_space *mapping;
struct folio **folios;
struct bio_vec *bv;
};
static int orangefs_writepages_work(struct orangefs_writepages *ow,
struct writeback_control *wbc)
struct writeback_control *wbc)
{
struct inode *inode = ow->pages[0]->mapping->host;
struct inode *inode = ow->mapping->host;
struct orangefs_write_range *wrp, wr;
struct iov_iter iter;
ssize_t ret;
size_t len;
loff_t off;
size_t start;
loff_t len, off;
int i;
len = i_size_read(inode);
for (i = 0; i < ow->npages; i++) {
set_page_writeback(ow->pages[i]);
bvec_set_page(&ow->bv[i], ow->pages[i],
min(page_offset(ow->pages[i]) + PAGE_SIZE,
ow->off + ow->len) -
max(ow->off, page_offset(ow->pages[i])),
i == 0 ? ow->off - page_offset(ow->pages[i]) : 0);
start = offset_in_folio(ow->folios[0], ow->off);
for (i = 0; i < ow->nfolios; i++) {
folio_start_writeback(ow->folios[i]);
bvec_set_folio(&ow->bv[i], ow->folios[i],
folio_size(ow->folios[i]) - start, start);
start = 0;
}
iov_iter_bvec(&iter, ITER_SOURCE, ow->bv, ow->npages, ow->len);
iov_iter_bvec(&iter, ITER_SOURCE, ow->bv, ow->nfolios, ow->len);
WARN_ON(ow->off >= len);
if (ow->off + ow->len > len)
@ -116,40 +107,24 @@ static int orangefs_writepages_work(struct orangefs_writepages *ow,
wr.gid = ow->gid;
ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, ow->len,
0, &wr, NULL, NULL);
if (ret < 0) {
for (i = 0; i < ow->npages; i++) {
mapping_set_error(ow->pages[i]->mapping, ret);
if (PagePrivate(ow->pages[i])) {
wrp = (struct orangefs_write_range *)
page_private(ow->pages[i]);
ClearPagePrivate(ow->pages[i]);
put_page(ow->pages[i]);
kfree(wrp);
}
end_page_writeback(ow->pages[i]);
unlock_page(ow->pages[i]);
}
} else {
if (ret < 0)
mapping_set_error(ow->mapping, ret);
else
ret = 0;
for (i = 0; i < ow->npages; i++) {
if (PagePrivate(ow->pages[i])) {
wrp = (struct orangefs_write_range *)
page_private(ow->pages[i]);
ClearPagePrivate(ow->pages[i]);
put_page(ow->pages[i]);
kfree(wrp);
}
end_page_writeback(ow->pages[i]);
unlock_page(ow->pages[i]);
}
for (i = 0; i < ow->nfolios; i++) {
wrp = folio_detach_private(ow->folios[i]);
kfree(wrp);
folio_end_writeback(ow->folios[i]);
folio_unlock(ow->folios[i]);
}
return ret;
}
static int orangefs_writepages_callback(struct folio *folio,
struct writeback_control *wbc, void *data)
struct writeback_control *wbc, struct orangefs_writepages *ow)
{
struct orangefs_writepages *ow = data;
struct orangefs_write_range *wr = folio->private;
int ret;
@ -162,41 +137,41 @@ static int orangefs_writepages_callback(struct folio *folio,
}
ret = -1;
if (ow->npages == 0) {
if (ow->nfolios == 0) {
ow->off = wr->pos;
ow->len = wr->len;
ow->uid = wr->uid;
ow->gid = wr->gid;
ow->pages[ow->npages++] = &folio->page;
ow->folios[ow->nfolios++] = folio;
ret = 0;
goto done;
}
if (!uid_eq(ow->uid, wr->uid) || !gid_eq(ow->gid, wr->gid)) {
orangefs_writepages_work(ow, wbc);
ow->npages = 0;
ow->nfolios = 0;
ret = -1;
goto done;
}
if (ow->off + ow->len == wr->pos) {
ow->len += wr->len;
ow->pages[ow->npages++] = &folio->page;
ow->folios[ow->nfolios++] = folio;
ret = 0;
goto done;
}
done:
if (ret == -1) {
if (ow->npages) {
if (ow->nfolios) {
orangefs_writepages_work(ow, wbc);
ow->npages = 0;
ow->nfolios = 0;
}
ret = orangefs_writepage_locked(&folio->page, wbc);
ret = orangefs_writepage_locked(folio, wbc);
mapping_set_error(folio->mapping, ret);
folio_unlock(folio);
folio_end_writeback(folio);
} else {
if (ow->npages == ow->maxpages) {
if (ow->nfolios == ow->maxpages) {
orangefs_writepages_work(ow, wbc);
ow->npages = 0;
ow->nfolios = 0;
}
}
return ret;
@ -207,31 +182,35 @@ static int orangefs_writepages(struct address_space *mapping,
{
struct orangefs_writepages *ow;
struct blk_plug plug;
int ret;
int error;
struct folio *folio = NULL;
ow = kzalloc(sizeof(struct orangefs_writepages), GFP_KERNEL);
if (!ow)
return -ENOMEM;
ow->maxpages = orangefs_bufmap_size_query()/PAGE_SIZE;
ow->pages = kcalloc(ow->maxpages, sizeof(struct page *), GFP_KERNEL);
if (!ow->pages) {
ow->folios = kcalloc(ow->maxpages, sizeof(struct folio *), GFP_KERNEL);
if (!ow->folios) {
kfree(ow);
return -ENOMEM;
}
ow->bv = kcalloc(ow->maxpages, sizeof(struct bio_vec), GFP_KERNEL);
if (!ow->bv) {
kfree(ow->pages);
kfree(ow->folios);
kfree(ow);
return -ENOMEM;
}
ow->mapping = mapping;
blk_start_plug(&plug);
ret = write_cache_pages(mapping, wbc, orangefs_writepages_callback, ow);
if (ow->npages)
ret = orangefs_writepages_work(ow, wbc);
while ((folio = writeback_iter(mapping, wbc, folio, &error)))
error = orangefs_writepages_callback(folio, wbc, ow);
if (ow->nfolios)
error = orangefs_writepages_work(ow, wbc);
blk_finish_plug(&plug);
kfree(ow->pages);
kfree(ow->folios);
kfree(ow->bv);
kfree(ow);
return ret;
return error;
}
static int orangefs_launder_folio(struct folio *);
@ -484,7 +463,7 @@ static int orangefs_launder_folio(struct folio *folio)
};
folio_wait_writeback(folio);
if (folio_clear_dirty_for_io(folio)) {
r = orangefs_writepage_locked(&folio->page, &wbc);
r = orangefs_writepage_locked(folio, &wbc);
folio_end_writeback(folio);
}
return r;
@ -606,7 +585,6 @@ static ssize_t orangefs_direct_IO(struct kiocb *iocb,
/** ORANGEFS2 implementation of address space operations */
static const struct address_space_operations orangefs_address_operations = {
.writepage = orangefs_writepage,
.readahead = orangefs_readahead,
.read_folio = orangefs_read_folio,
.writepages = orangefs_writepages,
@ -616,6 +594,7 @@ static const struct address_space_operations orangefs_address_operations = {
.invalidate_folio = orangefs_invalidate_folio,
.release_folio = orangefs_release_folio,
.free_folio = orangefs_free_folio,
.migrate_folio = filemap_migrate_folio,
.launder_folio = orangefs_launder_folio,
.direct_IO = orangefs_direct_IO,
};

43
fs/orangefs/orangefs-debug.h
View File

@ -43,47 +43,4 @@
#define GOSSIP_MAX_NR 16
#define GOSSIP_MAX_DEBUG (((__u64)1 << GOSSIP_MAX_NR) - 1)
/* a private internal type */
struct __keyword_mask_s {
const char *keyword;
__u64 mask_val;
};
/*
* Map all kmod keywords to kmod debug masks here. Keep this
* structure "packed":
*
* "all" is always last...
*
* keyword mask_val index
* foo 1 0
* bar 2 1
* baz 4 2
* qux 8 3
* . . .
*/
static struct __keyword_mask_s s_kmod_keyword_mask_map[] = {
{"super", GOSSIP_SUPER_DEBUG},
{"inode", GOSSIP_INODE_DEBUG},
{"file", GOSSIP_FILE_DEBUG},
{"dir", GOSSIP_DIR_DEBUG},
{"utils", GOSSIP_UTILS_DEBUG},
{"wait", GOSSIP_WAIT_DEBUG},
{"acl", GOSSIP_ACL_DEBUG},
{"dcache", GOSSIP_DCACHE_DEBUG},
{"dev", GOSSIP_DEV_DEBUG},
{"name", GOSSIP_NAME_DEBUG},
{"bufmap", GOSSIP_BUFMAP_DEBUG},
{"cache", GOSSIP_CACHE_DEBUG},
{"debugfs", GOSSIP_DEBUGFS_DEBUG},
{"xattr", GOSSIP_XATTR_DEBUG},
{"init", GOSSIP_INIT_DEBUG},
{"sysfs", GOSSIP_SYSFS_DEBUG},
{"none", GOSSIP_NO_DEBUG},
{"all", GOSSIP_MAX_DEBUG}
};
static const int num_kmod_keyword_mask_map = (int)
(ARRAY_SIZE(s_kmod_keyword_mask_map));
#endif /* __ORANGEFS_DEBUG_H */

43
fs/orangefs/orangefs-debugfs.c
View File

@ -44,6 +44,49 @@
#include "protocol.h"
#include "orangefs-kernel.h"
/* a private internal type */
struct __keyword_mask_s {
const char *keyword;
__u64 mask_val;
};
/*
* Map all kmod keywords to kmod debug masks here. Keep this
* structure "packed":
*
* "all" is always last...
*
* keyword mask_val index
* foo 1 0
* bar 2 1
* baz 4 2
* qux 8 3
* . . .
*/
static struct __keyword_mask_s s_kmod_keyword_mask_map[] = {
{"super", GOSSIP_SUPER_DEBUG},
{"inode", GOSSIP_INODE_DEBUG},
{"file", GOSSIP_FILE_DEBUG},
{"dir", GOSSIP_DIR_DEBUG},
{"utils", GOSSIP_UTILS_DEBUG},
{"wait", GOSSIP_WAIT_DEBUG},
{"acl", GOSSIP_ACL_DEBUG},
{"dcache", GOSSIP_DCACHE_DEBUG},
{"dev", GOSSIP_DEV_DEBUG},
{"name", GOSSIP_NAME_DEBUG},
{"bufmap", GOSSIP_BUFMAP_DEBUG},
{"cache", GOSSIP_CACHE_DEBUG},
{"debugfs", GOSSIP_DEBUGFS_DEBUG},
{"xattr", GOSSIP_XATTR_DEBUG},
{"init", GOSSIP_INIT_DEBUG},
{"sysfs", GOSSIP_SYSFS_DEBUG},
{"none", GOSSIP_NO_DEBUG},
{"all", GOSSIP_MAX_DEBUG}
};
static const int num_kmod_keyword_mask_map = (int)
(ARRAY_SIZE(s_kmod_keyword_mask_map));
#define DEBUG_HELP_STRING_SIZE 4096
#define HELP_STRING_UNINITIALIZED \
"Client Debug Keywords are unknown until the first time\n" \