![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cd9660_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / isofs / cd9660|
Return to cd9660_lookup.c CVS log | Up to [Apple XNU] / XNU / bsd / isofs / cd9660 |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* $NetBSD: cd9660_lookup.c,v 1.13 1994/12/24 15:30:03 cgd Exp $ */ ! 23: ! 24: /*- ! 25: * Copyright (c) 1989, 1993, 1994 ! 26: * The Regents of the University of California. All rights reserved. ! 27: * ! 28: * This code is derived from software contributed to Berkeley ! 29: * by Pace Willisson ([email protected]). The Rock Ridge Extension ! 30: * Support code is derived from software contributed to Berkeley ! 31: * by Atsushi Murai ([email protected]). ! 32: * ! 33: * Redistribution and use in source and binary forms, with or without ! 34: * modification, are permitted provided that the following conditions ! 35: * are met: ! 36: * 1. Redistributions of source code must retain the above copyright ! 37: * notice, this list of conditions and the following disclaimer. ! 38: * 2. Redistributions in binary form must reproduce the above copyright ! 39: * notice, this list of conditions and the following disclaimer in the ! 40: * documentation and/or other materials provided with the distribution. ! 41: * 3. All advertising materials mentioning features or use of this software ! 42: * must display the following acknowledgement: ! 43: * This product includes software developed by the University of ! 44: * California, Berkeley and its contributors. ! 45: * 4. Neither the name of the University nor the names of its contributors ! 46: * may be used to endorse or promote products derived from this software ! 47: * without specific prior written permission. ! 48: * ! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 59: * SUCH DAMAGE. ! 60: * ! 61: * from: @(#)ufs_lookup.c 7.33 (Berkeley) 5/19/91 ! 62: * ! 63: * @(#)cd9660_lookup.c 8.5 (Berkeley) 12/5/94 ! 64: ! 65: ! 66: ! 67: * HISTORY ! 68: * 22-Jan-98 radar 1669467 - ISO 9660 CD support - jwc ! 69: ! 70: */ ! 71: ! 72: #include <sys/param.h> ! 73: #include <sys/namei.h> ! 74: #include <sys/buf.h> ! 75: #include <sys/file.h> ! 76: #include <sys/vnode.h> ! 77: #include <sys/mount.h> ! 78: ! 79: #include <isofs/cd9660/iso.h> ! 80: #include <isofs/cd9660/cd9660_node.h> ! 81: #include <isofs/cd9660/iso_rrip.h> ! 82: #include <isofs/cd9660/cd9660_rrip.h> ! 83: ! 84: struct nchstats iso_nchstats; ! 85: ! 86: /* ! 87: * Convert a component of a pathname into a pointer to a locked inode. ! 88: * This is a very central and rather complicated routine. ! 89: * If the file system is not maintained in a strict tree hierarchy, ! 90: * this can result in a deadlock situation (see comments in code below). ! 91: * ! 92: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on ! 93: * whether the name is to be looked up, created, renamed, or deleted. ! 94: * When CREATE, RENAME, or DELETE is specified, information usable in ! 95: * creating, renaming, or deleting a directory entry may be calculated. ! 96: * If flag has LOCKPARENT or'ed into it and the target of the pathname ! 97: * exists, lookup returns both the target and its parent directory locked. ! 98: * When creating or renaming and LOCKPARENT is specified, the target may ! 99: * not be ".". When deleting and LOCKPARENT is specified, the target may ! 100: * be "."., but the caller must check to ensure it does an vrele and iput ! 101: * instead of two iputs. ! 102: * ! 103: * Overall outline of ufs_lookup: ! 104: * ! 105: * check accessibility of directory ! 106: * look for name in cache, if found, then if at end of path ! 107: * and deleting or creating, drop it, else return name ! 108: * search for name in directory, to found or notfound ! 109: * notfound: ! 110: * if creating, return locked directory, leaving info on available slots ! 111: * else return error ! 112: * found: ! 113: * if at end of path and deleting, return information to allow delete ! 114: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target ! 115: * inode and return info to allow rewrite ! 116: * if not at end, add name to cache; if at end and neither creating ! 117: * nor deleting, add name to cache ! 118: * ! 119: * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked. ! 120: */ ! 121: int ! 122: cd9660_lookup(ap) ! 123: struct vop_lookup_args /* { ! 124: struct vnode *a_dvp; ! 125: struct vnode **a_vpp; ! 126: struct componentname *a_cnp; ! 127: } */ *ap; ! 128: { ! 129: register struct vnode *vdp; /* vnode for directory being searched */ ! 130: register struct iso_node *dp; /* inode for directory being searched */ ! 131: register struct iso_mnt *imp; /* file system that directory is in */ ! 132: struct buf *bp; /* a buffer of directory entries */ ! 133: struct iso_directory_record *ep = NULL;/* the current directory entry */ ! 134: int entryoffsetinblock; /* offset of ep in bp's buffer */ ! 135: int saveoffset = 0; /* offset of last directory entry in dir */ ! 136: int numdirpasses; /* strategy for directory search */ ! 137: doff_t endsearch; /* offset to end directory search */ ! 138: struct vnode *pdp; /* saved dp during symlink work */ ! 139: struct vnode *tdp; /* returned by cd9660_vget_internal */ ! 140: u_long bmask; /* block offset mask */ ! 141: int lockparent; /* 1 => lockparent flag is set */ ! 142: int wantparent; /* 1 => wantparent or lockparent flag */ ! 143: int error; ! 144: ino_t ino = 0; ! 145: int reclen; ! 146: u_short namelen; ! 147: char altname[NAME_MAX]; ! 148: int res; ! 149: int assoc, len; ! 150: char *name; ! 151: struct vnode **vpp = ap->a_vpp; ! 152: struct componentname *cnp = ap->a_cnp; ! 153: struct ucred *cred = cnp->cn_cred; ! 154: int flags = cnp->cn_flags; ! 155: int nameiop = cnp->cn_nameiop; ! 156: #ifdef NeXT ! 157: int devBlockSize=0; ! 158: #endif /* NeXT */ ! 159: ! 160: bp = NULL; ! 161: *vpp = NULL; ! 162: vdp = ap->a_dvp; ! 163: dp = VTOI(vdp); ! 164: imp = dp->i_mnt; ! 165: lockparent = flags & LOCKPARENT; ! 166: wantparent = flags & (LOCKPARENT|WANTPARENT); ! 167: ! 168: /* ! 169: * Check accessiblity of directory. ! 170: */ ! 171: if (vdp->v_type != VDIR) ! 172: return (ENOTDIR); ! 173: if ( (error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc)) ) // radar 1669467 - fix compiler warning ! 174: return (error); ! 175: ! 176: /* ! 177: * We now have a segment name to search for, and a directory to search. ! 178: * ! 179: * Before tediously performing a linear scan of the directory, ! 180: * check the name cache to see if the directory/name pair ! 181: * we are looking for is known already. ! 182: */ ! 183: if ( (error = cache_lookup(vdp, vpp, cnp)) ) { // radar 1669467 - fix compiler warning ! 184: int vpid; /* capability number of vnode */ ! 185: ! 186: if (error == ENOENT) ! 187: return (error); ! 188: #ifdef PARANOID ! 189: if ((vdp->v_flag & VROOT) && (flags & ISDOTDOT)) ! 190: panic("cd9660_lookup: .. through root"); ! 191: #endif ! 192: /* ! 193: * Get the next vnode in the path. ! 194: * See comment below starting `Step through' for ! 195: * an explaination of the locking protocol. ! 196: */ ! 197: pdp = vdp; ! 198: dp = VTOI(*vpp); ! 199: vdp = *vpp; ! 200: vpid = vdp->v_id; ! 201: if (pdp == vdp) { ! 202: VREF(vdp); ! 203: error = 0; ! 204: } else if (flags & ISDOTDOT) { ! 205: VOP_UNLOCK(pdp, 0, cnp->cn_proc); ! 206: error = vget(vdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc); ! 207: if (!error && lockparent && (flags & ISLASTCN)) ! 208: error = VOP_LOCK(pdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc); ! 209: } else { ! 210: error = vget(vdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc); ! 211: if (!lockparent || error || !(flags & ISLASTCN)) ! 212: VOP_UNLOCK(pdp, 0, cnp->cn_proc); ! 213: } ! 214: /* ! 215: * Check that the capability number did not change ! 216: * while we were waiting for the lock. ! 217: */ ! 218: if (!error) { ! 219: if (vpid == vdp->v_id) ! 220: return (0); ! 221: vput(vdp); ! 222: if (lockparent && pdp != vdp && (flags & ISLASTCN)) ! 223: VOP_UNLOCK(pdp, 0, cnp->cn_proc); ! 224: } ! 225: if ( (error = VOP_LOCK(pdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc)) ) // radar 1669467 - fix compiler warning ! 226: return (error); ! 227: vdp = pdp; ! 228: dp = VTOI(pdp); ! 229: *vpp = NULL; ! 230: } ! 231: ! 232: len = cnp->cn_namelen; ! 233: name = cnp->cn_nameptr; ! 234: /* ! 235: * A leading `=' means, we are looking for an associated file ! 236: */ ! 237: if ( (assoc = (imp->iso_ftype != ISO_FTYPE_RRIP && *name == ASSOCCHAR)) ) { // radar 1669467 - fix compiler warning ! 238: len--; ! 239: name++; ! 240: } ! 241: ! 242: /* ! 243: * If there is cached information on a previous search of ! 244: * this directory, pick up where we last left off. ! 245: * We cache only lookups as these are the most common ! 246: * and have the greatest payoff. Caching CREATE has little ! 247: * benefit as it usually must search the entire directory ! 248: * to determine that the entry does not exist. Caching the ! 249: * location of the last DELETE or RENAME has not reduced ! 250: * profiling time and hence has been removed in the interest ! 251: * of simplicity. ! 252: */ ! 253: bmask = imp->im_bmask; ! 254: if (nameiop != LOOKUP || dp->i_diroff == 0 || ! 255: dp->i_diroff > dp->i_size) { ! 256: entryoffsetinblock = 0; ! 257: dp->i_offset = 0; ! 258: numdirpasses = 1; ! 259: } else { ! 260: dp->i_offset = dp->i_diroff; ! 261: ! 262: if ((entryoffsetinblock = dp->i_offset & bmask) && ! 263: (error = VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp))) ! 264: return (error); ! 265: numdirpasses = 2; ! 266: iso_nchstats.ncs_2passes++; ! 267: } ! 268: endsearch = dp->i_size; ! 269: ! 270: searchloop: ! 271: while (dp->i_offset < endsearch) { ! 272: /* ! 273: * If offset is on a block boundary, ! 274: * read the next directory block. ! 275: * Release previous if it exists. ! 276: */ ! 277: if ((dp->i_offset & bmask) == 0) { ! 278: if (bp != NULL) ! 279: brelse(bp); ! 280: if ( (error = VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp)) ) // radar 1669467 - fix compiler warning ! 281: return (error); ! 282: entryoffsetinblock = 0; ! 283: } ! 284: /* ! 285: * Get pointer to next entry. ! 286: */ ! 287: ep = (struct iso_directory_record *) ! 288: ((char *)bp->b_data + entryoffsetinblock); ! 289: ! 290: reclen = isonum_711(ep->length); ! 291: if (reclen == 0) { ! 292: /* skip to next block, if any */ ! 293: dp->i_offset = ! 294: (dp->i_offset & ~bmask) + imp->logical_block_size; ! 295: continue; ! 296: } ! 297: ! 298: if (reclen < ISO_DIRECTORY_RECORD_SIZE) ! 299: /* illegal entry, stop */ ! 300: break; ! 301: ! 302: if (entryoffsetinblock + reclen > imp->logical_block_size) ! 303: /* entries are not allowed to cross boundaries */ ! 304: break; ! 305: ! 306: namelen = isonum_711(ep->name_len); ! 307: ! 308: if (reclen < ISO_DIRECTORY_RECORD_SIZE + namelen) ! 309: /* illegal entry, stop */ ! 310: break; ! 311: ! 312: /* ! 313: * Check for a name match. ! 314: */ ! 315: switch (imp->iso_ftype) { ! 316: default: ! 317: if ((!(isonum_711(ep->flags) & associatedBit)) == !assoc) { ! 318: if ((len == 1 ! 319: && *name == '.') ! 320: || (flags & ISDOTDOT)) { ! 321: if (namelen == 1 ! 322: && ep->name[0] == ((flags & ISDOTDOT) ? 1 : 0)) { ! 323: /* ! 324: * Save directory entry's inode number and ! 325: * release directory buffer. ! 326: */ ! 327: dp->i_ino = isodirino(ep, imp); ! 328: goto found; ! 329: } ! 330: if (namelen != 1 ! 331: || ep->name[0] != 0) ! 332: goto notfound; ! 333: } else if (!(res = isofncmp(name,len, ! 334: ep->name,namelen))) { ! 335: #if 1 // radar 1669467 - make it pretty ! 336: if ( isonum_711(ep->flags) & directoryBit ) ! 337: #else ! 338: if (isonum_711(ep->flags)&2) ! 339: #endif // radar 1669467 ! 340: ino = isodirino(ep, imp); ! 341: else ! 342: { ! 343: #if 1 // radar 1669467 - use im_bshift to convert block offset to byte offset ! 344: ino = (bp->b_blkno << imp->im_bshift) + entryoffsetinblock; ! 345: #else ! 346: ino = dbtob(bp->b_blkno) + entryoffsetinblock; ! 347: #endif // radar 1669467 ! 348: } ! 349: saveoffset = dp->i_offset; ! 350: } else if (ino) ! 351: goto foundino; ! 352: #ifdef NOSORTBUG /* On some CDs directory entries are not sorted correctly */ ! 353: else if (res < 0) ! 354: goto notfound; ! 355: else if (res > 0 && numdirpasses == 2) ! 356: numdirpasses++; ! 357: #endif ! 358: } ! 359: break; ! 360: case ISO_FTYPE_RRIP: ! 361: #if 1 // radar 1669467 - make it pretty ! 362: if ( isonum_711(ep->flags) & directoryBit ) ! 363: #else ! 364: if (isonum_711(ep->flags)&2) ! 365: #endif // radar 1669467 ! 366: ino = isodirino(ep, imp); ! 367: else ! 368: { ! 369: #if 1 // radar 1669467 - use im_bshift to convert block offset to byte offset ! 370: ino = (bp->b_blkno << imp->im_bshift) + entryoffsetinblock; ! 371: #else ! 372: ino = dbtob(bp->b_blkno) + entryoffsetinblock; ! 373: #endif // radar 1669467 ! 374: } ! 375: dp->i_ino = ino; ! 376: cd9660_rrip_getname(ep,altname,&namelen,&dp->i_ino,imp); ! 377: if (namelen == cnp->cn_namelen ! 378: && !bcmp(name,altname,namelen)) ! 379: goto found; ! 380: ino = 0; ! 381: break; ! 382: } ! 383: dp->i_offset += reclen; ! 384: entryoffsetinblock += reclen; ! 385: } // end of while (dp->i_offset < endsearch) ! 386: ! 387: if (ino) { ! 388: foundino: ! 389: dp->i_ino = ino; ! 390: if (saveoffset != dp->i_offset) { ! 391: if (lblkno(imp, dp->i_offset) != ! 392: lblkno(imp, saveoffset)) { ! 393: if (bp != NULL) ! 394: brelse(bp); ! 395: if ( (error = VOP_BLKATOFF(vdp, (off_t)saveoffset, NULL, &bp)) ) // radar 1669467 - fix compiler warning ! 396: return (error); ! 397: } ! 398: entryoffsetinblock = saveoffset & bmask; ! 399: ep = (struct iso_directory_record *) ! 400: ((char *)bp->b_data + entryoffsetinblock); ! 401: dp->i_offset = saveoffset; ! 402: } ! 403: goto found; ! 404: } ! 405: notfound: ! 406: /* ! 407: * If we started in the middle of the directory and failed ! 408: * to find our target, we must check the beginning as well. ! 409: */ ! 410: if (numdirpasses == 2) { ! 411: numdirpasses--; ! 412: dp->i_offset = 0; ! 413: endsearch = dp->i_diroff; ! 414: goto searchloop; ! 415: } ! 416: if (bp != NULL) ! 417: brelse(bp); ! 418: ! 419: /* ! 420: * Insert name into cache (as non-existent) if appropriate. ! 421: */ ! 422: if (cnp->cn_flags & MAKEENTRY) ! 423: cache_enter(vdp, *vpp, cnp); ! 424: if (nameiop == CREATE || nameiop == RENAME) ! 425: { ! 426: // radar 1669467 return EROFS (NOT EJUSTRETURN). The caller will then unlock ! 427: // the parentfor us. ! 428: return (EROFS); ! 429: } ! 430: return (ENOENT); ! 431: ! 432: found: ! 433: if (numdirpasses == 2) ! 434: iso_nchstats.ncs_pass2++; ! 435: ! 436: /* ! 437: * Found component in pathname. ! 438: * If the final component of path name, save information ! 439: * in the cache as to where the entry was found. ! 440: */ ! 441: if ((flags & ISLASTCN) && nameiop == LOOKUP) ! 442: dp->i_diroff = dp->i_offset; ! 443: ! 444: /* ! 445: * Step through the translation in the name. We do not `iput' the ! 446: * directory because we may need it again if a symbolic link ! 447: * is relative to the current directory. Instead we save it ! 448: * unlocked as "pdp". We must get the target inode before unlocking ! 449: * the directory to insure that the inode will not be removed ! 450: * before we get it. We prevent deadlock by always fetching ! 451: * inodes from the root, moving down the directory tree. Thus ! 452: * when following backward pointers ".." we must unlock the ! 453: * parent directory before getting the requested directory. ! 454: * There is a potential race condition here if both the current ! 455: * and parent directories are removed before the `iget' for the ! 456: * inode associated with ".." returns. We hope that this occurs ! 457: * infrequently since we cannot avoid this race condition without ! 458: * implementing a sophisticated deadlock detection algorithm. ! 459: * Note also that this simple deadlock detection scheme will not ! 460: * work if the file system has any hard links other than ".." ! 461: * that point backwards in the directory structure. ! 462: */ ! 463: pdp = vdp; ! 464: /* ! 465: * If ino is different from dp->i_ino, ! 466: * it's a relocated directory. ! 467: */ ! 468: if (flags & ISDOTDOT) { ! 469: VOP_UNLOCK(pdp, 0, cnp->cn_proc); /* race to get the inode */ ! 470: error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, ! 471: dp->i_ino != ino, ep, cnp->cn_proc); ! 472: VTOI(tdp)->i_parent = VTOI(pdp)->i_number; ! 473: brelse(bp); ! 474: if (error) { ! 475: VOP_LOCK(pdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc); ! 476: return (error); ! 477: } ! 478: if (lockparent && (flags & ISLASTCN) && ! 479: (error = VOP_LOCK(pdp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc))) { ! 480: vput(tdp); ! 481: return (error); ! 482: } ! 483: *vpp = tdp; ! 484: } else if (dp->i_number == dp->i_ino) { ! 485: brelse(bp); ! 486: VREF(vdp); /* we want ourself, ie "." */ ! 487: *vpp = vdp; ! 488: } else { ! 489: error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, ! 490: dp->i_ino != ino, ep, cnp->cn_proc); ! 491: VTOI(tdp)->i_parent = VTOI(pdp)->i_number; /* save parent inode number */ ! 492: brelse(bp); ! 493: if (error) ! 494: return (error); ! 495: if (!lockparent || !(flags & ISLASTCN)) ! 496: VOP_UNLOCK(pdp, 0, cnp->cn_proc); ! 497: *vpp = tdp; ! 498: } ! 499: ! 500: /* ! 501: * Insert name into cache if appropriate. ! 502: */ ! 503: if (cnp->cn_flags & MAKEENTRY) ! 504: cache_enter(vdp, *vpp, cnp); ! 505: ! 506: return (0); ! 507: } ! 508: ! 509: ! 510: /* ! 511: * Return buffer with the contents of block "offset" from the beginning of ! 512: * directory "ip". If "res" is non-zero, fill it in with a pointer to the ! 513: * remaining space in the directory. ! 514: */ ! 515: int ! 516: cd9660_blkatoff(ap) ! 517: struct vop_blkatoff_args /* { ! 518: struct vnode *a_vp; ! 519: off_t a_offset; // in bytes!!!! ! 520: char **a_res; ! 521: struct buf **a_bpp; ! 522: } */ *ap; ! 523: { ! 524: struct iso_node *ip; ! 525: register struct iso_mnt *imp; ! 526: struct buf *bp; ! 527: daddr_t lbn; ! 528: int bsize, error; ! 529: ! 530: ip = VTOI(ap->a_vp); ! 531: imp = ip->i_mnt; ! 532: lbn = lblkno(imp, ap->a_offset); ! 533: bsize = blksize(imp, ip, lbn); ! 534: ! 535: if ( (error = bread(ap->a_vp, lbn, bsize, NOCRED, &bp)) ) { // radar 1669467 - fix compiler warning ! 536: brelse(bp); ! 537: *ap->a_bpp = NULL; ! 538: return (error); ! 539: } ! 540: if (ap->a_res) ! 541: *ap->a_res = (char *)bp->b_data + blkoff(imp, ap->a_offset); ! 542: *ap->a_bpp = bp; ! 543: ! 544: return (0); ! 545: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.