Lines Matching +full:blocking +full:- +full:io
3 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
32 inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY); in fuse_send_open()
33 if (!fc->atomic_o_trunc) in fuse_send_open()
55 ff->fc = fc; in fuse_file_alloc()
56 ff->reserved_req = fuse_request_alloc(0); in fuse_file_alloc()
57 if (unlikely(!ff->reserved_req)) { in fuse_file_alloc()
62 INIT_LIST_HEAD(&ff->write_entry); in fuse_file_alloc()
63 refcount_set(&ff->count, 1); in fuse_file_alloc()
64 RB_CLEAR_NODE(&ff->polled_node); in fuse_file_alloc()
65 init_waitqueue_head(&ff->poll_wait); in fuse_file_alloc()
67 spin_lock(&fc->lock); in fuse_file_alloc()
68 ff->kh = ++fc->khctr; in fuse_file_alloc()
69 spin_unlock(&fc->lock); in fuse_file_alloc()
76 fuse_request_free(ff->reserved_req); in fuse_file_free()
82 refcount_inc(&ff->count); in fuse_file_get()
88 iput(req->misc.release.inode); in fuse_release_end()
93 if (refcount_dec_and_test(&ff->count)) { in fuse_file_put()
94 struct fuse_req *req = ff->reserved_req; in fuse_file_put()
96 if (ff->fc->no_open && !isdir) { in fuse_file_put()
101 __clear_bit(FR_BACKGROUND, &req->flags); in fuse_file_put()
102 iput(req->misc.release.inode); in fuse_file_put()
103 fuse_put_request(ff->fc, req); in fuse_file_put()
105 __set_bit(FR_FORCE, &req->flags); in fuse_file_put()
106 __clear_bit(FR_BACKGROUND, &req->flags); in fuse_file_put()
107 fuse_request_send(ff->fc, req); in fuse_file_put()
108 iput(req->misc.release.inode); in fuse_file_put()
109 fuse_put_request(ff->fc, req); in fuse_file_put()
111 req->end = fuse_release_end; in fuse_file_put()
112 __set_bit(FR_BACKGROUND, &req->flags); in fuse_file_put()
113 fuse_request_send_background(ff->fc, req); in fuse_file_put()
127 return -ENOMEM; in fuse_do_open()
129 ff->fh = 0; in fuse_do_open()
130 ff->open_flags = FOPEN_KEEP_CACHE; /* Default for no-open */ in fuse_do_open()
131 if (!fc->no_open || isdir) { in fuse_do_open()
137 ff->fh = outarg.fh; in fuse_do_open()
138 ff->open_flags = outarg.open_flags; in fuse_do_open()
140 } else if (err != -ENOSYS || isdir) { in fuse_do_open()
144 fc->no_open = 1; in fuse_do_open()
149 ff->open_flags &= ~FOPEN_DIRECT_IO; in fuse_do_open()
151 ff->nodeid = nodeid; in fuse_do_open()
152 file->private_data = ff; in fuse_do_open()
163 struct fuse_file *ff = file->private_data; in fuse_link_write_file()
168 spin_lock(&fc->lock); in fuse_link_write_file()
169 if (list_empty(&ff->write_entry)) in fuse_link_write_file()
170 list_add(&ff->write_entry, &fi->write_files); in fuse_link_write_file()
171 spin_unlock(&fc->lock); in fuse_link_write_file()
176 struct fuse_file *ff = file->private_data; in fuse_finish_open()
179 if (ff->open_flags & FOPEN_DIRECT_IO) in fuse_finish_open()
180 file->f_op = &fuse_direct_io_file_operations; in fuse_finish_open()
181 if (!(ff->open_flags & FOPEN_KEEP_CACHE)) in fuse_finish_open()
182 invalidate_inode_pages2(inode->i_mapping); in fuse_finish_open()
183 if (ff->open_flags & FOPEN_STREAM) in fuse_finish_open()
185 else if (ff->open_flags & FOPEN_NONSEEKABLE) in fuse_finish_open()
187 if (fc->atomic_o_trunc && (file->f_flags & O_TRUNC)) { in fuse_finish_open()
190 spin_lock(&fc->lock); in fuse_finish_open()
191 fi->attr_version = ++fc->attr_version; in fuse_finish_open()
193 spin_unlock(&fc->lock); in fuse_finish_open()
195 if (fc->writeback_cache) in fuse_finish_open()
198 if ((file->f_mode & FMODE_WRITE) && fc->writeback_cache) in fuse_finish_open()
206 bool is_wb_truncate = (file->f_flags & O_TRUNC) && in fuse_open_common()
207 fc->atomic_o_trunc && in fuse_open_common()
208 fc->writeback_cache; in fuse_open_common()
211 return -EIO; in fuse_open_common()
237 struct fuse_conn *fc = ff->fc; in fuse_prepare_release()
238 struct fuse_req *req = ff->reserved_req; in fuse_prepare_release()
239 struct fuse_release_in *inarg = &req->misc.release.in; in fuse_prepare_release()
241 spin_lock(&fc->lock); in fuse_prepare_release()
242 list_del(&ff->write_entry); in fuse_prepare_release()
243 if (!RB_EMPTY_NODE(&ff->polled_node)) in fuse_prepare_release()
244 rb_erase(&ff->polled_node, &fc->polled_files); in fuse_prepare_release()
245 spin_unlock(&fc->lock); in fuse_prepare_release()
247 wake_up_interruptible_all(&ff->poll_wait); in fuse_prepare_release()
249 inarg->fh = ff->fh; in fuse_prepare_release()
250 inarg->flags = flags; in fuse_prepare_release()
251 req->in.h.opcode = opcode; in fuse_prepare_release()
252 req->in.h.nodeid = ff->nodeid; in fuse_prepare_release()
253 req->in.numargs = 1; in fuse_prepare_release()
254 req->in.args[0].size = sizeof(struct fuse_release_in); in fuse_prepare_release()
255 req->in.args[0].value = inarg; in fuse_prepare_release()
260 struct fuse_file *ff = file->private_data; in fuse_release_common()
261 struct fuse_req *req = ff->reserved_req; in fuse_release_common()
264 fuse_prepare_release(ff, file->f_flags, opcode); in fuse_release_common()
266 if (ff->flock) { in fuse_release_common()
267 struct fuse_release_in *inarg = &req->misc.release.in; in fuse_release_common()
268 inarg->release_flags |= FUSE_RELEASE_FLOCK_UNLOCK; in fuse_release_common()
269 inarg->lock_owner = fuse_lock_owner_id(ff->fc, in fuse_release_common()
273 req->misc.release.inode = igrab(file_inode(file)); in fuse_release_common()
284 fuse_file_put(ff, ff->fc->destroy_req != NULL, isdir); in fuse_release_common()
297 if (fc->writeback_cache) in fuse_release()
308 WARN_ON(refcount_read(&ff->count) > 1); in fuse_sync_release()
311 * iput(NULL) is a no-op and since the refcount is 1 and everything's in fuse_sync_release()
324 u32 *k = fc->scramble_key; in fuse_lock_owner_id()
354 spin_lock(&fc->lock); in fuse_range_is_writeback()
355 list_for_each_entry(req, &fi->writepages, writepages_entry) { in fuse_range_is_writeback()
358 BUG_ON(req->inode != inode); in fuse_range_is_writeback()
359 curr_index = req->misc.write.in.offset >> PAGE_SHIFT; in fuse_range_is_writeback()
360 if (idx_from < curr_index + req->num_pages && in fuse_range_is_writeback()
366 spin_unlock(&fc->lock); in fuse_range_is_writeback()
386 wait_event(fi->page_waitq, !fuse_page_is_writeback(inode, index)); in fuse_wait_on_page_writeback()
393 * This is currently done by blocking further writes with FUSE_NOWRITE
409 struct fuse_file *ff = file->private_data; in fuse_flush()
415 return -EIO; in fuse_flush()
417 if (fc->no_flush) in fuse_flush()
428 err = filemap_check_errors(file->f_mapping); in fuse_flush()
434 inarg.fh = ff->fh; in fuse_flush()
436 req->in.h.opcode = FUSE_FLUSH; in fuse_flush()
437 req->in.h.nodeid = get_node_id(inode); in fuse_flush()
438 req->in.numargs = 1; in fuse_flush()
439 req->in.args[0].size = sizeof(inarg); in fuse_flush()
440 req->in.args[0].value = &inarg; in fuse_flush()
441 __set_bit(FR_FORCE, &req->flags); in fuse_flush()
443 err = req->out.h.error; in fuse_flush()
445 if (err == -ENOSYS) { in fuse_flush()
446 fc->no_flush = 1; in fuse_flush()
455 struct inode *inode = file->f_mapping->host; in fuse_fsync_common()
457 struct fuse_file *ff = file->private_data; in fuse_fsync_common()
463 return -EIO; in fuse_fsync_common()
491 if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir)) in fuse_fsync_common()
495 inarg.fh = ff->fh; in fuse_fsync_common()
503 if (err == -ENOSYS) { in fuse_fsync_common()
505 fc->no_fsyncdir = 1; in fuse_fsync_common()
507 fc->no_fsync = 1; in fuse_fsync_common()
524 struct fuse_read_in *inarg = &req->misc.read.in; in fuse_read_fill()
525 struct fuse_file *ff = file->private_data; in fuse_read_fill()
527 inarg->fh = ff->fh; in fuse_read_fill()
528 inarg->offset = pos; in fuse_read_fill()
529 inarg->size = count; in fuse_read_fill()
530 inarg->flags = file->f_flags; in fuse_read_fill()
531 req->in.h.opcode = opcode; in fuse_read_fill()
532 req->in.h.nodeid = ff->nodeid; in fuse_read_fill()
533 req->in.numargs = 1; in fuse_read_fill()
534 req->in.args[0].size = sizeof(struct fuse_read_in); in fuse_read_fill()
535 req->in.args[0].value = inarg; in fuse_read_fill()
536 req->out.argvar = 1; in fuse_read_fill()
537 req->out.numargs = 1; in fuse_read_fill()
538 req->out.args[0].size = count; in fuse_read_fill()
545 for (i = 0; i < req->num_pages; i++) { in fuse_release_user_pages()
546 struct page *page = req->pages[i]; in fuse_release_user_pages()
558 static ssize_t fuse_get_res_by_io(struct fuse_io_priv *io) in fuse_get_res_by_io() argument
560 if (io->err) in fuse_get_res_by_io()
561 return io->err; in fuse_get_res_by_io()
563 if (io->bytes >= 0 && io->write) in fuse_get_res_by_io()
564 return -EIO; in fuse_get_res_by_io()
566 return io->bytes < 0 ? io->size : io->bytes; in fuse_get_res_by_io()
571 * actual end of fuse request in IO request. Otherwise, if bytes_requested
572 * == bytes_transferred or rw == WRITE, the caller sets 'pos' to -1.
577 * fully completed (req->out.args[0].size == 32K) resulting in pos == -1. The
581 * Thus, when all fuse requests are completed, the minimal non-negative 'pos'
583 * transferred data starting from the beginning of IO request.
585 static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos) in fuse_aio_complete() argument
589 spin_lock(&io->lock); in fuse_aio_complete()
591 io->err = io->err ? : err; in fuse_aio_complete()
592 else if (pos >= 0 && (io->bytes < 0 || pos < io->bytes)) in fuse_aio_complete()
593 io->bytes = pos; in fuse_aio_complete()
595 left = --io->reqs; in fuse_aio_complete()
596 if (!left && io->blocking) in fuse_aio_complete()
597 complete(io->done); in fuse_aio_complete()
598 spin_unlock(&io->lock); in fuse_aio_complete()
600 if (!left && !io->blocking) { in fuse_aio_complete()
601 ssize_t res = fuse_get_res_by_io(io); in fuse_aio_complete()
604 struct inode *inode = file_inode(io->iocb->ki_filp); in fuse_aio_complete()
608 spin_lock(&fc->lock); in fuse_aio_complete()
609 fi->attr_version = ++fc->attr_version; in fuse_aio_complete()
610 spin_unlock(&fc->lock); in fuse_aio_complete()
613 io->iocb->ki_complete(io->iocb, res, 0); in fuse_aio_complete()
616 kref_put(&io->refcnt, fuse_io_release); in fuse_aio_complete()
621 struct fuse_io_priv *io = req->io; in fuse_aio_complete_req() local
622 ssize_t pos = -1; in fuse_aio_complete_req()
624 fuse_release_user_pages(req, io->should_dirty); in fuse_aio_complete_req()
626 if (io->write) { in fuse_aio_complete_req()
627 if (req->misc.write.in.size != req->misc.write.out.size) in fuse_aio_complete_req()
628 pos = req->misc.write.in.offset - io->offset + in fuse_aio_complete_req()
629 req->misc.write.out.size; in fuse_aio_complete_req()
631 if (req->misc.read.in.size != req->out.args[0].size) in fuse_aio_complete_req()
632 pos = req->misc.read.in.offset - io->offset + in fuse_aio_complete_req()
633 req->out.args[0].size; in fuse_aio_complete_req()
636 fuse_aio_complete(io, req->out.h.error, pos); in fuse_aio_complete_req()
640 size_t num_bytes, struct fuse_io_priv *io) in fuse_async_req_send() argument
642 spin_lock(&io->lock); in fuse_async_req_send()
643 kref_get(&io->refcnt); in fuse_async_req_send()
644 io->size += num_bytes; in fuse_async_req_send()
645 io->reqs++; in fuse_async_req_send()
646 spin_unlock(&io->lock); in fuse_async_req_send()
648 req->io = io; in fuse_async_req_send()
649 req->end = fuse_aio_complete_req; in fuse_async_req_send()
657 static size_t fuse_send_read(struct fuse_req *req, struct fuse_io_priv *io, in fuse_send_read() argument
660 struct file *file = io->iocb->ki_filp; in fuse_send_read()
661 struct fuse_file *ff = file->private_data; in fuse_send_read()
662 struct fuse_conn *fc = ff->fc; in fuse_send_read()
666 struct fuse_read_in *inarg = &req->misc.read.in; in fuse_send_read()
668 inarg->read_flags |= FUSE_READ_LOCKOWNER; in fuse_send_read()
669 inarg->lock_owner = fuse_lock_owner_id(fc, owner); in fuse_send_read()
672 if (io->async) in fuse_send_read()
673 return fuse_async_req_send(fc, req, count, io); in fuse_send_read()
676 return req->out.args[0].size; in fuse_send_read()
685 spin_lock(&fc->lock); in fuse_read_update_size()
686 if (attr_ver == fi->attr_version && size < inode->i_size && in fuse_read_update_size()
687 !test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) { in fuse_read_update_size()
688 fi->attr_version = ++fc->attr_version; in fuse_read_update_size()
691 spin_unlock(&fc->lock); in fuse_read_update_size()
697 size_t num_read = req->out.args[0].size; in fuse_short_read()
700 if (fc->writeback_cache) { in fuse_short_read()
708 size_t off = num_read & (PAGE_SIZE - 1); in fuse_short_read()
710 for (i = start_idx; i < req->num_pages; i++) { in fuse_short_read()
711 zero_user_segment(req->pages[i], off, PAGE_SIZE); in fuse_short_read()
715 loff_t pos = page_offset(req->pages[0]) + num_read; in fuse_short_read()
723 struct fuse_io_priv io; in fuse_do_readpage() local
724 struct inode *inode = page->mapping->host; in fuse_do_readpage()
735 * page-cache page, so make sure we read a properly synced in fuse_do_readpage()
738 fuse_wait_on_page_writeback(inode, page->index); in fuse_do_readpage()
746 req->out.page_zeroing = 1; in fuse_do_readpage()
747 req->out.argpages = 1; in fuse_do_readpage()
748 req->num_pages = 1; in fuse_do_readpage()
749 req->pages[0] = page; in fuse_do_readpage()
750 req->page_descs[0].length = count; in fuse_do_readpage()
752 io = (struct fuse_io_priv) FUSE_IO_PRIV_SYNC(&iocb); in fuse_do_readpage()
753 num_read = fuse_send_read(req, &io, pos, count, NULL); in fuse_do_readpage()
754 err = req->out.h.error; in fuse_do_readpage()
773 struct inode *inode = page->mapping->host; in fuse_readpage()
776 err = -EIO; in fuse_readpage()
790 size_t count = req->misc.read.in.size; in fuse_readpages_end()
791 size_t num_read = req->out.args[0].size; in fuse_readpages_end()
794 for (i = 0; mapping == NULL && i < req->num_pages; i++) in fuse_readpages_end()
795 mapping = req->pages[i]->mapping; in fuse_readpages_end()
798 struct inode *inode = mapping->host; in fuse_readpages_end()
803 if (!req->out.h.error && num_read < count) in fuse_readpages_end()
804 fuse_short_read(req, inode, req->misc.read.attr_ver); in fuse_readpages_end()
809 for (i = 0; i < req->num_pages; i++) { in fuse_readpages_end()
810 struct page *page = req->pages[i]; in fuse_readpages_end()
811 if (!req->out.h.error) in fuse_readpages_end()
818 if (req->ff) in fuse_readpages_end()
819 fuse_file_put(req->ff, false, false); in fuse_readpages_end()
824 struct fuse_file *ff = file->private_data; in fuse_send_readpages()
825 struct fuse_conn *fc = ff->fc; in fuse_send_readpages()
826 loff_t pos = page_offset(req->pages[0]); in fuse_send_readpages()
827 size_t count = req->num_pages << PAGE_SHIFT; in fuse_send_readpages()
829 req->out.argpages = 1; in fuse_send_readpages()
830 req->out.page_zeroing = 1; in fuse_send_readpages()
831 req->out.page_replace = 1; in fuse_send_readpages()
833 req->misc.read.attr_ver = fuse_get_attr_version(fc); in fuse_send_readpages()
834 if (fc->async_read) { in fuse_send_readpages()
835 req->ff = fuse_file_get(ff); in fuse_send_readpages()
836 req->end = fuse_readpages_end; in fuse_send_readpages()
855 struct fuse_req *req = data->req; in fuse_readpages_fill()
856 struct inode *inode = data->inode; in fuse_readpages_fill()
859 fuse_wait_on_page_writeback(inode, page->index); in fuse_readpages_fill()
861 if (req->num_pages && in fuse_readpages_fill()
862 (req->num_pages == FUSE_MAX_PAGES_PER_REQ || in fuse_readpages_fill()
863 (req->num_pages + 1) * PAGE_SIZE > fc->max_read || in fuse_readpages_fill()
864 req->pages[req->num_pages - 1]->index + 1 != page->index)) { in fuse_readpages_fill()
865 int nr_alloc = min_t(unsigned, data->nr_pages, in fuse_readpages_fill()
867 fuse_send_readpages(req, data->file); in fuse_readpages_fill()
868 if (fc->async_read) in fuse_readpages_fill()
873 data->req = req; in fuse_readpages_fill()
880 if (WARN_ON(req->num_pages >= req->max_pages)) { in fuse_readpages_fill()
883 return -EIO; in fuse_readpages_fill()
887 req->pages[req->num_pages] = page; in fuse_readpages_fill()
888 req->page_descs[req->num_pages].length = PAGE_SIZE; in fuse_readpages_fill()
889 req->num_pages++; in fuse_readpages_fill()
890 data->nr_pages--; in fuse_readpages_fill()
897 struct inode *inode = mapping->host; in fuse_readpages()
903 err = -EIO; in fuse_readpages()
909 if (fc->async_read) in fuse_readpages()
920 if (data.req->num_pages) in fuse_readpages()
931 struct inode *inode = iocb->ki_filp->f_mapping->host; in fuse_file_read_iter()
939 if (fc->auto_inval_data || in fuse_file_read_iter()
940 (iocb->ki_pos + iov_iter_count(to) > i_size_read(inode))) { in fuse_file_read_iter()
942 err = fuse_update_attributes(inode, iocb->ki_filp); in fuse_file_read_iter()
953 struct fuse_write_in *inarg = &req->misc.write.in; in fuse_write_fill()
954 struct fuse_write_out *outarg = &req->misc.write.out; in fuse_write_fill()
956 inarg->fh = ff->fh; in fuse_write_fill()
957 inarg->offset = pos; in fuse_write_fill()
958 inarg->size = count; in fuse_write_fill()
959 req->in.h.opcode = FUSE_WRITE; in fuse_write_fill()
960 req->in.h.nodeid = ff->nodeid; in fuse_write_fill()
961 req->in.numargs = 2; in fuse_write_fill()
962 if (ff->fc->minor < 9) in fuse_write_fill()
963 req->in.args[0].size = FUSE_COMPAT_WRITE_IN_SIZE; in fuse_write_fill()
965 req->in.args[0].size = sizeof(struct fuse_write_in); in fuse_write_fill()
966 req->in.args[0].value = inarg; in fuse_write_fill()
967 req->in.args[1].size = count; in fuse_write_fill()
968 req->out.numargs = 1; in fuse_write_fill()
969 req->out.args[0].size = sizeof(struct fuse_write_out); in fuse_write_fill()
970 req->out.args[0].value = outarg; in fuse_write_fill()
973 static size_t fuse_send_write(struct fuse_req *req, struct fuse_io_priv *io, in fuse_send_write() argument
976 struct kiocb *iocb = io->iocb; in fuse_send_write()
977 struct file *file = iocb->ki_filp; in fuse_send_write()
978 struct fuse_file *ff = file->private_data; in fuse_send_write()
979 struct fuse_conn *fc = ff->fc; in fuse_send_write()
980 struct fuse_write_in *inarg = &req->misc.write.in; in fuse_send_write()
983 inarg->flags = file->f_flags; in fuse_send_write()
984 if (iocb->ki_flags & IOCB_DSYNC) in fuse_send_write()
985 inarg->flags |= O_DSYNC; in fuse_send_write()
986 if (iocb->ki_flags & IOCB_SYNC) in fuse_send_write()
987 inarg->flags |= O_SYNC; in fuse_send_write()
989 inarg->write_flags |= FUSE_WRITE_LOCKOWNER; in fuse_send_write()
990 inarg->lock_owner = fuse_lock_owner_id(fc, owner); in fuse_send_write()
993 if (io->async) in fuse_send_write()
994 return fuse_async_req_send(fc, req, count, io); in fuse_send_write()
997 return req->misc.write.out.size; in fuse_send_write()
1006 spin_lock(&fc->lock); in fuse_write_update_size()
1007 fi->attr_version = ++fc->attr_version; in fuse_write_update_size()
1008 if (pos > inode->i_size) { in fuse_write_update_size()
1012 spin_unlock(&fc->lock); in fuse_write_update_size()
1024 struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb); in fuse_send_write_pages() local
1026 for (i = 0; i < req->num_pages; i++) in fuse_send_write_pages()
1027 fuse_wait_on_page_writeback(inode, req->pages[i]->index); in fuse_send_write_pages()
1029 res = fuse_send_write(req, &io, pos, count, NULL); in fuse_send_write_pages()
1031 offset = req->page_descs[0].offset; in fuse_send_write_pages()
1033 for (i = 0; i < req->num_pages; i++) { in fuse_send_write_pages()
1034 struct page *page = req->pages[i]; in fuse_send_write_pages()
1036 if (!req->out.h.error && !offset && count >= PAGE_SIZE) in fuse_send_write_pages()
1039 if (count > PAGE_SIZE - offset) in fuse_send_write_pages()
1040 count -= PAGE_SIZE - offset; in fuse_send_write_pages()
1056 struct fuse_conn *fc = get_fuse_conn(mapping->host); in fuse_fill_write_pages()
1057 unsigned offset = pos & (PAGE_SIZE - 1); in fuse_fill_write_pages()
1061 req->in.argpages = 1; in fuse_fill_write_pages()
1062 req->page_descs[0].offset = offset; in fuse_fill_write_pages()
1068 size_t bytes = min_t(size_t, PAGE_SIZE - offset, in fuse_fill_write_pages()
1071 bytes = min_t(size_t, bytes, fc->max_write - count); in fuse_fill_write_pages()
1074 err = -EFAULT; in fuse_fill_write_pages()
1078 err = -ENOMEM; in fuse_fill_write_pages()
1098 req->pages[req->num_pages] = page; in fuse_fill_write_pages()
1099 req->page_descs[req->num_pages].length = tmp; in fuse_fill_write_pages()
1100 req->num_pages++; in fuse_fill_write_pages()
1108 if (!fc->big_writes) in fuse_fill_write_pages()
1110 } while (iov_iter_count(ii) && count < fc->max_write && in fuse_fill_write_pages()
1111 req->num_pages < req->max_pages && offset == 0); in fuse_fill_write_pages()
1119 ((pos + len - 1) >> PAGE_SHIFT) - in fuse_wr_pages()
1128 struct inode *inode = mapping->host; in fuse_perform_write()
1135 return -EIO; in fuse_perform_write()
1137 if (inode->i_size < pos + iov_iter_count(ii)) in fuse_perform_write()
1138 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state); in fuse_perform_write()
1159 err = req->out.h.error; in fuse_perform_write()
1166 err = -EIO; in fuse_perform_write()
1175 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state); in fuse_perform_write()
1183 struct file *file = iocb->ki_filp; in fuse_file_write_iter()
1184 struct address_space *mapping = file->f_mapping; in fuse_file_write_iter()
1187 struct inode *inode = mapping->host; in fuse_file_write_iter()
1191 if (get_fuse_conn(inode)->writeback_cache) { in fuse_file_write_iter()
1193 err = fuse_update_attributes(mapping->host, file); in fuse_file_write_iter()
1203 current->backing_dev_info = inode_to_bdi(inode); in fuse_file_write_iter()
1217 if (iocb->ki_flags & IOCB_DIRECT) { in fuse_file_write_iter()
1218 loff_t pos = iocb->ki_pos; in fuse_file_write_iter()
1230 endbyte = pos + written_buffered - 1; in fuse_file_write_iter()
1232 err = filemap_write_and_wait_range(file->f_mapping, pos, in fuse_file_write_iter()
1237 invalidate_mapping_pages(file->f_mapping, in fuse_file_write_iter()
1242 iocb->ki_pos = pos + written_buffered; in fuse_file_write_iter()
1244 written = fuse_perform_write(iocb, mapping, from, iocb->ki_pos); in fuse_file_write_iter()
1246 iocb->ki_pos += written; in fuse_file_write_iter()
1249 current->backing_dev_info = NULL; in fuse_file_write_iter()
1263 req->page_descs[i].length = PAGE_SIZE - in fuse_page_descs_length_init()
1264 req->page_descs[i].offset; in fuse_page_descs_length_init()
1269 return (unsigned long)ii->iov->iov_base + ii->iov_offset; in fuse_get_user_addr()
1285 if (ii->type & ITER_KVEC) { in fuse_get_user_pages()
1290 req->in.args[1].value = (void *) user_addr; in fuse_get_user_pages()
1292 req->out.args[0].value = (void *) user_addr; in fuse_get_user_pages()
1299 while (nbytes < *nbytesp && req->num_pages < req->max_pages) { in fuse_get_user_pages()
1302 ret = iov_iter_get_pages(ii, &req->pages[req->num_pages], in fuse_get_user_pages()
1303 *nbytesp - nbytes, in fuse_get_user_pages()
1304 req->max_pages - req->num_pages, in fuse_get_user_pages()
1313 npages = (ret + PAGE_SIZE - 1) / PAGE_SIZE; in fuse_get_user_pages()
1315 req->page_descs[req->num_pages].offset = start; in fuse_get_user_pages()
1316 fuse_page_descs_length_init(req, req->num_pages, npages); in fuse_get_user_pages()
1318 req->num_pages += npages; in fuse_get_user_pages()
1319 req->page_descs[req->num_pages - 1].length -= in fuse_get_user_pages()
1320 (PAGE_SIZE - ret) & (PAGE_SIZE - 1); in fuse_get_user_pages()
1324 req->in.user_pages = 1; in fuse_get_user_pages()
1325 req->in.argpages = 1; in fuse_get_user_pages()
1327 req->out.argpages = 1; in fuse_get_user_pages()
1340 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter, in fuse_direct_io() argument
1345 struct file *file = io->iocb->ki_filp; in fuse_direct_io()
1346 struct inode *inode = file->f_mapping->host; in fuse_direct_io()
1347 struct fuse_file *ff = file->private_data; in fuse_direct_io()
1348 struct fuse_conn *fc = ff->fc; in fuse_direct_io()
1349 size_t nmax = write ? fc->max_write : fc->max_read; in fuse_direct_io()
1353 pgoff_t idx_to = (pos + count - 1) >> PAGE_SHIFT; in fuse_direct_io()
1358 if (io->async) in fuse_direct_io()
1373 io->should_dirty = !write && iter_is_iovec(iter); in fuse_direct_io()
1376 fl_owner_t owner = current->files; in fuse_direct_io()
1383 nres = fuse_send_write(req, io, pos, nbytes, owner); in fuse_direct_io()
1385 nres = fuse_send_read(req, io, pos, nbytes, owner); in fuse_direct_io()
1387 if (!io->async) in fuse_direct_io()
1388 fuse_release_user_pages(req, io->should_dirty); in fuse_direct_io()
1389 if (req->out.h.error) { in fuse_direct_io()
1390 err = req->out.h.error; in fuse_direct_io()
1394 err = -EIO; in fuse_direct_io()
1397 count -= nres; in fuse_direct_io()
1404 if (io->async) in fuse_direct_io()
1422 static ssize_t __fuse_direct_read(struct fuse_io_priv *io, in __fuse_direct_read() argument
1427 struct inode *inode = file_inode(io->iocb->ki_filp); in __fuse_direct_read()
1430 return -EIO; in __fuse_direct_read()
1432 res = fuse_direct_io(io, iter, ppos, 0); in __fuse_direct_read()
1441 struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb); in fuse_direct_read_iter() local
1442 return __fuse_direct_read(&io, to, &iocb->ki_pos); in fuse_direct_read_iter()
1447 struct inode *inode = file_inode(iocb->ki_filp); in fuse_direct_write_iter()
1448 struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(iocb); in fuse_direct_write_iter() local
1452 return -EIO; in fuse_direct_write_iter()
1458 res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE); in fuse_direct_write_iter()
1461 fuse_write_update_size(inode, iocb->ki_pos); in fuse_direct_write_iter()
1471 for (i = 0; i < req->num_pages; i++) in fuse_writepage_free()
1472 __free_page(req->pages[i]); in fuse_writepage_free()
1474 if (req->ff) in fuse_writepage_free()
1475 fuse_file_put(req->ff, false, false); in fuse_writepage_free()
1480 struct inode *inode = req->inode; in fuse_writepage_finish()
1485 list_del(&req->writepages_entry); in fuse_writepage_finish()
1486 for (i = 0; i < req->num_pages; i++) { in fuse_writepage_finish()
1487 dec_wb_stat(&bdi->wb, WB_WRITEBACK); in fuse_writepage_finish()
1488 dec_node_page_state(req->pages[i], NR_WRITEBACK_TEMP); in fuse_writepage_finish()
1489 wb_writeout_inc(&bdi->wb); in fuse_writepage_finish()
1491 wake_up(&fi->page_waitq); in fuse_writepage_finish()
1494 /* Called under fc->lock, may release and reacquire it */
1497 __releases(fc->lock) in fuse_send_writepage()
1498 __acquires(fc->lock) in fuse_send_writepage()
1500 struct fuse_inode *fi = get_fuse_inode(req->inode); in fuse_send_writepage()
1501 struct fuse_write_in *inarg = &req->misc.write.in; in fuse_send_writepage()
1502 __u64 data_size = req->num_pages * PAGE_SIZE; in fuse_send_writepage()
1504 if (!fc->connected) in fuse_send_writepage()
1507 if (inarg->offset + data_size <= size) { in fuse_send_writepage()
1508 inarg->size = data_size; in fuse_send_writepage()
1509 } else if (inarg->offset < size) { in fuse_send_writepage()
1510 inarg->size = size - inarg->offset; in fuse_send_writepage()
1516 req->in.args[1].size = inarg->size; in fuse_send_writepage()
1517 fi->writectr++; in fuse_send_writepage()
1523 spin_unlock(&fc->lock); in fuse_send_writepage()
1526 spin_lock(&fc->lock); in fuse_send_writepage()
1530 * If fi->writectr is positive (no truncate or fsync going on) send
1533 * Called with fc->lock
1536 __releases(fc->lock) in fuse_flush_writepages()
1537 __acquires(fc->lock) in fuse_flush_writepages()
1544 while (fi->writectr >= 0 && !list_empty(&fi->queued_writes)) { in fuse_flush_writepages()
1545 req = list_entry(fi->queued_writes.next, struct fuse_req, list); in fuse_flush_writepages()
1546 list_del_init(&req->list); in fuse_flush_writepages()
1553 struct inode *inode = req->inode; in fuse_writepage_end()
1556 mapping_set_error(inode->i_mapping, req->out.h.error); in fuse_writepage_end()
1557 spin_lock(&fc->lock); in fuse_writepage_end()
1558 while (req->misc.write.next) { in fuse_writepage_end()
1560 struct fuse_write_in *inarg = &req->misc.write.in; in fuse_writepage_end()
1561 struct fuse_req *next = req->misc.write.next; in fuse_writepage_end()
1562 req->misc.write.next = next->misc.write.next; in fuse_writepage_end()
1563 next->misc.write.next = NULL; in fuse_writepage_end()
1564 next->ff = fuse_file_get(req->ff); in fuse_writepage_end()
1565 list_add(&next->writepages_entry, &fi->writepages); in fuse_writepage_end()
1577 * now for completion of all in-flight requests. This happens in fuse_writepage_end()
1583 * that fuse_set_nowrite returned implies that all in-flight in fuse_writepage_end()
1586 * writectr. Hence there cannot be any in-flight requests and in fuse_writepage_end()
1590 fuse_send_writepage(fc, next, inarg->offset + inarg->size); in fuse_writepage_end()
1592 fi->writectr--; in fuse_writepage_end()
1594 spin_unlock(&fc->lock); in fuse_writepage_end()
1603 spin_lock(&fc->lock); in __fuse_write_file_get()
1604 if (!list_empty(&fi->write_files)) { in __fuse_write_file_get()
1605 ff = list_entry(fi->write_files.next, struct fuse_file, in __fuse_write_file_get()
1609 spin_unlock(&fc->lock); in __fuse_write_file_get()
1639 struct address_space *mapping = page->mapping; in fuse_writepage_locked()
1640 struct inode *inode = mapping->host; in fuse_writepage_locked()
1645 int error = -ENOMEM; in fuse_writepage_locked()
1654 __set_bit(FR_BACKGROUND, &req->flags); in fuse_writepage_locked()
1659 error = -EIO; in fuse_writepage_locked()
1660 req->ff = fuse_write_file_get(fc, fi); in fuse_writepage_locked()
1661 if (!req->ff) in fuse_writepage_locked()
1664 fuse_write_fill(req, req->ff, page_offset(page), 0); in fuse_writepage_locked()
1667 req->misc.write.in.write_flags |= FUSE_WRITE_CACHE; in fuse_writepage_locked()
1668 req->misc.write.next = NULL; in fuse_writepage_locked()
1669 req->in.argpages = 1; in fuse_writepage_locked()
1670 req->num_pages = 1; in fuse_writepage_locked()
1671 req->pages[0] = tmp_page; in fuse_writepage_locked()
1672 req->page_descs[0].offset = 0; in fuse_writepage_locked()
1673 req->page_descs[0].length = PAGE_SIZE; in fuse_writepage_locked()
1674 req->end = fuse_writepage_end; in fuse_writepage_locked()
1675 req->inode = inode; in fuse_writepage_locked()
1677 inc_wb_stat(&inode_to_bdi(inode)->wb, WB_WRITEBACK); in fuse_writepage_locked()
1680 spin_lock(&fc->lock); in fuse_writepage_locked()
1681 list_add(&req->writepages_entry, &fi->writepages); in fuse_writepage_locked()
1682 list_add_tail(&req->list, &fi->queued_writes); in fuse_writepage_locked()
1684 spin_unlock(&fc->lock); in fuse_writepage_locked()
1695 mapping_set_error(page->mapping, error); in fuse_writepage_locked()
1704 if (fuse_page_is_writeback(page->mapping->host, page->index)) { in fuse_writepage()
1706 * ->writepages() should be called for sync() and friends. We in fuse_writepage()
1710 WARN_ON(wbc->sync_mode == WB_SYNC_ALL); in fuse_writepage()
1732 struct fuse_req *req = data->req; in fuse_writepages_send()
1733 struct inode *inode = data->inode; in fuse_writepages_send()
1736 int num_pages = req->num_pages; in fuse_writepages_send()
1739 req->ff = fuse_file_get(data->ff); in fuse_writepages_send()
1740 spin_lock(&fc->lock); in fuse_writepages_send()
1741 list_add_tail(&req->list, &fi->queued_writes); in fuse_writepages_send()
1743 spin_unlock(&fc->lock); in fuse_writepages_send()
1746 end_page_writeback(data->orig_pages[i]); in fuse_writepages_send()
1752 struct fuse_conn *fc = get_fuse_conn(new_req->inode); in fuse_writepage_in_flight()
1753 struct fuse_inode *fi = get_fuse_inode(new_req->inode); in fuse_writepage_in_flight()
1759 BUG_ON(new_req->num_pages != 0); in fuse_writepage_in_flight()
1761 spin_lock(&fc->lock); in fuse_writepage_in_flight()
1762 list_del(&new_req->writepages_entry); in fuse_writepage_in_flight()
1763 list_for_each_entry(old_req, &fi->writepages, writepages_entry) { in fuse_writepage_in_flight()
1764 BUG_ON(old_req->inode != new_req->inode); in fuse_writepage_in_flight()
1765 curr_index = old_req->misc.write.in.offset >> PAGE_SHIFT; in fuse_writepage_in_flight()
1766 if (curr_index <= page->index && in fuse_writepage_in_flight()
1767 page->index < curr_index + old_req->num_pages) { in fuse_writepage_in_flight()
1773 list_add(&new_req->writepages_entry, &fi->writepages); in fuse_writepage_in_flight()
1777 new_req->num_pages = 1; in fuse_writepage_in_flight()
1778 for (tmp = old_req; tmp != NULL; tmp = tmp->misc.write.next) { in fuse_writepage_in_flight()
1779 BUG_ON(tmp->inode != new_req->inode); in fuse_writepage_in_flight()
1780 curr_index = tmp->misc.write.in.offset >> PAGE_SHIFT; in fuse_writepage_in_flight()
1781 if (tmp->num_pages == 1 && in fuse_writepage_in_flight()
1782 curr_index == page->index) { in fuse_writepage_in_flight()
1787 if (old_req->num_pages == 1 && test_bit(FR_PENDING, &old_req->flags)) { in fuse_writepage_in_flight()
1788 struct backing_dev_info *bdi = inode_to_bdi(page->mapping->host); in fuse_writepage_in_flight()
1790 copy_highpage(old_req->pages[0], page); in fuse_writepage_in_flight()
1791 spin_unlock(&fc->lock); in fuse_writepage_in_flight()
1793 dec_wb_stat(&bdi->wb, WB_WRITEBACK); in fuse_writepage_in_flight()
1794 dec_node_page_state(new_req->pages[0], NR_WRITEBACK_TEMP); in fuse_writepage_in_flight()
1795 wb_writeout_inc(&bdi->wb); in fuse_writepage_in_flight()
1800 new_req->misc.write.next = old_req->misc.write.next; in fuse_writepage_in_flight()
1801 old_req->misc.write.next = new_req; in fuse_writepage_in_flight()
1804 spin_unlock(&fc->lock); in fuse_writepage_in_flight()
1813 struct fuse_req *req = data->req; in fuse_writepages_fill()
1814 struct inode *inode = data->inode; in fuse_writepages_fill()
1820 if (!data->ff) { in fuse_writepages_fill()
1821 err = -EIO; in fuse_writepages_fill()
1822 data->ff = fuse_write_file_get(fc, get_fuse_inode(inode)); in fuse_writepages_fill()
1823 if (!data->ff) in fuse_writepages_fill()
1833 is_writeback = fuse_page_is_writeback(inode, page->index); in fuse_writepages_fill()
1835 if (req && req->num_pages && in fuse_writepages_fill()
1836 (is_writeback || req->num_pages == FUSE_MAX_PAGES_PER_REQ || in fuse_writepages_fill()
1837 (req->num_pages + 1) * PAGE_SIZE > fc->max_write || in fuse_writepages_fill()
1838 data->orig_pages[req->num_pages - 1]->index + 1 != page->index)) { in fuse_writepages_fill()
1840 data->req = NULL; in fuse_writepages_fill()
1842 err = -ENOMEM; in fuse_writepages_fill()
1856 * request to the fi->writepages list and increment req->num_pages. in fuse_writepages_fill()
1860 if (data->req == NULL) { in fuse_writepages_fill()
1863 err = -ENOMEM; in fuse_writepages_fill()
1870 fuse_write_fill(req, data->ff, page_offset(page), 0); in fuse_writepages_fill()
1871 req->misc.write.in.write_flags |= FUSE_WRITE_CACHE; in fuse_writepages_fill()
1872 req->misc.write.next = NULL; in fuse_writepages_fill()
1873 req->in.argpages = 1; in fuse_writepages_fill()
1874 __set_bit(FR_BACKGROUND, &req->flags); in fuse_writepages_fill()
1875 req->num_pages = 0; in fuse_writepages_fill()
1876 req->end = fuse_writepage_end; in fuse_writepages_fill()
1877 req->inode = inode; in fuse_writepages_fill()
1879 spin_lock(&fc->lock); in fuse_writepages_fill()
1880 list_add(&req->writepages_entry, &fi->writepages); in fuse_writepages_fill()
1881 spin_unlock(&fc->lock); in fuse_writepages_fill()
1883 data->req = req; in fuse_writepages_fill()
1888 req->pages[req->num_pages] = tmp_page; in fuse_writepages_fill()
1889 req->page_descs[req->num_pages].offset = 0; in fuse_writepages_fill()
1890 req->page_descs[req->num_pages].length = PAGE_SIZE; in fuse_writepages_fill()
1892 inc_wb_stat(&inode_to_bdi(inode)->wb, WB_WRITEBACK); in fuse_writepages_fill()
1898 data->req = NULL; in fuse_writepages_fill()
1901 data->orig_pages[req->num_pages] = page; in fuse_writepages_fill()
1904 * Protected by fc->lock against concurrent access by in fuse_writepages_fill()
1907 spin_lock(&fc->lock); in fuse_writepages_fill()
1908 req->num_pages++; in fuse_writepages_fill()
1909 spin_unlock(&fc->lock); in fuse_writepages_fill()
1920 struct inode *inode = mapping->host; in fuse_writepages()
1924 err = -EIO; in fuse_writepages()
1932 err = -ENOMEM; in fuse_writepages()
1942 BUG_ON(!data.req->num_pages); in fuse_writepages()
1966 int err = -ENOMEM; in fuse_write_begin()
1968 WARN_ON(!fc->writeback_cache); in fuse_write_begin()
1974 fuse_wait_on_page_writeback(mapping->host, page->index); in fuse_write_begin()
1982 fsize = i_size_read(mapping->host); in fuse_write_begin()
2007 struct inode *inode = page->mapping->host; in fuse_write_end()
2035 struct inode *inode = page->mapping->host; in fuse_launder_page()
2038 fuse_wait_on_page_writeback(inode, page->index); in fuse_launder_page()
2049 filemap_write_and_wait(vma->vm_file->f_mapping); in fuse_vma_close()
2057 * Block here, instead of in ->writepage(), so that the userspace fs
2063 * - page migration
2064 * - sync(2)
2065 * - try_to_free_pages() with order > PAGE_ALLOC_COSTLY_ORDER
2069 struct page *page = vmf->page; in fuse_page_mkwrite()
2070 struct inode *inode = file_inode(vmf->vma->vm_file); in fuse_page_mkwrite()
2072 file_update_time(vmf->vma->vm_file); in fuse_page_mkwrite()
2074 if (page->mapping != inode->i_mapping) { in fuse_page_mkwrite()
2079 fuse_wait_on_page_writeback(inode, page->index); in fuse_page_mkwrite()
2092 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) in fuse_file_mmap()
2096 vma->vm_ops = &fuse_file_vm_ops; in fuse_file_mmap()
2103 if (vma->vm_flags & VM_MAYSHARE) in fuse_direct_mmap()
2104 return -ENODEV; in fuse_direct_mmap()
2106 invalidate_inode_pages2(file->f_mapping); in fuse_direct_mmap()
2115 switch (ffl->type) { in convert_fuse_file_lock()
2121 if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX || in convert_fuse_file_lock()
2122 ffl->end < ffl->start) in convert_fuse_file_lock()
2123 return -EIO; in convert_fuse_file_lock()
2125 fl->fl_start = ffl->start; in convert_fuse_file_lock()
2126 fl->fl_end = ffl->end; in convert_fuse_file_lock()
2133 fl->fl_pid = pid_nr_ns(find_pid_ns(ffl->pid, fc->pid_ns), &init_pid_ns); in convert_fuse_file_lock()
2138 return -EIO; in convert_fuse_file_lock()
2140 fl->fl_type = ffl->type; in convert_fuse_file_lock()
2150 struct fuse_file *ff = file->private_data; in fuse_lk_fill()
2153 inarg->fh = ff->fh; in fuse_lk_fill()
2154 inarg->owner = fuse_lock_owner_id(fc, fl->fl_owner); in fuse_lk_fill()
2155 inarg->lk.start = fl->fl_start; in fuse_lk_fill()
2156 inarg->lk.end = fl->fl_end; in fuse_lk_fill()
2157 inarg->lk.type = fl->fl_type; in fuse_lk_fill()
2158 inarg->lk.pid = pid; in fuse_lk_fill()
2160 inarg->lk_flags |= FUSE_LK_FLOCK; in fuse_lk_fill()
2161 args->in.h.opcode = opcode; in fuse_lk_fill()
2162 args->in.h.nodeid = get_node_id(inode); in fuse_lk_fill()
2163 args->in.numargs = 1; in fuse_lk_fill()
2164 args->in.args[0].size = sizeof(*inarg); in fuse_lk_fill()
2165 args->in.args[0].value = inarg; in fuse_lk_fill()
2194 int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; in fuse_setlk()
2195 struct pid *pid = fl->fl_type != F_UNLCK ? task_tgid(current) : NULL; in fuse_setlk()
2196 pid_t pid_nr = pid_nr_ns(pid, fc->pid_ns); in fuse_setlk()
2199 if (fl->fl_lmops && fl->fl_lmops->lm_grant) { in fuse_setlk()
2201 return -ENOLCK; in fuse_setlk()
2205 if ((fl->fl_flags & FL_CLOSE_POSIX) == FL_CLOSE_POSIX) in fuse_setlk()
2212 if (err == -EINTR) in fuse_setlk()
2213 err = -ERESTARTSYS; in fuse_setlk()
2227 if (fc->no_lock) { in fuse_file_lock()
2233 if (fc->no_lock) in fuse_file_lock()
2247 if (fc->no_flock) { in fuse_file_flock()
2250 struct fuse_file *ff = file->private_data; in fuse_file_flock()
2253 ff->flock = true; in fuse_file_flock()
2262 struct inode *inode = mapping->host; in fuse_bmap()
2269 if (!inode->i_sb->s_bdev || fc->no_bmap) in fuse_bmap()
2274 inarg.blocksize = inode->i_sb->s_blocksize; in fuse_bmap()
2284 if (err == -ENOSYS) in fuse_bmap()
2285 fc->no_bmap = 1; in fuse_bmap()
2292 struct inode *inode = file->f_mapping->host; in fuse_lseek()
2294 struct fuse_file *ff = file->private_data; in fuse_lseek()
2297 .fh = ff->fh, in fuse_lseek()
2304 if (fc->no_lseek) in fuse_lseek()
2308 args.in.h.nodeid = ff->nodeid; in fuse_lseek()
2317 if (err == -ENOSYS) { in fuse_lseek()
2318 fc->no_lseek = 1; in fuse_lseek()
2324 return vfs_setpos(file, outarg.offset, inode->i_sb->s_maxbytes); in fuse_lseek()
2359 retval = -EINVAL; in fuse_file_llseek()
2382 * non-compat (i.e. ones coming from 64bit apps) ioctl in fuse_copy_ioctl_iovec_old()
2386 return -EINVAL; in fuse_copy_ioctl_iovec_old()
2397 return -EIO; in fuse_copy_ioctl_iovec_old()
2410 if (iov->iov_len > (size_t) max) in fuse_verify_ioctl_iov()
2411 return -ENOMEM; in fuse_verify_ioctl_iov()
2412 max -= iov->iov_len; in fuse_verify_ioctl_iov()
2424 if (fc->minor < 16) { in fuse_copy_ioctl_iovec()
2430 return -EIO; in fuse_copy_ioctl_iovec()
2436 return -EIO; in fuse_copy_ioctl_iovec()
2445 return -EIO; in fuse_copy_ioctl_iovec()
2469 * On the first callout to FUSE server, inarg->in_size and
2470 * inarg->out_size will be NULL; then, the server completes the ioctl
2471 * with FUSE_IOCTL_RETRY set in out->flags, out->in_iovs set to 1 and
2479 * it sets FUSE_IOCTL_RETRY, out->in_iovs to 2 and iov array to
2496 * limits ioctl data transfers to well-formed ioctls and is the forced
2502 struct fuse_file *ff = file->private_data; in fuse_do_ioctl()
2503 struct fuse_conn *fc = ff->fc; in fuse_do_ioctl()
2505 .fh = ff->fh, in fuse_do_ioctl()
2530 err = -ENOMEM; in fuse_do_ioctl()
2537 * If restricted, initialize IO parameters as encoded in @cmd. in fuse_do_ioctl()
2543 iov->iov_base = (void __user *)arg; in fuse_do_ioctl()
2548 iov->iov_len = sizeof(int); in fuse_do_ioctl()
2551 iov->iov_len = _IOC_SIZE(cmd); in fuse_do_ioctl()
2578 err = -ENOMEM; in fuse_do_ioctl()
2594 memcpy(req->pages, pages, sizeof(req->pages[0]) * num_pages); in fuse_do_ioctl()
2595 req->num_pages = num_pages; in fuse_do_ioctl()
2596 fuse_page_descs_length_init(req, 0, req->num_pages); in fuse_do_ioctl()
2599 req->in.h.opcode = FUSE_IOCTL; in fuse_do_ioctl()
2600 req->in.h.nodeid = ff->nodeid; in fuse_do_ioctl()
2601 req->in.numargs = 1; in fuse_do_ioctl()
2602 req->in.args[0].size = sizeof(inarg); in fuse_do_ioctl()
2603 req->in.args[0].value = &inarg; in fuse_do_ioctl()
2605 req->in.numargs++; in fuse_do_ioctl()
2606 req->in.args[1].size = in_size; in fuse_do_ioctl()
2607 req->in.argpages = 1; in fuse_do_ioctl()
2609 err = -EFAULT; in fuse_do_ioctl()
2618 req->out.numargs = 2; in fuse_do_ioctl()
2619 req->out.args[0].size = sizeof(outarg); in fuse_do_ioctl()
2620 req->out.args[0].value = &outarg; in fuse_do_ioctl()
2621 req->out.args[1].size = out_size; in fuse_do_ioctl()
2622 req->out.argpages = 1; in fuse_do_ioctl()
2623 req->out.argvar = 1; in fuse_do_ioctl()
2626 err = req->out.h.error; in fuse_do_ioctl()
2627 transferred = req->out.args[1].size; in fuse_do_ioctl()
2638 err = -EIO; in fuse_do_ioctl()
2649 err = -ENOMEM; in fuse_do_ioctl()
2677 err = -EIO; in fuse_do_ioctl()
2681 err = -EFAULT; in fuse_do_ioctl()
2694 __free_page(pages[--num_pages]); in fuse_do_ioctl()
2708 return -EACCES; in fuse_ioctl_common()
2711 return -EIO; in fuse_ioctl_common()
2730 * fuse_conn->polled_files which is indexed by kh. Walk the tree and
2736 struct rb_node **link = &fc->polled_files.rb_node; in fuse_find_polled_node()
2745 if (kh < ff->kh) in fuse_find_polled_node()
2746 link = &last->rb_left; in fuse_find_polled_node()
2747 else if (kh > ff->kh) in fuse_find_polled_node()
2748 link = &last->rb_right; in fuse_find_polled_node()
2767 spin_lock(&fc->lock); in fuse_register_polled_file()
2768 if (RB_EMPTY_NODE(&ff->polled_node)) { in fuse_register_polled_file()
2771 link = fuse_find_polled_node(fc, ff->kh, &parent); in fuse_register_polled_file()
2773 rb_link_node(&ff->polled_node, parent, link); in fuse_register_polled_file()
2774 rb_insert_color(&ff->polled_node, &fc->polled_files); in fuse_register_polled_file()
2776 spin_unlock(&fc->lock); in fuse_register_polled_file()
2781 struct fuse_file *ff = file->private_data; in fuse_file_poll()
2782 struct fuse_conn *fc = ff->fc; in fuse_file_poll()
2783 struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh }; in fuse_file_poll()
2788 if (fc->no_poll) in fuse_file_poll()
2791 poll_wait(file, &ff->poll_wait, wait); in fuse_file_poll()
2798 if (waitqueue_active(&ff->poll_wait)) { in fuse_file_poll()
2804 args.in.h.nodeid = ff->nodeid; in fuse_file_poll()
2815 if (err == -ENOSYS) { in fuse_file_poll()
2816 fc->no_poll = 1; in fuse_file_poll()
2830 u64 kh = outarg->kh; in fuse_notify_poll_wakeup()
2833 spin_lock(&fc->lock); in fuse_notify_poll_wakeup()
2840 wake_up_interruptible_sync(&ff->poll_wait); in fuse_notify_poll_wakeup()
2843 spin_unlock(&fc->lock); in fuse_notify_poll_wakeup()
2849 struct inode *inode = file->f_mapping->host; in fuse_do_truncate()
2871 struct file *file = iocb->ki_filp; in fuse_direct_IO()
2872 struct fuse_file *ff = file->private_data; in fuse_direct_IO()
2873 bool async_dio = ff->fc->async_dio; in fuse_direct_IO()
2878 loff_t offset = iocb->ki_pos; in fuse_direct_IO()
2879 struct fuse_io_priv *io; in fuse_direct_IO() local
2882 inode = file->f_mapping->host; in fuse_direct_IO()
2892 iov_iter_truncate(iter, fuse_round_up(i_size - offset)); in fuse_direct_IO()
2896 io = kmalloc(sizeof(struct fuse_io_priv), GFP_KERNEL); in fuse_direct_IO()
2897 if (!io) in fuse_direct_IO()
2898 return -ENOMEM; in fuse_direct_IO()
2899 spin_lock_init(&io->lock); in fuse_direct_IO()
2900 kref_init(&io->refcnt); in fuse_direct_IO()
2901 io->reqs = 1; in fuse_direct_IO()
2902 io->bytes = -1; in fuse_direct_IO()
2903 io->size = 0; in fuse_direct_IO()
2904 io->offset = offset; in fuse_direct_IO()
2905 io->write = (iov_iter_rw(iter) == WRITE); in fuse_direct_IO()
2906 io->err = 0; in fuse_direct_IO()
2911 io->async = async_dio; in fuse_direct_IO()
2912 io->iocb = iocb; in fuse_direct_IO()
2913 io->blocking = is_sync_kiocb(iocb); in fuse_direct_IO()
2917 * In such case the aio will behave exactly like sync io. in fuse_direct_IO()
2920 io->blocking = true; in fuse_direct_IO()
2922 if (io->async && io->blocking) { in fuse_direct_IO()
2924 * Additional reference to keep io around after in fuse_direct_IO()
2927 kref_get(&io->refcnt); in fuse_direct_IO()
2928 io->done = &wait; in fuse_direct_IO()
2932 ret = fuse_direct_io(io, iter, &pos, FUSE_DIO_WRITE); in fuse_direct_IO()
2935 ret = __fuse_direct_read(io, iter, &pos); in fuse_direct_IO()
2938 if (io->async) { in fuse_direct_IO()
2939 bool blocking = io->blocking; in fuse_direct_IO() local
2941 fuse_aio_complete(io, ret < 0 ? ret : 0, -1); in fuse_direct_IO()
2943 /* we have a non-extending, async request, so return */ in fuse_direct_IO()
2944 if (!blocking) in fuse_direct_IO()
2945 return -EIOCBQUEUED; in fuse_direct_IO()
2948 ret = fuse_get_res_by_io(io); in fuse_direct_IO()
2951 kref_put(&io->refcnt, fuse_io_release); in fuse_direct_IO()
2966 struct fuse_file *ff = file->private_data; in fuse_file_fallocate()
2969 struct fuse_conn *fc = ff->fc; in fuse_file_fallocate()
2972 .fh = ff->fh, in fuse_file_fallocate()
2982 return -EOPNOTSUPP; in fuse_file_fallocate()
2984 if (fc->no_fallocate) in fuse_file_fallocate()
2985 return -EOPNOTSUPP; in fuse_file_fallocate()
2990 loff_t endbyte = offset + length - 1; in fuse_file_fallocate()
2991 err = filemap_write_and_wait_range(inode->i_mapping, in fuse_file_fallocate()
3008 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state); in fuse_file_fallocate()
3011 args.in.h.nodeid = ff->nodeid; in fuse_file_fallocate()
3016 if (err == -ENOSYS) { in fuse_file_fallocate()
3017 fc->no_fallocate = 1; in fuse_file_fallocate()
3018 err = -EOPNOTSUPP; in fuse_file_fallocate()
3027 if (changed && fc->writeback_cache) in fuse_file_fallocate()
3032 truncate_pagecache_range(inode, offset, offset + length - 1); in fuse_file_fallocate()
3038 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state); in fuse_file_fallocate()
3097 inode->i_fop = &fuse_file_operations; in fuse_init_file_inode()
3098 inode->i_data.a_ops = &fuse_file_aops; in fuse_init_file_inode()