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