advnops.c revision 1.1
1 /* $NetBSD: advnops.c,v 1.1 2002/12/23 17:15:26 jdolecek Exp $ */ 2 3 /* 4 * Copyright (c) 1994 Christian E. Hopps 5 * Copyright (c) 1996 Matthias Scheler 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by Christian E. Hopps. 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission 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, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: advnops.c,v 1.1 2002/12/23 17:15:26 jdolecek Exp $"); 36 37 #if defined(_KERNEL_OPT) 38 #include "opt_quota.h" 39 #endif 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/vnode.h> 44 #include <sys/mount.h> 45 #include <sys/time.h> 46 #include <sys/queue.h> 47 #include <sys/namei.h> 48 #include <sys/buf.h> 49 #include <sys/dirent.h> 50 #include <sys/malloc.h> 51 #include <sys/pool.h> 52 #include <sys/stat.h> 53 #include <sys/unistd.h> 54 #include <sys/proc.h> 55 56 #include <miscfs/genfs/genfs.h> 57 #include <miscfs/specfs/specdev.h> 58 #include <fs/adosfs/adosfs.h> 59 60 extern struct vnodeops adosfs_vnodeops; 61 62 #define adosfs_open genfs_nullop 63 int adosfs_getattr __P((void *)); 64 int adosfs_read __P((void *)); 65 int adosfs_write __P((void *)); 66 #define adosfs_fcntl genfs_fcntl 67 #define adosfs_ioctl genfs_enoioctl 68 #define adosfs_poll genfs_poll 69 int adosfs_strategy __P((void *)); 70 int adosfs_link __P((void *)); 71 int adosfs_symlink __P((void *)); 72 #define adosfs_abortop genfs_abortop 73 int adosfs_bmap __P((void *)); 74 int adosfs_print __P((void *)); 75 int adosfs_readdir __P((void *)); 76 int adosfs_access __P((void *)); 77 int adosfs_readlink __P((void *)); 78 int adosfs_inactive __P((void *)); 79 int adosfs_reclaim __P((void *)); 80 int adosfs_pathconf __P((void *)); 81 82 #define adosfs_close genfs_nullop 83 #define adosfs_fsync genfs_nullop 84 #define adosfs_lease_check genfs_lease_check 85 #define adosfs_seek genfs_seek 86 #define adosfs_vfree genfs_nullop 87 88 #define adosfs_advlock genfs_einval 89 #define adosfs_blkatoff genfs_eopnotsupp 90 #define adosfs_bwrite genfs_eopnotsupp 91 #define adosfs_create genfs_eopnotsupp 92 #define adosfs_mkdir genfs_eopnotsupp 93 #define adosfs_mknod genfs_eopnotsupp 94 #define adosfs_revoke genfs_revoke 95 #define adosfs_mmap genfs_mmap 96 #define adosfs_remove genfs_eopnotsupp 97 #define adosfs_rename genfs_eopnotsupp 98 #define adosfs_rmdir genfs_eopnotsupp 99 #define adosfs_setattr genfs_eopnotsupp 100 #define adosfs_truncate genfs_eopnotsupp 101 #define adosfs_update genfs_nullop 102 #define adosfs_valloc genfs_eopnotsupp 103 104 const struct vnodeopv_entry_desc adosfs_vnodeop_entries[] = { 105 { &vop_default_desc, vn_default_error }, 106 { &vop_lookup_desc, adosfs_lookup }, /* lookup */ 107 { &vop_create_desc, adosfs_create }, /* create */ 108 { &vop_mknod_desc, adosfs_mknod }, /* mknod */ 109 { &vop_open_desc, adosfs_open }, /* open */ 110 { &vop_close_desc, adosfs_close }, /* close */ 111 { &vop_access_desc, adosfs_access }, /* access */ 112 { &vop_getattr_desc, adosfs_getattr }, /* getattr */ 113 { &vop_setattr_desc, adosfs_setattr }, /* setattr */ 114 { &vop_read_desc, adosfs_read }, /* read */ 115 { &vop_write_desc, adosfs_write }, /* write */ 116 { &vop_lease_desc, adosfs_lease_check }, /* lease */ 117 { &vop_fcntl_desc, adosfs_fcntl }, /* fcntl */ 118 { &vop_ioctl_desc, adosfs_ioctl }, /* ioctl */ 119 { &vop_poll_desc, adosfs_poll }, /* poll */ 120 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */ 121 { &vop_revoke_desc, adosfs_revoke }, /* revoke */ 122 { &vop_mmap_desc, adosfs_mmap }, /* mmap */ 123 { &vop_fsync_desc, adosfs_fsync }, /* fsync */ 124 { &vop_seek_desc, adosfs_seek }, /* seek */ 125 { &vop_remove_desc, adosfs_remove }, /* remove */ 126 { &vop_link_desc, adosfs_link }, /* link */ 127 { &vop_rename_desc, adosfs_rename }, /* rename */ 128 { &vop_mkdir_desc, adosfs_mkdir }, /* mkdir */ 129 { &vop_rmdir_desc, adosfs_rmdir }, /* rmdir */ 130 { &vop_symlink_desc, adosfs_symlink }, /* symlink */ 131 { &vop_readdir_desc, adosfs_readdir }, /* readdir */ 132 { &vop_readlink_desc, adosfs_readlink }, /* readlink */ 133 { &vop_abortop_desc, adosfs_abortop }, /* abortop */ 134 { &vop_inactive_desc, adosfs_inactive }, /* inactive */ 135 { &vop_reclaim_desc, adosfs_reclaim }, /* reclaim */ 136 { &vop_lock_desc, genfs_lock }, /* lock */ 137 { &vop_unlock_desc, genfs_unlock }, /* unlock */ 138 { &vop_bmap_desc, adosfs_bmap }, /* bmap */ 139 { &vop_strategy_desc, adosfs_strategy }, /* strategy */ 140 { &vop_print_desc, adosfs_print }, /* print */ 141 { &vop_islocked_desc, genfs_islocked }, /* islocked */ 142 { &vop_pathconf_desc, adosfs_pathconf }, /* pathconf */ 143 { &vop_advlock_desc, adosfs_advlock }, /* advlock */ 144 { &vop_blkatoff_desc, adosfs_blkatoff }, /* blkatoff */ 145 { &vop_valloc_desc, adosfs_valloc }, /* valloc */ 146 { &vop_vfree_desc, adosfs_vfree }, /* vfree */ 147 { &vop_truncate_desc, adosfs_truncate }, /* truncate */ 148 { &vop_update_desc, adosfs_update }, /* update */ 149 { &vop_bwrite_desc, adosfs_bwrite }, /* bwrite */ 150 { &vop_getpages_desc, genfs_getpages }, /* getpages */ 151 { &vop_putpages_desc, genfs_putpages }, /* putpages */ 152 { NULL, NULL } 153 }; 154 155 const struct vnodeopv_desc adosfs_vnodeop_opv_desc = 156 { &adosfs_vnodeop_p, adosfs_vnodeop_entries }; 157 158 int 159 adosfs_getattr(v) 160 void *v; 161 { 162 struct vop_getattr_args /* { 163 struct vnode *a_vp; 164 struct vattr *a_vap; 165 struct ucred *a_cred; 166 struct proc *a_p; 167 } */ *sp = v; 168 struct vattr *vap; 169 struct adosfsmount *amp; 170 struct anode *ap; 171 u_long fblks; 172 173 #ifdef ADOSFS_DIAGNOSTIC 174 advopprint(sp); 175 #endif 176 vap = sp->a_vap; 177 ap = VTOA(sp->a_vp); 178 amp = ap->amp; 179 vattr_null(vap); 180 vap->va_uid = ap->uid; 181 vap->va_gid = ap->gid; 182 vap->va_fsid = sp->a_vp->v_mount->mnt_stat.f_fsid.val[0]; 183 vap->va_atime.tv_sec = vap->va_mtime.tv_sec = vap->va_ctime.tv_sec = 184 ap->mtime.days * 24 * 60 * 60 + ap->mtime.mins * 60 + 185 ap->mtime.ticks / 50 + (8 * 365 + 2) * 24 * 60 * 60; 186 vap->va_atime.tv_nsec = vap->va_mtime.tv_nsec = vap->va_ctime.tv_nsec = 0; 187 vap->va_gen = 0; 188 vap->va_flags = 0; 189 vap->va_rdev = NODEV; 190 vap->va_fileid = ap->block; 191 vap->va_type = sp->a_vp->v_type; 192 vap->va_mode = adunixprot(ap->adprot) & amp->mask; 193 if (sp->a_vp->v_type == VDIR) { 194 vap->va_nlink = 1; /* XXX bogus, oh well */ 195 vap->va_bytes = amp->bsize; 196 vap->va_size = amp->bsize; 197 } else { 198 /* 199 * XXX actually we can track this if we were to walk the list 200 * of links if it exists. 201 * XXX for now, just set nlink to 2 if this is a hard link 202 * to a file, or a file with a hard link. 203 */ 204 vap->va_nlink = 1 + (ap->linkto != 0); 205 /* 206 * round up to nearest blocks add number of file list 207 * blocks needed and mutiply by number of bytes per block. 208 */ 209 fblks = howmany(ap->fsize, amp->dbsize); 210 fblks += howmany(fblks, ANODENDATBLKENT(ap)); 211 vap->va_bytes = fblks * amp->dbsize; 212 vap->va_size = ap->fsize; 213 214 vap->va_blocksize = amp->dbsize; 215 } 216 #ifdef ADOSFS_DIAGNOSTIC 217 printf(" 0)"); 218 #endif 219 return(0); 220 } 221 /* 222 * are things locked??? they need to be to avoid this being 223 * deleted or changed (data block pointer blocks moving about.) 224 */ 225 int 226 adosfs_read(v) 227 void *v; 228 { 229 struct vop_read_args /* { 230 struct vnode *a_vp; 231 struct uio *a_uio; 232 int a_ioflag; 233 struct ucred *a_cred; 234 } */ *sp = v; 235 struct vnode *vp = sp->a_vp; 236 struct adosfsmount *amp; 237 struct anode *ap; 238 struct uio *uio; 239 struct buf *bp; 240 daddr_t lbn; 241 int size, diff, error; 242 long n, on; 243 244 #ifdef ADOSFS_DIAGNOSTIC 245 advopprint(sp); 246 #endif 247 error = 0; 248 uio = sp->a_uio; 249 ap = VTOA(sp->a_vp); 250 amp = ap->amp; 251 /* 252 * Return EOF for character devices, EIO for others 253 */ 254 if (sp->a_vp->v_type != VREG) { 255 error = EIO; 256 goto reterr; 257 } 258 if (uio->uio_resid == 0) 259 goto reterr; 260 if (uio->uio_offset < 0) { 261 error = EINVAL; 262 goto reterr; 263 } 264 265 /* 266 * to expensive to let general algorithm figure out that 267 * we are beyond the file. Do it now. 268 */ 269 if (uio->uio_offset >= ap->fsize) 270 goto reterr; 271 272 /* 273 * taken from ufs_read() 274 */ 275 276 if (vp->v_type == VREG && IS_FFS(amp)) { 277 error = 0; 278 while (uio->uio_resid > 0) { 279 void *win; 280 vsize_t bytelen = MIN(ap->fsize - uio->uio_offset, 281 uio->uio_resid); 282 283 if (bytelen == 0) { 284 break; 285 } 286 win = ubc_alloc(&vp->v_uobj, uio->uio_offset, 287 &bytelen, UBC_READ); 288 error = uiomove(win, bytelen, uio); 289 ubc_release(win, 0); 290 if (error) { 291 break; 292 } 293 } 294 goto out; 295 } 296 297 do { 298 size = amp->dbsize; 299 lbn = uio->uio_offset / size; 300 on = uio->uio_offset % size; 301 n = MIN(size - on, uio->uio_resid); 302 diff = ap->fsize - uio->uio_offset; 303 /* 304 * check for EOF 305 */ 306 if (diff <= 0) 307 return(0); 308 if (diff < n) 309 n = diff; 310 /* 311 * read ahead could possibly be worth something 312 * but not much as ados makes little attempt to 313 * make things contigous 314 */ 315 error = bread(sp->a_vp, lbn * amp->bsize / DEV_BSIZE, 316 amp->bsize, NOCRED, &bp); 317 if (error) { 318 brelse(bp); 319 goto reterr; 320 } 321 if (!IS_FFS(amp)) { 322 if (bp->b_resid > 0) 323 error = EIO; /* OFS needs the complete block */ 324 else if (adoswordn(bp, 0) != BPT_DATA) { 325 #ifdef DIAGNOSTIC 326 printf("adosfs: bad primary type blk %ld\n", 327 bp->b_blkno / (amp->bsize / DEV_BSIZE)); 328 #endif 329 error = EINVAL; 330 } else if (adoscksum(bp, ap->nwords)) { 331 #ifdef DIAGNOSTIC 332 printf("adosfs: blk %ld failed cksum.\n", 333 bp->b_blkno / (amp->bsize / DEV_BSIZE)); 334 #endif 335 error = EINVAL; 336 } 337 } 338 339 if (error) { 340 brelse(bp); 341 goto reterr; 342 } 343 #ifdef ADOSFS_DIAGNOSTIC 344 printf(" %d+%d-%d+%d", lbn, on, lbn, n); 345 #endif 346 n = MIN(n, size - bp->b_resid); 347 error = uiomove(bp->b_data + on + 348 amp->bsize - amp->dbsize, (int)n, uio); 349 brelse(bp); 350 } while (error == 0 && uio->uio_resid > 0 && n != 0); 351 352 out: 353 reterr: 354 #ifdef ADOSFS_DIAGNOSTIC 355 printf(" %d)", error); 356 #endif 357 return(error); 358 } 359 360 int 361 adosfs_write(v) 362 void *v; 363 { 364 #ifdef ADOSFS_DIAGNOSTIC 365 struct vop_write_args /* { 366 struct vnode *a_vp; 367 struct uio *a_uio; 368 int a_ioflag; 369 struct ucred *a_cred; 370 } */ *sp = v; 371 advopprint(sp); 372 printf(" EOPNOTSUPP)"); 373 #endif 374 return(EOPNOTSUPP); 375 } 376 377 /* 378 * Just call the device strategy routine 379 */ 380 int 381 adosfs_strategy(v) 382 void *v; 383 { 384 struct vop_strategy_args /* { 385 struct buf *a_bp; 386 } */ *sp = v; 387 struct buf *bp; 388 struct anode *ap; 389 struct vnode *vp; 390 int error; 391 392 #ifdef ADOSFS_DIAGNOSTIC 393 advopprint(sp); 394 #endif 395 error = 0; 396 bp = sp->a_bp; 397 if (bp->b_vp == NULL) { 398 bp->b_flags |= B_ERROR; 399 biodone(bp); 400 error = EIO; 401 goto reterr; 402 } 403 vp = bp->b_vp; 404 ap = VTOA(vp); 405 if (bp->b_blkno == bp->b_lblkno) { 406 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL); 407 if (error) { 408 bp->b_flags |= B_ERROR; 409 biodone(bp); 410 goto reterr; 411 } 412 } 413 if ((long)bp->b_blkno == -1) { 414 biodone(bp); 415 error = 0; 416 goto reterr; 417 } 418 vp = ap->amp->devvp; 419 bp->b_dev = vp->v_rdev; 420 VOCALL(vp->v_op, VOFFSET(vop_strategy), sp); 421 reterr: 422 #ifdef ADOSFS_DIAGNOSTIC 423 printf(" %d)", error); 424 #endif 425 return(error); 426 } 427 428 int 429 adosfs_link(v) 430 void *v; 431 { 432 struct vop_link_args /* { 433 struct vnode *a_dvp; 434 struct vnode *a_vp; 435 struct componentname *a_cnp; 436 } */ *ap = v; 437 438 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 439 vput(ap->a_dvp); 440 return (EROFS); 441 } 442 443 int 444 adosfs_symlink(v) 445 void *v; 446 { 447 struct vop_symlink_args /* { 448 struct vnode *a_dvp; 449 struct vnode **a_vpp; 450 struct componentname *a_cnp; 451 struct vattr *a_vap; 452 char *a_target; 453 } */ *ap = v; 454 455 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 456 vput(ap->a_dvp); 457 return (EROFS); 458 } 459 460 /* 461 * Wait until the vnode has finished changing state. 462 */ 463 int 464 adosfs_bmap(v) 465 void *v; 466 { 467 struct vop_bmap_args /* { 468 struct vnode *a_vp; 469 daddr_t a_bn; 470 struct vnode **a_vpp; 471 daddr_t *a_bnp; 472 int *a_runp; 473 } */ *sp = v; 474 struct anode *ap; 475 struct buf *flbp; 476 long nb, flblk, flblkoff, fcnt; 477 daddr_t *bnp; 478 daddr_t bn; 479 int error; 480 481 #ifdef ADOSFS_DIAGNOSTIC 482 advopprint(sp); 483 #endif 484 ap = VTOA(sp->a_vp); 485 bn = sp->a_bn / (ap->amp->bsize / DEV_BSIZE); 486 bnp = sp->a_bnp; 487 if (sp->a_runp) { 488 *sp->a_runp = 0; 489 } 490 error = 0; 491 492 if (sp->a_vpp != NULL) 493 *sp->a_vpp = ap->amp->devvp; 494 if (bnp == NULL) 495 goto reterr; 496 if (bn < 0) { 497 error = EFBIG; 498 goto reterr; 499 } 500 if (sp->a_vp->v_type != VREG) { 501 error = EINVAL; 502 goto reterr; 503 } 504 505 /* 506 * walk the chain of file list blocks until we find 507 * the one that will yield the block pointer we need. 508 */ 509 if (ap->type == AFILE) 510 nb = ap->block; /* pointer to ourself */ 511 else if (ap->type == ALFILE) 512 nb = ap->linkto; /* pointer to real file */ 513 else { 514 error = EINVAL; 515 goto reterr; 516 } 517 518 flblk = bn / ANODENDATBLKENT(ap); 519 flbp = NULL; 520 521 /* 522 * check last indirect block cache 523 */ 524 if (flblk < ap->lastlindblk) 525 fcnt = 0; 526 else { 527 flblk -= ap->lastlindblk; 528 fcnt = ap->lastlindblk; 529 nb = ap->lastindblk; 530 } 531 while (flblk >= 0) { 532 if (flbp) 533 brelse(flbp); 534 if (nb == 0) { 535 #ifdef DIAGNOSTIC 536 printf("adosfs: bad file list chain.\n"); 537 #endif 538 error = EINVAL; 539 goto reterr; 540 } 541 error = bread(ap->amp->devvp, nb * ap->amp->bsize / DEV_BSIZE, 542 ap->amp->bsize, NOCRED, &flbp); 543 if (error) { 544 brelse(flbp); 545 goto reterr; 546 } 547 if (adoscksum(flbp, ap->nwords)) { 548 #ifdef DIAGNOSTIC 549 printf("adosfs: blk %ld failed cksum.\n", nb); 550 #endif 551 brelse(flbp); 552 error = EINVAL; 553 goto reterr; 554 } 555 /* 556 * update last indirect block cache 557 */ 558 ap->lastlindblk = fcnt++; 559 ap->lastindblk = nb; 560 561 nb = adoswordn(flbp, ap->nwords - 2); 562 flblk--; 563 } 564 /* 565 * calculate offset of block number in table. The table starts 566 * at nwords - 51 and goes to offset 6 or less if indicated by the 567 * valid table entries stored at offset ADBI_NBLKTABENT. 568 */ 569 flblkoff = bn % ANODENDATBLKENT(ap); 570 if (flblkoff < adoswordn(flbp, 2 /* ADBI_NBLKTABENT */)) { 571 flblkoff = (ap->nwords - 51) - flblkoff; 572 *bnp = adoswordn(flbp, flblkoff) * ap->amp->bsize / DEV_BSIZE; 573 } else { 574 #ifdef DIAGNOSTIC 575 printf("flblk offset %ld too large in lblk %ld blk %d\n", 576 flblkoff, bn / (ap->amp->bsize / DEV_BSIZE), flbp->b_blkno); 577 #endif 578 error = EINVAL; 579 } 580 brelse(flbp); 581 reterr: 582 #ifdef ADOSFS_DIAGNOSTIC 583 if (error == 0 && bnp) 584 printf(" %d => %d", bn, *bnp); 585 printf(" %d)", error); 586 #endif 587 return(error); 588 } 589 590 /* 591 * Print out the contents of a adosfs vnode. 592 */ 593 /* ARGSUSED */ 594 int 595 adosfs_print(v) 596 void *v; 597 { 598 #if 0 599 struct vop_print_args /* { 600 struct vnode *a_vp; 601 } */ *sp = v; 602 #endif 603 return(0); 604 } 605 606 struct adirent { 607 u_long fileno; 608 u_short reclen; 609 char type; 610 char namlen; 611 char name[32]; /* maxlen of 30 plus 2 NUL's */ 612 }; 613 614 int 615 adosfs_readdir(v) 616 void *v; 617 { 618 struct vop_readdir_args /* { 619 struct vnode *a_vp; 620 struct uio *a_uio; 621 struct ucred *a_cred; 622 int *a_eofflag; 623 off_t **a_cookies; 624 int *a_ncookies; 625 } */ *sp = v; 626 int error, useri, chainc, hashi, scanned, uavail; 627 struct adirent ad, *adp; 628 struct anode *pap, *ap; 629 struct adosfsmount *amp; 630 struct vnode *vp; 631 struct uio *uio; 632 u_long nextbn; 633 off_t uoff, *cookies = NULL; 634 int ncookies = 0; 635 636 #ifdef ADOSFS_DIAGNOSTIC 637 advopprint(sp); 638 #endif 639 if (sp->a_vp->v_type != VDIR) { 640 error = ENOTDIR; 641 goto reterr; 642 } 643 644 uio = sp->a_uio; 645 uoff = uio->uio_offset; 646 if (uoff < 0) { 647 error = EINVAL; 648 goto reterr; 649 } 650 651 pap = VTOA(sp->a_vp); 652 amp = pap->amp; 653 adp = &ad; 654 error = nextbn = hashi = chainc = scanned = 0; 655 uavail = uio->uio_resid / sizeof(ad); 656 useri = uoff / sizeof(ad); 657 658 /* 659 * if no slots available or offset requested is not on a slot boundry 660 */ 661 if (uavail < 1 || uoff % sizeof(ad)) { 662 error = EINVAL; 663 goto reterr; 664 } 665 666 if (sp->a_ncookies) { 667 ncookies = 0; 668 cookies = malloc(sizeof (off_t) * uavail, M_TEMP, M_WAITOK); 669 *sp->a_cookies = cookies; 670 } 671 672 while (uavail) { 673 if (hashi == pap->ntabent) { 674 *sp->a_eofflag = 1; 675 break; 676 } 677 if (pap->tab[hashi] == 0) { 678 hashi++; 679 continue; 680 } 681 if (nextbn == 0) 682 nextbn = pap->tab[hashi]; 683 684 /* 685 * first determine if we can skip this chain 686 */ 687 if (chainc == 0) { 688 int skip; 689 690 skip = useri - scanned; 691 if (pap->tabi[hashi] > 0 && pap->tabi[hashi] <= skip) { 692 scanned += pap->tabi[hashi]; 693 hashi++; 694 nextbn = 0; 695 continue; 696 } 697 } 698 699 /* 700 * now [continue to] walk the chain 701 */ 702 ap = NULL; 703 do { 704 error = VFS_VGET(amp->mp, (ino_t)nextbn, &vp); 705 if (error) 706 goto reterr; 707 ap = VTOA(vp); 708 scanned++; 709 chainc++; 710 nextbn = ap->hashf; 711 712 /* 713 * check for end of chain. 714 */ 715 if (nextbn == 0) { 716 pap->tabi[hashi] = chainc; 717 hashi++; 718 chainc = 0; 719 } else if (pap->tabi[hashi] <= 0 && 720 -chainc < pap->tabi[hashi]) 721 pap->tabi[hashi] = -chainc; 722 723 if (useri >= scanned) { 724 vput(vp); 725 ap = NULL; 726 } 727 } while (ap == NULL && nextbn != 0); 728 729 /* 730 * we left the loop but without a result so do main over. 731 */ 732 if (ap == NULL) 733 continue; 734 /* 735 * Fill in dirent record 736 */ 737 memset(adp, 0, sizeof(struct adirent)); 738 adp->fileno = ap->block; 739 /* 740 * this deserves an function in kern/vfs_subr.c 741 */ 742 switch (ATOV(ap)->v_type) { 743 case VREG: 744 adp->type = DT_REG; 745 break; 746 case VDIR: 747 adp->type = DT_DIR; 748 break; 749 case VLNK: 750 adp->type = DT_LNK; 751 break; 752 default: 753 adp->type = DT_UNKNOWN; 754 break; 755 } 756 adp->reclen = sizeof(struct adirent); 757 adp->namlen = strlen(ap->name); 758 memcpy(adp->name, ap->name, adp->namlen); 759 vput(vp); 760 761 error = uiomove((caddr_t) adp, sizeof(struct adirent), uio); 762 if (error) 763 break; 764 if (sp->a_ncookies) { 765 *cookies++ = uoff; 766 ncookies++; 767 } 768 uoff += sizeof(struct adirent); 769 useri++; 770 uavail--; 771 } 772 #if doesnt_uiomove_handle_this 773 uio->uio_offset = uoff; 774 #endif 775 reterr: 776 #ifdef ADOSFS_DIAGNOSTIC 777 printf(" %d)", error); 778 #endif 779 if (sp->a_ncookies) { 780 if (error) { 781 free(*sp->a_cookies, M_TEMP); 782 *sp->a_ncookies = 0; 783 *sp->a_cookies = NULL; 784 } else 785 *sp->a_ncookies = ncookies; 786 } 787 return(error); 788 } 789 790 791 int 792 adosfs_access(v) 793 void *v; 794 { 795 struct vop_access_args /* { 796 struct vnode *a_vp; 797 int a_mode; 798 struct ucred *a_cred; 799 struct proc *a_p; 800 } */ *sp = v; 801 struct anode *ap; 802 struct vnode *vp = sp->a_vp; 803 int error; 804 805 #ifdef ADOSFS_DIAGNOSTIC 806 advopprint(sp); 807 #endif 808 809 ap = VTOA(vp); 810 #ifdef DIAGNOSTIC 811 if (!VOP_ISLOCKED(vp)) { 812 vprint("adosfs_access: not locked", sp->a_vp); 813 panic("adosfs_access: not locked"); 814 } 815 #endif 816 /* 817 * Disallow write attempts unless the file is a socket, 818 * fifo, or a block or character device resident on the 819 * file system. 820 */ 821 if (sp->a_mode & VWRITE) { 822 switch (vp->v_type) { 823 case VDIR: 824 case VLNK: 825 case VREG: 826 return (EROFS); 827 default: 828 break; 829 } 830 } 831 #ifdef QUOTA 832 #endif 833 error = vaccess(sp->a_vp->v_type, adunixprot(ap->adprot) & ap->amp->mask, 834 ap->uid, ap->gid, sp->a_mode, sp->a_cred); 835 #ifdef ADOSFS_DIAGNOSTIC 836 printf(" %d)", error); 837 #endif 838 return(error); 839 } 840 841 int 842 adosfs_readlink(v) 843 void *v; 844 { 845 struct vop_readlink_args /* { 846 struct vnode *a_vp; 847 struct uio *a_uio; 848 struct ucred *a_cred; 849 } */ *sp = v; 850 struct anode *ap; 851 int error; 852 853 #ifdef ADOSFS_DIAGNOSTIC 854 advopprint(sp); 855 #endif 856 ap = VTOA(sp->a_vp); 857 error = uiomove(ap->slinkto, strlen(ap->slinkto), sp->a_uio); 858 #ifdef ADOSFS_DIAGNOSTIC 859 printf(" %d)", error); 860 #endif 861 return (error); 862 } 863 864 /*ARGSUSED*/ 865 int 866 adosfs_inactive(v) 867 void *v; 868 { 869 struct vop_inactive_args /* { 870 struct vnode *a_vp; 871 struct proc *a_p; 872 } */ *sp = v; 873 struct vnode *vp = sp->a_vp; 874 struct proc *p = sp->a_p; 875 #ifdef ADOSFS_DIAGNOSTIC 876 advopprint(sp); 877 #endif 878 VOP_UNLOCK(vp, 0); 879 /* XXX this needs to check if file was deleted */ 880 vrecycle(vp, NULL, p); 881 882 #ifdef ADOSFS_DIAGNOSTIC 883 printf(" 0)"); 884 #endif 885 return(0); 886 } 887 888 /* 889 * the kernel wants its vnode back. 890 * no lock needed we are being called from vclean() 891 */ 892 int 893 adosfs_reclaim(v) 894 void *v; 895 { 896 struct vop_reclaim_args /* { 897 struct vnode *a_vp; 898 } */ *sp = v; 899 struct vnode *vp; 900 struct anode *ap; 901 902 #ifdef ADOSFS_DIAGNOSTIC 903 printf("(reclaim 0)"); 904 #endif 905 vp = sp->a_vp; 906 ap = VTOA(vp); 907 LIST_REMOVE(ap, link); 908 cache_purge(vp); 909 if (vp->v_type == VDIR && ap->tab) 910 free(ap->tab, M_ANODE); 911 else if (vp->v_type == VLNK && ap->slinkto) 912 free(ap->slinkto, M_ANODE); 913 pool_put(&adosfs_node_pool, ap); 914 vp->v_data = NULL; 915 return(0); 916 } 917 918 /* 919 * POSIX pathconf info, grabbed from kern/u fs, probably need to 920 * investigate exactly what each return type means as they are probably 921 * not valid currently 922 */ 923 int 924 adosfs_pathconf(v) 925 void *v; 926 { 927 struct vop_pathconf_args /* { 928 struct vnode *a_vp; 929 int a_name; 930 register_t *a_retval; 931 } */ *sp = v; 932 933 switch (sp->a_name) { 934 case _PC_LINK_MAX: 935 *sp->a_retval = LINK_MAX; 936 return (0); 937 case _PC_PIPE_BUF: 938 *sp->a_retval = PIPE_BUF; 939 return (0); 940 case _PC_CHOWN_RESTRICTED: 941 *sp->a_retval = 1; 942 return (0); 943 case _PC_VDISABLE: 944 *sp->a_retval = _POSIX_VDISABLE; 945 return (0); 946 case _PC_SYNC_IO: 947 *sp->a_retval = 1; 948 return (0); 949 case _PC_FILESIZEBITS: 950 *sp->a_retval = 32; 951 return (0); 952 default: 953 return (EINVAL); 954 } 955 /* NOTREACHED */ 956 } 957
Indexes created Tue Sep 23 07:09:52 GMT 2025