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