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