../machine => machine

[unix-history] / usr / src / sys / kern / kern_physio.c

diff --git a/usr/src/sys/kern/kern_physio.c b/usr/src/sys/kern/kern_physio.c
index a45cf4c..79e2e03 100644 (file)
--- a/usr/src/sys/kern/kern_physio.c
+++ b/usr/src/sys/kern/kern_physio.c
@@ -1,19 +1,30 @@
-/*     kern_physio.c   4.41    83/05/21        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)kern_physio.c       7.5 (Berkeley) %G%
+ */

 
 

-#include "../machine/pte.h"
+#include "param.h"
+#include "systm.h"
+#include "dir.h"
+#include "user.h"
+#include "buf.h"
+#include "conf.h"
+#include "proc.h"
+#include "seg.h"
+#include "vm.h"
+#include "trace.h"
+#include "map.h"
+#include "uio.h"

 
 

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/buf.h"
-#include "../h/conf.h"
-#include "../h/proc.h"
-#include "../h/seg.h"
-#include "../h/vm.h"
-#include "../h/trace.h"
-#include "../h/map.h"
-#include "../h/uio.h"
+#include "machine/pte.h"
+#ifdef SECSIZE
+#include "file.h"
+#include "ioctl.h"
+#include "disklabel.h"
+#endif SECSIZE

 
 /*
  * Swap IO headers -
 
 /*
  * Swap IO headers -


@@ -36,7 +47,7 @@ struct        buf *swbuf;
  * the index of the swap header that has been allocated.
  * We simply initialize the header and queue the I/O but
  * do not wait for completion. When the I/O completes,
  * the index of the swap header that has been allocated.
  * We simply initialize the header and queue the I/O but
  * do not wait for completion. When the I/O completes,

- * iodone() will link the header to a list of cleaned
+ * biodone() will link the header to a list of cleaned

  * pages to be processed by the pageout daemon.
  */
 swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
  * pages to be processed by the pageout daemon.
  */
 swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)


@@ -48,22 +59,17 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
        u_int pfcent;
 {
        register struct buf *bp;
        u_int pfcent;
 {
        register struct buf *bp;

-       register u_int c;
-       int p2dp;

        register struct pte *dpte, *vpte;
        register struct pte *dpte, *vpte;

-       int s;
-       extern swdone();
-
-       s = spl6();
-       while (bswlist.av_forw == NULL) {
-               bswlist.b_flags |= B_WANTED;
-               sleep((caddr_t)&bswlist, PSWP+1);
-       }
-       bp = bswlist.av_forw;
-       bswlist.av_forw = bp->av_forw;
-       splx(s);
+       register u_int c;
+       int p2dp, s, error = 0;
+       struct buf *getswbuf();
+       int swdone();

 
 

+       bp = getswbuf(PSWP+1);

        bp->b_flags = B_BUSY | B_PHYS | rdflg | flag;
        bp->b_flags = B_BUSY | B_PHYS | rdflg | flag;

+#ifdef SECSIZE
+       bp->b_blksize = DEV_BSIZE;
+#endif SECSIZE

        if ((bp->b_flags & (B_DIRTY|B_PGIN)) == 0)
                if (rdflg == B_READ)
                        sum.v_pswpin += btoc(nbytes);
        if ((bp->b_flags & (B_DIRTY|B_PGIN)) == 0)
                if (rdflg == B_READ)
                        sum.v_pswpin += btoc(nbytes);


@@ -94,32 +100,31 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
 #ifdef TRACE
                trace(TR_SWAPIO, dev, bp->b_blkno);
 #endif
 #ifdef TRACE
                trace(TR_SWAPIO, dev, bp->b_blkno);
 #endif

-               physstrat(bp, bdevsw[major(dev)].d_strategy, PSWP);
+               (*bdevsw[major(dev)].d_strategy)(bp);
+               /* pageout daemon doesn't wait for pushed pages */

                if (flag & B_DIRTY) {
                        if (c < nbytes)
                                panic("big push");
                if (flag & B_DIRTY) {
                        if (c < nbytes)
                                panic("big push");

-                       return;
+                       return (0);

                }
                bp->b_un.b_addr += c;
                bp->b_flags &= ~B_DONE;
                if (bp->b_flags & B_ERROR) {
                        if ((flag & (B_UAREA|B_PAGET)) || rdflg == B_WRITE)
                                panic("hard IO err in swap");
                }
                bp->b_un.b_addr += c;
                bp->b_flags &= ~B_DONE;
                if (bp->b_flags & B_ERROR) {
                        if ((flag & (B_UAREA|B_PAGET)) || rdflg == B_WRITE)
                                panic("hard IO err in swap");

-                       swkill(p, (char *)0);
+                       swkill(p, "swap: read error from swap device");
+                       error = EIO;

                }
                nbytes -= c;
                }
                nbytes -= c;

+#ifdef SECSIZE
+               if (flag & B_PGIN && nbytes > 0)
+                       panic("big pgin");
+#endif SECSIZE

                dblkno += btodb(c);
        }
                dblkno += btodb(c);
        }

-       s = spl6();

        bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY);
        bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY);

-       bp->av_forw = bswlist.av_forw;
-       bswlist.av_forw = bp;
-       if (bswlist.b_flags & B_WANTED) {
-               bswlist.b_flags &= ~B_WANTED;
-               wakeup((caddr_t)&bswlist);
-               wakeup((caddr_t)&proc[2]);
-       }
-       splx(s);
+       freeswbuf(bp);
+       return (error);

 }
 
 /*
 }
 
 /*


@@ -133,7 +138,7 @@ swdone(bp)
 
        if (bp->b_flags & B_ERROR)
                panic("IO err in push");
 
        if (bp->b_flags & B_ERROR)
                panic("IO err in push");

-       s = spl6();
+       s = splbio();

        bp->av_forw = bclnlist;
        cnt.v_pgout++;
        cnt.v_pgpgout += bp->b_bcount / NBPG;
        bp->av_forw = bclnlist;
        cnt.v_pgout++;
        cnt.v_pgpgout += bp->b_bcount / NBPG;


@@ -152,14 +157,9 @@ swkill(p, rout)
        struct proc *p;
        char *rout;
 {
        struct proc *p;
        char *rout;
 {

-       char *mesg;

 
 

-       printf("pid %d: ", p->p_pid);
-       if (rout)
-               printf(mesg = "killed due to no swap space\n");
-       else
-               printf(mesg = "killed on swap error\n");
-       uprintf("sorry, pid %d was %s", p->p_pid, mesg);
+       printf("pid %d: %s\n", p->p_pid, rout);
+       uprintf("sorry, pid %d was killed in %s\n", p->p_pid, rout);

        /*
         * To be sure no looping (e.g. in vmsched trying to
         * swap out) mark process locked in core (as though
        /*
         * To be sure no looping (e.g. in vmsched trying to
         * swap out) mark process locked in core (as though


@@ -173,8 +173,9 @@ swkill(p, rout)
 /*
  * Raw I/O. The arguments are
  *     The strategy routine for the device
 /*
  * Raw I/O. The arguments are
  *     The strategy routine for the device

- *     A buffer, which will always be a special buffer
- *       header owned exclusively by the device for this purpose
+ *     A buffer, which will either be a special buffer header owned
+ *         exclusively by the device for this purpose, or NULL,
+ *         indicating that we should use a swap buffer

  *     The device number
  *     Read/write flag
  * Essentially all the work is computing physical addresses and
  *     The device number
  *     Read/write flag
  * Essentially all the work is computing physical addresses and


@@ -189,78 +190,151 @@ physio(strat, bp, dev, rw, mincnt, uio)
        register struct buf *bp;
        dev_t dev;
        int rw;
        register struct buf *bp;
        dev_t dev;
        int rw;

-       unsigned (*mincnt)();
+       u_int (*mincnt)();

        struct uio *uio;
 {
        struct uio *uio;
 {

-       register struct iovec *iov = uio->uio_iov;
+       register struct iovec *iov;

        register int c;
        char *a;
        register int c;
        char *a;

-       int s, error = 0;
+       int s, allocbuf = 0, error = 0;
+       struct buf *getswbuf();
+#ifdef SECSIZE
+       int bsize;
+       struct partinfo dpart;
+#endif SECSIZE

 
 

-nextiov:
-       if (uio->uio_iovcnt == 0)
-               return (0);
-       if (useracc(iov->iov_base,(u_int)iov->iov_len,rw==B_READ?B_WRITE:B_READ) == NULL)
-               return (EFAULT);
-       s = spl6();
-       while (bp->b_flags&B_BUSY) {
-               bp->b_flags |= B_WANTED;
-               sleep((caddr_t)bp, PRIBIO+1);
-       }
-       splx(s);
-       bp->b_error = 0;
-       bp->b_proc = u.u_procp;
-       bp->b_un.b_addr = iov->iov_base;
-       while (iov->iov_len > 0) {
-               bp->b_flags = B_BUSY | B_PHYS | rw;
-               bp->b_dev = dev;
-               bp->b_blkno = btodb(uio->uio_offset);
-               bp->b_bcount = iov->iov_len;
-               (*mincnt)(bp);
-               c = bp->b_bcount;
-               u.u_procp->p_flag |= SPHYSIO;
-               vslock(a = bp->b_un.b_addr, c);
-               physstrat(bp, strat, PRIBIO);
-               (void) spl6();
-               vsunlock(a, c, rw);
-               u.u_procp->p_flag &= ~SPHYSIO;
-               if (bp->b_flags&B_WANTED)
-                       wakeup((caddr_t)bp);
-               splx(s);
-               c -= bp->b_resid;
-               bp->b_un.b_addr += c;
-               iov->iov_len -= c;
-               uio->uio_resid -= c;
-               uio->uio_offset += c;
+#ifdef SECSIZE
+       if ((unsigned)major(dev) < nchrdev &&
+           (*cdevsw[major(dev)].d_ioctl)(dev, DIOCGPART, (caddr_t)&dpart,
+           FREAD) == 0)
+               bsize = dpart.disklab->d_secsize;
+       else
+               bsize = DEV_BSIZE;
+#endif SECSIZE
+       for (;;) {
+               if (uio->uio_iovcnt == 0)
+                       return (0);
+               iov = uio->uio_iov;
+               if (useracc(iov->iov_base, (u_int)iov->iov_len,
+                   rw==B_READ? B_WRITE : B_READ) == NULL)
+                       return (EFAULT);
+               s = splbio();
+               while (bp->b_flags&B_BUSY) {
+                       bp->b_flags |= B_WANTED;
+                       sleep((caddr_t)bp, PRIBIO+1);
+               }
+               if (!allocbuf) {        /* only if sharing caller's buffer */
+                       s = splbio();
+                       while (bp->b_flags&B_BUSY) {
+                               bp->b_flags |= B_WANTED;
+                               sleep((caddr_t)bp, PRIBIO+1);
+                       }
+                       splx(s);
+               }
+               bp->b_error = 0;
+               bp->b_proc = u.u_procp;
+#ifdef SECSIZE
+               bp->b_blksize = bsize;
+#endif SECSIZE
+               bp->b_un.b_addr = iov->iov_base;
+               while (iov->iov_len > 0) {
+                       bp->b_flags = B_BUSY | B_PHYS | rw;
+                       bp->b_dev = dev;
+#ifdef SECSIZE
+                       bp->b_blkno = uio->uio_offset / bsize;
+#else SECSIZE
+                       bp->b_blkno = btodb(uio->uio_offset);
+#endif SECSIZE
+                       bp->b_bcount = iov->iov_len;
+                       (*mincnt)(bp);
+                       c = bp->b_bcount;
+                       u.u_procp->p_flag |= SPHYSIO;
+                       vslock(a = bp->b_un.b_addr, c);
+                       physstrat(bp, strat, PRIBIO);
+                       (void) splbio();
+                       vsunlock(a, c, rw);
+                       u.u_procp->p_flag &= ~SPHYSIO;
+                       if (bp->b_flags&B_WANTED)
+                               wakeup((caddr_t)bp);
+                       splx(s);
+                       c -= bp->b_resid;
+                       bp->b_un.b_addr += c;
+                       iov->iov_len -= c;
+                       uio->uio_resid -= c;
+                       uio->uio_offset += c;
+                       /* temp kludge for tape drives */
+                       if (bp->b_resid || (bp->b_flags&B_ERROR))
+                               break;
+               }
+               bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS);
+               error = geterror(bp);

                /* temp kludge for tape drives */
                /* temp kludge for tape drives */

-               if (bp->b_resid || (bp->b_flags&B_ERROR))
-                       break;
+               if (bp->b_resid || error)
+                       return (error);
+               uio->uio_iov++;
+               uio->uio_iovcnt--;

        }
        }

-       bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS);
-       error = geterror(bp);
-       /* temp kludge for tape drives */
-       if (bp->b_resid || error)
-               return (error);
-       uio->uio_iov++;
-       uio->uio_iovcnt--;
-       goto nextiov;
+       if (allocbuf)
+               freeswbuf(bp);
+       return (error);

 }
 
 }
 

-#define        MAXPHYS (63 * 1024)
-
-/* network disk brain damage */
-#include "nd.h"
-#if NND > 0
-#undef MAXPHYS
-#define        MAXPHYS (32 * 1024)
-#endif
-
-unsigned
+u_int

 minphys(bp)
        struct buf *bp;
 {
 minphys(bp)
        struct buf *bp;
 {

-

        if (bp->b_bcount > MAXPHYS)
                bp->b_bcount = MAXPHYS;
 }
 
        if (bp->b_bcount > MAXPHYS)
                bp->b_bcount = MAXPHYS;
 }
 

+static
+struct buf *
+getswbuf(prio)
+       int prio;
+{
+       int s;
+       struct buf *bp;
+
+       s = splbio();
+       while (bswlist.av_forw == NULL) {
+               bswlist.b_flags |= B_WANTED;
+               sleep((caddr_t)&bswlist, prio);
+       }
+       bp = bswlist.av_forw;
+       bswlist.av_forw = bp->av_forw;
+       splx(s);
+       return (bp);
+}
+
+static
+freeswbuf(bp)
+       struct buf *bp;
+{
+       int s;
+
+       s = splbio();
+       bp->av_forw = bswlist.av_forw;
+       bswlist.av_forw = bp;
+       if (bswlist.b_flags & B_WANTED) {
+               bswlist.b_flags &= ~B_WANTED;
+               wakeup((caddr_t)&bswlist);
+               wakeup((caddr_t)&proc[2]);
+       }
+       splx(s);
+}
+
+rawread(dev, uio)
+       dev_t dev;
+       struct uio *uio;
+{
+       return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
+           dev, B_READ, minphys, uio));
+}
+
+rawwrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;
+{
+       return (physio(cdevsw[major(dev)].d_strategy, (struct buf *)NULL,
+           dev, B_WRITE, minphys, uio));
+}