X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/de355530ae67247cbd0da700edb3a2a1dae884c2..21362eb3e66fd2c787aee132bce100a44d71a99c:/bsd/kern/kern_physio.c diff --git a/bsd/kern/kern_physio.c b/bsd/kern/kern_physio.c index c4f2415f5..b23a39611 100644 --- a/bsd/kern/kern_physio.c +++ b/bsd/kern/kern_physio.c @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * 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. 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. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * 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 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * 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 @@ -66,23 +72,28 @@ #include #include -#include +#include #include -#include +#include +#include int physio(strategy, bp, dev, flags, minphys, uio, blocksize) void (*strategy)(); - struct buf *bp; + buf_t bp; dev_t dev; int flags; u_int (*minphys)(); struct uio *uio; int blocksize; { - struct iovec *iovp; struct proc *p = current_proc(); - int error, done, i, nobuf, s, todo; + int error, i, nobuf, todo, iosize; +#if LP64KERN + int64_t done; +#else + int done; +#endif error = 0; flags &= B_READ | B_WRITE; @@ -95,64 +106,56 @@ 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)) { + if (!useracc(uio_iov_base_at(uio, i), + uio_iov_len_at(uio, i), (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"); + bp = buf_alloc((vnode_t)0); } - /* [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); + while (((error = (int)buf_acquire(bp, 0, 0, 0)) == EAGAIN)); + + if (error) { + if (nobuf) + buf_free(bp); + return (error); } - /* Mark it busy, so nobody else will use it. */ - bp->b_flags |= B_BUSY; - - /* [lower the priority level] */ - splx(s); - /* [set up the fixed part of the buffer for a transfer] */ bp->b_dev = dev; - bp->b_error = 0; bp->b_proc = p; + buf_seterror(bp, 0); /* - * [while there are data to transfer and no I/O error] + * [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_iov_len_at(uio, i) > 0) { /* * [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.) + * to the read/write flag.) */ - s = splbio(); - bp->b_flags = B_BUSY | B_PHYS | B_RAW | flags; - splx(s); + buf_setflags(bp, B_PHYS | B_RAW | flags); + + if ( (iosize = uio_iov_len_at(uio, i)) > MAXPHYSIO_WIRED) + iosize = MAXPHYSIO_WIRED; /* [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->uio_offset / blocksize); + buf_setcount(bp, iosize); + // LP64todo - fix this! + buf_setdataptr(bp, CAST_DOWN(caddr_t, uio_iov_base_at(uio, i))); /* * [call minphys to bound the tranfer size] @@ -160,65 +163,42 @@ physio(strategy, bp, dev, flags, minphys, uio, blocksize) * for later comparison. */ (*minphys)(bp); - todo = bp->b_bcount; + 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)) + vslock(CAST_USER_ADDR_T(buf_dataptr(bp)), + (user_size_t)todo); -#if 0 - vmapbuf(bp, todo); -#endif /* 0 */ /* [call strategy to start the transfer] */ (*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_iov_len_add_at(uio, -done, i); + uio_iov_base_add_at(uio, done, i); + uio->uio_offset += done; + uio_setresid(uio, (uio_resid(uio) - done)); /* * Now, check for an error. @@ -235,25 +215,14 @@ done: * 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); + buf_clearflags(bp, B_PHYS | B_RAW); + if (nobuf) + buf_free(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); + { + buf_drop(bp); } - } - splx(s); return (error); } @@ -272,8 +241,8 @@ minphys(bp) struct buf *bp; { - bp->b_bcount = min(MAXPHYS, bp->b_bcount); - return bp->b_bcount; + buf_setcount(bp, min(MAXPHYS, buf_count(bp))); + return buf_count(bp); } /*