1 /*- 2 * Copyright (c) 1994 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley 6 * by Pace Willisson (pace@blitz.com). The Rock Ridge Extension 7 * Support code is derived from software contributed to Berkeley 8 * by Atsushi Murai (amurai@spec.co.jp). 9 * 10 * %sccs.include.redist.c% 11 * 12 * @(#)cd9660_vnops.c 8.6 (Berkeley) 06/14/94 13 */ 14 15 #include <sys/param.h> 16 #include <sys/systm.h> 17 #include <sys/namei.h> 18 #include <sys/resourcevar.h> 19 #include <sys/kernel.h> 20 #include <sys/file.h> 21 #include <sys/stat.h> 22 #include <sys/buf.h> 23 #include <sys/proc.h> 24 #include <sys/conf.h> 25 #include <sys/mount.h> 26 #include <sys/vnode.h> 27 #include <miscfs/specfs/specdev.h> 28 #include <miscfs/fifofs/fifo.h> 29 #include <sys/malloc.h> 30 #include <sys/dir.h> 31 32 #include <isofs/cd9660/iso.h> 33 #include <isofs/cd9660/cd9660_node.h> 34 #include <isofs/cd9660/iso_rrip.h> 35 36 #if 0 37 /* 38 * Mknod vnode call 39 * Actually remap the device number 40 */ 41 cd9660_mknod(ndp, vap, cred, p) 42 struct nameidata *ndp; 43 struct ucred *cred; 44 struct vattr *vap; 45 struct proc *p; 46 { 47 #ifndef ISODEVMAP 48 free(ndp->ni_pnbuf, M_NAMEI); 49 vput(ndp->ni_dvp); 50 vput(ndp->ni_vp); 51 return (EINVAL); 52 #else 53 register struct vnode *vp; 54 struct iso_node *ip; 55 struct iso_dnode *dp; 56 int error; 57 58 vp = ndp->ni_vp; 59 ip = VTOI(vp); 60 61 if (ip->i_mnt->iso_ftype != ISO_FTYPE_RRIP 62 || vap->va_type != vp->v_type 63 || (vap->va_type != VCHR && vap->va_type != VBLK)) { 64 free(ndp->ni_pnbuf, M_NAMEI); 65 vput(ndp->ni_dvp); 66 vput(ndp->ni_vp); 67 return (EINVAL); 68 } 69 70 dp = iso_dmap(ip->i_dev,ip->i_number,1); 71 if (ip->inode.iso_rdev == vap->va_rdev || vap->va_rdev == VNOVAL) { 72 /* same as the unmapped one, delete the mapping */ 73 remque(dp); 74 FREE(dp,M_CACHE); 75 } else 76 /* enter new mapping */ 77 dp->d_dev = vap->va_rdev; 78 79 /* 80 * Remove inode so that it will be reloaded by iget and 81 * checked to see if it is an alias of an existing entry 82 * in the inode cache. 83 */ 84 vput(vp); 85 vp->v_type = VNON; 86 vgone(vp); 87 return (0); 88 #endif 89 } 90 #endif 91 92 /* 93 * Open called. 94 * 95 * Nothing to do. 96 */ 97 /* ARGSUSED */ 98 int 99 cd9660_open(ap) 100 struct vop_open_args /* { 101 struct vnode *a_vp; 102 int a_mode; 103 struct ucred *a_cred; 104 struct proc *a_p; 105 } */ *ap; 106 { 107 return (0); 108 } 109 110 /* 111 * Close called 112 * 113 * Update the times on the inode on writeable file systems. 114 */ 115 /* ARGSUSED */ 116 int 117 cd9660_close(ap) 118 struct vop_close_args /* { 119 struct vnode *a_vp; 120 int a_fflag; 121 struct ucred *a_cred; 122 struct proc *a_p; 123 } */ *ap; 124 { 125 return (0); 126 } 127 128 /* 129 * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC. 130 * The mode is shifted to select the owner/group/other fields. The 131 * super user is granted all permissions. 132 */ 133 /* ARGSUSED */ 134 cd9660_access(ap) 135 struct vop_access_args /* { 136 struct vnode *a_vp; 137 int a_mode; 138 struct ucred *a_cred; 139 struct proc *a_p; 140 } */ *ap; 141 { 142 struct iso_node *ip = VTOI(ap->a_vp); 143 struct ucred *cred = ap->a_cred; 144 mode_t mask, mode = ap->a_mode; 145 gid_t *gp; 146 int i, error; 147 148 /* User id 0 always gets access. */ 149 if (cred->cr_uid == 0) 150 return (0); 151 152 mask = 0; 153 154 /* Otherwise, check the owner. */ 155 if (cred->cr_uid == ip->inode.iso_uid) { 156 if (mode & VEXEC) 157 mask |= S_IXUSR; 158 if (mode & VREAD) 159 mask |= S_IRUSR; 160 if (mode & VWRITE) 161 mask |= S_IWUSR; 162 return ((ip->inode.iso_mode & mask) == mask ? 0 : EACCES); 163 } 164 165 /* Otherwise, check the groups. */ 166 for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) 167 if (ip->inode.iso_gid == *gp) { 168 if (mode & VEXEC) 169 mask |= S_IXGRP; 170 if (mode & VREAD) 171 mask |= S_IRGRP; 172 if (mode & VWRITE) 173 mask |= S_IWGRP; 174 return ((ip->inode.iso_mode & mask) == mask ? 175 0 : EACCES); 176 } 177 178 /* Otherwise, check everyone else. */ 179 if (mode & VEXEC) 180 mask |= S_IXOTH; 181 if (mode & VREAD) 182 mask |= S_IROTH; 183 if (mode & VWRITE) 184 mask |= S_IWOTH; 185 return ((ip->inode.iso_mode & mask) == mask ? 0 : EACCES); 186 } 187 188 cd9660_getattr(ap) 189 struct vop_getattr_args /* { 190 struct vnode *a_vp; 191 struct vattr *a_vap; 192 struct ucred *a_cred; 193 struct proc *a_p; 194 } */ *ap; 195 196 { 197 struct vnode *vp = ap->a_vp; 198 register struct vattr *vap = ap->a_vap; 199 register struct iso_node *ip = VTOI(vp); 200 int i; 201 202 vap->va_fsid = ip->i_dev; 203 vap->va_fileid = ip->i_number; 204 205 vap->va_mode = ip->inode.iso_mode; 206 vap->va_nlink = ip->inode.iso_links; 207 vap->va_uid = ip->inode.iso_uid; 208 vap->va_gid = ip->inode.iso_gid; 209 vap->va_atime = ip->inode.iso_atime; 210 vap->va_mtime = ip->inode.iso_mtime; 211 vap->va_ctime = ip->inode.iso_ctime; 212 vap->va_rdev = ip->inode.iso_rdev; 213 214 vap->va_size = (u_quad_t) ip->i_size; 215 vap->va_flags = 0; 216 vap->va_gen = 1; 217 vap->va_blocksize = ip->i_mnt->logical_block_size; 218 vap->va_bytes = (u_quad_t) ip->i_size; 219 vap->va_type = vp->v_type; 220 return (0); 221 } 222 223 #if ISO_DEFAULT_BLOCK_SIZE >= NBPG 224 #ifdef DEBUG 225 extern int doclusterread; 226 #else 227 #define doclusterread 1 228 #endif 229 #else 230 /* XXX until cluster routines can handle block sizes less than one page */ 231 #define doclusterread 0 232 #endif 233 234 /* 235 * Vnode op for reading. 236 */ 237 cd9660_read(ap) 238 struct vop_read_args /* { 239 struct vnode *a_vp; 240 struct uio *a_uio; 241 int a_ioflag; 242 struct ucred *a_cred; 243 } */ *ap; 244 { 245 struct vnode *vp = ap->a_vp; 246 register struct uio *uio = ap->a_uio; 247 register struct iso_node *ip = VTOI(vp); 248 register struct iso_mnt *imp; 249 struct buf *bp; 250 daddr_t lbn, bn, rablock; 251 off_t diff; 252 int rasize, error = 0; 253 long size, n, on; 254 255 if (uio->uio_resid == 0) 256 return (0); 257 if (uio->uio_offset < 0) 258 return (EINVAL); 259 ip->i_flag |= IACC; 260 imp = ip->i_mnt; 261 do { 262 lbn = iso_lblkno(imp, uio->uio_offset); 263 on = iso_blkoff(imp, uio->uio_offset); 264 n = min((unsigned)(imp->logical_block_size - on), 265 uio->uio_resid); 266 diff = (off_t)ip->i_size - uio->uio_offset; 267 if (diff <= 0) 268 return (0); 269 if (diff < n) 270 n = diff; 271 size = iso_blksize(imp, ip, lbn); 272 rablock = lbn + 1; 273 if (doclusterread) { 274 if (iso_lblktosize(imp, rablock) <= ip->i_size) 275 error = cluster_read(vp, (off_t)ip->i_size, 276 lbn, size, NOCRED, &bp); 277 else 278 error = bread(vp, lbn, size, NOCRED, &bp); 279 } else { 280 if (vp->v_lastr + 1 == lbn && 281 iso_lblktosize(imp, rablock) < ip->i_size) { 282 rasize = iso_blksize(imp, ip, rablock); 283 error = breadn(vp, lbn, size, &rablock, 284 &rasize, 1, NOCRED, &bp); 285 } else 286 error = bread(vp, lbn, size, NOCRED, &bp); 287 } 288 vp->v_lastr = lbn; 289 n = min(n, size - bp->b_resid); 290 if (error) { 291 brelse(bp); 292 return (error); 293 } 294 295 error = uiomove(bp->b_un.b_addr + on, (int)n, uio); 296 if (n + on == imp->logical_block_size || 297 uio->uio_offset == (off_t)ip->i_size) 298 bp->b_flags |= B_AGE; 299 brelse(bp); 300 } while (error == 0 && uio->uio_resid > 0 && n != 0); 301 return (error); 302 } 303 304 /* ARGSUSED */ 305 int 306 cd9660_ioctl(ap) 307 struct vop_ioctl_args /* { 308 struct vnode *a_vp; 309 int a_command; 310 caddr_t a_data; 311 int a_fflag; 312 struct ucred *a_cred; 313 struct proc *a_p; 314 } */ *ap; 315 { 316 printf("You did ioctl for isofs !!\n"); 317 return (ENOTTY); 318 } 319 320 /* ARGSUSED */ 321 int 322 cd9660_select(ap) 323 struct vop_select_args /* { 324 struct vnode *a_vp; 325 int a_which; 326 int a_fflags; 327 struct ucred *a_cred; 328 struct proc *a_p; 329 } */ *ap; 330 { 331 332 /* 333 * We should really check to see if I/O is possible. 334 */ 335 return (1); 336 } 337 338 /* 339 * Mmap a file 340 * 341 * NB Currently unsupported. 342 */ 343 /* ARGSUSED */ 344 int 345 cd9660_mmap(ap) 346 struct vop_mmap_args /* { 347 struct vnode *a_vp; 348 int a_fflags; 349 struct ucred *a_cred; 350 struct proc *a_p; 351 } */ *ap; 352 { 353 354 return (EINVAL); 355 } 356 357 /* 358 * Seek on a file 359 * 360 * Nothing to do, so just return. 361 */ 362 /* ARGSUSED */ 363 int 364 cd9660_seek(ap) 365 struct vop_seek_args /* { 366 struct vnode *a_vp; 367 off_t a_oldoff; 368 off_t a_newoff; 369 struct ucred *a_cred; 370 } */ *ap; 371 { 372 373 return (0); 374 } 375 376 /* 377 * Structure for reading directories 378 */ 379 struct isoreaddir { 380 struct dirent saveent; 381 struct dirent assocent; 382 struct dirent current; 383 off_t saveoff; 384 off_t assocoff; 385 off_t curroff; 386 struct uio *uio; 387 off_t uio_off; 388 int eofflag; 389 u_long *cookies; 390 int ncookies; 391 }; 392 393 static int 394 iso_uiodir(idp,dp,off) 395 struct isoreaddir *idp; 396 struct dirent *dp; 397 off_t off; 398 { 399 int error; 400 401 dp->d_name[dp->d_namlen] = 0; 402 dp->d_reclen = DIRSIZ(dp); 403 404 if (idp->uio->uio_resid < dp->d_reclen) { 405 idp->eofflag = 0; 406 return (-1); 407 } 408 409 if (idp->cookies) { 410 if (idp->ncookies <= 0) { 411 idp->eofflag = 0; 412 return (-1); 413 } 414 415 *idp->cookies++ = off; 416 --idp->ncookies; 417 } 418 419 if (error = uiomove(dp,dp->d_reclen,idp->uio)) 420 return (error); 421 idp->uio_off = off; 422 return (0); 423 } 424 425 static int 426 iso_shipdir(idp) 427 struct isoreaddir *idp; 428 { 429 struct dirent *dp; 430 int cl, sl, assoc; 431 int error; 432 char *cname, *sname; 433 434 cl = idp->current.d_namlen; 435 cname = idp->current.d_name; 436 if (assoc = cl > 1 && *cname == ASSOCCHAR) { 437 cl--; 438 cname++; 439 } 440 441 dp = &idp->saveent; 442 sname = dp->d_name; 443 if (!(sl = dp->d_namlen)) { 444 dp = &idp->assocent; 445 sname = dp->d_name + 1; 446 sl = dp->d_namlen - 1; 447 } 448 if (sl > 0) { 449 if (sl != cl 450 || bcmp(sname,cname,sl)) { 451 if (idp->assocent.d_namlen) { 452 if (error = iso_uiodir(idp,&idp->assocent,idp->assocoff)) 453 return (error); 454 idp->assocent.d_namlen = 0; 455 } 456 if (idp->saveent.d_namlen) { 457 if (error = iso_uiodir(idp,&idp->saveent,idp->saveoff)) 458 return (error); 459 idp->saveent.d_namlen = 0; 460 } 461 } 462 } 463 idp->current.d_reclen = DIRSIZ(&idp->current); 464 if (assoc) { 465 idp->assocoff = idp->curroff; 466 bcopy(&idp->current,&idp->assocent,idp->current.d_reclen); 467 } else { 468 idp->saveoff = idp->curroff; 469 bcopy(&idp->current,&idp->saveent,idp->current.d_reclen); 470 } 471 return (0); 472 } 473 474 /* 475 * Vnode op for readdir 476 * XXX make sure everything still works now that eofflagp and cookies 477 * are no longer args. 478 */ 479 int 480 cd9660_readdir(ap) 481 struct vop_readdir_args /* { 482 struct vnode *a_vp; 483 struct uio *a_uio; 484 struct ucred *a_cred; 485 int *a_eofflag; 486 u_long *a_cookies; 487 int a_ncookies; 488 } */ *ap; 489 { 490 register struct uio *uio = ap->a_uio; 491 struct isoreaddir *idp; 492 int entryoffsetinblock; 493 int error = 0; 494 int endsearch; 495 struct iso_directory_record *ep; 496 u_short elen; 497 int reclen; 498 struct iso_mnt *imp; 499 struct iso_node *ip; 500 struct buf *bp = NULL; 501 502 ip = VTOI(ap->a_vp); 503 imp = ip->i_mnt; 504 505 MALLOC(idp,struct isoreaddir *,sizeof(*idp),M_TEMP,M_WAITOK); 506 idp->saveent.d_namlen = 0; 507 idp->assocent.d_namlen = 0; 508 idp->uio = uio; 509 idp->eofflag = 1; 510 idp->cookies = ap->a_cookies; 511 idp->ncookies = ap->a_ncookies; 512 idp->curroff = uio->uio_offset; 513 514 entryoffsetinblock = iso_blkoff(imp, idp->curroff); 515 if (entryoffsetinblock != 0) { 516 if (error = iso_blkatoff(ip, idp->curroff, &bp)) { 517 FREE(idp,M_TEMP); 518 return (error); 519 } 520 } 521 522 endsearch = ip->i_size; 523 524 while (idp->curroff < endsearch) { 525 /* 526 * If offset is on a block boundary, 527 * read the next directory block. 528 * Release previous if it exists. 529 */ 530 531 if (iso_blkoff(imp, idp->curroff) == 0) { 532 if (bp != NULL) 533 brelse(bp); 534 if (error = iso_blkatoff(ip, idp->curroff, &bp)) 535 break; 536 entryoffsetinblock = 0; 537 } 538 /* 539 * Get pointer to next entry. 540 */ 541 542 ep = (struct iso_directory_record *) 543 (bp->b_un.b_addr + entryoffsetinblock); 544 545 reclen = isonum_711 (ep->length); 546 if (reclen == 0) { 547 /* skip to next block, if any */ 548 idp->curroff = roundup (idp->curroff, 549 imp->logical_block_size); 550 continue; 551 } 552 553 if (reclen < ISO_DIRECTORY_RECORD_SIZE) { 554 error = EINVAL; 555 /* illegal entry, stop */ 556 break; 557 } 558 559 if (entryoffsetinblock + reclen > imp->logical_block_size) { 560 error = EINVAL; 561 /* illegal directory, so stop looking */ 562 break; 563 } 564 565 idp->current.d_namlen = isonum_711 (ep->name_len); 566 if (isonum_711(ep->flags)&2) 567 isodirino(&idp->current.d_fileno,ep,imp); 568 else 569 idp->current.d_fileno = dbtob(bp->b_blkno) + 570 idp->curroff; 571 572 if (reclen < ISO_DIRECTORY_RECORD_SIZE + idp->current.d_namlen) { 573 error = EINVAL; 574 /* illegal entry, stop */ 575 break; 576 } 577 578 idp->curroff += reclen; 579 /* 580 * 581 */ 582 switch (imp->iso_ftype) { 583 case ISO_FTYPE_RRIP: 584 cd9660_rrip_getname(ep,idp->current.d_name, &elen, 585 &idp->current.d_fileno,imp); 586 idp->current.d_namlen = (u_char)elen; 587 if (idp->current.d_namlen) 588 error = iso_uiodir(idp,&idp->current,idp->curroff); 589 break; 590 default: /* ISO_FTYPE_DEFAULT || ISO_FTYPE_9660 */ 591 strcpy(idp->current.d_name,".."); 592 switch (ep->name[0]) { 593 case 0: 594 idp->current.d_namlen = 1; 595 error = iso_uiodir(idp,&idp->current,idp->curroff); 596 break; 597 case 1: 598 idp->current.d_namlen = 2; 599 error = iso_uiodir(idp,&idp->current,idp->curroff); 600 break; 601 default: 602 isofntrans(ep->name,idp->current.d_namlen, 603 idp->current.d_name, &elen, 604 imp->iso_ftype == ISO_FTYPE_9660, 605 isonum_711(ep->flags)&4); 606 idp->current.d_namlen = (u_char)elen; 607 if (imp->iso_ftype == ISO_FTYPE_DEFAULT) 608 error = iso_shipdir(idp); 609 else 610 error = iso_uiodir(idp,&idp->current,idp->curroff); 611 break; 612 } 613 } 614 if (error) 615 break; 616 617 entryoffsetinblock += reclen; 618 } 619 620 if (!error && imp->iso_ftype == ISO_FTYPE_DEFAULT) { 621 idp->current.d_namlen = 0; 622 error = iso_shipdir(idp); 623 } 624 if (error < 0) 625 error = 0; 626 627 if (bp) 628 brelse (bp); 629 630 uio->uio_offset = idp->uio_off; 631 *ap->a_eofflag = idp->eofflag; 632 633 FREE(idp,M_TEMP); 634 635 return (error); 636 } 637 638 /* 639 * Return target name of a symbolic link 640 * Shouldn't we get the parent vnode and read the data from there? 641 * This could eventually result in deadlocks in cd9660_lookup. 642 * But otherwise the block read here is in the block buffer two times. 643 */ 644 typedef struct iso_directory_record ISODIR; 645 typedef struct iso_node ISONODE; 646 typedef struct iso_mnt ISOMNT; 647 int 648 cd9660_readlink(ap) 649 struct vop_readlink_args /* { 650 struct vnode *a_vp; 651 struct uio *a_uio; 652 struct ucred *a_cred; 653 } */ *ap; 654 { 655 ISONODE *ip; 656 ISODIR *dirp; 657 ISOMNT *imp; 658 struct buf *bp; 659 u_short symlen; 660 int error; 661 char *symname; 662 ino_t ino; 663 664 ip = VTOI(ap->a_vp); 665 imp = ip->i_mnt; 666 667 if (imp->iso_ftype != ISO_FTYPE_RRIP) 668 return (EINVAL); 669 670 /* 671 * Get parents directory record block that this inode included. 672 */ 673 error = bread(imp->im_devvp, 674 (daddr_t)((ip->i_number&~imp->im_bmask) / DEV_BSIZE), 675 imp->logical_block_size, 676 NOCRED, 677 &bp); 678 if (error) { 679 brelse(bp); 680 return (EINVAL); 681 } 682 683 /* 684 * Setup the directory pointer for this inode 685 */ 686 dirp = (ISODIR *)(bp->b_un.b_addr + (ip->i_number & imp->im_bmask)); 687 688 /* 689 * Just make sure, we have a right one.... 690 * 1: Check not cross boundary on block 691 */ 692 if ((ip->i_number & imp->im_bmask) + isonum_711(dirp->length) 693 > imp->logical_block_size) { 694 brelse(bp); 695 return (EINVAL); 696 } 697 698 /* 699 * Now get a buffer 700 * Abuse a namei buffer for now. 701 */ 702 MALLOC(symname,char *,MAXPATHLEN,M_NAMEI,M_WAITOK); 703 704 /* 705 * Ok, we just gathering a symbolic name in SL record. 706 */ 707 if (cd9660_rrip_getsymname(dirp,symname,&symlen,imp) == 0) { 708 FREE(symname,M_NAMEI); 709 brelse(bp); 710 return (EINVAL); 711 } 712 /* 713 * Don't forget before you leave from home ;-) 714 */ 715 brelse(bp); 716 717 /* 718 * return with the symbolic name to caller's. 719 */ 720 error = uiomove(symname,symlen,ap->a_uio); 721 722 FREE(symname,M_NAMEI); 723 724 return (error); 725 } 726 727 /* 728 * Ufs abort op, called after namei() when a CREATE/DELETE isn't actually 729 * done. If a buffer has been saved in anticipation of a CREATE, delete it. 730 */ 731 int 732 cd9660_abortop(ap) 733 struct vop_abortop_args /* { 734 struct vnode *a_dvp; 735 struct componentname *a_cnp; 736 } */ *ap; 737 { 738 if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) 739 FREE(ap->a_cnp->cn_pnbuf, M_NAMEI); 740 return (0); 741 } 742 743 /* 744 * Lock an inode. 745 */ 746 int 747 cd9660_lock(ap) 748 struct vop_lock_args /* { 749 struct vnode *a_vp; 750 } */ *ap; 751 { 752 register struct iso_node *ip = VTOI(ap->a_vp); 753 754 ISO_ILOCK(ip); 755 return (0); 756 } 757 758 /* 759 * Unlock an inode. 760 */ 761 int 762 cd9660_unlock(ap) 763 struct vop_unlock_args /* { 764 struct vnode *a_vp; 765 } */ *ap; 766 { 767 register struct iso_node *ip = VTOI(ap->a_vp); 768 769 if (!(ip->i_flag & ILOCKED)) 770 panic("cd9660_unlock NOT LOCKED"); 771 ISO_IUNLOCK(ip); 772 return (0); 773 } 774 775 /* 776 * Check for a locked inode. 777 */ 778 int 779 cd9660_islocked(ap) 780 struct vop_islocked_args /* { 781 struct vnode *a_vp; 782 } */ *ap; 783 { 784 785 if (VTOI(ap->a_vp)->i_flag & ILOCKED) 786 return (1); 787 return (0); 788 } 789 790 /* 791 * Calculate the logical to physical mapping if not done already, 792 * then call the device strategy routine. 793 */ 794 int 795 cd9660_strategy(ap) 796 struct vop_strategy_args /* { 797 struct buf *a_bp; 798 } */ *ap; 799 { 800 register struct buf *bp = ap->a_bp; 801 register struct vnode *vp = bp->b_vp; 802 register struct iso_node *ip; 803 int error; 804 805 ip = VTOI(vp); 806 if (vp->v_type == VBLK || vp->v_type == VCHR) 807 panic("cd9660_strategy: spec"); 808 if (bp->b_blkno == bp->b_lblkno) { 809 if (error = 810 VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL)) { 811 bp->b_error = error; 812 bp->b_flags |= B_ERROR; 813 biodone(bp); 814 return (error); 815 } 816 if ((long)bp->b_blkno == -1) 817 clrbuf(bp); 818 } 819 if ((long)bp->b_blkno == -1) { 820 biodone(bp); 821 return (0); 822 } 823 vp = ip->i_devvp; 824 bp->b_dev = vp->v_rdev; 825 VOCALL (vp->v_op, VOFFSET(vop_strategy), ap); 826 return (0); 827 } 828 829 /* 830 * Print out the contents of an inode. 831 */ 832 int 833 cd9660_print(ap) 834 struct vop_print_args /* { 835 struct vnode *a_vp; 836 } */ *ap; 837 { 838 printf("tag VT_ISOFS, isofs vnode\n"); 839 return (0); 840 } 841 842 /* 843 * Unsupported operation 844 */ 845 int 846 cd9660_enotsupp() 847 { 848 849 return (EOPNOTSUPP); 850 } 851 852 /* 853 * Global vfs data structures for isofs 854 */ 855 #define cd9660_create \ 856 ((int (*) __P((struct vop_create_args *)))cd9660_enotsupp) 857 #define cd9660_mknod ((int (*) __P((struct vop_mknod_args *)))cd9660_enotsupp) 858 #define cd9660_setattr \ 859 ((int (*) __P((struct vop_setattr_args *)))cd9660_enotsupp) 860 #define cd9660_write ((int (*) __P((struct vop_write_args *)))cd9660_enotsupp) 861 #define cd9660_fsync ((int (*) __P((struct vop_fsync_args *)))nullop) 862 #define cd9660_remove \ 863 ((int (*) __P((struct vop_remove_args *)))cd9660_enotsupp) 864 #define cd9660_link ((int (*) __P((struct vop_link_args *)))cd9660_enotsupp) 865 #define cd9660_rename \ 866 ((int (*) __P((struct vop_rename_args *)))cd9660_enotsupp) 867 #define cd9660_mkdir ((int (*) __P((struct vop_mkdir_args *)))cd9660_enotsupp) 868 #define cd9660_rmdir ((int (*) __P((struct vop_rmdir_args *)))cd9660_enotsupp) 869 #define cd9660_symlink \ 870 ((int (*) __P((struct vop_symlink_args *)))cd9660_enotsupp) 871 #define cd9660_pathconf \ 872 ((int (*) __P((struct vop_pathconf_args *)))cd9660_enotsupp) 873 #define cd9660_advlock \ 874 ((int (*) __P((struct vop_advlock_args *)))cd9660_enotsupp) 875 #define cd9660_blkatoff \ 876 ((int (*) __P((struct vop_blkatoff_args *)))cd9660_enotsupp) 877 #define cd9660_valloc ((int(*) __P(( \ 878 struct vnode *pvp, \ 879 int mode, \ 880 struct ucred *cred, \ 881 struct vnode **vpp))) cd9660_enotsupp) 882 #define cd9660_vfree ((int (*) __P((struct vop_vfree_args *)))cd9660_enotsupp) 883 #define cd9660_truncate \ 884 ((int (*) __P((struct vop_truncate_args *)))cd9660_enotsupp) 885 #define cd9660_update \ 886 ((int (*) __P((struct vop_update_args *)))cd9660_enotsupp) 887 #define cd9660_bwrite \ 888 ((int (*) __P((struct vop_bwrite_args *)))cd9660_enotsupp) 889 890 /* 891 * Global vfs data structures for nfs 892 */ 893 int (**cd9660_vnodeop_p)(); 894 struct vnodeopv_entry_desc cd9660_vnodeop_entries[] = { 895 { &vop_default_desc, vn_default_error }, 896 { &vop_lookup_desc, cd9660_lookup }, /* lookup */ 897 { &vop_create_desc, cd9660_create }, /* create */ 898 { &vop_mknod_desc, cd9660_mknod }, /* mknod */ 899 { &vop_open_desc, cd9660_open }, /* open */ 900 { &vop_close_desc, cd9660_close }, /* close */ 901 { &vop_access_desc, cd9660_access }, /* access */ 902 { &vop_getattr_desc, cd9660_getattr }, /* getattr */ 903 { &vop_setattr_desc, cd9660_setattr }, /* setattr */ 904 { &vop_read_desc, cd9660_read }, /* read */ 905 { &vop_write_desc, cd9660_write }, /* write */ 906 { &vop_ioctl_desc, cd9660_ioctl }, /* ioctl */ 907 { &vop_select_desc, cd9660_select }, /* select */ 908 { &vop_mmap_desc, cd9660_mmap }, /* mmap */ 909 { &vop_fsync_desc, cd9660_fsync }, /* fsync */ 910 { &vop_seek_desc, cd9660_seek }, /* seek */ 911 { &vop_remove_desc, cd9660_remove }, /* remove */ 912 { &vop_link_desc, cd9660_link }, /* link */ 913 { &vop_rename_desc, cd9660_rename }, /* rename */ 914 { &vop_mkdir_desc, cd9660_mkdir }, /* mkdir */ 915 { &vop_rmdir_desc, cd9660_rmdir }, /* rmdir */ 916 { &vop_symlink_desc, cd9660_symlink }, /* symlink */ 917 { &vop_readdir_desc, cd9660_readdir }, /* readdir */ 918 { &vop_readlink_desc, cd9660_readlink },/* readlink */ 919 { &vop_abortop_desc, cd9660_abortop }, /* abortop */ 920 { &vop_inactive_desc, cd9660_inactive },/* inactive */ 921 { &vop_reclaim_desc, cd9660_reclaim }, /* reclaim */ 922 { &vop_lock_desc, cd9660_lock }, /* lock */ 923 { &vop_unlock_desc, cd9660_unlock }, /* unlock */ 924 { &vop_bmap_desc, cd9660_bmap }, /* bmap */ 925 { &vop_strategy_desc, cd9660_strategy },/* strategy */ 926 { &vop_print_desc, cd9660_print }, /* print */ 927 { &vop_islocked_desc, cd9660_islocked },/* islocked */ 928 { &vop_pathconf_desc, cd9660_pathconf },/* pathconf */ 929 { &vop_advlock_desc, cd9660_advlock }, /* advlock */ 930 { &vop_blkatoff_desc, cd9660_blkatoff },/* blkatoff */ 931 { &vop_valloc_desc, cd9660_valloc }, /* valloc */ 932 { &vop_vfree_desc, cd9660_vfree }, /* vfree */ 933 { &vop_truncate_desc, cd9660_truncate },/* truncate */ 934 { &vop_update_desc, cd9660_update }, /* update */ 935 { &vop_bwrite_desc, vn_bwrite }, 936 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 937 }; 938 struct vnodeopv_desc cd9660_vnodeop_opv_desc = 939 { &cd9660_vnodeop_p, cd9660_vnodeop_entries }; 940 941 /* 942 * Special device vnode ops 943 */ 944 int (**cd9660_specop_p)(); 945 struct vnodeopv_entry_desc cd9660_specop_entries[] = { 946 { &vop_default_desc, vn_default_error }, 947 { &vop_lookup_desc, spec_lookup }, /* lookup */ 948 { &vop_create_desc, cd9660_create }, /* create */ 949 { &vop_mknod_desc, cd9660_mknod }, /* mknod */ 950 { &vop_open_desc, spec_open }, /* open */ 951 { &vop_close_desc, spec_close }, /* close */ 952 { &vop_access_desc, cd9660_access }, /* access */ 953 { &vop_getattr_desc, cd9660_getattr }, /* getattr */ 954 { &vop_setattr_desc, cd9660_setattr }, /* setattr */ 955 { &vop_read_desc, spec_read }, /* read */ 956 { &vop_write_desc, spec_write }, /* write */ 957 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 958 { &vop_select_desc, spec_select }, /* select */ 959 { &vop_mmap_desc, spec_mmap }, /* mmap */ 960 { &vop_fsync_desc, spec_fsync }, /* fsync */ 961 { &vop_seek_desc, spec_seek }, /* seek */ 962 { &vop_remove_desc, cd9660_remove }, /* remove */ 963 { &vop_link_desc, cd9660_link }, /* link */ 964 { &vop_rename_desc, cd9660_rename }, /* rename */ 965 { &vop_mkdir_desc, cd9660_mkdir }, /* mkdir */ 966 { &vop_rmdir_desc, cd9660_rmdir }, /* rmdir */ 967 { &vop_symlink_desc, cd9660_symlink }, /* symlink */ 968 { &vop_readdir_desc, spec_readdir }, /* readdir */ 969 { &vop_readlink_desc, spec_readlink }, /* readlink */ 970 { &vop_abortop_desc, spec_abortop }, /* abortop */ 971 { &vop_inactive_desc, cd9660_inactive },/* inactive */ 972 { &vop_reclaim_desc, cd9660_reclaim }, /* reclaim */ 973 { &vop_lock_desc, cd9660_lock }, /* lock */ 974 { &vop_unlock_desc, cd9660_unlock }, /* unlock */ 975 { &vop_bmap_desc, spec_bmap }, /* bmap */ 976 /* XXX strategy: panics, should be notsupp instead? */ 977 { &vop_strategy_desc, cd9660_strategy },/* strategy */ 978 { &vop_print_desc, cd9660_print }, /* print */ 979 { &vop_islocked_desc, cd9660_islocked },/* islocked */ 980 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 981 { &vop_advlock_desc, spec_advlock }, /* advlock */ 982 { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ 983 { &vop_valloc_desc, spec_valloc }, /* valloc */ 984 { &vop_vfree_desc, spec_vfree }, /* vfree */ 985 { &vop_truncate_desc, spec_truncate }, /* truncate */ 986 { &vop_update_desc, cd9660_update }, /* update */ 987 { &vop_bwrite_desc, vn_bwrite }, 988 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 989 }; 990 struct vnodeopv_desc cd9660_specop_opv_desc = 991 { &cd9660_specop_p, cd9660_specop_entries }; 992 993 #ifdef FIFO 994 int (**cd9660_fifoop_p)(); 995 struct vnodeopv_entry_desc cd9660_fifoop_entries[] = { 996 { &vop_default_desc, vn_default_error }, 997 { &vop_lookup_desc, fifo_lookup }, /* lookup */ 998 { &vop_create_desc, cd9660_create }, /* create */ 999 { &vop_mknod_desc, cd9660_mknod }, /* mknod */ 1000 { &vop_open_desc, fifo_open }, /* open */ 1001 { &vop_close_desc, fifo_close }, /* close */ 1002 { &vop_access_desc, cd9660_access }, /* access */ 1003 { &vop_getattr_desc, cd9660_getattr }, /* getattr */ 1004 { &vop_setattr_desc, cd9660_setattr }, /* setattr */ 1005 { &vop_read_desc, fifo_read }, /* read */ 1006 { &vop_write_desc, fifo_write }, /* write */ 1007 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ 1008 { &vop_select_desc, fifo_select }, /* select */ 1009 { &vop_mmap_desc, fifo_mmap }, /* mmap */ 1010 { &vop_fsync_desc, fifo_fsync }, /* fsync */ 1011 { &vop_seek_desc, fifo_seek }, /* seek */ 1012 { &vop_remove_desc, cd9660_remove }, /* remove */ 1013 { &vop_link_desc, cd9660_link }, /* link */ 1014 { &vop_rename_desc, cd9660_rename }, /* rename */ 1015 { &vop_mkdir_desc, cd9660_mkdir }, /* mkdir */ 1016 { &vop_rmdir_desc, cd9660_rmdir }, /* rmdir */ 1017 { &vop_symlink_desc, cd9660_symlink }, /* symlink */ 1018 { &vop_readdir_desc, fifo_readdir }, /* readdir */ 1019 { &vop_readlink_desc, fifo_readlink }, /* readlink */ 1020 { &vop_abortop_desc, fifo_abortop }, /* abortop */ 1021 { &vop_inactive_desc, cd9660_inactive },/* inactive */ 1022 { &vop_reclaim_desc, cd9660_reclaim }, /* reclaim */ 1023 { &vop_lock_desc, cd9660_lock }, /* lock */ 1024 { &vop_unlock_desc, cd9660_unlock }, /* unlock */ 1025 { &vop_bmap_desc, fifo_bmap }, /* bmap */ 1026 { &vop_strategy_desc, fifo_badop }, /* strategy */ 1027 { &vop_print_desc, cd9660_print }, /* print */ 1028 { &vop_islocked_desc, cd9660_islocked },/* islocked */ 1029 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */ 1030 { &vop_advlock_desc, fifo_advlock }, /* advlock */ 1031 { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */ 1032 { &vop_valloc_desc, fifo_valloc }, /* valloc */ 1033 { &vop_vfree_desc, fifo_vfree }, /* vfree */ 1034 { &vop_truncate_desc, fifo_truncate }, /* truncate */ 1035 { &vop_update_desc, cd9660_update }, /* update */ 1036 { &vop_bwrite_desc, vn_bwrite }, 1037 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 1038 }; 1039 struct vnodeopv_desc cd9660_fifoop_opv_desc = 1040 { &cd9660_fifoop_p, cd9660_fifoop_entries }; 1041 #endif /* FIFO */ 1042