X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/91447636331957f3d9b5ca5b508f07c526b0074d..HEAD:/bsd/kern/kern_physio.c diff --git a/bsd/kern/kern_physio.c b/bsd/kern/kern_physio.c index 2b6ba9062..3d8b00ef3 100644 --- a/bsd/kern/kern_physio.c +++ b/bsd/kern/kern_physio.c @@ -1,23 +1,29 @@ /* * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. * - * @APPLE_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 Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * @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. 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 * 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. - * - * @APPLE_LICENSE_HEADER_END@ + * 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_OSREFERENCE_LICENSE_HEADER_END@ */ /*- * Copyright (c) 1982, 1986, 1990, 1993 @@ -70,27 +76,26 @@ #include #include #include +#include int -physio(strategy, bp, dev, flags, minphys, uio, blocksize) - void (*strategy)(); - buf_t 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 proc *p = current_proc(); - int error, i, nobuf, todo, iosize; -#if LP64KERN + int error, i, buf_allocated, todo; + size_t iosize; + int orig_bflags = 0; 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] @@ -100,163 +105,152 @@ 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_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); + 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 = buf_alloc((vnode_t)0); - } - - /* [while the buffer is marked busy] */ - while (((error = (int)buf_acquire(bp, 0, 0, 0)) == EAGAIN)); - - if (error) { - if (nobuf) - buf_free(bp); - return (error); + /* + * 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_proc = p; - buf_seterror(bp, 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 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++) { - 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 read/write flag.) - */ - buf_setflags(bp, B_PHYS | B_RAW | flags); - - if ( (iosize = uio_iov_len_at(uio, i)) > MAXPHYSIO_WIRED) - iosize = MAXPHYSIO_WIRED; + while (uio_resid(uio) > 0) { + iosize = uio_curriovlen(uio); + if (iosize > MAXPHYSIO_WIRED) { + iosize = MAXPHYSIO_WIRED; + } - /* [set up the buffer for a maximum-sized transfer] */ - 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] - * and remember the amount of data to transfer, - * for later comparison. - */ - (*minphys)(bp); - todo = buf_count(bp); + /* + * make sure we're set to issue a fresh I/O + * in the right direction + */ + buf_reset(bp, flags); - /* - * [lock the part of the user address space involved - * in the transfer] - */ + /* [set up the buffer for a maximum-sized transfer] */ + buf_setblkno(bp, uio_offset(uio) / blocksize); + assert(iosize <= UINT32_MAX); + buf_setcount(bp, (uint32_t)iosize); + buf_setdataptr(bp, (uintptr_t)CAST_DOWN(caddr_t, uio_curriovbase(uio))); - if(UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) - vslock(CAST_USER_ADDR_T(buf_dataptr(bp)), - (user_size_t)todo); - - /* [call strategy to start the transfer] */ - (*strategy)(bp); + /* + * [call f_minphys to bound the tranfer size] + * and remember the amount of data to transfer, + * for later comparison. + */ + (*f_minphys)(bp); + todo = buf_count(bp); + /* + * [lock the part of the user address space involved + * in the transfer] + */ + + 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 finished; + } + } - /* [wait for the transfer to complete] */ - error = (int)buf_biowait(bp); + /* [call f_strategy to start the transfer] */ + (*f_strategy)(bp); - /* - * [unlock the part of the address space previously - * locked] - */ - 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 = 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)); + /* [wait for the transfer to complete] */ + error = (int)buf_biowait(bp); - /* - * Now, check for an error. - * Also, handle weird end-of-disk semantics. - */ - if (error || done < todo) - goto done; + /* + * [unlock the part of the address space previously + * locked] + */ + if (UIO_SEG_IS_USER_SPACE(uio->uio_segflg)) { + vsunlock(CAST_USER_ADDR_T(buf_dataptr(bp)), + (user_size_t)todo, + (flags & B_READ)); } - } -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. - */ + /* + * [deduct the transfer size from the total number + * of data to transfer] + */ + done = buf_count(bp) - buf_resid(bp); + assert(0 <= done && done <= UINT32_MAX); + uio_update(uio, (user_size_t)done); - buf_clearflags(bp, B_PHYS | B_RAW); - if (nobuf) - buf_free(bp); - else - { - buf_drop(bp); + /* + * Now, check for an error. + * Also, handle weird end-of-disk semantics. + */ + if (error || done < todo) { + goto finished; } + } - return (error); +finished: + if (buf_allocated) { + buf_free(bp); + } else { + buf_setflags(bp, orig_bflags); + } + + return error; } /* * Leffler, et al., says on p. 231: * "The minphys() routine is called by physio() to adjust the * size of each I/O transfer before the latter is passed to - * the strategy routine..." + * the strategy routine..." * * so, just adjust the buffer's count accounting to MAXPHYS here, * and return the new count; */ u_int -minphys(bp) - struct buf *bp; +minphys(struct buf *bp) { - buf_setcount(bp, min(MAXPHYS, buf_count(bp))); - return buf_count(bp); -} - -/* - * 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)); + return buf_count(bp); }