projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
typo
[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 daf7208..eedca3a 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   6.2     83/09/09        */
+/*
+ * 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.3 (Berkeley) %G%
+ */
 
 #include "../machine/pte.h"
 
 
 #include "../machine/pte.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 "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"
+#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)
@@ -53,8 +64,9 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
        register struct pte *dpte, *vpte;
        int s;
        extern swdone();
        register struct pte *dpte, *vpte;
        int s;
        extern swdone();
+       int error = 0;
 
 
-       s = spl6();
+       s = splbio();
        while (bswlist.av_forw == NULL) {
                bswlist.b_flags |= B_WANTED;
                sleep((caddr_t)&bswlist, PSWP+1);
        while (bswlist.av_forw == NULL) {
                bswlist.b_flags |= B_WANTED;
                sleep((caddr_t)&bswlist, PSWP+1);
@@ -64,6 +76,9 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
        splx(s);
 
        bp->b_flags = B_BUSY | B_PHYS | rdflg | flag;
        splx(s);
 
        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);
@@ -98,19 +113,24 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
                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();
+       s = splbio();
        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;
        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;
@@ -120,6 +140,7 @@ swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
                wakeup((caddr_t)&proc[2]);
        }
        splx(s);
                wakeup((caddr_t)&proc[2]);
        }
        splx(s);
+       return (error);
 }
 
 /*
 }
 
 /*
@@ -133,7 +154,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 +173,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
@@ -192,62 +208,81 @@ physio(strat, bp, dev, rw, mincnt, uio)
        unsigned (*mincnt)();
        struct uio *uio;
 {
        unsigned (*mincnt)();
        struct uio *uio;
 {
-       register struct iovec *iov = uio->uio_iov;
+       register struct iovec *iov;
        register int c;
        char *a;
        int s, error = 0;
        register int c;
        char *a;
        int s, error = 0;
+#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);
+#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);
+               }
                splx(s);
                splx(s);
-               c -= bp->b_resid;
-               bp->b_un.b_addr += c;
-               iov->iov_len -= c;
-               uio->uio_resid -= c;
-               uio->uio_offset += c;
+               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;
 }
 
 }
 
-#define        MAXPHYS (63 * 1024)
-
 unsigned
 minphys(bp)
        struct buf *bp;
 unsigned
 minphys(bp)
        struct buf *bp;
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.