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 - read from a file 363 * @filp: file pointer to read 364 * @udata: user data buffer to read data into 365 * @count: size of buffer 366 * @offset: offset at which to read data 367 * 368 */ 369 370 static ssize_t 371 v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 372 { 373 struct p9_fid *fid = iocb->ki_filp->private_data; 374 int ret, err = 0; 375 376 p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n", 377 iov_iter_count(to), iocb->ki_pos); 378 379 if (iocb->ki_filp->f_flags & O_NONBLOCK) 380 ret = p9_client_read_once(fid, iocb->ki_pos, to, &err); 381 else 382 ret = p9_client_read(fid, iocb->ki_pos, to, &err); 383 if (!ret) 384 return err; 385 386 iocb->ki_pos += ret; 387 return ret; 388 } 389 390 /** 391 * v9fs_file_write - write to a file 392 * @filp: file pointer to write 393 * @data: data buffer to write data from 394 * @count: size of buffer 395 * @offset: offset at which to write data 396 * 397 */ 398 static ssize_t 399 v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 400 { 401 struct file *file = iocb->ki_filp; 402 ssize_t retval; 403 loff_t origin; 404 int err = 0; 405 406 retval = generic_write_checks(iocb, from); 407 if (retval <= 0) 408 return retval; 409 410 origin = iocb->ki_pos; 411 retval = p9_client_write(file->private_data, iocb->ki_pos, from, &err); 412 if (retval > 0) { 413 struct inode *inode = file_inode(file); 414 loff_t i_size; 415 unsigned long pg_start, pg_end; 416 pg_start = origin >> PAGE_SHIFT; 417 pg_end = (origin + retval - 1) >> PAGE_SHIFT; 418 if (inode->i_mapping && inode->i_mapping->nrpages) 419 invalidate_inode_pages2_range(inode->i_mapping, 420 pg_start, pg_end); 421 iocb->ki_pos += retval; 422 i_size = i_size_read(inode); 423 if (iocb->ki_pos > i_size) { 424 inode_add_bytes(inode, iocb->ki_pos - i_size); 425 /* 426 * Need to serialize against i_size_write() in 427 * v9fs_stat2inode() 428 */ 429 v9fs_i_size_write(inode, iocb->ki_pos); 430 } 431 return retval; 432 } 433 return err; 434 } 435 436 static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, 437 int datasync) 438 { 439 struct p9_fid *fid; 440 struct inode *inode = filp->f_mapping->host; 441 struct p9_wstat wstat; 442 int retval; 443 444 retval = file_write_and_wait_range(filp, start, end); 445 if (retval) 446 return retval; 447 448 inode_lock(inode); 449 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 450 451 fid = filp->private_data; 452 v9fs_blank_wstat(&wstat); 453 454 retval = p9_client_wstat(fid, &wstat); 455 inode_unlock(inode); 456 457 return retval; 458 } 459 460 int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, 461 int datasync) 462 { 463 struct p9_fid *fid; 464 struct inode *inode = filp->f_mapping->host; 465 int retval; 466 467 retval = file_write_and_wait_range(filp, start, end); 468 if (retval) 469 return retval; 470 471 inode_lock(inode); 472 p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 473 474 fid = filp->private_data; 475 476 retval = p9_client_fsync(fid, datasync); 477 inode_unlock(inode); 478 479 return retval; 480 } 481 482 static int 483 v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma) 484 { 485 int retval; 486 487 488 retval = generic_file_mmap(filp, vma); 489 if (!retval) 490 vma->vm_ops = &v9fs_file_vm_ops; 491 492 return retval; 493 } 494 495 static int 496 v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma) 497 { 498 int retval; 499 struct inode *inode; 500 struct v9fs_inode *v9inode; 501 struct p9_fid *fid; 502 503 inode = file_inode(filp); 504 v9inode = V9FS_I(inode); 505 mutex_lock(&v9inode->v_mutex); 506 if (!v9inode->writeback_fid && 507 (vma->vm_flags & VM_SHARED) && 508 (vma->vm_flags & VM_WRITE)) { 509 /* 510 * clone a fid and add it to writeback_fid 511 * we do it during mmap instead of 512 * page dirty time via write_begin/page_mkwrite 513 * because we want write after unlink usecase 514 * to work. 515 */ 516 fid = v9fs_writeback_fid(file_dentry(filp)); 517 if (IS_ERR(fid)) { 518 retval = PTR_ERR(fid); 519 mutex_unlock(&v9inode->v_mutex); 520 return retval; 521 } 522 v9inode->writeback_fid = (void *) fid; 523 } 524 mutex_unlock(&v9inode->v_mutex); 525 526 retval = generic_file_mmap(filp, vma); 527 if (!retval) 528 vma->vm_ops = &v9fs_mmap_file_vm_ops; 529 530 return retval; 531 } 532 533 static vm_fault_t 534 v9fs_vm_page_mkwrite(struct vm_fault *vmf) 535 { 536 struct v9fs_inode *v9inode; 537 struct page *page = vmf->page; 538 struct file *filp = vmf->vma->vm_file; 539 struct inode *inode = file_inode(filp); 540 541 542 p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n", 543 page, (unsigned long)filp->private_data); 544 545 /* Update file times before taking page lock */ 546 file_update_time(filp); 547 548 v9inode = V9FS_I(inode); 549 /* make sure the cache has finished storing the page */ 550 v9fs_fscache_wait_on_page_write(inode, page); 551 BUG_ON(!v9inode->writeback_fid); 552 lock_page(page); 553 if (page->mapping != inode->i_mapping) 554 goto out_unlock; 555 wait_for_stable_page(page); 556 557 return VM_FAULT_LOCKED; 558 out_unlock: 559 unlock_page(page); 560 return VM_FAULT_NOPAGE; 561 } 562 563 /** 564 * v9fs_mmap_file_read - read from a file 565 * @filp: file pointer to read 566 * @data: user data buffer to read data into 567 * @count: size of buffer 568 * @offset: offset at which to read data 569 * 570 */ 571 static ssize_t 572 v9fs_mmap_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 573 { 574 /* TODO: Check if there are dirty pages */ 575 return v9fs_file_read_iter(iocb, to); 576 } 577 578 /** 579 * v9fs_mmap_file_write - write to a file 580 * @filp: file pointer to write 581 * @data: data buffer to write data from 582 * @count: size of buffer 583 * @offset: offset at which to write data 584 * 585 */ 586 static ssize_t 587 v9fs_mmap_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 588 { 589 /* 590 * TODO: invalidate mmaps on filp's inode between 591 * offset and offset+count 592 */ 593 return v9fs_file_write_iter(iocb, from); 594 } 595 596 static void v9fs_mmap_vm_close(struct vm_area_struct *vma) 597 { 598 struct inode *inode; 599 600 struct writeback_control wbc = { 601 .nr_to_write = LONG_MAX, 602 .sync_mode = WB_SYNC_ALL, 603 .range_start = (loff_t)vma->vm_pgoff * PAGE_SIZE, 604 /* absolute end, byte at end included */ 605 .range_end = (loff_t)vma->vm_pgoff * PAGE_SIZE + 606 (vma->vm_end - vma->vm_start - 1), 607 }; 608 609 if (!(vma->vm_flags & VM_SHARED)) 610 return; 611 612 p9_debug(P9_DEBUG_VFS, "9p VMA close, %p, flushing", vma); 613 614 inode = file_inode(vma->vm_file); 615 filemap_fdatawrite_wbc(inode->i_mapping, &wbc); 616 } 617 618 619 static const struct vm_operations_struct v9fs_file_vm_ops = { 620 .fault = filemap_fault, 621 .map_pages = filemap_map_pages, 622 .page_mkwrite = v9fs_vm_page_mkwrite, 623 }; 624 625 static const struct vm_operations_struct v9fs_mmap_file_vm_ops = { 626 .close = v9fs_mmap_vm_close, 627 .fault = filemap_fault, 628 .map_pages = filemap_map_pages, 629 .page_mkwrite = v9fs_vm_page_mkwrite, 630 }; 631 632 633 const struct file_operations v9fs_cached_file_operations = { 634 .llseek = generic_file_llseek, 635 .read_iter = generic_file_read_iter, 636 .write_iter = generic_file_write_iter, 637 .open = v9fs_file_open, 638 .release = v9fs_dir_release, 639 .lock = v9fs_file_lock, 640 .mmap = v9fs_file_mmap, 641 .splice_read = generic_file_splice_read, 642 .splice_write = iter_file_splice_write, 643 .fsync = v9fs_file_fsync, 644 }; 645 646 const struct file_operations v9fs_cached_file_operations_dotl = { 647 .llseek = generic_file_llseek, 648 .read_iter = generic_file_read_iter, 649 .write_iter = generic_file_write_iter, 650 .open = v9fs_file_open, 651 .release = v9fs_dir_release, 652 .lock = v9fs_file_lock_dotl, 653 .flock = v9fs_file_flock_dotl, 654 .mmap = v9fs_file_mmap, 655 .splice_read = generic_file_splice_read, 656 .splice_write = iter_file_splice_write, 657 .fsync = v9fs_file_fsync_dotl, 658 }; 659 660 const struct file_operations v9fs_file_operations = { 661 .llseek = generic_file_llseek, 662 .read_iter = v9fs_file_read_iter, 663 .write_iter = v9fs_file_write_iter, 664 .open = v9fs_file_open, 665 .release = v9fs_dir_release, 666 .lock = v9fs_file_lock, 667 .mmap = generic_file_readonly_mmap, 668 .splice_read = generic_file_splice_read, 669 .splice_write = iter_file_splice_write, 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 .splice_read = generic_file_splice_read, 683 .splice_write = iter_file_splice_write, 684 .fsync = v9fs_file_fsync_dotl, 685 }; 686 687 const struct file_operations v9fs_mmap_file_operations = { 688 .llseek = generic_file_llseek, 689 .read_iter = v9fs_mmap_file_read_iter, 690 .write_iter = v9fs_mmap_file_write_iter, 691 .open = v9fs_file_open, 692 .release = v9fs_dir_release, 693 .lock = v9fs_file_lock, 694 .mmap = v9fs_mmap_file_mmap, 695 .splice_read = generic_file_splice_read, 696 .splice_write = iter_file_splice_write, 697 .fsync = v9fs_file_fsync, 698 }; 699 700 const struct file_operations v9fs_mmap_file_operations_dotl = { 701 .llseek = generic_file_llseek, 702 .read_iter = v9fs_mmap_file_read_iter, 703 .write_iter = v9fs_mmap_file_write_iter, 704 .open = v9fs_file_open, 705 .release = v9fs_dir_release, 706 .lock = v9fs_file_lock_dotl, 707 .flock = v9fs_file_flock_dotl, 708 .mmap = v9fs_mmap_file_mmap, 709 .splice_read = generic_file_splice_read, 710 .splice_write = iter_file_splice_write, 711 .fsync = v9fs_file_fsync_dotl, 712 }; 713