Merge tag 'linux-kselftest-kunit-fixes-5.15-rc6' of git://git.kernel.org/pub/scm...
[linux-2.6-microblaze.git] / fs / 9p / vfs_file.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/fs/9p/vfs_file.c
4  *
5  * This file contians vfs file ops for 9P2000.
6  *
7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9  */
10
11 #include <linux/module.h>
12 #include <linux/errno.h>
13 #include <linux/fs.h>
14 #include <linux/sched.h>
15 #include <linux/file.h>
16 #include <linux/stat.h>
17 #include <linux/string.h>
18 #include <linux/inet.h>
19 #include <linux/list.h>
20 #include <linux/pagemap.h>
21 #include <linux/utsname.h>
22 #include <linux/uaccess.h>
23 #include <linux/idr.h>
24 #include <linux/uio.h>
25 #include <linux/slab.h>
26 #include <net/9p/9p.h>
27 #include <net/9p/client.h>
28
29 #include "v9fs.h"
30 #include "v9fs_vfs.h"
31 #include "fid.h"
32 #include "cache.h"
33
34 static const struct vm_operations_struct v9fs_file_vm_ops;
35 static const struct vm_operations_struct v9fs_mmap_file_vm_ops;
36
37 /**
38  * v9fs_file_open - open a file (or directory)
39  * @inode: inode to be opened
40  * @file: file being opened
41  *
42  */
43
44 int v9fs_file_open(struct inode *inode, struct file *file)
45 {
46         int err;
47         struct v9fs_inode *v9inode;
48         struct v9fs_session_info *v9ses;
49         struct p9_fid *fid, *writeback_fid;
50         int omode;
51
52         p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
53         v9inode = V9FS_I(inode);
54         v9ses = v9fs_inode2v9ses(inode);
55         if (v9fs_proto_dotl(v9ses))
56                 omode = v9fs_open_to_dotl_flags(file->f_flags);
57         else
58                 omode = v9fs_uflags2omode(file->f_flags,
59                                         v9fs_proto_dotu(v9ses));
60         fid = file->private_data;
61         if (!fid) {
62                 fid = v9fs_fid_clone(file_dentry(file));
63                 if (IS_ERR(fid))
64                         return PTR_ERR(fid);
65
66                 err = p9_client_open(fid, omode);
67                 if (err < 0) {
68                         p9_client_clunk(fid);
69                         return err;
70                 }
71                 if ((file->f_flags & O_APPEND) &&
72                         (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
73                         generic_file_llseek(file, 0, SEEK_END);
74         }
75
76         file->private_data = fid;
77         mutex_lock(&v9inode->v_mutex);
78         if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
79             !v9inode->writeback_fid &&
80             ((file->f_flags & O_ACCMODE) != O_RDONLY)) {
81                 /*
82                  * clone a fid and add it to writeback_fid
83                  * we do it during open time instead of
84                  * page dirty time via write_begin/page_mkwrite
85                  * because we want write after unlink usecase
86                  * to work.
87                  */
88                 writeback_fid = v9fs_writeback_fid(file_dentry(file));
89                 if (IS_ERR(writeback_fid)) {
90                         err = PTR_ERR(writeback_fid);
91                         mutex_unlock(&v9inode->v_mutex);
92                         goto out_error;
93                 }
94                 v9inode->writeback_fid = (void *) writeback_fid;
95         }
96         mutex_unlock(&v9inode->v_mutex);
97         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
98                 v9fs_cache_inode_set_cookie(inode, file);
99         v9fs_open_fid_add(inode, fid);
100         return 0;
101 out_error:
102         p9_client_clunk(file->private_data);
103         file->private_data = NULL;
104         return err;
105 }
106
107 /**
108  * v9fs_file_lock - lock a file (or directory)
109  * @filp: file to be locked
110  * @cmd: lock command
111  * @fl: file lock structure
112  *
113  * Bugs: this looks like a local only lock, we should extend into 9P
114  *       by using open exclusive
115  */
116
117 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
118 {
119         int res = 0;
120         struct inode *inode = file_inode(filp);
121
122         p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
123
124         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
125                 filemap_write_and_wait(inode->i_mapping);
126                 invalidate_mapping_pages(&inode->i_data, 0, -1);
127         }
128
129         return res;
130 }
131
132 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
133 {
134         struct p9_flock flock;
135         struct p9_fid *fid;
136         uint8_t status = P9_LOCK_ERROR;
137         int res = 0;
138         unsigned char fl_type;
139         struct v9fs_session_info *v9ses;
140
141         fid = filp->private_data;
142         BUG_ON(fid == NULL);
143
144         if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
145                 BUG();
146
147         res = locks_lock_file_wait(filp, fl);
148         if (res < 0)
149                 goto out;
150
151         /* convert posix lock to p9 tlock args */
152         memset(&flock, 0, sizeof(flock));
153         /* map the lock type */
154         switch (fl->fl_type) {
155         case F_RDLCK:
156                 flock.type = P9_LOCK_TYPE_RDLCK;
157                 break;
158         case F_WRLCK:
159                 flock.type = P9_LOCK_TYPE_WRLCK;
160                 break;
161         case F_UNLCK:
162                 flock.type = P9_LOCK_TYPE_UNLCK;
163                 break;
164         }
165         flock.start = fl->fl_start;
166         if (fl->fl_end == OFFSET_MAX)
167                 flock.length = 0;
168         else
169                 flock.length = fl->fl_end - fl->fl_start + 1;
170         flock.proc_id = fl->fl_pid;
171         flock.client_id = fid->clnt->name;
172         if (IS_SETLKW(cmd))
173                 flock.flags = P9_LOCK_FLAGS_BLOCK;
174
175         v9ses = v9fs_inode2v9ses(file_inode(filp));
176
177         /*
178          * if its a blocked request and we get P9_LOCK_BLOCKED as the status
179          * for lock request, keep on trying
180          */
181         for (;;) {
182                 res = p9_client_lock_dotl(fid, &flock, &status);
183                 if (res < 0)
184                         goto out_unlock;
185
186                 if (status != P9_LOCK_BLOCKED)
187                         break;
188                 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))
189                         break;
190                 if (schedule_timeout_interruptible(v9ses->session_lock_timeout)
191                                 != 0)
192                         break;
193                 /*
194                  * p9_client_lock_dotl overwrites flock.client_id with the
195                  * server message, free and reuse the client name
196                  */
197                 if (flock.client_id != fid->clnt->name) {
198                         kfree(flock.client_id);
199                         flock.client_id = fid->clnt->name;
200                 }
201         }
202
203         /* map 9p status to VFS status */
204         switch (status) {
205         case P9_LOCK_SUCCESS:
206                 res = 0;
207                 break;
208         case P9_LOCK_BLOCKED:
209                 res = -EAGAIN;
210                 break;
211         default:
212                 WARN_ONCE(1, "unknown lock status code: %d\n", status);
213                 fallthrough;
214         case P9_LOCK_ERROR:
215         case P9_LOCK_GRACE:
216                 res = -ENOLCK;
217                 break;
218         }
219
220 out_unlock:
221         /*
222          * incase server returned error for lock request, revert
223          * it locally
224          */
225         if (res < 0 && fl->fl_type != F_UNLCK) {
226                 fl_type = fl->fl_type;
227                 fl->fl_type = F_UNLCK;
228                 /* Even if this fails we want to return the remote error */
229                 locks_lock_file_wait(filp, fl);
230                 fl->fl_type = fl_type;
231         }
232         if (flock.client_id != fid->clnt->name)
233                 kfree(flock.client_id);
234 out:
235         return res;
236 }
237
238 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
239 {
240         struct p9_getlock glock;
241         struct p9_fid *fid;
242         int res = 0;
243
244         fid = filp->private_data;
245         BUG_ON(fid == NULL);
246
247         posix_test_lock(filp, fl);
248         /*
249          * if we have a conflicting lock locally, no need to validate
250          * with server
251          */
252         if (fl->fl_type != F_UNLCK)
253                 return res;
254
255         /* convert posix lock to p9 tgetlock args */
256         memset(&glock, 0, sizeof(glock));
257         glock.type  = P9_LOCK_TYPE_UNLCK;
258         glock.start = fl->fl_start;
259         if (fl->fl_end == OFFSET_MAX)
260                 glock.length = 0;
261         else
262                 glock.length = fl->fl_end - fl->fl_start + 1;
263         glock.proc_id = fl->fl_pid;
264         glock.client_id = fid->clnt->name;
265
266         res = p9_client_getlock_dotl(fid, &glock);
267         if (res < 0)
268                 goto out;
269         /* map 9p lock type to os lock type */
270         switch (glock.type) {
271         case P9_LOCK_TYPE_RDLCK:
272                 fl->fl_type = F_RDLCK;
273                 break;
274         case P9_LOCK_TYPE_WRLCK:
275                 fl->fl_type = F_WRLCK;
276                 break;
277         case P9_LOCK_TYPE_UNLCK:
278                 fl->fl_type = F_UNLCK;
279                 break;
280         }
281         if (glock.type != P9_LOCK_TYPE_UNLCK) {
282                 fl->fl_start = glock.start;
283                 if (glock.length == 0)
284                         fl->fl_end = OFFSET_MAX;
285                 else
286                         fl->fl_end = glock.start + glock.length - 1;
287                 fl->fl_pid = -glock.proc_id;
288         }
289 out:
290         if (glock.client_id != fid->clnt->name)
291                 kfree(glock.client_id);
292         return res;
293 }
294
295 /**
296  * v9fs_file_lock_dotl - lock a file (or directory)
297  * @filp: file to be locked
298  * @cmd: lock command
299  * @fl: file lock structure
300  *
301  */
302
303 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
304 {
305         struct inode *inode = file_inode(filp);
306         int ret = -ENOLCK;
307
308         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n",
309                  filp, cmd, fl, filp);
310
311         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
312                 filemap_write_and_wait(inode->i_mapping);
313                 invalidate_mapping_pages(&inode->i_data, 0, -1);
314         }
315
316         if (IS_SETLK(cmd) || IS_SETLKW(cmd))
317                 ret = v9fs_file_do_lock(filp, cmd, fl);
318         else if (IS_GETLK(cmd))
319                 ret = v9fs_file_getlock(filp, fl);
320         else
321                 ret = -EINVAL;
322         return ret;
323 }
324
325 /**
326  * v9fs_file_flock_dotl - lock a file
327  * @filp: file to be locked
328  * @cmd: lock command
329  * @fl: file lock structure
330  *
331  */
332
333 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
334         struct file_lock *fl)
335 {
336         struct inode *inode = file_inode(filp);
337         int ret = -ENOLCK;
338
339         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n",
340                  filp, cmd, fl, filp);
341
342         if (!(fl->fl_flags & FL_FLOCK))
343                 goto out_err;
344
345         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
346                 filemap_write_and_wait(inode->i_mapping);
347                 invalidate_mapping_pages(&inode->i_data, 0, -1);
348         }
349         /* Convert flock to posix lock */
350         fl->fl_flags |= FL_POSIX;
351         fl->fl_flags ^= FL_FLOCK;
352
353         if (IS_SETLK(cmd) | IS_SETLKW(cmd))
354                 ret = v9fs_file_do_lock(filp, cmd, fl);
355         else
356                 ret = -EINVAL;
357 out_err:
358         return ret;
359 }
360
361 /**
362  * v9fs_file_read_iter - read from a file
363  * @iocb: The operation parameters
364  * @to: The buffer to read into
365  *
366  */
367 static ssize_t
368 v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
369 {
370         struct p9_fid *fid = iocb->ki_filp->private_data;
371         int ret, err = 0;
372
373         p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n",
374                  iov_iter_count(to), iocb->ki_pos);
375
376         if (iocb->ki_filp->f_flags & O_NONBLOCK)
377                 ret = p9_client_read_once(fid, iocb->ki_pos, to, &err);
378         else
379                 ret = p9_client_read(fid, iocb->ki_pos, to, &err);
380         if (!ret)
381                 return err;
382
383         iocb->ki_pos += ret;
384         return ret;
385 }
386
387 /**
388  * v9fs_file_write_iter - write to a file
389  * @iocb: The operation parameters
390  * @from: The data to write
391  *
392  */
393 static ssize_t
394 v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
395 {
396         struct file *file = iocb->ki_filp;
397         ssize_t retval;
398         loff_t origin;
399         int err = 0;
400
401         retval = generic_write_checks(iocb, from);
402         if (retval <= 0)
403                 return retval;
404
405         origin = iocb->ki_pos;
406         retval = p9_client_write(file->private_data, iocb->ki_pos, from, &err);
407         if (retval > 0) {
408                 struct inode *inode = file_inode(file);
409                 loff_t i_size;
410                 unsigned long pg_start, pg_end;
411                 pg_start = origin >> PAGE_SHIFT;
412                 pg_end = (origin + retval - 1) >> PAGE_SHIFT;
413                 if (inode->i_mapping && inode->i_mapping->nrpages)
414                         invalidate_inode_pages2_range(inode->i_mapping,
415                                                       pg_start, pg_end);
416                 iocb->ki_pos += retval;
417                 i_size = i_size_read(inode);
418                 if (iocb->ki_pos > i_size) {
419                         inode_add_bytes(inode, iocb->ki_pos - i_size);
420                         /*
421                          * Need to serialize against i_size_write() in
422                          * v9fs_stat2inode()
423                          */
424                         v9fs_i_size_write(inode, iocb->ki_pos);
425                 }
426                 return retval;
427         }
428         return err;
429 }
430
431 static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end,
432                            int datasync)
433 {
434         struct p9_fid *fid;
435         struct inode *inode = filp->f_mapping->host;
436         struct p9_wstat wstat;
437         int retval;
438
439         retval = file_write_and_wait_range(filp, start, end);
440         if (retval)
441                 return retval;
442
443         inode_lock(inode);
444         p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
445
446         fid = filp->private_data;
447         v9fs_blank_wstat(&wstat);
448
449         retval = p9_client_wstat(fid, &wstat);
450         inode_unlock(inode);
451
452         return retval;
453 }
454
455 int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
456                          int datasync)
457 {
458         struct p9_fid *fid;
459         struct inode *inode = filp->f_mapping->host;
460         int retval;
461
462         retval = file_write_and_wait_range(filp, start, end);
463         if (retval)
464                 return retval;
465
466         inode_lock(inode);
467         p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
468
469         fid = filp->private_data;
470
471         retval = p9_client_fsync(fid, datasync);
472         inode_unlock(inode);
473
474         return retval;
475 }
476
477 static int
478 v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma)
479 {
480         int retval;
481
482
483         retval = generic_file_mmap(filp, vma);
484         if (!retval)
485                 vma->vm_ops = &v9fs_file_vm_ops;
486
487         return retval;
488 }
489
490 static int
491 v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma)
492 {
493         int retval;
494         struct inode *inode;
495         struct v9fs_inode *v9inode;
496         struct p9_fid *fid;
497
498         inode = file_inode(filp);
499         v9inode = V9FS_I(inode);
500         mutex_lock(&v9inode->v_mutex);
501         if (!v9inode->writeback_fid &&
502             (vma->vm_flags & VM_SHARED) &&
503             (vma->vm_flags & VM_WRITE)) {
504                 /*
505                  * clone a fid and add it to writeback_fid
506                  * we do it during mmap instead of
507                  * page dirty time via write_begin/page_mkwrite
508                  * because we want write after unlink usecase
509                  * to work.
510                  */
511                 fid = v9fs_writeback_fid(file_dentry(filp));
512                 if (IS_ERR(fid)) {
513                         retval = PTR_ERR(fid);
514                         mutex_unlock(&v9inode->v_mutex);
515                         return retval;
516                 }
517                 v9inode->writeback_fid = (void *) fid;
518         }
519         mutex_unlock(&v9inode->v_mutex);
520
521         retval = generic_file_mmap(filp, vma);
522         if (!retval)
523                 vma->vm_ops = &v9fs_mmap_file_vm_ops;
524
525         return retval;
526 }
527
528 static vm_fault_t
529 v9fs_vm_page_mkwrite(struct vm_fault *vmf)
530 {
531         struct v9fs_inode *v9inode;
532         struct page *page = vmf->page;
533         struct file *filp = vmf->vma->vm_file;
534         struct inode *inode = file_inode(filp);
535
536
537         p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n",
538                  page, (unsigned long)filp->private_data);
539
540         /* Update file times before taking page lock */
541         file_update_time(filp);
542
543         v9inode = V9FS_I(inode);
544         /* make sure the cache has finished storing the page */
545         v9fs_fscache_wait_on_page_write(inode, page);
546         BUG_ON(!v9inode->writeback_fid);
547         lock_page(page);
548         if (page->mapping != inode->i_mapping)
549                 goto out_unlock;
550         wait_for_stable_page(page);
551
552         return VM_FAULT_LOCKED;
553 out_unlock:
554         unlock_page(page);
555         return VM_FAULT_NOPAGE;
556 }
557
558 /**
559  * v9fs_mmap_file_read_iter - read from a file
560  * @iocb: The operation parameters
561  * @to: The buffer to read into
562  *
563  */
564 static ssize_t
565 v9fs_mmap_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
566 {
567         /* TODO: Check if there are dirty pages */
568         return v9fs_file_read_iter(iocb, to);
569 }
570
571 /**
572  * v9fs_mmap_file_write_iter - write to a file
573  * @iocb: The operation parameters
574  * @from: The data to write
575  *
576  */
577 static ssize_t
578 v9fs_mmap_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
579 {
580         /*
581          * TODO: invalidate mmaps on filp's inode between
582          * offset and offset+count
583          */
584         return v9fs_file_write_iter(iocb, from);
585 }
586
587 static void v9fs_mmap_vm_close(struct vm_area_struct *vma)
588 {
589         struct inode *inode;
590
591         struct writeback_control wbc = {
592                 .nr_to_write = LONG_MAX,
593                 .sync_mode = WB_SYNC_ALL,
594                 .range_start = (loff_t)vma->vm_pgoff * PAGE_SIZE,
595                  /* absolute end, byte at end included */
596                 .range_end = (loff_t)vma->vm_pgoff * PAGE_SIZE +
597                         (vma->vm_end - vma->vm_start - 1),
598         };
599
600         if (!(vma->vm_flags & VM_SHARED))
601                 return;
602
603         p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma);
604
605         inode = file_inode(vma->vm_file);
606         filemap_fdatawrite_wbc(inode->i_mapping, &wbc);
607 }
608
609
610 static const struct vm_operations_struct v9fs_file_vm_ops = {
611         .fault = filemap_fault,
612         .map_pages = filemap_map_pages,
613         .page_mkwrite = v9fs_vm_page_mkwrite,
614 };
615
616 static const struct vm_operations_struct v9fs_mmap_file_vm_ops = {
617         .close = v9fs_mmap_vm_close,
618         .fault = filemap_fault,
619         .map_pages = filemap_map_pages,
620         .page_mkwrite = v9fs_vm_page_mkwrite,
621 };
622
623
624 const struct file_operations v9fs_cached_file_operations = {
625         .llseek = generic_file_llseek,
626         .read_iter = generic_file_read_iter,
627         .write_iter = generic_file_write_iter,
628         .open = v9fs_file_open,
629         .release = v9fs_dir_release,
630         .lock = v9fs_file_lock,
631         .mmap = v9fs_file_mmap,
632         .splice_read = generic_file_splice_read,
633         .splice_write = iter_file_splice_write,
634         .fsync = v9fs_file_fsync,
635 };
636
637 const struct file_operations v9fs_cached_file_operations_dotl = {
638         .llseek = generic_file_llseek,
639         .read_iter = generic_file_read_iter,
640         .write_iter = generic_file_write_iter,
641         .open = v9fs_file_open,
642         .release = v9fs_dir_release,
643         .lock = v9fs_file_lock_dotl,
644         .flock = v9fs_file_flock_dotl,
645         .mmap = v9fs_file_mmap,
646         .splice_read = generic_file_splice_read,
647         .splice_write = iter_file_splice_write,
648         .fsync = v9fs_file_fsync_dotl,
649 };
650
651 const struct file_operations v9fs_file_operations = {
652         .llseek = generic_file_llseek,
653         .read_iter = v9fs_file_read_iter,
654         .write_iter = v9fs_file_write_iter,
655         .open = v9fs_file_open,
656         .release = v9fs_dir_release,
657         .lock = v9fs_file_lock,
658         .mmap = generic_file_readonly_mmap,
659         .splice_read = generic_file_splice_read,
660         .splice_write = iter_file_splice_write,
661         .fsync = v9fs_file_fsync,
662 };
663
664 const struct file_operations v9fs_file_operations_dotl = {
665         .llseek = generic_file_llseek,
666         .read_iter = v9fs_file_read_iter,
667         .write_iter = v9fs_file_write_iter,
668         .open = v9fs_file_open,
669         .release = v9fs_dir_release,
670         .lock = v9fs_file_lock_dotl,
671         .flock = v9fs_file_flock_dotl,
672         .mmap = generic_file_readonly_mmap,
673         .splice_read = generic_file_splice_read,
674         .splice_write = iter_file_splice_write,
675         .fsync = v9fs_file_fsync_dotl,
676 };
677
678 const struct file_operations v9fs_mmap_file_operations = {
679         .llseek = generic_file_llseek,
680         .read_iter = v9fs_mmap_file_read_iter,
681         .write_iter = v9fs_mmap_file_write_iter,
682         .open = v9fs_file_open,
683         .release = v9fs_dir_release,
684         .lock = v9fs_file_lock,
685         .mmap = v9fs_mmap_file_mmap,
686         .splice_read = generic_file_splice_read,
687         .splice_write = iter_file_splice_write,
688         .fsync = v9fs_file_fsync,
689 };
690
691 const struct file_operations v9fs_mmap_file_operations_dotl = {
692         .llseek = generic_file_llseek,
693         .read_iter = v9fs_mmap_file_read_iter,
694         .write_iter = v9fs_mmap_file_write_iter,
695         .open = v9fs_file_open,
696         .release = v9fs_dir_release,
697         .lock = v9fs_file_lock_dotl,
698         .flock = v9fs_file_flock_dotl,
699         .mmap = v9fs_mmap_file_mmap,
700         .splice_read = generic_file_splice_read,
701         .splice_write = iter_file_splice_write,
702         .fsync = v9fs_file_fsync_dotl,
703 };