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 49 /** 50 * v9fs_file_open - open a file (or directory) 51 * @inode: inode to be opened 52 * @file: file being opened 53 * 54 */ 55 56 int v9fs_file_open(struct inode *inode, struct file *file) 57 { 58 int err; 59 struct v9fs_inode *v9inode; 60 struct v9fs_session_info *v9ses; 61 struct p9_fid *fid; 62 int omode; 63 64 P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file); 65 v9inode = V9FS_I(inode); 66 v9ses = v9fs_inode2v9ses(inode); 67 if (v9fs_proto_dotl(v9ses)) 68 omode = file->f_flags; 69 else 70 omode = v9fs_uflags2omode(file->f_flags, 71 v9fs_proto_dotu(v9ses)); 72 fid = file->private_data; 73 if (!fid) { 74 fid = v9fs_fid_clone(file->f_path.dentry); 75 if (IS_ERR(fid)) 76 return PTR_ERR(fid); 77 78 err = p9_client_open(fid, omode); 79 if (err < 0) { 80 p9_client_clunk(fid); 81 return err; 82 } 83 if (file->f_flags & O_TRUNC) { 84 i_size_write(inode, 0); 85 inode->i_blocks = 0; 86 } 87 if ((file->f_flags & O_APPEND) && 88 (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))) 89 generic_file_llseek(file, 0, SEEK_END); 90 } 91 92 file->private_data = fid; 93 mutex_lock(&v9inode->v_mutex); 94 if (v9ses->cache && !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 #ifdef CONFIG_9P_FSCACHE 113 if (v9ses->cache) 114 v9fs_cache_inode_set_cookie(inode, file); 115 #endif 116 return 0; 117 out_error: 118 p9_client_clunk(file->private_data); 119 file->private_data = NULL; 120 return err; 121 } 122 123 /** 124 * v9fs_file_lock - lock a file (or directory) 125 * @filp: file to be locked 126 * @cmd: lock command 127 * @fl: file lock structure 128 * 129 * Bugs: this looks like a local only lock, we should extend into 9P 130 * by using open exclusive 131 */ 132 133 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) 134 { 135 int res = 0; 136 struct inode *inode = filp->f_path.dentry->d_inode; 137 138 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); 139 140 /* No mandatory locks */ 141 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 142 return -ENOLCK; 143 144 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 145 filemap_write_and_wait(inode->i_mapping); 146 invalidate_mapping_pages(&inode->i_data, 0, -1); 147 } 148 149 return res; 150 } 151 152 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) 153 { 154 struct p9_flock flock; 155 struct p9_fid *fid; 156 uint8_t status; 157 int res = 0; 158 unsigned char fl_type; 159 160 fid = filp->private_data; 161 BUG_ON(fid == NULL); 162 163 if ((fl->fl_flags & FL_POSIX) != FL_POSIX) 164 BUG(); 165 166 res = posix_lock_file_wait(filp, fl); 167 if (res < 0) 168 goto out; 169 170 /* convert posix lock to p9 tlock args */ 171 memset(&flock, 0, sizeof(flock)); 172 flock.type = fl->fl_type; 173 flock.start = fl->fl_start; 174 if (fl->fl_end == OFFSET_MAX) 175 flock.length = 0; 176 else 177 flock.length = fl->fl_end - fl->fl_start + 1; 178 flock.proc_id = fl->fl_pid; 179 flock.client_id = utsname()->nodename; 180 if (IS_SETLKW(cmd)) 181 flock.flags = P9_LOCK_FLAGS_BLOCK; 182 183 /* 184 * if its a blocked request and we get P9_LOCK_BLOCKED as the status 185 * for lock request, keep on trying 186 */ 187 for (;;) { 188 res = p9_client_lock_dotl(fid, &flock, &status); 189 if (res < 0) 190 break; 191 192 if (status != P9_LOCK_BLOCKED) 193 break; 194 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd)) 195 break; 196 schedule_timeout_interruptible(P9_LOCK_TIMEOUT); 197 } 198 199 /* map 9p status to VFS status */ 200 switch (status) { 201 case P9_LOCK_SUCCESS: 202 res = 0; 203 break; 204 case P9_LOCK_BLOCKED: 205 res = -EAGAIN; 206 break; 207 case P9_LOCK_ERROR: 208 case P9_LOCK_GRACE: 209 res = -ENOLCK; 210 break; 211 default: 212 BUG(); 213 } 214 215 /* 216 * incase server returned error for lock request, revert 217 * it locally 218 */ 219 if (res < 0 && fl->fl_type != F_UNLCK) { 220 fl_type = fl->fl_type; 221 fl->fl_type = F_UNLCK; 222 res = posix_lock_file_wait(filp, fl); 223 fl->fl_type = fl_type; 224 } 225 out: 226 return res; 227 } 228 229 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) 230 { 231 struct p9_getlock glock; 232 struct p9_fid *fid; 233 int res = 0; 234 235 fid = filp->private_data; 236 BUG_ON(fid == NULL); 237 238 posix_test_lock(filp, fl); 239 /* 240 * if we have a conflicting lock locally, no need to validate 241 * with server 242 */ 243 if (fl->fl_type != F_UNLCK) 244 return res; 245 246 /* convert posix lock to p9 tgetlock args */ 247 memset(&glock, 0, sizeof(glock)); 248 glock.type = fl->fl_type; 249 glock.start = fl->fl_start; 250 if (fl->fl_end == OFFSET_MAX) 251 glock.length = 0; 252 else 253 glock.length = fl->fl_end - fl->fl_start + 1; 254 glock.proc_id = fl->fl_pid; 255 glock.client_id = utsname()->nodename; 256 257 res = p9_client_getlock_dotl(fid, &glock); 258 if (res < 0) 259 return res; 260 if (glock.type != F_UNLCK) { 261 fl->fl_type = glock.type; 262 fl->fl_start = glock.start; 263 if (glock.length == 0) 264 fl->fl_end = OFFSET_MAX; 265 else 266 fl->fl_end = glock.start + glock.length - 1; 267 fl->fl_pid = glock.proc_id; 268 } else 269 fl->fl_type = F_UNLCK; 270 271 return res; 272 } 273 274 /** 275 * v9fs_file_lock_dotl - lock a file (or directory) 276 * @filp: file to be locked 277 * @cmd: lock command 278 * @fl: file lock structure 279 * 280 */ 281 282 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) 283 { 284 struct inode *inode = filp->f_path.dentry->d_inode; 285 int ret = -ENOLCK; 286 287 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp, 288 cmd, fl, filp->f_path.dentry->d_name.name); 289 290 /* No mandatory locks */ 291 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 292 goto out_err; 293 294 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 295 filemap_write_and_wait(inode->i_mapping); 296 invalidate_mapping_pages(&inode->i_data, 0, -1); 297 } 298 299 if (IS_SETLK(cmd) || IS_SETLKW(cmd)) 300 ret = v9fs_file_do_lock(filp, cmd, fl); 301 else if (IS_GETLK(cmd)) 302 ret = v9fs_file_getlock(filp, fl); 303 else 304 ret = -EINVAL; 305 out_err: 306 return ret; 307 } 308 309 /** 310 * v9fs_file_flock_dotl - lock a file 311 * @filp: file to be locked 312 * @cmd: lock command 313 * @fl: file lock structure 314 * 315 */ 316 317 static int v9fs_file_flock_dotl(struct file *filp, int cmd, 318 struct file_lock *fl) 319 { 320 struct inode *inode = filp->f_path.dentry->d_inode; 321 int ret = -ENOLCK; 322 323 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp, 324 cmd, fl, filp->f_path.dentry->d_name.name); 325 326 /* No mandatory locks */ 327 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 328 goto out_err; 329 330 if (!(fl->fl_flags & FL_FLOCK)) 331 goto out_err; 332 333 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 334 filemap_write_and_wait(inode->i_mapping); 335 invalidate_mapping_pages(&inode->i_data, 0, -1); 336 } 337 /* Convert flock to posix lock */ 338 fl->fl_owner = (fl_owner_t)filp; 339 fl->fl_start = 0; 340 fl->fl_end = OFFSET_MAX; 341 fl->fl_flags |= FL_POSIX; 342 fl->fl_flags ^= FL_FLOCK; 343 344 if (IS_SETLK(cmd) | IS_SETLKW(cmd)) 345 ret = v9fs_file_do_lock(filp, cmd, fl); 346 else 347 ret = -EINVAL; 348 out_err: 349 return ret; 350 } 351 352 /** 353 * v9fs_fid_readn - read from a fid 354 * @fid: fid to read 355 * @data: data buffer to read data into 356 * @udata: user data buffer to read data into 357 * @count: size of buffer 358 * @offset: offset at which to read data 359 * 360 */ 361 ssize_t 362 v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count, 363 u64 offset) 364 { 365 int n, total, size; 366 367 P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid, 368 (long long unsigned) offset, count); 369 n = 0; 370 total = 0; 371 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 372 do { 373 n = p9_client_read(fid, data, udata, offset, count); 374 if (n <= 0) 375 break; 376 377 if (data) 378 data += n; 379 if (udata) 380 udata += n; 381 382 offset += n; 383 count -= n; 384 total += n; 385 } while (count > 0 && n == size); 386 387 if (n < 0) 388 total = n; 389 390 return total; 391 } 392 393 /** 394 * v9fs_file_readn - read from a file 395 * @filp: file pointer to read 396 * @data: data buffer to read data into 397 * @udata: user data buffer to read data into 398 * @count: size of buffer 399 * @offset: offset at which to read data 400 * 401 */ 402 ssize_t 403 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count, 404 u64 offset) 405 { 406 return v9fs_fid_readn(filp->private_data, data, udata, count, offset); 407 } 408 409 /** 410 * v9fs_file_read - read from a file 411 * @filp: file pointer to read 412 * @udata: user data buffer to read data into 413 * @count: size of buffer 414 * @offset: offset at which to read data 415 * 416 */ 417 418 static ssize_t 419 v9fs_file_read(struct file *filp, char __user *udata, size_t count, 420 loff_t * offset) 421 { 422 int ret; 423 struct p9_fid *fid; 424 size_t size; 425 426 P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset); 427 fid = filp->private_data; 428 429 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 430 if (count > size) 431 ret = v9fs_file_readn(filp, NULL, udata, count, *offset); 432 else 433 ret = p9_client_read(fid, NULL, udata, *offset, count); 434 435 if (ret > 0) 436 *offset += ret; 437 438 return ret; 439 } 440 441 ssize_t 442 v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid, 443 const char __user *data, size_t count, 444 loff_t *offset, int invalidate) 445 { 446 int n; 447 loff_t i_size; 448 size_t total = 0; 449 struct p9_client *clnt; 450 loff_t origin = *offset; 451 unsigned long pg_start, pg_end; 452 453 P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data, 454 (int)count, (int)*offset); 455 456 clnt = fid->clnt; 457 do { 458 n = p9_client_write(fid, NULL, data+total, origin+total, count); 459 if (n <= 0) 460 break; 461 count -= n; 462 total += n; 463 } while (count > 0); 464 465 if (invalidate && (total > 0)) { 466 pg_start = origin >> PAGE_CACHE_SHIFT; 467 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT; 468 if (inode->i_mapping && inode->i_mapping->nrpages) 469 invalidate_inode_pages2_range(inode->i_mapping, 470 pg_start, pg_end); 471 *offset += total; 472 i_size = i_size_read(inode); 473 if (*offset > i_size) { 474 inode_add_bytes(inode, *offset - i_size); 475 i_size_write(inode, *offset); 476 } 477 } 478 if (n < 0) 479 return n; 480 481 return total; 482 } 483 484 /** 485 * v9fs_file_write - write to a file 486 * @filp: file pointer to write 487 * @data: data buffer to write data from 488 * @count: size of buffer 489 * @offset: offset at which to write data 490 * 491 */ 492 static ssize_t 493 v9fs_file_write(struct file *filp, const char __user * data, 494 size_t count, loff_t *offset) 495 { 496 ssize_t retval = 0; 497 loff_t origin = *offset; 498 499 500 retval = generic_write_checks(filp, &origin, &count, 0); 501 if (retval) 502 goto out; 503 504 retval = -EINVAL; 505 if ((ssize_t) count < 0) 506 goto out; 507 retval = 0; 508 if (!count) 509 goto out; 510 511 retval = v9fs_file_write_internal(filp->f_path.dentry->d_inode, 512 filp->private_data, 513 data, count, &origin, 1); 514 /* update offset on successful write */ 515 if (retval > 0) 516 *offset = origin; 517 out: 518 return retval; 519 } 520 521 522 static int v9fs_file_fsync(struct file *filp, int datasync) 523 { 524 struct p9_fid *fid; 525 struct p9_wstat wstat; 526 int retval; 527 528 P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 529 530 fid = filp->private_data; 531 v9fs_blank_wstat(&wstat); 532 533 retval = p9_client_wstat(fid, &wstat); 534 return retval; 535 } 536 537 int v9fs_file_fsync_dotl(struct file *filp, int datasync) 538 { 539 struct p9_fid *fid; 540 int retval; 541 542 P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n", 543 filp, datasync); 544 545 fid = filp->private_data; 546 547 retval = p9_client_fsync(fid, datasync); 548 return retval; 549 } 550 551 static int 552 v9fs_file_mmap(struct file *file, struct vm_area_struct *vma) 553 { 554 int retval; 555 556 retval = generic_file_mmap(file, vma); 557 if (!retval) 558 vma->vm_ops = &v9fs_file_vm_ops; 559 560 return retval; 561 } 562 563 static int 564 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 565 { 566 struct v9fs_inode *v9inode; 567 struct page *page = vmf->page; 568 struct file *filp = vma->vm_file; 569 struct inode *inode = filp->f_path.dentry->d_inode; 570 571 572 P9_DPRINTK(P9_DEBUG_VFS, "page %p fid %lx\n", 573 page, (unsigned long)filp->private_data); 574 575 v9inode = V9FS_I(inode); 576 /* make sure the cache has finished storing the page */ 577 v9fs_fscache_wait_on_page_write(inode, page); 578 BUG_ON(!v9inode->writeback_fid); 579 lock_page(page); 580 if (page->mapping != inode->i_mapping) 581 goto out_unlock; 582 583 return VM_FAULT_LOCKED; 584 out_unlock: 585 unlock_page(page); 586 return VM_FAULT_NOPAGE; 587 } 588 589 static ssize_t 590 v9fs_direct_read(struct file *filp, char __user *udata, size_t count, 591 loff_t *offsetp) 592 { 593 loff_t size, offset; 594 struct inode *inode; 595 struct address_space *mapping; 596 597 offset = *offsetp; 598 mapping = filp->f_mapping; 599 inode = mapping->host; 600 if (!count) 601 return 0; 602 size = i_size_read(inode); 603 if (offset < size) 604 filemap_write_and_wait_range(mapping, offset, 605 offset + count - 1); 606 607 return v9fs_file_read(filp, udata, count, offsetp); 608 } 609 610 /** 611 * v9fs_cached_file_read - read from a file 612 * @filp: file pointer to read 613 * @udata: user data buffer to read data into 614 * @count: size of buffer 615 * @offset: offset at which to read data 616 * 617 */ 618 static ssize_t 619 v9fs_cached_file_read(struct file *filp, char __user *data, size_t count, 620 loff_t *offset) 621 { 622 if (filp->f_flags & O_DIRECT) 623 return v9fs_direct_read(filp, data, count, offset); 624 return do_sync_read(filp, data, count, offset); 625 } 626 627 static ssize_t 628 v9fs_direct_write(struct file *filp, const char __user * data, 629 size_t count, loff_t *offsetp) 630 { 631 loff_t offset; 632 ssize_t retval; 633 struct inode *inode; 634 struct address_space *mapping; 635 636 offset = *offsetp; 637 mapping = filp->f_mapping; 638 inode = mapping->host; 639 if (!count) 640 return 0; 641 642 mutex_lock(&inode->i_mutex); 643 retval = filemap_write_and_wait_range(mapping, offset, 644 offset + count - 1); 645 if (retval) 646 goto err_out; 647 /* 648 * After a write we want buffered reads to be sure to go to disk to get 649 * the new data. We invalidate clean cached page from the region we're 650 * about to write. We do this *before* the write so that if we fail 651 * here we fall back to buffered write 652 */ 653 if (mapping->nrpages) { 654 pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT; 655 pgoff_t pg_end = (offset + count - 1) >> PAGE_CACHE_SHIFT; 656 657 retval = invalidate_inode_pages2_range(mapping, 658 pg_start, pg_end); 659 /* 660 * If a page can not be invalidated, fall back 661 * to buffered write. 662 */ 663 if (retval) { 664 if (retval == -EBUSY) 665 goto buff_write; 666 goto err_out; 667 } 668 } 669 retval = v9fs_file_write(filp, data, count, offsetp); 670 err_out: 671 mutex_unlock(&inode->i_mutex); 672 return retval; 673 674 buff_write: 675 mutex_unlock(&inode->i_mutex); 676 return do_sync_write(filp, data, count, offsetp); 677 } 678 679 /** 680 * v9fs_cached_file_write - write to a file 681 * @filp: file pointer to write 682 * @data: data buffer to write data from 683 * @count: size of buffer 684 * @offset: offset at which to write data 685 * 686 */ 687 static ssize_t 688 v9fs_cached_file_write(struct file *filp, const char __user * data, 689 size_t count, loff_t *offset) 690 { 691 692 if (filp->f_flags & O_DIRECT) 693 return v9fs_direct_write(filp, data, count, offset); 694 return do_sync_write(filp, data, count, offset); 695 } 696 697 static const struct vm_operations_struct v9fs_file_vm_ops = { 698 .fault = filemap_fault, 699 .page_mkwrite = v9fs_vm_page_mkwrite, 700 }; 701 702 703 const struct file_operations v9fs_cached_file_operations = { 704 .llseek = generic_file_llseek, 705 .read = v9fs_cached_file_read, 706 .write = v9fs_cached_file_write, 707 .aio_read = generic_file_aio_read, 708 .aio_write = generic_file_aio_write, 709 .open = v9fs_file_open, 710 .release = v9fs_dir_release, 711 .lock = v9fs_file_lock, 712 .mmap = v9fs_file_mmap, 713 .fsync = v9fs_file_fsync, 714 }; 715 716 const struct file_operations v9fs_cached_file_operations_dotl = { 717 .llseek = generic_file_llseek, 718 .read = v9fs_cached_file_read, 719 .write = v9fs_cached_file_write, 720 .aio_read = generic_file_aio_read, 721 .aio_write = generic_file_aio_write, 722 .open = v9fs_file_open, 723 .release = v9fs_dir_release, 724 .lock = v9fs_file_lock_dotl, 725 .flock = v9fs_file_flock_dotl, 726 .mmap = v9fs_file_mmap, 727 .fsync = v9fs_file_fsync_dotl, 728 }; 729 730 const struct file_operations v9fs_file_operations = { 731 .llseek = generic_file_llseek, 732 .read = v9fs_file_read, 733 .write = v9fs_file_write, 734 .open = v9fs_file_open, 735 .release = v9fs_dir_release, 736 .lock = v9fs_file_lock, 737 .mmap = generic_file_readonly_mmap, 738 .fsync = v9fs_file_fsync, 739 }; 740 741 const struct file_operations v9fs_file_operations_dotl = { 742 .llseek = generic_file_llseek, 743 .read = v9fs_file_read, 744 .write = v9fs_file_write, 745 .open = v9fs_file_open, 746 .release = v9fs_dir_release, 747 .lock = v9fs_file_lock_dotl, 748 .flock = v9fs_file_flock_dotl, 749 .mmap = generic_file_readonly_mmap, 750 .fsync = v9fs_file_fsync_dotl, 751 }; 752