1 /* 2 * linux/fs/9p/vfs_file.c 3 * 4 * This file contians vfs file ops for 9P2000. 5 * 6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> 7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 11 * as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to: 20 * Free Software Foundation 21 * 51 Franklin Street, Fifth Floor 22 * Boston, MA 02111-1301 USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/fs.h> 29 #include <linux/sched.h> 30 #include <linux/file.h> 31 #include <linux/stat.h> 32 #include <linux/string.h> 33 #include <linux/inet.h> 34 #include <linux/list.h> 35 #include <linux/pagemap.h> 36 #include <linux/utsname.h> 37 #include <asm/uaccess.h> 38 #include <linux/idr.h> 39 #include <net/9p/9p.h> 40 #include <net/9p/client.h> 41 42 #include "v9fs.h" 43 #include "v9fs_vfs.h" 44 #include "fid.h" 45 #include "cache.h" 46 47 static const struct vm_operations_struct v9fs_file_vm_ops; 48 static const struct vm_operations_struct v9fs_mmap_file_vm_ops; 49 50 /** 51 * v9fs_file_open - open a file (or directory) 52 * @inode: inode to be opened 53 * @file: file being opened 54 * 55 */ 56 57 int v9fs_file_open(struct inode *inode, struct file *file) 58 { 59 int err; 60 struct v9fs_inode *v9inode; 61 struct v9fs_session_info *v9ses; 62 struct p9_fid *fid; 63 int omode; 64 65 p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file); 66 v9inode = V9FS_I(inode); 67 v9ses = v9fs_inode2v9ses(inode); 68 if (v9fs_proto_dotl(v9ses)) 69 omode = v9fs_open_to_dotl_flags(file->f_flags); 70 else 71 omode = v9fs_uflags2omode(file->f_flags, 72 v9fs_proto_dotu(v9ses)); 73 fid = file->private_data; 74 if (!fid) { 75 fid = v9fs_fid_clone(file->f_path.dentry); 76 if (IS_ERR(fid)) 77 return PTR_ERR(fid); 78 79 err = p9_client_open(fid, omode); 80 if (err < 0) { 81 p9_client_clunk(fid); 82 return err; 83 } 84 if ((file->f_flags & O_APPEND) && 85 (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))) 86 generic_file_llseek(file, 0, SEEK_END); 87 } 88 89 file->private_data = fid; 90 mutex_lock(&v9inode->v_mutex); 91 if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) && 92 !v9inode->writeback_fid && 93 ((file->f_flags & O_ACCMODE) != O_RDONLY)) { 94 /* 95 * clone a fid and add it to writeback_fid 96 * we do it during open time instead of 97 * page dirty time via write_begin/page_mkwrite 98 * because we want write after unlink usecase 99 * to work. 100 */ 101 fid = v9fs_writeback_fid(file->f_path.dentry); 102 if (IS_ERR(fid)) { 103 err = PTR_ERR(fid); 104 mutex_unlock(&v9inode->v_mutex); 105 goto out_error; 106 } 107 v9inode->writeback_fid = (void *) fid; 108 } 109 mutex_unlock(&v9inode->v_mutex); 110 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) 111 v9fs_cache_inode_set_cookie(inode, file); 112 return 0; 113 out_error: 114 p9_client_clunk(file->private_data); 115 file->private_data = NULL; 116 return err; 117 } 118 119 /** 120 * v9fs_file_lock - lock a file (or directory) 121 * @filp: file to be locked 122 * @cmd: lock command 123 * @fl: file lock structure 124 * 125 * Bugs: this looks like a local only lock, we should extend into 9P 126 * by using open exclusive 127 */ 128 129 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) 130 { 131 int res = 0; 132 struct inode *inode = file_inode(filp); 133 134 p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); 135 136 /* No mandatory locks */ 137 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 138 return -ENOLCK; 139 140 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 141 filemap_write_and_wait(inode->i_mapping); 142 invalidate_mapping_pages(&inode->i_data, 0, -1); 143 } 144 145 return res; 146 } 147 148 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) 149 { 150 struct p9_flock flock; 151 struct p9_fid *fid; 152 uint8_t status; 153 int res = 0; 154 unsigned char fl_type; 155 156 fid = filp->private_data; 157 BUG_ON(fid == NULL); 158 159 if ((fl->fl_flags & FL_POSIX) != FL_POSIX) 160 BUG(); 161 162 res = posix_lock_file_wait(filp, fl); 163 if (res < 0) 164 goto out; 165 166 /* convert posix lock to p9 tlock args */ 167 memset(&flock, 0, sizeof(flock)); 168 /* map the lock type */ 169 switch (fl->fl_type) { 170 case F_RDLCK: 171 flock.type = P9_LOCK_TYPE_RDLCK; 172 break; 173 case F_WRLCK: 174 flock.type = P9_LOCK_TYPE_WRLCK; 175 break; 176 case F_UNLCK: 177 flock.type = P9_LOCK_TYPE_UNLCK; 178 break; 179 } 180 flock.start = fl->fl_start; 181 if (fl->fl_end == OFFSET_MAX) 182 flock.length = 0; 183 else 184 flock.length = fl->fl_end - fl->fl_start + 1; 185 flock.proc_id = fl->fl_pid; 186 flock.client_id = fid->clnt->name; 187 if (IS_SETLKW(cmd)) 188 flock.flags = P9_LOCK_FLAGS_BLOCK; 189 190 /* 191 * if its a blocked request and we get P9_LOCK_BLOCKED as the status 192 * for lock request, keep on trying 193 */ 194 for (;;) { 195 res = p9_client_lock_dotl(fid, &flock, &status); 196 if (res < 0) 197 break; 198 199 if (status != P9_LOCK_BLOCKED) 200 break; 201 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd)) 202 break; 203 if (schedule_timeout_interruptible(P9_LOCK_TIMEOUT) != 0) 204 break; 205 } 206 207 /* map 9p status to VFS status */ 208 switch (status) { 209 case P9_LOCK_SUCCESS: 210 res = 0; 211 break; 212 case P9_LOCK_BLOCKED: 213 res = -EAGAIN; 214 break; 215 case P9_LOCK_ERROR: 216 case P9_LOCK_GRACE: 217 res = -ENOLCK; 218 break; 219 default: 220 BUG(); 221 } 222 223 /* 224 * incase server returned error for lock request, revert 225 * it locally 226 */ 227 if (res < 0 && fl->fl_type != F_UNLCK) { 228 fl_type = fl->fl_type; 229 fl->fl_type = F_UNLCK; 230 res = posix_lock_file_wait(filp, fl); 231 fl->fl_type = fl_type; 232 } 233 out: 234 return res; 235 } 236 237 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) 238 { 239 struct p9_getlock glock; 240 struct p9_fid *fid; 241 int res = 0; 242 243 fid = filp->private_data; 244 BUG_ON(fid == NULL); 245 246 posix_test_lock(filp, fl); 247 /* 248 * if we have a conflicting lock locally, no need to validate 249 * with server 250 */ 251 if (fl->fl_type != F_UNLCK) 252 return res; 253 254 /* convert posix lock to p9 tgetlock args */ 255 memset(&glock, 0, sizeof(glock)); 256 glock.type = P9_LOCK_TYPE_UNLCK; 257 glock.start = fl->fl_start; 258 if (fl->fl_end == OFFSET_MAX) 259 glock.length = 0; 260 else 261 glock.length = fl->fl_end - fl->fl_start + 1; 262 glock.proc_id = fl->fl_pid; 263 glock.client_id = fid->clnt->name; 264 265 res = p9_client_getlock_dotl(fid, &glock); 266 if (res < 0) 267 return res; 268 /* map 9p lock type to os lock type */ 269 switch (glock.type) { 270 case P9_LOCK_TYPE_RDLCK: 271 fl->fl_type = F_RDLCK; 272 break; 273 case P9_LOCK_TYPE_WRLCK: 274 fl->fl_type = F_WRLCK; 275 break; 276 case P9_LOCK_TYPE_UNLCK: 277 fl->fl_type = F_UNLCK; 278 break; 279 } 280 if (glock.type != P9_LOCK_TYPE_UNLCK) { 281 fl->fl_start = glock.start; 282 if (glock.length == 0) 283 fl->fl_end = OFFSET_MAX; 284 else 285 fl->fl_end = glock.start + glock.length - 1; 286 fl->fl_pid = glock.proc_id; 287 } 288 return res; 289 } 290 291 /** 292 * v9fs_file_lock_dotl - lock a file (or directory) 293 * @filp: file to be locked 294 * @cmd: lock command 295 * @fl: file lock structure 296 * 297 */ 298 299 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) 300 { 301 struct inode *inode = file_inode(filp); 302 int ret = -ENOLCK; 303 304 p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", 305 filp, cmd, fl, filp->f_path.dentry->d_name.name); 306 307 /* No mandatory locks */ 308 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 309 goto out_err; 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 out_err: 323 return ret; 324 } 325 326 /** 327 * v9fs_file_flock_dotl - lock a file 328 * @filp: file to be locked 329 * @cmd: lock command 330 * @fl: file lock structure 331 * 332 */ 333 334 static int v9fs_file_flock_dotl(struct file *filp, int cmd, 335 struct file_lock *fl) 336 { 337 struct inode *inode = file_inode(filp); 338 int ret = -ENOLCK; 339 340 p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", 341 filp, cmd, fl, filp->f_path.dentry->d_name.name); 342 343 /* No mandatory locks */ 344 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 345 goto out_err; 346 347 if (!(fl->fl_flags & FL_FLOCK)) 348 goto out_err; 349 350 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 351 filemap_write_and_wait(inode->i_mapping); 352 invalidate_mapping_pages(&inode->i_data, 0, -1); 353 } 354 /* Convert flock to posix lock */ 355 fl->fl_owner = (fl_owner_t)filp; 356 fl->fl_start = 0; 357 fl->fl_end = OFFSET_MAX; 358 fl->fl_flags |= FL_POSIX; 359 fl->fl_flags ^= FL_FLOCK; 360 361 if (IS_SETLK(cmd) | IS_SETLKW(cmd)) 362 ret = v9fs_file_do_lock(filp, cmd, fl); 363 else 364 ret = -EINVAL; 365 out_err: 366 return ret; 367 } 368 369 /** 370 * v9fs_fid_readn - read from a fid 371 * @fid: fid to read 372 * @data: data buffer to read data into 373 * @udata: user data buffer to read data into 374 * @count: size of buffer 375 * @offset: offset at which to read data 376 * 377 */ 378 ssize_t 379 v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count, 380 u64 offset) 381 { 382 int n, total, size; 383 384 p9_debug(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", 385 fid->fid, (long long unsigned)offset, count); 386 n = 0; 387 total = 0; 388 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 389 do { 390 n = p9_client_read(fid, data, udata, offset, count); 391 if (n <= 0) 392 break; 393 394 if (data) 395 data += n; 396 if (udata) 397 udata += n; 398 399 offset += n; 400 count -= n; 401 total += n; 402 } while (count > 0 && n == size); 403 404 if (n < 0) 405 total = n; 406 407 return total; 408 } 409 410 /** 411 * v9fs_file_readn - read from a file 412 * @filp: file pointer to read 413 * @data: data buffer to read data into 414 * @udata: user data buffer to read data into 415 * @count: size of buffer 416 * @offset: offset at which to read data 417 * 418 */ 419 ssize_t 420 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count, 421 u64 offset) 422 { 423 return v9fs_fid_readn(filp->private_data, data, udata, count, offset); 424 } 425 426 /** 427 * v9fs_file_read - read from a file 428 * @filp: file pointer to read 429 * @udata: user data buffer to read data into 430 * @count: size of buffer 431 * @offset: offset at which to read data 432 * 433 */ 434 435 static ssize_t 436 v9fs_file_read(struct file *filp, char __user *udata, size_t count, 437 loff_t * offset) 438 { 439 int ret; 440 struct p9_fid *fid; 441 size_t size; 442 443 p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset); 444 fid = filp->private_data; 445 446 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 447 if (count > size) 448 ret = v9fs_file_readn(filp, NULL, udata, count, *offset); 449 else 450 ret = p9_client_read(fid, NULL, udata, *offset, count); 451 452 if (ret > 0) 453 *offset += ret; 454 455 return ret; 456 } 457 458 ssize_t 459 v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid, 460 const char __user *data, size_t count, 461 loff_t *offset, int invalidate) 462 { 463 int n; 464 loff_t i_size; 465 size_t total = 0; 466 loff_t origin = *offset; 467 unsigned long pg_start, pg_end; 468 469 p9_debug(P9_DEBUG_VFS, "data %p count %d offset %x\n", 470 data, (int)count, (int)*offset); 471 472 do { 473 n = p9_client_write(fid, NULL, data+total, origin+total, count); 474 if (n <= 0) 475 break; 476 count -= n; 477 total += n; 478 } while (count > 0); 479 480 if (invalidate && (total > 0)) { 481 pg_start = origin >> PAGE_CACHE_SHIFT; 482 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT; 483 if (inode->i_mapping && inode->i_mapping->nrpages) 484 invalidate_inode_pages2_range(inode->i_mapping, 485 pg_start, pg_end); 486 *offset += total; 487 i_size = i_size_read(inode); 488 if (*offset > i_size) { 489 inode_add_bytes(inode, *offset - i_size); 490 i_size_write(inode, *offset); 491 } 492 } 493 if (n < 0) 494 return n; 495 496 return total; 497 } 498 499 /** 500 * v9fs_file_write - write to a file 501 * @filp: file pointer to write 502 * @data: data buffer to write data from 503 * @count: size of buffer 504 * @offset: offset at which to write data 505 * 506 */ 507 static ssize_t 508 v9fs_file_write(struct file *filp, const char __user * data, 509 size_t count, loff_t *offset) 510 { 511 ssize_t retval = 0; 512 loff_t origin = *offset; 513 514 515 retval = generic_write_checks(filp, &origin, &count, 0); 516 if (retval) 517 goto out; 518 519 retval = -EINVAL; 520 if ((ssize_t) count < 0) 521 goto out; 522 retval = 0; 523 if (!count) 524 goto out; 525 526 retval = v9fs_file_write_internal(file_inode(filp), 527 filp->private_data, 528 data, count, &origin, 1); 529 /* update offset on successful write */ 530 if (retval > 0) 531 *offset = origin; 532 out: 533 return retval; 534 } 535 536 537 static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, 538 int datasync) 539 { 540 struct p9_fid *fid; 541 struct inode *inode = filp->f_mapping->host; 542 struct p9_wstat wstat; 543 int retval; 544 545 retval = filemap_write_and_wait_range(inode->i_mapping, start, end); 546 if (retval) 547 return retval; 548 549 mutex_lock(&inode->i_mutex); 550 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 551 552 fid = filp->private_data; 553 v9fs_blank_wstat(&wstat); 554 555 retval = p9_client_wstat(fid, &wstat); 556 mutex_unlock(&inode->i_mutex); 557 558 return retval; 559 } 560 561 int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, 562 int datasync) 563 { 564 struct p9_fid *fid; 565 struct inode *inode = filp->f_mapping->host; 566 int retval; 567 568 retval = filemap_write_and_wait_range(inode->i_mapping, start, end); 569 if (retval) 570 return retval; 571 572 mutex_lock(&inode->i_mutex); 573 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 574 575 fid = filp->private_data; 576 577 retval = p9_client_fsync(fid, datasync); 578 mutex_unlock(&inode->i_mutex); 579 580 return retval; 581 } 582 583 static int 584 v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) 585 { 586 int retval; 587 588 589 retval = generic_file_mmap(filp, vma); 590 if (!retval) 591 vma->vm_ops = &v9fs_file_vm_ops; 592 593 return retval; 594 } 595 596 static int 597 v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma) 598 { 599 int retval; 600 struct inode *inode; 601 struct v9fs_inode *v9inode; 602 struct p9_fid *fid; 603 604 inode = file_inode(filp); 605 v9inode = V9FS_I(inode); 606 mutex_lock(&v9inode->v_mutex); 607 if (!v9inode->writeback_fid && 608 (vma->vm_flags & VM_WRITE)) { 609 /* 610 * clone a fid and add it to writeback_fid 611 * we do it during mmap instead of 612 * page dirty time via write_begin/page_mkwrite 613 * because we want write after unlink usecase 614 * to work. 615 */ 616 fid = v9fs_writeback_fid(filp->f_path.dentry); 617 if (IS_ERR(fid)) { 618 retval = PTR_ERR(fid); 619 mutex_unlock(&v9inode->v_mutex); 620 return retval; 621 } 622 v9inode->writeback_fid = (void *) fid; 623 } 624 mutex_unlock(&v9inode->v_mutex); 625 626 retval = generic_file_mmap(filp, vma); 627 if (!retval) 628 vma->vm_ops = &v9fs_mmap_file_vm_ops; 629 630 return retval; 631 } 632 633 static int 634 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 635 { 636 struct v9fs_inode *v9inode; 637 struct page *page = vmf->page; 638 struct file *filp = vma->vm_file; 639 struct inode *inode = file_inode(filp); 640 641 642 p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n", 643 page, (unsigned long)filp->private_data); 644 645 /* Update file times before taking page lock */ 646 file_update_time(filp); 647 648 v9inode = V9FS_I(inode); 649 /* make sure the cache has finished storing the page */ 650 v9fs_fscache_wait_on_page_write(inode, page); 651 BUG_ON(!v9inode->writeback_fid); 652 lock_page(page); 653 if (page->mapping != inode->i_mapping) 654 goto out_unlock; 655 wait_for_stable_page(page); 656 657 return VM_FAULT_LOCKED; 658 out_unlock: 659 unlock_page(page); 660 return VM_FAULT_NOPAGE; 661 } 662 663 static ssize_t 664 v9fs_direct_read(struct file *filp, char __user *udata, size_t count, 665 loff_t *offsetp) 666 { 667 loff_t size, offset; 668 struct inode *inode; 669 struct address_space *mapping; 670 671 offset = *offsetp; 672 mapping = filp->f_mapping; 673 inode = mapping->host; 674 if (!count) 675 return 0; 676 size = i_size_read(inode); 677 if (offset < size) 678 filemap_write_and_wait_range(mapping, offset, 679 offset + count - 1); 680 681 return v9fs_file_read(filp, udata, count, offsetp); 682 } 683 684 /** 685 * v9fs_cached_file_read - read from a file 686 * @filp: file pointer to read 687 * @udata: user data buffer to read data into 688 * @count: size of buffer 689 * @offset: offset at which to read data 690 * 691 */ 692 static ssize_t 693 v9fs_cached_file_read(struct file *filp, char __user *data, size_t count, 694 loff_t *offset) 695 { 696 if (filp->f_flags & O_DIRECT) 697 return v9fs_direct_read(filp, data, count, offset); 698 return do_sync_read(filp, data, count, offset); 699 } 700 701 /** 702 * v9fs_mmap_file_read - read from a file 703 * @filp: file pointer to read 704 * @udata: user data buffer to read data into 705 * @count: size of buffer 706 * @offset: offset at which to read data 707 * 708 */ 709 static ssize_t 710 v9fs_mmap_file_read(struct file *filp, char __user *data, size_t count, 711 loff_t *offset) 712 { 713 /* TODO: Check if there are dirty pages */ 714 return v9fs_file_read(filp, data, count, offset); 715 } 716 717 static ssize_t 718 v9fs_direct_write(struct file *filp, const char __user * data, 719 size_t count, loff_t *offsetp) 720 { 721 loff_t offset; 722 ssize_t retval; 723 struct inode *inode; 724 struct address_space *mapping; 725 726 offset = *offsetp; 727 mapping = filp->f_mapping; 728 inode = mapping->host; 729 if (!count) 730 return 0; 731 732 mutex_lock(&inode->i_mutex); 733 retval = filemap_write_and_wait_range(mapping, offset, 734 offset + count - 1); 735 if (retval) 736 goto err_out; 737 /* 738 * After a write we want buffered reads to be sure to go to disk to get 739 * the new data. We invalidate clean cached page from the region we're 740 * about to write. We do this *before* the write so that if we fail 741 * here we fall back to buffered write 742 */ 743 if (mapping->nrpages) { 744 pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT; 745 pgoff_t pg_end = (offset + count - 1) >> PAGE_CACHE_SHIFT; 746 747 retval = invalidate_inode_pages2_range(mapping, 748 pg_start, pg_end); 749 /* 750 * If a page can not be invalidated, fall back 751 * to buffered write. 752 */ 753 if (retval) { 754 if (retval == -EBUSY) 755 goto buff_write; 756 goto err_out; 757 } 758 } 759 retval = v9fs_file_write(filp, data, count, offsetp); 760 err_out: 761 mutex_unlock(&inode->i_mutex); 762 return retval; 763 764 buff_write: 765 mutex_unlock(&inode->i_mutex); 766 return do_sync_write(filp, data, count, offsetp); 767 } 768 769 /** 770 * v9fs_cached_file_write - write to a file 771 * @filp: file pointer to write 772 * @data: data buffer to write data from 773 * @count: size of buffer 774 * @offset: offset at which to write data 775 * 776 */ 777 static ssize_t 778 v9fs_cached_file_write(struct file *filp, const char __user * data, 779 size_t count, loff_t *offset) 780 { 781 782 if (filp->f_flags & O_DIRECT) 783 return v9fs_direct_write(filp, data, count, offset); 784 return do_sync_write(filp, data, count, offset); 785 } 786 787 788 /** 789 * v9fs_mmap_file_write - write to a file 790 * @filp: file pointer to write 791 * @data: data buffer to write data from 792 * @count: size of buffer 793 * @offset: offset at which to write data 794 * 795 */ 796 static ssize_t 797 v9fs_mmap_file_write(struct file *filp, const char __user *data, 798 size_t count, loff_t *offset) 799 { 800 /* 801 * TODO: invalidate mmaps on filp's inode between 802 * offset and offset+count 803 */ 804 return v9fs_file_write(filp, data, count, offset); 805 } 806 807 static void v9fs_mmap_vm_close(struct vm_area_struct *vma) 808 { 809 struct inode *inode; 810 811 struct writeback_control wbc = { 812 .nr_to_write = LONG_MAX, 813 .sync_mode = WB_SYNC_ALL, 814 .range_start = vma->vm_pgoff * PAGE_SIZE, 815 /* absolute end, byte at end included */ 816 .range_end = vma->vm_pgoff * PAGE_SIZE + 817 (vma->vm_end - vma->vm_start - 1), 818 }; 819 820 821 p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); 822 823 inode = file_inode(vma->vm_file); 824 825 if (!mapping_cap_writeback_dirty(inode->i_mapping)) 826 wbc.nr_to_write = 0; 827 828 might_sleep(); 829 sync_inode(inode, &wbc); 830 } 831 832 833 static const struct vm_operations_struct v9fs_file_vm_ops = { 834 .fault = filemap_fault, 835 .map_pages = filemap_map_pages, 836 .page_mkwrite = v9fs_vm_page_mkwrite, 837 .remap_pages = generic_file_remap_pages, 838 }; 839 840 static const struct vm_operations_struct v9fs_mmap_file_vm_ops = { 841 .close = v9fs_mmap_vm_close, 842 .fault = filemap_fault, 843 .map_pages = filemap_map_pages, 844 .page_mkwrite = v9fs_vm_page_mkwrite, 845 .remap_pages = generic_file_remap_pages, 846 }; 847 848 849 const struct file_operations v9fs_cached_file_operations = { 850 .llseek = generic_file_llseek, 851 .read = v9fs_cached_file_read, 852 .write = v9fs_cached_file_write, 853 .aio_read = generic_file_aio_read, 854 .aio_write = generic_file_aio_write, 855 .open = v9fs_file_open, 856 .release = v9fs_dir_release, 857 .lock = v9fs_file_lock, 858 .mmap = v9fs_file_mmap, 859 .fsync = v9fs_file_fsync, 860 }; 861 862 const struct file_operations v9fs_cached_file_operations_dotl = { 863 .llseek = generic_file_llseek, 864 .read = v9fs_cached_file_read, 865 .write = v9fs_cached_file_write, 866 .aio_read = generic_file_aio_read, 867 .aio_write = generic_file_aio_write, 868 .open = v9fs_file_open, 869 .release = v9fs_dir_release, 870 .lock = v9fs_file_lock_dotl, 871 .flock = v9fs_file_flock_dotl, 872 .mmap = v9fs_file_mmap, 873 .fsync = v9fs_file_fsync_dotl, 874 }; 875 876 const struct file_operations v9fs_file_operations = { 877 .llseek = generic_file_llseek, 878 .read = v9fs_file_read, 879 .write = v9fs_file_write, 880 .open = v9fs_file_open, 881 .release = v9fs_dir_release, 882 .lock = v9fs_file_lock, 883 .mmap = generic_file_readonly_mmap, 884 .fsync = v9fs_file_fsync, 885 }; 886 887 const struct file_operations v9fs_file_operations_dotl = { 888 .llseek = generic_file_llseek, 889 .read = v9fs_file_read, 890 .write = v9fs_file_write, 891 .open = v9fs_file_open, 892 .release = v9fs_dir_release, 893 .lock = v9fs_file_lock_dotl, 894 .flock = v9fs_file_flock_dotl, 895 .mmap = generic_file_readonly_mmap, 896 .fsync = v9fs_file_fsync_dotl, 897 }; 898 899 const struct file_operations v9fs_mmap_file_operations = { 900 .llseek = generic_file_llseek, 901 .read = v9fs_mmap_file_read, 902 .write = v9fs_mmap_file_write, 903 .open = v9fs_file_open, 904 .release = v9fs_dir_release, 905 .lock = v9fs_file_lock, 906 .mmap = v9fs_mmap_file_mmap, 907 .fsync = v9fs_file_fsync, 908 }; 909 910 const struct file_operations v9fs_mmap_file_operations_dotl = { 911 .llseek = generic_file_llseek, 912 .read = v9fs_mmap_file_read, 913 .write = v9fs_mmap_file_write, 914 .open = v9fs_file_open, 915 .release = v9fs_dir_release, 916 .lock = v9fs_file_lock_dotl, 917 .flock = v9fs_file_flock_dotl, 918 .mmap = v9fs_mmap_file_mmap, 919 .fsync = v9fs_file_fsync_dotl, 920 }; 921