Return to kern__physio.c CVS log

Up to [Net/2] / Net2 / kern

Annotation of Net2/kern/kern__physio.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1989, 1990, 1991, 1992 William F. Jolitz, TeleMuse
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms, with or without
                      6:  * modification, are permitted provided that the following conditions
                      7:  * are met:
                      8:  * 1. Redistributions of source code must retain the above copyright
                      9:  *    notice, this list of conditions and the following disclaimer.
                     10:  * 2. Redistributions in binary form must reproduce the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer in the
                     12:  *    documentation and/or other materials provided with the distribution.
                     13:  * 3. All advertising materials mentioning features or use of this software
                     14:  *    must display the following acknowledgement:
                     15:  *     This software is a component of "386BSD" developed by 
                     16:        William F. Jolitz, TeleMuse.
                     17:  * 4. Neither the name of the developer nor the name "386BSD"
                     18:  *    may be used to endorse or promote products derived from this software
                     19:  *    without specific prior written permission.
                     20:  *
                     21:  * THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ 
                     22:  * AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS 
                     23:  * SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT. 
                     24:  * THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT 
                     25:  * NOT MAKE USE THIS WORK.
                     26:  *
                     27:  * FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
                     28:  * BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN 
                     29:  * REFERENCES SUCH AS THE  "PORTING UNIX TO THE 386" SERIES 
                     30:  * (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING 
                     31:  * JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND 
                     32:  * LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE 
                     33:  * ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS 
                     34:  * OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
                     35:  *
                     36:  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
                     37:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     38:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     39:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE DEVELOPER BE LIABLE
                     40:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     41:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     42:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     43:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     44:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     45:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     46:  * SUCH DAMAGE.
                     47:  *
                     48:  */
                     49: static char rcsid[] = "$Header: /usr/bill/working/sys/kern/RCS/kern__physio.c,v 1.3 92/01/21 21:29:06 william Exp $";
                     50: 
                     51: #include "param.h"
                     52: #include "systm.h"
                     53: #include "buf.h"
                     54: #include "conf.h"
                     55: #include "proc.h"
                     56: #include "malloc.h"
                     57: #include "vnode.h"
                     58: #include "specdev.h"
                     59: 
                     60: static physio(int (*)(), int, int, int, caddr_t, int *, struct proc *);
                     61: 
                     62: /*
                     63:  * Driver interface to do "raw" I/O in the address space of a
                     64:  * user process directly for read and write operations..
                     65:  */
                     66: 
                     67: rawread(dev, uio)
                     68:        dev_t dev; struct uio *uio;
                     69: {
                     70:        return (uioapply(physio, cdevsw[major(dev)].d_strategy, dev, uio));
                     71: }
                     72: 
                     73: rawwrite(dev, uio)
                     74:        dev_t dev; struct uio *uio;
                     75: {
                     76:        return (uioapply(physio, cdevsw[major(dev)].d_strategy, dev, uio));
                     77: }
                     78: 
                     79: static physio(strat, dev, off, rw, base, len, p)
                     80:        int (*strat)(); 
                     81:        dev_t dev;
                     82:        int rw, off;
                     83:        caddr_t base;
                     84:        int *len;
                     85:        struct proc *p;
                     86: {
                     87:        register struct buf *bp;
                     88:        int resid = *len, error;
                     89: 
                     90:        rw = rw == UIO_READ ? B_READ : 0;
                     91: 
                     92:        /* create and build a buffer header for a transfer */
                     93:        bp = (struct buf *)malloc(sizeof(*bp), M_TEMP, M_NOWAIT);
                     94:        bp->b_flags = B_BUSY | B_PHYS | rw;
                     95:        bp->b_proc = p;
                     96:        bp->b_dev = dev;
                     97:        bp->b_error = 0;
                     98:        bp->b_blkno = off/DEV_BSIZE;
                     99: 
                    100:        /* iteratively do I/O on as large a chunk as possible */
                    101:        do {
                    102:                bp->b_flags &= ~B_DONE;
                    103:                bp->b_un.b_addr = base;
                    104:                /* DMA controller limit */
                    105:                bp->b_bcount = min (64*1024, resid);
                    106:                resid -= bp->b_bcount;
                    107:                off += bp->b_bcount;
                    108: 
                    109:                /* first, check if accessible */
                    110:                if (rw == B_READ && !useracc(base, bp->b_bcount, B_WRITE))
                    111:                        return (EFAULT);
                    112:                if (rw == B_WRITE && !useracc(base, bp->b_bcount, B_READ))
                    113:                        return (EFAULT);
                    114: 
                    115:                /* lock in core */
                    116:                vslock (base, bp->b_bcount);
                    117: 
                    118:                /* perform transfer */
                    119:                physstrat(bp, strat, PRIBIO);
                    120: 
                    121:                /* unlock */
                    122:                vsunlock (base, bp->b_bcount, 0);
                    123:                resid += bp->b_resid;
                    124:                bp->b_blkno = off/DEV_BSIZE;
                    125:        } while (resid && (bp->b_flags & B_ERROR) == 0 && bp->b_resid == 0);
                    126: 
                    127:        error = bp->b_error;
                    128:        free(bp, M_TEMP);
                    129:        *len = resid;
                    130:        return (error);
                    131: }