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