chfs_vnops.c revision 1.41
1 /* $NetBSD: chfs_vnops.c,v 1.41 2020/05/23 23:42:44 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Department of Software Engineering, 5 * University of Szeged, Hungary 6 * Copyright (C) 2010 Tamas Toth <ttoth (at) inf.u-szeged.hu> 7 * Copyright (C) 2010 Adam Hoka <ahoka (at) NetBSD.org> 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by the Department of Software Engineering, University of Szeged, Hungary 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <sys/param.h> 36 #include <miscfs/specfs/specdev.h> 37 #include <miscfs/fifofs/fifo.h> 38 #include <miscfs/genfs/genfs.h> 39 #include <ufs/ufs/dir.h> 40 #include <ufs/ufs/ufs_extern.h> 41 #include <uvm/uvm.h> 42 #include <sys/namei.h> 43 #include <sys/stat.h> 44 #include <sys/fcntl.h> 45 #include <sys/buf.h> 46 #include <sys/vnode.h> 47 48 #include "chfs.h" 49 50 #define READ_S "chfs_read" 51 52 int 53 chfs_lookup(void *v) 54 { 55 struct vnode *dvp = ((struct vop_lookup_v2_args *) v)->a_dvp; 56 struct vnode **vpp = ((struct vop_lookup_v2_args *) v)->a_vpp; 57 struct componentname *cnp = ((struct vop_lookup_v2_args *) v)->a_cnp; 58 59 int error; 60 struct chfs_inode* ip; 61 struct ufsmount* ump; 62 struct chfs_mount* chmp; 63 struct chfs_vnode_cache* chvc __diagused; 64 struct chfs_dirent* fd; 65 66 dbg("lookup(): %s\n", cnp->cn_nameptr); 67 68 KASSERT(VOP_ISLOCKED(dvp)); 69 70 *vpp = NULL; 71 72 /* Check accessibility of requested node as a first step. */ 73 error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred); 74 if (error != 0) { 75 goto out; 76 } 77 78 /* If requesting the last path component on a read-only file system 79 * with a write operation, deny it. */ 80 if ((cnp->cn_flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) 81 && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 82 error = EROFS; 83 goto out; 84 } 85 86 /* Avoid doing a linear scan of the directory if the requested 87 * directory/name couple is already in the cache. */ 88 if (cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen, 89 cnp->cn_nameiop, cnp->cn_flags, NULL, vpp)) { 90 return (*vpp == NULLVP ? ENOENT : 0); 91 } 92 93 /* May need to restart the lookup with an exclusive lock. */ 94 if (VOP_ISLOCKED(dvp) != LK_EXCLUSIVE) 95 return ENOLCK; 96 97 ip = VTOI(dvp); 98 ump = VFSTOUFS(dvp->v_mount); 99 chmp = ump->um_chfs; 100 if (ip->ino == 0) { 101 ip->ino = ++chmp->chm_max_vno; 102 } 103 mutex_enter(&chmp->chm_lock_vnocache); 104 chvc = chfs_vnode_cache_get(chmp, ip->ino); 105 mutex_exit(&chmp->chm_lock_vnocache); 106 107 /* We cannot be requesting the parent directory of the root node. */ 108 KASSERT(IMPLIES(ip->ch_type == CHT_DIR && chvc->pvno == chvc->vno, 109 !(cnp->cn_flags & ISDOTDOT))); 110 111 if (cnp->cn_flags & ISDOTDOT) { 112 VOP_UNLOCK(dvp); 113 error = VFS_VGET(dvp->v_mount, ip->chvc->pvno, LK_EXCLUSIVE, 114 vpp); 115 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 116 } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 117 vref(dvp); 118 *vpp = dvp; 119 error = 0; 120 } else { 121 fd = chfs_dir_lookup(ip, cnp); 122 123 if (fd == NULL) { 124 dbg("fd null\n"); 125 /* The entry was not found in the directory. 126 * This is OK if we are creating or renaming an 127 * entry and are working on the last component of 128 * the path name. */ 129 if ((cnp->cn_flags & ISLASTCN) && (cnp->cn_nameiop == CREATE 130 || cnp->cn_nameiop == RENAME)) { 131 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); 132 if (error) { 133 dbg("after the entry was not found in dir\n"); 134 goto out; 135 } 136 137 dbg("return EJUSTRETURN\n"); 138 error = EJUSTRETURN; 139 } else { 140 error = ENOENT; 141 } 142 } else { 143 /* If we are not at the last path component and 144 * found a non-directory or non-link entry (which 145 * may itself be pointing to a directory), raise 146 * an error. */ 147 if ((fd->type != CHT_DIR && fd->type != CHT_LNK) && !(cnp->cn_flags 148 & ISLASTCN)) { 149 error = ENOTDIR; 150 goto out; 151 } 152 153 dbg("vno@allocating new vnode: %llu\n", 154 (unsigned long long)fd->vno); 155 error = VFS_VGET(dvp->v_mount, fd->vno, LK_EXCLUSIVE, 156 vpp); 157 } 158 } 159 /* Store the result of this lookup in the cache. Avoid this if the 160 * request was for creation, as it does not improve timings on 161 * emprical tests. */ 162 if (cnp->cn_nameiop != CREATE && (cnp->cn_flags & ISDOTDOT) == 0) { 163 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, 164 cnp->cn_flags); 165 } 166 167 out: 168 /* If there were no errors, *vpp cannot be NULL. */ 169 KASSERT(IFF(error == 0, *vpp != NULL)); 170 KASSERT(VOP_ISLOCKED(dvp)); 171 172 if (error) 173 return error; 174 if (*vpp != dvp) 175 VOP_UNLOCK(*vpp); 176 return 0; 177 } 178 179 /* --------------------------------------------------------------------- */ 180 181 int 182 chfs_create(void *v) 183 { 184 struct vop_create_v3_args /* { 185 struct vnode *a_dvp; 186 struct vnode **a_vpp; 187 struct componentname *a_cnp; 188 struct vattr *a_vap; 189 } */*ap = v; 190 int error, mode; 191 dbg("create()\n"); 192 193 mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode); 194 195 if ((mode & IFMT) == 0) { 196 if (ap->a_vap->va_type == VREG) 197 mode |= IFREG; 198 if (ap->a_vap->va_type == VSOCK) 199 mode |= IFSOCK; 200 } 201 202 error = chfs_makeinode(mode, ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap->va_type); 203 204 if (error) { 205 dbg("error: %d\n", error); 206 return error; 207 } 208 209 VN_KNOTE(ap->a_dvp, NOTE_WRITE); 210 return 0; 211 } 212 /* --------------------------------------------------------------------- */ 213 214 int 215 chfs_mknod(void *v) 216 { 217 struct vnode *dvp = ((struct vop_mknod_v3_args *) v)->a_dvp; 218 struct vnode **vpp = ((struct vop_mknod_v3_args *) v)->a_vpp; 219 struct componentname *cnp = ((struct vop_mknod_v3_args *) v)->a_cnp; 220 struct vattr *vap = ((struct vop_mknod_v3_args *) v)->a_vap; 221 int mode, err = 0; 222 struct chfs_inode *ip; 223 struct vnode *vp; 224 225 struct ufsmount *ump; 226 struct chfs_mount *chmp; 227 228 struct chfs_full_dnode *fd; 229 struct buf *bp; 230 int len; 231 dbg("mknod()\n"); 232 233 ump = VFSTOUFS(dvp->v_mount); 234 chmp = ump->um_chfs; 235 236 /* Check type of node. */ 237 if (vap->va_type != VBLK && vap->va_type != VCHR && vap->va_type != VFIFO) 238 return EINVAL; 239 240 vp = *vpp; 241 242 mode = MAKEIMODE(vap->va_type, vap->va_mode); 243 244 if ((mode & IFMT) == 0) { 245 switch (vap->va_type) { 246 case VBLK: 247 mode |= IFBLK; 248 break; 249 case VCHR: 250 mode |= IFCHR; 251 break; 252 case VFIFO: 253 mode |= IFIFO; 254 break; 255 default: 256 break; 257 } 258 } 259 260 /* Create a new node. */ 261 err = chfs_makeinode(mode, dvp, &vp, cnp, vap->va_type); 262 263 ip = VTOI(vp); 264 if (vap->va_rdev != VNOVAL) 265 ip->rdev = vap->va_rdev; 266 267 if (vap->va_type == VFIFO) 268 vp->v_op = chfs_fifoop_p; 269 else { 270 vp->v_op = chfs_specop_p; 271 spec_node_init(vp, ip->rdev); 272 } 273 274 if (err) 275 return err; 276 277 /* Device is written out as a data node. */ 278 len = sizeof(dev_t); 279 chfs_set_vnode_size(vp, len); 280 bp = getiobuf(vp, true); 281 bp->b_bufsize = bp->b_resid = len; 282 bp->b_data = kmem_alloc(len, KM_SLEEP); 283 memcpy(bp->b_data, &ip->rdev, len); 284 bp->b_blkno = 0; 285 286 fd = chfs_alloc_full_dnode(); 287 288 mutex_enter(&chmp->chm_lock_mountfields); 289 290 err = chfs_write_flash_dnode(chmp, vp, bp, fd); 291 if (err) { 292 mutex_exit(&chmp->chm_lock_mountfields); 293 kmem_free(bp->b_data, len); 294 return err; 295 } 296 297 /* Add data node to the inode. */ 298 err = chfs_add_full_dnode_to_inode(chmp, ip, fd); 299 if (err) { 300 mutex_exit(&chmp->chm_lock_mountfields); 301 kmem_free(bp->b_data, len); 302 return err; 303 } 304 305 mutex_exit(&chmp->chm_lock_mountfields); 306 307 *vpp = vp; 308 kmem_free(bp->b_data, len); 309 putiobuf(bp); 310 311 return 0; 312 } 313 314 /* --------------------------------------------------------------------- */ 315 316 int 317 chfs_open(void *v) 318 { 319 struct vnode *vp = ((struct vop_open_args *) v)->a_vp; 320 int mode = ((struct vop_open_args *) v)->a_mode; 321 dbg("open()\n"); 322 323 int error; 324 struct chfs_inode *ip; 325 326 KASSERT(VOP_ISLOCKED(vp)); 327 328 ip = VTOI(vp); 329 330 KASSERT(vp->v_size == ip->size); 331 if (ip->chvc->nlink < 1) { 332 error = ENOENT; 333 goto out; 334 } 335 336 /* If the file is marked append-only, deny write requests. */ 337 if (ip->flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE) 338 error = EPERM; 339 else 340 error = 0; 341 342 out: 343 KASSERT(VOP_ISLOCKED(vp)); 344 return error; 345 } 346 347 /* --------------------------------------------------------------------- */ 348 349 int 350 chfs_close(void *v) 351 { 352 struct vnode *vp = ((struct vop_close_args *) v)->a_vp; 353 dbg("close()\n"); 354 355 struct chfs_inode *ip; 356 357 KASSERT(VOP_ISLOCKED(vp)); 358 359 ip = VTOI(vp); 360 361 if (ip->chvc->nlink > 0) { 362 chfs_update(vp, NULL, NULL, UPDATE_CLOSE); 363 } 364 365 return 0; 366 } 367 368 /* --------------------------------------------------------------------- */ 369 370 int 371 chfs_access(void *v) 372 { 373 struct vnode *vp = ((struct vop_access_args *) v)->a_vp; 374 accmode_t accmode = ((struct vop_access_args *) v)->a_accmode; 375 kauth_cred_t cred = ((struct vop_access_args *) v)->a_cred; 376 377 dbg("access()\n"); 378 struct chfs_inode *ip = VTOI(vp); 379 380 if (accmode & VWRITE) { 381 switch (vp->v_type) { 382 case VLNK: 383 case VDIR: 384 case VREG: 385 if (vp->v_mount->mnt_flag & MNT_RDONLY) 386 return (EROFS); 387 break; 388 case VBLK: 389 case VCHR: 390 case VSOCK: 391 case VFIFO: 392 break; 393 default: 394 break; 395 } 396 } 397 398 if (accmode & VWRITE && ip->flags & IMMUTABLE) 399 return (EPERM); 400 401 return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode, 402 vp->v_type, ip->mode & ALLPERMS), vp, NULL, genfs_can_access(vp, 403 cred, ip->uid, ip->gid, ip->mode & ALLPERMS, NULL, accmode)); 404 } 405 406 /* --------------------------------------------------------------------- */ 407 408 int 409 chfs_getattr(void *v) 410 { 411 struct vnode *vp = ((struct vop_getattr_args *) v)->a_vp; 412 struct vattr *vap = ((struct vop_getattr_args *) v)->a_vap; 413 414 struct chfs_inode *ip = VTOI(vp); 415 dbg("getattr()\n"); 416 417 KASSERT(vp->v_size == ip->size); 418 419 vattr_null(vap); 420 CHFS_ITIMES(ip, NULL, NULL, NULL); 421 422 vap->va_type = CHTTOVT(ip->ch_type); 423 vap->va_mode = ip->mode & ALLPERMS; 424 vap->va_nlink = ip->chvc->nlink; 425 vap->va_uid = ip->uid; 426 vap->va_gid = ip->gid; 427 vap->va_fsid = ip->dev; 428 vap->va_fileid = ip->ino; 429 vap->va_size = ip->size; 430 vap->va_blocksize = PAGE_SIZE; 431 vap->va_atime.tv_sec = ip->atime; 432 vap->va_atime.tv_nsec = 0; 433 vap->va_mtime.tv_sec = ip->mtime; 434 vap->va_mtime.tv_nsec = 0; 435 vap->va_ctime.tv_sec = ip->ctime; 436 vap->va_ctime.tv_nsec = 0; 437 vap->va_gen = ip->version; 438 vap->va_flags = ip->flags; 439 vap->va_rdev = ip->rdev; 440 vap->va_bytes = round_page(ip->size); 441 vap->va_filerev = VNOVAL; 442 vap->va_vaflags = 0; 443 vap->va_spare = VNOVAL; 444 445 return 0; 446 } 447 448 /* --------------------------------------------------------------------- */ 449 450 /* Note: modelled after tmpfs's same function */ 451 452 int 453 chfs_setattr(void *v) 454 { 455 struct vnode *vp = ((struct vop_setattr_args *) v)->a_vp; 456 struct vattr *vap = ((struct vop_setattr_args *) v)->a_vap; 457 kauth_cred_t cred = ((struct vop_setattr_args *) v)->a_cred; 458 459 struct chfs_inode *ip; 460 struct ufsmount *ump = VFSTOUFS(vp->v_mount); 461 struct chfs_mount *chmp = ump->um_chfs; 462 int error = 0; 463 464 dbg("setattr()\n"); 465 466 KASSERT(VOP_ISLOCKED(vp)); 467 ip = VTOI(vp); 468 469 /* Abort if any unsettable attribute is given. */ 470 if (vap->va_type != VNON || vap->va_nlink != VNOVAL || 471 vap->va_fsid != VNOVAL || vap->va_fileid != VNOVAL || 472 vap->va_blocksize != VNOVAL /*|| GOODTIME(&vap->va_ctime)*/ || 473 vap->va_gen != VNOVAL || vap->va_rdev != VNOVAL || 474 vap->va_bytes != VNOVAL) { 475 return EINVAL; 476 } 477 478 /* set flags */ 479 if (error == 0 && (vap->va_flags != VNOVAL)) { 480 error = chfs_chflags(vp, vap->va_flags, cred); 481 return error; 482 } 483 484 if (ip->flags & (IMMUTABLE | APPEND)) { 485 error = EPERM; 486 return error; 487 } 488 489 /* set size */ 490 if (error == 0 && (vap->va_size != VNOVAL)) { 491 error = chfs_chsize(vp, vap->va_size, cred); 492 if (error) 493 return error; 494 } 495 496 /* set owner */ 497 if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL)) { 498 error = chfs_chown(vp, vap->va_uid, vap->va_gid, cred); 499 if (error) 500 return error; 501 } 502 503 /* set mode */ 504 if (error == 0 && (vap->va_mode != VNOVAL)) { 505 error = chfs_chmod(vp, vap->va_mode, cred); 506 if (error) 507 return error; 508 } 509 510 /* set time */ 511 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { 512 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp, 513 NULL, genfs_can_chtimes(vp, cred, ip->uid, 514 vap->va_vaflags)); 515 if (error) 516 return error; 517 if (vap->va_atime.tv_sec != VNOVAL) 518 ip->iflag |= IN_ACCESS; 519 if (vap->va_mtime.tv_sec != VNOVAL) 520 ip->iflag |= IN_CHANGE | IN_UPDATE; 521 error = chfs_update(vp, 522 &vap->va_atime, &vap->va_mtime, UPDATE_WAIT); 523 if (error) 524 return error; 525 } 526 527 /* Write it out. */ 528 mutex_enter(&chmp->chm_lock_mountfields); 529 error = chfs_write_flash_vnode(chmp, ip, ALLOC_NORMAL); 530 mutex_exit(&chmp->chm_lock_mountfields); 531 532 return error; 533 } 534 535 int 536 chfs_chmod(struct vnode *vp, int mode, kauth_cred_t cred) 537 { 538 struct chfs_inode *ip = VTOI(vp); 539 int error; 540 dbg("chmod\n"); 541 542 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY, vp, 543 NULL, genfs_can_chmod(vp, cred, ip->uid, ip->gid, mode)); 544 if (error) 545 return error; 546 ip->mode &= ~ALLPERMS; 547 ip->mode |= (mode & ALLPERMS); 548 ip->iflag |= IN_CHANGE; 549 550 error = chfs_update(vp, NULL, NULL, UPDATE_WAIT); 551 if (error) 552 return error; 553 554 return 0; 555 } 556 557 int 558 chfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred) 559 { 560 struct chfs_inode *ip = VTOI(vp); 561 int error; 562 dbg("chown\n"); 563 564 if (uid == (uid_t)VNOVAL) 565 uid = ip->uid; 566 if (gid == (gid_t)VNOVAL) 567 gid = ip->gid; 568 569 error = kauth_authorize_vnode(cred, KAUTH_VNODE_CHANGE_OWNERSHIP, vp, 570 NULL, genfs_can_chown(vp, cred, ip->uid, ip->gid, uid, gid)); 571 if (error) 572 return error; 573 574 ip->gid = gid; 575 ip->uid = uid; 576 ip->iflag |= IN_CHANGE; 577 578 error = chfs_update(vp, NULL, NULL, UPDATE_WAIT); 579 if (error) 580 return error; 581 582 return 0; 583 } 584 585 586 /* --------------------------------------------------------------------- */ 587 /* calculates ((off_t)blk * chmp->chm_chm_fs_bsize) */ 588 #define chfs_lblktosize(chmp, blk) \ 589 (((off_t)(blk)) << (chmp)->chm_fs_bshift) 590 591 /* calculates (loc % chmp->chm_chm_fs_bsize) */ 592 #define chfs_blkoff(chmp, loc) \ 593 ((loc) & (chmp)->chm_fs_qbmask) 594 595 /* calculates (loc / chmp->chm_chm_fs_bsize) */ 596 #define chfs_lblkno(chmp, loc) \ 597 ((loc) >> (chmp)->chm_fs_bshift) 598 599 /* calculates roundup(size, chmp->chm_chm_fs_fsize) */ 600 #define chfs_fragroundup(chmp, size) \ 601 (((size) + (chmp)->chm_fs_qfmask) & (chmp)->chm_fs_fmask) 602 603 #define chfs_blksize(chmp, ip, lbn) \ 604 (((lbn) >= UFS_NDADDR || (ip)->size >= chfs_lblktosize(chmp, (lbn) + 1)) \ 605 ? (chmp)->chm_fs_bsize \ 606 : (chfs_fragroundup(chmp, chfs_blkoff(chmp, (ip)->size)))) 607 608 /* calculates roundup(size, chmp->chm_chm_fs_bsize) */ 609 #define chfs_blkroundup(chmp, size) \ 610 (((size) + (chmp)->chm_fs_qbmask) & (chmp)->chm_fs_bmask) 611 612 /* from ffs read */ 613 int 614 chfs_read(void *v) 615 { 616 struct vop_read_args /* { 617 struct vnode *a_vp; 618 struct uio *a_uio; 619 int a_ioflag; 620 kauth_cred_t a_cred; 621 } */ *ap = v; 622 struct vnode *vp; 623 struct chfs_inode *ip; 624 struct uio *uio; 625 struct ufsmount *ump; 626 struct buf *bp; 627 struct chfs_mount *chmp; 628 daddr_t lbn, nextlbn; 629 off_t bytesinfile; 630 long size, xfersize, blkoffset; 631 int error, ioflag; 632 vsize_t bytelen; 633 bool usepc = false; 634 635 dbg("chfs_read\n"); 636 637 vp = ap->a_vp; 638 ip = VTOI(vp); 639 ump = ip->ump; 640 uio = ap->a_uio; 641 ioflag = ap->a_ioflag; 642 error = 0; 643 644 dbg("ip->size:%llu\n", (unsigned long long)ip->size); 645 646 #ifdef DIAGNOSTIC 647 if (uio->uio_rw != UIO_READ) 648 panic("%s: mode", READ_S); 649 650 if (vp->v_type == VLNK) { 651 if (ip->size < ump->um_maxsymlinklen) 652 panic("%s: short symlink", READ_S); 653 } else if (vp->v_type != VREG && vp->v_type != VDIR) 654 panic("%s: type %d", READ_S, vp->v_type); 655 #endif 656 chmp = ip->chmp; 657 if ((u_int64_t)uio->uio_offset > ump->um_maxfilesize) 658 return (EFBIG); 659 if (uio->uio_resid == 0) 660 return (0); 661 662 if (uio->uio_offset >= ip->size) 663 goto out; 664 665 usepc = vp->v_type == VREG; 666 bytelen = 0; 667 if (usepc) { 668 const int advice = IO_ADV_DECODE(ap->a_ioflag); 669 670 while (uio->uio_resid > 0) { 671 if (ioflag & IO_DIRECT) { 672 genfs_directio(vp, uio, ioflag); 673 } 674 bytelen = MIN(ip->size - uio->uio_offset, 675 uio->uio_resid); 676 if (bytelen == 0) 677 break; 678 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice, 679 UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp)); 680 if (error) 681 break; 682 683 } 684 goto out; 685 } 686 687 dbg("start reading\n"); 688 for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) { 689 bytesinfile = ip->size - uio->uio_offset; 690 if (bytesinfile <= 0) 691 break; 692 lbn = chfs_lblkno(chmp, uio->uio_offset); 693 nextlbn = lbn + 1; 694 size = chfs_blksize(chmp, ip, lbn); 695 blkoffset = chfs_blkoff(chmp, uio->uio_offset); 696 xfersize = MIN(MIN(chmp->chm_fs_bsize - blkoffset, uio->uio_resid), 697 bytesinfile); 698 699 if (chfs_lblktosize(chmp, nextlbn) >= ip->size) { 700 error = bread(vp, lbn, size, 0, &bp); 701 dbg("after bread\n"); 702 } else { 703 int nextsize = chfs_blksize(chmp, ip, nextlbn); 704 dbg("size: %ld\n", size); 705 error = breadn(vp, lbn, 706 size, &nextlbn, &nextsize, 1, 0, &bp); 707 dbg("after breadN\n"); 708 } 709 if (error) 710 break; 711 712 /* 713 * We should only get non-zero b_resid when an I/O error 714 * has occurred, which should cause us to break above. 715 * However, if the short read did not cause an error, 716 * then we want to ensure that we do not uiomove bad 717 * or uninitialized data. 718 */ 719 size -= bp->b_resid; 720 if (size < xfersize) { 721 if (size == 0) 722 break; 723 xfersize = size; 724 } 725 dbg("uiomove\n"); 726 error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio); 727 if (error) 728 break; 729 brelse(bp, 0); 730 } 731 732 if (bp != NULL) 733 brelse(bp, 0); 734 735 out: 736 // FIXME HACK 737 ip->ino = ip->chvc->vno; 738 739 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) { 740 ip->iflag |= IN_ACCESS; 741 if ((ap->a_ioflag & IO_SYNC) == IO_SYNC) { 742 if (error) { 743 return error; 744 } 745 error = chfs_update(vp, NULL, NULL, UPDATE_WAIT); 746 } 747 } 748 749 dbg("[END]\n"); 750 751 return (error); 752 } 753 754 755 /* --------------------------------------------------------------------- */ 756 757 /* from ffs write */ 758 int 759 chfs_write(void *v) 760 { 761 struct vop_write_args /* { 762 struct vnode *a_vp; 763 struct uio *a_uio; 764 int a_ioflag; 765 kauth_cred_t a_cred; 766 } */ *ap = v; 767 struct vnode *vp ; 768 struct uio *uio; 769 struct chfs_inode *ip; 770 struct chfs_mount *chmp; 771 struct lwp *l; 772 kauth_cred_t cred; 773 off_t osize, origoff, oldoff, preallocoff, endallocoff, nsize; 774 int blkoffset, error, flags, ioflag, resid; 775 int aflag; 776 int extended=0; 777 vsize_t bytelen; 778 bool async; 779 struct ufsmount *ump; 780 781 782 cred = ap->a_cred; 783 ioflag = ap->a_ioflag; 784 uio = ap->a_uio; 785 vp = ap->a_vp; 786 ip = VTOI(vp); 787 ump = ip->ump; 788 789 dbg("write\n"); 790 791 KASSERT(vp->v_size == ip->size); 792 793 switch (vp->v_type) { 794 case VREG: 795 if (ioflag & IO_APPEND) 796 uio->uio_offset = ip->size; 797 if ((ip->flags & APPEND) && uio->uio_offset != ip->size) 798 return (EPERM); 799 /* FALLTHROUGH */ 800 case VLNK: 801 break; 802 case VDIR: 803 if ((ioflag & IO_SYNC) == 0) 804 panic("chfs_write: nonsync dir write"); 805 break; 806 default: 807 panic("chfs_write: type"); 808 } 809 810 chmp = ip->chmp; 811 if (uio->uio_offset < 0 || 812 (u_int64_t)uio->uio_offset + 813 uio->uio_resid > ump->um_maxfilesize) { 814 dbg("uio->uio_offset = %lld | uio->uio_offset + " 815 "uio->uio_resid (%llu) > ump->um_maxfilesize (%lld)\n", 816 (long long)uio->uio_offset, 817 (uint64_t)uio->uio_offset + uio->uio_resid, 818 (long long)ump->um_maxfilesize); 819 return (EFBIG); 820 } 821 /* 822 * Maybe this should be above the vnode op call, but so long as 823 * file servers have no limits, I don't think it matters. 824 */ 825 l = curlwp; 826 if (vp->v_type == VREG && l && 827 uio->uio_offset + uio->uio_resid > 828 l->l_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) { 829 mutex_enter(&proc_lock); 830 psignal(l->l_proc, SIGXFSZ); 831 mutex_exit(&proc_lock); 832 return (EFBIG); 833 } 834 if (uio->uio_resid == 0) 835 return (0); 836 837 flags = ioflag & IO_SYNC ? B_SYNC : 0; 838 async = vp->v_mount->mnt_flag & MNT_ASYNC; 839 origoff = uio->uio_offset; 840 resid = uio->uio_resid; 841 osize = ip->size; 842 error = 0; 843 844 preallocoff = round_page(chfs_blkroundup(chmp, 845 MAX(osize, uio->uio_offset))); 846 aflag = ioflag & IO_SYNC ? B_SYNC : 0; 847 nsize = MAX(osize, uio->uio_offset + uio->uio_resid); 848 endallocoff = nsize - chfs_blkoff(chmp, nsize); 849 850 /* 851 * if we're increasing the file size, deal with expanding 852 * the fragment if there is one. 853 */ 854 855 if (nsize > osize && chfs_lblkno(chmp, osize) < UFS_NDADDR && 856 chfs_lblkno(chmp, osize) != chfs_lblkno(chmp, nsize) && 857 chfs_blkroundup(chmp, osize) != osize) { 858 off_t eob; 859 860 eob = chfs_blkroundup(chmp, osize); 861 uvm_vnp_setwritesize(vp, eob); 862 error = ufs_balloc_range(vp, osize, eob - osize, cred, aflag); 863 if (error) 864 goto out; 865 if (flags & B_SYNC) { 866 rw_enter(vp->v_uobj.vmobjlock, RW_WRITER); 867 VOP_PUTPAGES(vp, 868 trunc_page(osize & chmp->chm_fs_bmask), 869 round_page(eob), 870 PGO_CLEANIT | PGO_SYNCIO | PGO_JOURNALLOCKED); 871 } 872 } 873 874 while (uio->uio_resid > 0) { 875 int ubc_flags = UBC_WRITE; 876 bool overwrite; /* if we're overwrite a whole block */ 877 off_t newoff; 878 879 if (ioflag & IO_DIRECT) { 880 genfs_directio(vp, uio, ioflag | IO_JOURNALLOCKED); 881 } 882 883 oldoff = uio->uio_offset; 884 blkoffset = chfs_blkoff(chmp, uio->uio_offset); 885 bytelen = MIN(chmp->chm_fs_bsize - blkoffset, uio->uio_resid); 886 if (bytelen == 0) { 887 break; 888 } 889 890 /* 891 * if we're filling in a hole, allocate the blocks now and 892 * initialize the pages first. if we're extending the file, 893 * we can safely allocate blocks without initializing pages 894 * since the new blocks will be inaccessible until the write 895 * is complete. 896 */ 897 overwrite = uio->uio_offset >= preallocoff && 898 uio->uio_offset < endallocoff; 899 if (!overwrite && (vp->v_vflag & VV_MAPPED) == 0 && 900 chfs_blkoff(chmp, uio->uio_offset) == 0 && 901 (uio->uio_offset & PAGE_MASK) == 0) { 902 vsize_t len; 903 904 len = trunc_page(bytelen); 905 len -= chfs_blkoff(chmp, len); 906 if (len > 0) { 907 overwrite = true; 908 bytelen = len; 909 } 910 } 911 912 newoff = oldoff + bytelen; 913 if (vp->v_size < newoff) { 914 uvm_vnp_setwritesize(vp, newoff); 915 } 916 917 if (!overwrite) { 918 error = ufs_balloc_range(vp, uio->uio_offset, bytelen, 919 cred, aflag); 920 if (error) 921 break; 922 } else { 923 genfs_node_wrlock(vp); 924 error = GOP_ALLOC(vp, uio->uio_offset, bytelen, 925 aflag, cred); 926 genfs_node_unlock(vp); 927 if (error) 928 break; 929 ubc_flags |= UBC_FAULTBUSY; 930 } 931 932 /* 933 * copy the data. 934 */ 935 936 ubc_flags |= UBC_VNODE_FLAGS(vp); 937 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, 938 IO_ADV_DECODE(ioflag), ubc_flags); 939 940 /* 941 * update UVM's notion of the size now that we've 942 * copied the data into the vnode's pages. 943 * 944 * we should update the size even when uiomove failed. 945 */ 946 947 if (vp->v_size < newoff) { 948 uvm_vnp_setsize(vp, newoff); 949 extended = 1; 950 } 951 952 if (error) 953 break; 954 955 /* 956 * flush what we just wrote if necessary. 957 * XXXUBC simplistic async flushing. 958 */ 959 960 if (!async && oldoff >> 16 != uio->uio_offset >> 16) { 961 rw_enter(vp->v_uobj.vmobjlock, RW_WRITER); 962 error = VOP_PUTPAGES(vp, (oldoff >> 16) << 16, 963 (uio->uio_offset >> 16) << 16, 964 PGO_CLEANIT | PGO_JOURNALLOCKED); 965 if (error) 966 break; 967 } 968 } 969 out: 970 if (error == 0 && ioflag & IO_SYNC) { 971 rw_enter(vp->v_uobj.vmobjlock, RW_WRITER); 972 error = VOP_PUTPAGES(vp, 973 trunc_page(origoff & chmp->chm_fs_bmask), 974 round_page(chfs_blkroundup(chmp, uio->uio_offset)), 975 PGO_CLEANIT | PGO_SYNCIO | PGO_JOURNALLOCKED); 976 } 977 ip->iflag |= IN_CHANGE | IN_UPDATE; 978 if (resid > uio->uio_resid && ap->a_cred) { 979 if (ip->mode & ISUID) { 980 if (kauth_authorize_vnode(ap->a_cred, 981 KAUTH_VNODE_RETAIN_SUID, vp, NULL, EPERM) != 0) 982 ip->mode &= ~ISUID; 983 } 984 985 if (ip->mode & ISGID) { 986 if (kauth_authorize_vnode(ap->a_cred, 987 KAUTH_VNODE_RETAIN_SGID, vp, NULL, EPERM) != 0) 988 ip->mode &= ~ISGID; 989 } 990 } 991 if (resid > uio->uio_resid) 992 VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0)); 993 if (error) { 994 (void) UFS_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred); 995 uio->uio_offset -= resid - uio->uio_resid; 996 uio->uio_resid = resid; 997 } else if (resid > uio->uio_resid && (ioflag & IO_SYNC) == IO_SYNC) 998 error = UFS_UPDATE(vp, NULL, NULL, UPDATE_WAIT); 999 1000 //FIXME HACK 1001 chfs_set_vnode_size(vp, vp->v_size); 1002 1003 1004 KASSERT(vp->v_size == ip->size); 1005 1006 mutex_enter(&chmp->chm_lock_mountfields); 1007 error = chfs_write_flash_vnode(chmp, ip, ALLOC_NORMAL); 1008 mutex_exit(&chmp->chm_lock_mountfields); 1009 1010 return (error); 1011 } 1012 1013 1014 /* --------------------------------------------------------------------- */ 1015 1016 int 1017 chfs_fsync(void *v) 1018 { 1019 struct vop_fsync_args /* { 1020 struct vnode *a_vp; 1021 kauth_cred_t a_cred; 1022 int a_flags; 1023 off_t offlo; 1024 off_t offhi; 1025 } */ *ap = v; 1026 struct vnode *vp = ap->a_vp; 1027 1028 if (ap->a_flags & FSYNC_CACHE) { 1029 return ENODEV; 1030 } 1031 vflushbuf(vp, ap->a_flags); 1032 1033 return 0; 1034 } 1035 1036 /* --------------------------------------------------------------------- */ 1037 1038 int 1039 chfs_remove(void *v) 1040 { 1041 struct vnode *dvp = ((struct vop_remove_v2_args *) v)->a_dvp; 1042 struct vnode *vp = ((struct vop_remove_v2_args *) v)->a_vp; 1043 struct componentname *cnp = (((struct vop_remove_v2_args *) v)->a_cnp); 1044 dbg("remove\n"); 1045 1046 KASSERT(VOP_ISLOCKED(dvp)); 1047 KASSERT(VOP_ISLOCKED(vp)); 1048 1049 struct chfs_inode *ip = VTOI(vp); 1050 struct chfs_inode *parent = VTOI(dvp); 1051 int error = 0; 1052 1053 if (vp->v_type == VDIR || (ip->flags & (IMMUTABLE | APPEND)) || 1054 (parent->flags & APPEND)) { 1055 error = EPERM; 1056 goto out; 1057 } 1058 1059 KASSERT(ip->chvc->vno != ip->chvc->pvno); 1060 1061 error = chfs_do_unlink(ip, 1062 parent, cnp->cn_nameptr, cnp->cn_namelen); 1063 1064 out: 1065 vput(vp); 1066 1067 return error; 1068 } 1069 1070 /* --------------------------------------------------------------------- */ 1071 1072 int 1073 chfs_link(void *v) 1074 { 1075 struct vnode *dvp = ((struct vop_link_v2_args *) v)->a_dvp; 1076 struct vnode *vp = ((struct vop_link_v2_args *) v)->a_vp; 1077 struct componentname *cnp = ((struct vop_link_v2_args *) v)->a_cnp; 1078 1079 struct chfs_inode *ip, *parent; 1080 int error = 0; 1081 1082 if (vp->v_type == VDIR) { 1083 VOP_ABORTOP(dvp, cnp); 1084 error = EISDIR; 1085 goto out; 1086 } 1087 if (dvp->v_mount != vp->v_mount) { 1088 VOP_ABORTOP(dvp, cnp); 1089 error = EXDEV; 1090 goto out; 1091 } 1092 if (dvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE))) { 1093 VOP_ABORTOP(dvp, cnp); 1094 goto out; 1095 } 1096 1097 parent = VTOI(dvp); 1098 ip = VTOI(vp); 1099 1100 error = chfs_do_link(ip, 1101 parent, cnp->cn_nameptr, cnp->cn_namelen, ip->ch_type); 1102 1103 if (dvp != vp) 1104 VOP_UNLOCK(vp); 1105 out: 1106 return error; 1107 } 1108 1109 /* --------------------------------------------------------------------- */ 1110 1111 int 1112 chfs_rename(void *v) 1113 { 1114 struct vnode *fdvp = ((struct vop_rename_args *) v)->a_fdvp; 1115 struct vnode *fvp = ((struct vop_rename_args *) v)->a_fvp; 1116 struct componentname *fcnp = ((struct vop_rename_args *) v)->a_fcnp; 1117 struct vnode *tdvp = ((struct vop_rename_args *) v)->a_tdvp; 1118 struct vnode *tvp = ((struct vop_rename_args *) v)->a_tvp; 1119 struct componentname *tcnp = ((struct vop_rename_args *) v)->a_tcnp; 1120 1121 struct chfs_inode *oldparent, *old; 1122 struct chfs_inode *newparent; 1123 struct chfs_dirent *fd; 1124 struct chfs_inode *ip; 1125 int error = 0; 1126 dbg("rename\n"); 1127 1128 KASSERT(VOP_ISLOCKED(tdvp)); 1129 KASSERT(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp) == LK_EXCLUSIVE)); 1130 1131 oldparent = VTOI(fdvp); 1132 old = VTOI(fvp); 1133 newparent = VTOI(tdvp); 1134 if (tvp) { 1135 dbg("tvp not null\n"); 1136 ip = VTOI(tvp); 1137 if (tvp->v_type == VDIR) { 1138 TAILQ_FOREACH(fd, &ip->dents, fds) { 1139 if (fd->vno) { 1140 error = ENOTEMPTY; 1141 goto out_unlocked; 1142 } 1143 } 1144 } 1145 error = chfs_do_unlink(ip, 1146 newparent, tcnp->cn_nameptr, tcnp->cn_namelen); 1147 vput(tvp); 1148 } 1149 VFS_VGET(tdvp->v_mount, old->ino, LK_EXCLUSIVE, &tvp); 1150 ip = VTOI(tvp); 1151 1152 /* link new */ 1153 error = chfs_do_link(ip, 1154 newparent, tcnp->cn_nameptr, tcnp->cn_namelen, ip->ch_type); 1155 /* remove old */ 1156 error = chfs_do_unlink(old, 1157 oldparent, fcnp->cn_nameptr, fcnp->cn_namelen); 1158 1159 out_unlocked: 1160 /* Release target nodes. */ 1161 if (tdvp == tvp) 1162 vrele(tdvp); 1163 else 1164 vput(tdvp); 1165 if (tvp != NULL) 1166 vput(tvp); 1167 1168 /* Release source nodes. */ 1169 vrele(fdvp); 1170 vrele(fvp); 1171 1172 return error; 1173 } 1174 1175 /* --------------------------------------------------------------------- */ 1176 1177 int 1178 chfs_mkdir(void *v) 1179 { 1180 struct vnode *dvp = ((struct vop_mkdir_v3_args *) v)->a_dvp; 1181 struct vnode **vpp = ((struct vop_mkdir_v3_args *)v)->a_vpp; 1182 struct componentname *cnp = ((struct vop_mkdir_v3_args *) v)->a_cnp; 1183 struct vattr *vap = ((struct vop_mkdir_v3_args *) v)->a_vap; 1184 dbg("mkdir()\n"); 1185 1186 int mode; 1187 1188 mode = vap->va_mode & ACCESSPERMS; 1189 if ((mode & IFMT) == 0) { 1190 mode |= IFDIR; 1191 } 1192 1193 KASSERT(vap->va_type == VDIR); 1194 1195 return chfs_makeinode(mode, dvp, vpp, cnp, VDIR); 1196 } 1197 1198 /* --------------------------------------------------------------------- */ 1199 1200 int 1201 chfs_rmdir(void *v) 1202 { 1203 struct vnode *dvp = ((struct vop_rmdir_v2_args *) v)->a_dvp; 1204 struct vnode *vp = ((struct vop_rmdir_v2_args *) v)->a_vp; 1205 struct componentname *cnp = ((struct vop_rmdir_v2_args *) v)->a_cnp; 1206 dbg("rmdir()\n"); 1207 1208 KASSERT(VOP_ISLOCKED(dvp)); 1209 KASSERT(VOP_ISLOCKED(vp)); 1210 1211 struct chfs_inode *ip = VTOI(vp); 1212 struct chfs_inode *parent = VTOI(dvp); 1213 struct chfs_dirent *fd; 1214 int error = 0; 1215 1216 if (vp->v_type != VDIR) { 1217 error = ENOTDIR; 1218 goto out; 1219 } 1220 1221 KASSERT(ip->chvc->vno != ip->chvc->pvno); 1222 1223 TAILQ_FOREACH(fd, &ip->dents, fds) { 1224 if (fd->vno) { 1225 error = ENOTEMPTY; 1226 goto out; 1227 } 1228 } 1229 1230 error = chfs_do_unlink(ip, 1231 parent, cnp->cn_nameptr, cnp->cn_namelen); 1232 1233 out: 1234 vput(vp); 1235 1236 return error; 1237 } 1238 1239 /* --------------------------------------------------------------------- */ 1240 1241 int 1242 chfs_symlink(void *v) 1243 { 1244 struct vnode *dvp = ((struct vop_symlink_v3_args *) v)->a_dvp; 1245 struct vnode **vpp = ((struct vop_symlink_v3_args *) v)->a_vpp; 1246 struct componentname *cnp = ((struct vop_symlink_v3_args *) v)->a_cnp; 1247 struct vattr *vap = ((struct vop_symlink_v3_args *) v)->a_vap; 1248 char *target = ((struct vop_symlink_v3_args *) v)->a_target; 1249 1250 struct ufsmount *ump; 1251 struct chfs_mount *chmp; 1252 struct vnode *vp; 1253 struct chfs_inode *ip; 1254 int len, err; 1255 struct chfs_full_dnode *fd; 1256 struct buf *bp; 1257 dbg("symlink()\n"); 1258 1259 ump = VFSTOUFS(dvp->v_mount); 1260 chmp = ump->um_chfs; 1261 1262 err = chfs_makeinode(IFLNK | vap->va_mode, dvp, vpp, cnp, VLNK); 1263 if (err) 1264 return (err); 1265 VN_KNOTE(dvp, NOTE_WRITE); 1266 vp = *vpp; 1267 len = strlen(target); 1268 ip = VTOI(vp); 1269 /* TODO max symlink len instead of "100" */ 1270 if (len < 100) { 1271 /* symlink path stored as a data node */ 1272 ip->target = kmem_alloc(len, KM_SLEEP); 1273 memcpy(ip->target, target, len); 1274 chfs_set_vnode_size(vp, len); 1275 ip->iflag |= IN_CHANGE | IN_UPDATE; 1276 1277 bp = getiobuf(vp, true); 1278 bp->b_bufsize = bp->b_resid = len; 1279 bp->b_data = kmem_alloc(len, KM_SLEEP); 1280 memcpy(bp->b_data, target, len); 1281 bp->b_blkno = 0; 1282 1283 fd = chfs_alloc_full_dnode(); 1284 1285 mutex_enter(&chmp->chm_lock_mountfields); 1286 1287 /* write out the data node */ 1288 err = chfs_write_flash_dnode(chmp, vp, bp, fd); 1289 if (err) { 1290 mutex_exit(&chmp->chm_lock_mountfields); 1291 goto out; 1292 } 1293 1294 /* add it to the inode */ 1295 err = chfs_add_full_dnode_to_inode(chmp, ip, fd); 1296 if (err) { 1297 mutex_exit(&chmp->chm_lock_mountfields); 1298 goto out; 1299 } 1300 1301 mutex_exit(&chmp->chm_lock_mountfields); 1302 1303 kmem_free(bp->b_data, len); 1304 putiobuf(bp); 1305 1306 uvm_vnp_setsize(vp, len); 1307 } else { 1308 err = ufs_bufio(UIO_WRITE, vp, target, len, (off_t)0, 1309 IO_NODELOCKED, cnp->cn_cred, (size_t *)0, NULL); 1310 } 1311 1312 out: 1313 if (err) 1314 vrele(vp); 1315 1316 return (err); 1317 } 1318 1319 /* --------------------------------------------------------------------- */ 1320 1321 int 1322 chfs_readdir(void *v) 1323 { 1324 struct vnode *vp = ((struct vop_readdir_args *) v)->a_vp; 1325 struct uio *uio = ((struct vop_readdir_args *) v)->a_uio; 1326 int *eofflag = ((struct vop_readdir_args *) v)->a_eofflag; 1327 1328 int error = 0; 1329 off_t skip, offset; 1330 struct chfs_inode *ip; 1331 struct chfs_dirent *fd; 1332 1333 struct ufsmount *ump; 1334 struct chfs_mount *chmp; 1335 struct chfs_vnode_cache *chvc; 1336 1337 KASSERT(VOP_ISLOCKED(vp)); 1338 1339 /* This operation only makes sense on directory nodes. */ 1340 if (vp->v_type != VDIR) { 1341 error = ENOTDIR; 1342 goto out; 1343 } 1344 1345 ip = VTOI(vp); 1346 1347 /* uiomove in chfs_filldir automatically increments the 1348 * uio_offset by an arbitrary size, so we discard any change 1349 * to uio_offset and set it to our own value on return 1350 */ 1351 offset = uio->uio_offset; 1352 1353 /* Add this entry. */ 1354 if (offset == CHFS_OFFSET_DOT) { 1355 error = chfs_filldir(uio, ip->ino, ".", 1, CHT_DIR); 1356 if (error == -1) { 1357 error = 0; 1358 goto outok; 1359 } else if (error != 0) 1360 goto outok; 1361 1362 offset = CHFS_OFFSET_DOTDOT; 1363 } 1364 1365 /* Add parent entry. */ 1366 if (offset == CHFS_OFFSET_DOTDOT) { 1367 ump = VFSTOUFS(vp->v_mount); 1368 chmp = ump->um_chfs; 1369 mutex_enter(&chmp->chm_lock_vnocache); 1370 chvc = chfs_vnode_cache_get(chmp, ip->ino); 1371 mutex_exit(&chmp->chm_lock_vnocache); 1372 1373 error = chfs_filldir(uio, chvc->pvno, "..", 2, CHT_DIR); 1374 if (error == -1) { 1375 error = 0; 1376 goto outok; 1377 } else if (error != 0) { 1378 goto outok; 1379 } 1380 1381 /* Has child or not? */ 1382 if (TAILQ_EMPTY(&ip->dents)) { 1383 offset = CHFS_OFFSET_EOF; 1384 } else { 1385 offset = CHFS_OFFSET_FIRST; 1386 } 1387 } 1388 1389 if (offset != CHFS_OFFSET_EOF) { 1390 /* Child entries. */ 1391 skip = offset - CHFS_OFFSET_FIRST; 1392 1393 TAILQ_FOREACH(fd, &ip->dents, fds) { 1394 /* seek to offset by skipping items */ 1395 /* XXX race conditions by changed dirent? */ 1396 if (skip > 0) { 1397 skip--; 1398 continue; 1399 } 1400 1401 if (fd->vno != 0) { 1402 error = chfs_filldir(uio, fd->vno, 1403 fd->name, fd->nsize, fd->type); 1404 if (error == -1) { 1405 error = 0; 1406 goto outok; 1407 } else if (error != 0) { 1408 dbg("err %d\n", error); 1409 goto outok; 1410 } 1411 } 1412 offset++; 1413 } 1414 } 1415 offset = CHFS_OFFSET_EOF; 1416 1417 outok: 1418 uio->uio_offset = offset; 1419 1420 if (eofflag != NULL) { 1421 *eofflag = (error == 0 && 1422 uio->uio_offset == CHFS_OFFSET_EOF); 1423 } 1424 1425 out: 1426 KASSERT(VOP_ISLOCKED(vp)); 1427 1428 return error; 1429 } 1430 1431 /* --------------------------------------------------------------------- */ 1432 1433 int 1434 chfs_readlink(void *v) 1435 { 1436 1437 struct vnode *vp = ((struct vop_readlink_args *) v)->a_vp; 1438 struct uio *uio = ((struct vop_readlink_args *) v)->a_uio; 1439 kauth_cred_t cred = ((struct vop_readlink_args *) v)->a_cred; 1440 1441 struct chfs_inode *ip = VTOI(vp); 1442 1443 dbg("readlink()\n"); 1444 1445 /* TODO max symlink len instead of "100" */ 1446 if (ip->size < 100) { 1447 uiomove(ip->target, ip->size, uio); 1448 return (0); 1449 } 1450 1451 return (UFS_BUFRD(vp, uio, 0, cred)); 1452 } 1453 1454 /* --------------------------------------------------------------------- */ 1455 1456 int 1457 chfs_inactive(void *v) 1458 { 1459 struct vnode *vp = ((struct vop_inactive_v2_args *) v)->a_vp; 1460 struct chfs_inode *ip = VTOI(vp); 1461 struct chfs_vnode_cache *chvc; 1462 dbg("inactive | vno: %llu\n", (unsigned long long)ip->ino); 1463 1464 KASSERT(VOP_ISLOCKED(vp)); 1465 1466 /* Reclaim only if there is no link to the node. */ 1467 if (ip->ino) { 1468 chvc = ip->chvc; 1469 if (chvc->nlink) 1470 *((struct vop_inactive_v2_args *) v)->a_recycle = 0; 1471 } else { 1472 *((struct vop_inactive_v2_args *) v)->a_recycle = 1; 1473 } 1474 1475 return 0; 1476 } 1477 1478 /* --------------------------------------------------------------------- */ 1479 1480 int 1481 chfs_reclaim(void *v) 1482 { 1483 struct vop_reclaim_v2_args *ap = v; 1484 struct vnode *vp = ap->a_vp; 1485 struct chfs_inode *ip = VTOI(vp); 1486 struct chfs_mount *chmp = ip->chmp; 1487 struct chfs_dirent *fd; 1488 1489 VOP_UNLOCK(vp); 1490 1491 mutex_enter(&chmp->chm_lock_mountfields); 1492 1493 mutex_enter(&chmp->chm_lock_vnocache); 1494 ip->chvc->state = VNO_STATE_CHECKEDABSENT; 1495 mutex_exit(&chmp->chm_lock_vnocache); 1496 1497 chfs_update(vp, NULL, NULL, UPDATE_CLOSE); 1498 1499 /* Clean fragments. */ 1500 chfs_kill_fragtree(chmp, &ip->fragtree); 1501 1502 /* Clean dirents. */ 1503 fd = TAILQ_FIRST(&ip->dents); 1504 while (fd) { 1505 TAILQ_REMOVE(&ip->dents, fd, fds); 1506 chfs_free_dirent(fd); 1507 fd = TAILQ_FIRST(&ip->dents); 1508 } 1509 1510 cache_purge(vp); 1511 if (ip->devvp) { 1512 vrele(ip->devvp); 1513 ip->devvp = 0; 1514 } 1515 1516 genfs_node_destroy(vp); 1517 pool_put(&chfs_inode_pool, vp->v_data); 1518 vp->v_data = NULL; 1519 1520 mutex_exit(&chmp->chm_lock_mountfields); 1521 1522 return (0); 1523 } 1524 1525 /* --------------------------------------------------------------------- */ 1526 1527 int 1528 chfs_advlock(void *v) 1529 { 1530 return 0; 1531 } 1532 1533 /* --------------------------------------------------------------------- */ 1534 int 1535 chfs_strategy(void *v) 1536 { 1537 struct vop_strategy_args /* { 1538 const struct vnodeop_desc *a_desc; 1539 struct vnode *a_vp; 1540 struct buf *a_bp; 1541 } */ *ap = v; 1542 struct chfs_full_dnode *fd; 1543 struct buf *bp = ap->a_bp; 1544 struct vnode *vp = ap->a_vp; 1545 struct chfs_inode *ip = VTOI(vp); 1546 struct chfs_mount *chmp = ip->chmp; 1547 int read = (bp->b_flags & B_READ) ? 1 : 0; 1548 int err = 0; 1549 1550 if (read) { 1551 err = chfs_read_data(chmp, vp, bp); 1552 } else { 1553 mutex_enter(&chmp->chm_lock_mountfields); 1554 1555 fd = chfs_alloc_full_dnode(); 1556 1557 err = chfs_write_flash_dnode(chmp, vp, bp, fd); 1558 if (err) { 1559 mutex_exit(&chmp->chm_lock_mountfields); 1560 goto out; 1561 } 1562 1563 ip = VTOI(vp); 1564 err = chfs_add_full_dnode_to_inode(chmp, ip, fd); 1565 1566 mutex_exit(&chmp->chm_lock_mountfields); 1567 } 1568 out: 1569 biodone(bp); 1570 return err; 1571 } 1572 1573 int 1574 chfs_bmap(void *v) 1575 { 1576 struct vop_bmap_args /* { 1577 struct vnode *a_vp; 1578 daddr_t a_bn; 1579 struct vnode **a_vpp; 1580 daddr_t *a_bnp; 1581 int *a_runp; 1582 int *a_runb; 1583 } */ *ap = v; 1584 if (ap->a_vpp != NULL) 1585 *ap->a_vpp = ap->a_vp; 1586 if (ap->a_bnp != NULL) 1587 *ap->a_bnp = ap->a_bn; 1588 if (ap->a_runp != NULL) 1589 *ap->a_runp = 0; 1590 return (0); 1591 } 1592 1593 /* 1594 * vnode operations vector used for files stored in a chfs file system. 1595 */ 1596 int 1597 (**chfs_vnodeop_p)(void *); 1598 const struct vnodeopv_entry_desc chfs_vnodeop_entries[] = 1599 { 1600 { &vop_default_desc, vn_default_error }, 1601 { &vop_lookup_desc, chfs_lookup }, 1602 { &vop_create_desc, chfs_create }, 1603 { &vop_mknod_desc, chfs_mknod }, 1604 { &vop_open_desc, chfs_open }, 1605 { &vop_close_desc, chfs_close }, 1606 { &vop_access_desc, chfs_access }, 1607 { &vop_accessx_desc, genfs_accessx }, 1608 { &vop_getattr_desc, chfs_getattr }, 1609 { &vop_setattr_desc, chfs_setattr }, 1610 { &vop_read_desc, chfs_read }, 1611 { &vop_write_desc, chfs_write }, 1612 { &vop_fallocate_desc, genfs_eopnotsupp }, 1613 { &vop_fdiscard_desc, genfs_eopnotsupp }, 1614 { &vop_ioctl_desc, genfs_enoioctl }, 1615 { &vop_fcntl_desc, genfs_fcntl }, 1616 { &vop_poll_desc, genfs_poll }, 1617 { &vop_kqfilter_desc, genfs_kqfilter }, 1618 { &vop_revoke_desc, genfs_revoke }, 1619 { &vop_mmap_desc, genfs_mmap }, 1620 { &vop_fsync_desc, chfs_fsync }, 1621 { &vop_seek_desc, genfs_seek }, 1622 { &vop_remove_desc, chfs_remove }, 1623 { &vop_link_desc, chfs_link }, 1624 { &vop_rename_desc, chfs_rename }, 1625 { &vop_mkdir_desc, chfs_mkdir }, 1626 { &vop_rmdir_desc, chfs_rmdir }, 1627 { &vop_symlink_desc, chfs_symlink }, 1628 { &vop_readdir_desc, chfs_readdir }, 1629 { &vop_readlink_desc, chfs_readlink }, 1630 { &vop_abortop_desc, genfs_abortop }, 1631 { &vop_inactive_desc, chfs_inactive }, 1632 { &vop_reclaim_desc, chfs_reclaim }, 1633 { &vop_lock_desc, genfs_lock }, 1634 { &vop_unlock_desc, genfs_unlock }, 1635 { &vop_bmap_desc, chfs_bmap }, 1636 { &vop_strategy_desc, chfs_strategy }, 1637 { &vop_print_desc, ufs_print }, 1638 { &vop_pathconf_desc, ufs_pathconf }, 1639 { &vop_islocked_desc, genfs_islocked }, 1640 { &vop_advlock_desc, chfs_advlock }, 1641 { &vop_bwrite_desc, vn_bwrite }, 1642 { &vop_getpages_desc, genfs_getpages }, 1643 { &vop_putpages_desc, genfs_putpages }, 1644 { NULL, NULL } }; 1645 1646 const struct vnodeopv_desc chfs_vnodeop_opv_desc = 1647 { &chfs_vnodeop_p, chfs_vnodeop_entries }; 1648 1649 /* --------------------------------------------------------------------- */ 1650 1651 /* 1652 * vnode operations vector used for special devices stored in a chfs 1653 * file system. 1654 */ 1655 int 1656 (**chfs_specop_p)(void *); 1657 const struct vnodeopv_entry_desc chfs_specop_entries[] = 1658 { 1659 { &vop_default_desc, vn_default_error }, 1660 { &vop_lookup_desc, spec_lookup }, 1661 { &vop_create_desc, spec_create }, 1662 { &vop_mknod_desc, spec_mknod }, 1663 { &vop_open_desc, spec_open }, 1664 { &vop_close_desc, ufsspec_close }, 1665 { &vop_access_desc, chfs_access }, 1666 { &vop_accessx_desc, genfs_accessx }, 1667 { &vop_getattr_desc, chfs_getattr }, 1668 { &vop_setattr_desc, chfs_setattr }, 1669 { &vop_read_desc, chfs_read }, 1670 { &vop_write_desc, chfs_write }, 1671 { &vop_fallocate_desc, spec_fallocate }, 1672 { &vop_fdiscard_desc, spec_fdiscard }, 1673 { &vop_ioctl_desc, spec_ioctl }, 1674 { &vop_fcntl_desc, genfs_fcntl }, 1675 { &vop_poll_desc, spec_poll }, 1676 { &vop_kqfilter_desc, spec_kqfilter }, 1677 { &vop_revoke_desc, spec_revoke }, 1678 { &vop_mmap_desc, spec_mmap }, 1679 { &vop_fsync_desc, spec_fsync }, 1680 { &vop_seek_desc, spec_seek }, 1681 { &vop_remove_desc, spec_remove }, 1682 { &vop_link_desc, spec_link }, 1683 { &vop_rename_desc, spec_rename }, 1684 { &vop_mkdir_desc, spec_mkdir }, 1685 { &vop_rmdir_desc, spec_rmdir }, 1686 { &vop_symlink_desc, spec_symlink }, 1687 { &vop_readdir_desc, spec_readdir }, 1688 { &vop_readlink_desc, spec_readlink }, 1689 { &vop_abortop_desc, spec_abortop }, 1690 { &vop_inactive_desc, chfs_inactive }, 1691 { &vop_reclaim_desc, chfs_reclaim }, 1692 { &vop_lock_desc, genfs_lock }, 1693 { &vop_unlock_desc, genfs_unlock }, 1694 { &vop_bmap_desc, spec_bmap }, 1695 { &vop_strategy_desc, spec_strategy }, 1696 { &vop_print_desc, ufs_print }, 1697 { &vop_pathconf_desc, spec_pathconf }, 1698 { &vop_islocked_desc, genfs_islocked }, 1699 { &vop_advlock_desc, spec_advlock }, 1700 { &vop_bwrite_desc, vn_bwrite }, 1701 { &vop_getpages_desc, spec_getpages }, 1702 { &vop_putpages_desc, spec_putpages }, 1703 { NULL, NULL } }; 1704 1705 const struct vnodeopv_desc chfs_specop_opv_desc = 1706 { &chfs_specop_p, chfs_specop_entries }; 1707 1708 /* --------------------------------------------------------------------- */ 1709 /* 1710 * vnode operations vector used for fifos stored in a chfs file system. 1711 */ 1712 int 1713 (**chfs_fifoop_p)(void *); 1714 const struct vnodeopv_entry_desc chfs_fifoop_entries[] = 1715 { 1716 { &vop_default_desc, vn_default_error }, 1717 { &vop_lookup_desc, vn_fifo_bypass }, 1718 { &vop_create_desc, vn_fifo_bypass }, 1719 { &vop_mknod_desc, vn_fifo_bypass }, 1720 { &vop_open_desc, vn_fifo_bypass }, 1721 { &vop_close_desc, ufsfifo_close }, 1722 { &vop_access_desc, chfs_access }, 1723 { &vop_accessx_desc, genfs_accessx }, 1724 { &vop_getattr_desc, chfs_getattr }, 1725 { &vop_setattr_desc, chfs_setattr }, 1726 { &vop_read_desc, ufsfifo_read }, 1727 { &vop_write_desc, ufsfifo_write }, 1728 { &vop_fallocate_desc, vn_fifo_bypass }, 1729 { &vop_fdiscard_desc, vn_fifo_bypass }, 1730 { &vop_ioctl_desc, vn_fifo_bypass }, 1731 { &vop_fcntl_desc, genfs_fcntl }, 1732 { &vop_poll_desc, vn_fifo_bypass }, 1733 { &vop_kqfilter_desc, vn_fifo_bypass }, 1734 { &vop_revoke_desc, vn_fifo_bypass }, 1735 { &vop_mmap_desc, vn_fifo_bypass }, 1736 { &vop_fsync_desc, vn_fifo_bypass }, 1737 { &vop_seek_desc, vn_fifo_bypass }, 1738 { &vop_remove_desc, vn_fifo_bypass }, 1739 { &vop_link_desc, vn_fifo_bypass }, 1740 { &vop_rename_desc, vn_fifo_bypass }, 1741 { &vop_mkdir_desc, vn_fifo_bypass }, 1742 { &vop_rmdir_desc, vn_fifo_bypass }, 1743 { &vop_symlink_desc, vn_fifo_bypass }, 1744 { &vop_readdir_desc, vn_fifo_bypass }, 1745 { &vop_readlink_desc, vn_fifo_bypass }, 1746 { &vop_abortop_desc, vn_fifo_bypass }, 1747 { &vop_inactive_desc, chfs_inactive }, 1748 { &vop_reclaim_desc, chfs_reclaim }, 1749 { &vop_lock_desc, genfs_lock }, 1750 { &vop_unlock_desc, genfs_unlock }, 1751 { &vop_bmap_desc, vn_fifo_bypass }, 1752 { &vop_strategy_desc, vn_fifo_bypass }, 1753 { &vop_print_desc, ufs_print }, 1754 { &vop_pathconf_desc, vn_fifo_bypass }, 1755 { &vop_islocked_desc, genfs_islocked }, 1756 { &vop_advlock_desc, vn_fifo_bypass }, 1757 { &vop_bwrite_desc, genfs_nullop }, 1758 { &vop_getpages_desc, genfs_badop }, 1759 { &vop_putpages_desc, vn_fifo_bypass }, 1760 { NULL, NULL } }; 1761 1762 const struct vnodeopv_desc chfs_fifoop_opv_desc = 1763 { &chfs_fifoop_p, chfs_fifoop_entries }; 1764
Indexes created Sun Sep 28 12:09:53 GMT 2025