efs_vnops.c revision 1.24.10.1
1 /* $NetBSD: efs_vnops.c,v 1.24.10.1 2012/08/12 12:59:49 martin Exp $ */ 2 3 /* 4 * Copyright (c) 2006 Stephen M. Rumble <rumble (at) ephemeral.org> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/cdefs.h> 20 __KERNEL_RCSID(0, "$NetBSD: efs_vnops.c,v 1.24.10.1 2012/08/12 12:59:49 martin Exp $"); 21 22 #include <sys/param.h> 23 #include <sys/systm.h> 24 #include <sys/proc.h> 25 #include <sys/kernel.h> 26 #include <sys/vnode.h> 27 #include <sys/mount.h> 28 #include <sys/malloc.h> 29 #include <sys/namei.h> 30 #include <sys/dirent.h> 31 #include <sys/lockf.h> 32 #include <sys/unistd.h> 33 #include <sys/buf.h> 34 35 #include <miscfs/genfs/genfs.h> 36 #include <miscfs/genfs/genfs_node.h> 37 #include <miscfs/fifofs/fifo.h> 38 #include <miscfs/specfs/specdev.h> 39 40 #include <fs/efs/efs.h> 41 #include <fs/efs/efs_sb.h> 42 #include <fs/efs/efs_dir.h> 43 #include <fs/efs/efs_genfs.h> 44 #include <fs/efs/efs_mount.h> 45 #include <fs/efs/efs_extent.h> 46 #include <fs/efs/efs_dinode.h> 47 #include <fs/efs/efs_inode.h> 48 #include <fs/efs/efs_subr.h> 49 #include <fs/efs/efs_ihash.h> 50 51 MALLOC_DECLARE(M_EFSTMP); 52 53 /* 54 * Lookup a pathname component in the given directory. 55 * 56 * Returns 0 on success. 57 */ 58 static int 59 efs_lookup(void *v) 60 { 61 struct vop_lookup_args /* { 62 struct vnode *a_dvp; 63 struct vnode **a_vpp; 64 struct componentname *a_cnp; 65 } */ *ap = v; 66 struct componentname *cnp = ap->a_cnp; 67 struct vnode *vp; 68 ino_t ino; 69 int err, nameiop = cnp->cn_nameiop; 70 71 /* ensure that the directory can be accessed first */ 72 err = VOP_ACCESS(ap->a_dvp, VEXEC, cnp->cn_cred); 73 if (err) 74 return (err); 75 76 err = cache_lookup(ap->a_dvp, ap->a_vpp, cnp); 77 if (err != -1) 78 return (err); 79 80 /* 81 * Handle the three lookup types: '.', '..', and everything else. 82 */ 83 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 84 vref(ap->a_dvp); 85 *ap->a_vpp = ap->a_dvp; 86 } else if (cnp->cn_flags & ISDOTDOT) { 87 err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount), 88 EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino); 89 if (err) 90 return (err); 91 92 VOP_UNLOCK(ap->a_dvp); /* preserve lock order */ 93 94 err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp); 95 if (err) { 96 vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY); 97 return (err); 98 } 99 vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY); 100 *ap->a_vpp = vp; 101 } else { 102 err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount), 103 EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino); 104 if (err) { 105 if (err == ENOENT && nameiop != CREATE) 106 cache_enter(ap->a_dvp, NULL, cnp); 107 if (err == ENOENT && (nameiop == CREATE || 108 nameiop == RENAME)) { 109 err = VOP_ACCESS(ap->a_dvp, VWRITE, 110 cnp->cn_cred); 111 if (err) 112 return (err); 113 return (EJUSTRETURN); 114 } 115 return (err); 116 } 117 err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp); 118 if (err) 119 return (err); 120 *ap->a_vpp = vp; 121 } 122 123 cache_enter(ap->a_dvp, *ap->a_vpp, cnp); 124 125 return 0; 126 } 127 128 static int 129 efs_check_possible(struct vnode *vp, struct efs_inode *eip, mode_t mode) 130 { 131 132 if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) 133 return (EROFS); 134 135 return 0; 136 } 137 138 /* 139 * Determine the accessiblity of a file based on the permissions allowed by the 140 * specified credentials. 141 * 142 * Returns 0 on success. 143 */ 144 static int 145 efs_check_permitted(struct vnode *vp, struct efs_inode *eip, mode_t mode, 146 kauth_cred_t cred) 147 { 148 149 return genfs_can_access(vp->v_type, eip->ei_mode, eip->ei_uid, 150 eip->ei_gid, mode, cred); 151 } 152 153 static int 154 efs_access(void *v) 155 { 156 struct vop_access_args /* { 157 const struct vnodeop_desc *a_desc; 158 struct vnode *a_vp; 159 int a_mode; 160 struct ucred *a_cred; 161 } */ *ap = v; 162 struct vnode *vp = ap->a_vp; 163 struct efs_inode *eip = EFS_VTOI(vp); 164 int error; 165 166 error = efs_check_possible(vp, eip, ap->a_mode); 167 if (error) 168 return error; 169 170 error = efs_check_permitted(vp, eip, ap->a_mode, ap->a_cred); 171 172 return error; 173 } 174 175 /* 176 * Get specific vnode attributes on a file. See vattr(9). 177 * 178 * Returns 0 on success. 179 */ 180 static int 181 efs_getattr(void *v) 182 { 183 struct vop_getattr_args /* { 184 const struct vnodeop_desc *a_desc; 185 struct vnode *a_vp; 186 struct vattr *a_vap; 187 struct ucred *a_cred; 188 } */ *ap = v; 189 190 struct vattr *vap = ap->a_vap; 191 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 192 193 vattr_null(ap->a_vap); 194 vap->va_type = ap->a_vp->v_type; 195 vap->va_mode = eip->ei_mode; 196 vap->va_nlink = eip->ei_nlink; 197 vap->va_uid = eip->ei_uid; 198 vap->va_gid = eip->ei_gid; 199 vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid; 200 vap->va_fileid = eip->ei_number; 201 vap->va_size = eip->ei_size; 202 203 if (ap->a_vp->v_type == VBLK) 204 vap->va_blocksize = BLKDEV_IOSIZE; 205 else if (ap->a_vp->v_type == VCHR) 206 vap->va_blocksize = MAXBSIZE; 207 else 208 vap->va_blocksize = EFS_BB_SIZE; 209 210 vap->va_atime.tv_sec = eip->ei_atime; 211 vap->va_mtime.tv_sec = eip->ei_mtime; 212 vap->va_ctime.tv_sec = eip->ei_ctime; 213 /* vap->va_birthtime = */ 214 vap->va_gen = eip->ei_gen; 215 vap->va_flags = ap->a_vp->v_vflag | 216 ap->a_vp->v_iflag | ap->a_vp->v_uflag; 217 218 if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR) { 219 uint32_t dmaj, dmin; 220 221 if (be16toh(eip->ei_di.di_odev) != EFS_DINODE_ODEV_INVALID) { 222 dmaj = EFS_DINODE_ODEV_MAJ(be16toh(eip->ei_di.di_odev)); 223 dmin = EFS_DINODE_ODEV_MIN(be16toh(eip->ei_di.di_odev)); 224 } else { 225 dmaj = EFS_DINODE_NDEV_MAJ(be32toh(eip->ei_di.di_ndev)); 226 dmin = EFS_DINODE_NDEV_MIN(be32toh(eip->ei_di.di_ndev)); 227 } 228 229 vap->va_rdev = makedev(dmaj, dmin); 230 } 231 232 vap->va_bytes = eip->ei_size; 233 /* vap->va_filerev = */ 234 /* vap->va_vaflags = */ 235 236 return (0); 237 } 238 239 /* 240 * Read a file. 241 * 242 * Returns 0 on success. 243 */ 244 static int 245 efs_read(void *v) 246 { 247 struct vop_read_args /* { 248 const struct vnodeop_desc *a_desc; 249 struct vnode *a_vp; 250 struct uio *a_uio; 251 int a_ioflag; 252 struct ucred *a_cred; 253 } */ *ap = v; 254 struct efs_extent ex; 255 struct efs_extent_iterator exi; 256 struct uio *uio = ap->a_uio; 257 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 258 off_t start; 259 vsize_t len; 260 int err, ret; 261 const int advice = IO_ADV_DECODE(ap->a_ioflag); 262 263 if (ap->a_vp->v_type == VDIR) 264 return (EISDIR); 265 266 if (ap->a_vp->v_type != VREG) 267 return (EINVAL); 268 269 efs_extent_iterator_init(&exi, eip, uio->uio_offset); 270 ret = efs_extent_iterator_next(&exi, &ex); 271 while (ret == 0) { 272 if (uio->uio_offset < 0 || uio->uio_offset >= eip->ei_size || 273 uio->uio_resid == 0) 274 break; 275 276 start = ex.ex_offset * EFS_BB_SIZE; 277 len = ex.ex_length * EFS_BB_SIZE; 278 279 if (!(uio->uio_offset >= start && 280 uio->uio_offset < (start + len))) { 281 ret = efs_extent_iterator_next(&exi, &ex); 282 continue; 283 } 284 285 start = uio->uio_offset - start; 286 287 len = MIN(len - start, uio->uio_resid); 288 len = MIN(len, eip->ei_size - uio->uio_offset); 289 290 err = ubc_uiomove(&ap->a_vp->v_uobj, uio, len, advice, 291 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(ap->a_vp)); 292 if (err) { 293 EFS_DPRINTF(("efs_read: uiomove error %d\n", 294 err)); 295 return (err); 296 } 297 } 298 299 return ((ret == -1) ? 0 : ret); 300 } 301 302 static int 303 efs_readdir(void *v) 304 { 305 struct vop_readdir_args /* { 306 const struct vnodeop_desc *a_desc; 307 struct vnode *a_vp; 308 struct uio *a_uio; 309 struct ucred *a_cred; 310 int *a_eofflag; 311 off_t **a_cookies; 312 int *a_ncookies; 313 } */ *ap = v; 314 struct dirent *dp; 315 struct efs_dinode edi; 316 struct efs_extent ex; 317 struct efs_extent_iterator exi; 318 struct buf *bp; 319 struct efs_dirent *de; 320 struct efs_dirblk *db; 321 struct uio *uio = ap->a_uio; 322 struct efs_inode *ei = EFS_VTOI(ap->a_vp); 323 off_t *cookies = NULL; 324 off_t offset; 325 int i, j, err, ret, s, slot, ncookies, maxcookies = 0; 326 327 if (ap->a_vp->v_type != VDIR) 328 return (ENOTDIR); 329 330 if (ap->a_eofflag != NULL) 331 *ap->a_eofflag = false; 332 333 if (ap->a_ncookies != NULL) { 334 ncookies = 0; 335 maxcookies = 336 uio->uio_resid / _DIRENT_MINSIZE((struct dirent *)0); 337 cookies = malloc(maxcookies * sizeof(off_t), M_TEMP, M_WAITOK); 338 } 339 340 dp = malloc(sizeof(struct dirent), M_EFSTMP, M_WAITOK | M_ZERO); 341 342 offset = 0; 343 efs_extent_iterator_init(&exi, ei, 0); 344 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) { 345 for (i = 0; i < ex.ex_length; i++) { 346 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount), 347 ex.ex_bn + i, NULL, &bp); 348 if (err) { 349 brelse(bp, 0); 350 goto exit_err; 351 } 352 353 db = (struct efs_dirblk *)bp->b_data; 354 355 if (be16toh(db->db_magic) != EFS_DIRBLK_MAGIC) { 356 printf("efs_readdir: bad dirblk\n"); 357 brelse(bp, 0); 358 continue; 359 } 360 361 for (j = 0; j < db->db_slots; j++) { 362 slot = EFS_DIRENT_OFF_EXPND(db->db_space[j]); 363 if (slot == EFS_DIRBLK_SLOT_FREE) 364 continue; 365 366 if (!EFS_DIRENT_OFF_VALID(slot)) { 367 printf("efs_readdir: bad dirent\n"); 368 continue; 369 } 370 371 de = EFS_DIRBLK_TO_DIRENT(db, slot); 372 s = _DIRENT_RECLEN(dp, de->de_namelen); 373 374 if (offset < uio->uio_offset) { 375 offset += s; 376 continue; 377 } 378 379 /* XXX - shouldn't happen, right? */ 380 if (offset > uio->uio_offset || 381 s > uio->uio_resid) { 382 brelse(bp, 0); 383 goto exit_ok; 384 } 385 386 /* de_namelen is uint8_t, d.d_name is 512b */ 387 KASSERT(sizeof(dp->d_name)-de->de_namelen > 0); 388 dp->d_fileno = be32toh(de->de_inumber); 389 dp->d_reclen = s; 390 dp->d_namlen = de->de_namelen; 391 memcpy(dp->d_name, de->de_name, 392 de->de_namelen); 393 dp->d_name[de->de_namelen] = '\0'; 394 395 /* look up inode to get type */ 396 err = efs_read_inode( 397 VFSTOEFS(ap->a_vp->v_mount), 398 dp->d_fileno, NULL, &edi); 399 if (err) { 400 brelse(bp, 0); 401 goto exit_err; 402 } 403 404 switch (be16toh(edi.di_mode) & EFS_IFMT) { 405 case EFS_IFIFO: 406 dp->d_type = DT_FIFO; 407 break; 408 case EFS_IFCHR: 409 dp->d_type = DT_CHR; 410 break; 411 case EFS_IFDIR: 412 dp->d_type = DT_DIR; 413 break; 414 case EFS_IFBLK: 415 dp->d_type = DT_BLK; 416 break; 417 case EFS_IFREG: 418 dp->d_type = DT_REG; 419 break; 420 case EFS_IFLNK: 421 dp->d_type = DT_LNK; 422 break; 423 case EFS_IFSOCK: 424 dp->d_type = DT_SOCK; 425 break; 426 default: 427 dp->d_type = DT_UNKNOWN; 428 break; 429 } 430 431 err = uiomove(dp, s, uio); 432 if (err) { 433 brelse(bp, 0); 434 goto exit_err; 435 } 436 437 offset += s; 438 439 if (cookies != NULL && maxcookies != 0) { 440 cookies[ncookies++] = offset; 441 if (ncookies == maxcookies) { 442 brelse(bp, 0); 443 goto exit_ok; 444 } 445 } 446 } 447 448 brelse(bp, 0); 449 } 450 } 451 452 if (ret != -1) { 453 err = ret; 454 goto exit_err; 455 } 456 457 if (ap->a_eofflag != NULL) 458 *ap->a_eofflag = true; 459 460 exit_ok: 461 if (cookies != NULL) { 462 *ap->a_cookies = cookies; 463 *ap->a_ncookies = ncookies; 464 } 465 466 uio->uio_offset = offset; 467 468 free(dp, M_EFSTMP); 469 470 return (0); 471 472 exit_err: 473 if (cookies != NULL) 474 free(cookies, M_TEMP); 475 476 free(dp, M_EFSTMP); 477 478 return (err); 479 } 480 481 static int 482 efs_readlink(void *v) 483 { 484 struct vop_readlink_args /* { 485 const struct vnodeop_desc *a_desc; 486 struct vnode *a_vp; 487 struct uio *a_uio; 488 struct ucred *a_cred; 489 } */ *ap = v; 490 struct uio *uio = ap->a_uio; 491 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 492 char *buf; 493 size_t len; 494 int err, i; 495 496 if ((eip->ei_mode & EFS_IFMT) != EFS_IFLNK) 497 return (EINVAL); 498 499 if (uio->uio_resid < 1) 500 return (EINVAL); 501 502 buf = malloc(eip->ei_size + 1, M_EFSTMP, M_ZERO | M_WAITOK); 503 504 /* symlinks are either inlined in the inode, or in extents */ 505 if (eip->ei_numextents == 0) { 506 if (eip->ei_size > sizeof(eip->ei_di.di_symlink)) { 507 EFS_DPRINTF(("efs_readlink: too big for inline\n")); 508 free(buf, M_EFSTMP); 509 return (EBADF); 510 } 511 512 memcpy(buf, eip->ei_di.di_symlink, eip->ei_size); 513 len = MIN(uio->uio_resid, eip->ei_size + 1); 514 } else { 515 struct efs_extent_iterator exi; 516 struct efs_extent ex; 517 struct buf *bp; 518 int resid, off, ret; 519 520 off = 0; 521 resid = eip->ei_size; 522 523 efs_extent_iterator_init(&exi, eip, 0); 524 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) { 525 for (i = 0; i < ex.ex_length; i++) { 526 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount), 527 ex.ex_bn + i, NULL, &bp); 528 if (err) { 529 brelse(bp, 0); 530 free(buf, M_EFSTMP); 531 return (err); 532 } 533 534 len = MIN(resid, bp->b_bcount); 535 memcpy(buf + off, bp->b_data, len); 536 brelse(bp, 0); 537 538 off += len; 539 resid -= len; 540 541 if (resid == 0) 542 break; 543 } 544 545 if (resid == 0) 546 break; 547 } 548 549 if (ret != 0 && ret != -1) { 550 free(buf, M_EFSTMP); 551 return (ret); 552 } 553 554 len = off + 1; 555 } 556 557 KASSERT(len >= 1 && len <= (eip->ei_size + 1)); 558 buf[len - 1] = '\0'; 559 err = uiomove(buf, len, uio); 560 free(buf, M_EFSTMP); 561 562 return (err); 563 } 564 565 /* 566 * Release an inactive vnode. The vnode _must_ be unlocked on return. 567 * It is either nolonger being used by the kernel, or an unmount is being 568 * forced. 569 * 570 * Returns 0 on success. 571 */ 572 static int 573 efs_inactive(void *v) 574 { 575 struct vop_inactive_args /* { 576 const struct vnodeop_desc *a_desc; 577 struct vnode *a_vp; 578 bool *a_recycle 579 } */ *ap = v; 580 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 581 582 *ap->a_recycle = (eip->ei_mode == 0); 583 VOP_UNLOCK(ap->a_vp); 584 585 return (0); 586 } 587 588 static int 589 efs_reclaim(void *v) 590 { 591 struct vop_reclaim_args /* { 592 const struct vnodeop_desc *a_desc; 593 struct vnode *a_vp; 594 } */ *ap = v; 595 struct vnode *vp = ap->a_vp; 596 597 efs_ihashrem(EFS_VTOI(vp)); 598 genfs_node_destroy(vp); 599 pool_put(&efs_inode_pool, vp->v_data); 600 vp->v_data = NULL; 601 602 return (0); 603 } 604 605 static int 606 efs_bmap(void *v) 607 { 608 struct vop_bmap_args /* { 609 const struct vnodeop_desc *a_desc; 610 struct vnode *a_vp; 611 daddr_t a_bn; 612 struct vnode **a_vpp; 613 daddr_t *a_bnp; 614 int *a_runp; 615 } */ *ap = v; 616 struct efs_extent ex; 617 struct efs_extent_iterator exi; 618 struct vnode *vp = ap->a_vp; 619 struct efs_inode *eip = EFS_VTOI(vp); 620 bool found; 621 int ret; 622 623 if (ap->a_vpp != NULL) 624 *ap->a_vpp = VFSTOEFS(vp->v_mount)->em_devvp; 625 626 found = false; 627 efs_extent_iterator_init(&exi, eip, ap->a_bn * EFS_BB_SIZE); 628 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) { 629 if (ap->a_bn >= ex.ex_offset && 630 ap->a_bn < (ex.ex_offset + ex.ex_length)) { 631 found = true; 632 break; 633 } 634 } 635 636 KASSERT(!found || (found && ret == 0)); 637 638 if (!found) { 639 EFS_DPRINTF(("efs_bmap: ap->a_bn not in extents\n")); 640 return ((ret == -1) ? EIO : ret); 641 } 642 643 if (ex.ex_magic != EFS_EXTENT_MAGIC) { 644 EFS_DPRINTF(("efs_bmap: exn.ex_magic != EFS_EXTENT_MAGIC\n")); 645 return (EIO); 646 } 647 648 if (ap->a_bn < ex.ex_offset) { 649 EFS_DPRINTF(("efs_bmap: ap->a_bn < exn.ex_offset\n")); 650 return (EIO); 651 } 652 653 KASSERT(ap->a_bn >= ex.ex_offset); 654 KASSERT(ex.ex_length > ap->a_bn - ex.ex_offset); 655 656 *ap->a_bnp = ex.ex_bn + (ap->a_bn - ex.ex_offset); 657 if (ap->a_runp != NULL) 658 *ap->a_runp = ex.ex_length - (ap->a_bn - ex.ex_offset) - 1; 659 660 return (0); 661 } 662 663 static int 664 efs_strategy(void *v) 665 { 666 struct vop_strategy_args /* { 667 const struct vnodeop_desc *a_desc; 668 struct vnode *a_vp; 669 struct buf *a_bp; 670 } */ *ap = v; 671 struct vnode *vp = ap->a_vp; 672 struct buf *bp = ap->a_bp; 673 int error; 674 675 if (vp == NULL) { 676 bp->b_error = EIO; 677 biodone(bp); 678 return (EIO); 679 } 680 681 if (bp->b_blkno == bp->b_lblkno) { 682 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL); 683 if (error) { 684 bp->b_error = error; 685 biodone(bp); 686 return (error); 687 } 688 if ((long)bp->b_blkno == -1) 689 clrbuf(bp); 690 } 691 692 if ((long)bp->b_blkno == -1) { 693 biodone(bp); 694 return (0); 695 } 696 697 return (VOP_STRATEGY(VFSTOEFS(vp->v_mount)->em_devvp, bp)); 698 } 699 700 static int 701 efs_print(void *v) 702 { 703 struct vop_print_args /* { 704 const struct vnodeop_desc *a_desc; 705 struct vnode *a_vp; 706 } */ *ap = v; 707 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 708 709 printf( "efs_inode (ino %lu):\n" 710 " ei_mode: %07o\n" 711 " ei_nlink: %d\n" 712 " ei_uid: %d\n" 713 " ei_gid: %d\n" 714 " ei_size: %d\n" 715 " ei_atime: %d\n" 716 " ei_mtime: %d\n" 717 " ei_ctime: %d\n" 718 " ei_gen: %d\n" 719 " ei_numextents: %d\n" 720 " ei_version: %d\n", 721 (unsigned long)eip->ei_number, 722 (unsigned int)eip->ei_mode, 723 eip->ei_nlink, 724 eip->ei_uid, 725 eip->ei_gid, 726 eip->ei_size, 727 (int32_t)eip->ei_atime, 728 (int32_t)eip->ei_mtime, 729 (int32_t)eip->ei_ctime, 730 eip->ei_gen, 731 eip->ei_numextents, 732 eip->ei_version); 733 734 return (0); 735 } 736 737 static int 738 efs_pathconf(void *v) 739 { 740 struct vop_pathconf_args /* { 741 const struct vnodeop_desc *a_desc; 742 struct vnode *a_vp; 743 int a_name; 744 register_t *a_retval; 745 } */ *ap = v; 746 747 /* IRIX 4 values */ 748 switch (ap->a_name) { 749 case _PC_LINK_MAX: 750 *ap->a_retval = 30000; 751 break; 752 case _PC_NAME_MAX: 753 *ap->a_retval = 255; 754 break; 755 case _PC_PATH_MAX: 756 *ap->a_retval = 1024; 757 break; 758 case _PC_NO_TRUNC: 759 *ap->a_retval = 1; 760 break; 761 case _PC_CHOWN_RESTRICTED: 762 *ap->a_retval = 1; 763 break; 764 case _PC_SYNC_IO: 765 *ap->a_retval = 1; 766 break; 767 case _PC_FILESIZEBITS: 768 *ap->a_retval = 32; 769 break; 770 default: 771 return (EINVAL); 772 } 773 774 return (0); 775 } 776 777 static int 778 efs_advlock(void *v) 779 { 780 struct vop_advlock_args /* { 781 const struct vnodeop_desc *a_desc; 782 struct vnode *a_vp; 783 void *a_id; 784 int a_op; 785 struct flock *a_fl; 786 int a_flags; 787 } */ *ap = v; 788 struct efs_inode *eip = EFS_VTOI(ap->a_vp); 789 790 return (lf_advlock(ap, &eip->ei_lockf, eip->ei_size)); 791 } 792 793 /* Global vfs data structures for efs */ 794 int (**efs_vnodeop_p)(void *); 795 const struct vnodeopv_entry_desc efs_vnodeop_entries[] = { 796 { &vop_default_desc, vn_default_error}, /* error handler */ 797 { &vop_lookup_desc, efs_lookup }, /* lookup */ 798 { &vop_create_desc, genfs_eopnotsupp}, /* create */ 799 { &vop_mknod_desc, genfs_eopnotsupp}, /* mknod */ 800 { &vop_open_desc, genfs_nullop }, /* open */ 801 { &vop_close_desc, genfs_nullop }, /* close */ 802 { &vop_access_desc, efs_access }, /* access */ 803 { &vop_getattr_desc, efs_getattr }, /* getattr */ 804 { &vop_setattr_desc, genfs_eopnotsupp}, /* setattr */ 805 { &vop_read_desc, efs_read }, /* read */ 806 { &vop_write_desc, genfs_eopnotsupp}, /* write */ 807 { &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */ 808 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ 809 { &vop_poll_desc, genfs_poll }, /* poll */ 810 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */ 811 { &vop_revoke_desc, genfs_revoke }, /* revoke */ 812 { &vop_mmap_desc, genfs_mmap }, /* mmap */ 813 { &vop_fsync_desc, genfs_eopnotsupp}, /* fsync */ 814 { &vop_seek_desc, genfs_seek }, /* seek */ 815 { &vop_remove_desc, genfs_eopnotsupp}, /* remove */ 816 { &vop_link_desc, genfs_eopnotsupp}, /* link */ 817 { &vop_rename_desc, genfs_eopnotsupp}, /* rename */ 818 { &vop_mkdir_desc, genfs_eopnotsupp}, /* mkdir */ 819 { &vop_rmdir_desc, genfs_eopnotsupp}, /* rmdir */ 820 { &vop_symlink_desc, genfs_eopnotsupp}, /* symlink */ 821 { &vop_readdir_desc, efs_readdir }, /* readdir */ 822 { &vop_readlink_desc, efs_readlink }, /* readlink */ 823 { &vop_abortop_desc, genfs_abortop }, /* abortop */ 824 { &vop_inactive_desc, efs_inactive }, /* inactive */ 825 { &vop_reclaim_desc, efs_reclaim }, /* reclaim */ 826 { &vop_lock_desc, genfs_lock, }, /* lock */ 827 { &vop_unlock_desc, genfs_unlock, }, /* unlock */ 828 { &vop_islocked_desc, genfs_islocked, }, /* islocked */ 829 { &vop_bmap_desc, efs_bmap }, /* bmap */ 830 { &vop_print_desc, efs_print }, /* print */ 831 { &vop_pathconf_desc, efs_pathconf }, /* pathconf */ 832 { &vop_advlock_desc, efs_advlock }, /* advlock */ 833 /* blkatoff */ 834 /* valloc */ 835 /* balloc */ 836 /* vfree */ 837 /* truncate */ 838 /* whiteout */ 839 { &vop_getpages_desc, genfs_getpages }, /* getpages */ 840 { &vop_putpages_desc, genfs_putpages }, /* putpages */ 841 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 842 { &vop_strategy_desc, efs_strategy }, /* strategy */ 843 { NULL, NULL } 844 }; 845 const struct vnodeopv_desc efs_vnodeop_opv_desc = { 846 &efs_vnodeop_p, 847 efs_vnodeop_entries 848 }; 849 850 int (**efs_specop_p)(void *); 851 const struct vnodeopv_entry_desc efs_specop_entries[] = { 852 { &vop_default_desc, vn_default_error}, /* error handler */ 853 { &vop_lookup_desc, spec_lookup }, /* lookup */ 854 { &vop_create_desc, spec_create }, /* create */ 855 { &vop_mknod_desc, spec_mknod }, /* mknod */ 856 { &vop_open_desc, spec_open }, /* open */ 857 { &vop_close_desc, spec_close }, /* close */ 858 { &vop_access_desc, efs_access }, /* access */ 859 { &vop_getattr_desc, efs_getattr }, /* getattr */ 860 { &vop_setattr_desc, genfs_eopnotsupp}, /* setattr */ 861 { &vop_read_desc, spec_read }, /* read */ 862 { &vop_write_desc, spec_write }, /* write */ 863 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 864 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ 865 { &vop_poll_desc, spec_poll }, /* poll */ 866 { &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */ 867 { &vop_revoke_desc, spec_revoke }, /* revoke */ 868 { &vop_mmap_desc, spec_mmap }, /* mmap */ 869 { &vop_fsync_desc, spec_fsync }, /* fsync */ 870 { &vop_seek_desc, spec_seek }, /* seek */ 871 { &vop_remove_desc, spec_remove }, /* remove */ 872 { &vop_link_desc, spec_link }, /* link */ 873 { &vop_rename_desc, spec_rename }, /* rename */ 874 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ 875 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ 876 { &vop_symlink_desc, spec_symlink }, /* symlink */ 877 { &vop_readdir_desc, spec_readdir }, /* readdir */ 878 { &vop_readlink_desc, spec_readlink }, /* readlink */ 879 { &vop_abortop_desc, spec_abortop }, /* abortop */ 880 { &vop_inactive_desc, efs_inactive }, /* inactive */ 881 { &vop_reclaim_desc, efs_reclaim }, /* reclaim */ 882 { &vop_lock_desc, genfs_lock, }, /* lock */ 883 { &vop_unlock_desc, genfs_unlock, }, /* unlock */ 884 { &vop_islocked_desc, genfs_islocked, }, /* islocked */ 885 { &vop_bmap_desc, spec_bmap }, /* bmap */ 886 { &vop_print_desc, efs_print }, /* print */ 887 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 888 { &vop_advlock_desc, spec_advlock }, /* advlock */ 889 /* blkatoff */ 890 /* valloc */ 891 /* balloc */ 892 /* vfree */ 893 /* truncate */ 894 /* whiteout */ 895 { &vop_getpages_desc, spec_getpages }, /* getpages */ 896 { &vop_putpages_desc, spec_putpages }, /* putpages */ 897 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 898 { &vop_strategy_desc, spec_strategy }, /* strategy */ 899 { NULL, NULL } 900 }; 901 const struct vnodeopv_desc efs_specop_opv_desc = { 902 &efs_specop_p, 903 efs_specop_entries 904 }; 905 906 int (**efs_fifoop_p)(void *); 907 const struct vnodeopv_entry_desc efs_fifoop_entries[] = { 908 { &vop_default_desc, vn_default_error}, /* error handler */ 909 { &vop_lookup_desc, vn_fifo_bypass }, /* lookup */ 910 { &vop_create_desc, vn_fifo_bypass }, /* create */ 911 { &vop_mknod_desc, vn_fifo_bypass }, /* mknod */ 912 { &vop_open_desc, vn_fifo_bypass }, /* open */ 913 { &vop_close_desc, vn_fifo_bypass }, /* close */ 914 { &vop_access_desc, efs_access }, /* access */ 915 { &vop_getattr_desc, efs_getattr }, /* getattr */ 916 { &vop_setattr_desc, genfs_eopnotsupp}, /* setattr */ 917 { &vop_read_desc, vn_fifo_bypass }, /* read */ 918 { &vop_write_desc, vn_fifo_bypass }, /* write */ 919 { &vop_ioctl_desc, vn_fifo_bypass }, /* ioctl */ 920 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ 921 { &vop_poll_desc, vn_fifo_bypass }, /* poll */ 922 { &vop_kqfilter_desc, vn_fifo_bypass }, /* kqfilter */ 923 { &vop_revoke_desc, vn_fifo_bypass }, /* revoke */ 924 { &vop_mmap_desc, vn_fifo_bypass }, /* mmap */ 925 { &vop_fsync_desc, vn_fifo_bypass }, /* fsync */ 926 { &vop_seek_desc, vn_fifo_bypass }, /* seek */ 927 { &vop_remove_desc, vn_fifo_bypass }, /* remove */ 928 { &vop_link_desc, vn_fifo_bypass }, /* link */ 929 { &vop_rename_desc, vn_fifo_bypass }, /* rename */ 930 { &vop_mkdir_desc, vn_fifo_bypass }, /* mkdir */ 931 { &vop_rmdir_desc, vn_fifo_bypass }, /* rmdir */ 932 { &vop_symlink_desc, vn_fifo_bypass }, /* symlink */ 933 { &vop_readdir_desc, vn_fifo_bypass }, /* readdir */ 934 { &vop_readlink_desc, vn_fifo_bypass }, /* readlink */ 935 { &vop_abortop_desc, vn_fifo_bypass }, /* abortop */ 936 { &vop_inactive_desc, efs_inactive }, /* inactive */ 937 { &vop_reclaim_desc, efs_reclaim }, /* reclaim */ 938 { &vop_lock_desc, genfs_lock, }, /* lock */ 939 { &vop_unlock_desc, genfs_unlock, }, /* unlock */ 940 { &vop_islocked_desc, genfs_islocked, }, /* islocked */ 941 { &vop_bmap_desc, vn_fifo_bypass }, /* bmap */ 942 { &vop_print_desc, efs_print }, /* print */ 943 { &vop_pathconf_desc, vn_fifo_bypass }, /* pathconf */ 944 { &vop_advlock_desc, vn_fifo_bypass }, /* advlock */ 945 /* blkatoff */ 946 /* valloc */ 947 /* balloc */ 948 /* vfree */ 949 /* truncate */ 950 /* whiteout */ 951 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 952 { &vop_strategy_desc, vn_fifo_bypass }, /* strategy */ 953 { NULL, NULL } 954 }; 955 const struct vnodeopv_desc efs_fifoop_opv_desc = { 956 &efs_fifoop_p, 957 efs_fifoop_entries 958 }; 959
Indexes created Sat Oct 25 16:10:12 GMT 2025