![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_readwrite.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs|
Return to hfs_readwrite.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: /*- ! 25: * Copyright (c) 1993 ! 26: * The Regents of the University of California. All rights reserved. ! 27: * ! 28: * Redistribution and use in source and binary forms, with or without ! 29: * modification, are permitted provided that the following conditions ! 30: * are met: ! 31: * 1. Redistributions of source code must retain the above copyright ! 32: * notice, this list of conditions and the following disclaimer. ! 33: * 2. Redistributions in binary form must reproduce the above copyright ! 34: * notice, this list of conditions and the following disclaimer in the ! 35: * documentation and/or other materials provided with the distribution. ! 36: * 3. All advertising materials mentioning features or use of this software ! 37: * must display the following acknowledgement: ! 38: * This product includes software developed by the University of ! 39: * California, Berkeley and its contributors. ! 40: * 4. Neither the name of the University nor the names of its contributors ! 41: * may be used to endorse or promote products derived from this software ! 42: * without specific prior written permission. ! 43: * ! 44: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 45: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 46: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 47: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 48: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 49: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 50: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 52: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 53: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 54: * SUCH DAMAGE. ! 55: * ! 56: * @(#)hfs_readwrite.c 1.0 ! 57: * derived from @(#)ufs_readwrite.c 8.11 (Berkeley) 5/8/95 ! 58: * ! 59: * (c) 1998 Apple Computer, Inc. All Rights Reserved ! 60: * (c) 1990, 1992 NeXT Computer, Inc. All Rights Reserved ! 61: * ! 62: * ! 63: * hfs_readwrite.c -- vnode operations to deal with reading and writing files. ! 64: * ! 65: * MODIFICATION HISTORY: ! 66: * 3-Feb-1999 Pat Dirks Merged in Joe's change to hfs_truncate to skip vinvalbuf if LEOF isn't changing (#2302796) ! 67: * Removed superfluous (and potentially dangerous) second call to vinvalbuf() in hfs_truncate. ! 68: * 2-Dec-1998 Pat Dirks Added support for read/write bootstrap ioctls. ! 69: * 10-Nov-1998 Pat Dirks Changed read/write/truncate logic to optimize block sizes for first extents of a file. ! 70: * Changed hfs_strategy to correct I/O sizes from cluser code I/O requests in light of ! 71: * different block sizing. Changed bexpand to handle RELEASE_BUFFER flag. ! 72: * 22-Sep-1998 Don Brady Changed truncate zero-fill to use bwrite after several bawrites have been queued. ! 73: * 11-Sep-1998 Pat Dirks Fixed buffering logic to not rely on B_CACHE, which is set for empty buffers that ! 74: * have been pre-read by cluster_read (use b_validend > 0 instead). ! 75: * 27-Aug-1998 Pat Dirks Changed hfs_truncate to use cluster_write in place of bawrite where possible. ! 76: * 25-Aug-1998 Pat Dirks Changed hfs_write to do small device-block aligned writes into buffers without doing ! 77: * read-ahead of the buffer. Added bexpand to deal with incomplete [dirty] buffers. ! 78: * Fixed can_cluster macro to use MAXPHYSIO instead of MAXBSIZE. ! 79: * 19-Aug-1998 Don Brady Remove optimization in hfs_truncate that prevented extra physical blocks from ! 80: * being truncated (radar #2265750). Also set fcb->fcbEOF before calling vinvalbuf. ! 81: * 7-Jul-1998 Pat Dirks Added code to honor IO_NOZEROFILL in hfs_truncate. ! 82: * 16-Jul-1998 Don Brady In hfs_bmap use MAXPHYSIO instead of MAXBSIZE when calling MapFileBlockC (radar #2263753). ! 83: * 16-Jul-1998 Don Brady Fix error handling in hfs_allocate (radar #2252265). ! 84: * 04-Jul-1998 chw Synchronized options in hfs_allocate with flags in call to ExtendFileC ! 85: * 25-Jun-1998 Don Brady Add missing blockNo incrementing to zero fill loop in hfs_truncate. ! 86: * 22-Jun-1998 Don Brady Add bp = NULL assignment after brelse in hfs_read. ! 87: * 4-Jun-1998 Pat Dirks Split off from hfs_vnodeops.c ! 88: */ ! 89: ! 90: #include <sys/param.h> ! 91: #include <sys/systm.h> ! 92: #include <sys/resourcevar.h> ! 93: #include <sys/kernel.h> ! 94: #include <sys/file.h> ! 95: #include <sys/stat.h> ! 96: #include <sys/buf.h> ! 97: #include <sys/proc.h> ! 98: #include <sys/conf.h> ! 99: #include <sys/mount.h> ! 100: #include <mach/machine/vm_types.h> ! 101: #include <sys/vnode.h> ! 102: //#include <sys/vnode_if.h> ! 103: #include <sys/malloc.h> ! 104: #include <sys/namei.h> ! 105: #include <sys/signalvar.h> ! 106: #include <sys/uio.h> ! 107: #include <sys/time.h> ! 108: #include <sys/attr.h> ! 109: #include <miscfs/specfs/specdev.h> ! 110: ! 111: ! 112: #include <sys/vm.h> ! 113: #include <libkern/libkern.h> ! 114: #include <mach/machine/simple_lock.h> ! 115: #include <machine/spl.h> ! 116: #include <mach/features.h> ! 117: #if MACH_NBC ! 118: #include <kern/mapfs.h> ! 119: #endif /* MACH_NBC */ ! 120: ! 121: #include "hfs.h" ! 122: #include "hfs_dbg.h" ! 123: #include "hfscommon/headers/FileMgrInternal.h" ! 124: #include "hfscommon/headers/CatalogPrivate.h" ! 125: ! 126: #define can_cluster(size) ((((size & (4096-1))) == 0) && (size <= (MAXPHYSIO/2))) ! 127: ! 128: enum { ! 129: MAXHFSFILESIZE = 0x7FFFFFFF /* this needs to go in the mount structure */ ! 130: }; ! 131: ! 132: extern void vnode_pager_setsize( struct vnode *vp, u_long nsize); ! 133: extern int vnode_uncache( struct vnode *vp); ! 134: ! 135: /* ! 136: * Enabling cluster read/write operations. ! 137: */ ! 138: extern int doclusterread; ! 139: extern int doclusterwrite; ! 140: ! 141: #if DBG_VOP_TEST_LOCKS ! 142: extern void DbgVopTest(int maxSlots, int retval, VopDbgStoreRec *VopDbgStore, char *funcname); ! 143: #endif ! 144: ! 145: int bexpand(struct buf *bp, int newsize, struct buf **nbpp, long flags); ! 146: ! 147: #if DIAGNOSTIC ! 148: void debug_check_blocksizes(struct vnode *vp); ! 149: #endif ! 150: ! 151: /***************************************************************************** ! 152: * ! 153: * Operations on vnodes ! 154: * ! 155: *****************************************************************************/ ! 156: ! 157: /* ! 158: #% read vp L L L ! 159: # ! 160: vop_read { ! 161: IN struct vnode *vp; ! 162: INOUT struct uio *uio; ! 163: IN int ioflag; ! 164: IN struct ucred *cred; ! 165: ! 166: */ ! 167: ! 168: int ! 169: hfs_read(ap) ! 170: struct vop_read_args /* { ! 171: struct vnode *a_vp; ! 172: struct uio *a_uio; ! 173: int a_ioflag; ! 174: struct ucred *a_cred; ! 175: } */ *ap; ! 176: { ! 177: register struct vnode *vp; ! 178: struct hfsnode *hp; ! 179: register struct uio *uio; ! 180: struct buf *bp; ! 181: daddr_t logBlockNo; ! 182: u_long fragSize, moveSize, startOffset, ioxfersize; ! 183: long devBlockSize = 0; ! 184: off_t bytesRemaining; ! 185: int retval; ! 186: u_short mode; ! 187: FCB *fcb; ! 188: Boolean firstpass; /* Used for cluster reading */ ! 189: int seq; /* Also used for cluster reading */ ! 190: ! 191: DBG_FUNC_NAME("hfs_read"); ! 192: DBG_VOP_LOCKS_DECL(1); ! 193: DBG_VOP_PRINT_FUNCNAME(); ! 194: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 195: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 196: ! 197: vp = ap->a_vp; ! 198: hp = VTOH(vp); ! 199: fcb = HTOFCB(hp); ! 200: mode = hp->h_meta->h_mode; ! 201: uio = ap->a_uio; ! 202: ! 203: #if DIAGNOSTIC ! 204: if (uio->uio_rw != UIO_READ) ! 205: panic("%s: mode", funcname); ! 206: #endif ! 207: ! 208: /* Can only read files */ ! 209: if (ap->a_vp->v_type != VREG && ap->a_vp->v_type != VLNK) { ! 210: DBG_VOP_LOCKS_TEST(EISDIR); ! 211: return (EISDIR); ! 212: } ! 213: DBG_VOP(("\tfile size Ox%lX\n", (UInt32)fcb->fcbEOF)); ! 214: DBG_VOP(("\tstarting at offset Ox%X of file, length Ox%X\n", (u_int)uio->uio_offset, (u_int)uio->uio_resid)); ! 215: ! 216: #if DIAGNOSTIC ! 217: debug_check_blocksizes(vp); ! 218: #endif ! 219: ! 220: /* ! 221: * If they didn't ask for any data, then we are done. ! 222: */ ! 223: if (uio->uio_resid == 0) { ! 224: DBG_VOP_LOCKS_TEST(E_NONE); ! 225: return (E_NONE); ! 226: } ! 227: ! 228: /* cant read from a negative offset */ ! 229: if (uio->uio_offset < 0) { ! 230: DBG_VOP_LOCKS_TEST(EINVAL); ! 231: return (EINVAL); ! 232: } ! 233: ! 234: if ((u_int64_t)uio->uio_offset > (u_int64_t)fcb->fcbEOF) { ! 235: if ((u_int64_t)uio->uio_offset > (u_int64_t)MAXHFSFILESIZE) ! 236: retval = EFBIG; ! 237: else ! 238: retval = E_NONE; ! 239: ! 240: DBG_VOP_LOCKS_TEST(retval); ! 241: return (retval); ! 242: } ! 243: ! 244: VOP_DEVBLOCKSIZE(hp->h_devvp, &devBlockSize); ! 245: ! 246: for (retval = 0, bp = NULL, firstpass = TRUE; uio->uio_resid > 0; bp = NULL) { ! 247: ! 248: if ((bytesRemaining = (fcb->fcbEOF - uio->uio_offset)) <= 0) ! 249: break; ! 250: ! 251: MapFileOffset(hp, uio->uio_offset, &logBlockNo, &fragSize, &startOffset); ! 252: ! 253: DBG_VOP(("\tat logBlockNo Ox%X, with Ox%lX left to read\n", logBlockNo, (UInt32)uio->uio_resid)); ! 254: moveSize = ioxfersize = fragSize; ! 255: DBG_VOP(("\tmoveSize = Ox%lX; ioxfersize = Ox%lX; startOffset = Ox%lX.\n", ! 256: moveSize, ioxfersize, startOffset)); ! 257: DBG_ASSERT(moveSize >= startOffset); ! 258: moveSize -= startOffset; ! 259: if (bytesRemaining < moveSize) moveSize = bytesRemaining; ! 260: ! 261: if (uio->uio_resid < moveSize) { ! 262: moveSize = uio->uio_resid; ! 263: DBG_VOP(("\treducing moveSize to Ox%lX (uio->uio_resid).\n", moveSize)); ! 264: }; ! 265: ! 266: if (moveSize == 0) { ! 267: break; ! 268: }; ! 269: DBG_VOP(("\tat logBlockNo Ox%X, extent of Ox%lX, xfer of Ox%lX; moveSize = Ox%lX\n", logBlockNo, fragSize, ioxfersize, moveSize)); ! 270: if (( uio->uio_offset + fragSize) >= fcb->fcbEOF) { ! 271: retval = bread(vp, logBlockNo, ioxfersize, NOCRED, &bp); ! 272: } else if (doclusterread && !(vp->v_flag & VRAOFF) && can_cluster(fragSize)) { ! 273: retval = cluster_read(vp, fcb->fcbEOF, logBlockNo, ioxfersize, NOCRED, &bp, ! 274: devBlockSize, firstpass, (uio->uio_resid + startOffset), &seq); ! 275: } else if (logBlockNo - 1 == vp->v_lastr && !(vp->v_flag & VRAOFF)) { ! 276: daddr_t nextLogBlockNo = logBlockNo + 1; ! 277: long nextsize; ! 278: int nextsize_for_bsd; ! 279: long nextblkoffset; ! 280: ! 281: MapFileOffset(hp, uio->uio_offset + fragSize, &nextLogBlockNo, &nextsize, &nextblkoffset); ! 282: /* Yuck! This copy exists just because I refuse to write the interface to MapFileOffset relying on 'int' to be 'long'... */ ! 283: nextsize_for_bsd = nextsize; ! 284: retval = breadn(vp, logBlockNo, ioxfersize, &nextLogBlockNo, &nextsize_for_bsd, 1, NOCRED, &bp); ! 285: } else { ! 286: retval = bread(vp, logBlockNo, ioxfersize, NOCRED, &bp); ! 287: }; ! 288: ! 289: if (retval != E_NONE) { ! 290: if (bp) { ! 291: brelse(bp); ! 292: bp = NULL; ! 293: } ! 294: break; ! 295: }; ! 296: ! 297: firstpass = FALSE; ! 298: ! 299: if (bp->b_validend > 0) { ! 300: /* ! 301: b_validoff, b_validend, b_dirtyoff, and b_dirtyend are valid for blocks in the cache: ! 302: The only blocks that are incomplete (b_validend < fragSize) are blocks that have been ! 303: partially written from the start of the buffer: ! 304: */ ! 305: if (bp->b_validend < bp->b_bcount) { ! 306: DBG_ASSERT((bp->b_dirtyoff == 0) && (bp->b_validoff == 0) && (bp->b_dirtyend <= bp->b_validend)); ! 307: /* Incomplete blocks must have only device-block multiples of data... */ ! 308: DBG_ASSERT((bp->b_validend % devBlockSize) == 0); ! 309: bp->b_bcount = bp->b_validend; ! 310: ! 311: if (bp->b_validend < (startOffset + moveSize)) { /* buffer doesn't hold enough valid data for this read request */ ! 312: /* We stumbled onto an incomplete [but successfully acquired] buffer: ! 313: try to get the full contents now because it's the only way to get ! 314: the data in this logical block... ! 315: */ ! 316: retval = bexpand(bp, ioxfersize, &bp, 0); ! 317: }; ! 318: }; ! 319: } else { ! 320: /* This block was newly allocated; b_validoff, b_validend, b_dirtyoff, and b_dirtyend are ! 321: all set to zero, which is fine except for b_validend: */ ! 322: DBG_ASSERT(bp->b_validoff == 0); ! 323: bp->b_validend = bp->b_bcount; ! 324: DBG_ASSERT(bp->b_dirtyoff == 0); ! 325: DBG_ASSERT(bp->b_dirtyend == 0); ! 326: }; ! 327: ! 328: vp->v_lastr = logBlockNo; ! 329: ! 330: /* ! 331: * We should only get non-zero b_resid when an I/O retval ! 332: * has occurred, which should cause us to break above. ! 333: * However, if the short read did not cause an retval, ! 334: * then we want to ensure that we do not uiomove bad ! 335: * or uninitialized data. ! 336: */ ! 337: ioxfersize -= bp->b_resid; ! 338: if (ioxfersize < moveSize) { /* XXX PPD This should take the offset into account, too! */ ! 339: if (ioxfersize == 0) ! 340: break; ! 341: moveSize = ioxfersize; ! 342: } ! 343: ! 344: DBG_VOP(("\tcopying Ox%lX bytes from %p; resid = Ox%lX...\n", moveSize, (char *)bp->b_data + startOffset, bp->b_resid)); ! 345: if ((retval = ! 346: uiomove((caddr_t)bp->b_data + startOffset, (int)moveSize, uio))) ! 347: break; ! 348: ! 349: if (S_ISREG(mode) && ! 350: (((startOffset + moveSize) == fragSize) || (uio->uio_offset == fcb->fcbEOF))) { ! 351: bp->b_flags |= B_AGE; ! 352: }; ! 353: ! 354: DBG_ASSERT(bp->b_bcount == bp->b_validend); ! 355: brelse(bp); ! 356: /* Start of loop resets bp to NULL before reaching outside this block... */ ! 357: } ! 358: ! 359: if (bp != NULL) { ! 360: DBG_ASSERT(bp->b_bcount == bp->b_validend); ! 361: brelse(bp); ! 362: }; ! 363: if (HTOVCB(hp)->vcbSigWord == kHFSPlusSigWord) ! 364: hp->h_meta->h_nodeflags |= IN_ACCESS; ! 365: ! 366: DBG_VOP_LOCKS_TEST(retval); ! 367: ! 368: #if DIAGNOSTIC ! 369: debug_check_blocksizes(vp); ! 370: #endif ! 371: ! 372: return (retval); ! 373: } ! 374: ! 375: /* ! 376: * Write data to a file or directory. ! 377: #% write vp L L L ! 378: # ! 379: vop_write { ! 380: IN struct vnode *vp; ! 381: INOUT struct uio *uio; ! 382: IN int ioflag; ! 383: IN struct ucred *cred; ! 384: ! 385: */ ! 386: int ! 387: hfs_write(ap) ! 388: struct vop_write_args /* { ! 389: struct vnode *a_vp; ! 390: struct uio *a_uio; ! 391: int a_ioflag; ! 392: struct ucred *a_cred; ! 393: } */ *ap; ! 394: { ! 395: struct hfsnode *hp = VTOH(ap->a_vp); ! 396: struct uio *uio = ap->a_uio; ! 397: struct vnode *vp = ap->a_vp ; ! 398: struct vnode *dev; ! 399: struct buf *bp; ! 400: struct proc *p, *cp; ! 401: FCB *fcb = HTOFCB(hp); ! 402: ExtendedVCB *vcb = HTOVCB(hp); ! 403: long devBlockSize = 0; ! 404: daddr_t logBlockNo; ! 405: long fragSize; ! 406: off_t origFileSize, currOffset, writelimit, bytesToAdd; ! 407: u_long blkoffset, resid, xfersize, clearSize; ! 408: UInt32 actualBytesAdded; ! 409: int flags, ioflag; ! 410: int retval; ! 411: DBG_FUNC_NAME("write"); ! 412: DBG_VOP_LOCKS_DECL(1); ! 413: DBG_VOP_PRINT_FUNCNAME(); ! 414: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 415: DBG_VOP(("\thfsnode 0x%x (%s)\n", (u_int)hp, H_NAME(hp))); ! 416: DBG_VOP(("\tstarting at offset Ox%lX of file, length Ox%lX\n", (UInt32)uio->uio_offset, (UInt32)uio->uio_resid)); ! 417: ! 418: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 419: ! 420: dev = hp->h_devvp; ! 421: ! 422: #if DIAGNOSTIC ! 423: debug_check_blocksizes(vp); ! 424: #endif ! 425: ! 426: if (uio->uio_offset < 0) { ! 427: DBG_VOP_LOCKS_TEST(EINVAL); ! 428: return (EINVAL); ! 429: } ! 430: ! 431: if (uio->uio_resid == 0) { ! 432: DBG_VOP_LOCKS_TEST(E_NONE); ! 433: return (E_NONE); ! 434: } ! 435: ! 436: if (ap->a_vp->v_type != VREG && ap->a_vp->v_type != VLNK) { /* Can only write files */ ! 437: DBG_VOP_LOCKS_TEST(EISDIR); ! 438: return (EISDIR); ! 439: }; ! 440: ! 441: (void)vnode_uncache(vp); /* XXX PPD Is this the right place to call this? It'll VOP_UNLOCK the vnode */ ! 442: ! 443: #if DIAGNOSTIC ! 444: if (uio->uio_rw != UIO_WRITE) ! 445: panic("%s: mode", funcname); ! 446: #endif ! 447: ! 448: ioflag = ap->a_ioflag; ! 449: uio = ap->a_uio; ! 450: vp = ap->a_vp; ! 451: ! 452: if (ioflag & IO_APPEND) ! 453: uio->uio_offset = fcb->fcbEOF; ! 454: if ((hp->h_meta->h_pflags & APPEND) && uio->uio_offset != fcb->fcbEOF) ! 455: return (EPERM); ! 456: ! 457: writelimit = uio->uio_offset + uio->uio_resid; ! 458: ! 459: /* ! 460: * Maybe this should be above the vnode op call, but so long as ! 461: * file servers have no limits, I don't think it matters. ! 462: */ ! 463: p = uio->uio_procp; ! 464: if (vp->v_type == VREG && p && ! 465: writelimit > p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { ! 466: psignal(p, SIGXFSZ); ! 467: return (EFBIG); ! 468: }; ! 469: VOP_DEVBLOCKSIZE(hp->h_devvp, &devBlockSize); ! 470: ! 471: resid = uio->uio_resid; ! 472: origFileSize = fcb->fcbPLen; ! 473: flags = ioflag & IO_SYNC ? B_SYNC : 0; ! 474: ! 475: DBG_VOP(("\tLEOF is 0x%lX, PEOF is 0x%lX.\n", fcb->fcbEOF, fcb->fcbPLen)); ! 476: ! 477: /* ! 478: NOTE: In the following loop there are two positions tracked: ! 479: currOffset is the current I/O starting offset. currOffset is never >LEOF; the ! 480: LEOF is nudged along with currOffset as data is zeroed or written. ! 481: uio->uio_offset is the start of the current I/O operation. It may be arbitrarily ! 482: beyond currOffset. ! 483: ! 484: The following is true at all times: ! 485: ! 486: currOffset <= LEOF <= uio->uio_offset <= writelimit ! 487: */ ! 488: currOffset = MIN(uio->uio_offset, fcb->fcbEOF); ! 489: ! 490: DBG_VOP(("\tstarting I/O loop at 0x%lX.\n", (u_long)currOffset)); ! 491: ! 492: cp = CURRENT_PROC; ! 493: ! 494: for (retval = 0; uio->uio_resid > 0;) { ! 495: /* Now test if we need to extend the file */ ! 496: /* Doing so will adjust the fcbPLen for us */ ! 497: if (writelimit > (off_t)fcb->fcbPLen) { ! 498: /* XXX PPD Allocate only 2GB at a time until ExtendFileC's interface changes... */ ! 499: bytesToAdd = writelimit - (off_t)fcb->fcbPLen; ! 500: if (bytesToAdd > (off_t)0x80000000) bytesToAdd = (off_t)0x80000000; ! 501: DBG_VOP(("\textending file by 0x%lX bytes; 0x%lX blocks free", (unsigned long)bytesToAdd, (unsigned long)vcb->vcbFreeBks)); ! 502: /* lock extents b-tree (also protects volume bitmap) */ ! 503: retval = hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_EXCLUSIVE, cp); ! 504: if (retval != E_NONE) ! 505: break; ! 506: ! 507: retval = MacToVFSError( ! 508: ExtendFileC (vcb, ! 509: fcb, ! 510: (unsigned long)bytesToAdd, ! 511: kEFContigBit, ! 512: &actualBytesAdded)); ! 513: ! 514: (void) hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_RELEASE, cp); ! 515: DBG_VOP_CONT(("\tactual bytes added = 0x%lX bytes, retval = %d...\n", actualBytesAdded, retval)); ! 516: if ((actualBytesAdded == 0) && (retval == 0)) retval = ENOSPC; ! 517: if (retval != E_NONE) ! 518: break; ! 519: ! 520: UpdateBlockMappingTable(hp); ! 521: ! 522: /* We successfully extended the file: take a fresh look to see how things have changed... */ ! 523: continue; ! 524: }; ! 525: ! 526: /* What block are we starting the write */ ! 527: MapFileOffset(hp, currOffset, &logBlockNo, &fragSize, &blkoffset); ! 528: ! 529: xfersize = fragSize - blkoffset; ! 530: ! 531: DBG_VOP(("\tcurrOffset = Ox%lX, logBlockNo = Ox%X, blkoffset = Ox%lX, xfersize = Ox%lX, fragSize = Ox%lX.\n", ! 532: (unsigned long)currOffset, logBlockNo, blkoffset, xfersize, fragSize)); ! 533: ! 534: /* Make any adjustments for boundary conditions */ ! 535: if (currOffset + (off_t)xfersize > writelimit) { ! 536: xfersize = writelimit - currOffset; ! 537: DBG_VOP(("\ttrimming xfersize to 0x%lX to match writelimit (uio_resid)...\n", xfersize)); ! 538: }; ! 539: ! 540: /* ! 541: * There is no need to read into bp if: ! 542: * We start on a block boundary and will overwrite the whole block ! 543: * ! 544: * OR ! 545: * ! 546: * The transfer starts on a device block boundary and is an even ! 547: * multiple of the device block size (in which case we'll write ! 548: * through the data presented) ! 549: * ! 550: */ ! 551: if ((blkoffset == 0) && ((xfersize >= fragSize) || (xfersize % devBlockSize == 0))) { ! 552: DBG_VOP(("\tRequesting %ld-byte block Ox%lX w/o read...\n", fragSize, (long)logBlockNo)); ! 553: bp = getblk(vp, logBlockNo, fragSize, 0, 0); ! 554: retval = 0; ! 555: if (bp->b_blkno == -1) { ! 556: brelse(bp); ! 557: retval = EIO; /* XXX */ ! 558: break; ! 559: } ! 560: ! 561: if (bp->b_flags & (B_DELWRI | B_DONE | B_CACHE)) { ! 562: /* ! 563: This buffer is fully pre-read and may already have some modified data in it: ! 564: it doesn't need special-casing for write-through. ! 565: */ ! 566: } else { ! 567: /* This is an empty buffer just allocated for our use: ! 568: b_validoff, b_validend, b_dirtyoff, and b_dirtyend are all zero, ! 569: which is exactly right (b_bcount is set to fragSize). */ ! 570: ! 571: /* XXX PPD Can't this be skipped if b_blkno != logBlockNo? */ ! 572: ! 573: /* Setting up the physical block number is required ! 574: (1) to keep cluster_write informed about which blocks can be clustered, and ! 575: (2) to avoid a second call to bmap() in strategy() on the write. ! 576: */ ! 577: if ((retval = VOP_BMAP(vp, logBlockNo, NULL, &bp->b_blkno, NULL))) { ! 578: brelse(bp); ! 579: break; ! 580: }; ! 581: ! 582: bp->b_bcount = 0; /* No valid data in block yet */ ! 583: bp->b_validend = 0; /* No valid data in block yet */ ! 584: }; ! 585: } else { ! 586: /* ! 587: * This I/O transfer is not sufficiently aligned, so read the affected block into a buffer: ! 588: */ ! 589: DBG_VOP(("\tRequesting block Ox%X, size = 0x%08lX...\n", logBlockNo, fragSize)); ! 590: retval = bread(vp, logBlockNo, fragSize, ap->a_cred, &bp); ! 591: if (retval != E_NONE) { ! 592: if (bp) brelse(bp); ! 593: break; ! 594: } ! 595: } ! 596: ! 597: /* Fix up the anciliary fields for this buffer, depending on whether they've been initialized yet: */ ! 598: if (bp->b_validend > 0) { ! 599: /* ! 600: b_validoff, b_validend, b_dirtyoff, and b_dirtyend are valid for blocks in the cache: ! 601: The only blocks that are incomplete (b_validend < fragSize) are blocks that have been ! 602: partially written from the start of the buffer: ! 603: */ ! 604: if (bp->b_validend < bp->b_bcount) { ! 605: DBG_ASSERT((bp->b_dirtyoff == 0) && (bp->b_validoff == 0) && (bp->b_dirtyend <= bp->b_validend)); ! 606: /* Incomplete blocks must have only device-block multiples of data... */ ! 607: DBG_ASSERT((bp->b_validend % devBlockSize) == 0); ! 608: bp->b_bcount = bp->b_validend; ! 609: ! 610: if ((bp->b_validend < blkoffset) || /* ... valid data does not overlap (or at least abut) start of new write */ ! 611: (bp->b_bufsize < (blkoffset + xfersize)) || /* ... or isn't enough buffer space to hold entire transfer */ ! 612: ((blkoffset + xfersize) % devBlockSize != 0)) { /* ... or won't leave blocksize-multiple of dirty bytes */ ! 613: /* We stumbled onto an incomplete [but successfully acquired] buffer: ! 614: try to get the full contents now because it's the only way to get ! 615: the data in this logical block... ! 616: */ ! 617: retval = bexpand(bp, fragSize, &bp, 0); ! 618: }; ! 619: }; ! 620: } else { ! 621: /* This buffer was either just allocated or just read in its entirity [see b_bcount]: ! 622: b_validoff, b_validend, b_dirtyoff, and b_dirtyend are all zeroed, which is almost correct. */ ! 623: DBG_ASSERT(bp->b_validoff == 0); ! 624: bp->b_validend = bp->b_bcount; /* b_bcount > 0 iff block was actually read from disk in bread */ ! 625: DBG_ASSERT(bp->b_dirtyoff == 0); ! 626: DBG_ASSERT(bp->b_dirtyend == 0); ! 627: }; ! 628: ! 629: /* See if we are starting to write within file boundaries: ! 630: If not, then we need to present a "hole" for the area between ! 631: the current EOF and the start of the current I/O operation: ! 632: ! 633: Note that currOffset is only less than uio_offset if uio_offset > LEOF... ! 634: */ ! 635: if (uio->uio_offset > currOffset) { ! 636: clearSize = MIN(uio->uio_offset - currOffset, xfersize); ! 637: DBG_VOP(("\tzeroing Ox%lX bytes Ox%lX bytes into block Ox%X...\n", clearSize, blkoffset, logBlockNo)); ! 638: bzero(bp->b_data + blkoffset, clearSize); ! 639: currOffset += clearSize; ! 640: blkoffset += clearSize; ! 641: xfersize -= clearSize; ! 642: }; ! 643: ! 644: if (xfersize > 0) { ! 645: DBG_VOP(("\tCopying Ox%lX bytes Ox%lX bytes into block Ox%X... ioflag == 0x%X\n", ! 646: xfersize, blkoffset, logBlockNo, ioflag)); ! 647: retval = uiomove((caddr_t)bp->b_data + blkoffset, (int)xfersize, uio); ! 648: currOffset += xfersize; ! 649: }; ! 650: ! 651: if (blkoffset + xfersize > bp->b_dirtyend) bp->b_dirtyend = blkoffset + xfersize; /* Newly written data is now [also] dirty */ ! 652: if (bp->b_dirtyend > bp->b_validend) bp->b_validend = bp->b_dirtyend; /* Data just written is now valid, too */ ! 653: bp->b_bcount = bp->b_validend; ! 654: ! 655: DBG_ASSERT((bp->b_bcount % devBlockSize) == 0); ! 656: DBG_ASSERT(bp->b_bcount == bp->b_validend); ! 657: if (ioflag & IO_SYNC) { ! 658: (void)bwrite(bp); ! 659: //DBG_VOP(("\tissuing bwrite\n")); ! 660: } else if ((xfersize + blkoffset) == fragSize) { ! 661: if (doclusterwrite && can_cluster(fragSize)) { ! 662: //DBG_VOP(("\tissuing cluster_write\n")); ! 663: cluster_write(bp, fcb->fcbPLen, devBlockSize); ! 664: } else { ! 665: //DBG_VOP(("\tissuing bawrite\n")); ! 666: bp->b_flags |= B_AGE; ! 667: bawrite(bp); ! 668: } ! 669: } else { ! 670: //DBG_VOP(("\tissuing bdwrite\n")); ! 671: bdwrite(bp); ! 672: }; ! 673: ! 674: /* Update the EOF if we just extended the file ! 675: (the PEOF has already been moved out and the block mapping table has been updated): */ ! 676: if (currOffset > fcb->fcbEOF) { ! 677: DBG_VOP(("\textending EOF to 0x%lX...\n", fcb->fcbEOF)); ! 678: fcb->fcbEOF = currOffset; ! 679: #if MACH_NBC ! 680: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) { ! 681: #endif /* MACH_NBC */ ! 682: vnode_pager_setsize(vp, (u_long)fcb->fcbEOF); ! 683: #if MACH_NBC ! 684: } ! 685: #endif /* MACH_NBC */ ! 686: }; ! 687: ! 688: if (retval || (resid == 0)) ! 689: break; ! 690: hp->h_meta->h_nodeflags |= IN_CHANGE | IN_UPDATE; ! 691: }; ! 692: /* ! 693: * If we successfully wrote any data, and we are not the superuser ! 694: * we clear the setuid and setgid bits as a precaution against ! 695: * tampering. ! 696: */ ! 697: if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0) ! 698: hp->h_meta->h_mode &= ~(ISUID | ISGID); ! 699: if (retval) { ! 700: if (ioflag & IO_UNIT) { ! 701: (void)VOP_TRUNCATE(vp, origFileSize, ! 702: ioflag & IO_SYNC, ap->a_cred, uio->uio_procp); ! 703: uio->uio_offset -= resid - uio->uio_resid; ! 704: uio->uio_resid = resid; ! 705: } ! 706: } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) ! 707: retval = VOP_UPDATE(vp, &time, &time, 1); ! 708: ! 709: #if DIAGNOSTIC ! 710: debug_check_blocksizes(vp); ! 711: #endif ! 712: ! 713: DBG_VOP_LOCKS_TEST(retval); ! 714: return (retval); ! 715: } ! 716: ! 717: ! 718: /* ! 719: ! 720: #% ioctl vp U U U ! 721: # ! 722: vop_ioctl { ! 723: IN struct vnode *vp; ! 724: IN u_long command; ! 725: IN caddr_t data; ! 726: IN int fflag; ! 727: IN struct ucred *cred; ! 728: IN struct proc *p; ! 729: ! 730: */ ! 731: ! 732: ! 733: /* ARGSUSED */ ! 734: int ! 735: hfs_ioctl(ap) ! 736: struct vop_ioctl_args /* { ! 737: struct vnode *a_vp; ! 738: int a_command; ! 739: caddr_t a_data; ! 740: int a_fflag; ! 741: struct ucred *a_cred; ! 742: struct proc *a_p; ! 743: } */ *ap; ! 744: { ! 745: DBG_FUNC_NAME("ioctl"); ! 746: DBG_VOP_LOCKS_DECL(1); ! 747: DBG_VOP_PRINT_FUNCNAME(); ! 748: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 749: ! 750: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_UNLOCKED, VOPDBG_POS); ! 751: ! 752: switch (ap->a_command) { ! 753: ! 754: case 1: ! 755: { register struct hfsnode *hp; ! 756: register struct vnode *vp; ! 757: register struct radvisory *ra; ! 758: FCB *fcb; ! 759: int devBlockSize = 0; ! 760: int error; ! 761: long size; ! 762: daddr_t lbn; ! 763: ! 764: vp = ap->a_vp; ! 765: ! 766: VOP_LEASE(vp, ap->a_p, ap->a_cred, LEASE_READ); ! 767: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_p); ! 768: ! 769: ra = (struct radvisory *)(ap->a_data); ! 770: hp = VTOH(vp); ! 771: ! 772: fcb = HTOFCB(hp); ! 773: ! 774: if ((u_int64_t)ra->ra_offset >= (u_int64_t)fcb->fcbEOF) { ! 775: VOP_UNLOCK(vp, 0, ap->a_p); ! 776: DBG_VOP_LOCKS_TEST(EFBIG); ! 777: return (EFBIG); ! 778: } ! 779: VOP_DEVBLOCKSIZE(hp->h_devvp, &devBlockSize); ! 780: size = hp->h_meta->h_logBlockSize; ! 781: ! 782: if ( !(can_cluster(size))) { ! 783: VOP_UNLOCK(vp, 0, ap->a_p); ! 784: DBG_VOP_LOCKS_TEST(EINVAL); ! 785: return (EINVAL); ! 786: } ! 787: size = MIN(size, MAXBSIZE); ! 788: lbn = ra->ra_offset / size; ! 789: ! 790: error = advisory_read(vp, fcb->fcbEOF, lbn, size, size, ra->ra_count, devBlockSize); ! 791: VOP_UNLOCK(vp, 0, ap->a_p); ! 792: ! 793: DBG_VOP_LOCKS_TEST(error); ! 794: return (error); ! 795: } ! 796: ! 797: case 2: /* F_READBOOTBLOCKS */ ! 798: case 3: /* F_WRITEBOOTBLOCKS */ ! 799: { ! 800: struct vnode *vp = ap->a_vp; ! 801: struct hfsnode *hp = VTOH(vp); ! 802: struct fbootstraptransfer *btd = (struct fbootstraptransfer *)ap->a_data; ! 803: u_long devBlockSize; ! 804: int error; ! 805: struct iovec aiov; ! 806: struct uio auio; ! 807: u_long blockNumber; ! 808: u_long blockOffset; ! 809: u_long xfersize; ! 810: struct buf *bp; ! 811: ! 812: if ((vp->v_flag & VROOT) == 0) return EINVAL; ! 813: if (btd->fbt_offset + btd->fbt_length > 1024) return EINVAL; ! 814: ! 815: aiov.iov_base = btd->fbt_buffer; ! 816: aiov.iov_len = btd->fbt_length; ! 817: ! 818: auio.uio_iov = &aiov; ! 819: auio.uio_iovcnt = 1; ! 820: auio.uio_offset = btd->fbt_offset; ! 821: auio.uio_resid = btd->fbt_length; ! 822: auio.uio_segflg = UIO_USERSPACE; ! 823: auio.uio_rw = (ap->a_command == 3) ? UIO_WRITE : UIO_READ; /* F_WRITEBOOTSTRAP / F_READBOOTSTRAP */ ! 824: auio.uio_procp = ap->a_p; ! 825: ! 826: VOP_DEVBLOCKSIZE(hp->h_devvp, &devBlockSize); ! 827: ! 828: while (auio.uio_resid > 0) { ! 829: blockNumber = auio.uio_offset / devBlockSize; ! 830: error = bread(hp->h_devvp, blockNumber, devBlockSize, ap->a_cred, &bp); ! 831: if (error) { ! 832: if (bp) brelse(bp); ! 833: return error; ! 834: }; ! 835: ! 836: blockOffset = auio.uio_offset % devBlockSize; ! 837: xfersize = devBlockSize - blockOffset; ! 838: error = uiomove((caddr_t)bp->b_data + blockOffset, (int)xfersize, &auio); ! 839: if (error) { ! 840: brelse(bp); ! 841: return error; ! 842: }; ! 843: if (auio.uio_rw == UIO_WRITE) { ! 844: error = bwrite(bp); ! 845: if (error) return error; ! 846: } else { ! 847: brelse(bp); ! 848: }; ! 849: }; ! 850: }; ! 851: return 0; ! 852: ! 853: default: ! 854: DBG_VOP_LOCKS_TEST(ENOTTY); ! 855: return (ENOTTY); ! 856: } ! 857: ! 858: return 0; ! 859: } ! 860: ! 861: /* ARGSUSED */ ! 862: int ! 863: hfs_select(ap) ! 864: struct vop_select_args /* { ! 865: struct vnode *a_vp; ! 866: int a_which; ! 867: int a_fflags; ! 868: struct ucred *a_cred; ! 869: struct proc *a_p; ! 870: } */ *ap; ! 871: { ! 872: DBG_FUNC_NAME("select"); ! 873: DBG_VOP_LOCKS_DECL(1); ! 874: DBG_VOP_PRINT_FUNCNAME(); ! 875: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 876: ! 877: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 878: ! 879: /* ! 880: * We should really check to see if I/O is possible. ! 881: */ ! 882: DBG_VOP_LOCKS_TEST(1); ! 883: return (1); ! 884: } ! 885: ! 886: ! 887: ! 888: /* ! 889: * Mmap a file ! 890: * ! 891: * NB Currently unsupported. ! 892: # XXX - not used ! 893: # ! 894: vop_mmap { ! 895: IN struct vnode *vp; ! 896: IN int fflags; ! 897: IN struct ucred *cred; ! 898: IN struct proc *p; ! 899: ! 900: */ ! 901: ! 902: /* ARGSUSED */ ! 903: ! 904: int ! 905: hfs_mmap(ap) ! 906: struct vop_mmap_args /* { ! 907: struct vnode *a_vp; ! 908: int a_fflags; ! 909: struct ucred *a_cred; ! 910: struct proc *a_p; ! 911: } */ *ap; ! 912: { ! 913: DBG_FUNC_NAME("mmap"); ! 914: DBG_VOP_LOCKS_DECL(1); ! 915: DBG_VOP_PRINT_FUNCNAME(); ! 916: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 917: ! 918: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 919: ! 920: DBG_VOP_LOCKS_TEST(EINVAL); ! 921: return (EINVAL); ! 922: } ! 923: ! 924: ! 925: ! 926: /* ! 927: * Seek on a file ! 928: * ! 929: * Nothing to do, so just return. ! 930: # XXX - not used ! 931: # Needs work: Is newoff right? What's it mean? ! 932: # ! 933: vop_seek { ! 934: IN struct vnode *vp; ! 935: IN off_t oldoff; ! 936: IN off_t newoff; ! 937: IN struct ucred *cred; ! 938: */ ! 939: /* ARGSUSED */ ! 940: int ! 941: hfs_seek(ap) ! 942: struct vop_seek_args /* { ! 943: struct vnode *a_vp; ! 944: off_t a_oldoff; ! 945: off_t a_newoff; ! 946: struct ucred *a_cred; ! 947: } */ *ap; ! 948: { ! 949: DBG_FUNC_NAME("seek"); ! 950: DBG_VOP_LOCKS_DECL(1); ! 951: DBG_VOP_PRINT_FUNCNAME(); ! 952: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 953: ! 954: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 955: ! 956: DBG_VOP_LOCKS_TEST(E_NONE); ! 957: return (E_NONE); ! 958: } ! 959: ! 960: ! 961: /* ! 962: * Bmap converts a the logical block number of a file to its physical block ! 963: * number on the disk. ! 964: */ ! 965: ! 966: /* ! 967: * vp - address of vnode file the file ! 968: * bn - which logical block to convert to a physical block number. ! 969: * vpp - returns the vnode for the block special file holding the filesystem ! 970: * containing the file of interest ! 971: * bnp - address of where to return the filesystem physical block number ! 972: #% bmap vp L L L ! 973: #% bmap vpp - U - ! 974: # ! 975: vop_bmap { ! 976: IN struct vnode *vp; ! 977: IN daddr_t bn; ! 978: OUT struct vnode **vpp; ! 979: IN daddr_t *bnp; ! 980: OUT int *runp; ! 981: */ ! 982: /* ! 983: * Converts a logical block number to a physical block, and optionally returns ! 984: * the amount of remaining blocks in a run. The logical block is based on hfsNode.logBlockSize. ! 985: * The physical block number is based on the device block size, currently its 512. ! 986: * The block run is returned in logical blocks, and is the REMAINING amount of blocks ! 987: */ ! 988: ! 989: int ! 990: hfs_bmap(ap) ! 991: struct vop_bmap_args /* { ! 992: struct vnode *a_vp; ! 993: daddr_t a_bn; ! 994: struct vnode **a_vpp; ! 995: daddr_t *a_bnp; ! 996: int *a_runp; ! 997: } */ *ap; ! 998: { ! 999: struct hfsnode *hp = VTOH(ap->a_vp); ! 1000: struct hfsmount *hfsmp = VTOHFS(ap->a_vp); ! 1001: int retval = E_NONE; ! 1002: daddr_t logBlockSize; ! 1003: UInt32 bytesContAvail = 0; ! 1004: struct proc *p = NULL; ! 1005: int lockExtBtree; ! 1006: ! 1007: #define DEBUG_BMAP 0 ! 1008: #if DEBUG_BMAP ! 1009: DBG_FUNC_NAME("bmap"); ! 1010: DBG_VOP_LOCKS_DECL(2); ! 1011: DBG_VOP_PRINT_FUNCNAME(); ! 1012: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP((": %d --> ", ap->a_bn)); ! 1013: ! 1014: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 1015: if (ap->a_vpp != NULL) { ! 1016: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_UNLOCKED, VOPDBG_IGNORE, VOPDBG_POS); ! 1017: } else { ! 1018: DBG_VOP_LOCKS_INIT(1,NULL, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 1019: }; ! 1020: #endif ! 1021: ! 1022: /* ! 1023: * Check for underlying vnode requests and ensure that logical ! 1024: * to physical mapping is requested. ! 1025: */ ! 1026: if (ap->a_vpp != NULL) ! 1027: *ap->a_vpp = VTOH(ap->a_vp)->h_devvp; ! 1028: if (ap->a_bnp == NULL) ! 1029: return (0); ! 1030: ! 1031: lockExtBtree = hasOverflowExtents(hp); ! 1032: if (lockExtBtree) ! 1033: { ! 1034: p = CURRENT_PROC; ! 1035: retval = hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE | LK_CANRECURSE, p); ! 1036: if (retval) ! 1037: return (retval); ! 1038: } ! 1039: ! 1040: ! 1041: if (ap->a_bn < hp->h_uniformblocksizestart) { ! 1042: int targetLogicalBlockNo = ap->a_bn; ! 1043: off_t fileOffset = 0; ! 1044: int extent; ! 1045: long extentSize; ! 1046: ! 1047: logBlockSize = MAXLOGBLOCKSIZE; ! 1048: for (extent = 0; extent < LOGBLOCKMAPENTRIES; ++extent) { ! 1049: if ((hp->h_logicalblocktable[extent].logicalBlockCount > 0) && ! 1050: (targetLogicalBlockNo < hp->h_logicalblocktable[extent].logicalBlockCount)) { ! 1051: retval = MacToVFSError( ! 1052: MapFileBlockC (HFSTOVCB(hfsmp), ! 1053: HTOFCB(hp), ! 1054: MAXPHYSIO, ! 1055: fileOffset + (targetLogicalBlockNo * MAXLOGBLOCKSIZE), ! 1056: (UInt32 *)ap->a_bnp, ! 1057: &bytesContAvail)); ! 1058: /* Take the current FCB's extent length info: we could be mid-update */ ! 1059: if (HTOVCB(hp)->vcbSigWord == kHFSSigWord) { ! 1060: extentSize = hp->h_xfcb->fcb_fcb.fcbExtRec[extent].blockCount * HTOVCB(hp)->blockSize; ! 1061: } else { ! 1062: extentSize = hp->h_xfcb->fcb_extFCB.extents[extent].blockCount * HTOVCB(hp)->blockSize; ! 1063: }; ! 1064: DBG_ASSERT((bytesContAvail == MAXPHYSIO) || (bytesContAvail == (extentSize - (targetLogicalBlockNo * MAXLOGBLOCKSIZE)))); ! 1065: break; ! 1066: }; ! 1067: targetLogicalBlockNo -= hp->h_logicalblocktable[extent].logicalBlockCount; ! 1068: fileOffset += hp->h_logicalblocktable[extent].extentLength; ! 1069: }; ! 1070: } else { ! 1071: logBlockSize = hp->h_meta->h_logBlockSize; ! 1072: retval = MacToVFSError( ! 1073: MapFileBlockC (HFSTOVCB(hfsmp), ! 1074: HTOFCB(hp), ! 1075: MAXPHYSIO, ! 1076: hp->h_optimizedblocksizelimit + ! 1077: ((ap->a_bn - hp->h_uniformblocksizestart) * logBlockSize), ! 1078: (UInt32 *)ap->a_bnp, ! 1079: &bytesContAvail)); ! 1080: ! 1081: }; ! 1082: ! 1083: if (lockExtBtree) (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_RELEASE, p); ! 1084: ! 1085: if (retval == E_NONE) { ! 1086: /* Figure out how many read ahead blocks there are */ ! 1087: if (ap->a_runp != NULL) { ! 1088: if (can_cluster(logBlockSize)) { ! 1089: /* Make sure this result never goes negative: */ ! 1090: *ap->a_runp = (bytesContAvail < logBlockSize) ? 0 : (bytesContAvail / logBlockSize) - 1; ! 1091: } else { ! 1092: *ap->a_runp = 0; ! 1093: }; ! 1094: }; ! 1095: }; ! 1096: ! 1097: #if DEBUG_BMAP ! 1098: DBG_VOP(("%d:%d.\n", *ap->a_bnp, (bytesContAvail < logBlockSize) ? 0 : (bytesContAvail / logBlockSize) - 1)); ! 1099: ! 1100: DBG_VOP_LOCKS_TEST(retval); ! 1101: #endif ! 1102: ! 1103: if (ap->a_runp) { ! 1104: DBG_ASSERT((*ap->a_runp * logBlockSize) < bytesContAvail); /* At least *ap->a_runp blocks left and ... */ ! 1105: if (can_cluster(logBlockSize)) { ! 1106: DBG_ASSERT(bytesContAvail - (*ap->a_runp * logBlockSize) < (2*logBlockSize)); /* ... at most 1 logical block accounted for by current block */ ! 1107: /* ... plus some sub-logical block sized piece */ ! 1108: }; ! 1109: }; ! 1110: ! 1111: return (retval); ! 1112: } ! 1113: ! 1114: ! 1115: /* ! 1116: * Calculate the logical to physical mapping if not done already, ! 1117: * then call the device strategy routine. ! 1118: # ! 1119: #vop_strategy { ! 1120: # IN struct buf *bp; ! 1121: */ ! 1122: int ! 1123: hfs_strategy(ap) ! 1124: struct vop_strategy_args /* { ! 1125: struct buf *a_bp; ! 1126: } */ *ap; ! 1127: { ! 1128: register struct buf *bp = ap->a_bp; ! 1129: register struct vnode *vp = bp->b_vp; ! 1130: register struct hfsnode *hp; ! 1131: long logBlockSize; ! 1132: int retval = 0; ! 1133: DBG_FUNC_NAME("strategy"); ! 1134: ! 1135: // DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n")); ! 1136: ! 1137: hp = VTOH(vp); ! 1138: if (vp->v_type == VBLK || vp->v_type == VCHR) ! 1139: panic("hfs_strategy: device vnode passed!"); ! 1140: ! 1141: /* ! 1142: * If we don't already know the filesystem relative block number ! 1143: * then get it using VOP_BMAP(). If VOP_BMAP() returns the block ! 1144: * number as -1 then we've got a hole in the file. HFS filesystems ! 1145: * don't allow files with holes, so we shouldn't ever see this. ! 1146: */ ! 1147: if (bp->b_blkno == bp->b_lblkno) { ! 1148: if ((retval = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL))) { ! 1149: bp->b_error = retval; ! 1150: bp->b_flags |= B_ERROR; ! 1151: biodone(bp); ! 1152: return (retval); ! 1153: } ! 1154: if ((long)bp->b_blkno == -1) ! 1155: clrbuf(bp); ! 1156: } ! 1157: if ((long)bp->b_blkno == -1) { ! 1158: biodone(bp); ! 1159: return (0); ! 1160: } ! 1161: ! 1162: /* Make sure some over-eager cluster code didn't generate an excessively large read: */ ! 1163: if (bp->b_bcount != hp->h_meta->h_logBlockSize) { ! 1164: logBlockSize = LogicalBlockSize(hp, bp->b_lblkno); ! 1165: if ((bp->b_bcount > logBlockSize) && !(can_cluster(logBlockSize))) bp->b_bcount = logBlockSize; ! 1166: }; ! 1167: ! 1168: if (bp->b_validend == 0) { ! 1169: /* Record the exact size of the I/O transfer about to be made: */ ! 1170: DBG_ASSERT(bp->b_validoff == 0); ! 1171: bp->b_validend = bp->b_bcount; ! 1172: DBG_ASSERT(bp->b_dirtyoff == 0); ! 1173: }; ! 1174: ! 1175: vp = hp->h_devvp; ! 1176: bp->b_dev = vp->v_rdev; ! 1177: DBG_VOP(("\t\t>>>%s: continuing w/ vp: 0x%x with logBlk Ox%X and phyBlk Ox%X\n", funcname, (u_int)vp, bp->b_lblkno, bp->b_blkno)); ! 1178: ! 1179: return VOCALL (vp->v_op, VOFFSET(vop_strategy), ap); ! 1180: } ! 1181: ! 1182: ! 1183: /* ! 1184: #% reallocblks vp L L L ! 1185: # ! 1186: vop_reallocblks { ! 1187: IN struct vnode *vp; ! 1188: IN struct cluster_save *buflist; ! 1189: ! 1190: */ ! 1191: ! 1192: int ! 1193: hfs_reallocblks(ap) ! 1194: struct vop_reallocblks_args /* { ! 1195: struct vnode *a_vp; ! 1196: struct cluster_save *a_buflist; ! 1197: } */ *ap; ! 1198: { ! 1199: DBG_FUNC_NAME("reallocblks"); ! 1200: DBG_VOP_LOCKS_DECL(1); ! 1201: DBG_VOP_PRINT_FUNCNAME(); ! 1202: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 1203: ! 1204: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 1205: ! 1206: /* Currently no support for clustering */ /* XXX */ ! 1207: DBG_VOP_LOCKS_TEST(ENOSPC); ! 1208: return (ENOSPC); ! 1209: } ! 1210: ! 1211: ! 1212: ! 1213: /* ! 1214: # ! 1215: #% truncate vp L L L ! 1216: # ! 1217: vop_truncate { ! 1218: IN struct vnode *vp; ! 1219: IN off_t length; ! 1220: IN int flags; (IO_SYNC) ! 1221: IN struct ucred *cred; ! 1222: IN struct proc *p; ! 1223: }; ! 1224: * Truncate the hfsnode hp to at most length size, freeing (or adding) the ! 1225: * disk blocks. ! 1226: */ ! 1227: int hfs_truncate(ap) ! 1228: struct vop_truncate_args /* { ! 1229: struct vnode *a_vp; ! 1230: off_t a_length; ! 1231: int a_flags; ! 1232: struct ucred *a_cred; ! 1233: struct proc *a_p; ! 1234: } */ *ap; ! 1235: { ! 1236: register struct vnode *vp = ap->a_vp; ! 1237: register struct hfsnode *hp = VTOH(vp); ! 1238: off_t length = ap->a_length; ! 1239: long vflags; ! 1240: struct timeval tv; ! 1241: int retval; ! 1242: FCB *fcb; ! 1243: off_t bytesToAdd; ! 1244: UInt32 actualBytesAdded; ! 1245: long devBlockSize = 512; ! 1246: DBG_FUNC_NAME("truncate"); ! 1247: DBG_VOP_LOCKS_DECL(1); ! 1248: DBG_VOP_PRINT_FUNCNAME(); ! 1249: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 1250: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 1251: ! 1252: #if DIAGNOSTIC ! 1253: debug_check_blocksizes(ap->a_vp); ! 1254: #endif ! 1255: ! 1256: if (length < 0) { ! 1257: DBG_VOP_LOCKS_TEST(EINVAL); ! 1258: return (EINVAL); ! 1259: } ! 1260: ! 1261: if (length > (off_t)MAXHFSFILESIZE) { /* XXX need to distinguish between hfs and hfs+ */ ! 1262: DBG_VOP_LOCKS_TEST(EFBIG); ! 1263: return (EFBIG); ! 1264: } ! 1265: ! 1266: if (vp->v_type != VREG && vp->v_type != VLNK) { ! 1267: DBG_VOP_LOCKS_TEST(EISDIR); ! 1268: return (EISDIR); /* hfs doesn't support truncating of directories */ ! 1269: } ! 1270: ! 1271: fcb = HTOFCB(hp); ! 1272: tv = time; ! 1273: retval = E_NONE; ! 1274: ! 1275: DBG_VOP(("%s: truncate from Ox%lX to Ox%X bytes\n", funcname, fcb->fcbPLen, (u_int)length)); ! 1276: ! 1277: /* ! 1278: * we cannot just check if fcb->fcbEOF == length (as an optimization) ! 1279: * since there may be extra physical blocks that also need truncation ! 1280: */ ! 1281: ! 1282: #if MACH_NBC ! 1283: retval = mapfs_trunc(vp, (vm_offset_t)length); ! 1284: if (retval) { ! 1285: DBG_VOP_LOCKS_TEST(retval); ! 1286: return (retval); ! 1287: } ! 1288: #endif /* MACH_NBC */ ! 1289: ! 1290: /* ! 1291: * Lengthen the size of the file. We must ensure that the ! 1292: * last byte of the file is allocated. Since the smallest ! 1293: * value of fcbEOF is 0, length will be at least 1. ! 1294: */ ! 1295: if ((u_long)length > fcb->fcbEOF) { ! 1296: off_t filePosition; ! 1297: daddr_t logBlockNo; ! 1298: long logBlockSize; ! 1299: long blkOffset; ! 1300: off_t bytestoclear; ! 1301: int blockZeroCount; ! 1302: struct buf *bp=NULL; ! 1303: ! 1304: /* ! 1305: * If we don't have enough physical space then ! 1306: * we need to extend the physical size. ! 1307: */ ! 1308: if ((u_long)length > fcb->fcbPLen) { ! 1309: /* lock extents b-tree (also protects volume bitmap) */ ! 1310: retval = hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p); ! 1311: if (retval) goto Err_Exit; ! 1312: ! 1313: while (((u_long)length > fcb->fcbPLen) && (retval == E_NONE)) { ! 1314: /* XXX PPD Allocate only 2GB at a time until ExtendFileC's interface changes... */ ! 1315: bytesToAdd = length - (off_t)fcb->fcbPLen; ! 1316: if (bytesToAdd > (off_t)0x80000000) bytesToAdd = (off_t)0x80000000; ! 1317: retval = MacToVFSError( ! 1318: ExtendFileC (HTOVCB(hp), ! 1319: fcb, ! 1320: (u_long)bytesToAdd, ! 1321: kEFAllMask, /* allocate all requested bytes or none */ ! 1322: &actualBytesAdded)); ! 1323: ! 1324: if (actualBytesAdded == 0 && retval == E_NONE) { ! 1325: if ((u_long)length > fcb->fcbPLen) ! 1326: length = (off_t)fcb->fcbPLen; ! 1327: break; ! 1328: } ! 1329: ! 1330: /* If we just successfully extended the file by only 2GB, try again (just to be sure): */ ! 1331: if (bytesToAdd == (off_t)0x80000000) continue; ! 1332: } ! 1333: (void) hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_RELEASE, ap->a_p); ! 1334: if (retval) goto Err_Exit; ! 1335: ! 1336: DBG_ASSERT((u_long)length <= fcb->fcbPLen); ! 1337: ! 1338: UpdateBlockMappingTable(hp); ! 1339: ! 1340: #if MACH_NBC ! 1341: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) { ! 1342: #endif /* MACH_NBC */ ! 1343: vnode_pager_setsize(vp, (u_long)length); ! 1344: vnode_uncache(vp); ! 1345: #if MACH_NBC ! 1346: } ! 1347: #endif /* !MACH_NBC */ ! 1348: } ! 1349: ! 1350: if (! (ap->a_flags & IO_NOZEROFILL)) { ! 1351: /* ! 1352: * zero out any new logical space... ! 1353: */ ! 1354: VOP_DEVBLOCKSIZE(hp->h_devvp, &devBlockSize); ! 1355: ! 1356: bytestoclear = length - (off_t)fcb->fcbEOF; ! 1357: filePosition = (off_t)fcb->fcbEOF; ! 1358: while (bytestoclear > 0) { ! 1359: MapFileOffset(hp, filePosition, &logBlockNo, &logBlockSize, &blkOffset); ! 1360: blockZeroCount = MIN(bytestoclear, logBlockSize - blkOffset); ! 1361: if ((blkOffset == 0) && (bytestoclear >= logBlockSize)) { ! 1362: bp = getblk(vp, logBlockNo, logBlockSize, 0, 0); ! 1363: retval = 0; ! 1364: if (bp->b_flags & (B_DELWRI | B_DONE | B_CACHE)) { ! 1365: /* ! 1366: This buffer is fully pre-read and may already have some modified data in it: ! 1367: it doesn't need special-casing for write-through. ! 1368: */ ! 1369: } else { ! 1370: /* This is an empty buffer just allocated for our use: */ ! 1371: ! 1372: /* XXX PPD Can't this be skipped if b_blkno != logBlockNo? */ ! 1373: ! 1374: /* Setting up the physical block number is required ! 1375: (1) to keep cluster_write informed about which blocks can be clustered, and ! 1376: (2) to avoid a second call to bmap() in strategy() on the write. ! 1377: */ ! 1378: if ((retval = VOP_BMAP(vp, logBlockNo, NULL, &bp->b_blkno, NULL))) { ! 1379: brelse(bp); ! 1380: break; ! 1381: }; ! 1382: ! 1383: bp->b_bcount = 0; /* No valid data in block yet */ ! 1384: bp->b_validend = 0; /* No valid data in block yet */ ! 1385: }; ! 1386: } else { ! 1387: retval = bread(vp, logBlockNo, logBlockSize, ap->a_cred, &bp); ! 1388: if (retval) { ! 1389: brelse(bp); ! 1390: goto Err_Exit; ! 1391: } ! 1392: } ! 1393: ! 1394: /* ! 1395: Fix up the anciliary fields for this buffer, depending on whether they've been initialized yet, ! 1396: and check to see whether we need to get more data than what was just found in the cache: ! 1397: */ ! 1398: if (bp->b_validend > 0) { ! 1399: /* ! 1400: b_validoff, b_validend, b_dirtyoff, and b_dirtyend are valid for blocks in the cache: ! 1401: The only blocks that are incomplete (b_validend < fragSize) are blocks that have been ! 1402: partially written from the start of the buffer: ! 1403: */ ! 1404: if (bp->b_validend < bp->b_bcount) { ! 1405: /* ! 1406: We stumbled onto an incomplete [but successfully acquired] buffer: ! 1407: try to get the full contents now because it's the only way to get ! 1408: the data in this logical block... ! 1409: */ ! 1410: DBG_ASSERT((bp->b_dirtyoff == 0) && (bp->b_validoff == 0) && (bp->b_dirtyend <= bp->b_validend)); ! 1411: /* Incomplete blocks must have only device-block multiples of data... */ ! 1412: DBG_ASSERT((bp->b_validend % devBlockSize) == 0); ! 1413: bp->b_bcount = bp->b_validend; ! 1414: ! 1415: retval = bexpand(bp, logBlockSize, &bp, 0); ! 1416: }; ! 1417: } else { ! 1418: /* This buffer was either just allocated or just read in its entirity [see b_bcount]: */ ! 1419: DBG_ASSERT(bp->b_validoff == 0); ! 1420: bp->b_validend = bp->b_bcount; /* b_bcount > 0 iff block was actually read from disk in bread */ ! 1421: DBG_ASSERT(bp->b_dirtyoff == 0); ! 1422: DBG_ASSERT(bp->b_dirtyend == 0); ! 1423: }; ! 1424: ! 1425: bzero((char *)bp->b_data + blkOffset, blockZeroCount); ! 1426: ! 1427: if (blkOffset + blockZeroCount > bp->b_dirtyend) bp->b_dirtyend = blkOffset + blockZeroCount; ! 1428: if (bp->b_dirtyend > bp->b_validend) bp->b_validend = bp->b_dirtyend; ! 1429: if (bp->b_validend > bp->b_bcount) bp->b_bcount = bp->b_validend; ! 1430: DBG_ASSERT(bp->b_bcount % devBlockSize == 0); ! 1431: DBG_ASSERT(bp->b_bcount == bp->b_validend); ! 1432: bp->b_flags |= B_DIRTY | B_AGE; ! 1433: if (ap->a_flags & IO_SYNC) { ! 1434: bwrite(bp); ! 1435: } else if (doclusterwrite && can_cluster(logBlockSize)) { ! 1436: cluster_write(bp, fcb->fcbPLen, devBlockSize); ! 1437: } else if (logBlockNo % 32) { ! 1438: bawrite(bp); ! 1439: } else { ! 1440: bwrite(bp); /* wait after we issue 32 requests */ ! 1441: }; ! 1442: ! 1443: bytestoclear -= blockZeroCount; ! 1444: if (blkOffset > 0) ! 1445: blkOffset = 0; ! 1446: ! 1447: filePosition += blockZeroCount; ! 1448: } ! 1449: } ! 1450: ! 1451: fcb->fcbEOF = (u_long)length; ! 1452: ! 1453: } else { /* Shorten the size of the file */ ! 1454: ! 1455: if (fcb->fcbEOF > (u_long)length) { ! 1456: /* ! 1457: * Any buffers that are past the truncation point need to be ! 1458: * invalidated (to maintain buffer cache consistency). For ! 1459: * simplicity, we invalidate all the buffers by calling vinvalbuf. ! 1460: */ ! 1461: vflags = ((length > 0) ? V_SAVE : 0); /* XXX PPD Should we set SAVE_META? */ ! 1462: retval = vinvalbuf(vp, vflags, ap->a_cred, ap->a_p, 0, 0); ! 1463: } ! 1464: /* lock extents b-tree (also protects volume bitmap) */ ! 1465: retval = hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p); ! 1466: if (retval) goto Err_Exit; ! 1467: ! 1468: retval = MacToVFSError( ! 1469: TruncateFileC( ! 1470: HTOVCB(hp), ! 1471: fcb, ! 1472: (u_long)length, ! 1473: false)); ! 1474: (void) hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_RELEASE, ap->a_p); ! 1475: if (retval) goto Err_Exit; ! 1476: ! 1477: fcb->fcbEOF = (u_long)length; ! 1478: if (fcb->fcbFlags &fcbModifiedMask) ! 1479: hp->h_meta->h_nodeflags |= IN_MODIFIED; ! 1480: ! 1481: UpdateBlockMappingTable(hp); ! 1482: ! 1483: #if MACH_NBC ! 1484: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) { ! 1485: #endif /* MACH_NBC */ ! 1486: vnode_pager_setsize(vp, (u_long)length); ! 1487: #if MACH_NBC ! 1488: } ! 1489: #endif /* MACH_NBC */ ! 1490: ! 1491: } ! 1492: ! 1493: hp->h_meta->h_nodeflags |= IN_CHANGE | IN_UPDATE; ! 1494: retval = VOP_UPDATE(vp, &tv, &tv, MNT_WAIT); ! 1495: ! 1496: Err_Exit:; ! 1497: ! 1498: #if DIAGNOSTIC ! 1499: debug_check_blocksizes(ap->a_vp); ! 1500: #endif ! 1501: ! 1502: DBG_VOP_LOCKS_TEST(retval); ! 1503: return (retval); ! 1504: } ! 1505: ! 1506: ! 1507: ! 1508: /* ! 1509: # ! 1510: #% allocate vp L L L ! 1511: # ! 1512: vop_allocate { ! 1513: IN struct vnode *vp; ! 1514: IN off_t length; ! 1515: IN int flags; ! 1516: IN struct ucred *cred; ! 1517: IN struct proc *p; ! 1518: }; ! 1519: * allocate the hfsnode hp to at most length size ! 1520: */ ! 1521: int hfs_allocate(ap) ! 1522: struct vop_allocate_args /* { ! 1523: struct vnode *a_vp; ! 1524: off_t a_length; ! 1525: u_int32_t a_flags; ! 1526: off_t *a_bytesallocated; ! 1527: struct ucred *a_cred; ! 1528: struct proc *a_p; ! 1529: } */ *ap; ! 1530: { ! 1531: register struct vnode *vp = ap->a_vp; ! 1532: register struct hfsnode *hp = VTOH(vp); ! 1533: off_t length = ap->a_length; ! 1534: long vflags; ! 1535: u_long startingPEOF; ! 1536: struct timeval tv; ! 1537: int retval, retval2; ! 1538: FCB *fcb; ! 1539: UInt32 actualBytesAdded; ! 1540: UInt32 extendFlags =0; /* For call to ExtendFileC */ ! 1541: DBG_FUNC_NAME("allocate"); ! 1542: DBG_VOP_LOCKS_DECL(1); ! 1543: DBG_VOP_PRINT_FUNCNAME(); ! 1544: DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP_CONT(("\n")); ! 1545: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 1546: ! 1547: /* Set the number of bytes allocated to 0 so that the caller will know that we ! 1548: did nothing. ExtendFileC will fill this in for us if we actually allocate space */ ! 1549: ! 1550: *(ap->a_bytesallocated) = 0; ! 1551: ! 1552: /* Now for some error checking */ ! 1553: ! 1554: if (length < (off_t)0) { ! 1555: DBG_VOP_LOCKS_TEST(EINVAL); ! 1556: return (EINVAL); ! 1557: } ! 1558: ! 1559: if (length > (u_int64_t)0x7FFFFFFF) { /* XXX need to distinguish between hfs and hfs+ */ ! 1560: DBG_VOP_LOCKS_TEST(EFBIG); ! 1561: return (EFBIG); ! 1562: } ! 1563: ! 1564: if (vp->v_type != VREG && vp->v_type != VLNK) { ! 1565: DBG_VOP_LOCKS_TEST(EISDIR); ! 1566: return (EISDIR); /* hfs doesn't support truncating of directories */ ! 1567: } ! 1568: ! 1569: /* Fill in the flags word for the call to Extend the file */ ! 1570: ! 1571: if (ap->a_flags & ALLOCATECONTIG) { ! 1572: extendFlags |= kEFContigMask; ! 1573: } ! 1574: ! 1575: if (ap->a_flags & ALLOCATEALL) { ! 1576: extendFlags |= kEFAllMask; ! 1577: } ! 1578: ! 1579: fcb = HTOFCB(hp); ! 1580: tv = time; ! 1581: retval = E_NONE; ! 1582: startingPEOF = fcb->fcbPLen; ! 1583: ! 1584: if (ap->a_flags & ALLOCATEFROMPEOF) { ! 1585: length += fcb->fcbPLen; ! 1586: } ! 1587: ! 1588: DBG_VOP(("%s: allocate from Ox%lX to Ox%X bytes\n", funcname, fcb->fcbPLen, (u_int)length)); ! 1589: ! 1590: /* If no changes are necesary, then we're done */ ! 1591: if (fcb->fcbPLen == (u_long)length) ! 1592: goto Std_Exit; ! 1593: ! 1594: /* ! 1595: * Lengthen the size of the file. We must ensure that the ! 1596: * last byte of the file is allocated. Since the smallest ! 1597: * value of fcbPLen is 0, length will be at least 1. ! 1598: */ ! 1599: if ((u_long)length > fcb->fcbPLen) { ! 1600: ! 1601: /* lock extents b-tree (also protects volume bitmap) */ ! 1602: retval = hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p); ! 1603: if (retval) goto Err_Exit; ! 1604: ! 1605: retval = MacToVFSError( ! 1606: ExtendFileC(HTOVCB(hp), ! 1607: fcb, ! 1608: (u_long)length - fcb->fcbPLen, ! 1609: extendFlags, ! 1610: &actualBytesAdded)); ! 1611: ! 1612: *(ap->a_bytesallocated) = actualBytesAdded; ! 1613: ! 1614: (void) hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_RELEASE, ap->a_p); ! 1615: ! 1616: DBG_ASSERT((u_long)length <= fcb->fcbPLen); ! 1617: ! 1618: UpdateBlockMappingTable(hp); ! 1619: ! 1620: /* ! 1621: * if we get an error and no changes were made then exit ! 1622: * otherwise we must do the VOP_UPDATE to reflect the changes ! 1623: */ ! 1624: if (retval && (startingPEOF == fcb->fcbPLen)) goto Err_Exit; ! 1625: ! 1626: } else { /* Shorten the size of the file */ ! 1627: ! 1628: if (fcb->fcbEOF > (u_long)length) { ! 1629: /* ! 1630: * Any buffers that are past the truncation point need to be ! 1631: * invalidated (to maintain buffer cache consistency). For ! 1632: * simplicity, we invalidate all the buffers by calling vinvalbuf. ! 1633: */ ! 1634: vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA; ! 1635: (void) vinvalbuf(vp, vflags, ap->a_cred, ap->a_p, 0, 0); ! 1636: } ! 1637: ! 1638: /* lock extents b-tree (also protects volume bitmap) */ ! 1639: retval = hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_EXCLUSIVE, ap->a_p); ! 1640: if (retval) goto Err_Exit; ! 1641: ! 1642: retval = MacToVFSError( ! 1643: TruncateFileC( ! 1644: HTOVCB(hp), ! 1645: fcb, ! 1646: (u_long)length, ! 1647: false)); ! 1648: (void) hfs_metafilelocking(HTOHFS(hp), kHFSExtentsFileID, LK_RELEASE, ap->a_p); ! 1649: ! 1650: /* ! 1651: * if we get an error and no changes were made then exit ! 1652: * otherwise we must do the VOP_UPDATE to reflect the changes ! 1653: */ ! 1654: if (retval && (startingPEOF == fcb->fcbPLen)) goto Err_Exit; ! 1655: if (fcb->fcbFlags & fcbModifiedMask) ! 1656: hp->h_meta->h_nodeflags |= IN_MODIFIED; ! 1657: ! 1658: DBG_ASSERT((u_long)length <= fcb->fcbPLen) // DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG ! 1659: ! 1660: if (fcb->fcbEOF > fcb->fcbPLen) { ! 1661: fcb->fcbEOF = fcb->fcbPLen; ! 1662: ! 1663: UpdateBlockMappingTable(hp); ! 1664: ! 1665: #if MACH_NBC ! 1666: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) { ! 1667: #endif /* MACH_NBC */ ! 1668: vnode_pager_setsize(vp, (u_long)fcb->fcbEOF); ! 1669: #if MACH_NBC ! 1670: } ! 1671: #endif /* MACH_NBC */ ! 1672: } ! 1673: (void)vnode_uncache(vp); ! 1674: } ! 1675: ! 1676: Std_Exit: ! 1677: hp->h_meta->h_nodeflags |= IN_CHANGE | IN_UPDATE; ! 1678: retval2 = VOP_UPDATE(vp, &tv, &tv, MNT_WAIT); ! 1679: ! 1680: if (retval == 0) retval = retval2; ! 1681: ! 1682: Err_Exit: ! 1683: DBG_VOP_LOCKS_TEST(retval); ! 1684: return (retval); ! 1685: } ! 1686: ! 1687: ! 1688: ! 1689: ! 1690: /* Pass-through pagein for HFS filesystem */ ! 1691: int ! 1692: hfs_pagein(ap) ! 1693: struct vop_pagein_args /* { ! 1694: struct vnode *a_vp; ! 1695: struct uio *a_uio; ! 1696: int a_ioflag; ! 1697: struct ucred *a_cred; ! 1698: } */ *ap; ! 1699: { ! 1700: /* pass thru to read */ ! 1701: return (VOP_READ(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred)); ! 1702: } ! 1703: ! 1704: /* Pass-through pageout for HFS filesystem */ ! 1705: int ! 1706: hfs_pageout(ap) ! 1707: struct vop_pageout_args /* { ! 1708: struct vnode *a_vp; ! 1709: struct uio *a_uio; ! 1710: int a_ioflag; ! 1711: struct ucred *a_cred; ! 1712: } */ *ap; ! 1713: { ! 1714: /* pass thru to write */ ! 1715: return (VOP_WRITE(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred)); ! 1716: } ! 1717: ! 1718: ! 1719: ! 1720: /* ! 1721: Try to expand the range of a buffer. ! 1722: ! 1723: Possible values for 'flags' are: ! 1724: ! 1725: RELEASE_BUFFER - to specify that the expanded buffer need not be held ! 1726: ! 1727: Calling bexpand with nbpp == &bp to expand a given buffer is OK; ! 1728: even on errors, the current buffer (bp) is always brelse-ed! ! 1729: */ ! 1730: int ! 1731: bexpand(struct buf *bp, int newsize, struct buf **nbpp, long flags) ! 1732: { ! 1733: struct vnode *ovp; ! 1734: daddr_t olblkno; ! 1735: struct ucred *ocred; ! 1736: int odirtyend; ! 1737: int releasebp = 1; ! 1738: struct buf *tbp = NULL; ! 1739: struct buf *nbp = NULL; ! 1740: int retval = 0; ! 1741: ! 1742: DBG_ASSERT(bp != NULL); ! 1743: if (nbpp == NULL) DBG_ASSERT(flags & RELEASE_BUFFER); ! 1744: ! 1745: if (bp->b_validend >= newsize) { ! 1746: /* Sufficient amount already read or written into buffer: */ ! 1747: nbp = bp; /* nbp is checked against bp in exit path */ ! 1748: retval = 0; ! 1749: goto stdexit; ! 1750: }; ! 1751: ! 1752: if (nbpp) *nbpp = NULL; /* Just to be clean, and to ensure != bp... */ ! 1753: ! 1754: ovp = bp->b_vp; ! 1755: olblkno = bp->b_lblkno; ! 1756: ocred = bp->b_rcred; ! 1757: odirtyend = bp->b_dirtyend; ! 1758: ! 1759: if (bp->b_flags & B_DELWRI) { ! 1760: /* This buffer holds dirtied data that must be preserved: */ ! 1761: /* XXX PPD 9/28/98 Should assert that b_dirtyoff == 0 here, but not this late in the game... */ ! 1762: tbp = geteblk(odirtyend); /* Grab a new [temporary] buffer big enough to ! 1763: hold the dirty parts of this buffer for a sec. */ ! 1764: if (tbp == NULL) { ! 1765: retval = ENOMEM; ! 1766: goto errexit; ! 1767: }; ! 1768: bcopy(bp->b_data, tbp->b_data, odirtyend); ! 1769: }; ! 1770: ! 1771: /* It's now safe to trash the entire current contents of the buffer */ ! 1772: bp->b_flags |= B_INVAL; ! 1773: DBG_ASSERT((bp->b_validend == 0) || (bp->b_validend == bp->b_bcount)); ! 1774: brelse(bp); ! 1775: releasebp = 0; ! 1776: ! 1777: // if (((flags & RELEASE_BUFFER) == 0) || (tbp != NULL)) { ! 1778: if (1) { ! 1779: retval = bread(ovp, olblkno, newsize, ocred, &nbp); /* Read in the requested data */ ! 1780: if (retval != 0) goto errexit; ! 1781: ! 1782: nbp->b_validoff = 0; ! 1783: nbp->b_validend = newsize; ! 1784: nbp->b_dirtyoff = 0; ! 1785: nbp->b_dirtyend = 0; ! 1786: ! 1787: if (tbp) { ! 1788: /* Restore the modified data from the old buffer: */ ! 1789: bcopy(tbp->b_data, nbp->b_data, odirtyend); ! 1790: nbp->b_dirtyend = odirtyend; ! 1791: DBG_ASSERT((bp->b_validend == 0) || (bp->b_validend == bp->b_bcount)); ! 1792: bdwrite(nbp); /* Mark this block dirty and move to appropriate buffer */ ! 1793: ! 1794: if (flags & RELEASE_BUFFER) { ! 1795: nbp = NULL; /* Forget about the new buffer just written */ ! 1796: } else { ! 1797: /* Get the buffer back on behalf of our caller, even reading it back in in the ! 1798: unlikely case it's been flushed and re-used since the bdwrite(), above: */ ! 1799: retval = bread(ovp, olblkno, newsize, ocred, nbpp); ! 1800: if (retval != 0) goto errexit; ! 1801: nbp->b_validoff = 0; ! 1802: nbp->b_validend = newsize; ! 1803: nbp->b_dirtyoff = 0; ! 1804: nbp->b_dirtyend = odirtyend; ! 1805: }; ! 1806: ! 1807: brelse(tbp); ! 1808: tbp = NULL; /* Just in case we hit errors later */ ! 1809: }; ! 1810: }; ! 1811: goto stdexit; ! 1812: ! 1813: errexit: ! 1814: if (tbp) brelse(tbp); ! 1815: ! 1816: if (releasebp && (bp != nbp)) { ! 1817: DBG_ASSERT((bp->b_validend == 0) || (bp->b_validend == bp->b_bcount)); ! 1818: brelse(bp); ! 1819: }; ! 1820: ! 1821: stdexit:; ! 1822: if (nbpp) *nbpp = nbp; ! 1823: ! 1824: if ((flags & RELEASE_BUFFER) && (nbp != NULL)) { ! 1825: brelse(nbp); ! 1826: }; ! 1827: ! 1828: #if DIAGNOSTIC ! 1829: debug_check_blocksizes(bp->b_vp); ! 1830: #endif ! 1831: ! 1832: return retval; ! 1833: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.