X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d7e50217d7adf6e52786a38bcaa4cd698cb9a79e..316670eb35587141e969394ae8537d66b9211e80:/bsd/kern/kern_physio.c diff --git a/bsd/kern/kern_physio.c b/bsd/kern/kern_physio.c index def3db886..2c4998ec3 100644 --- a/bsd/kern/kern_physio.c +++ b/bsd/kern/kern_physio.c @@ -1,16 +1,19 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in - * compliance with the License. Please obtain a copy of the License at - * http://www.opensource.apple.com/apsl/ and read it before using this - * file. + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER @@ -20,7 +23,7 @@ * Please see the License for the specific language governing rights and * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /*- * Copyright (c) 1982, 1986, 1990, 1993 @@ -69,26 +72,33 @@ #include #include -#include +#include #include -#include +#include +#include +#include int -physio(strategy, bp, dev, flags, minphys, uio, blocksize) - void (*strategy)(); - struct buf *bp; - dev_t dev; - int flags; - u_int (*minphys)(); - struct uio *uio; - int blocksize; +physio( void (*f_strategy)(buf_t), + buf_t bp, + dev_t dev, + int flags, + u_int (*f_minphys)(buf_t), + struct uio *uio, + int blocksize) { - struct iovec *iovp; struct proc *p = current_proc(); - int error, done, i, nobuf, s, todo; + int error, i, buf_allocated, todo, iosize; + int orig_bflags = 0; +#if LP64KERN + int64_t done; +#else + int done; +#endif error = 0; flags &= B_READ | B_WRITE; + buf_allocated = 0; /* * [check user read/write access to the data buffer] @@ -98,130 +108,112 @@ physio(strategy, bp, dev, flags, minphys, uio, blocksize) * we're doing a read, that's a *write* to user-space. */ for (i = 0; i < uio->uio_iovcnt; i++) { - if(uio->uio_segflg != UIO_SYSSPACE) { - if (!useracc(uio->uio_iov[i].iov_base, - uio->uio_iov[i].iov_len, + if (UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) { + user_addr_t base; + user_size_t len; + + if (uio_getiov(uio, i, &base, &len) || + !useracc(base, + len, (flags == B_READ) ? B_WRITE : B_READ)) return (EFAULT); } } - /* Make sure we have a buffer, creating one if necessary. */ - if (nobuf = (bp == NULL)) { -// bp = getphysbuf(); - panic("physio: null buf pointer\n"); - } - - /* [raise the processor priority level to splbio;] */ - s = splbio(); - - /* [while the buffer is marked busy] */ - while (bp->b_flags & B_BUSY) { - /* [mark the buffer wanted] */ - bp->b_flags |= B_WANTED; - /* [wait until the buffer is available] */ - tsleep((caddr_t)bp, PRIBIO+1, "physbuf", 0); - } - - /* Mark it busy, so nobody else will use it. */ - bp->b_flags |= B_BUSY; - - /* [lower the priority level] */ - splx(s); + /* + * Make sure we have a buffer, creating one if necessary. + */ + if (bp == NULL) { + bp = buf_alloc((vnode_t)0); + buf_allocated = 1; + } else + orig_bflags = buf_flags(bp); + /* + * at this point we should have a buffer + * that is marked BL_BUSY... we either + * acquired it via buf_alloc, or it was + * passed into us... if it was passed + * in, it needs to already be owned by + * the caller (i.e. BL_BUSY is set) + */ + assert(bp->b_lflags & BL_BUSY); - /* [set up the fixed part of the buffer for a transfer] */ + /* + * [set up the fixed part of the buffer for a transfer] + */ bp->b_dev = dev; - bp->b_error = 0; bp->b_proc = p; /* - * [while there are data to transfer and no I/O error] + * [mark the buffer busy for physical I/O] + * (i.e. set B_PHYS (because it's an I/O to user + * memory, and B_RAW, because B_RAW is to be + * "Set by physio for raw transfers.", in addition + * to the read/write flag.) + */ + buf_setflags(bp, B_PHYS | B_RAW); + + /* + * [while there is data to transfer and no I/O error] * Note that I/O errors are handled with a 'goto' at the bottom * of the 'while' loop. */ - for (i = 0; i < uio->uio_iovcnt; i++) { - iovp = &uio->uio_iov[i]; - while (iovp->iov_len > 0) { + while (uio_resid(uio) > 0) { + + if ( (iosize = uio_curriovlen(uio)) > MAXPHYSIO_WIRED) + iosize = MAXPHYSIO_WIRED; /* - * [mark the buffer busy for physical I/O] - * (i.e. set B_PHYS (because it's an I/O to user - * memory, and B_RAW, because B_RAW is to be - * "Set by physio for raw transfers.", in addition - * to the "busy" and read/write flag.) + * make sure we're set to issue a fresh I/O + * in the right direction */ - s = splbio(); - bp->b_flags = B_BUSY | B_PHYS | B_RAW | flags; - splx(s); + buf_reset(bp, flags); /* [set up the buffer for a maximum-sized transfer] */ - bp->b_blkno = uio->uio_offset / blocksize; - bp->b_bcount = iovp->iov_len; - bp->b_data = iovp->iov_base; + buf_setblkno(bp, uio_offset(uio) / blocksize); + buf_setcount(bp, iosize); + buf_setdataptr(bp, (uintptr_t)CAST_DOWN(caddr_t, uio_curriovbase(uio))); /* - * [call minphys to bound the tranfer size] + * [call f_minphys to bound the tranfer size] * and remember the amount of data to transfer, * for later comparison. */ - (*minphys)(bp); - todo = bp->b_bcount; + (*f_minphys)(bp); + todo = buf_count(bp); /* * [lock the part of the user address space involved * in the transfer] - * Beware vmapbuf(); it clobbers b_data and - * saves it in b_saveaddr. However, vunmapbuf() - * restores it. */ - if(uio->uio_segflg != UIO_SYSSPACE) - vslock(bp->b_data, todo); + if(UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) { + error = vslock(CAST_USER_ADDR_T(buf_dataptr(bp)), + (user_size_t)todo); + if (error) + goto done; + } -#if 0 - vmapbuf(bp, todo); -#endif /* 0 */ - /* [call strategy to start the transfer] */ - (*strategy)(bp); + /* [call f_strategy to start the transfer] */ + (*f_strategy)(bp); - /* - * Note that the raise/wait/lower/get error - * steps below would be done by biowait(), but - * we want to unlock the address space before - * we lower the priority. - * - * [raise the priority level to splbio] - */ - s = splbio(); /* [wait for the transfer to complete] */ - while ((bp->b_flags & B_DONE) == 0) - tsleep((caddr_t) bp, PRIBIO + 1, "physio", 0); + error = (int)buf_biowait(bp); /* * [unlock the part of the address space previously * locked] */ -#if 0 - vunmapbuf(bp, todo); -#endif /* 0 */ - if(uio->uio_segflg != UIO_SYSSPACE) - vsunlock(bp->b_data, todo); - - /* remember error value (save a splbio/splx pair) */ - if (bp->b_flags & B_ERROR) - error = (bp->b_error ? bp->b_error : EIO); - - /* [lower the priority level] */ - splx(s); + if(UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) + vsunlock(CAST_USER_ADDR_T(buf_dataptr(bp)), + (user_size_t)todo, + (flags & B_READ)); /* * [deduct the transfer size from the total number * of data to transfer] */ - done = bp->b_bcount - bp->b_resid; - iovp->iov_len -= done; - iovp->iov_base += done; - uio->uio_offset += done; - uio->uio_resid -= done; + done = buf_count(bp) - buf_resid(bp); + uio_update(uio, done); /* * Now, check for an error. @@ -229,34 +221,13 @@ physio(strategy, bp, dev, flags, minphys, uio, blocksize) */ if (error || done < todo) goto done; - } } done: - /* - * [clean up the state of the buffer] - * Remember if somebody wants it, so we can wake them up below. - * Also, if we had to steal it, give it back. - */ - s = splbio(); - bp->b_flags &= ~(B_BUSY | B_PHYS | B_RAW); -#if 0 - if (nobuf) - putphysbuf(bp); - - else -#endif /* 0 */ - { - /* - * [if another process is waiting for the raw I/O buffer, - * wake up processes waiting to do physical I/O; - */ - if (bp->b_flags & B_WANTED) { - bp->b_flags &= ~B_WANTED; - wakeup(bp); - } - } - splx(s); + if (buf_allocated) + buf_free(bp); + else + buf_setflags(bp, orig_bflags); return (error); } @@ -271,32 +242,9 @@ done: * and return the new count; */ u_int -minphys(bp) - struct buf *bp; +minphys(struct buf *bp) { - bp->b_bcount = min(MAXPHYS, bp->b_bcount); - return bp->b_bcount; -} - -/* - * Do a read on a device for a user process. - */ -rawread(dev, uio) - dev_t dev; - struct uio *uio; -{ - return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL, - dev, B_READ, minphys, uio, DEV_BSIZE)); -} - -/* - * Do a write on a device for a user process. - */ -rawwrite(dev, uio) - dev_t dev; - struct uio *uio; -{ - return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL, - dev, B_WRITE, minphys, uio, DEV_BSIZE)); + buf_setcount(bp, min(MAXPHYS, buf_count(bp))); + return buf_count(bp); }