projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_3 release
[unix-history] / usr / src / sys / vaxuba / rk.c
diff --git a/usr/src/sys/vaxuba/rk.c b/usr/src/sys/vaxuba/rk.c
index 45c258c..e5d2b13 100644 (file)
--- a/usr/src/sys/vaxuba/rk.c
+++ b/usr/src/sys/vaxuba/rk.c
@@ -1,4 +1,10 @@
-/*     rk.c    6.2     83/10/11        */
+/*
+ * 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.
+ *
+ *     @(#)rk.c        7.1 (Berkeley) 6/5/86
+ */
 
 #include "rk.h"
 #if NHK > 0
 
 #include "rk.h"
 #if NHK > 0
@@ -20,24 +26,25 @@ int rkbdebug;
  */
 #include "../machine/pte.h"
 
  */
 #include "../machine/pte.h"
 
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/buf.h"
-#include "../h/conf.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/map.h"
-#include "../h/vm.h"
-#include "../h/dk.h"
-#include "../h/cmap.h"
-#include "../h/dkbad.h"
-#include "../h/uio.h"
-#include "../h/kernel.h"
+#include "param.h"
+#include "systm.h"
+#include "buf.h"
+#include "conf.h"
+#include "dir.h"
+#include "user.h"
+#include "map.h"
+#include "vm.h"
+#include "dk.h"
+#include "cmap.h"
+#include "dkbad.h"
+#include "uio.h"
+#include "kernel.h"
+#include "syslog.h"
 
 #include "../vax/cpu.h"
 
 #include "../vax/cpu.h"
-#include "../vaxuba/ubareg.h"
-#include "../vaxuba/ubavar.h"
-#include "../vaxuba/rkreg.h"
+#include "ubareg.h"
+#include "ubavar.h"
+#include "rkreg.h"
 
 struct rk_softc {
        int     sc_softas;
 
 struct rk_softc {
        int     sc_softas;
@@ -46,18 +53,20 @@ struct      rk_softc {
        int     sc_recal;
 } rk_softc[NHK];
 
        int     sc_recal;
 } rk_softc[NHK];
 
+#define rkunit(dev)    (minor(dev) >> 3)
+
 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
 struct size {
        daddr_t nblocks;
        int     cyloff;
 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
 struct size {
        daddr_t nblocks;
        int     cyloff;
-} rk7_sizes[8] ={
+} rk7_sizes[8] = {
        15884,  0,              /* A=cyl 0 thru 240 */
        10032,  241,            /* B=cyl 241 thru 392 */
        53790,  0,              /* C=cyl 0 thru 814 */
        15884,  0,              /* A=cyl 0 thru 240 */
        10032,  241,            /* B=cyl 241 thru 392 */
        53790,  0,              /* C=cyl 0 thru 814 */
+       15884,  393,            /* D=cyl 393 thru 633 */
        0,      0,
        0,      0,
-       0,      0,
-       0,      0,
-       27786,  393,            /* G=cyl 393 thru 813 */
+       11792,  634,            /* F=cyl 634 thru 814 */
+       27786,  393,            /* G=cyl 393 thru 814, should be 27698 */
        0,      0,
 }, rk6_sizes[8] ={
        15884,  0,              /* A=cyl 0 thru 240 */
        0,      0,
 }, rk6_sizes[8] ={
        15884,  0,              /* A=cyl 0 thru 240 */
@@ -106,10 +115,6 @@ struct     buf rrkbuf[NRK];
 
 #define        b_cylin b_resid
 
 
 #define        b_cylin b_resid
 
-#ifdef INTRLVE
-daddr_t        dkblock();
-#endif
-
 int    rkwstart, rkwatch();
 
 rkprobe(reg)
 int    rkwstart, rkwatch();
 
 rkprobe(reg)
@@ -169,7 +174,7 @@ rkattach(ui)
 rkopen(dev)
        dev_t dev;
 {
 rkopen(dev)
        dev_t dev;
 {
-       register int unit = minor(dev) >> 3;
+       register int unit = rkunit(dev);
        register struct uba_device *ui;
 
        if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0)
        register struct uba_device *ui;
 
        if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0)
@@ -189,16 +194,26 @@ rkstrategy(bp)
        int s;
 
        sz = (bp->b_bcount+511) >> 9;
        int s;
 
        sz = (bp->b_bcount+511) >> 9;
-       unit = dkunit(bp);
-       if (unit >= NRK)
+       unit = rkunit(bp->b_dev);
+       if (unit >= NRK) {
+               bp->b_error = ENXIO;
                goto bad;
                goto bad;
+       }
        ui = rkdinfo[unit];
        ui = rkdinfo[unit];
-       if (ui == 0 || ui->ui_alive == 0)
+       if (ui == 0 || ui->ui_alive == 0) {
+               bp->b_error = ENXIO;
                goto bad;
                goto bad;
+       }
        st = &rkst[ui->ui_type];
        if (bp->b_blkno < 0 ||
        st = &rkst[ui->ui_type];
        if (bp->b_blkno < 0 ||
-           (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks)
+           (bn = bp->b_blkno)+sz > st->sizes[xunit].nblocks) {
+               if (bp->b_blkno == st->sizes[xunit].nblocks) {
+                   bp->b_resid = bp->b_bcount;
+                   goto done;
+               }
+               bp->b_error = EINVAL;
                goto bad;
                goto bad;
+       }
        bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
        s = spl5();
        dp = &rkutab[ui->ui_unit];
        bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
        s = spl5();
        dp = &rkutab[ui->ui_unit];
@@ -214,6 +229,7 @@ rkstrategy(bp)
 
 bad:
        bp->b_flags |= B_ERROR;
 
 bad:
        bp->b_flags |= B_ERROR;
+done:
        iodone(bp);
        return;
 }
        iodone(bp);
        return;
 }
@@ -308,8 +324,8 @@ loop:
                goto loop;
        }
        um->um_tab.b_active++;
                goto loop;
        }
        um->um_tab.b_active++;
-       ui = rkdinfo[dkunit(bp)];
-       bn = dkblock(bp);
+       ui = rkdinfo[rkunit(bp->b_dev)];
+       bn = bp->b_blkno;
        st = &rkst[ui->ui_type];
        sn = bn%st->nspc;
        tn = sn/st->nsect;
        st = &rkst[ui->ui_type];
        sn = bn%st->nspc;
        tn = sn/st->nsect;
@@ -329,7 +345,7 @@ retry:
                goto retry;
        }
        if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
                goto retry;
        }
        if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
-               printf("rk%d: not ready", dkunit(bp));
+               printf("rk%d: not ready", rkunit(bp->b_dev));
                if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
                        printf("\n");
                        rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
                if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
                        printf("\n");
                        rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
@@ -386,7 +402,7 @@ rkintr(rk11)
                um->um_tab.b_active = 1;
                dp = um->um_tab.b_actf;
                bp = dp->b_actf;
                um->um_tab.b_active = 1;
                dp = um->um_tab.b_actf;
                bp = dp->b_actf;
-               ui = rkdinfo[dkunit(bp)];
+               ui = rkdinfo[rkunit(bp->b_dev)];
                dk_busy &= ~(1 << ui->ui_dk);
                if (bp->b_flags&B_BAD)
                        if (rkecc(ui, CONT))
                dk_busy &= ~(1 << ui->ui_dk);
                if (bp->b_flags&B_BAD)
                        if (rkecc(ui, CONT))
@@ -404,7 +420,8 @@ rkintr(rk11)
                        }
 #endif
                        if (er & RKER_WLE) {
                        }
 #endif
                        if (er & RKER_WLE) {
-                               printf("rk%d: write locked\n", dkunit(bp));
+                               printf("rk%d: write locked\n",
+                                       rkunit(bp->b_dev));
                                bp->b_flags |= B_ERROR;
                        } else if (++um->um_tab.b_errcnt > 28 ||
                            ds&RKDS_HARD || er&RKER_HARD || cs2&RKCS2_HARD) {
                                bp->b_flags |= B_ERROR;
                        } else if (++um->um_tab.b_errcnt > 28 ||
                            ds&RKDS_HARD || er&RKER_HARD || cs2&RKCS2_HARD) {
@@ -518,7 +535,7 @@ rkread(dev, uio)
        dev_t dev;
        struct uio *uio;
 {
        dev_t dev;
        struct uio *uio;
 {
-       register int unit = minor(dev) >> 3;
+       register int unit = rkunit(dev);
 
        if (unit >= NRK)
                return (ENXIO);
 
        if (unit >= NRK)
                return (ENXIO);
@@ -529,7 +546,7 @@ rkwrite(dev, uio)
        dev_t dev;
        struct uio *uio;
 {
        dev_t dev;
        struct uio *uio;
 {
-       register int unit = minor(dev) >> 3;
+       register int unit = rkunit(dev);
 
        if (unit >= NRK)
                return (ENXIO);
 
        if (unit >= NRK)
                return (ENXIO);
@@ -551,10 +568,10 @@ rkecc(ui, flag)
        if (flag == CONT)
                npf = bp->b_error;
        else
        if (flag == CONT)
                npf = bp->b_error;
        else
-               npf = btop((rk->rkwc * sizeof(short)) + bp->b_bcount);
+               npf = btodb(bp->b_bcount + (rk->rkwc * sizeof(short)) + 511);
        reg = btop(um->um_ubinfo&0x3ffff) + npf;
        o = (int)bp->b_un.b_addr & PGOFSET;
        reg = btop(um->um_ubinfo&0x3ffff) + npf;
        o = (int)bp->b_un.b_addr & PGOFSET;
-       bn = dkblock(bp);
+       bn = bp->b_blkno;
        st = &rkst[ui->ui_type];
        cn = bp->b_cylin;
        sn = bn%st->nspc + npf;
        st = &rkst[ui->ui_type];
        cn = bp->b_cylin;
        sn = bn%st->nspc + npf;
@@ -571,14 +588,14 @@ rkecc(ui, flag)
 
                npf--;
                reg--;
 
                npf--;
                reg--;
-               printf("rk%d%c: soft ecc sn%d\n", dkunit(bp),
+               log(LOG_WARNING, "rk%d%c: soft ecc sn%d\n", rkunit(bp->b_dev),
                    'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
                mask = rk->rkec2;
                i = rk->rkec1 - 1;              /* -1 makes 0 origin */
                bit = i&07;
                i = (i&~07)>>3;
                byte = i + o;
                    'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
                mask = rk->rkec2;
                i = rk->rkec1 - 1;              /* -1 makes 0 origin */
                bit = i&07;
                i = (i&~07)>>3;
                byte = i + o;
-               while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
+               while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) {
                        addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+
                            (byte & PGOFSET);
                        putmemc(addr, getmemc(addr)^(mask<<bit));
                        addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+
                            (byte & PGOFSET);
                        putmemc(addr, getmemc(addr)^(mask<<bit));
@@ -622,9 +639,9 @@ rkecc(ui, flag)
        printf("rkecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn);
 #endif
                bp->b_flags &= ~B_BAD;
        printf("rkecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn);
 #endif
                bp->b_flags &= ~B_BAD;
-               rk->rkwc = -((bp->b_bcount - (int)ptob(npf)) / sizeof (short));
-               if (rk->rkwc == 0)
+               if ((int)dbtob(npf) >= bp->b_bcount)
                        return (0);
                        return (0);
+               rk->rkwc = -((bp->b_bcount - (int)dbtob(npf)) / sizeof (short));
                break;
        }
        rk->rkcs1 = RK_CCLR;
                break;
        }
        rk->rkcs1 = RK_CCLR;
@@ -720,7 +737,7 @@ rkdump(dev)
        register short *rp;
        struct rkst *st;
 
        register short *rp;
        struct rkst *st;
 
-       unit = minor(dev) >> 3;
+       unit = rkunit(dev);
        if (unit >= NRK)
                return (ENXIO);
 #define        phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
        if (unit >= NRK)
                return (ENXIO);
 #define        phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
@@ -742,8 +759,10 @@ rkdump(dev)
        }
        st = &rkst[ui->ui_type];
        sizes = phys(struct size *, st->sizes);
        }
        st = &rkst[ui->ui_type];
        sizes = phys(struct size *, st->sizes);
-       if (dumplo < 0 || dumplo + num >= sizes[minor(dev)&07].nblocks)
+       if (dumplo < 0)
                return (EINVAL);
                return (EINVAL);
+       if (dumplo + num >= sizes[minor(dev)&07].nblocks)
+               num = sizes[minor(dev)&07].nblocks - dumplo;
        while (num > 0) {
                register struct pte *io;
                register int i;
        while (num > 0) {
                register struct pte *io;
                register int i;
@@ -778,7 +797,7 @@ rkdump(dev)
 rksize(dev)
        dev_t dev;
 {
 rksize(dev)
        dev_t dev;
 {
-       int unit = minor(dev) >> 3;
+       int unit = rkunit(dev);
        struct uba_device *ui;
        struct rkst *st;
 
        struct uba_device *ui;
        struct rkst *st;
 
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.