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