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