1
2
3
4
5
6
7
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/slab.h>
13#include <linux/kernel.h>
14#include <linux/sched.h>
15#include <linux/module.h>
16#include <linux/compat.h>
17#include <linux/swap.h>
18#include <linux/aio.h>
19#include <linux/falloc.h>
20
21static const struct file_operations fuse_direct_io_file_operations;
22
23static int fuse_send_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
24 int opcode, struct fuse_open_out *outargp)
25{
26 struct fuse_open_in inarg;
27 struct fuse_req *req;
28 int err;
29
30 req = fuse_get_req_nopages(fc);
31 if (IS_ERR(req))
32 return PTR_ERR(req);
33
34 memset(&inarg, 0, sizeof(inarg));
35 inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY);
36 if (!fc->atomic_o_trunc)
37 inarg.flags &= ~O_TRUNC;
38 req->in.h.opcode = opcode;
39 req->in.h.nodeid = nodeid;
40 req->in.numargs = 1;
41 req->in.args[0].size = sizeof(inarg);
42 req->in.args[0].value = &inarg;
43 req->out.numargs = 1;
44 req->out.args[0].size = sizeof(*outargp);
45 req->out.args[0].value = outargp;
46 fuse_request_send(fc, req);
47 err = req->out.h.error;
48 fuse_put_request(fc, req);
49
50 return err;
51}
52
53struct fuse_file *fuse_file_alloc(struct fuse_conn *fc)
54{
55 struct fuse_file *ff;
56
57 ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
58 if (unlikely(!ff))
59 return NULL;
60
61 ff->fc = fc;
62 ff->reserved_req = fuse_request_alloc(0);
63 if (unlikely(!ff->reserved_req)) {
64 kfree(ff);
65 return NULL;
66 }
67
68 INIT_LIST_HEAD(&ff->write_entry);
69 atomic_set(&ff->count, 0);
70 RB_CLEAR_NODE(&ff->polled_node);
71 init_waitqueue_head(&ff->poll_wait);
72
73 spin_lock(&fc->lock);
74 ff->kh = ++fc->khctr;
75 spin_unlock(&fc->lock);
76
77 return ff;
78}
79
80void fuse_file_free(struct fuse_file *ff)
81{
82 fuse_request_free(ff->reserved_req);
83 kfree(ff);
84}
85
86struct fuse_file *fuse_file_get(struct fuse_file *ff)
87{
88 atomic_inc(&ff->count);
89 return ff;
90}
91
92static void fuse_release_async(struct work_struct *work)
93{
94 struct fuse_req *req;
95 struct fuse_conn *fc;
96 struct path path;
97
98 req = container_of(work, struct fuse_req, misc.release.work);
99 path = req->misc.release.path;
100 fc = get_fuse_conn(path.dentry->d_inode);
101
102 fuse_put_request(fc, req);
103 path_put(&path);
104}
105
106static void fuse_release_end(struct fuse_conn *fc, struct fuse_req *req)
107{
108 if (fc->destroy_req) {
109
110
111
112
113
114
115
116
117 atomic_inc(&req->count);
118 INIT_WORK(&req->misc.release.work, fuse_release_async);
119 schedule_work(&req->misc.release.work);
120 } else {
121 path_put(&req->misc.release.path);
122 }
123}
124
125static void fuse_file_put(struct fuse_file *ff, bool sync)
126{
127 if (atomic_dec_and_test(&ff->count)) {
128 struct fuse_req *req = ff->reserved_req;
129
130 if (ff->fc->no_open) {
131
132
133
134
135 req->background = 0;
136 path_put(&req->misc.release.path);
137 fuse_put_request(ff->fc, req);
138 } else if (sync) {
139 req->background = 0;
140 fuse_request_send(ff->fc, req);
141 path_put(&req->misc.release.path);
142 fuse_put_request(ff->fc, req);
143 } else {
144 req->end = fuse_release_end;
145 req->background = 1;
146 fuse_request_send_background(ff->fc, req);
147 }
148 kfree(ff);
149 }
150}
151
152int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
153 bool isdir)
154{
155 struct fuse_file *ff;
156 int opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
157
158 ff = fuse_file_alloc(fc);
159 if (!ff)
160 return -ENOMEM;
161
162 ff->fh = 0;
163 ff->open_flags = FOPEN_KEEP_CACHE;
164 if (!fc->no_open || isdir) {
165 struct fuse_open_out outarg;
166 int err;
167
168 err = fuse_send_open(fc, nodeid, file, opcode, &outarg);
169 if (!err) {
170 ff->fh = outarg.fh;
171 ff->open_flags = outarg.open_flags;
172
173 } else if (err != -ENOSYS || isdir) {
174 fuse_file_free(ff);
175 return err;
176 } else {
177 fc->no_open = 1;
178 }
179 }
180
181 if (isdir)
182 ff->open_flags &= ~FOPEN_DIRECT_IO;
183
184 ff->nodeid = nodeid;
185 file->private_data = fuse_file_get(ff);
186
187 return 0;
188}
189EXPORT_SYMBOL_GPL(fuse_do_open);
190
191static void fuse_link_write_file(struct file *file)
192{
193 struct inode *inode = file_inode(file);
194 struct fuse_conn *fc = get_fuse_conn(inode);
195 struct fuse_inode *fi = get_fuse_inode(inode);
196 struct fuse_file *ff = file->private_data;
197
198
199
200
201 spin_lock(&fc->lock);
202 if (list_empty(&ff->write_entry))
203 list_add(&ff->write_entry, &fi->write_files);
204 spin_unlock(&fc->lock);
205}
206
207void fuse_finish_open(struct inode *inode, struct file *file)
208{
209 struct fuse_file *ff = file->private_data;
210 struct fuse_conn *fc = get_fuse_conn(inode);
211
212 if (ff->open_flags & FOPEN_DIRECT_IO)
213 file->f_op = &fuse_direct_io_file_operations;
214 if (!(ff->open_flags & FOPEN_KEEP_CACHE))
215 invalidate_inode_pages2(inode->i_mapping);
216 if (ff->open_flags & FOPEN_NONSEEKABLE)
217 nonseekable_open(inode, file);
218 if (fc->atomic_o_trunc && (file->f_flags & O_TRUNC)) {
219 struct fuse_inode *fi = get_fuse_inode(inode);
220
221 spin_lock(&fc->lock);
222 fi->attr_version = ++fc->attr_version;
223 i_size_write(inode, 0);
224 spin_unlock(&fc->lock);
225 fuse_invalidate_attr(inode);
226 if (fc->writeback_cache)
227 file_update_time(file);
228 }
229 if ((file->f_mode & FMODE_WRITE) && fc->writeback_cache)
230 fuse_link_write_file(file);
231}
232
233int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
234{
235 struct fuse_conn *fc = get_fuse_conn(inode);
236 int err;
237 bool lock_inode = (file->f_flags & O_TRUNC) &&
238 fc->atomic_o_trunc &&
239 fc->writeback_cache;
240
241 err = generic_file_open(inode, file);
242 if (err)
243 return err;
244
245 if (lock_inode)
246 mutex_lock(&inode->i_mutex);
247
248 err = fuse_do_open(fc, get_node_id(inode), file, isdir);
249
250 if (!err)
251 fuse_finish_open(inode, file);
252
253 if (lock_inode)
254 mutex_unlock(&inode->i_mutex);
255
256 return err;
257}
258
259static void fuse_prepare_release(struct fuse_file *ff, int flags, int opcode)
260{
261 struct fuse_conn *fc = ff->fc;
262 struct fuse_req *req = ff->reserved_req;
263 struct fuse_release_in *inarg = &req->misc.release.in;
264
265 spin_lock(&fc->lock);
266 list_del(&ff->write_entry);
267 if (!RB_EMPTY_NODE(&ff->polled_node))
268 rb_erase(&ff->polled_node, &fc->polled_files);
269 spin_unlock(&fc->lock);
270
271 wake_up_interruptible_all(&ff->poll_wait);
272
273 inarg->fh = ff->fh;
274 inarg->flags = flags;
275 req->in.h.opcode = opcode;
276 req->in.h.nodeid = ff->nodeid;
277 req->in.numargs = 1;
278 req->in.args[0].size = sizeof(struct fuse_release_in);
279 req->in.args[0].value = inarg;
280}
281
282void fuse_release_common(struct file *file, int opcode)
283{
284 struct fuse_file *ff;
285 struct fuse_req *req;
286
287 ff = file->private_data;
288 if (unlikely(!ff))
289 return;
290
291 req = ff->reserved_req;
292 fuse_prepare_release(ff, file->f_flags, opcode);
293
294 if (ff->flock) {
295 struct fuse_release_in *inarg = &req->misc.release.in;
296 inarg->release_flags |= FUSE_RELEASE_FLOCK_UNLOCK;
297 inarg->lock_owner = fuse_lock_owner_id(ff->fc,
298 (fl_owner_t) file);
299 }
300
301 path_get(&file->f_path);
302 req->misc.release.path = file->f_path;
303
304
305
306
307
308
309
310
311
312
313 fuse_file_put(ff, ff->fc->destroy_req != NULL);
314}
315
316static int fuse_open(struct inode *inode, struct file *file)
317{
318 return fuse_open_common(inode, file, false);
319}
320
321static int fuse_release(struct inode *inode, struct file *file)
322{
323 struct fuse_conn *fc = get_fuse_conn(inode);
324
325
326 if (fc->writeback_cache)
327 write_inode_now(inode, 1);
328
329 fuse_release_common(file, FUSE_RELEASE);
330
331
332 return 0;
333}
334
335void fuse_sync_release(struct fuse_file *ff, int flags)
336{
337 WARN_ON(atomic_read(&ff->count) > 1);
338 fuse_prepare_release(ff, flags, FUSE_RELEASE);
339 ff->reserved_req->force = 1;
340 ff->reserved_req->background = 0;
341 fuse_request_send(ff->fc, ff->reserved_req);
342 fuse_put_request(ff->fc, ff->reserved_req);
343 kfree(ff);
344}
345EXPORT_SYMBOL_GPL(fuse_sync_release);
346
347
348
349
350
351u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
352{
353 u32 *k = fc->scramble_key;
354 u64 v = (unsigned long) id;
355 u32 v0 = v;
356 u32 v1 = v >> 32;
357 u32 sum = 0;
358 int i;
359
360 for (i = 0; i < 32; i++) {
361 v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
362 sum += 0x9E3779B9;
363 v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
364 }
365
366 return (u64) v0 + ((u64) v1 << 32);
367}
368
369
370
371
372
373
374
375static bool fuse_range_is_writeback(struct inode *inode, pgoff_t idx_from,
376 pgoff_t idx_to)
377{
378 struct fuse_conn *fc = get_fuse_conn(inode);
379 struct fuse_inode *fi = get_fuse_inode(inode);
380 struct fuse_req *req;
381 bool found = false;
382
383 spin_lock(&fc->lock);
384 list_for_each_entry(req, &fi->writepages, writepages_entry) {
385 pgoff_t curr_index;
386
387 BUG_ON(req->inode != inode);
388 curr_index = req->misc.write.in.offset >> PAGE_CACHE_SHIFT;
389 if (idx_from < curr_index + req->num_pages &&
390 curr_index <= idx_to) {
391 found = true;
392 break;
393 }
394 }
395 spin_unlock(&fc->lock);
396
397 return found;
398}
399
400static inline bool fuse_page_is_writeback(struct inode *inode, pgoff_t index)
401{
402 return fuse_range_is_writeback(inode, index, index);
403}
404
405
406
407
408
409
410
411static int fuse_wait_on_page_writeback(struct inode *inode, pgoff_t index)
412{
413 struct fuse_inode *fi = get_fuse_inode(inode);
414
415 wait_event(fi->page_waitq, !fuse_page_is_writeback(inode, index));
416 return 0;
417}
418
419
420
421
422
423
424
425
426
427
428static void fuse_sync_writes(struct inode *inode)
429{
430 fuse_set_nowrite(inode);
431 fuse_release_nowrite(inode);
432}
433
434static int fuse_flush(struct file *file, fl_owner_t id)
435{
436 struct inode *inode = file_inode(file);
437 struct fuse_conn *fc = get_fuse_conn(inode);
438 struct fuse_file *ff = file->private_data;
439 struct fuse_req *req;
440 struct fuse_flush_in inarg;
441 int err;
442
443 if (is_bad_inode(inode))
444 return -EIO;
445
446 if (fc->no_flush)
447 return 0;
448
449 err = write_inode_now(inode, 1);
450 if (err)
451 return err;
452
453 mutex_lock(&inode->i_mutex);
454 fuse_sync_writes(inode);
455 mutex_unlock(&inode->i_mutex);
456
457 req = fuse_get_req_nofail_nopages(fc, file);
458 memset(&inarg, 0, sizeof(inarg));
459 inarg.fh = ff->fh;
460 inarg.lock_owner = fuse_lock_owner_id(fc, id);
461 req->in.h.opcode = FUSE_FLUSH;
462 req->in.h.nodeid = get_node_id(inode);
463 req->in.numargs = 1;
464 req->in.args[0].size = sizeof(inarg);
465 req->in.args[0].value = &inarg;
466 req->force = 1;
467 fuse_request_send(fc, req);
468 err = req->out.h.error;
469 fuse_put_request(fc, req);
470 if (err == -ENOSYS) {
471 fc->no_flush = 1;
472 err = 0;
473 }
474 return err;
475}
476
477int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
478 int datasync, int isdir)
479{
480 struct inode *inode = file->f_mapping->host;
481 struct fuse_conn *fc = get_fuse_conn(inode);
482 struct fuse_file *ff = file->private_data;
483 struct fuse_req *req;
484 struct fuse_fsync_in inarg;
485 int err;
486
487 if (is_bad_inode(inode))
488 return -EIO;
489
490 mutex_lock(&inode->i_mutex);
491
492
493
494
495
496
497 err = filemap_write_and_wait_range(inode->i_mapping, start, end);
498 if (err)
499 goto out;
500
501 fuse_sync_writes(inode);
502 err = sync_inode_metadata(inode, 1);
503 if (err)
504 goto out;
505
506 if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))
507 goto out;
508
509 req = fuse_get_req_nopages(fc);
510 if (IS_ERR(req)) {
511 err = PTR_ERR(req);
512 goto out;
513 }
514
515 memset(&inarg, 0, sizeof(inarg));
516 inarg.fh = ff->fh;
517 inarg.fsync_flags = datasync ? 1 : 0;
518 req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;
519 req->in.h.nodeid = get_node_id(inode);
520 req->in.numargs = 1;
521 req->in.args[0].size = sizeof(inarg);
522 req->in.args[0].value = &inarg;
523 fuse_request_send(fc, req);
524 err = req->out.h.error;
525 fuse_put_request(fc, req);
526 if (err == -ENOSYS) {
527 if (isdir)
528 fc->no_fsyncdir = 1;
529 else
530 fc->no_fsync = 1;
531 err = 0;
532 }
533out:
534 mutex_unlock(&inode->i_mutex);
535 return err;
536}
537
538static int fuse_fsync(struct file *file, loff_t start, loff_t end,
539 int datasync)
540{
541 return fuse_fsync_common(file, start, end, datasync, 0);
542}
543
544void fuse_read_fill(struct fuse_req *req, struct file *file, loff_t pos,
545 size_t count, int opcode)
546{
547 struct fuse_read_in *inarg = &req->misc.read.in;
548 struct fuse_file *ff = file->private_data;
549
550 inarg->fh = ff->fh;
551 inarg->offset = pos;
552 inarg->size = count;
553 inarg->flags = file->f_flags;
554 req->in.h.opcode = opcode;
555 req->in.h.nodeid = ff->nodeid;
556 req->in.numargs = 1;
557 req->in.args[0].size = sizeof(struct fuse_read_in);
558 req->in.args[0].value = inarg;
559 req->out.argvar = 1;
560 req->out.numargs = 1;
561 req->out.args[0].size = count;
562}
563
564static void fuse_release_user_pages(struct fuse_req *req, int write)
565{
566 unsigned i;
567
568 for (i = 0; i < req->num_pages; i++) {
569 struct page *page = req->pages[i];
570 if (write)
571 set_page_dirty_lock(page);
572 put_page(page);
573 }
574}
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
593{
594 int left;
595
596 spin_lock(&io->lock);
597 if (err)
598 io->err = io->err ? : err;
599 else if (pos >= 0 && (io->bytes < 0 || pos < io->bytes))
600 io->bytes = pos;
601
602 left = --io->reqs;
603 spin_unlock(&io->lock);
604
605 if (!left) {
606 long res;
607
608 if (io->err)
609 res = io->err;
610 else if (io->bytes >= 0 && io->write)
611 res = -EIO;
612 else {
613 res = io->bytes < 0 ? io->size : io->bytes;
614
615 if (!is_sync_kiocb(io->iocb)) {
616 struct inode *inode = file_inode(io->iocb->ki_filp);
617 struct fuse_conn *fc = get_fuse_conn(inode);
618 struct fuse_inode *fi = get_fuse_inode(inode);
619
620 spin_lock(&fc->lock);
621 fi->attr_version = ++fc->attr_version;
622 spin_unlock(&fc->lock);
623 }
624 }
625
626 aio_complete(io->iocb, res, 0);
627 kfree(io);
628 }
629}
630
631static void fuse_aio_complete_req(struct fuse_conn *fc, struct fuse_req *req)
632{
633 struct fuse_io_priv *io = req->io;
634 ssize_t pos = -1;
635
636 fuse_release_user_pages(req, !io->write);
637
638 if (io->write) {
639 if (req->misc.write.in.size != req->misc.write.out.size)
640 pos = req->misc.write.in.offset - io->offset +
641 req->misc.write.out.size;
642 } else {
643 if (req->misc.read.in.size != req->out.args[0].size)
644 pos = req->misc.read.in.offset - io->offset +
645 req->out.args[0].size;
646 }
647
648 fuse_aio_complete(io, req->out.h.error, pos);
649}
650
651static size_t fuse_async_req_send(struct fuse_conn *fc, struct fuse_req *req,
652 size_t num_bytes, struct fuse_io_priv *io)
653{
654 spin_lock(&io->lock);
655 io->size += num_bytes;
656 io->reqs++;
657 spin_unlock(&io->lock);
658
659 req->io = io;
660 req->end = fuse_aio_complete_req;
661
662 __fuse_get_request(req);
663 fuse_request_send_background(fc, req);
664
665 return num_bytes;
666}
667
668static size_t fuse_send_read(struct fuse_req *req, struct fuse_io_priv *io,
669 loff_t pos, size_t count, fl_owner_t owner)
670{
671 struct file *file = io->file;
672 struct fuse_file *ff = file->private_data;
673 struct fuse_conn *fc = ff->fc;
674
675 fuse_read_fill(req, file, pos, count, FUSE_READ);
676 if (owner != NULL) {
677 struct fuse_read_in *inarg = &req->misc.read.in;
678
679 inarg->read_flags |= FUSE_READ_LOCKOWNER;
680 inarg->lock_owner = fuse_lock_owner_id(fc, owner);
681 }
682
683 if (io->async)
684 return fuse_async_req_send(fc, req, count, io);
685
686 fuse_request_send(fc, req);
687 return req->out.args[0].size;
688}
689
690static void fuse_read_update_size(struct inode *inode, loff_t size,
691 u64 attr_ver)
692{
693 struct fuse_conn *fc = get_fuse_conn(inode);
694 struct fuse_inode *fi = get_fuse_inode(inode);
695
696 spin_lock(&fc->lock);
697 if (attr_ver == fi->attr_version && size < inode->i_size &&
698 !test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
699 fi->attr_version = ++fc->attr_version;
700 i_size_write(inode, size);
701 }
702 spin_unlock(&fc->lock);
703}
704
705static void fuse_short_read(struct fuse_req *req, struct inode *inode,
706 u64 attr_ver)
707{
708 size_t num_read = req->out.args[0].size;
709 struct fuse_conn *fc = get_fuse_conn(inode);
710
711 if (fc->writeback_cache) {
712
713
714
715
716
717 int i;
718 int start_idx = num_read >> PAGE_CACHE_SHIFT;
719 size_t off = num_read & (PAGE_CACHE_SIZE - 1);
720
721 for (i = start_idx; i < req->num_pages; i++) {
722 zero_user_segment(req->pages[i], off, PAGE_CACHE_SIZE);
723 off = 0;
724 }
725 } else {
726 loff_t pos = page_offset(req->pages[0]) + num_read;
727 fuse_read_update_size(inode, pos, attr_ver);
728 }
729}
730
731static int fuse_do_readpage(struct file *file, struct page *page)
732{
733 struct fuse_io_priv io = { .async = 0, .file = file };
734 struct inode *inode = page->mapping->host;
735 struct fuse_conn *fc = get_fuse_conn(inode);
736 struct fuse_req *req;
737 size_t num_read;
738 loff_t pos = page_offset(page);
739 size_t count = PAGE_CACHE_SIZE;
740 u64 attr_ver;
741 int err;
742
743
744
745
746
747
748 fuse_wait_on_page_writeback(inode, page->index);
749
750 req = fuse_get_req(fc, 1);
751 if (IS_ERR(req))
752 return PTR_ERR(req);
753
754 attr_ver = fuse_get_attr_version(fc);
755
756 req->out.page_zeroing = 1;
757 req->out.argpages = 1;
758 req->num_pages = 1;
759 req->pages[0] = page;
760 req->page_descs[0].length = count;
761 num_read = fuse_send_read(req, &io, pos, count, NULL);
762 err = req->out.h.error;
763
764 if (!err) {
765
766
767
768 if (num_read < count)
769 fuse_short_read(req, inode, attr_ver);
770
771 SetPageUptodate(page);
772 }
773
774 fuse_put_request(fc, req);
775
776 return err;
777}
778
779static int fuse_readpage(struct file *file, struct page *page)
780{
781 struct inode *inode = page->mapping->host;
782 int err;
783
784 err = -EIO;
785 if (is_bad_inode(inode))
786 goto out;
787
788 err = fuse_do_readpage(file, page);
789 fuse_invalidate_atime(inode);
790 out:
791 unlock_page(page);
792 return err;
793}
794
795static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_req *req)
796{
797 int i;
798 size_t count = req->misc.read.in.size;
799 size_t num_read = req->out.args[0].size;
800 struct address_space *mapping = NULL;
801
802 for (i = 0; mapping == NULL && i < req->num_pages; i++)
803 mapping = req->pages[i]->mapping;
804
805 if (mapping) {
806 struct inode *inode = mapping->host;
807
808
809
810
811 if (!req->out.h.error && num_read < count)
812 fuse_short_read(req, inode, req->misc.read.attr_ver);
813
814 fuse_invalidate_atime(inode);
815 }
816
817 for (i = 0; i < req->num_pages; i++) {
818 struct page *page = req->pages[i];
819 if (!req->out.h.error)
820 SetPageUptodate(page);
821 else
822 SetPageError(page);
823 unlock_page(page);
824 page_cache_release(page);
825 }
826 if (req->ff)
827 fuse_file_put(req->ff, false);
828}
829
830static void fuse_send_readpages(struct fuse_req *req, struct file *file)
831{
832 struct fuse_file *ff = file->private_data;
833 struct fuse_conn *fc = ff->fc;
834 loff_t pos = page_offset(req->pages[0]);
835 size_t count = req->num_pages << PAGE_CACHE_SHIFT;
836
837 req->out.argpages = 1;
838 req->out.page_zeroing = 1;
839 req->out.page_replace = 1;
840 fuse_read_fill(req, file, pos, count, FUSE_READ);
841 req->misc.read.attr_ver = fuse_get_attr_version(fc);
842 if (fc->async_read) {
843 req->ff = fuse_file_get(ff);
844 req->end = fuse_readpages_end;
845 fuse_request_send_background(fc, req);
846 } else {
847 fuse_request_send(fc, req);
848 fuse_readpages_end(fc, req);
849 fuse_put_request(fc, req);
850 }
851}
852
853struct fuse_fill_data {
854 struct fuse_req *req;
855 struct file *file;
856 struct inode *inode;
857 unsigned nr_pages;
858};
859
860static int fuse_readpages_fill(void *_data, struct page *page)
861{
862 struct fuse_fill_data *data = _data;
863 struct fuse_req *req = data->req;
864 struct inode *inode = data->inode;
865 struct fuse_conn *fc = get_fuse_conn(inode);
866
867 fuse_wait_on_page_writeback(inode, page->index);
868
869 if (req->num_pages &&
870 (req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
871 (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read ||
872 req->pages[req->num_pages - 1]->index + 1 != page->index)) {
873 int nr_alloc = min_t(unsigned, data->nr_pages,
874 FUSE_MAX_PAGES_PER_REQ);
875 fuse_send_readpages(req, data->file);
876 if (fc->async_read)
877 req = fuse_get_req_for_background(fc, nr_alloc);
878 else
879 req = fuse_get_req(fc, nr_alloc);
880
881 data->req = req;
882 if (IS_ERR(req)) {
883 unlock_page(page);
884 return PTR_ERR(req);
885 }
886 }
887
888 if (WARN_ON(req->num_pages >= req->max_pages)) {
889 fuse_put_request(fc, req);
890 return -EIO;
891 }
892
893 page_cache_get(page);
894 req->pages[req->num_pages] = page;
895 req->page_descs[req->num_pages].length = PAGE_SIZE;
896 req->num_pages++;
897 data->nr_pages--;
898 return 0;
899}
900
901static int fuse_readpages(struct file *file, struct address_space *mapping,
902 struct list_head *pages, unsigned nr_pages)
903{
904 struct inode *inode = mapping->host;
905 struct fuse_conn *fc = get_fuse_conn(inode);
906 struct fuse_fill_data data;
907 int err;
908 int nr_alloc = min_t(unsigned, nr_pages, FUSE_MAX_PAGES_PER_REQ);
909
910 err = -EIO;
911 if (is_bad_inode(inode))
912 goto out;
913
914 data.file = file;
915 data.inode = inode;
916 if (fc->async_read)
917 data.req = fuse_get_req_for_background(fc, nr_alloc);
918 else
919 data.req = fuse_get_req(fc, nr_alloc);
920 data.nr_pages = nr_pages;
921 err = PTR_ERR(data.req);
922 if (IS_ERR(data.req))
923 goto out;
924
925 err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data);
926 if (!err) {
927 if (data.req->num_pages)
928 fuse_send_readpages(data.req, file);
929 else
930 fuse_put_request(fc, data.req);
931 }
932out:
933 return err;
934}
935
936static ssize_t fuse_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
937 unsigned long nr_segs, loff_t pos)
938{
939 struct inode *inode = iocb->ki_filp->f_mapping->host;
940 struct fuse_conn *fc = get_fuse_conn(inode);
941
942
943
944
945
946
947 if (fc->auto_inval_data ||
948 (pos + iov_length(iov, nr_segs) > i_size_read(inode))) {
949 int err;
950 err = fuse_update_attributes(inode, NULL, iocb->ki_filp, NULL);
951 if (err)
952 return err;
953 }
954
955 return generic_file_aio_read(iocb, iov, nr_segs, pos);
956}
957
958static void fuse_write_fill(struct fuse_req *req, struct fuse_file *ff,
959 loff_t pos, size_t count)
960{
961 struct fuse_write_in *inarg = &req->misc.write.in;
962 struct fuse_write_out *outarg = &req->misc.write.out;
963
964 inarg->fh = ff->fh;
965 inarg->offset = pos;
966 inarg->size = count;
967 req->in.h.opcode = FUSE_WRITE;
968 req->in.h.nodeid = ff->nodeid;
969 req->in.numargs = 2;
970 if (ff->fc->minor < 9)
971 req->in.args[0].size = FUSE_COMPAT_WRITE_IN_SIZE;
972 else
973 req->in.args[0].size = sizeof(struct fuse_write_in);
974 req->in.args[0].value = inarg;
975 req->in.args[1].size = count;
976 req->out.numargs = 1;
977 req->out.args[0].size = sizeof(struct fuse_write_out);
978 req->out.args[0].value = outarg;
979}
980
981static size_t fuse_send_write(struct fuse_req *req, struct fuse_io_priv *io,
982 loff_t pos, size_t count, fl_owner_t owner)
983{
984 struct file *file = io->file;
985 struct fuse_file *ff = file->private_data;
986 struct fuse_conn *fc = ff->fc;
987 struct fuse_write_in *inarg = &req->misc.write.in;
988
989 fuse_write_fill(req, ff, pos, count);
990 inarg->flags = file->f_flags;
991 if (owner != NULL) {
992 inarg->write_flags |= FUSE_WRITE_LOCKOWNER;
993 inarg->lock_owner = fuse_lock_owner_id(fc, owner);
994 }
995
996 if (io->async)
997 return fuse_async_req_send(fc, req, count, io);
998
999 fuse_request_send(fc, req);
1000 return req->misc.write.out.size;
1001}
1002
1003bool fuse_write_update_size(struct inode *inode, loff_t pos)
1004{
1005 struct fuse_conn *fc = get_fuse_conn(inode);
1006 struct fuse_inode *fi = get_fuse_inode(inode);
1007 bool ret = false;
1008
1009 spin_lock(&fc->lock);
1010 fi->attr_version = ++fc->attr_version;
1011 if (pos > inode->i_size) {
1012 i_size_write(inode, pos);
1013 ret = true;
1014 }
1015 spin_unlock(&fc->lock);
1016
1017 return ret;
1018}
1019
1020static size_t fuse_send_write_pages(struct fuse_req *req, struct file *file,
1021 struct inode *inode, loff_t pos,
1022 size_t count)
1023{
1024 size_t res;
1025 unsigned offset;
1026 unsigned i;
1027 struct fuse_io_priv io = { .async = 0, .file = file };
1028
1029 for (i = 0; i < req->num_pages; i++)
1030 fuse_wait_on_page_writeback(inode, req->pages[i]->index);
1031
1032 res = fuse_send_write(req, &io, pos, count, NULL);
1033
1034 offset = req->page_descs[0].offset;
1035 count = res;
1036 for (i = 0; i < req->num_pages; i++) {
1037 struct page *page = req->pages[i];
1038
1039 if (!req->out.h.error && !offset && count >= PAGE_CACHE_SIZE)
1040 SetPageUptodate(page);
1041
1042 if (count > PAGE_CACHE_SIZE - offset)
1043 count -= PAGE_CACHE_SIZE - offset;
1044 else
1045 count = 0;
1046 offset = 0;
1047
1048 unlock_page(page);
1049 page_cache_release(page);
1050 }
1051
1052 return res;
1053}
1054
1055static ssize_t fuse_fill_write_pages(struct fuse_req *req,
1056 struct address_space *mapping,
1057 struct iov_iter *ii, loff_t pos)
1058{
1059 struct fuse_conn *fc = get_fuse_conn(mapping->host);
1060 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1061 size_t count = 0;
1062 int err;
1063
1064 req->in.argpages = 1;
1065 req->page_descs[0].offset = offset;
1066
1067 do {
1068 size_t tmp;
1069 struct page *page;
1070 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
1071 size_t bytes = min_t(size_t, PAGE_CACHE_SIZE - offset,
1072 iov_iter_count(ii));
1073
1074 bytes = min_t(size_t, bytes, fc->max_write - count);
1075
1076 again:
1077 err = -EFAULT;
1078 if (iov_iter_fault_in_readable(ii, bytes))
1079 break;
1080
1081 err = -ENOMEM;
1082 page = grab_cache_page_write_begin(mapping, index, 0);
1083 if (!page)
1084 break;
1085
1086 if (mapping_writably_mapped(mapping))
1087 flush_dcache_page(page);
1088
1089 tmp = iov_iter_copy_from_user_atomic(page, ii, offset, bytes);
1090 flush_dcache_page(page);
1091
1092 mark_page_accessed(page);
1093
1094 if (!tmp) {
1095 unlock_page(page);
1096 page_cache_release(page);
1097 bytes = min(bytes, iov_iter_single_seg_count(ii));
1098 goto again;
1099 }
1100
1101 err = 0;
1102 req->pages[req->num_pages] = page;
1103 req->page_descs[req->num_pages].length = tmp;
1104 req->num_pages++;
1105
1106 iov_iter_advance(ii, tmp);
1107 count += tmp;
1108 pos += tmp;
1109 offset += tmp;
1110 if (offset == PAGE_CACHE_SIZE)
1111 offset = 0;
1112
1113 if (!fc->big_writes)
1114 break;
1115 } while (iov_iter_count(ii) && count < fc->max_write &&
1116 req->num_pages < req->max_pages && offset == 0);
1117
1118 return count > 0 ? count : err;
1119}
1120
1121static inline unsigned fuse_wr_pages(loff_t pos, size_t len)
1122{
1123 return min_t(unsigned,
1124 ((pos + len - 1) >> PAGE_CACHE_SHIFT) -
1125 (pos >> PAGE_CACHE_SHIFT) + 1,
1126 FUSE_MAX_PAGES_PER_REQ);
1127}
1128
1129static ssize_t fuse_perform_write(struct file *file,
1130 struct address_space *mapping,
1131 struct iov_iter *ii, loff_t pos)
1132{
1133 struct inode *inode = mapping->host;
1134 struct fuse_conn *fc = get_fuse_conn(inode);
1135 struct fuse_inode *fi = get_fuse_inode(inode);
1136 int err = 0;
1137 ssize_t res = 0;
1138
1139 if (is_bad_inode(inode))
1140 return -EIO;
1141
1142 if (inode->i_size < pos + iov_iter_count(ii))
1143 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1144
1145 do {
1146 struct fuse_req *req;
1147 ssize_t count;
1148 unsigned nr_pages = fuse_wr_pages(pos, iov_iter_count(ii));
1149
1150 req = fuse_get_req(fc, nr_pages);
1151 if (IS_ERR(req)) {
1152 err = PTR_ERR(req);
1153 break;
1154 }
1155
1156 count = fuse_fill_write_pages(req, mapping, ii, pos);
1157 if (count <= 0) {
1158 err = count;
1159 } else {
1160 size_t num_written;
1161
1162 num_written = fuse_send_write_pages(req, file, inode,
1163 pos, count);
1164 err = req->out.h.error;
1165 if (!err) {
1166 res += num_written;
1167 pos += num_written;
1168
1169
1170 if (num_written != count)
1171 err = -EIO;
1172 }
1173 }
1174 fuse_put_request(fc, req);
1175 } while (!err && iov_iter_count(ii));
1176
1177 if (res > 0)
1178 fuse_write_update_size(inode, pos);
1179
1180 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1181 fuse_invalidate_attr(inode);
1182
1183 return res > 0 ? res : err;
1184}
1185
1186static ssize_t fuse_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1187 unsigned long nr_segs, loff_t pos)
1188{
1189 struct file *file = iocb->ki_filp;
1190 struct address_space *mapping = file->f_mapping;
1191 size_t count = 0;
1192 size_t ocount = 0;
1193 ssize_t written = 0;
1194 ssize_t written_buffered = 0;
1195 struct inode *inode = mapping->host;
1196 ssize_t err;
1197 struct iov_iter i;
1198 loff_t endbyte = 0;
1199
1200 if (get_fuse_conn(inode)->writeback_cache) {
1201
1202 err = fuse_update_attributes(mapping->host, NULL, file, NULL);
1203 if (err)
1204 return err;
1205
1206 return generic_file_aio_write(iocb, iov, nr_segs, pos);
1207 }
1208
1209 WARN_ON(iocb->ki_pos != pos);
1210
1211 ocount = 0;
1212 err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
1213 if (err)
1214 return err;
1215
1216 count = ocount;
1217 mutex_lock(&inode->i_mutex);
1218
1219
1220 current->backing_dev_info = mapping->backing_dev_info;
1221
1222 err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
1223 if (err)
1224 goto out;
1225
1226 if (count == 0)
1227 goto out;
1228
1229 err = file_remove_suid(file);
1230 if (err)
1231 goto out;
1232
1233 err = file_update_time(file);
1234 if (err)
1235 goto out;
1236
1237 if (file->f_flags & O_DIRECT) {
1238 written = generic_file_direct_write(iocb, iov, &nr_segs, pos,
1239 count, ocount);
1240 if (written < 0 || written == count)
1241 goto out;
1242
1243 pos += written;
1244 count -= written;
1245
1246 iov_iter_init(&i, iov, nr_segs, count, written);
1247 written_buffered = fuse_perform_write(file, mapping, &i, pos);
1248 if (written_buffered < 0) {
1249 err = written_buffered;
1250 goto out;
1251 }
1252 endbyte = pos + written_buffered - 1;
1253
1254 err = filemap_write_and_wait_range(file->f_mapping, pos,
1255 endbyte);
1256 if (err)
1257 goto out;
1258
1259 invalidate_mapping_pages(file->f_mapping,
1260 pos >> PAGE_CACHE_SHIFT,
1261 endbyte >> PAGE_CACHE_SHIFT);
1262
1263 written += written_buffered;
1264 iocb->ki_pos = pos + written_buffered;
1265 } else {
1266 iov_iter_init(&i, iov, nr_segs, count, 0);
1267 written = fuse_perform_write(file, mapping, &i, pos);
1268 if (written >= 0)
1269 iocb->ki_pos = pos + written;
1270 }
1271out:
1272 current->backing_dev_info = NULL;
1273 mutex_unlock(&inode->i_mutex);
1274
1275 return written ? written : err;
1276}
1277
1278static inline void fuse_page_descs_length_init(struct fuse_req *req,
1279 unsigned index, unsigned nr_pages)
1280{
1281 int i;
1282
1283 for (i = index; i < index + nr_pages; i++)
1284 req->page_descs[i].length = PAGE_SIZE -
1285 req->page_descs[i].offset;
1286}
1287
1288static inline unsigned long fuse_get_user_addr(const struct iov_iter *ii)
1289{
1290 return (unsigned long)ii->iov->iov_base + ii->iov_offset;
1291}
1292
1293static inline size_t fuse_get_frag_size(const struct iov_iter *ii,
1294 size_t max_size)
1295{
1296 return min(iov_iter_single_seg_count(ii), max_size);
1297}
1298
1299static int fuse_get_user_pages(struct fuse_req *req, struct iov_iter *ii,
1300 size_t *nbytesp, int write)
1301{
1302 size_t nbytes = 0;
1303
1304
1305 if (segment_eq(get_fs(), KERNEL_DS)) {
1306 unsigned long user_addr = fuse_get_user_addr(ii);
1307 size_t frag_size = fuse_get_frag_size(ii, *nbytesp);
1308
1309 if (write)
1310 req->in.args[1].value = (void *) user_addr;
1311 else
1312 req->out.args[0].value = (void *) user_addr;
1313
1314 iov_iter_advance(ii, frag_size);
1315 *nbytesp = frag_size;
1316 return 0;
1317 }
1318
1319 while (nbytes < *nbytesp && req->num_pages < req->max_pages) {
1320 unsigned npages;
1321 unsigned long user_addr = fuse_get_user_addr(ii);
1322 unsigned offset = user_addr & ~PAGE_MASK;
1323 size_t frag_size = fuse_get_frag_size(ii, *nbytesp - nbytes);
1324 int ret;
1325
1326 unsigned n = req->max_pages - req->num_pages;
1327 frag_size = min_t(size_t, frag_size, n << PAGE_SHIFT);
1328
1329 npages = (frag_size + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
1330 npages = clamp(npages, 1U, n);
1331
1332 ret = get_user_pages_fast(user_addr, npages, !write,
1333 &req->pages[req->num_pages]);
1334 if (ret < 0)
1335 return ret;
1336
1337 npages = ret;
1338 frag_size = min_t(size_t, frag_size,
1339 (npages << PAGE_SHIFT) - offset);
1340 iov_iter_advance(ii, frag_size);
1341
1342 req->page_descs[req->num_pages].offset = offset;
1343 fuse_page_descs_length_init(req, req->num_pages, npages);
1344
1345 req->num_pages += npages;
1346 req->page_descs[req->num_pages - 1].length -=
1347 (npages << PAGE_SHIFT) - offset - frag_size;
1348
1349 nbytes += frag_size;
1350 }
1351
1352 if (write)
1353 req->in.argpages = 1;
1354 else
1355 req->out.argpages = 1;
1356
1357 *nbytesp = nbytes;
1358
1359 return 0;
1360}
1361
1362static inline int fuse_iter_npages(const struct iov_iter *ii_p)
1363{
1364 struct iov_iter ii = *ii_p;
1365 int npages = 0;
1366
1367 while (iov_iter_count(&ii) && npages < FUSE_MAX_PAGES_PER_REQ) {
1368 unsigned long user_addr = fuse_get_user_addr(&ii);
1369 unsigned offset = user_addr & ~PAGE_MASK;
1370 size_t frag_size = iov_iter_single_seg_count(&ii);
1371
1372 npages += (frag_size + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
1373 iov_iter_advance(&ii, frag_size);
1374 }
1375
1376 return min(npages, FUSE_MAX_PAGES_PER_REQ);
1377}
1378
1379ssize_t fuse_direct_io(struct fuse_io_priv *io, const struct iovec *iov,
1380 unsigned long nr_segs, size_t count, loff_t *ppos,
1381 int flags)
1382{
1383 int write = flags & FUSE_DIO_WRITE;
1384 int cuse = flags & FUSE_DIO_CUSE;
1385 struct file *file = io->file;
1386 struct inode *inode = file->f_mapping->host;
1387 struct fuse_file *ff = file->private_data;
1388 struct fuse_conn *fc = ff->fc;
1389 size_t nmax = write ? fc->max_write : fc->max_read;
1390 loff_t pos = *ppos;
1391 pgoff_t idx_from = pos >> PAGE_CACHE_SHIFT;
1392 pgoff_t idx_to = (pos + count - 1) >> PAGE_CACHE_SHIFT;
1393 ssize_t res = 0;
1394 struct fuse_req *req;
1395 struct iov_iter ii;
1396
1397 iov_iter_init(&ii, iov, nr_segs, count, 0);
1398
1399 if (io->async)
1400 req = fuse_get_req_for_background(fc, fuse_iter_npages(&ii));
1401 else
1402 req = fuse_get_req(fc, fuse_iter_npages(&ii));
1403 if (IS_ERR(req))
1404 return PTR_ERR(req);
1405
1406 if (!cuse && fuse_range_is_writeback(inode, idx_from, idx_to)) {
1407 if (!write)
1408 mutex_lock(&inode->i_mutex);
1409 fuse_sync_writes(inode);
1410 if (!write)
1411 mutex_unlock(&inode->i_mutex);
1412 }
1413
1414 while (count) {
1415 size_t nres;
1416 fl_owner_t owner = current->files;
1417 size_t nbytes = min(count, nmax);
1418 int err = fuse_get_user_pages(req, &ii, &nbytes, write);
1419 if (err) {
1420 res = err;
1421 break;
1422 }
1423
1424 if (write)
1425 nres = fuse_send_write(req, io, pos, nbytes, owner);
1426 else
1427 nres = fuse_send_read(req, io, pos, nbytes, owner);
1428
1429 if (!io->async)
1430 fuse_release_user_pages(req, !write);
1431 if (req->out.h.error) {
1432 if (!res)
1433 res = req->out.h.error;
1434 break;
1435 } else if (nres > nbytes) {
1436 res = -EIO;
1437 break;
1438 }
1439 count -= nres;
1440 res += nres;
1441 pos += nres;
1442 if (nres != nbytes)
1443 break;
1444 if (count) {
1445 fuse_put_request(fc, req);
1446 if (io->async)
1447 req = fuse_get_req_for_background(fc,
1448 fuse_iter_npages(&ii));
1449 else
1450 req = fuse_get_req(fc, fuse_iter_npages(&ii));
1451 if (IS_ERR(req))
1452 break;
1453 }
1454 }
1455 if (!IS_ERR(req))
1456 fuse_put_request(fc, req);
1457 if (res > 0)
1458 *ppos = pos;
1459
1460 return res;
1461}
1462EXPORT_SYMBOL_GPL(fuse_direct_io);
1463
1464static ssize_t __fuse_direct_read(struct fuse_io_priv *io,
1465 const struct iovec *iov,
1466 unsigned long nr_segs, loff_t *ppos,
1467 size_t count)
1468{
1469 ssize_t res;
1470 struct file *file = io->file;
1471 struct inode *inode = file_inode(file);
1472
1473 if (is_bad_inode(inode))
1474 return -EIO;
1475
1476 res = fuse_direct_io(io, iov, nr_segs, count, ppos, 0);
1477
1478 fuse_invalidate_attr(inode);
1479
1480 return res;
1481}
1482
1483static ssize_t fuse_direct_read(struct file *file, char __user *buf,
1484 size_t count, loff_t *ppos)
1485{
1486 struct fuse_io_priv io = { .async = 0, .file = file };
1487 struct iovec iov = { .iov_base = buf, .iov_len = count };
1488 return __fuse_direct_read(&io, &iov, 1, ppos, count);
1489}
1490
1491static ssize_t __fuse_direct_write(struct fuse_io_priv *io,
1492 const struct iovec *iov,
1493 unsigned long nr_segs, loff_t *ppos)
1494{
1495 struct file *file = io->file;
1496 struct inode *inode = file_inode(file);
1497 size_t count = iov_length(iov, nr_segs);
1498 ssize_t res;
1499
1500 res = generic_write_checks(file, ppos, &count, 0);
1501 if (!res)
1502 res = fuse_direct_io(io, iov, nr_segs, count, ppos,
1503 FUSE_DIO_WRITE);
1504
1505 fuse_invalidate_attr(inode);
1506
1507 return res;
1508}
1509
1510static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
1511 size_t count, loff_t *ppos)
1512{
1513 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
1514 struct inode *inode = file_inode(file);
1515 ssize_t res;
1516 struct fuse_io_priv io = { .async = 0, .file = file };
1517
1518 if (is_bad_inode(inode))
1519 return -EIO;
1520
1521
1522 mutex_lock(&inode->i_mutex);
1523 res = __fuse_direct_write(&io, &iov, 1, ppos);
1524 if (res > 0)
1525 fuse_write_update_size(inode, *ppos);
1526 mutex_unlock(&inode->i_mutex);
1527
1528 return res;
1529}
1530
1531static void fuse_writepage_free(struct fuse_conn *fc, struct fuse_req *req)
1532{
1533 int i;
1534
1535 for (i = 0; i < req->num_pages; i++)
1536 __free_page(req->pages[i]);
1537
1538 if (req->ff)
1539 fuse_file_put(req->ff, false);
1540}
1541
1542static void fuse_writepage_finish(struct fuse_conn *fc, struct fuse_req *req)
1543{
1544 struct inode *inode = req->inode;
1545 struct fuse_inode *fi = get_fuse_inode(inode);
1546 struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info;
1547 int i;
1548
1549 list_del(&req->writepages_entry);
1550 for (i = 0; i < req->num_pages; i++) {
1551 dec_bdi_stat(bdi, BDI_WRITEBACK);
1552 dec_zone_page_state(req->pages[i], NR_WRITEBACK_TEMP);
1553 bdi_writeout_inc(bdi);
1554 }
1555 wake_up(&fi->page_waitq);
1556}
1557
1558
1559static void fuse_send_writepage(struct fuse_conn *fc, struct fuse_req *req,
1560 loff_t size)
1561__releases(fc->lock)
1562__acquires(fc->lock)
1563{
1564 struct fuse_inode *fi = get_fuse_inode(req->inode);
1565 struct fuse_write_in *inarg = &req->misc.write.in;
1566 __u64 data_size = req->num_pages * PAGE_CACHE_SIZE;
1567
1568 if (!fc->connected)
1569 goto out_free;
1570
1571 if (inarg->offset + data_size <= size) {
1572 inarg->size = data_size;
1573 } else if (inarg->offset < size) {
1574 inarg->size = size - inarg->offset;
1575 } else {
1576
1577 goto out_free;
1578 }
1579
1580 req->in.args[1].size = inarg->size;
1581 fi->writectr++;
1582 fuse_request_send_background_locked(fc, req);
1583 return;
1584
1585 out_free:
1586 fuse_writepage_finish(fc, req);
1587 spin_unlock(&fc->lock);
1588 fuse_writepage_free(fc, req);
1589 fuse_put_request(fc, req);
1590 spin_lock(&fc->lock);
1591}
1592
1593
1594
1595
1596
1597
1598
1599void fuse_flush_writepages(struct inode *inode)
1600__releases(fc->lock)
1601__acquires(fc->lock)
1602{
1603 struct fuse_conn *fc = get_fuse_conn(inode);
1604 struct fuse_inode *fi = get_fuse_inode(inode);
1605 size_t crop = i_size_read(inode);
1606 struct fuse_req *req;
1607
1608 while (fi->writectr >= 0 && !list_empty(&fi->queued_writes)) {
1609 req = list_entry(fi->queued_writes.next, struct fuse_req, list);
1610 list_del_init(&req->list);
1611 fuse_send_writepage(fc, req, crop);
1612 }
1613}
1614
1615static void fuse_writepage_end(struct fuse_conn *fc, struct fuse_req *req)
1616{
1617 struct inode *inode = req->inode;
1618 struct fuse_inode *fi = get_fuse_inode(inode);
1619
1620 mapping_set_error(inode->i_mapping, req->out.h.error);
1621 spin_lock(&fc->lock);
1622 while (req->misc.write.next) {
1623 struct fuse_conn *fc = get_fuse_conn(inode);
1624 struct fuse_write_in *inarg = &req->misc.write.in;
1625 struct fuse_req *next = req->misc.write.next;
1626 req->misc.write.next = next->misc.write.next;
1627 next->misc.write.next = NULL;
1628 next->ff = fuse_file_get(req->ff);
1629 list_add(&next->writepages_entry, &fi->writepages);
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654 fuse_send_writepage(fc, next, inarg->offset + inarg->size);
1655 }
1656 fi->writectr--;
1657 fuse_writepage_finish(fc, req);
1658 spin_unlock(&fc->lock);
1659 fuse_writepage_free(fc, req);
1660}
1661
1662static struct fuse_file *__fuse_write_file_get(struct fuse_conn *fc,
1663 struct fuse_inode *fi)
1664{
1665 struct fuse_file *ff = NULL;
1666
1667 spin_lock(&fc->lock);
1668 if (!list_empty(&fi->write_files)) {
1669 ff = list_entry(fi->write_files.next, struct fuse_file,
1670 write_entry);
1671 fuse_file_get(ff);
1672 }
1673 spin_unlock(&fc->lock);
1674
1675 return ff;
1676}
1677
1678static struct fuse_file *fuse_write_file_get(struct fuse_conn *fc,
1679 struct fuse_inode *fi)
1680{
1681 struct fuse_file *ff = __fuse_write_file_get(fc, fi);
1682 WARN_ON(!ff);
1683 return ff;
1684}
1685
1686int fuse_write_inode(struct inode *inode, struct writeback_control *wbc)
1687{
1688 struct fuse_conn *fc = get_fuse_conn(inode);
1689 struct fuse_inode *fi = get_fuse_inode(inode);
1690 struct fuse_file *ff;
1691 int err;
1692
1693 ff = __fuse_write_file_get(fc, fi);
1694 err = fuse_flush_times(inode, ff);
1695 if (ff)
1696 fuse_file_put(ff, 0);
1697
1698 return err;
1699}
1700
1701static int fuse_writepage_locked(struct page *page)
1702{
1703 struct address_space *mapping = page->mapping;
1704 struct inode *inode = mapping->host;
1705 struct fuse_conn *fc = get_fuse_conn(inode);
1706 struct fuse_inode *fi = get_fuse_inode(inode);
1707 struct fuse_req *req;
1708 struct page *tmp_page;
1709 int error = -ENOMEM;
1710
1711 set_page_writeback(page);
1712
1713 req = fuse_request_alloc_nofs(1);
1714 if (!req)
1715 goto err;
1716
1717 req->background = 1;
1718 tmp_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
1719 if (!tmp_page)
1720 goto err_free;
1721
1722 error = -EIO;
1723 req->ff = fuse_write_file_get(fc, fi);
1724 if (!req->ff)
1725 goto err_free;
1726
1727 fuse_write_fill(req, req->ff, page_offset(page), 0);
1728
1729 copy_highpage(tmp_page, page);
1730 req->misc.write.in.write_flags |= FUSE_WRITE_CACHE;
1731 req->misc.write.next = NULL;
1732 req->in.argpages = 1;
1733 req->num_pages = 1;
1734 req->pages[0] = tmp_page;
1735 req->page_descs[0].offset = 0;
1736 req->page_descs[0].length = PAGE_SIZE;
1737 req->end = fuse_writepage_end;
1738 req->inode = inode;
1739
1740 inc_bdi_stat(mapping->backing_dev_info, BDI_WRITEBACK);
1741 inc_zone_page_state(tmp_page, NR_WRITEBACK_TEMP);
1742
1743 spin_lock(&fc->lock);
1744 list_add(&req->writepages_entry, &fi->writepages);
1745 list_add_tail(&req->list, &fi->queued_writes);
1746 fuse_flush_writepages(inode);
1747 spin_unlock(&fc->lock);
1748
1749 end_page_writeback(page);
1750
1751 return 0;
1752
1753err_free:
1754 fuse_request_free(req);
1755err:
1756 end_page_writeback(page);
1757 return error;
1758}
1759
1760static int fuse_writepage(struct page *page, struct writeback_control *wbc)
1761{
1762 int err;
1763
1764 if (fuse_page_is_writeback(page->mapping->host, page->index)) {
1765
1766
1767
1768
1769
1770 WARN_ON(wbc->sync_mode == WB_SYNC_ALL);
1771
1772 redirty_page_for_writepage(wbc, page);
1773 return 0;
1774 }
1775
1776 err = fuse_writepage_locked(page);
1777 unlock_page(page);
1778
1779 return err;
1780}
1781
1782struct fuse_fill_wb_data {
1783 struct fuse_req *req;
1784 struct fuse_file *ff;
1785 struct inode *inode;
1786 struct page **orig_pages;
1787};
1788
1789static void fuse_writepages_send(struct fuse_fill_wb_data *data)
1790{
1791 struct fuse_req *req = data->req;
1792 struct inode *inode = data->inode;
1793 struct fuse_conn *fc = get_fuse_conn(inode);
1794 struct fuse_inode *fi = get_fuse_inode(inode);
1795 int num_pages = req->num_pages;
1796 int i;
1797
1798 req->ff = fuse_file_get(data->ff);
1799 spin_lock(&fc->lock);
1800 list_add_tail(&req->list, &fi->queued_writes);
1801 fuse_flush_writepages(inode);
1802 spin_unlock(&fc->lock);
1803
1804 for (i = 0; i < num_pages; i++)
1805 end_page_writeback(data->orig_pages[i]);
1806}
1807
1808static bool fuse_writepage_in_flight(struct fuse_req *new_req,
1809 struct page *page)
1810{
1811 struct fuse_conn *fc = get_fuse_conn(new_req->inode);
1812 struct fuse_inode *fi = get_fuse_inode(new_req->inode);
1813 struct fuse_req *tmp;
1814 struct fuse_req *old_req;
1815 bool found = false;
1816 pgoff_t curr_index;
1817
1818 BUG_ON(new_req->num_pages != 0);
1819
1820 spin_lock(&fc->lock);
1821 list_del(&new_req->writepages_entry);
1822 list_for_each_entry(old_req, &fi->writepages, writepages_entry) {
1823 BUG_ON(old_req->inode != new_req->inode);
1824 curr_index = old_req->misc.write.in.offset >> PAGE_CACHE_SHIFT;
1825 if (curr_index <= page->index &&
1826 page->index < curr_index + old_req->num_pages) {
1827 found = true;
1828 break;
1829 }
1830 }
1831 if (!found) {
1832 list_add(&new_req->writepages_entry, &fi->writepages);
1833 goto out_unlock;
1834 }
1835
1836 new_req->num_pages = 1;
1837 for (tmp = old_req; tmp != NULL; tmp = tmp->misc.write.next) {
1838 BUG_ON(tmp->inode != new_req->inode);
1839 curr_index = tmp->misc.write.in.offset >> PAGE_CACHE_SHIFT;
1840 if (tmp->num_pages == 1 &&
1841 curr_index == page->index) {
1842 old_req = tmp;
1843 }
1844 }
1845
1846 if (old_req->num_pages == 1 && (old_req->state == FUSE_REQ_INIT ||
1847 old_req->state == FUSE_REQ_PENDING)) {
1848 struct backing_dev_info *bdi = page->mapping->backing_dev_info;
1849
1850 copy_highpage(old_req->pages[0], page);
1851 spin_unlock(&fc->lock);
1852
1853 dec_bdi_stat(bdi, BDI_WRITEBACK);
1854 dec_zone_page_state(page, NR_WRITEBACK_TEMP);
1855 bdi_writeout_inc(bdi);
1856 fuse_writepage_free(fc, new_req);
1857 fuse_request_free(new_req);
1858 goto out;
1859 } else {
1860 new_req->misc.write.next = old_req->misc.write.next;
1861 old_req->misc.write.next = new_req;
1862 }
1863out_unlock:
1864 spin_unlock(&fc->lock);
1865out:
1866 return found;
1867}
1868
1869static int fuse_writepages_fill(struct page *page,
1870 struct writeback_control *wbc, void *_data)
1871{
1872 struct fuse_fill_wb_data *data = _data;
1873 struct fuse_req *req = data->req;
1874 struct inode *inode = data->inode;
1875 struct fuse_conn *fc = get_fuse_conn(inode);
1876 struct page *tmp_page;
1877 bool is_writeback;
1878 int err;
1879
1880 if (!data->ff) {
1881 err = -EIO;
1882 data->ff = fuse_write_file_get(fc, get_fuse_inode(inode));
1883 if (!data->ff)
1884 goto out_unlock;
1885 }
1886
1887
1888
1889
1890
1891
1892
1893 is_writeback = fuse_page_is_writeback(inode, page->index);
1894
1895 if (req && req->num_pages &&
1896 (is_writeback || req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
1897 (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_write ||
1898 data->orig_pages[req->num_pages - 1]->index + 1 != page->index)) {
1899 fuse_writepages_send(data);
1900 data->req = NULL;
1901 }
1902 err = -ENOMEM;
1903 tmp_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
1904 if (!tmp_page)
1905 goto out_unlock;
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920 if (data->req == NULL) {
1921 struct fuse_inode *fi = get_fuse_inode(inode);
1922
1923 err = -ENOMEM;
1924 req = fuse_request_alloc_nofs(FUSE_MAX_PAGES_PER_REQ);
1925 if (!req) {
1926 __free_page(tmp_page);
1927 goto out_unlock;
1928 }
1929
1930 fuse_write_fill(req, data->ff, page_offset(page), 0);
1931 req->misc.write.in.write_flags |= FUSE_WRITE_CACHE;
1932 req->misc.write.next = NULL;
1933 req->in.argpages = 1;
1934 req->background = 1;
1935 req->num_pages = 0;
1936 req->end = fuse_writepage_end;
1937 req->inode = inode;
1938
1939 spin_lock(&fc->lock);
1940 list_add(&req->writepages_entry, &fi->writepages);
1941 spin_unlock(&fc->lock);
1942
1943 data->req = req;
1944 }
1945 set_page_writeback(page);
1946
1947 copy_highpage(tmp_page, page);
1948 req->pages[req->num_pages] = tmp_page;
1949 req->page_descs[req->num_pages].offset = 0;
1950 req->page_descs[req->num_pages].length = PAGE_SIZE;
1951
1952 inc_bdi_stat(page->mapping->backing_dev_info, BDI_WRITEBACK);
1953 inc_zone_page_state(tmp_page, NR_WRITEBACK_TEMP);
1954
1955 err = 0;
1956 if (is_writeback && fuse_writepage_in_flight(req, page)) {
1957 end_page_writeback(page);
1958 data->req = NULL;
1959 goto out_unlock;
1960 }
1961 data->orig_pages[req->num_pages] = page;
1962
1963
1964
1965
1966
1967 spin_lock(&fc->lock);
1968 req->num_pages++;
1969 spin_unlock(&fc->lock);
1970
1971out_unlock:
1972 unlock_page(page);
1973
1974 return err;
1975}
1976
1977static int fuse_writepages(struct address_space *mapping,
1978 struct writeback_control *wbc)
1979{
1980 struct inode *inode = mapping->host;
1981 struct fuse_fill_wb_data data;
1982 int err;
1983
1984 err = -EIO;
1985 if (is_bad_inode(inode))
1986 goto out;
1987
1988 data.inode = inode;
1989 data.req = NULL;
1990 data.ff = NULL;
1991
1992 err = -ENOMEM;
1993 data.orig_pages = kzalloc(sizeof(struct page *) *
1994 FUSE_MAX_PAGES_PER_REQ,
1995 GFP_NOFS);
1996 if (!data.orig_pages)
1997 goto out;
1998
1999 err = write_cache_pages(mapping, wbc, fuse_writepages_fill, &data);
2000 if (data.req) {
2001
2002 BUG_ON(!data.req->num_pages);
2003 fuse_writepages_send(&data);
2004 err = 0;
2005 }
2006 if (data.ff)
2007 fuse_file_put(data.ff, false);
2008
2009 kfree(data.orig_pages);
2010out:
2011 return err;
2012}
2013
2014
2015
2016
2017
2018static int fuse_write_begin(struct file *file, struct address_space *mapping,
2019 loff_t pos, unsigned len, unsigned flags,
2020 struct page **pagep, void **fsdata)
2021{
2022 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2023 struct fuse_conn *fc = get_fuse_conn(file->f_dentry->d_inode);
2024 struct page *page;
2025 loff_t fsize;
2026 int err = -ENOMEM;
2027
2028 WARN_ON(!fc->writeback_cache);
2029
2030 page = grab_cache_page_write_begin(mapping, index, flags);
2031 if (!page)
2032 goto error;
2033
2034 fuse_wait_on_page_writeback(mapping->host, page->index);
2035
2036 if (PageUptodate(page) || len == PAGE_CACHE_SIZE)
2037 goto success;
2038
2039
2040
2041
2042 fsize = i_size_read(mapping->host);
2043 if (fsize <= (pos & PAGE_CACHE_MASK)) {
2044 size_t off = pos & ~PAGE_CACHE_MASK;
2045 if (off)
2046 zero_user_segment(page, 0, off);
2047 goto success;
2048 }
2049 err = fuse_do_readpage(file, page);
2050 if (err)
2051 goto cleanup;
2052success:
2053 *pagep = page;
2054 return 0;
2055
2056cleanup:
2057 unlock_page(page);
2058 page_cache_release(page);
2059error:
2060 return err;
2061}
2062
2063static int fuse_write_end(struct file *file, struct address_space *mapping,
2064 loff_t pos, unsigned len, unsigned copied,
2065 struct page *page, void *fsdata)
2066{
2067 struct inode *inode = page->mapping->host;
2068
2069 if (!PageUptodate(page)) {
2070
2071 size_t endoff = (pos + copied) & ~PAGE_CACHE_MASK;
2072 if (endoff)
2073 zero_user_segment(page, endoff, PAGE_CACHE_SIZE);
2074 SetPageUptodate(page);
2075 }
2076
2077 fuse_write_update_size(inode, pos + copied);
2078 set_page_dirty(page);
2079 unlock_page(page);
2080 page_cache_release(page);
2081
2082 return copied;
2083}
2084
2085static int fuse_launder_page(struct page *page)
2086{
2087 int err = 0;
2088 if (clear_page_dirty_for_io(page)) {
2089 struct inode *inode = page->mapping->host;
2090 err = fuse_writepage_locked(page);
2091 if (!err)
2092 fuse_wait_on_page_writeback(inode, page->index);
2093 }
2094 return err;
2095}
2096
2097
2098
2099
2100
2101static void fuse_vma_close(struct vm_area_struct *vma)
2102{
2103 filemap_write_and_wait(vma->vm_file->f_mapping);
2104}
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121static int fuse_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2122{
2123 struct page *page = vmf->page;
2124 struct inode *inode = file_inode(vma->vm_file);
2125
2126 file_update_time(vma->vm_file);
2127 lock_page(page);
2128 if (page->mapping != inode->i_mapping) {
2129 unlock_page(page);
2130 return VM_FAULT_NOPAGE;
2131 }
2132
2133 fuse_wait_on_page_writeback(inode, page->index);
2134 return VM_FAULT_LOCKED;
2135}
2136
2137static const struct vm_operations_struct fuse_file_vm_ops = {
2138 .close = fuse_vma_close,
2139 .fault = filemap_fault,
2140 .map_pages = filemap_map_pages,
2141 .page_mkwrite = fuse_page_mkwrite,
2142 .remap_pages = generic_file_remap_pages,
2143};
2144
2145static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
2146{
2147 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE))
2148 fuse_link_write_file(file);
2149
2150 file_accessed(file);
2151 vma->vm_ops = &fuse_file_vm_ops;
2152 return 0;
2153}
2154
2155static int fuse_direct_mmap(struct file *file, struct vm_area_struct *vma)
2156{
2157
2158 if (vma->vm_flags & VM_MAYSHARE)
2159 return -ENODEV;
2160
2161 invalidate_inode_pages2(file->f_mapping);
2162
2163 return generic_file_mmap(file, vma);
2164}
2165
2166static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
2167 struct file_lock *fl)
2168{
2169 switch (ffl->type) {
2170 case F_UNLCK:
2171 break;
2172
2173 case F_RDLCK:
2174 case F_WRLCK:
2175 if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX ||
2176 ffl->end < ffl->start)
2177 return -EIO;
2178
2179 fl->fl_start = ffl->start;
2180 fl->fl_end = ffl->end;
2181 fl->fl_pid = ffl->pid;
2182 break;
2183
2184 default:
2185 return -EIO;
2186 }
2187 fl->fl_type = ffl->type;
2188 return 0;
2189}
2190
2191static void fuse_lk_fill(struct fuse_req *req, struct file *file,
2192 const struct file_lock *fl, int opcode, pid_t pid,
2193 int flock)
2194{
2195 struct inode *inode = file_inode(file);
2196 struct fuse_conn *fc = get_fuse_conn(inode);
2197 struct fuse_file *ff = file->private_data;
2198 struct fuse_lk_in *arg = &req->misc.lk_in;
2199
2200 arg->fh = ff->fh;
2201 arg->owner = fuse_lock_owner_id(fc, fl->fl_owner);
2202 arg->lk.start = fl->fl_start;
2203 arg->lk.end = fl->fl_end;
2204 arg->lk.type = fl->fl_type;
2205 arg->lk.pid = pid;
2206 if (flock)
2207 arg->lk_flags |= FUSE_LK_FLOCK;
2208 req->in.h.opcode = opcode;
2209 req->in.h.nodeid = get_node_id(inode);
2210 req->in.numargs = 1;
2211 req->in.args[0].size = sizeof(*arg);
2212 req->in.args[0].value = arg;
2213}
2214
2215static int fuse_getlk(struct file *file, struct file_lock *fl)
2216{
2217 struct inode *inode = file_inode(file);
2218 struct fuse_conn *fc = get_fuse_conn(inode);
2219 struct fuse_req *req;
2220 struct fuse_lk_out outarg;
2221 int err;
2222
2223 req = fuse_get_req_nopages(fc);
2224 if (IS_ERR(req))
2225 return PTR_ERR(req);
2226
2227 fuse_lk_fill(req, file, fl, FUSE_GETLK, 0, 0);
2228 req->out.numargs = 1;
2229 req->out.args[0].size = sizeof(outarg);
2230 req->out.args[0].value = &outarg;
2231 fuse_request_send(fc, req);
2232 err = req->out.h.error;
2233 fuse_put_request(fc, req);
2234 if (!err)
2235 err = convert_fuse_file_lock(&outarg.lk, fl);
2236
2237 return err;
2238}
2239
2240static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)
2241{
2242 struct inode *inode = file_inode(file);
2243 struct fuse_conn *fc = get_fuse_conn(inode);
2244 struct fuse_req *req;
2245 int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
2246 pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0;
2247 int err;
2248
2249 if (fl->fl_lmops && fl->fl_lmops->lm_grant) {
2250
2251 return -ENOLCK;
2252 }
2253
2254
2255 if (fl->fl_flags & FL_CLOSE)
2256 return 0;
2257
2258 req = fuse_get_req_nopages(fc);
2259 if (IS_ERR(req))
2260 return PTR_ERR(req);
2261
2262 fuse_lk_fill(req, file, fl, opcode, pid, flock);
2263 fuse_request_send(fc, req);
2264 err = req->out.h.error;
2265
2266 if (err == -EINTR)
2267 err = -ERESTARTSYS;
2268 fuse_put_request(fc, req);
2269 return err;
2270}
2271
2272static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
2273{
2274 struct inode *inode = file_inode(file);
2275 struct fuse_conn *fc = get_fuse_conn(inode);
2276 int err;
2277
2278 if (cmd == F_CANCELLK) {
2279 err = 0;
2280 } else if (cmd == F_GETLK) {
2281 if (fc->no_lock) {
2282 posix_test_lock(file, fl);
2283 err = 0;
2284 } else
2285 err = fuse_getlk(file, fl);
2286 } else {
2287 if (fc->no_lock)
2288 err = posix_lock_file(file, fl, NULL);
2289 else
2290 err = fuse_setlk(file, fl, 0);
2291 }
2292 return err;
2293}
2294
2295static int fuse_file_flock(struct file *file, int cmd, struct file_lock *fl)
2296{
2297 struct inode *inode = file_inode(file);
2298 struct fuse_conn *fc = get_fuse_conn(inode);
2299 int err;
2300
2301 if (fc->no_flock) {
2302 err = flock_lock_file_wait(file, fl);
2303 } else {
2304 struct fuse_file *ff = file->private_data;
2305
2306
2307 fl->fl_owner = (fl_owner_t) file;
2308 ff->flock = true;
2309 err = fuse_setlk(file, fl, 1);
2310 }
2311
2312 return err;
2313}
2314
2315static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
2316{
2317 struct inode *inode = mapping->host;
2318 struct fuse_conn *fc = get_fuse_conn(inode);
2319 struct fuse_req *req;
2320 struct fuse_bmap_in inarg;
2321 struct fuse_bmap_out outarg;
2322 int err;
2323
2324 if (!inode->i_sb->s_bdev || fc->no_bmap)
2325 return 0;
2326
2327 req = fuse_get_req_nopages(fc);
2328 if (IS_ERR(req))
2329 return 0;
2330
2331 memset(&inarg, 0, sizeof(inarg));
2332 inarg.block = block;
2333 inarg.blocksize = inode->i_sb->s_blocksize;
2334 req->in.h.opcode = FUSE_BMAP;
2335 req->in.h.nodeid = get_node_id(inode);
2336 req->in.numargs = 1;
2337 req->in.args[0].size = sizeof(inarg);
2338 req->in.args[0].value = &inarg;
2339 req->out.numargs = 1;
2340 req->out.args[0].size = sizeof(outarg);
2341 req->out.args[0].value = &outarg;
2342 fuse_request_send(fc, req);
2343 err = req->out.h.error;
2344 fuse_put_request(fc, req);
2345 if (err == -ENOSYS)
2346 fc->no_bmap = 1;
2347
2348 return err ? 0 : outarg.block;
2349}
2350
2351static loff_t fuse_file_llseek(struct file *file, loff_t offset, int whence)
2352{
2353 loff_t retval;
2354 struct inode *inode = file_inode(file);
2355
2356
2357 if (whence == SEEK_CUR || whence == SEEK_SET)
2358 return generic_file_llseek(file, offset, whence);
2359
2360 mutex_lock(&inode->i_mutex);
2361 retval = fuse_update_attributes(inode, NULL, file, NULL);
2362 if (!retval)
2363 retval = generic_file_llseek(file, offset, whence);
2364 mutex_unlock(&inode->i_mutex);
2365
2366 return retval;
2367}
2368
2369static int fuse_ioctl_copy_user(struct page **pages, struct iovec *iov,
2370 unsigned int nr_segs, size_t bytes, bool to_user)
2371{
2372 struct iov_iter ii;
2373 int page_idx = 0;
2374
2375 if (!bytes)
2376 return 0;
2377
2378 iov_iter_init(&ii, iov, nr_segs, bytes, 0);
2379
2380 while (iov_iter_count(&ii)) {
2381 struct page *page = pages[page_idx++];
2382 size_t todo = min_t(size_t, PAGE_SIZE, iov_iter_count(&ii));
2383 void *kaddr;
2384
2385 kaddr = kmap(page);
2386
2387 while (todo) {
2388 char __user *uaddr = ii.iov->iov_base + ii.iov_offset;
2389 size_t iov_len = ii.iov->iov_len - ii.iov_offset;
2390 size_t copy = min(todo, iov_len);
2391 size_t left;
2392
2393 if (!to_user)
2394 left = copy_from_user(kaddr, uaddr, copy);
2395 else
2396 left = copy_to_user(uaddr, kaddr, copy);
2397
2398 if (unlikely(left))
2399 return -EFAULT;
2400
2401 iov_iter_advance(&ii, copy);
2402 todo -= copy;
2403 kaddr += copy;
2404 }
2405
2406 kunmap(page);
2407 }
2408
2409 return 0;
2410}
2411
2412
2413
2414
2415
2416
2417
2418static int fuse_copy_ioctl_iovec_old(struct iovec *dst, void *src,
2419 size_t transferred, unsigned count,
2420 bool is_compat)
2421{
2422#ifdef CONFIG_COMPAT
2423 if (count * sizeof(struct compat_iovec) == transferred) {
2424 struct compat_iovec *ciov = src;
2425 unsigned i;
2426
2427
2428
2429
2430
2431
2432 if (!is_compat)
2433 return -EINVAL;
2434
2435 for (i = 0; i < count; i++) {
2436 dst[i].iov_base = compat_ptr(ciov[i].iov_base);
2437 dst[i].iov_len = ciov[i].iov_len;
2438 }
2439 return 0;
2440 }
2441#endif
2442
2443 if (count * sizeof(struct iovec) != transferred)
2444 return -EIO;
2445
2446 memcpy(dst, src, transferred);
2447 return 0;
2448}
2449
2450
2451static int fuse_verify_ioctl_iov(struct iovec *iov, size_t count)
2452{
2453 size_t n;
2454 u32 max = FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT;
2455
2456 for (n = 0; n < count; n++, iov++) {
2457 if (iov->iov_len > (size_t) max)
2458 return -ENOMEM;
2459 max -= iov->iov_len;
2460 }
2461 return 0;
2462}
2463
2464static int fuse_copy_ioctl_iovec(struct fuse_conn *fc, struct iovec *dst,
2465 void *src, size_t transferred, unsigned count,
2466 bool is_compat)
2467{
2468 unsigned i;
2469 struct fuse_ioctl_iovec *fiov = src;
2470
2471 if (fc->minor < 16) {
2472 return fuse_copy_ioctl_iovec_old(dst, src, transferred,
2473 count, is_compat);
2474 }
2475
2476 if (count * sizeof(struct fuse_ioctl_iovec) != transferred)
2477 return -EIO;
2478
2479 for (i = 0; i < count; i++) {
2480
2481 if (fiov[i].base != (unsigned long) fiov[i].base ||
2482 fiov[i].len != (unsigned long) fiov[i].len)
2483 return -EIO;
2484
2485 dst[i].iov_base = (void __user *) (unsigned long) fiov[i].base;
2486 dst[i].iov_len = (size_t) fiov[i].len;
2487
2488#ifdef CONFIG_COMPAT
2489 if (is_compat &&
2490 (ptr_to_compat(dst[i].iov_base) != fiov[i].base ||
2491 (compat_size_t) dst[i].iov_len != fiov[i].len))
2492 return -EIO;
2493#endif
2494 }
2495
2496 return 0;
2497}
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
2547 unsigned int flags)
2548{
2549 struct fuse_file *ff = file->private_data;
2550 struct fuse_conn *fc = ff->fc;
2551 struct fuse_ioctl_in inarg = {
2552 .fh = ff->fh,
2553 .cmd = cmd,
2554 .arg = arg,
2555 .flags = flags
2556 };
2557 struct fuse_ioctl_out outarg;
2558 struct fuse_req *req = NULL;
2559 struct page **pages = NULL;
2560 struct iovec *iov_page = NULL;
2561 struct iovec *in_iov = NULL, *out_iov = NULL;
2562 unsigned int in_iovs = 0, out_iovs = 0, num_pages = 0, max_pages;
2563 size_t in_size, out_size, transferred;
2564 int err;
2565
2566#if BITS_PER_LONG == 32
2567 inarg.flags |= FUSE_IOCTL_32BIT;
2568#else
2569 if (flags & FUSE_IOCTL_COMPAT)
2570 inarg.flags |= FUSE_IOCTL_32BIT;
2571#endif
2572
2573
2574 BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE);
2575
2576 err = -ENOMEM;
2577 pages = kcalloc(FUSE_MAX_PAGES_PER_REQ, sizeof(pages[0]), GFP_KERNEL);
2578 iov_page = (struct iovec *) __get_free_page(GFP_KERNEL);
2579 if (!pages || !iov_page)
2580 goto out;
2581
2582
2583
2584
2585
2586 if (!(flags & FUSE_IOCTL_UNRESTRICTED)) {
2587 struct iovec *iov = iov_page;
2588
2589 iov->iov_base = (void __user *)arg;
2590 iov->iov_len = _IOC_SIZE(cmd);
2591
2592 if (_IOC_DIR(cmd) & _IOC_WRITE) {
2593 in_iov = iov;
2594 in_iovs = 1;
2595 }
2596
2597 if (_IOC_DIR(cmd) & _IOC_READ) {
2598 out_iov = iov;
2599 out_iovs = 1;
2600 }
2601 }
2602
2603 retry:
2604 inarg.in_size = in_size = iov_length(in_iov, in_iovs);
2605 inarg.out_size = out_size = iov_length(out_iov, out_iovs);
2606
2607
2608
2609
2610
2611 out_size = max_t(size_t, out_size, PAGE_SIZE);
2612 max_pages = DIV_ROUND_UP(max(in_size, out_size), PAGE_SIZE);
2613
2614
2615 err = -ENOMEM;
2616 if (max_pages > FUSE_MAX_PAGES_PER_REQ)
2617 goto out;
2618 while (num_pages < max_pages) {
2619 pages[num_pages] = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
2620 if (!pages[num_pages])
2621 goto out;
2622 num_pages++;
2623 }
2624
2625 req = fuse_get_req(fc, num_pages);
2626 if (IS_ERR(req)) {
2627 err = PTR_ERR(req);
2628 req = NULL;
2629 goto out;
2630 }
2631 memcpy(req->pages, pages, sizeof(req->pages[0]) * num_pages);
2632 req->num_pages = num_pages;
2633 fuse_page_descs_length_init(req, 0, req->num_pages);
2634
2635
2636 req->in.h.opcode = FUSE_IOCTL;
2637 req->in.h.nodeid = ff->nodeid;
2638 req->in.numargs = 1;
2639 req->in.args[0].size = sizeof(inarg);
2640 req->in.args[0].value = &inarg;
2641 if (in_size) {
2642 req->in.numargs++;
2643 req->in.args[1].size = in_size;
2644 req->in.argpages = 1;
2645
2646 err = fuse_ioctl_copy_user(pages, in_iov, in_iovs, in_size,
2647 false);
2648 if (err)
2649 goto out;
2650 }
2651
2652 req->out.numargs = 2;
2653 req->out.args[0].size = sizeof(outarg);
2654 req->out.args[0].value = &outarg;
2655 req->out.args[1].size = out_size;
2656 req->out.argpages = 1;
2657 req->out.argvar = 1;
2658
2659 fuse_request_send(fc, req);
2660 err = req->out.h.error;
2661 transferred = req->out.args[1].size;
2662 fuse_put_request(fc, req);
2663 req = NULL;
2664 if (err)
2665 goto out;
2666
2667
2668 if (outarg.flags & FUSE_IOCTL_RETRY) {
2669 void *vaddr;
2670
2671
2672 err = -EIO;
2673 if (!(flags & FUSE_IOCTL_UNRESTRICTED))
2674 goto out;
2675
2676 in_iovs = outarg.in_iovs;
2677 out_iovs = outarg.out_iovs;
2678
2679
2680
2681
2682
2683 err = -ENOMEM;
2684 if (in_iovs > FUSE_IOCTL_MAX_IOV ||
2685 out_iovs > FUSE_IOCTL_MAX_IOV ||
2686 in_iovs + out_iovs > FUSE_IOCTL_MAX_IOV)
2687 goto out;
2688
2689 vaddr = kmap_atomic(pages[0]);
2690 err = fuse_copy_ioctl_iovec(fc, iov_page, vaddr,
2691 transferred, in_iovs + out_iovs,
2692 (flags & FUSE_IOCTL_COMPAT) != 0);
2693 kunmap_atomic(vaddr);
2694 if (err)
2695 goto out;
2696
2697 in_iov = iov_page;
2698 out_iov = in_iov + in_iovs;
2699
2700 err = fuse_verify_ioctl_iov(in_iov, in_iovs);
2701 if (err)
2702 goto out;
2703
2704 err = fuse_verify_ioctl_iov(out_iov, out_iovs);
2705 if (err)
2706 goto out;
2707
2708 goto retry;
2709 }
2710
2711 err = -EIO;
2712 if (transferred > inarg.out_size)
2713 goto out;
2714
2715 err = fuse_ioctl_copy_user(pages, out_iov, out_iovs, transferred, true);
2716 out:
2717 if (req)
2718 fuse_put_request(fc, req);
2719 free_page((unsigned long) iov_page);
2720 while (num_pages)
2721 __free_page(pages[--num_pages]);
2722 kfree(pages);
2723
2724 return err ? err : outarg.result;
2725}
2726EXPORT_SYMBOL_GPL(fuse_do_ioctl);
2727
2728long fuse_ioctl_common(struct file *file, unsigned int cmd,
2729 unsigned long arg, unsigned int flags)
2730{
2731 struct inode *inode = file_inode(file);
2732 struct fuse_conn *fc = get_fuse_conn(inode);
2733
2734 if (!fuse_allow_current_process(fc))
2735 return -EACCES;
2736
2737 if (is_bad_inode(inode))
2738 return -EIO;
2739
2740 return fuse_do_ioctl(file, cmd, arg, flags);
2741}
2742
2743static long fuse_file_ioctl(struct file *file, unsigned int cmd,
2744 unsigned long arg)
2745{
2746 return fuse_ioctl_common(file, cmd, arg, 0);
2747}
2748
2749static long fuse_file_compat_ioctl(struct file *file, unsigned int cmd,
2750 unsigned long arg)
2751{
2752 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_COMPAT);
2753}
2754
2755
2756
2757
2758
2759
2760static struct rb_node **fuse_find_polled_node(struct fuse_conn *fc, u64 kh,
2761 struct rb_node **parent_out)
2762{
2763 struct rb_node **link = &fc->polled_files.rb_node;
2764 struct rb_node *last = NULL;
2765
2766 while (*link) {
2767 struct fuse_file *ff;
2768
2769 last = *link;
2770 ff = rb_entry(last, struct fuse_file, polled_node);
2771
2772 if (kh < ff->kh)
2773 link = &last->rb_left;
2774 else if (kh > ff->kh)
2775 link = &last->rb_right;
2776 else
2777 return link;
2778 }
2779
2780 if (parent_out)
2781 *parent_out = last;
2782 return link;
2783}
2784
2785
2786
2787
2788
2789
2790
2791static void fuse_register_polled_file(struct fuse_conn *fc,
2792 struct fuse_file *ff)
2793{
2794 spin_lock(&fc->lock);
2795 if (RB_EMPTY_NODE(&ff->polled_node)) {
2796 struct rb_node **link, *uninitialized_var(parent);
2797
2798 link = fuse_find_polled_node(fc, ff->kh, &parent);
2799 BUG_ON(*link);
2800 rb_link_node(&ff->polled_node, parent, link);
2801 rb_insert_color(&ff->polled_node, &fc->polled_files);
2802 }
2803 spin_unlock(&fc->lock);
2804}
2805
2806unsigned fuse_file_poll(struct file *file, poll_table *wait)
2807{
2808 struct fuse_file *ff = file->private_data;
2809 struct fuse_conn *fc = ff->fc;
2810 struct fuse_poll_in inarg = { .fh = ff->fh, .kh = ff->kh };
2811 struct fuse_poll_out outarg;
2812 struct fuse_req *req;
2813 int err;
2814
2815 if (fc->no_poll)
2816 return DEFAULT_POLLMASK;
2817
2818 poll_wait(file, &ff->poll_wait, wait);
2819 inarg.events = (__u32)poll_requested_events(wait);
2820
2821
2822
2823
2824
2825 if (waitqueue_active(&ff->poll_wait)) {
2826 inarg.flags |= FUSE_POLL_SCHEDULE_NOTIFY;
2827 fuse_register_polled_file(fc, ff);
2828 }
2829
2830 req = fuse_get_req_nopages(fc);
2831 if (IS_ERR(req))
2832 return POLLERR;
2833
2834 req->in.h.opcode = FUSE_POLL;
2835 req->in.h.nodeid = ff->nodeid;
2836 req->in.numargs = 1;
2837 req->in.args[0].size = sizeof(inarg);
2838 req->in.args[0].value = &inarg;
2839 req->out.numargs = 1;
2840 req->out.args[0].size = sizeof(outarg);
2841 req->out.args[0].value = &outarg;
2842 fuse_request_send(fc, req);
2843 err = req->out.h.error;
2844 fuse_put_request(fc, req);
2845
2846 if (!err)
2847 return outarg.revents;
2848 if (err == -ENOSYS) {
2849 fc->no_poll = 1;
2850 return DEFAULT_POLLMASK;
2851 }
2852 return POLLERR;
2853}
2854EXPORT_SYMBOL_GPL(fuse_file_poll);
2855
2856
2857
2858
2859
2860int fuse_notify_poll_wakeup(struct fuse_conn *fc,
2861 struct fuse_notify_poll_wakeup_out *outarg)
2862{
2863 u64 kh = outarg->kh;
2864 struct rb_node **link;
2865
2866 spin_lock(&fc->lock);
2867
2868 link = fuse_find_polled_node(fc, kh, NULL);
2869 if (*link) {
2870 struct fuse_file *ff;
2871
2872 ff = rb_entry(*link, struct fuse_file, polled_node);
2873 wake_up_interruptible_sync(&ff->poll_wait);
2874 }
2875
2876 spin_unlock(&fc->lock);
2877 return 0;
2878}
2879
2880static void fuse_do_truncate(struct file *file)
2881{
2882 struct inode *inode = file->f_mapping->host;
2883 struct iattr attr;
2884
2885 attr.ia_valid = ATTR_SIZE;
2886 attr.ia_size = i_size_read(inode);
2887
2888 attr.ia_file = file;
2889 attr.ia_valid |= ATTR_FILE;
2890
2891 fuse_do_setattr(inode, &attr, file);
2892}
2893
2894static inline loff_t fuse_round_up(loff_t off)
2895{
2896 return round_up(off, FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
2897}
2898
2899static ssize_t
2900fuse_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
2901 loff_t offset, unsigned long nr_segs)
2902{
2903 ssize_t ret = 0;
2904 struct file *file = iocb->ki_filp;
2905 struct fuse_file *ff = file->private_data;
2906 bool async_dio = ff->fc->async_dio;
2907 loff_t pos = 0;
2908 struct inode *inode;
2909 loff_t i_size;
2910 size_t count = iov_length(iov, nr_segs);
2911 struct fuse_io_priv *io;
2912
2913 pos = offset;
2914 inode = file->f_mapping->host;
2915 i_size = i_size_read(inode);
2916
2917 if ((rw == READ) && (offset > i_size))
2918 return 0;
2919
2920
2921 if (async_dio && rw != WRITE && offset + count > i_size) {
2922 if (offset >= i_size)
2923 return 0;
2924 count = min_t(loff_t, count, fuse_round_up(i_size - offset));
2925 }
2926
2927 io = kmalloc(sizeof(struct fuse_io_priv), GFP_KERNEL);
2928 if (!io)
2929 return -ENOMEM;
2930 spin_lock_init(&io->lock);
2931 io->reqs = 1;
2932 io->bytes = -1;
2933 io->size = 0;
2934 io->offset = offset;
2935 io->write = (rw == WRITE);
2936 io->err = 0;
2937 io->file = file;
2938
2939
2940
2941
2942 io->async = async_dio;
2943 io->iocb = iocb;
2944
2945
2946
2947
2948
2949
2950 if (!is_sync_kiocb(iocb) && (offset + count > i_size) && rw == WRITE)
2951 io->async = false;
2952
2953 if (rw == WRITE)
2954 ret = __fuse_direct_write(io, iov, nr_segs, &pos);
2955 else
2956 ret = __fuse_direct_read(io, iov, nr_segs, &pos, count);
2957
2958 if (io->async) {
2959 fuse_aio_complete(io, ret < 0 ? ret : 0, -1);
2960
2961
2962 if (!is_sync_kiocb(iocb))
2963 return -EIOCBQUEUED;
2964
2965 ret = wait_on_sync_kiocb(iocb);
2966 } else {
2967 kfree(io);
2968 }
2969
2970 if (rw == WRITE) {
2971 if (ret > 0)
2972 fuse_write_update_size(inode, pos);
2973 else if (ret < 0 && offset + count > i_size)
2974 fuse_do_truncate(file);
2975 }
2976
2977 return ret;
2978}
2979
2980static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
2981 loff_t length)
2982{
2983 struct fuse_file *ff = file->private_data;
2984 struct inode *inode = file->f_inode;
2985 struct fuse_inode *fi = get_fuse_inode(inode);
2986 struct fuse_conn *fc = ff->fc;
2987 struct fuse_req *req;
2988 struct fuse_fallocate_in inarg = {
2989 .fh = ff->fh,
2990 .offset = offset,
2991 .length = length,
2992 .mode = mode
2993 };
2994 int err;
2995 bool lock_inode = !(mode & FALLOC_FL_KEEP_SIZE) ||
2996 (mode & FALLOC_FL_PUNCH_HOLE);
2997
2998 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
2999 return -EOPNOTSUPP;
3000
3001 if (fc->no_fallocate)
3002 return -EOPNOTSUPP;
3003
3004 if (lock_inode) {
3005 mutex_lock(&inode->i_mutex);
3006 if (mode & FALLOC_FL_PUNCH_HOLE) {
3007 loff_t endbyte = offset + length - 1;
3008 err = filemap_write_and_wait_range(inode->i_mapping,
3009 offset, endbyte);
3010 if (err)
3011 goto out;
3012
3013 fuse_sync_writes(inode);
3014 }
3015 }
3016
3017 if (!(mode & FALLOC_FL_KEEP_SIZE))
3018 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
3019
3020 req = fuse_get_req_nopages(fc);
3021 if (IS_ERR(req)) {
3022 err = PTR_ERR(req);
3023 goto out;
3024 }
3025
3026 req->in.h.opcode = FUSE_FALLOCATE;
3027 req->in.h.nodeid = ff->nodeid;
3028 req->in.numargs = 1;
3029 req->in.args[0].size = sizeof(inarg);
3030 req->in.args[0].value = &inarg;
3031 fuse_request_send(fc, req);
3032 err = req->out.h.error;
3033 if (err == -ENOSYS) {
3034 fc->no_fallocate = 1;
3035 err = -EOPNOTSUPP;
3036 }
3037 fuse_put_request(fc, req);
3038
3039 if (err)
3040 goto out;
3041
3042
3043 if (!(mode & FALLOC_FL_KEEP_SIZE)) {
3044 bool changed = fuse_write_update_size(inode, offset + length);
3045
3046 if (changed && fc->writeback_cache)
3047 file_update_time(file);
3048 }
3049
3050 if (mode & FALLOC_FL_PUNCH_HOLE)
3051 truncate_pagecache_range(inode, offset, offset + length - 1);
3052
3053 fuse_invalidate_attr(inode);
3054
3055out:
3056 if (!(mode & FALLOC_FL_KEEP_SIZE))
3057 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
3058
3059 if (lock_inode)
3060 mutex_unlock(&inode->i_mutex);
3061
3062 return err;
3063}
3064
3065static const struct file_operations fuse_file_operations = {
3066 .llseek = fuse_file_llseek,
3067 .read = do_sync_read,
3068 .aio_read = fuse_file_aio_read,
3069 .write = do_sync_write,
3070 .aio_write = fuse_file_aio_write,
3071 .mmap = fuse_file_mmap,
3072 .open = fuse_open,
3073 .flush = fuse_flush,
3074 .release = fuse_release,
3075 .fsync = fuse_fsync,
3076 .lock = fuse_file_lock,
3077 .flock = fuse_file_flock,
3078 .splice_read = generic_file_splice_read,
3079 .unlocked_ioctl = fuse_file_ioctl,
3080 .compat_ioctl = fuse_file_compat_ioctl,
3081 .poll = fuse_file_poll,
3082 .fallocate = fuse_file_fallocate,
3083};
3084
3085static const struct file_operations fuse_direct_io_file_operations = {
3086 .llseek = fuse_file_llseek,
3087 .read = fuse_direct_read,
3088 .write = fuse_direct_write,
3089 .mmap = fuse_direct_mmap,
3090 .open = fuse_open,
3091 .flush = fuse_flush,
3092 .release = fuse_release,
3093 .fsync = fuse_fsync,
3094 .lock = fuse_file_lock,
3095 .flock = fuse_file_flock,
3096 .unlocked_ioctl = fuse_file_ioctl,
3097 .compat_ioctl = fuse_file_compat_ioctl,
3098 .poll = fuse_file_poll,
3099 .fallocate = fuse_file_fallocate,
3100
3101};
3102
3103static const struct address_space_operations fuse_file_aops = {
3104 .readpage = fuse_readpage,
3105 .writepage = fuse_writepage,
3106 .writepages = fuse_writepages,
3107 .launder_page = fuse_launder_page,
3108 .readpages = fuse_readpages,
3109 .set_page_dirty = __set_page_dirty_nobuffers,
3110 .bmap = fuse_bmap,
3111 .direct_IO = fuse_direct_IO,
3112 .write_begin = fuse_write_begin,
3113 .write_end = fuse_write_end,
3114};
3115
3116void fuse_init_file_inode(struct inode *inode)
3117{
3118 inode->i_fop = &fuse_file_operations;
3119 inode->i_data.a_ops = &fuse_file_aops;
3120}
3121