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; |
b5ac1fb2 | 356 | int ret, err = 0; |
e69e7fe5 | 357 | |
1543b4c5 EVH |
358 | p9_debug(P9_DEBUG_VFS, "fid %d count %zu offset %lld\n", |
359 | fid->fid, iov_iter_count(to), iocb->ki_pos); | |
fbedadc1 | 360 | |
1543b4c5 EVH |
361 | if (!(fid->mode & P9L_DIRECT)) { |
362 | p9_debug(P9_DEBUG_VFS, "(cached)\n"); | |
d9bc0d11 | 363 | return generic_file_read_iter(iocb, to); |
1543b4c5 | 364 | } |
d9bc0d11 | 365 | |
52cbee2a SA |
366 | if (iocb->ki_filp->f_flags & O_NONBLOCK) |
367 | ret = p9_client_read_once(fid, iocb->ki_pos, to, &err); | |
368 | else | |
369 | ret = p9_client_read(fid, iocb->ki_pos, to, &err); | |
e1200fe6 AV |
370 | if (!ret) |
371 | return err; | |
e69e7fe5 | 372 | |
e494b6b5 | 373 | iocb->ki_pos += ret; |
bd238fb4 | 374 | return ret; |
e69e7fe5 EVH |
375 | } |
376 | ||
c829d0bd DH |
377 | /* |
378 | * v9fs_file_splice_read - splice-read from a file | |
379 | * @in: The 9p file to read from | |
380 | * @ppos: Where to find/update the file position | |
381 | * @pipe: The pipe to splice into | |
382 | * @len: The maximum amount of data to splice | |
383 | * @flags: SPLICE_F_* flags | |
384 | */ | |
385 | static ssize_t v9fs_file_splice_read(struct file *in, loff_t *ppos, | |
386 | struct pipe_inode_info *pipe, | |
387 | size_t len, unsigned int flags) | |
388 | { | |
389 | struct p9_fid *fid = in->private_data; | |
390 | ||
391 | p9_debug(P9_DEBUG_VFS, "fid %d count %zu offset %lld\n", | |
392 | fid->fid, len, *ppos); | |
393 | ||
394 | if (fid->mode & P9L_DIRECT) | |
395 | return copy_splice_read(in, ppos, pipe, len, flags); | |
396 | return filemap_splice_read(in, ppos, pipe, len, flags); | |
397 | } | |
398 | ||
17311779 | 399 | /** |
bc868036 DH |
400 | * v9fs_file_write_iter - write to a file |
401 | * @iocb: The operation parameters | |
402 | * @from: The data to write | |
17311779 AK |
403 | * |
404 | */ | |
405 | static ssize_t | |
e494b6b5 | 406 | v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) |
17311779 | 407 | { |
e494b6b5 | 408 | struct file *file = iocb->ki_filp; |
1543b4c5 | 409 | struct p9_fid *fid = file->private_data; |
3309dd04 AV |
410 | ssize_t retval; |
411 | loff_t origin; | |
c711a6b1 | 412 | int err = 0; |
d9bc0d11 | 413 | |
1543b4c5 EVH |
414 | p9_debug(P9_DEBUG_VFS, "fid %d\n", fid->fid); |
415 | ||
416 | if (!(fid->mode & (P9L_DIRECT | P9L_NOWRITECACHE))) { | |
417 | p9_debug(P9_DEBUG_CACHE, "(cached)\n"); | |
d9bc0d11 | 418 | return generic_file_write_iter(iocb, from); |
1543b4c5 | 419 | } |
17311779 | 420 | |
3309dd04 AV |
421 | retval = generic_write_checks(iocb, from); |
422 | if (retval <= 0) | |
c711a6b1 AV |
423 | return retval; |
424 | ||
3309dd04 AV |
425 | origin = iocb->ki_pos; |
426 | retval = p9_client_write(file->private_data, iocb->ki_pos, from, &err); | |
c711a6b1 | 427 | if (retval > 0) { |
e494b6b5 | 428 | struct inode *inode = file_inode(file); |
c711a6b1 AV |
429 | loff_t i_size; |
430 | unsigned long pg_start, pg_end; | |
6e195b0f | 431 | |
09cbfeaf KS |
432 | pg_start = origin >> PAGE_SHIFT; |
433 | pg_end = (origin + retval - 1) >> PAGE_SHIFT; | |
c711a6b1 AV |
434 | if (inode->i_mapping && inode->i_mapping->nrpages) |
435 | invalidate_inode_pages2_range(inode->i_mapping, | |
436 | pg_start, pg_end); | |
3309dd04 | 437 | iocb->ki_pos += retval; |
c711a6b1 | 438 | i_size = i_size_read(inode); |
3309dd04 AV |
439 | if (iocb->ki_pos > i_size) { |
440 | inode_add_bytes(inode, iocb->ki_pos - i_size); | |
5e3cc1ee HT |
441 | /* |
442 | * Need to serialize against i_size_write() in | |
443 | * v9fs_stat2inode() | |
444 | */ | |
445 | v9fs_i_size_write(inode, iocb->ki_pos); | |
c711a6b1 AV |
446 | } |
447 | return retval; | |
448 | } | |
449 | return err; | |
e69e7fe5 EVH |
450 | } |
451 | ||
02c24a82 JB |
452 | static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, |
453 | int datasync) | |
7a4439c4 MK |
454 | { |
455 | struct p9_fid *fid; | |
02c24a82 | 456 | struct inode *inode = filp->f_mapping->host; |
7a4439c4 MK |
457 | struct p9_wstat wstat; |
458 | int retval; | |
459 | ||
3b49c9a1 | 460 | retval = file_write_and_wait_range(filp, start, end); |
02c24a82 JB |
461 | if (retval) |
462 | return retval; | |
463 | ||
5955102c | 464 | inode_lock(inode); |
5d385153 | 465 | p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); |
7a4439c4 MK |
466 | |
467 | fid = filp->private_data; | |
468 | v9fs_blank_wstat(&wstat); | |
469 | ||
470 | retval = p9_client_wstat(fid, &wstat); | |
5955102c | 471 | inode_unlock(inode); |
02c24a82 | 472 | |
7a4439c4 MK |
473 | return retval; |
474 | } | |
475 | ||
02c24a82 JB |
476 | int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, |
477 | int datasync) | |
920e65dc VJJ |
478 | { |
479 | struct p9_fid *fid; | |
02c24a82 | 480 | struct inode *inode = filp->f_mapping->host; |
920e65dc VJJ |
481 | int retval; |
482 | ||
3b49c9a1 | 483 | retval = file_write_and_wait_range(filp, start, end); |
02c24a82 JB |
484 | if (retval) |
485 | return retval; | |
486 | ||
5955102c | 487 | inode_lock(inode); |
5d385153 | 488 | p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); |
920e65dc VJJ |
489 | |
490 | fid = filp->private_data; | |
491 | ||
b165d601 | 492 | retval = p9_client_fsync(fid, datasync); |
5955102c | 493 | inode_unlock(inode); |
02c24a82 | 494 | |
920e65dc VJJ |
495 | return retval; |
496 | } | |
497 | ||
7263cebe | 498 | static int |
fb89b45c | 499 | v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) |
7263cebe AK |
500 | { |
501 | int retval; | |
d9bc0d11 | 502 | struct inode *inode = file_inode(filp); |
d9bc0d11 | 503 | struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode); |
1543b4c5 EVH |
504 | |
505 | p9_debug(P9_DEBUG_MMAP, "filp :%p\n", filp); | |
fb89b45c | 506 | |
4eb31178 | 507 | if (!(v9ses->cache & CACHE_WRITEBACK)) { |
75b39682 | 508 | p9_debug(P9_DEBUG_CACHE, "(read-only mmap mode)"); |
d9bc0d11 EVH |
509 | return generic_file_readonly_mmap(filp, vma); |
510 | } | |
511 | ||
fb89b45c DM |
512 | retval = generic_file_mmap(filp, vma); |
513 | if (!retval) | |
514 | vma->vm_ops = &v9fs_mmap_file_vm_ops; | |
515 | ||
516 | return retval; | |
517 | } | |
518 | ||
fe6340e2 | 519 | static vm_fault_t |
11bac800 | 520 | v9fs_vm_page_mkwrite(struct vm_fault *vmf) |
7263cebe | 521 | { |
78525c74 | 522 | struct folio *folio = page_folio(vmf->page); |
11bac800 | 523 | struct file *filp = vmf->vma->vm_file; |
496ad9aa | 524 | struct inode *inode = file_inode(filp); |
7263cebe AK |
525 | |
526 | ||
78525c74 DH |
527 | p9_debug(P9_DEBUG_VFS, "folio %p fid %lx\n", |
528 | folio, (unsigned long)filp->private_data); | |
7263cebe | 529 | |
eb497943 DH |
530 | /* Wait for the page to be written to the cache before we allow it to |
531 | * be modified. We then assume the entire page will need writing back. | |
532 | */ | |
533 | #ifdef CONFIG_9P_FSCACHE | |
78525c74 DH |
534 | if (folio_test_fscache(folio) && |
535 | folio_wait_fscache_killable(folio) < 0) | |
536 | return VM_FAULT_NOPAGE; | |
eb497943 DH |
537 | #endif |
538 | ||
120c2bca JK |
539 | /* Update file times before taking page lock */ |
540 | file_update_time(filp); | |
541 | ||
78525c74 | 542 | if (folio_lock_killable(folio) < 0) |
eb497943 | 543 | return VM_FAULT_RETRY; |
78525c74 | 544 | if (folio_mapping(folio) != inode->i_mapping) |
7263cebe | 545 | goto out_unlock; |
78525c74 | 546 | folio_wait_stable(folio); |
7263cebe AK |
547 | |
548 | return VM_FAULT_LOCKED; | |
549 | out_unlock: | |
78525c74 | 550 | folio_unlock(folio); |
7263cebe AK |
551 | return VM_FAULT_NOPAGE; |
552 | } | |
553 | ||
fb89b45c DM |
554 | static void v9fs_mmap_vm_close(struct vm_area_struct *vma) |
555 | { | |
556 | struct inode *inode; | |
557 | ||
558 | struct writeback_control wbc = { | |
559 | .nr_to_write = LONG_MAX, | |
560 | .sync_mode = WB_SYNC_ALL, | |
f5f7ab16 | 561 | .range_start = (loff_t)vma->vm_pgoff * PAGE_SIZE, |
fb89b45c | 562 | /* absolute end, byte at end included */ |
f5f7ab16 | 563 | .range_end = (loff_t)vma->vm_pgoff * PAGE_SIZE + |
fb89b45c DM |
564 | (vma->vm_end - vma->vm_start - 1), |
565 | }; | |
566 | ||
c87a37eb CX |
567 | if (!(vma->vm_flags & VM_SHARED)) |
568 | return; | |
fb89b45c DM |
569 | |
570 | p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); | |
571 | ||
572 | inode = file_inode(vma->vm_file); | |
25d23cd0 | 573 | filemap_fdatawrite_wbc(inode->i_mapping, &wbc); |
fb89b45c DM |
574 | } |
575 | ||
fb89b45c DM |
576 | static const struct vm_operations_struct v9fs_mmap_file_vm_ops = { |
577 | .close = v9fs_mmap_vm_close, | |
578 | .fault = filemap_fault, | |
f1820361 | 579 | .map_pages = filemap_map_pages, |
fb89b45c | 580 | .page_mkwrite = v9fs_vm_page_mkwrite, |
fb89b45c DM |
581 | }; |
582 | ||
4b6f5d20 | 583 | const struct file_operations v9fs_file_operations = { |
e69e7fe5 | 584 | .llseek = generic_file_llseek, |
e494b6b5 AV |
585 | .read_iter = v9fs_file_read_iter, |
586 | .write_iter = v9fs_file_write_iter, | |
e69e7fe5 EVH |
587 | .open = v9fs_file_open, |
588 | .release = v9fs_dir_release, | |
589 | .lock = v9fs_file_lock, | |
14b8869f | 590 | .mmap = generic_file_readonly_mmap, |
c829d0bd | 591 | .splice_read = v9fs_file_splice_read, |
960f4f8a | 592 | .splice_write = iter_file_splice_write, |
7a4439c4 | 593 | .fsync = v9fs_file_fsync, |
e69e7fe5 | 594 | }; |
9b6533c9 SK |
595 | |
596 | const struct file_operations v9fs_file_operations_dotl = { | |
597 | .llseek = generic_file_llseek, | |
e494b6b5 AV |
598 | .read_iter = v9fs_file_read_iter, |
599 | .write_iter = v9fs_file_write_iter, | |
9b6533c9 SK |
600 | .open = v9fs_file_open, |
601 | .release = v9fs_dir_release, | |
a099027c MK |
602 | .lock = v9fs_file_lock_dotl, |
603 | .flock = v9fs_file_flock_dotl, | |
d9bc0d11 | 604 | .mmap = v9fs_file_mmap, |
c829d0bd | 605 | .splice_read = v9fs_file_splice_read, |
960f4f8a | 606 | .splice_write = iter_file_splice_write, |
fb89b45c DM |
607 | .fsync = v9fs_file_fsync_dotl, |
608 | }; |