Commit | Line | Data |
---|---|---|
1f327613 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
e69e7fe5 | 2 | /* |
e69e7fe5 EVH |
3 | * This file contians vfs file ops for 9P2000. |
4 | * | |
5 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | |
6 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | |
e69e7fe5 EVH |
7 | */ |
8 | ||
9 | #include <linux/module.h> | |
10 | #include <linux/errno.h> | |
11 | #include <linux/fs.h> | |
5970e15d | 12 | #include <linux/filelock.h> |
914e2637 | 13 | #include <linux/sched.h> |
e69e7fe5 EVH |
14 | #include <linux/file.h> |
15 | #include <linux/stat.h> | |
16 | #include <linux/string.h> | |
e69e7fe5 | 17 | #include <linux/list.h> |
637d020a | 18 | #include <linux/pagemap.h> |
a099027c | 19 | #include <linux/utsname.h> |
7c0f6ba6 | 20 | #include <linux/uaccess.h> |
070b3656 | 21 | #include <linux/uio.h> |
ce85dd58 | 22 | #include <linux/slab.h> |
bd238fb4 LI |
23 | #include <net/9p/9p.h> |
24 | #include <net/9p/client.h> | |
e69e7fe5 | 25 | |
e69e7fe5 | 26 | #include "v9fs.h" |
e69e7fe5 EVH |
27 | #include "v9fs_vfs.h" |
28 | #include "fid.h" | |
60e78d2c | 29 | #include "cache.h" |
e69e7fe5 | 30 | |
fb89b45c | 31 | static const struct vm_operations_struct v9fs_mmap_file_vm_ops; |
7263cebe | 32 | |
e69e7fe5 EVH |
33 | /** |
34 | * v9fs_file_open - open a file (or directory) | |
35 | * @inode: inode to be opened | |
36 | * @file: file being opened | |
37 | * | |
38 | */ | |
39 | ||
40 | int v9fs_file_open(struct inode *inode, struct file *file) | |
41 | { | |
6a3124a3 | 42 | int err; |
bd238fb4 | 43 | struct v9fs_session_info *v9ses; |
1543b4c5 | 44 | struct p9_fid *fid; |
bd238fb4 | 45 | int omode; |
e69e7fe5 | 46 | |
5d385153 | 47 | p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file); |
bd238fb4 | 48 | v9ses = v9fs_inode2v9ses(inode); |
ef56547e | 49 | if (v9fs_proto_dotl(v9ses)) |
f88657ce | 50 | omode = v9fs_open_to_dotl_flags(file->f_flags); |
ef56547e MK |
51 | else |
52 | omode = v9fs_uflags2omode(file->f_flags, | |
53 | v9fs_proto_dotu(v9ses)); | |
bd238fb4 LI |
54 | fid = file->private_data; |
55 | if (!fid) { | |
b403f0e3 | 56 | fid = v9fs_fid_clone(file_dentry(file)); |
bd238fb4 LI |
57 | if (IS_ERR(fid)) |
58 | return PTR_ERR(fid); | |
59 | ||
4eb31178 | 60 | if ((v9ses->cache & CACHE_WRITEBACK) && (omode & P9_OWRITE)) { |
1543b4c5 EVH |
61 | int writeback_omode = (omode & ~P9_OWRITE) | P9_ORDWR; |
62 | ||
63 | p9_debug(P9_DEBUG_CACHE, "write-only file with writeback enabled, try opening O_RDWR\n"); | |
64 | err = p9_client_open(fid, writeback_omode); | |
65 | if (err < 0) { | |
66 | p9_debug(P9_DEBUG_CACHE, "could not open O_RDWR, disabling caches\n"); | |
67 | err = p9_client_open(fid, omode); | |
68 | fid->mode |= P9L_DIRECT; | |
69 | } | |
70 | } else { | |
71 | err = p9_client_open(fid, omode); | |
72 | } | |
9523a841 | 73 | if (err < 0) { |
b48dbb99 | 74 | p9_fid_put(fid); |
bd238fb4 LI |
75 | return err; |
76 | } | |
ef56547e MK |
77 | if ((file->f_flags & O_APPEND) && |
78 | (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))) | |
2e4bef41 | 79 | generic_file_llseek(file, 0, SEEK_END); |
dafbe689 DM |
80 | |
81 | file->private_data = fid; | |
6a3124a3 | 82 | } |
e69e7fe5 | 83 | |
344504e9 | 84 | #ifdef CONFIG_9P_FSCACHE |
4eb31178 EVH |
85 | if (v9ses->cache & CACHE_FSCACHE) |
86 | fscache_use_cookie(v9fs_inode_cookie(V9FS_I(inode)), | |
24e42e32 | 87 | file->f_mode & FMODE_WRITE); |
344504e9 | 88 | #endif |
1543b4c5 | 89 | v9fs_fid_add_modes(fid, v9ses->flags, v9ses->cache, file->f_flags); |
dafbe689 | 90 | v9fs_open_fid_add(inode, &fid); |
6a3124a3 | 91 | return 0; |
e69e7fe5 EVH |
92 | } |
93 | ||
94 | /** | |
95 | * v9fs_file_lock - lock a file (or directory) | |
ee443996 EVH |
96 | * @filp: file to be locked |
97 | * @cmd: lock command | |
98 | * @fl: file lock structure | |
e69e7fe5 | 99 | * |
ee443996 | 100 | * Bugs: this looks like a local only lock, we should extend into 9P |
e69e7fe5 EVH |
101 | * by using open exclusive |
102 | */ | |
103 | ||
104 | static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) | |
105 | { | |
496ad9aa | 106 | struct inode *inode = file_inode(filp); |
e69e7fe5 | 107 | |
5d385153 | 108 | p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); |
e69e7fe5 | 109 | |
e69e7fe5 | 110 | if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { |
28fd1298 | 111 | filemap_write_and_wait(inode->i_mapping); |
fc0ecff6 | 112 | invalidate_mapping_pages(&inode->i_data, 0, -1); |
e69e7fe5 EVH |
113 | } |
114 | ||
90d6cf34 | 115 | return 0; |
e69e7fe5 EVH |
116 | } |
117 | ||
a099027c MK |
118 | static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) |
119 | { | |
120 | struct p9_flock flock; | |
121 | struct p9_fid *fid; | |
5c4086b8 | 122 | uint8_t status = P9_LOCK_ERROR; |
a099027c MK |
123 | int res = 0; |
124 | unsigned char fl_type; | |
5e172f75 | 125 | struct v9fs_session_info *v9ses; |
a099027c MK |
126 | |
127 | fid = filp->private_data; | |
128 | BUG_ON(fid == NULL); | |
129 | ||
a7a427d1 | 130 | BUG_ON((fl->fl_flags & FL_POSIX) != FL_POSIX); |
a099027c | 131 | |
4f656367 | 132 | res = locks_lock_file_wait(filp, fl); |
a099027c MK |
133 | if (res < 0) |
134 | goto out; | |
135 | ||
136 | /* convert posix lock to p9 tlock args */ | |
137 | memset(&flock, 0, sizeof(flock)); | |
51b8b4fb JG |
138 | /* map the lock type */ |
139 | switch (fl->fl_type) { | |
140 | case F_RDLCK: | |
141 | flock.type = P9_LOCK_TYPE_RDLCK; | |
142 | break; | |
143 | case F_WRLCK: | |
144 | flock.type = P9_LOCK_TYPE_WRLCK; | |
145 | break; | |
146 | case F_UNLCK: | |
147 | flock.type = P9_LOCK_TYPE_UNLCK; | |
148 | break; | |
149 | } | |
a099027c MK |
150 | flock.start = fl->fl_start; |
151 | if (fl->fl_end == OFFSET_MAX) | |
152 | flock.length = 0; | |
153 | else | |
154 | flock.length = fl->fl_end - fl->fl_start + 1; | |
155 | flock.proc_id = fl->fl_pid; | |
50192abe | 156 | flock.client_id = fid->clnt->name; |
a099027c MK |
157 | if (IS_SETLKW(cmd)) |
158 | flock.flags = P9_LOCK_FLAGS_BLOCK; | |
159 | ||
5e172f75 DRCS |
160 | v9ses = v9fs_inode2v9ses(file_inode(filp)); |
161 | ||
a099027c MK |
162 | /* |
163 | * if its a blocked request and we get P9_LOCK_BLOCKED as the status | |
164 | * for lock request, keep on trying | |
165 | */ | |
166 | for (;;) { | |
167 | res = p9_client_lock_dotl(fid, &flock, &status); | |
168 | if (res < 0) | |
ad80492d | 169 | goto out_unlock; |
a099027c MK |
170 | |
171 | if (status != P9_LOCK_BLOCKED) | |
172 | break; | |
173 | if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd)) | |
174 | break; | |
5e172f75 DRCS |
175 | if (schedule_timeout_interruptible(v9ses->session_lock_timeout) |
176 | != 0) | |
a0ea787b | 177 | break; |
b4dc44b3 DM |
178 | /* |
179 | * p9_client_lock_dotl overwrites flock.client_id with the | |
180 | * server message, free and reuse the client name | |
181 | */ | |
182 | if (flock.client_id != fid->clnt->name) { | |
183 | kfree(flock.client_id); | |
184 | flock.client_id = fid->clnt->name; | |
185 | } | |
a099027c MK |
186 | } |
187 | ||
188 | /* map 9p status to VFS status */ | |
189 | switch (status) { | |
190 | case P9_LOCK_SUCCESS: | |
191 | res = 0; | |
192 | break; | |
193 | case P9_LOCK_BLOCKED: | |
194 | res = -EAGAIN; | |
195 | break; | |
b642f726 KS |
196 | default: |
197 | WARN_ONCE(1, "unknown lock status code: %d\n", status); | |
df561f66 | 198 | fallthrough; |
a099027c MK |
199 | case P9_LOCK_ERROR: |
200 | case P9_LOCK_GRACE: | |
201 | res = -ENOLCK; | |
202 | break; | |
a099027c MK |
203 | } |
204 | ||
ad80492d | 205 | out_unlock: |
a099027c MK |
206 | /* |
207 | * incase server returned error for lock request, revert | |
208 | * it locally | |
209 | */ | |
210 | if (res < 0 && fl->fl_type != F_UNLCK) { | |
211 | fl_type = fl->fl_type; | |
212 | fl->fl_type = F_UNLCK; | |
b6478740 | 213 | /* Even if this fails we want to return the remote error */ |
2e3078af | 214 | locks_lock_file_wait(filp, fl); |
a099027c MK |
215 | fl->fl_type = fl_type; |
216 | } | |
b4dc44b3 DM |
217 | if (flock.client_id != fid->clnt->name) |
218 | kfree(flock.client_id); | |
a099027c MK |
219 | out: |
220 | return res; | |
221 | } | |
222 | ||
1d769cd1 MK |
223 | static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) |
224 | { | |
225 | struct p9_getlock glock; | |
226 | struct p9_fid *fid; | |
227 | int res = 0; | |
228 | ||
229 | fid = filp->private_data; | |
230 | BUG_ON(fid == NULL); | |
231 | ||
232 | posix_test_lock(filp, fl); | |
233 | /* | |
234 | * if we have a conflicting lock locally, no need to validate | |
235 | * with server | |
236 | */ | |
237 | if (fl->fl_type != F_UNLCK) | |
238 | return res; | |
239 | ||
240 | /* convert posix lock to p9 tgetlock args */ | |
241 | memset(&glock, 0, sizeof(glock)); | |
51b8b4fb | 242 | glock.type = P9_LOCK_TYPE_UNLCK; |
1d769cd1 MK |
243 | glock.start = fl->fl_start; |
244 | if (fl->fl_end == OFFSET_MAX) | |
245 | glock.length = 0; | |
246 | else | |
247 | glock.length = fl->fl_end - fl->fl_start + 1; | |
248 | glock.proc_id = fl->fl_pid; | |
50192abe | 249 | glock.client_id = fid->clnt->name; |
1d769cd1 MK |
250 | |
251 | res = p9_client_getlock_dotl(fid, &glock); | |
252 | if (res < 0) | |
b4dc44b3 | 253 | goto out; |
51b8b4fb JG |
254 | /* map 9p lock type to os lock type */ |
255 | switch (glock.type) { | |
256 | case P9_LOCK_TYPE_RDLCK: | |
257 | fl->fl_type = F_RDLCK; | |
258 | break; | |
259 | case P9_LOCK_TYPE_WRLCK: | |
260 | fl->fl_type = F_WRLCK; | |
261 | break; | |
262 | case P9_LOCK_TYPE_UNLCK: | |
263 | fl->fl_type = F_UNLCK; | |
264 | break; | |
265 | } | |
266 | if (glock.type != P9_LOCK_TYPE_UNLCK) { | |
1d769cd1 MK |
267 | fl->fl_start = glock.start; |
268 | if (glock.length == 0) | |
269 | fl->fl_end = OFFSET_MAX; | |
270 | else | |
271 | fl->fl_end = glock.start + glock.length - 1; | |
9d5b86ac | 272 | fl->fl_pid = -glock.proc_id; |
51b8b4fb | 273 | } |
b4dc44b3 DM |
274 | out: |
275 | if (glock.client_id != fid->clnt->name) | |
276 | kfree(glock.client_id); | |
1d769cd1 MK |
277 | return res; |
278 | } | |
279 | ||
a099027c MK |
280 | /** |
281 | * v9fs_file_lock_dotl - lock a file (or directory) | |
282 | * @filp: file to be locked | |
283 | * @cmd: lock command | |
284 | * @fl: file lock structure | |
285 | * | |
286 | */ | |
287 | ||
288 | static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) | |
289 | { | |
496ad9aa | 290 | struct inode *inode = file_inode(filp); |
a099027c MK |
291 | int ret = -ENOLCK; |
292 | ||
4b8e9923 AV |
293 | p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", |
294 | filp, cmd, fl, filp); | |
a099027c | 295 | |
a099027c MK |
296 | if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { |
297 | filemap_write_and_wait(inode->i_mapping); | |
298 | invalidate_mapping_pages(&inode->i_data, 0, -1); | |
299 | } | |
300 | ||
301 | if (IS_SETLK(cmd) || IS_SETLKW(cmd)) | |
302 | ret = v9fs_file_do_lock(filp, cmd, fl); | |
1d769cd1 MK |
303 | else if (IS_GETLK(cmd)) |
304 | ret = v9fs_file_getlock(filp, fl); | |
a099027c MK |
305 | else |
306 | ret = -EINVAL; | |
a099027c MK |
307 | return ret; |
308 | } | |
309 | ||
310 | /** | |
311 | * v9fs_file_flock_dotl - lock a file | |
312 | * @filp: file to be locked | |
313 | * @cmd: lock command | |
314 | * @fl: file lock structure | |
315 | * | |
316 | */ | |
317 | ||
318 | static int v9fs_file_flock_dotl(struct file *filp, int cmd, | |
319 | struct file_lock *fl) | |
320 | { | |
496ad9aa | 321 | struct inode *inode = file_inode(filp); |
a099027c MK |
322 | int ret = -ENOLCK; |
323 | ||
4b8e9923 AV |
324 | p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", |
325 | filp, cmd, fl, filp); | |
a099027c | 326 | |
a099027c MK |
327 | if (!(fl->fl_flags & FL_FLOCK)) |
328 | goto out_err; | |
329 | ||
330 | if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { | |
331 | filemap_write_and_wait(inode->i_mapping); | |
332 | invalidate_mapping_pages(&inode->i_data, 0, -1); | |
333 | } | |
334 | /* Convert flock to posix lock */ | |
a099027c MK |
335 | fl->fl_flags |= FL_POSIX; |
336 | fl->fl_flags ^= FL_FLOCK; | |
337 | ||
338 | if (IS_SETLK(cmd) | IS_SETLKW(cmd)) | |
339 | ret = v9fs_file_do_lock(filp, cmd, fl); | |
340 | else | |
341 | ret = -EINVAL; | |
342 | out_err: | |
343 | return ret; | |
344 | } | |
345 | ||
fbedadc1 | 346 | /** |
bc868036 DH |
347 | * v9fs_file_read_iter - read from a file |
348 | * @iocb: The operation parameters | |
349 | * @to: The buffer to read into | |
fbedadc1 EVH |
350 | * |
351 | */ | |
e69e7fe5 | 352 | static ssize_t |
e494b6b5 | 353 | v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) |
e69e7fe5 | 354 | { |
e494b6b5 | 355 | struct p9_fid *fid = iocb->ki_filp->private_data; |
e69e7fe5 | 356 | |
1543b4c5 EVH |
357 | p9_debug(P9_DEBUG_VFS, "fid %d count %zu offset %lld\n", |
358 | fid->fid, iov_iter_count(to), iocb->ki_pos); | |
fbedadc1 | 359 | |
80105ed2 DH |
360 | if (fid->mode & P9L_DIRECT) |
361 | return netfs_unbuffered_read_iter(iocb, to); | |
e69e7fe5 | 362 | |
80105ed2 DH |
363 | p9_debug(P9_DEBUG_VFS, "(cached)\n"); |
364 | return netfs_file_read_iter(iocb, to); | |
e69e7fe5 EVH |
365 | } |
366 | ||
c829d0bd DH |
367 | /* |
368 | * v9fs_file_splice_read - splice-read from a file | |
369 | * @in: The 9p file to read from | |
370 | * @ppos: Where to find/update the file position | |
371 | * @pipe: The pipe to splice into | |
372 | * @len: The maximum amount of data to splice | |
373 | * @flags: SPLICE_F_* flags | |
374 | */ | |
375 | static ssize_t v9fs_file_splice_read(struct file *in, loff_t *ppos, | |
376 | struct pipe_inode_info *pipe, | |
377 | size_t len, unsigned int flags) | |
378 | { | |
379 | struct p9_fid *fid = in->private_data; | |
380 | ||
381 | p9_debug(P9_DEBUG_VFS, "fid %d count %zu offset %lld\n", | |
382 | fid->fid, len, *ppos); | |
383 | ||
384 | if (fid->mode & P9L_DIRECT) | |
385 | return copy_splice_read(in, ppos, pipe, len, flags); | |
386 | return filemap_splice_read(in, ppos, pipe, len, flags); | |
387 | } | |
388 | ||
17311779 | 389 | /** |
bc868036 DH |
390 | * v9fs_file_write_iter - write to a file |
391 | * @iocb: The operation parameters | |
392 | * @from: The data to write | |
17311779 AK |
393 | * |
394 | */ | |
395 | static ssize_t | |
e494b6b5 | 396 | v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) |
17311779 | 397 | { |
e494b6b5 | 398 | struct file *file = iocb->ki_filp; |
1543b4c5 | 399 | struct p9_fid *fid = file->private_data; |
d9bc0d11 | 400 | |
1543b4c5 EVH |
401 | p9_debug(P9_DEBUG_VFS, "fid %d\n", fid->fid); |
402 | ||
80105ed2 DH |
403 | if (fid->mode & (P9L_DIRECT | P9L_NOWRITECACHE)) |
404 | return netfs_unbuffered_write_iter(iocb, from); | |
17311779 | 405 | |
80105ed2 DH |
406 | p9_debug(P9_DEBUG_CACHE, "(cached)\n"); |
407 | return netfs_file_write_iter(iocb, from); | |
e69e7fe5 EVH |
408 | } |
409 | ||
02c24a82 JB |
410 | static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, |
411 | int datasync) | |
7a4439c4 MK |
412 | { |
413 | struct p9_fid *fid; | |
02c24a82 | 414 | struct inode *inode = filp->f_mapping->host; |
7a4439c4 MK |
415 | struct p9_wstat wstat; |
416 | int retval; | |
417 | ||
3b49c9a1 | 418 | retval = file_write_and_wait_range(filp, start, end); |
02c24a82 JB |
419 | if (retval) |
420 | return retval; | |
421 | ||
5955102c | 422 | inode_lock(inode); |
5d385153 | 423 | p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); |
7a4439c4 MK |
424 | |
425 | fid = filp->private_data; | |
426 | v9fs_blank_wstat(&wstat); | |
427 | ||
428 | retval = p9_client_wstat(fid, &wstat); | |
5955102c | 429 | inode_unlock(inode); |
02c24a82 | 430 | |
7a4439c4 MK |
431 | return retval; |
432 | } | |
433 | ||
02c24a82 JB |
434 | int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, |
435 | int datasync) | |
920e65dc VJJ |
436 | { |
437 | struct p9_fid *fid; | |
02c24a82 | 438 | struct inode *inode = filp->f_mapping->host; |
920e65dc VJJ |
439 | int retval; |
440 | ||
3b49c9a1 | 441 | retval = file_write_and_wait_range(filp, start, end); |
02c24a82 JB |
442 | if (retval) |
443 | return retval; | |
444 | ||
5955102c | 445 | inode_lock(inode); |
5d385153 | 446 | p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); |
920e65dc VJJ |
447 | |
448 | fid = filp->private_data; | |
449 | ||
b165d601 | 450 | retval = p9_client_fsync(fid, datasync); |
5955102c | 451 | inode_unlock(inode); |
02c24a82 | 452 | |
920e65dc VJJ |
453 | return retval; |
454 | } | |
455 | ||
7263cebe | 456 | static int |
fb89b45c | 457 | v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) |
7263cebe AK |
458 | { |
459 | int retval; | |
d9bc0d11 | 460 | struct inode *inode = file_inode(filp); |
d9bc0d11 | 461 | struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode); |
1543b4c5 EVH |
462 | |
463 | p9_debug(P9_DEBUG_MMAP, "filp :%p\n", filp); | |
fb89b45c | 464 | |
4eb31178 | 465 | if (!(v9ses->cache & CACHE_WRITEBACK)) { |
75b39682 | 466 | p9_debug(P9_DEBUG_CACHE, "(read-only mmap mode)"); |
d9bc0d11 EVH |
467 | return generic_file_readonly_mmap(filp, vma); |
468 | } | |
469 | ||
fb89b45c DM |
470 | retval = generic_file_mmap(filp, vma); |
471 | if (!retval) | |
472 | vma->vm_ops = &v9fs_mmap_file_vm_ops; | |
473 | ||
474 | return retval; | |
475 | } | |
476 | ||
fe6340e2 | 477 | static vm_fault_t |
11bac800 | 478 | v9fs_vm_page_mkwrite(struct vm_fault *vmf) |
7263cebe | 479 | { |
80105ed2 | 480 | return netfs_page_mkwrite(vmf, NULL); |
7263cebe AK |
481 | } |
482 | ||
fb89b45c DM |
483 | static void v9fs_mmap_vm_close(struct vm_area_struct *vma) |
484 | { | |
485 | struct inode *inode; | |
486 | ||
487 | struct writeback_control wbc = { | |
488 | .nr_to_write = LONG_MAX, | |
489 | .sync_mode = WB_SYNC_ALL, | |
f5f7ab16 | 490 | .range_start = (loff_t)vma->vm_pgoff * PAGE_SIZE, |
fb89b45c | 491 | /* absolute end, byte at end included */ |
f5f7ab16 | 492 | .range_end = (loff_t)vma->vm_pgoff * PAGE_SIZE + |
fb89b45c DM |
493 | (vma->vm_end - vma->vm_start - 1), |
494 | }; | |
495 | ||
c87a37eb CX |
496 | if (!(vma->vm_flags & VM_SHARED)) |
497 | return; | |
fb89b45c DM |
498 | |
499 | p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); | |
500 | ||
501 | inode = file_inode(vma->vm_file); | |
25d23cd0 | 502 | filemap_fdatawrite_wbc(inode->i_mapping, &wbc); |
fb89b45c DM |
503 | } |
504 | ||
fb89b45c DM |
505 | static const struct vm_operations_struct v9fs_mmap_file_vm_ops = { |
506 | .close = v9fs_mmap_vm_close, | |
507 | .fault = filemap_fault, | |
f1820361 | 508 | .map_pages = filemap_map_pages, |
fb89b45c | 509 | .page_mkwrite = v9fs_vm_page_mkwrite, |
fb89b45c DM |
510 | }; |
511 | ||
4b6f5d20 | 512 | const struct file_operations v9fs_file_operations = { |
e69e7fe5 | 513 | .llseek = generic_file_llseek, |
e494b6b5 AV |
514 | .read_iter = v9fs_file_read_iter, |
515 | .write_iter = v9fs_file_write_iter, | |
e69e7fe5 EVH |
516 | .open = v9fs_file_open, |
517 | .release = v9fs_dir_release, | |
518 | .lock = v9fs_file_lock, | |
14b8869f | 519 | .mmap = generic_file_readonly_mmap, |
c829d0bd | 520 | .splice_read = v9fs_file_splice_read, |
960f4f8a | 521 | .splice_write = iter_file_splice_write, |
7a4439c4 | 522 | .fsync = v9fs_file_fsync, |
e69e7fe5 | 523 | }; |
9b6533c9 SK |
524 | |
525 | const struct file_operations v9fs_file_operations_dotl = { | |
526 | .llseek = generic_file_llseek, | |
e494b6b5 AV |
527 | .read_iter = v9fs_file_read_iter, |
528 | .write_iter = v9fs_file_write_iter, | |
9b6533c9 SK |
529 | .open = v9fs_file_open, |
530 | .release = v9fs_dir_release, | |
a099027c MK |
531 | .lock = v9fs_file_lock_dotl, |
532 | .flock = v9fs_file_flock_dotl, | |
d9bc0d11 | 533 | .mmap = v9fs_file_mmap, |
c829d0bd | 534 | .splice_read = v9fs_file_splice_read, |
960f4f8a | 535 | .splice_write = iter_file_splice_write, |
fb89b45c DM |
536 | .fsync = v9fs_file_fsync_dotl, |
537 | }; |