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 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)cd9660_vnops.c 8.19 (Berkeley) 5/27/95 35 * $FreeBSD: src/sys/isofs/cd9660/cd9660_vnops.c,v 1.62 1999/12/15 23:01:51 eivind Exp $ 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/uio.h> 41 #include <sys/proc.h> 42 #include <sys/kernel.h> 43 #include <sys/stat.h> 44 #include <sys/buf.h> 45 #include <sys/mount.h> 46 #include <sys/vnode.h> 47 #include <vfs/fifofs/fifo.h> 48 #include <sys/malloc.h> 49 #include <sys/dirent.h> 50 #include <sys/unistd.h> 51 #include <sys/filio.h> 52 #include <sys/lockf.h> 53 #include <sys/objcache.h> 54 55 #include <vm/vm.h> 56 #include <vm/vnode_pager.h> 57 58 #include <sys/buf2.h> 59 60 #include "iso.h" 61 #include "cd9660_node.h" 62 #include "iso_rrip.h" 63 64 static int cd9660_access(struct vop_access_args *); 65 static int cd9660_advlock(struct vop_advlock_args *); 66 static int cd9660_getattr(struct vop_getattr_args *); 67 static int cd9660_ioctl(struct vop_ioctl_args *); 68 static int cd9660_pathconf(struct vop_pathconf_args *); 69 static int cd9660_open(struct vop_open_args *); 70 static int cd9660_read(struct vop_read_args *); 71 static int cd9660_setattr(struct vop_setattr_args *); 72 struct isoreaddir; 73 static int iso_uiodir(struct isoreaddir *idp, struct dirent *dp, off_t off); 74 static int iso_shipdir(struct isoreaddir *idp); 75 static int cd9660_readdir(struct vop_readdir_args *); 76 static int cd9660_readlink(struct vop_readlink_args *ap); 77 static int cd9660_strategy(struct vop_strategy_args *); 78 static int cd9660_print(struct vop_print_args *); 79 80 /* 81 * Setattr call. Only allowed for block and character special devices. 82 * 83 * cd9660_setattr(struct vnode *a_vp, struct vattr *a_vap, 84 * struct ucred *a_cred, struct proc *a_p) 85 */ 86 int 87 cd9660_setattr(struct vop_setattr_args *ap) 88 { 89 struct vnode *vp = ap->a_vp; 90 struct vattr *vap = ap->a_vap; 91 92 if (vap->va_flags != (u_long)VNOVAL || vap->va_uid != (uid_t)VNOVAL || 93 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 94 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) 95 return (EROFS); 96 if (vap->va_size != (u_quad_t)VNOVAL) { 97 switch (vp->v_type) { 98 case VDIR: 99 return (EISDIR); 100 case VLNK: 101 case VREG: 102 case VDATABASE: 103 return (EROFS); 104 case VCHR: 105 case VBLK: 106 case VSOCK: 107 case VFIFO: 108 default: 109 return (0); 110 } 111 } 112 return (0); 113 } 114 115 /* 116 * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC. 117 * The mode is shifted to select the owner/group/other fields. The 118 * super user is granted all permissions. 119 * 120 * cd9660_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred, 121 * struct proc *a_p) 122 */ 123 /* ARGSUSED */ 124 static int 125 cd9660_access(struct vop_access_args *ap) 126 { 127 struct vnode *vp = ap->a_vp; 128 struct iso_node *ip = VTOI(vp); 129 130 KKASSERT(vp->v_mount->mnt_flag & MNT_RDONLY); 131 return (vop_helper_access(ap, ip->inode.iso_uid, ip->inode.iso_gid, 132 ip->inode.iso_mode, 0)); 133 } 134 135 /* 136 * cd9660_getattr(struct vnode *a_vp, struct vattr *a_vap) 137 */ 138 static int 139 cd9660_getattr(struct vop_getattr_args *ap) 140 { 141 struct vnode *vp = ap->a_vp; 142 struct vattr *vap = ap->a_vap; 143 struct iso_node *ip = VTOI(vp); 144 145 vap->va_fsid = devid_from_dev(ip->i_dev); 146 vap->va_fileid = ip->i_number; 147 148 vap->va_mode = ip->inode.iso_mode; 149 vap->va_nlink = ip->inode.iso_links; 150 vap->va_uid = ip->inode.iso_uid; 151 vap->va_gid = ip->inode.iso_gid; 152 vap->va_atime = ip->inode.iso_atime; 153 vap->va_mtime = ip->inode.iso_mtime; 154 vap->va_ctime = ip->inode.iso_ctime; 155 vap->va_rmajor = umajor(ip->inode.iso_rdev); 156 vap->va_rminor = uminor(ip->inode.iso_rdev); 157 158 vap->va_size = (u_quad_t)(unsigned long)ip->i_size; 159 if (ip->i_size == 0 && (vap->va_mode & S_IFMT) == S_IFLNK) { 160 struct vop_readlink_args rdlnk; 161 struct iovec aiov; 162 struct uio auio; 163 char *cp; 164 165 cp = kmalloc(MAXPATHLEN, M_TEMP, M_WAITOK); 166 aiov.iov_base = cp; 167 aiov.iov_len = MAXPATHLEN; 168 auio.uio_iov = &aiov; 169 auio.uio_iovcnt = 1; 170 auio.uio_offset = 0; 171 auio.uio_rw = UIO_READ; 172 auio.uio_segflg = UIO_SYSSPACE; 173 auio.uio_td = curthread; 174 auio.uio_resid = MAXPATHLEN; 175 rdlnk.a_uio = &auio; 176 rdlnk.a_vp = ap->a_vp; 177 rdlnk.a_cred = proc0.p_ucred; /* use root cred */ 178 if (cd9660_readlink(&rdlnk) == 0) 179 vap->va_size = MAXPATHLEN - auio.uio_resid; 180 kfree(cp, M_TEMP); 181 } 182 vap->va_flags = 0; 183 vap->va_gen = 1; 184 vap->va_blocksize = ip->i_mnt->logical_block_size; 185 vap->va_bytes = (u_quad_t) ip->i_size; 186 vap->va_type = vp->v_type; 187 vap->va_filerev = 0; 188 return (0); 189 } 190 191 /* 192 * Vnode op for ioctl. 193 * 194 * cd9660_ioctl(struct vnode *a_vp, int a_command, caddr_t a_data, 195 * int a_fflag, struct ucred *a_cred, struct proc *a_p) 196 */ 197 static int 198 cd9660_ioctl(struct vop_ioctl_args *ap) 199 { 200 struct vnode *vp = ap->a_vp; 201 struct iso_node *ip = VTOI(vp); 202 203 switch (ap->a_command) { 204 205 case FIOGETLBA: 206 *(int *)(ap->a_data) = ip->iso_start; 207 return 0; 208 default: 209 return (ENOTTY); 210 } 211 } 212 213 /* 214 * open is called when the kernel intends to read or memory map a vnode. 215 */ 216 static int 217 cd9660_open(struct vop_open_args *ap) 218 { 219 return(vop_stdopen(ap)); 220 } 221 222 /* 223 * Vnode op for reading. 224 * 225 * cd9660_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, 226 * struct ucred *a_cred) 227 */ 228 static int 229 cd9660_read(struct vop_read_args *ap) 230 { 231 struct vnode *vp = ap->a_vp; 232 struct uio *uio = ap->a_uio; 233 struct iso_node *ip = VTOI(vp); 234 struct iso_mnt *imp; 235 struct buf *bp; 236 daddr_t lbn, rablock; 237 off_t raoffset; 238 off_t loffset; 239 off_t diff; 240 int rasize, error = 0; 241 int seqcount; 242 long size, n, on; 243 244 seqcount = ap->a_ioflag >> IO_SEQSHIFT; 245 246 if (uio->uio_resid == 0) 247 return (0); 248 if (uio->uio_offset < 0) 249 return (EINVAL); 250 ip->i_flag |= IN_ACCESS; 251 imp = ip->i_mnt; 252 do { 253 lbn = lblkno(imp, uio->uio_offset); 254 loffset = lblktooff(imp, lbn); 255 on = blkoff(imp, uio->uio_offset); 256 n = szmin((u_int)(imp->logical_block_size - on), 257 uio->uio_resid); 258 diff = (off_t)ip->i_size - uio->uio_offset; 259 if (diff <= 0) 260 return (0); 261 if (diff < n) 262 n = diff; 263 size = blksize(imp, ip, lbn); 264 rablock = lbn + 1; 265 raoffset = lblktooff(imp, rablock); 266 if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) { 267 if (raoffset < ip->i_size) { 268 error = cluster_read(vp, (off_t)ip->i_size, 269 loffset, size, 270 uio->uio_resid, 271 (ap->a_ioflag >> IO_SEQSHIFT) * 272 MAXBSIZE, 273 &bp); 274 } else { 275 error = bread(vp, loffset, size, &bp); 276 } 277 } else { 278 if (seqcount > 1 && 279 lblktosize(imp, rablock) < ip->i_size) { 280 rasize = blksize(imp, ip, rablock); 281 error = breadn(vp, loffset, size, &raoffset, 282 &rasize, 1, &bp); 283 } else 284 error = bread(vp, loffset, size, &bp); 285 } 286 n = imin(n, size - bp->b_resid); 287 if (error) { 288 brelse(bp); 289 return (error); 290 } 291 292 error = uiomove(bp->b_data + on, (int)n, uio); 293 brelse(bp); 294 } while (error == 0 && uio->uio_resid > 0 && n != 0); 295 return (error); 296 } 297 298 /* struct dirent + enough space for the maximum supported size */ 299 struct iso_dirent { 300 struct dirent de; 301 char de_name[_DIRENT_RECLEN(NAME_MAX) - sizeof(struct dirent)]; 302 }; 303 304 /* 305 * Structure for reading directories 306 */ 307 struct isoreaddir { 308 struct iso_dirent saveent; 309 struct iso_dirent assocent; 310 struct iso_dirent current; 311 off_t saveoff; 312 off_t assocoff; 313 off_t curroff; 314 struct uio *uio; 315 off_t uio_off; 316 int eofflag; 317 off_t *cookies; 318 int ncookies; 319 }; 320 321 int 322 iso_uiodir(struct isoreaddir *idp, struct dirent *dp, off_t off) 323 { 324 int error; 325 326 dp->d_name[dp->d_namlen] = 0; 327 328 if (idp->uio->uio_resid < _DIRENT_DIRSIZ(dp)) { 329 idp->eofflag = 0; 330 return (-1); 331 } 332 333 if (idp->cookies) { 334 if (idp->ncookies <= 0) { 335 idp->eofflag = 0; 336 return (-1); 337 } 338 339 *idp->cookies++ = off; 340 --idp->ncookies; 341 } 342 343 if ((error = uiomove((caddr_t) dp,_DIRENT_DIRSIZ(dp),idp->uio)) != 0) 344 return (error); 345 idp->uio_off = off; 346 return (0); 347 } 348 349 int 350 iso_shipdir(struct isoreaddir *idp) 351 { 352 struct dirent *dp; 353 int cl, sl, assoc; 354 int error; 355 char *cname, *sname; 356 357 cl = idp->current.de.d_namlen; 358 cname = idp->current.de.d_name; 359 assoc = (cl > 1) && (*cname == ASSOCCHAR); 360 if (assoc) { 361 cl--; 362 cname++; 363 } 364 365 dp = &idp->saveent.de; 366 sname = dp->d_name; 367 if (!(sl = dp->d_namlen)) { 368 dp = &idp->assocent.de; 369 sname = dp->d_name + 1; 370 sl = dp->d_namlen - 1; 371 } 372 if (sl > 0) { 373 if (sl != cl 374 || bcmp(sname,cname,sl)) { 375 if (idp->assocent.de.d_namlen) { 376 if ((error = iso_uiodir(idp,&idp->assocent.de,idp->assocoff)) != 0) 377 return (error); 378 idp->assocent.de.d_namlen = 0; 379 } 380 if (idp->saveent.de.d_namlen) { 381 if ((error = iso_uiodir(idp,&idp->saveent.de,idp->saveoff)) != 0) 382 return (error); 383 idp->saveent.de.d_namlen = 0; 384 } 385 } 386 } 387 if (assoc) { 388 idp->assocoff = idp->curroff; 389 bcopy(&idp->current,&idp->assocent,_DIRENT_DIRSIZ(&idp->current.de)); 390 } else { 391 idp->saveoff = idp->curroff; 392 bcopy(&idp->current,&idp->saveent,_DIRENT_DIRSIZ(&idp->current.de)); 393 } 394 return (0); 395 } 396 397 /* 398 * Vnode op for readdir 399 * 400 * cd9660_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred, 401 * int *a_eofflag, int *a_ncookies, off_t *a_cookies) 402 */ 403 static int 404 cd9660_readdir(struct vop_readdir_args *ap) 405 { 406 struct uio *uio = ap->a_uio; 407 struct isoreaddir *idp; 408 struct vnode *vdp = ap->a_vp; 409 struct iso_node *dp; 410 struct iso_mnt *imp; 411 struct buf *bp = NULL; 412 struct iso_directory_record *ep; 413 int entryoffsetinblock; 414 doff_t endsearch; 415 u_long bmask; 416 int error = 0; 417 int reclen; 418 u_short namelen; 419 int ncookies = 0; 420 off_t *cookies = NULL; 421 422 dp = VTOI(vdp); 423 imp = dp->i_mnt; 424 bmask = imp->im_bmask; 425 426 error = vn_lock(vdp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM); 427 if (error) 428 return (error); 429 430 idp = kmalloc(sizeof(*idp), M_TEMP, M_WAITOK); 431 idp->saveent.de.d_namlen = idp->assocent.de.d_namlen = 0; 432 /* 433 * XXX 434 * Is it worth trying to figure out the type? 435 */ 436 idp->saveent.de.d_type = DT_UNKNOWN; 437 idp->assocent.de.d_type = DT_UNKNOWN; 438 idp->current.de.d_type = DT_UNKNOWN; 439 idp->uio = uio; 440 if (ap->a_ncookies == NULL) { 441 idp->cookies = NULL; 442 } else { 443 /* 444 * Guess the number of cookies needed. Guess at least 445 * 1 to avoid a degenerate case in malloc, and cap at 446 * a reasonable limit. 447 */ 448 ncookies = uio->uio_resid / 16 + 1; 449 if (ncookies > 1024) 450 ncookies = 1024; 451 cookies = kmalloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK); 452 idp->cookies = cookies; 453 idp->ncookies = ncookies; 454 } 455 idp->eofflag = 1; 456 idp->curroff = uio->uio_offset; 457 458 if ((entryoffsetinblock = idp->curroff & bmask) && 459 (error = cd9660_devblkatoff(vdp, idp->curroff, NULL, &bp))) { 460 kfree(idp, M_TEMP); 461 goto done; 462 } 463 endsearch = dp->i_size; 464 465 while (idp->curroff < endsearch) { 466 /* 467 * If offset is on a block boundary, 468 * read the next directory block. 469 * Release previous if it exists. 470 */ 471 if ((idp->curroff & bmask) == 0) { 472 if (bp != NULL) 473 brelse(bp); 474 if ((error = 475 cd9660_devblkatoff(vdp, idp->curroff, NULL, &bp)) != 0) 476 break; 477 entryoffsetinblock = 0; 478 } 479 /* 480 * Get pointer to next entry. 481 */ 482 ep = (struct iso_directory_record *) 483 ((char *)bp->b_data + entryoffsetinblock); 484 485 reclen = isonum_711(ep->length); 486 if (reclen == 0) { 487 /* skip to next block, if any */ 488 idp->curroff = 489 (idp->curroff & ~bmask) + imp->logical_block_size; 490 continue; 491 } 492 493 if (reclen < ISO_DIRECTORY_RECORD_SIZE) { 494 error = EINVAL; 495 /* illegal entry, stop */ 496 break; 497 } 498 499 if (entryoffsetinblock + reclen > imp->logical_block_size) { 500 error = EINVAL; 501 /* illegal directory, so stop looking */ 502 break; 503 } 504 505 idp->current.de.d_namlen = isonum_711(ep->name_len); 506 507 if (reclen < ISO_DIRECTORY_RECORD_SIZE + idp->current.de.d_namlen) { 508 error = EINVAL; 509 /* illegal entry, stop */ 510 break; 511 } 512 513 if (isonum_711(ep->flags)&2) 514 idp->current.de.d_ino = isodirino(ep, imp); 515 else 516 idp->current.de.d_ino = bp->b_bio1.bio_offset + 517 entryoffsetinblock; 518 519 idp->curroff += reclen; 520 521 switch (imp->iso_ftype) { 522 case ISO_FTYPE_RRIP: 523 { 524 ino_t cur_fileno = idp->current.de.d_ino; 525 cd9660_rrip_getname(ep,idp->current.de.d_name, &namelen, 526 &cur_fileno,imp); 527 idp->current.de.d_ino = cur_fileno; 528 idp->current.de.d_namlen = namelen; 529 if (idp->current.de.d_namlen) 530 error = iso_uiodir(idp,&idp->current.de,idp->curroff); 531 break; 532 } 533 default: /* ISO_FTYPE_DEFAULT || ISO_FTYPE_9660 || ISO_FTYPE_HIGH_SIERRA*/ 534 strcpy(idp->current.de.d_name,".."); 535 if (idp->current.de.d_namlen == 1 && ep->name[0] == 0) { 536 idp->current.de.d_namlen = 1; 537 error = iso_uiodir(idp,&idp->current.de,idp->curroff); 538 } else if (idp->current.de.d_namlen == 1 && ep->name[0] == 1) { 539 idp->current.de.d_namlen = 2; 540 error = iso_uiodir(idp,&idp->current.de,idp->curroff); 541 } else { 542 isofntrans(ep->name,idp->current.de.d_namlen, 543 idp->current.de.d_name, &namelen, 544 imp->iso_ftype == ISO_FTYPE_9660, 545 isonum_711(ep->flags)&4, 546 imp->joliet_level, 547 imp->im_flags, 548 imp->im_d2l); 549 idp->current.de.d_namlen = namelen; 550 if (imp->iso_ftype == ISO_FTYPE_DEFAULT) 551 error = iso_shipdir(idp); 552 else 553 error = iso_uiodir(idp,&idp->current.de,idp->curroff); 554 } 555 } 556 if (error) 557 break; 558 559 entryoffsetinblock += reclen; 560 } 561 562 if (!error && imp->iso_ftype == ISO_FTYPE_DEFAULT) { 563 idp->current.de.d_namlen = 0; 564 error = iso_shipdir(idp); 565 } 566 if (error < 0) 567 error = 0; 568 569 if (ap->a_ncookies != NULL) { 570 if (error) 571 kfree(cookies, M_TEMP); 572 else { 573 /* 574 * Work out the number of cookies actually used. 575 */ 576 *ap->a_ncookies = ncookies - idp->ncookies; 577 *ap->a_cookies = cookies; 578 } 579 } 580 581 if (bp) 582 brelse (bp); 583 584 uio->uio_offset = idp->uio_off; 585 *ap->a_eofflag = idp->eofflag; 586 587 kfree(idp, M_TEMP); 588 589 done: 590 vn_unlock(vdp); 591 return (error); 592 } 593 594 /* 595 * Return target name of a symbolic link 596 * Shouldn't we get the parent vnode and read the data from there? 597 * This could eventually result in deadlocks in cd9660_lookup. 598 * But otherwise the block read here is in the block buffer two times. 599 */ 600 typedef struct iso_directory_record ISODIR; 601 typedef struct iso_node ISONODE; 602 typedef struct iso_mnt ISOMNT; 603 /* 604 * cd9660_readlink(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred) 605 */ 606 static int 607 cd9660_readlink(struct vop_readlink_args *ap) 608 { 609 ISONODE *ip; 610 ISODIR *dirp; 611 ISOMNT *imp; 612 struct buf *bp; 613 struct uio *uio; 614 u_short symlen; 615 int error; 616 char *symname; 617 618 ip = VTOI(ap->a_vp); 619 imp = ip->i_mnt; 620 uio = ap->a_uio; 621 622 if (imp->iso_ftype != ISO_FTYPE_RRIP) 623 return (EINVAL); 624 625 /* 626 * Get parents directory record block that this inode included. 627 */ 628 error = bread(imp->im_devvp, 629 rounddown2((off_t)ip->i_number, 1 << imp->im_bshift), 630 imp->logical_block_size, &bp); 631 if (error) { 632 brelse(bp); 633 return (EINVAL); 634 } 635 636 /* 637 * Setup the directory pointer for this inode 638 */ 639 dirp = (ISODIR *)(bp->b_data + (ip->i_number & imp->im_bmask)); 640 641 /* 642 * Just make sure, we have a right one.... 643 * 1: Check not cross boundary on block 644 */ 645 if ((ip->i_number & imp->im_bmask) + isonum_711(dirp->length) 646 > (unsigned)imp->logical_block_size) { 647 brelse(bp); 648 return (EINVAL); 649 } 650 651 /* 652 * Now get a buffer 653 * Abuse a namei buffer for now. 654 */ 655 if (uio->uio_segflg == UIO_SYSSPACE) 656 symname = uio->uio_iov->iov_base; 657 else 658 symname = objcache_get(namei_oc, M_WAITOK); 659 660 /* 661 * Ok, we just gathering a symbolic name in SL record. 662 */ 663 if (cd9660_rrip_getsymname(dirp, symname, &symlen, imp) == 0) { 664 if (uio->uio_segflg != UIO_SYSSPACE) 665 objcache_put(namei_oc, symname); 666 brelse(bp); 667 return (EINVAL); 668 } 669 /* 670 * Don't forget before you leave from home ;-) 671 */ 672 brelse(bp); 673 674 /* 675 * return with the symbolic name to caller's. 676 */ 677 if (uio->uio_segflg != UIO_SYSSPACE) { 678 error = uiomove(symname, symlen, uio); 679 objcache_put(namei_oc, symname); 680 return (error); 681 } 682 uio->uio_resid -= symlen; 683 uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + symlen; 684 uio->uio_iov->iov_len -= symlen; 685 return (0); 686 } 687 688 /* 689 * Calculate the logical to physical mapping if not done already, 690 * then call the device strategy routine. 691 * 692 * cd9660_strategy(struct buf *a_vp, struct buf *a_bio) 693 */ 694 static int 695 cd9660_strategy(struct vop_strategy_args *ap) 696 { 697 struct bio *bio = ap->a_bio; 698 struct bio *nbio; 699 struct buf *bp = bio->bio_buf; 700 struct vnode *vp = ap->a_vp; 701 struct iso_node *ip; 702 int error; 703 704 ip = VTOI(vp); 705 if (vp->v_type == VBLK || vp->v_type == VCHR) 706 panic("cd9660_strategy: spec"); 707 nbio = push_bio(bio); 708 if (nbio->bio_offset == NOOFFSET) { 709 error = VOP_BMAP(vp, bio->bio_offset, 710 &nbio->bio_offset, NULL, NULL, bp->b_cmd); 711 if (error) { 712 bp->b_error = error; 713 bp->b_flags |= B_ERROR; 714 /* I/O was never started on nbio, must biodone(bio) */ 715 biodone(bio); 716 return (error); 717 } 718 if (nbio->bio_offset == NOOFFSET) 719 clrbuf(bp); 720 } 721 if (nbio->bio_offset == NOOFFSET) { 722 /* I/O was never started on nbio, must biodone(bio) */ 723 biodone(bio); 724 return (0); 725 } 726 vp = ip->i_devvp; 727 vn_strategy(vp, nbio); 728 return (0); 729 } 730 731 /* 732 * Print out the contents of an inode. 733 * 734 * cd9660_print(struct vnode *a_vp) 735 */ 736 static int 737 cd9660_print(struct vop_print_args *ap) 738 { 739 kprintf("tag VT_ISOFS, isofs vnode\n"); 740 return (0); 741 } 742 743 /* 744 * Return POSIX pathconf information applicable to cd9660 filesystems. 745 * 746 * cd9660_pathconf(struct vnode *a_vp, int a_name, register_t *a_retval) 747 */ 748 static int 749 cd9660_pathconf(struct vop_pathconf_args *ap) 750 { 751 switch (ap->a_name) { 752 case _PC_LINK_MAX: 753 *ap->a_retval = 1; 754 return (0); 755 case _PC_NAME_MAX: 756 if (VTOI(ap->a_vp)->i_mnt->iso_ftype == ISO_FTYPE_RRIP) 757 *ap->a_retval = NAME_MAX; 758 else 759 *ap->a_retval = 37; 760 return (0); 761 case _PC_PATH_MAX: 762 *ap->a_retval = PATH_MAX; 763 return (0); 764 case _PC_PIPE_BUF: 765 *ap->a_retval = PIPE_BUF; 766 return (0); 767 case _PC_CHOWN_RESTRICTED: 768 *ap->a_retval = 1; 769 return (0); 770 case _PC_NO_TRUNC: 771 *ap->a_retval = 1; 772 return (0); 773 default: 774 return (EINVAL); 775 } 776 /* NOTREACHED */ 777 } 778 779 /* 780 * Advisory lock support 781 */ 782 static int 783 cd9660_advlock(struct vop_advlock_args *ap) 784 { 785 struct iso_node *ip = VTOI(ap->a_vp); 786 return (lf_advlock(ap, &(ip->i_lockf), ip->i_size)); 787 } 788 789 /* 790 * Global vfs data structures for cd9660 791 */ 792 struct vop_ops cd9660_vnode_vops = { 793 .vop_default = vop_defaultop, 794 .vop_open = cd9660_open, 795 .vop_access = cd9660_access, 796 .vop_advlock = cd9660_advlock, 797 .vop_bmap = cd9660_bmap, 798 .vop_old_lookup = cd9660_lookup, 799 .vop_getattr = cd9660_getattr, 800 .vop_inactive = cd9660_inactive, 801 .vop_ioctl = cd9660_ioctl, 802 .vop_pathconf = cd9660_pathconf, 803 .vop_print = cd9660_print, 804 .vop_read = cd9660_read, 805 .vop_readdir = cd9660_readdir, 806 .vop_readlink = cd9660_readlink, 807 .vop_reclaim = cd9660_reclaim, 808 .vop_setattr = cd9660_setattr, 809 .vop_strategy = cd9660_strategy, 810 .vop_getpages = vop_stdgetpages, 811 .vop_putpages = vop_stdputpages 812 }; 813 814 /* 815 * Special device vnode ops 816 */ 817 struct vop_ops cd9660_spec_vops = { 818 .vop_default = vop_defaultop, 819 .vop_read = vop_stdnoread, 820 .vop_access = cd9660_access, 821 .vop_getattr = cd9660_getattr, 822 .vop_inactive = cd9660_inactive, 823 .vop_print = cd9660_print, 824 .vop_reclaim = cd9660_reclaim, 825 .vop_setattr = cd9660_setattr, 826 }; 827 828 struct vop_ops cd9660_fifo_vops = { 829 .vop_default = fifo_vnoperate, 830 .vop_access = cd9660_access, 831 .vop_getattr = cd9660_getattr, 832 .vop_inactive = cd9660_inactive, 833 .vop_print = cd9660_print, 834 .vop_reclaim = cd9660_reclaim, 835 .vop_setattr = cd9660_setattr, 836 }; 837