Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522// SPDX-License-Identifier: GPL-2.0-only
#include "dev.h"#include "fuse_i.h"
#include <linux/iomap.h>#include <linux/pagemap.h>
static int fuse_notify_poll(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_poll_wakeup_out outarg; int err;
if (size != sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
fuse_copy_finish(cs); return fuse_notify_poll_wakeup(fc, &outarg);}
static int fuse_notify_inval_inode(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_inval_inode_out outarg; int err;
if (size != sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err; fuse_copy_finish(cs);
down_read(&fc->killsb); err = fuse_reverse_inval_inode(fc, outarg.ino, outarg.off, outarg.len); up_read(&fc->killsb); return err;}
static int fuse_notify_inval_entry(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_inval_entry_out outarg; int err; char *buf; struct qstr name;
if (size < sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (outarg.namelen > fc->name_max) return -ENAMETOOLONG;
err = -EINVAL; if (size != sizeof(outarg) + outarg.namelen + 1) return -EINVAL;
buf = kzalloc(outarg.namelen + 1, GFP_KERNEL); if (!buf) return -ENOMEM;
name.name = buf; name.len = outarg.namelen; err = fuse_copy_one(cs, buf, outarg.namelen + 1); if (err) goto err; fuse_copy_finish(cs); buf[outarg.namelen] = 0;
down_read(&fc->killsb); err = fuse_reverse_inval_entry(fc, outarg.parent, 0, &name, outarg.flags); up_read(&fc->killsb);err: kfree(buf); return err;}
static int fuse_notify_delete(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_delete_out outarg; int err; char *buf; struct qstr name;
if (size < sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (outarg.namelen > fc->name_max) return -ENAMETOOLONG;
if (size != sizeof(outarg) + outarg.namelen + 1) return -EINVAL;
buf = kzalloc(outarg.namelen + 1, GFP_KERNEL); if (!buf) return -ENOMEM;
name.name = buf; name.len = outarg.namelen; err = fuse_copy_one(cs, buf, outarg.namelen + 1); if (err) goto err; fuse_copy_finish(cs); buf[outarg.namelen] = 0;
down_read(&fc->killsb); err = fuse_reverse_inval_entry(fc, outarg.parent, outarg.child, &name, 0); up_read(&fc->killsb);err: kfree(buf); return err;}
static int fuse_notify_store(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_store_out outarg; struct inode *inode; struct address_space *mapping; u64 nodeid; int err; unsigned int num; loff_t file_size; loff_t pos; loff_t end;
if (size < sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (size - sizeof(outarg) != outarg.size) return -EINVAL;
if (outarg.offset >= MAX_LFS_FILESIZE) return -EINVAL;
nodeid = outarg.nodeid; pos = outarg.offset; num = umin(outarg.size, MAX_LFS_FILESIZE - pos);
down_read(&fc->killsb);
err = -ENOENT; inode = fuse_ilookup(fc, nodeid, NULL); if (!inode) goto out_up_killsb; if (!S_ISREG(inode->i_mode)) { err = -EINVAL; goto out_iput; }
mapping = inode->i_mapping; file_size = i_size_read(inode); end = pos + num; if (end > file_size) { file_size = end; fuse_write_update_attr(inode, file_size, num); }
while (num) { struct folio *folio; unsigned int folio_offset; unsigned int nr_bytes; pgoff_t index = pos >> PAGE_SHIFT;
folio = filemap_grab_folio(mapping, index); err = PTR_ERR(folio); if (IS_ERR(folio)) goto out_iput;
folio_offset = offset_in_folio(folio, pos); nr_bytes = min(num, folio_size(folio) - folio_offset);
err = fuse_copy_folio(cs, &folio, folio_offset, nr_bytes); if (!folio_test_uptodate(folio) && !err && folio_offset == 0 && (nr_bytes == folio_size(folio) || file_size == end)) { folio_zero_segment(folio, nr_bytes, folio_size(folio)); iomap_folio_mark_uptodate(folio); } folio_unlock(folio); folio_put(folio);
if (err) goto out_iput;
pos += nr_bytes; num -= nr_bytes; }
err = 0;
out_iput: iput(inode);out_up_killsb: up_read(&fc->killsb); return err;}
struct fuse_retrieve_args { struct fuse_args_pages ap; struct fuse_notify_retrieve_in inarg;};
static void fuse_retrieve_end(struct fuse_args *args, int error){ struct fuse_retrieve_args *ra = container_of(args, typeof(*ra), ap.args);
release_pages(ra->ap.folios, ra->ap.num_folios); kfree(ra);}
static int fuse_retrieve(struct fuse_mount *fm, struct inode *inode, struct fuse_notify_retrieve_out *outarg){ int err; struct address_space *mapping = inode->i_mapping; loff_t file_size; unsigned int num; unsigned int offset; size_t total_len = 0; unsigned int num_pages; struct fuse_conn *fc = fm->fc; struct fuse_retrieve_args *ra; size_t args_size = sizeof(*ra); struct fuse_args_pages *ap; struct fuse_args *args; loff_t pos = outarg->offset;
offset = offset_in_page(pos); file_size = i_size_read(inode);
num = min(outarg->size, fc->max_write); if (pos > file_size) num = 0; else if (num > file_size - pos) num = file_size - pos;
num_pages = DIV_ROUND_UP(num + offset, PAGE_SIZE); num_pages = min(num_pages, fc->max_pages); num = min(num, num_pages << PAGE_SHIFT);
args_size += num_pages * (sizeof(ap->folios[0]) + sizeof(ap->descs[0]));
ra = kzalloc(args_size, GFP_KERNEL); if (!ra) return -ENOMEM;
ap = &ra->ap; ap->folios = (void *) (ra + 1); ap->descs = (void *) (ap->folios + num_pages);
args = &ap->args; args->nodeid = outarg->nodeid; args->opcode = FUSE_NOTIFY_REPLY; args->in_numargs = 3; args->in_pages = true; args->end = fuse_retrieve_end;
while (num && ap->num_folios < num_pages) { struct folio *folio; unsigned int folio_offset; unsigned int nr_bytes; pgoff_t index = pos >> PAGE_SHIFT;
folio = filemap_get_folio(mapping, index); if (IS_ERR(folio)) break; if (!folio_test_uptodate(folio)) { folio_put(folio); break; }
folio_offset = offset_in_folio(folio, pos); nr_bytes = min(folio_size(folio) - folio_offset, num);
ap->folios[ap->num_folios] = folio; ap->descs[ap->num_folios].offset = folio_offset; ap->descs[ap->num_folios].length = nr_bytes; ap->num_folios++;
pos += nr_bytes; num -= nr_bytes; total_len += nr_bytes; } ra->inarg.offset = outarg->offset; ra->inarg.size = total_len; fuse_set_zero_arg0(args); args->in_args[1].size = sizeof(ra->inarg); args->in_args[1].value = &ra->inarg; args->in_args[2].size = total_len;
err = fuse_simple_notify_reply(fm, args, outarg->notify_unique); if (err) fuse_retrieve_end(args, err);
return err;}
static int fuse_notify_retrieve(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_retrieve_out outarg; struct fuse_mount *fm; struct inode *inode; u64 nodeid; int err;
if (size != sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
fuse_copy_finish(cs);
if (outarg.offset >= MAX_LFS_FILESIZE) return -EINVAL;
down_read(&fc->killsb); err = -ENOENT; nodeid = outarg.nodeid;
inode = fuse_ilookup(fc, nodeid, &fm); if (inode) { err = -EINVAL; if (S_ISREG(inode->i_mode)) err = fuse_retrieve(fm, inode, &outarg); iput(inode); } up_read(&fc->killsb);
return err;}
static int fuse_notify_resend(struct fuse_conn *fc){ fuse_chan_resend(fc->chan); return 0;}
/* * Increments the fuse connection epoch. This will cause dentries and * readdir caches from previous epochs to be invalidated. Additionally, * if inval_wq is set, a work queue is scheduled to trigger the invalidation. */static int fuse_notify_inc_epoch(struct fuse_conn *fc){ atomic_inc(&fc->epoch); if (inval_wq) schedule_work(&fc->epoch_work);
return 0;}
static int fuse_notify_prune(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_prune_out outarg; const unsigned int batch = 512; u64 *nodeids __free(kfree) = kmalloc(sizeof(u64) * batch, GFP_KERNEL); unsigned int num, i; int err;
if (!nodeids) return -ENOMEM;
if (size < sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (size - sizeof(outarg) != array_size(outarg.count, sizeof(u64))) return -EINVAL;
for (; outarg.count; outarg.count -= num) { num = min(batch, outarg.count); err = fuse_copy_one(cs, nodeids, num * sizeof(u64)); if (err) return err;
scoped_guard(rwsem_read, &fc->killsb) { for (i = 0; i < num; i++) fuse_try_prune_one_inode(fc, nodeids[i]); } } return 0;}
static int fuse_notify_backing_remove(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_backing_remove_out outarg; int err;
if (!IS_ENABLED(CONFIG_FUSE_PASSTHROUGH)) return -EOPNOTSUPP;
if (size != sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (outarg.reserved) return -EINVAL;
if (!fc->backing_id_64) return -EINVAL;
return fuse_backing_close_64(fc, outarg.backing_id);}
static int fuse_notify_map(struct fuse_conn *fc, unsigned int size, struct fuse_copy_state *cs){ struct fuse_notify_backing_map_out outarg; struct fuse_extent *ext __free(kvfree) = NULL; int err;
if (size < sizeof(outarg)) return -EINVAL;
err = fuse_copy_one(cs, &outarg, sizeof(outarg)); if (err) return err;
if (!fc->backing_id_64) return -EINVAL;
if (outarg.num_extents > FUSE_MAX_EXTENTS) return -EINVAL;
size -= sizeof(outarg); if (size != outarg.num_extents * sizeof(*ext)) return -EINVAL;
if (outarg.reserved[0] != 0 || outarg.reserved[1] != 0) return -EINVAL;
if (outarg.flags & ~(FUSE_BACKING_MAP_CREATE | FUSE_BACKING_MAP_CYCLIC)) return -EINVAL;
if (!IS_ENABLED(CONFIG_FUSE_PASSTHROUGH)) return -EOPNOTSUPP;
ext = kvmalloc_objs(*ext, outarg.num_extents); if (!ext) return -ENOMEM;
err = fuse_copy_one(cs, ext, size); if (err) return err;
return fuse_ext_map_populate(fc, &outarg, ext);}
int fuse_notify(struct fuse_conn *fc, enum fuse_notify_code code, unsigned int size, struct fuse_copy_state *cs){ switch (code) { case FUSE_NOTIFY_POLL: return fuse_notify_poll(fc, size, cs);
case FUSE_NOTIFY_INVAL_INODE: return fuse_notify_inval_inode(fc, size, cs);
case FUSE_NOTIFY_INVAL_ENTRY: return fuse_notify_inval_entry(fc, size, cs);
case FUSE_NOTIFY_STORE: return fuse_notify_store(fc, size, cs);
case FUSE_NOTIFY_RETRIEVE: return fuse_notify_retrieve(fc, size, cs);
case FUSE_NOTIFY_DELETE: return fuse_notify_delete(fc, size, cs);
case FUSE_NOTIFY_RESEND: return fuse_notify_resend(fc);
case FUSE_NOTIFY_INC_EPOCH: return fuse_notify_inc_epoch(fc);
case FUSE_NOTIFY_PRUNE: return fuse_notify_prune(fc, size, cs);
case FUSE_NOTIFY_BACKING_REMOVE: return fuse_notify_backing_remove(fc, size, cs);
case FUSE_NOTIFY_BACKING_MAP: return fuse_notify_map(fc, size, cs);
default: return -EINVAL; }}