xnu-7195.101.1.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 def3db88675ccfde6be53f2d7cf3922319b501d5..3d8b00ef33059843b63b35b8cd32f59b723b2233 100644 (file)
--- a/bsd/kern/kern_physio.c
+++ b/bsd/kern/kern_physio.c
@@ -1,17 +1,20 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  *
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
- * 

  * 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
  * 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
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * 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,


@@ -19,8 +22,8 @@
  * 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.
  * 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


@@ -69,26 +72,30 @@
 
 #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
 
 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;
+       size_t iosize;
+       int orig_bflags = 0;
+       int64_t done;

 
        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]


@@ -98,205 +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++) {
         * 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,
-                               (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 = 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);
+       /*
+        * 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);

 
 

-       /* 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] */
+       /*
+        * [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.
         */
         * 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) {
-                       /*
-                        * [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.)
-                        */
-                       s = splbio();
-                       bp->b_flags = B_BUSY | B_PHYS | B_RAW | flags;
-                       splx(s);
-
-                       /* [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;
-                       
-                       /*
-                        * [call minphys to bound the tranfer size]
-                        * and remember the amount of data to transfer,
-                        * for later comparison.
-                        */
-                       (*minphys)(bp);
-                       todo = bp->b_bcount;
+       while (uio_resid(uio) > 0) {
+               iosize = uio_curriovlen(uio);
+               if (iosize > MAXPHYSIO_WIRED) {
+                       iosize = MAXPHYSIO_WIRED;
+               }

 
 

-                       /*
-                        * [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.
-                        */
+               /*
+                * make sure we're set to issue a fresh I/O
+                * in the right direction
+                */
+               buf_reset(bp, flags);

 
 

-                       if(uio->uio_segflg != UIO_SYSSPACE)
-                               vslock(bp->b_data, todo);
-                       
-#if 0
-                       vmapbuf(bp, todo);
-#endif /* 0 */
-                       /* [call strategy to start the transfer] */
-                       (*strategy)(bp);
+               /* [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)));

 
 

-                       /*
-                        * 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();
+               /*
+                * [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);

 
 

-                       /* [wait for the transfer to complete] */
-                       while ((bp->b_flags & B_DONE) == 0)
-                               tsleep((caddr_t) bp, PRIBIO + 1, "physio", 0);
+               /*
+                * [lock the part of the user address space involved
+                *    in the transfer]
+                */

 
 

-                       /*
-                        * [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);
+               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;
+                       }
+               }

 
 

-                       /* remember error value (save a splbio/splx pair) */
-                       if (bp->b_flags & B_ERROR)
-                               error = (bp->b_error ? bp->b_error : EIO);
+               /* [call f_strategy to start the transfer] */
+               (*f_strategy)(bp);

 
 

-                       /* [lower the priority level] */
-                       splx(s);

 
 

-                       /*
-                        * [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;
+               /* [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.
-        */
-       s = splbio();
-       bp->b_flags &= ~(B_BUSY | B_PHYS | B_RAW);
-#if 0
-       if (nobuf)
-               putphysbuf(bp);
+               /*
+                * [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);

 
 

-       else 
-#endif /* 0 */
-               {

                /*
                /*

-                * [if another process is waiting for the raw I/O buffer,
-                *    wake up processes waiting to do physical I/O;
+                * Now, check for an error.
+                * Also, handle weird end-of-disk semantics.

                 */
                 */

-               if (bp->b_flags & B_WANTED) {
-                       bp->b_flags &= ~B_WANTED;
-                       wakeup(bp);
+               if (error || done < todo) {
+                       goto finished;

                }
        }
                }
        }

-       splx(s);

 
 

-       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
 }
 
 /*
  * 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
  *
  * so, just adjust the buffer's count accounting to MAXPHYS here,
  * and return the new count;
  */
 u_int

-minphys(bp)
-       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;
+minphys(struct buf *bp)

 {
 {

-       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);

 }
 }