xnu-1228.7.58.tar.gz

[apple/xnu.git] / bsd / kern / kern_physio.c

diff --git a/bsd/kern/kern_physio.c b/bsd/kern/kern_physio.c
index c4f2415f5189ecb14280d67e7029635dee9c2318..2255daf1dc052389654ec75c8a3c486a27208d66 100644 (file)
--- 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,
  * 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
  */
 /*-
  * Copyright (c) 1982, 1986, 1990, 1993


@@ -66,26 +72,36 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
 
 #include <sys/param.h>
 #include <sys/systm.h>

-#include <sys/buf.h>
+#include <sys/buf_internal.h>

 #include <sys/conf.h>
 #include <sys/conf.h>

-#include <sys/proc.h>
+#include <sys/proc_internal.h>
+#include <sys/uio_internal.h>
+#include <kern/assert.h>
+
+int rawread(dev_t dev, struct uio *uio);
+int rawwrite(dev_t dev, struct uio *uio);

 
 int
 
 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();
        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;
 
        error = 0;
        flags &= B_READ | B_WRITE;

+       buf_allocated = 0;

 
        /*
         * [check user read/write access to the data buffer]
 
        /*
         * [check user read/write access to the data buffer]


@@ -95,130 +111,113 @@ 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++) {
         * 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);
                }
        }
                                (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_dev = dev;

-       bp->b_error = 0;

        bp->b_proc = p;
 
        /*
        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++) {
         * 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) {
+                       
+                       if ( (iosize = uio_iov_len_at(uio, i)) > 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] */
 
                        /* [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, (uintptr_t)CAST_DOWN(caddr_t, uio_iov_base_at(uio, i)));

                        
                        /*
                        
                        /*

-                        * [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.
                         */
                         * 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]
 
                        /*
                         * [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] */
 
                        /* [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]
                         */
 
                        /*
                         * [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]
                         */
 
                        /*
                         * [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.
 
                        /*
                         * Now, check for an error.


@@ -230,30 +229,10 @@ physio(strategy, bp, dev, flags, minphys, uio, blocksize)
        }
 
 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);
 }
 
        return (error);
 }


@@ -268,20 +247,18 @@ done:
  * and return the new count;
  */
 u_int
  * 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;
+       buf_setcount(bp, min(MAXPHYS, buf_count(bp)));
+        return buf_count(bp);

 }
 
 /*
  * Do a read on a device for a user process.
  */
 }
 
 /*
  * Do a read on a device for a user process.
  */

-rawread(dev, uio)
-       dev_t dev;
-       struct uio *uio;
+int
+rawread(dev_t dev, struct uio *uio)

 {
        return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
            dev, B_READ, minphys, uio, DEV_BSIZE));
 {
        return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
            dev, B_READ, minphys, uio, DEV_BSIZE));


@@ -290,9 +267,8 @@ rawread(dev, uio)
 /*
  * Do a write on a device for a user process.
  */
 /*
  * Do a write on a device for a user process.
  */

-rawwrite(dev, uio)
-       dev_t dev;
-       struct uio *uio;
+int
+rawwrite(dev_t dev, struct uio *uio)

 {
        return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
            dev, B_WRITE, minphys, uio, DEV_BSIZE));
 {
        return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
            dev, B_WRITE, minphys, uio, DEV_BSIZE));