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 <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->f_path.dentry); 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->f_path.dentry); 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 = posix_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 res = posix_lock_file_wait(filp, fl); 235 fl->fl_type = fl_type; 236 } 237 out: 238 return res; 239 } 240 241 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) 242 { 243 struct p9_getlock glock; 244 struct p9_fid *fid; 245 int res = 0; 246 247 fid = filp->private_data; 248 BUG_ON(fid == NULL); 249 250 posix_test_lock(filp, fl); 251 /* 252 * if we have a conflicting lock locally, no need to validate 253 * with server 254 */ 255 if (fl->fl_type != F_UNLCK) 256 return res; 257 258 /* convert posix lock to p9 tgetlock args */ 259 memset(&glock, 0, sizeof(glock)); 260 glock.type = P9_LOCK_TYPE_UNLCK; 261 glock.start = fl->fl_start; 262 if (fl->fl_end == OFFSET_MAX) 263 glock.length = 0; 264 else 265 glock.length = fl->fl_end - fl->fl_start + 1; 266 glock.proc_id = fl->fl_pid; 267 glock.client_id = fid->clnt->name; 268 269 res = p9_client_getlock_dotl(fid, &glock); 270 if (res < 0) 271 return res; 272 /* map 9p lock type to os lock type */ 273 switch (glock.type) { 274 case P9_LOCK_TYPE_RDLCK: 275 fl->fl_type = F_RDLCK; 276 break; 277 case P9_LOCK_TYPE_WRLCK: 278 fl->fl_type = F_WRLCK; 279 break; 280 case P9_LOCK_TYPE_UNLCK: 281 fl->fl_type = F_UNLCK; 282 break; 283 } 284 if (glock.type != P9_LOCK_TYPE_UNLCK) { 285 fl->fl_start = glock.start; 286 if (glock.length == 0) 287 fl->fl_end = OFFSET_MAX; 288 else 289 fl->fl_end = glock.start + glock.length - 1; 290 fl->fl_pid = glock.proc_id; 291 } 292 kfree(glock.client_id); 293 return res; 294 } 295 296 /** 297 * v9fs_file_lock_dotl - lock a file (or directory) 298 * @filp: file to be locked 299 * @cmd: lock command 300 * @fl: file lock structure 301 * 302 */ 303 304 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) 305 { 306 struct inode *inode = file_inode(filp); 307 int ret = -ENOLCK; 308 309 p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", 310 filp, cmd, fl, filp); 311 312 /* No mandatory locks */ 313 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 314 goto out_err; 315 316 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 317 filemap_write_and_wait(inode->i_mapping); 318 invalidate_mapping_pages(&inode->i_data, 0, -1); 319 } 320 321 if (IS_SETLK(cmd) || IS_SETLKW(cmd)) 322 ret = v9fs_file_do_lock(filp, cmd, fl); 323 else if (IS_GETLK(cmd)) 324 ret = v9fs_file_getlock(filp, fl); 325 else 326 ret = -EINVAL; 327 out_err: 328 return ret; 329 } 330 331 /** 332 * v9fs_file_flock_dotl - lock a file 333 * @filp: file to be locked 334 * @cmd: lock command 335 * @fl: file lock structure 336 * 337 */ 338 339 static int v9fs_file_flock_dotl(struct file *filp, int cmd, 340 struct file_lock *fl) 341 { 342 struct inode *inode = file_inode(filp); 343 int ret = -ENOLCK; 344 345 p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n", 346 filp, cmd, fl, filp); 347 348 /* No mandatory locks */ 349 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 350 goto out_err; 351 352 if (!(fl->fl_flags & FL_FLOCK)) 353 goto out_err; 354 355 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 356 filemap_write_and_wait(inode->i_mapping); 357 invalidate_mapping_pages(&inode->i_data, 0, -1); 358 } 359 /* Convert flock to posix lock */ 360 fl->fl_flags |= FL_POSIX; 361 fl->fl_flags ^= FL_FLOCK; 362 363 if (IS_SETLK(cmd) | IS_SETLKW(cmd)) 364 ret = v9fs_file_do_lock(filp, cmd, fl); 365 else 366 ret = -EINVAL; 367 out_err: 368 return ret; 369 } 370 371 /** 372 * v9fs_file_read - read from a file 373 * @filp: file pointer to read 374 * @udata: user data buffer to read data into 375 * @count: size of buffer 376 * @offset: offset at which to read data 377 * 378 */ 379 380 static ssize_t 381 v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 382 { 383 struct p9_fid *fid = iocb->ki_filp->private_data; 384 int ret, err; 385 386 p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n", 387 iov_iter_count(to), iocb->ki_pos); 388 389 ret = p9_client_read(fid, iocb->ki_pos, to, &err); 390 if (!ret) 391 return err; 392 393 iocb->ki_pos += ret; 394 return ret; 395 } 396 397 /** 398 * v9fs_file_write - write to a file 399 * @filp: file pointer to write 400 * @data: data buffer to write data from 401 * @count: size of buffer 402 * @offset: offset at which to write data 403 * 404 */ 405 static ssize_t 406 v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 407 { 408 struct file *file = iocb->ki_filp; 409 ssize_t retval; 410 loff_t origin; 411 int err = 0; 412 413 retval = generic_write_checks(iocb, from); 414 if (retval <= 0) 415 return retval; 416 417 origin = iocb->ki_pos; 418 retval = p9_client_write(file->private_data, iocb->ki_pos, from, &err); 419 if (retval > 0) { 420 struct inode *inode = file_inode(file); 421 loff_t i_size; 422 unsigned long pg_start, pg_end; 423 pg_start = origin >> PAGE_CACHE_SHIFT; 424 pg_end = (origin + retval - 1) >> PAGE_CACHE_SHIFT; 425 if (inode->i_mapping && inode->i_mapping->nrpages) 426 invalidate_inode_pages2_range(inode->i_mapping, 427 pg_start, pg_end); 428 iocb->ki_pos += retval; 429 i_size = i_size_read(inode); 430 if (iocb->ki_pos > i_size) { 431 inode_add_bytes(inode, iocb->ki_pos - i_size); 432 i_size_write(inode, iocb->ki_pos); 433 } 434 return retval; 435 } 436 return err; 437 } 438 439 static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, 440 int datasync) 441 { 442 struct p9_fid *fid; 443 struct inode *inode = filp->f_mapping->host; 444 struct p9_wstat wstat; 445 int retval; 446 447 retval = filemap_write_and_wait_range(inode->i_mapping, start, end); 448 if (retval) 449 return retval; 450 451 mutex_lock(&inode->i_mutex); 452 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 453 454 fid = filp->private_data; 455 v9fs_blank_wstat(&wstat); 456 457 retval = p9_client_wstat(fid, &wstat); 458 mutex_unlock(&inode->i_mutex); 459 460 return retval; 461 } 462 463 int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, 464 int datasync) 465 { 466 struct p9_fid *fid; 467 struct inode *inode = filp->f_mapping->host; 468 int retval; 469 470 retval = filemap_write_and_wait_range(inode->i_mapping, start, end); 471 if (retval) 472 return retval; 473 474 mutex_lock(&inode->i_mutex); 475 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 476 477 fid = filp->private_data; 478 479 retval = p9_client_fsync(fid, datasync); 480 mutex_unlock(&inode->i_mutex); 481 482 return retval; 483 } 484 485 static int 486 v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) 487 { 488 int retval; 489 490 491 retval = generic_file_mmap(filp, vma); 492 if (!retval) 493 vma->vm_ops = &v9fs_file_vm_ops; 494 495 return retval; 496 } 497 498 static int 499 v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma) 500 { 501 int retval; 502 struct inode *inode; 503 struct v9fs_inode *v9inode; 504 struct p9_fid *fid; 505 506 inode = file_inode(filp); 507 v9inode = V9FS_I(inode); 508 mutex_lock(&v9inode->v_mutex); 509 if (!v9inode->writeback_fid && 510 (vma->vm_flags & VM_WRITE)) { 511 /* 512 * clone a fid and add it to writeback_fid 513 * we do it during mmap instead of 514 * page dirty time via write_begin/page_mkwrite 515 * because we want write after unlink usecase 516 * to work. 517 */ 518 fid = v9fs_writeback_fid(filp->f_path.dentry); 519 if (IS_ERR(fid)) { 520 retval = PTR_ERR(fid); 521 mutex_unlock(&v9inode->v_mutex); 522 return retval; 523 } 524 v9inode->writeback_fid = (void *) fid; 525 } 526 mutex_unlock(&v9inode->v_mutex); 527 528 retval = generic_file_mmap(filp, vma); 529 if (!retval) 530 vma->vm_ops = &v9fs_mmap_file_vm_ops; 531 532 return retval; 533 } 534 535 static int 536 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 537 { 538 struct v9fs_inode *v9inode; 539 struct page *page = vmf->page; 540 struct file *filp = vma->vm_file; 541 struct inode *inode = file_inode(filp); 542 543 544 p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n", 545 page, (unsigned long)filp->private_data); 546 547 /* Update file times before taking page lock */ 548 file_update_time(filp); 549 550 v9inode = V9FS_I(inode); 551 /* make sure the cache has finished storing the page */ 552 v9fs_fscache_wait_on_page_write(inode, page); 553 BUG_ON(!v9inode->writeback_fid); 554 lock_page(page); 555 if (page->mapping != inode->i_mapping) 556 goto out_unlock; 557 wait_for_stable_page(page); 558 559 return VM_FAULT_LOCKED; 560 out_unlock: 561 unlock_page(page); 562 return VM_FAULT_NOPAGE; 563 } 564 565 /** 566 * v9fs_mmap_file_read - read from a file 567 * @filp: file pointer to read 568 * @data: user data buffer to read data into 569 * @count: size of buffer 570 * @offset: offset at which to read data 571 * 572 */ 573 static ssize_t 574 v9fs_mmap_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 575 { 576 /* TODO: Check if there are dirty pages */ 577 return v9fs_file_read_iter(iocb, to); 578 } 579 580 /** 581 * v9fs_mmap_file_write - write to a file 582 * @filp: file pointer to write 583 * @data: data buffer to write data from 584 * @count: size of buffer 585 * @offset: offset at which to write data 586 * 587 */ 588 static ssize_t 589 v9fs_mmap_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 590 { 591 /* 592 * TODO: invalidate mmaps on filp's inode between 593 * offset and offset+count 594 */ 595 return v9fs_file_write_iter(iocb, from); 596 } 597 598 static void v9fs_mmap_vm_close(struct vm_area_struct *vma) 599 { 600 struct inode *inode; 601 602 struct writeback_control wbc = { 603 .nr_to_write = LONG_MAX, 604 .sync_mode = WB_SYNC_ALL, 605 .range_start = vma->vm_pgoff * PAGE_SIZE, 606 /* absolute end, byte at end included */ 607 .range_end = vma->vm_pgoff * PAGE_SIZE + 608 (vma->vm_end - vma->vm_start - 1), 609 }; 610 611 612 p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); 613 614 inode = file_inode(vma->vm_file); 615 616 if (!mapping_cap_writeback_dirty(inode->i_mapping)) 617 wbc.nr_to_write = 0; 618 619 might_sleep(); 620 sync_inode(inode, &wbc); 621 } 622 623 624 static const struct vm_operations_struct v9fs_file_vm_ops = { 625 .fault = filemap_fault, 626 .map_pages = filemap_map_pages, 627 .page_mkwrite = v9fs_vm_page_mkwrite, 628 }; 629 630 static const struct vm_operations_struct v9fs_mmap_file_vm_ops = { 631 .close = v9fs_mmap_vm_close, 632 .fault = filemap_fault, 633 .map_pages = filemap_map_pages, 634 .page_mkwrite = v9fs_vm_page_mkwrite, 635 }; 636 637 638 const struct file_operations v9fs_cached_file_operations = { 639 .llseek = generic_file_llseek, 640 .read_iter = generic_file_read_iter, 641 .write_iter = generic_file_write_iter, 642 .open = v9fs_file_open, 643 .release = v9fs_dir_release, 644 .lock = v9fs_file_lock, 645 .mmap = v9fs_file_mmap, 646 .fsync = v9fs_file_fsync, 647 }; 648 649 const struct file_operations v9fs_cached_file_operations_dotl = { 650 .llseek = generic_file_llseek, 651 .read_iter = generic_file_read_iter, 652 .write_iter = generic_file_write_iter, 653 .open = v9fs_file_open, 654 .release = v9fs_dir_release, 655 .lock = v9fs_file_lock_dotl, 656 .flock = v9fs_file_flock_dotl, 657 .mmap = v9fs_file_mmap, 658 .fsync = v9fs_file_fsync_dotl, 659 }; 660 661 const struct file_operations v9fs_file_operations = { 662 .llseek = generic_file_llseek, 663 .read_iter = v9fs_file_read_iter, 664 .write_iter = v9fs_file_write_iter, 665 .open = v9fs_file_open, 666 .release = v9fs_dir_release, 667 .lock = v9fs_file_lock, 668 .mmap = generic_file_readonly_mmap, 669 .fsync = v9fs_file_fsync, 670 }; 671 672 const struct file_operations v9fs_file_operations_dotl = { 673 .llseek = generic_file_llseek, 674 .read_iter = v9fs_file_read_iter, 675 .write_iter = v9fs_file_write_iter, 676 .open = v9fs_file_open, 677 .release = v9fs_dir_release, 678 .lock = v9fs_file_lock_dotl, 679 .flock = v9fs_file_flock_dotl, 680 .mmap = generic_file_readonly_mmap, 681 .fsync = v9fs_file_fsync_dotl, 682 }; 683 684 const struct file_operations v9fs_mmap_file_operations = { 685 .llseek = generic_file_llseek, 686 .read_iter = v9fs_mmap_file_read_iter, 687 .write_iter = v9fs_mmap_file_write_iter, 688 .open = v9fs_file_open, 689 .release = v9fs_dir_release, 690 .lock = v9fs_file_lock, 691 .mmap = v9fs_mmap_file_mmap, 692 .fsync = v9fs_file_fsync, 693 }; 694 695 const struct file_operations v9fs_mmap_file_operations_dotl = { 696 .llseek = generic_file_llseek, 697 .read_iter = v9fs_mmap_file_read_iter, 698 .write_iter = v9fs_mmap_file_write_iter, 699 .open = v9fs_file_open, 700 .release = v9fs_dir_release, 701 .lock = v9fs_file_lock_dotl, 702 .flock = v9fs_file_flock_dotl, 703 .mmap = v9fs_mmap_file_mmap, 704 .fsync = v9fs_file_fsync_dotl, 705 }; 706