Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP Posting-Version: version B 2.10.1 6/24/83; site umcp-cs.UUCP Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!godot!harvard!seismo!umcp-cs!chris From: chris@umcp-cs.UUCP (Chris Torek) Newsgroups: net.sources Subject: kernel and dump mods (2 of 2) for mass driver and fast dumps Message-ID: <2263@umcp-cs.UUCP> Date: Sat, 5-Jan-85 04:13:45 EST Article-I.D.: umcp-cs.2263 Posted: Sat Jan 5 04:13:45 1985 Date-Received: Sun, 6-Jan-85 00:38:12 EST Distribution: net Organization: U of Maryland, Computer Science Dept., College Park, MD Lines: 2534 : Run this shell script with "sh" not "csh" PATH=:/bin:/usr/bin:/usr/ucb export PATH all=FALSE if [ $1x = -ax ]; then all=TRUE fi /bin/echo 'Extracting kernel_mods' sed 's/^X//' <<'//go.sysin dd *' >kernel_mods WARNING: You can't just apply these diffs. There are comments next to each to tell you why it's there. Some of them are parts of other fixes, some are local devices; anyway, you have to read the ``comments''. Be sure to read the README first! RCS file: RCS/conf.c,v retrieving revision 1.1 diff -b -c1 -r1.1 conf.c *** /tmp/,RCSt1003142 Fri Jan 4 23:00:18 1985 --- conf.c Thu Jan 3 11:57:30 1985 *************** I think this one is obvious. *** 14,16 int hpopen(),hpstrategy(),hpread(),hpwrite(),hpdump(),hpioctl(),hpsize(); ! #else #define hpopen nodev --- 14,16 ----- int hpopen(),hpstrategy(),hpread(),hpwrite(),hpdump(),hpioctl(),hpsize(); ! #else NHP > 0 #define hpopen nodev *************** Likewise... *** 22,24 #define hpsize 0 ! #endif --- 22,24 ----- #define hpsize 0 ! #endif NHP > 0 *************** Here's an addition for the mass driver on TU77s. *** 27,28 int htopen(),htclose(),htstrategy(),htread(),htwrite(),htdump(),htioctl(); #else --- 27,29 ----- int htopen(),htclose(),htstrategy(),htread(),htwrite(),htdump(),htioctl(); + int htmass(); #else *************** Again, but if you have no TU77s. *** 35,36 #define htioctl nodev #endif --- 36,38 ----- #define htioctl nodev + #define htmass 0 #endif *************** Not sure what this is; something used at BRL. *************** You probably don't want it. *** 37,38 #include "rk.h" --- 39,51 ----- + #include "rf.h" + #if NXF > 0 + int rfopen(),rfstrategy(),rfread(),rfwrite(),rfreset(); + #else + #define rfopen nodev + #define rfstrategy nodev + #define rfread nodev + #define rfwrite nodev + #define rfreset nodev + #endif + #include "rk.h" *************** More mass driver stuff, this for the TS11. *** 70,72 int tsopen(),tsclose(),tsstrategy(),tsread(),tswrite(); ! int tsioctl(),tsdump(),tsreset(); #else --- 83,85 ----- int tsopen(),tsclose(),tsstrategy(),tsread(),tswrite(); ! int tsioctl(),tsdump(),tsreset(),tsmass(); #else *************** Same, but if you have no TS11s. *** 80,81 #define tsreset nodev #endif --- 93,95 ----- #define tsreset nodev + #define tsmass 0 #endif *************** Still more mass driver additions, for the TU78. *** 85,87 int mtopen(),mtclose(),mtstrategy(),mtread(),mtwrite(); ! int mtioctl(),mtdump(); #else --- 99,101 ----- int mtopen(),mtclose(),mtstrategy(),mtread(),mtwrite(); ! int mtioctl(),mtdump(),mtmass(); #else *************** Mass driver stuff for when you have no TU78s. *** 94,95 #define mtdump nodev #endif --- 108,110 ----- #define mtdump nodev + #define mtmass 0 #endif *************** The BRL rf disk, which you probably don't want. *** 231,232 rlsize, 0 }, }; --- 246,249 ----- rlsize, 0 }, + { rfopen, nulldev, rfstrategy, nodev, /*15*/ + 0, 0 }, }; *************** The dh ``outgoing mode'' mods, which I posted before. *************** If you didn't get them then, you don't want this now. *** 263,264 #define dh11 0 #else --- 280,285 ----- #define dh11 0 + #define dhoopen nodev + #define dhoclose nodev + #define dhpopen nodev + #define dhpclose nodev #else *************** Continuation of above... *** 266,267 struct tty dh11[]; #endif --- 287,294 ----- struct tty dh11[]; + #include "dho.h" + #if NDHO > 0 + int dhoopen(),dhoclose(); + #else + #define dhoopen nodev + #define dhoclose nodev #endif *************** Passive mode DH (doesn't quite work anyway; you don't want it) *** 267,268 #endif --- 294,303 ----- #endif + #include "dhp.h" + #if NDHP > 0 + int dhpopen(),dhpclose(); + #else + #define dhpopen nodev + #define dhpclose nodev + #endif + #endif *************** 1. The ``file descriptor'' pseudo-device. If you didn't *************** get a copy earlier, ignore these too. *************** 2. The ``mass driver'' pseudo-device (from #include "driv.h" *************** on. Now this, you want.... *** 268,269 #include "dmf.h" --- 303,324 ----- + #include "fd.h" + #if NFD > 0 + int fdopen(); + #else + #define fdopen nodev + #endif NFD + + #include "driv.h" + #if NDRIV > 0 + int drivopen(), drivclose(), drivread(), drivwrite(), drivioctl(); + int drivselect(); + #else NDRIV > 0 + #define drivopen nodev + #define drivclose nodev + #define drivread nodev + #define drivwrite nodev + #define drivioctl nodev + #define drivselect nodev + #endif NDRIV > 0 + #include "dmf.h" *************** DZ outgoing mods. Ignore these if you haven't got them *************** already... *** 302,303 #define dz_tty 0 #else --- 357,360 ----- #define dz_tty 0 + #define dzoopen nodev + #define dzoclose nodev #else *************** etc... *** 305,306 struct tty dz_tty[]; #endif --- 362,369 ----- struct tty dz_tty[]; + #include "dzo.h" + #if NDZO > 0 + int dzoopen(),dzoclose(); + #else + #define dzoopen nodev + #define dzoclose nodev #endif *************** etc... *** 306,307 #endif --- 369,371 ----- #endif + #endif *************** Another BRL addition, the Ikonas frame buffer. Ignore... *** 411,412 #include "ps.h" --- 475,488 ----- + #include "ik.h" + #if NIK > 0 + int ikopen(),ikclose(),ikread(),ikwrite(),ikioctl(),ikreset(); + #else + #define ikopen nodev + #define ikclose nodev + #define ikread nodev + #define ikwrite nodev + #define ikioctl nodev + #define ikreset nodev + #endif + #include "ps.h" *************** Here come a bunch of BRL and U of MD local devices, *************** which you also don't want. *** 445,446 int ttselect(), seltrue(); --- 521,616 ----- + #include "mg.h" /* BRL */ + #if NMG > 0 + int mgopen(),mgclose(),mgreset(),mgread(),mgwrite(),mgioctl(),mgselect(); + #else + #define mgopen nodev + #define mgclose nodev + #define mgreset nodev + #define mgread nodev + #define mgwrite nodev + #define mgioctl nodev + #define mgselect nodev + #endif + + #include "vg.h" /* BRL */ + #if NVG > 0 + int vgopen(),vgclose(),vgreset(),vgread(),vgwrite(),vgioctl(),vgselect(); + #else + #define vgopen nodev + #define vgclose nodev + #define vgreset nodev + #define vgread nodev + #define vgwrite nodev + #define vgioctl nodev + #define vgselect nodev + #endif + + #include "ump.h" /* BRL */ + #if NUMP > 0 + int umpopen(),umpclose(),umpread(),umpwrite(),umpioctl(),umpselect(); + #else + #define umpopen nodev + #define umpclose nodev + #define umpread nodev + #define umpwrite nodev + #define umpioctl nodev + #define umpselect nodev + #endif + + #include "hsw.h" /* BRL */ + #if NHSW > 0 + int hswopen(),hswclose(),hswread(),hswwrite(),hswselect(); + #else + #define hswopen nodev + #define hswclose nodev + #define hswread nodev + #define hswwrite nodev + #define hswselect nodev + #endif + + #include "lsb.h" /* BRL */ + #if NLSB > 0 + int lsbopen(),lsbclose(),lsbread(),lsbwrite(),lsbreset(); + #else + #define lsbopen nodev + #define lsbclose nodev + #define lsbread nodev + #define lsbwrite nodev + #define lsbreset nodev + #endif + + #include "mcd.h" /* BRL */ + #if NMCD > 0 + int mcdopen(),mcdclose(),mcdread(),mcdwrite(),mcdreset(); + #else + #define mcdopen nodev + #define mcdclose nodev + #define mcdread nodev + #define mcdwrite nodev + #define mcdreset nulldev + #endif + + #include "mss.h" /* BRL */ + #if NMSS > 0 + int mssopen(),mssclose(),mssselect(),mssreset(), mssioctl(); + #else + #define mssopen nodev + #define mssclose nodev + #define mssselect nodev + #define mssreset nodev + #define mssioctl nodev + #endif + + /* zmob pseudo-device multiplexor FLB */ + #include "zm.h" + #if NZM > 0 + int zmopen(), zmclose(), zmread(), zmwrite(), zmioctl(); + #else + #define zmopen nodev + #define zmclose nodev + #define zmread nodev + #define zmwrite nodev + #define zmioctl nodev + #endif + int ttselect(), seltrue(); *************** Here come changes to the cdevsw[] table, as described *************** in the installation instructions. You need to make *************** the addition of ``0, 0,'' to each existing device in *************** your own table (except of course for those devices with *************** mass driver entries). *** 451,453 cnioctl, nulldev, nulldev, &cons, ! ttselect, nodev, dzopen, dzclose, dzread, dzwrite, /*1*/ --- 621,624 ----- cnioctl, nulldev, nulldev, &cons, ! ttselect, nodev, 0, 0, ! dzopen, dzclose, dzread, dzwrite, /*1*/ *************** *** 454,456 dzioctl, dzstop, dzreset, dz_tty, ! ttselect, nodev, syopen, nulldev, syread, sywrite, /*2*/ --- 625,628 ----- dzioctl, dzstop, dzreset, dz_tty, ! ttselect, nodev, 0, 0, ! syopen, nulldev, syread, sywrite, /*2*/ *************** *** 457,459 syioctl, nulldev, nulldev, 0, ! syselect, nodev, nulldev, nulldev, mmread, mmwrite, /*3*/ --- 629,632 ----- syioctl, nulldev, nulldev, 0, ! syselect, nodev, 0, 0, ! nulldev, nulldev, mmread, mmwrite, /*3*/ *************** *** 460,462 nodev, nulldev, nulldev, 0, ! mmselect, nodev, hpopen, nulldev, hpread, hpwrite, /*4*/ --- 633,636 ----- nodev, nulldev, nulldev, 0, ! mmselect, nodev, 0, 0, ! hpopen, nulldev, hpread, hpwrite, /*4*/ *************** *** 463,465 hpioctl, nodev, nulldev, 0, ! seltrue, nodev, htopen, htclose, htread, htwrite, /*5*/ --- 637,640 ----- hpioctl, nodev, nulldev, 0, ! seltrue, nodev, 0, 0, ! htopen, htclose, htread, htwrite, /*5*/ *************** *** 466,468 htioctl, nodev, nulldev, 0, ! seltrue, nodev, vpopen, vpclose, nodev, vpwrite, /*6*/ --- 641,644 ----- htioctl, nodev, nulldev, 0, ! seltrue, nodev, htmass, htstrategy, ! vpopen, vpclose, nodev, vpwrite, /*6*/ *************** *** 469,471 vpioctl, nulldev, vpreset, 0, ! vpselect, nodev, nulldev, nulldev, swread, swwrite, /*7*/ --- 645,648 ----- vpioctl, nulldev, vpreset, 0, ! vpselect, nodev, 0, 0, ! nulldev, nulldev, swread, swwrite, /*7*/ *************** *** 472,474 nodev, nodev, nulldev, 0, ! nodev, nodev, flopen, flclose, flread, flwrite, /*8*/ --- 649,652 ----- nodev, nodev, nulldev, 0, ! nodev, nodev, 0, 0, ! flopen, flclose, flread, flwrite, /*8*/ *************** *** 475,477 nodev, nodev, nulldev, 0, ! seltrue, nodev, udopen, nulldev, udread, udwrite, /*9*/ --- 653,656 ----- nodev, nodev, nulldev, 0, ! seltrue, nodev, 0, 0, ! udopen, nulldev, udread, udwrite, /*9*/ *************** *** 478,480 nodev, nodev, udreset, 0, ! seltrue, nodev, vaopen, vaclose, nodev, vawrite, /*10*/ --- 657,660 ----- nodev, nodev, udreset, 0, ! seltrue, nodev, 0, 0, ! vaopen, vaclose, nodev, vawrite, /*10*/ *************** *** 481,483 vaioctl, nulldev, vareset, 0, ! vaselect, nodev, rkopen, nulldev, rkread, rkwrite, /*11*/ --- 661,664 ----- vaioctl, nulldev, vareset, 0, ! vaselect, nodev, 0, 0, ! rkopen, nulldev, rkread, rkwrite, /*11*/ *************** *** 484,486 nodev, nodev, rkreset, 0, ! seltrue, nodev, dhopen, dhclose, dhread, dhwrite, /*12*/ --- 665,668 ----- nodev, nodev, rkreset, 0, ! seltrue, nodev, 0, 0, ! dhopen, dhclose, dhread, dhwrite, /*12*/ *************** *** 487,489 dhioctl, dhstop, dhreset, dh11, ! ttselect, nodev, upopen, nulldev, upread, upwrite, /*13*/ --- 669,672 ----- dhioctl, dhstop, dhreset, dh11, ! ttselect, nodev, 0, 0, ! upopen, nulldev, upread, upwrite, /*13*/ *************** *** 490,492 nodev, nodev, upreset, 0, ! seltrue, nodev, tmopen, tmclose, tmread, tmwrite, /*14*/ --- 673,676 ----- nodev, nodev, upreset, 0, ! seltrue, nodev, 0, 0, ! tmopen, tmclose, tmread, tmwrite, /*14*/ *************** *** 493,495 tmioctl, nodev, tmreset, 0, ! seltrue, nodev, lpopen, lpclose, nodev, lpwrite, /*15*/ --- 677,680 ----- tmioctl, nodev, tmreset, 0, ! seltrue, nodev, 0, 0, ! lpopen, lpclose, nodev, lpwrite, /*15*/ *************** *** 496,498 nodev, nodev, lpreset, 0, ! seltrue, nodev, tsopen, tsclose, tsread, tswrite, /*16*/ --- 681,684 ----- nodev, nodev, lpreset, 0, ! seltrue, nodev, 0, 0, ! tsopen, tsclose, tsread, tswrite, /*16*/ *************** *** 499,501 tsioctl, nodev, tsreset, 0, ! seltrue, nodev, utopen, utclose, utread, utwrite, /*17*/ --- 685,688 ----- tsioctl, nodev, tsreset, 0, ! seltrue, nodev, tsmass, tsstrategy, ! utopen, utclose, utread, utwrite, /*17*/ *************** *** 502,504 utioctl, nodev, utreset, 0, ! seltrue, nodev, ctopen, ctclose, nodev, ctwrite, /*18*/ --- 689,692 ----- utioctl, nodev, utreset, 0, ! seltrue, nodev, 0, 0, ! ctopen, ctclose, nodev, ctwrite, /*18*/ *************** *** 505,507 nodev, nodev, nulldev, 0, ! seltrue, nodev, mtopen, mtclose, mtread, mtwrite, /*19*/ --- 693,696 ----- nodev, nodev, nulldev, 0, ! seltrue, nodev, 0, 0, ! mtopen, mtclose, mtread, mtwrite, /*19*/ *************** *** 508,510 mtioctl, nodev, nodev, 0, ! seltrue, nodev, ptsopen, ptsclose, ptsread, ptswrite, /*20*/ --- 697,700 ----- mtioctl, nodev, nodev, 0, ! seltrue, nodev, mtmass, mtstrategy, ! ptsopen, ptsclose, ptsread, ptswrite, /*20*/ *************** *** 511,513 ptyioctl, ptsstop, nodev, pt_tty, ! ttselect, nodev, ptcopen, ptcclose, ptcread, ptcwrite, /*21*/ --- 701,704 ----- ptyioctl, ptsstop, nodev, pt_tty, ! ttselect, nodev, 0, 0, ! ptcopen, ptcclose, ptcread, ptcwrite, /*21*/ *************** *** 514,516 ptyioctl, nulldev, nodev, pt_tty, ! ptcselect, nodev, dmfopen, dmfclose, dmfread, dmfwrite, /*22*/ --- 705,708 ----- ptyioctl, nulldev, nodev, pt_tty, ! ptcselect, nodev, 0, 0, ! dmfopen, dmfclose, dmfread, dmfwrite, /*22*/ *************** *** 517,519 dmfioctl, dmfstop, dmfreset, dmf_tty, ! ttselect, nodev, idcopen, nulldev, idcread, idcwrite, /*23*/ --- 709,712 ----- dmfioctl, dmfstop, dmfreset, dmf_tty, ! ttselect, nodev, 0, 0, ! idcopen, nulldev, idcread, idcwrite, /*23*/ *************** *** 520,522 nodev, nodev, idcreset, 0, ! seltrue, nodev, dnopen, dnclose, nodev, dnwrite, /*24*/ --- 713,716 ----- nodev, nodev, idcreset, 0, ! seltrue, nodev, 0, 0, ! dnopen, dnclose, nodev, dnwrite, /*24*/ *************** *** 523,526 nodev, nodev, nodev, 0, ! seltrue, nodev, ! /* 25-29 reserved to local sites */ gpibopen, gpibclose, gpibread, gpibwrite, /*25*/ --- 717,720 ----- nodev, nodev, nodev, 0, ! seltrue, nodev, 0, 0, ! gpibopen, gpibclose, gpibread, gpibwrite, /*25*/ *************** *** 527,529 gpibioctl, nulldev, nodev, 0, ! seltrue, nodev, lpaopen, lpaclose, lparead, lpawrite, /*26*/ --- 721,724 ----- gpibioctl, nulldev, nodev, 0, ! seltrue, nodev, 0, 0, ! lpaopen, lpaclose, lparead, lpawrite, /*26*/ *************** *** 530,532 lpaioctl, nodev, nulldev, 0, ! seltrue, nodev, psopen, psclose, psread, pswrite, /*27*/ --- 725,728 ----- lpaioctl, nodev, nulldev, 0, ! seltrue, nodev, 0, 0, ! psopen, psclose, psread, pswrite, /*27*/ *************** *** 533,535 psioctl, nodev, psreset, 0, ! seltrue, nodev, ibopen, ibclose, ibread, ibwrite, /*28*/ --- 729,732 ----- psioctl, nodev, psreset, 0, ! seltrue, nodev, 0, 0, ! ibopen, ibclose, ibread, ibwrite, /*28*/ *************** *** 536,538 ibioctl, nodev, nodev, 0, ! seltrue, nodev, adopen, adclose, nodev, nodev, /*29*/ --- 733,736 ----- ibioctl, nodev, nodev, 0, ! seltrue, nodev, 0, 0, ! adopen, adclose, nodev, nodev, /*29*/ *************** *** 539,541 adioctl, nodev, adreset, 0, ! seltrue, nodev, rxopen, rxclose, rxread, rxwrite, /*30*/ --- 737,740 ----- adioctl, nodev, adreset, 0, ! seltrue, nodev, 0, 0, ! rxopen, rxclose, rxread, rxwrite, /*30*/ *************** *** 542,544 rxioctl, nodev, rxreset, 0, ! seltrue, nodev, ikopen, ikclose, ikread, ikwrite, /*31*/ --- 741,744 ----- rxioctl, nodev, rxreset, 0, ! seltrue, nodev, 0, 0, ! ikopen, ikclose, ikread, ikwrite, /*31*/ *************** *** 545,548 ikioctl, nodev, ikreset, 0, ! seltrue, nodev, ! rlopen, nodev, rlread, rlwrite, /* 32 */ nodev, nodev, rlreset, 0, --- 745,749 ----- ikioctl, nodev, ikreset, 0, ! seltrue, nodev, 0, 0, ! ! rlopen, nodev, rlread, rlwrite, /*32*/ nodev, nodev, rlreset, 0, *************** Here come lots of additions. The mass driver entry *************** is at the end of these. *** 548,550 nodev, nodev, rlreset, 0, ! seltrue, nodev, }; --- 749,813 ----- nodev, nodev, rlreset, 0, ! seltrue, nodev, 0, 0, ! ! /* BRL additions */ ! ! rfopen, nulldev, rfread, rfwrite, /*33*/ ! nodev, nodev, rfreset, 0, ! seltrue, nodev, 0, 0, ! ! vgopen, vgclose, vgread, vgwrite, /*34*/ ! vgioctl, nodev, vgreset, 0, ! vgselect, nodev, 0, 0, ! ! umpopen, umpclose, umpread, umpwrite, /*35*/ ! umpioctl, nodev, nulldev, 0, ! umpselect, nodev, 0, 0, ! ! hswopen, hswclose, hswread, hswwrite, /*36*/ ! nodev, nodev, nulldev, 0, ! hswselect, nodev, 0, 0, ! ! lsbopen, lsbclose, lsbread, lsbwrite, /*37*/ ! nodev, nodev, lsbreset, 0, ! seltrue, nodev, 0, 0, ! ! mcdopen, mcdclose, mcdread, mcdwrite, /*38*/ ! nodev, nodev, mcdreset, 0, ! seltrue, nodev, 0, 0, ! ! mssopen, mssclose, nodev, nodev, /*39*/ ! mssioctl, nodev, mssreset, 0, ! mssselect, nodev, 0, 0, ! ! mgopen, mgclose, mgread, mgwrite, /*40*/ ! mgioctl, nodev, mgreset, 0, ! mgselect, nodev, 0, 0, ! ! /* U of MD additions */ ! ! dzoopen, dzoclose, dzread, dzwrite, /*41*/ ! dzioctl, dzstop, nulldev, dz_tty, ! ttselect, nodev, 0, 0, ! ! dhoopen, dhoclose, dhread, dhwrite, /*42*/ ! dhioctl, dhstop, nulldev, dh11, ! ttselect, nodev, 0, 0, ! ! dhpopen, dhpclose, dhread, dhwrite, /*43*/ ! dhioctl, dhstop, nulldev, dh11, ! ttselect, nodev, 0, 0, ! ! fdopen, nodev, nodev, nodev, /*44*/ ! nodev, nodev, nodev, 0, ! nodev, nodev, 0, 0, ! ! /* moblet multiplexor device: FLB */ ! zmopen, zmclose, zmread, zmwrite, /*45*/ ! zmioctl, nodev, nulldev, 0, ! seltrue, nodev, 0, 0, ! ! /* mass driver */ ! drivopen, drivclose, drivread, drivwrite, /*46*/ ! drivioctl, nodev, nulldev, 0, ! drivselect, nodev, 0, 0, }; *************** Just a minor format gripe. *** 550,551 }; int nchrdev = sizeof (cdevsw) / sizeof (cdevsw[0]); --- 813,815 ----- }; + int nchrdev = sizeof (cdevsw) / sizeof (cdevsw[0]); RCS file: RCS/conf.h,v retrieving revision 1.1 diff -b -c1 -r1.1 conf.h *** /tmp/,RCSt1003100 Fri Jan 4 22:59:28 1985 --- conf.h Thu Jan 3 11:58:43 1985 *************** Here we have the new entries in character (raw) devices *************** to allow them to be used by the mass driver. *** 39,40 int (*d_mmap)(); }; --- 39,42 ----- int (*d_mmap)(); + int (*d_mass)(); + int (*d_bstrat)(); }; RCS file: RCS/fs.h,v retrieving revision 1.1 diff -b -c1 -r1.1 fs.h *** /tmp/,RCSt1003110 Fri Jan 4 22:59:37 1985 --- fs.h Wed Jan 2 09:50:21 1985 *************** Minor glitch in comments fixed. *** 89,92 * within the bounds dictated by MINBSIZE. ! * Note that super blocks are always of size MAXBSIZE, ! * and that MAXBSIZE must be >= MINBSIZE. */ --- 89,92 ----- * within the bounds dictated by MINBSIZE. ! * Note that super blocks are always of size SBSIZE, ! * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE. */ RCS file: RCS/ht.c,v retrieving revision 1.1 diff -b -c1 -r1.1 ht.c *** /tmp/,RCSt1003196 Fri Jan 4 23:01:37 1985 --- ht.c Wed Jan 2 12:19:05 1985 *************** Don't need conf.h in ht.c. *** 18,20 #include "../h/buf.h" - #include "../h/conf.h" #include "../h/dir.h" --- 18,19 ----- #include "../h/buf.h" #include "../h/dir.h" *************** The BRL "commented sleep" which you don't have and thus *************** can't use... *** 173,175 bp->b_flags |= B_WANTED; ! sleep((caddr_t)bp, PRIBIO); } --- 172,174 ----- bp->b_flags |= B_WANTED; ! csleep((caddr_t)bp, PRIBIO, "TAPE"); } *************** Here comes the real mass driver change (actually, addition): *** 454,455 return (0); } --- 453,469 ----- return (0); + } + + /* + * Start a ``raw block transfer'' from kernel space (via the + * mass driver). + */ + htmass(bp) + register struct buf *bp; + { + register struct tu_softc *sc; + + minphys(bp); + sc = &tu_softc[TUUNIT(bp->b_dev)]; + sc->sc_blkno = bdbtofsb(bp->b_blkno); + sc->sc_nxrec = sc->sc_blkno + 1; } RCS file: RCS/machdep.c,v retrieving revision 1.1 diff -b -c1 -r1.1 machdep.c *** /tmp/,RCSt1003151 Fri Jan 4 23:00:37 1985 --- machdep.c Wed Jan 2 10:38:44 1985 *************** Don't ask me! *** 1,2 ! /* machdep.c 6.2 83/10/02 */ --- 1,2 ----- ! /* machdep.c 6.4 (modified) 84/02/02 */ *************** Rearranging a few parameters. You want these changes.... *** 66,68 register struct pte *pte; - int mapaddr, j; register caddr_t v; --- 66,67 ----- register struct pte *pte; register caddr_t v; *************** *** 68,70 register caddr_t v; ! int maxbufs, base, residual; extern char etext; --- 67,70 ----- register caddr_t v; ! register int mapaddr, j; ! int t, base, residual, spaceleft; extern char etext; *************** This next little bit is for a title which we put in the *************** version file. Since you don't do this, you don't want *************** this particular change. (I'll tell you when to start *************** looking again.) *** 70,71 extern char etext; --- 70,72 ----- extern char etext; + extern char vers_title[]; *************** *** 83,84 */ printf(version); --- 84,92 ----- */ + if (vers_title[0]) { + i = strlen(version) - 1; /* sigh */ + version[i] = 0; + printf("%s (%s)\n", version, vers_title); + version[i] = '\n'; + } + else printf(version); *************** Start looking again. Here we change buffer allocation *************** policies... *** 90,91 * We allocate 1/2 as many swap buffer headers as file i/o buffers. */ --- 98,101 ----- * We allocate 1/2 as many swap buffer headers as file i/o buffers. + * MAXBSIZE is probably way bigger than most of the buffers + * we'll need, so we assume buffers of "average" size AVGBSIZE. */ *************** *** 91,94 */ - maxbufs = ((SYSPTSIZE * NBPG) - (5 * (int)(&etext - 0x80000000))) / - MAXBSIZE; if (bufpages == 0) --- 101,102 ----- */ if (bufpages == 0) *************** *** 96,98 if (nbuf == 0) { ! nbuf = bufpages / 2; if (nbuf < 16) --- 104,118 ----- if (nbuf == 0) { ! nbuf = bufpages * CLBYTES / AVGBSIZE; ! /* ! * We need enough space to map everything, so we assume ! * about 700K has to be left after mapping the buffers. ! * (It takes only 6K of pte's to map this, so if we need ! * less, we haven't wasted much memory.) ! */ ! t = ((SYSPTSIZE * NBPG) - 786432) / MAXBSIZE; ! if (nbuf > t) { ! printf("sys pt too small; want %d buffers", nbuf); ! nbuf = t; ! printf(" but space for only %d\n", nbuf); ! } if (nbuf < 16) *************** *** 99,102 nbuf = 16; - if (nbuf > maxbufs) - nbuf = maxbufs; } --- 119,120 ----- nbuf = 16; } *************** *** 102,105 } ! if (bufpages > nbuf * (MAXBSIZE / CLBYTES)) ! bufpages = nbuf * (MAXBSIZE / CLBYTES); if (nswbuf == 0) { --- 120,123 ----- } ! if (bufpages > (nbuf * AVGBSIZE) / CLBYTES) ! bufpages = (nbuf * AVGBSIZE) / CLBYTES; if (nswbuf == 0) { *************** *** 125,126 (name) = (type *)(v); (v) = (caddr_t)((lim) = ((name)+(num))) valloc(buffers, char, MAXBSIZE * nbuf); --- 143,152 ----- (name) = (type *)(v); (v) = (caddr_t)((lim) = ((name)+(num))) + /* + * Map the buffers first, because they are only partially mapped + * (that is to say, they get less physical memory than virtual). + * Each buffer maps a full MAXBSIZE bytes but (at least initially) + * contains only 1/nbuf'th of the total buffer pool, with the + * "extra" pages (if any) given to the first bufpages%nbuf buffers. + * binit() (in ../sys/init_main.c) uses this same convention. + */ valloc(buffers, char, MAXBSIZE * nbuf); *************** *** 128,131 residual = bufpages % nbuf; ! for (i = 0; i < residual; i++) { ! for (j = 0; j < (base + 1) * CLSIZE; j++) { *(int *)(&Sysmap[mapaddr+j]) = PG_V | PG_KW | firstaddr; --- 154,162 ----- residual = bufpages % nbuf; ! for (i = 0; i < nbuf; i++) { ! if (i < residual) ! t = base + 1; ! else ! t = base; ! t *= CLSIZE; ! for (j = 0; j < t; j++) { *(int *)(&Sysmap[mapaddr+j]) = PG_V | PG_KW | firstaddr; *************** *** 136,145 } ! for (i = residual; i < nbuf; i++) { ! for (j = 0; j < base * CLSIZE; j++) { ! *(int *)(&Sysmap[mapaddr+j]) = PG_V | PG_KW | firstaddr; ! clearseg((unsigned)firstaddr); ! firstaddr++; ! } ! mapaddr += MAXBSIZE / NBPG; ! } valloc(buf, struct buf, nbuf); --- 167,171 ----- } ! /* ! * Everything from here on is fully mapped. ! */ valloc(buf, struct buf, nbuf); *************** *** 161,163 /* ! * Now allocate space for core map * Allow space for all of phsical memory minus the amount --- 187,189 ----- /* ! * Now allocate space for core map. * Allow space for all of phsical memory minus the amount *************** *** 163,168 * Allow space for all of phsical memory minus the amount ! * dedicated to the system. The amount of physical memory ! * dedicated to the system is the total virtual memory of ! * the system minus the space in the buffers which is not ! * allocated real memory. */ --- 189,207 ----- * Allow space for all of phsical memory minus the amount ! * dedicated to the system ("kernel memory"). The amount ! * of kernel memory is equal to v-0x80000000 minus the ! * holes in the buffers. In other words: ! * ! * kernel mem = mem used - mem not REALLY used ! * = (v&~0x80000000) - (nbuf*MAXBSIZE-bufpages*CLBYTES) ! * space left = total space - kernel space ! * = physmem*NBPG - kernel space ! * ! * (Of course, when we allocate the core map, we use up some of ! * that left-over space, thus the formula for ncmap below.) ! * There is, however, no guarantee that we have enough pte's ! * to map everything. Here we calculate the ideal size for the ! * core map, find out how much space is left in the system page ! * table, and allocate the minimum of the two numbers. (It ! * currently takes about 100K to map 6M [with CLSIZE == 2 and ! * sizeof (struct cmap) == 16]). */ *************** *** 168,174 */ ! ncmap = (physmem*NBPG - ((int)v &~ 0x80000000) + ! (nbuf * (MAXBSIZE - 2 * CLBYTES))) / ! (NBPG*CLSIZE + sizeof (struct cmap)); ! valloclim(cmap, struct cmap, ncmap, ecmap); ! if ((((int)(ecmap+1))&~0x80000000) > SYSPTSIZE*NBPG) panic("sys pt too small"); --- 207,218 ----- */ ! spaceleft = physmem*NBPG - ((int)v & ~0x80000000) + ! nbuf*MAXBSIZE - bufpages*CLBYTES; ! if (spaceleft < 0) { ! printf("Kernel wants %d more bytes than exist!\n", ! -spaceleft); ! panic("kernel size"); ! } ! ncmap = spaceleft / (CLBYTES + sizeof (struct cmap)); ! spaceleft = SYSPTSIZE*NBPG - (((int)(v + 1)) & ~0x80000000); ! if (spaceleft < 0) panic("sys pt too small"); *************** *** 174,176 panic("sys pt too small"); ! /* --- 218,228 ----- panic("sys pt too small"); ! if (ncmap * sizeof (struct cmap) > spaceleft) { ! printf("sys pt too small; trimmed core map\n"); ! ncmap = spaceleft / sizeof (struct cmap); ! } ! valloclim(cmap, struct cmap, ncmap, ecmap); ! /* anti-bug test: */ ! spaceleft = SYSPTSIZE*NBPG - (((int)(ecmap+1))&~0x80000000); ! if (spaceleft < 0) ! panic("startup"); /* *************** (The part about #if GYRE is for our kernel hack machine.) *** 176,177 /* * Clear allocated space, and make r/w entries --- 228,242 ----- /* + * If there's "lots" of wasted space, gripe. + * (Lots == at least 5% of physical memory in wasted page tables. + * Spaceleft is currently the amount of memory we can still map.) + */ + spaceleft /= NBPG * NPTEPG; /* convert to true pages */ + #if GYRE + if (spaceleft >= NBPG) + printf("%d extra pages in sys pt\n", spaceleft / NBPG); + #else + if (spaceleft >= physmem / 20) + printf("%d extra pages in sys pt\n", spaceleft / NBPG); + #endif + /* * Clear allocated space, and make r/w entries *************** This is part of one of RWS@MIT-BOLD's fixes. I don't know *************** if it would hurt to put it in if you haven't already... it's *************** up to you. *** 286,288 */ ! if (!oonstack && (int)fp <= USRSTACK - ctob(u.u_ssize)) grow((unsigned)fp); --- 351,353 ----- */ ! if ((int)fp <= USRSTACK - ctob(u.u_ssize)) grow((unsigned)fp); *************** I thought this deserved a comment. *** 288,290 grow((unsigned)fp); ! ; #ifndef lint --- 353,355 ----- grow((unsigned)fp); ! ; /* Avoid asm() label botch */ #ifndef lint *************** More of those fixes from RWS@MIT-BOLD. *** 296,298 #endif ! if (!u.u_onstack && (int)scp <= USRSTACK - ctob(u.u_ssize)) grow((unsigned)scp); --- 361,363 ----- #endif ! if ((int)scp <= USRSTACK - ctob(u.u_ssize)) grow((unsigned)scp); *************** (Need I say anything?) *** 360,361 return; #ifndef lint --- 425,427 ----- return; + ; /* Avoid asm() label botch */ #ifndef lint *************** Part of the changes to handle 64K chip controllers. This *************** is not everything you need, so don't install it. *** 426,428 mcr = mcraddr[m]; ! switch (cpu) { #if VAX780 --- 492,494 ----- mcr = mcraddr[m]; ! switch (mcrtype[m]) { #if VAX780 *************** *** 428,431 #if VAX780 ! case VAX_780: ! M780_ENA(mcr); break; --- 494,497 ----- #if VAX780 ! case M780C: ! M780C_ENA(mcr); break; *************** *** 431,432 break; #endif --- 497,504 ----- break; + case M780EL: + M780EL_ENA(mcr); + break; + case M780EU: + M780EU_ENA(mcr); + break; #endif *************** *** 433,435 #if VAX750 ! case VAX_750: M750_ENA(mcr); --- 505,507 ----- #if VAX750 ! case M750: M750_ENA(mcr); *************** *** 438,440 #if VAX730 ! case VAX_730: M730_ENA(mcr); --- 510,512 ----- #if VAX730 ! case M730: M730_ENA(mcr); *************** *** 461,463 mcr = mcraddr[m]; ! switch (cpu) { #if VAX780 --- 533,535 ----- mcr = mcraddr[m]; ! switch (mcrtype[m]) { #if VAX780 *************** *** 463,466 #if VAX780 ! case VAX_780: ! if (M780_ERR(mcr)) { printf("mcr%d: soft ecc addr %x syn %x\n", --- 535,538 ----- #if VAX780 ! case M780C: ! if (M780C_ERR(mcr)) { printf("mcr%d: soft ecc addr %x syn %x\n", *************** *** 466,468 printf("mcr%d: soft ecc addr %x syn %x\n", ! m, M780_ADDR(mcr), M780_SYN(mcr)); #ifdef TRENDATA --- 538,540 ----- printf("mcr%d: soft ecc addr %x syn %x\n", ! m, M780C_ADDR(mcr), M780C_SYN(mcr)); #ifdef TRENDATA *************** *** 470,472 #endif ! M780_INH(mcr); } --- 542,544 ----- #endif ! M780C_INH(mcr); } *************** *** 473,474 break; #endif --- 545,562 ----- break; + + case M780EL: + if (M780EL_ERR(mcr)) { + printf("mcr%d: soft ecc addr %x syn %x\n", + m, M780EL_ADDR(mcr), M780EL_SYN(mcr)); + M780EL_INH(mcr); + } + break; + + case M780EU: + if (M780EU_ERR(mcr)) { + printf("mcr%d: soft ecc addr %x syn %x\n", + m, M780EU_ADDR(mcr), M780EU_SYN(mcr)); + M780EU_INH(mcr); + } + break; #endif *************** *** 475,477 #if VAX750 ! case VAX_750: if (M750_ERR(mcr)) { --- 563,565 ----- #if VAX750 ! case M750: if (M750_ERR(mcr)) { *************** *** 486,488 #if VAX730 ! case VAX_730: { register int mcreg = mcr->mc_reg[1]; --- 574,576 ----- #if VAX730 ! case M730: { register int mcreg = mcr->mc_reg[1]; *************** *** 539,541 ! switch (cpu) { --- 627,629 ----- ! switch (mcrtype[m]) { *************** *** 542,544 #if VAX780 ! case VAX_780: for (i = 0; i < (sizeof (memlogtab) / sizeof (memlogtab[0])); i++) --- 630,632 ----- #if VAX780 ! case M780C: for (i = 0; i < (sizeof (memlogtab) / sizeof (memlogtab[0])); i++) *************** *** 544,546 for (i = 0; i < (sizeof (memlogtab) / sizeof (memlogtab[0])); i++) ! if ((u_char)(M780_SYN(mcr)) == memlogtab[i].m_syndrome) { printf ( --- 632,634 ----- for (i = 0; i < (sizeof (memlogtab) / sizeof (memlogtab[0])); i++) ! if ((u_char)(M780C_SYN(mcr)) == memlogtab[i].m_syndrome) { printf ( *************** *** 549,552 memlogtab[i].m_chip, ! (M780_ADDR(mcr) & 0x8000) ? "upper" : "lower", ! (M780_ADDR(mcr) >> 16)); return; --- 637,640 ----- memlogtab[i].m_chip, ! (M780C_ADDR(mcr) & 0x8000) ? "upper" : "lower", ! (M780C_ADDR(mcr) >> 16)); return; *************** Here come some irrelevant but perhaps useful changes *************** in the panic/reboot code. *** 583,584 boot(paniced, arghowto) --- 671,675 ----- + /* + * Reboot. + */ boot(paniced, arghowto) *************** *** 588,589 register int devtype; /* r10 == major of root dev */ --- 679,682 ----- register int devtype; /* r10 == major of root dev */ + register struct buf *bp; + register iter, nbusy; *************** *** 593,595 #endif ! (void) spl1(); howto = arghowto; --- 686,692 ----- #endif ! /* ! * Figure out whether we can and should complete sandbagged I/O; ! * if so, wait for no busy buffers or a maximum time of ~1 sec. ! */ ! mtpr(IPL, 0x1f); /* block EVERYTHING */ howto = arghowto; *************** *** 597,598 waittime = 0; update(); --- 694,696 ----- waittime = 0; + (void) spl1(); update(); *************** *** 599,607 printf("syncing disks... "); ! #ifdef notdef ! DELAY(10000000); ! #else ! { register struct buf *bp; ! int iter, nbusy; ! ! for (iter = 0; iter < 20; iter++) { nbusy = 0; --- 697,699 ----- printf("syncing disks... "); ! for (iter = 0; iter < 32; iter++) { nbusy = 0; *************** *** 613,614 printf("%d ", nbusy); } --- 705,707 ----- printf("%d ", nbusy); + DELAY(20000); } *************** *** 614,617 } ! } ! #endif printf("done\n"); --- 707,710 ----- } ! if (nbusy != 0) ! printf("%d bufs un", nbusy); printf("done\n"); *************** *** 617,618 printf("done\n"); } --- 710,712 ----- printf("done\n"); + mtpr(IPL, 0x1f); } *************** *** 618,620 } - splx(0x1f); /* extreme priority */ devtype = major(rootdev); --- 712,713 ----- } devtype = major(rootdev); *************** *** 625,627 ; ! } else { if (paniced == RB_PANIC) { --- 718,721 ----- ; ! } ! else { if (paniced == RB_PANIC) { *************** *** 627,629 if (paniced == RB_PANIC) { ! doadump(); /* TXDB_BOOT's itsself */ /*NOTREACHED*/ --- 721,723 ----- if (paniced == RB_PANIC) { ! doadump(); /* TXDB_BOOT's itself */ /*NOTREACHED*/ *************** *** 633,636 #if defined(VAX750) || defined(VAX730) ! if (cpu != VAX_780) ! { asm("movl r11,r5"); } /* boot flags go in r5 */ #endif --- 727,733 ----- #if defined(VAX750) || defined(VAX730) ! /* ! * 750s and 730s want their boot flags in r5 (rather than r11). ! * Doesn't hurt 780s, so just do it all the time. ! */ ! asm("movl r11,r5"); #endif *************** *** 636,638 #endif ! for (;;) asm("halt"); --- 733,735 ----- #endif ! for (;;) { asm("halt"); *************** *** 638,639 asm("halt"); /*NOTREACHED*/ --- 735,737 ----- asm("halt"); + } /*NOTREACHED*/ *************** (Part of?) wls@astrovax's fix for tbuf parity errors. *************** If you haven't installed this, do so, maybe it will *************** help a bit. *** 809,811 mtpr(MCESR, 0xf); ! if ((mcf->mc5_mcesr&0xf) == MC750_TBPAR) { printf("tbuf par: flushing and returning\n"); --- 907,909 ----- mtpr(MCESR, 0xf); ! if ((mcf->mc5_mcesr&0xe) == MC750_TBPAR) { printf("tbuf par: flushing and returning\n"); *************** More BRL csleep changes that you should ignore *** 860,862 while ((bp->b_flags & B_DONE) == 0) ! sleep((caddr_t)bp, prio); splx(s); --- 958,960 ----- while ((bp->b_flags & B_DONE) == 0) ! csleep((caddr_t)bp, prio, "PHYSIO"); splx(s); *************** *** 863 } --- 961,962 ----- } + RCS file: RCS/mba.c,v retrieving revision 1.1 diff -b -c1 -r1.1 mba.c *** /tmp/,RCSt1003207 Fri Jan 4 23:01:50 1985 --- mba.c Fri Jan 4 19:34:40 1985 *************** Another useless "conf.h"! *** 13,15 #include "../h/buf.h" - #include "../h/conf.h" #include "../h/dir.h" --- 13,14 ----- #include "../h/buf.h" #include "../h/dir.h" *************** Track the b_active flag better. (Part of the mass driver *************** changes.) Just about everything else in this file is more *************** of the same. *** 46,48 bp = mi->mi_tab.b_actf; ! if (bp == NULL) return; --- 45,48 ----- bp = mi->mi_tab.b_actf; ! if (bp == NULL) { ! mi->mi_tab.b_active = 0; return; *************** *** 48,49 return; /* --- 48,51 ----- return; + } + mi->mi_tab.b_active = 1; /* *************** *** 56,58 mi->mi_tab.b_actf = bp->av_forw; - mi->mi_tab.b_active = 0; mi->mi_tab.b_errcnt = 0; --- 58,59 ----- mi->mi_tab.b_actf = bp->av_forw; mi->mi_tab.b_errcnt = 0; *************** *** 69,71 case MBU_NEXT: /* request is complete (e.g. ``sense'') */ - mi->mi_tab.b_active = 0; mi->mi_tab.b_errcnt = 0; --- 70,71 ----- case MBU_NEXT: /* request is complete (e.g. ``sense'') */ mi->mi_tab.b_errcnt = 0; *************** *** 91,93 * In any case the device is ``active'' waiting for the ! * data to transfer. */ --- 91,93 ----- * In any case the device is ``active'' waiting for the ! * data to transfer. (mi->mi_tab.b_active was set earlier.) */ *************** *** 93,95 */ - mi->mi_tab.b_active = 1; if (mhp->mh_active == 0) --- 93,94 ----- */ if (mhp->mh_active == 0) *************** *** 107,109 } - mi->mi_tab.b_active = 1; return; --- 106,107 ----- } return; *************** *** 116,117 mi->mi_tab.b_flags |= B_BUSY; return; --- 114,116 ----- mi->mi_tab.b_flags |= B_BUSY; + mi->mi_tab.b_active = 0; /* ??? */ return; *************** *** 143,144 if ((mi = mhp->mh_actf) == NULL) { return; --- 142,144 ----- if ((mi = mhp->mh_actf) == NULL) { + mhp->mh_active = 0; return; *************** *** 146,147 if ((bp = mi->mi_tab.b_actf) == NULL) { mhp->mh_actf = mi->mi_forw; --- 146,148 ----- if ((bp = mi->mi_tab.b_actf) == NULL) { + mi->mi_tab.b_active = 0; mhp->mh_actf = mi->mi_forw; *************** *** 149,150 } /* --- 150,153 ----- } + + mhp->mh_active = 1; /* *************** *** 167,169 mi->mi_tab.b_errcnt = 0; - mi->mi_tab.b_active = 0; bp->b_flags |= B_ERROR; --- 170,171 ----- mi->mi_tab.b_errcnt = 0; bp->b_flags |= B_ERROR; *************** *** 173,178 /* ! * We can do the operation; mark the massbus active ! * and let the device start routine setup any necessary ! * device state for the transfer (e.g. desired cylinder, etc ! * on disks). */ --- 175,179 ----- /* ! * We can do the operation; let the device start routine ! * set up any necessary device state for the transfer ! * (e.g. desired cylinder, etc on disks). */ *************** *** 178,180 */ - mhp->mh_active = 1; if (mi->mi_driver->md_start) { --- 179,180 ----- */ if (mi->mi_driver->md_start) { *************** Part of this is a fix from thomas@utah-gr which you should *************** install anyway, whether or not you are installing the mass *************** driver. (In other words, keep going.) *** 238,239 * are now finished. */ --- 238,242 ----- * are now finished. + * Data transfer complete interrupts do not set the attn + * bit, and positioning commands (e.g. recal) do not set + * DTCMP. */ *************** *** 239,241 */ ! if (mhp->mh_active) { /* --- 242,245 ----- */ ! mi = mhp->mh_actf; ! if (mhp->mh_active && (mbasr&MBSR_DTCMP || as&(1<mi_drive))) { /* *************** *** 246,248 */ - mi = mhp->mh_actf; as &= ~(1 << mi->mi_drive); --- 250,251 ----- */ as &= ~(1 << mi->mi_drive); *************** *** 324,326 case MBN_DONE: /* operation completed */ - mi->mi_tab.b_active = 0; mi->mi_tab.b_errcnt = 0; --- 327,328 ----- case MBN_DONE: /* operation completed */ mi->mi_tab.b_errcnt = 0; *************** *** 329,330 iodone(bp); /* fall into common code */ --- 331,333 ----- iodone(bp); + mi->mi_tab.b_active = 0; /* fall into common code */ *************** Here's some stuff I did 'cause I thought the code could *************** be cleaned up some. Well, it *is* *slightly* shorter.... *************** (This isn't necessary but can't hurt [famous last words]). *** 383,385 /* ! * Setup the mapping registers for a transfer. */ --- 386,389 ----- /* ! * Set up the mapping registers for a transfer. ! * Leave a zero entry at the end to guard against wild transfers. */ *************** *** 388,396 { ! register struct mba_regs *mbap = mi->mi_mba; ! struct buf *bp = mi->mi_tab.b_actf; ! register int npf; ! unsigned v; ! register struct pte *pte, *io; ! int o; ! struct proc *rp; --- 392,396 ----- { ! register struct buf *bp = mi->mi_tab.b_actf; ! register struct pte *pte; ! register int o; *************** *** 396,398 - v = btop(bp->b_un.b_addr); o = (int)bp->b_un.b_addr & PGOFSET; --- 396,397 ----- o = (int)bp->b_un.b_addr & PGOFSET; *************** *** 398,401 o = (int)bp->b_un.b_addr & PGOFSET; - npf = btoc(bp->b_bcount + o); - rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc; if ((bp->b_flags & B_PHYS) == 0) --- 397,398 ----- o = (int)bp->b_un.b_addr & PGOFSET; if ((bp->b_flags & B_PHYS) == 0) *************** *** 401,404 if ((bp->b_flags & B_PHYS) == 0) ! pte = &Sysmap[btop(((int)bp->b_un.b_addr)&0x7fffffff)]; ! else if (bp->b_flags & B_UAREA) pte = &rp->p_addr[v]; --- 398,406 ----- if ((bp->b_flags & B_PHYS) == 0) ! pte = &Sysmap[btop((int)bp->b_un.b_addr & 0x7fffffff)]; ! else { ! register struct proc *rp; ! register unsigned v = btop(bp->b_un.b_addr); ! ! rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc; ! if (bp->b_flags & B_UAREA) pte = &rp->p_addr[v]; *************** *** 408,410 pte = vtopte(rp, v); ! io = mbap->mba_map; while (--npf >= 0) { --- 410,416 ----- pte = vtopte(rp, v); ! } ! { ! register struct pte *io = mi->mi_mba->mba_map; ! register int npf = btoc(bp->b_bcount + o); ! while (--npf >= 0) { *************** *** 411,413 if (pte->pg_pfnum == 0) ! panic("mba, zero entry"); *(int *)io++ = pte++->pg_pfnum | PG_V; --- 417,419 ----- if (pte->pg_pfnum == 0) ! panic("mba zero entry"); *(int *)io++ = pte++->pg_pfnum | PG_V; *************** *** 414,416 } ! *(int *)io++ = 0; return (o); --- 420,423 ----- } ! *(int *)io = 0; ! } return (o); RCS file: RCS/mt.c,v retrieving revision 1.1 diff -b -c1 -r1.1 mt.c *** /tmp/,RCSt1003216 Fri Jan 4 23:02:04 1985 --- mt.c Wed Jan 2 12:22:07 1985 *************** Lots of these changes are stuff I never heard of. The *************** only mass driver change is the addition of mtmass(). *************** You can install these or not, as you choose. *** 9,10 * * TODO: --- 9,15 ----- * + * Changed by Jules P. Aronson to correct + * faulty identification of logical unit numbers with slave numbers + * specifically, the construct MUUNIT(dev) is replaced with sc->sc_slave + * in most cases. + * * TODO: *************** *** 19,21 #include "../h/buf.h" - #include "../h/conf.h" #include "../h/dir.h" --- 24,25 ----- #include "../h/buf.h" #include "../h/dir.h" *************** *** 23,24 #include "../h/user.h" #include "../h/map.h" --- 27,29 ----- #include "../h/user.h" + #include "../h/proc.h" #include "../h/map.h" *************** *** 53,54 #define MTUNIT(dev) (mutomt[MUUNIT(dev)]) --- 58,60 ----- #define MTUNIT(dev) (mutomt[MUUNIT(dev)]) + #define MUSLAVE(dev) ((&mu_softc[MUUNIT(dev)])->sc_slave) *************** *** 68,69 } mu_softc[NMU]; short mutomt[NMU]; --- 74,76 ----- } mu_softc[NMU]; + short mutomt[NMU]; *************** *** 119,122 muunit = MUUNIT(dev); ! if (muunit >= NMU || (sc = &mu_softc[muunit])->sc_openf || ! (mi = mtinfo[MTUNIT(dev)]) == 0 || mi->mi_alive == 0) return (ENXIO); --- 126,128 ----- muunit = MUUNIT(dev); ! if (muunit >= NMU || (mi = mtinfo[MTUNIT(dev)]) == 0 || !mi->mi_alive) return (ENXIO); *************** *** 122,123 return (ENXIO); olddens = sc->sc_dens; --- 128,132 ----- return (ENXIO); + sc = &mu_softc[muunit]; + if (sc->sc_openf) + return (EBUSY); olddens = sc->sc_dens; *************** *** 239,241 } else { ! mtaddr->mtncs[MUUNIT(bp->b_dev)] = (bp->b_repcnt<<8)|bp->b_command|MT_GO; --- 248,250 ----- } else { ! mtaddr->mtncs[sc->sc_slave] = (bp->b_repcnt<<8)|bp->b_command|MT_GO; *************** *** 245,247 if (mi->mi_tab.b_errcnt == 2) { ! mtaddr->mtca = MUUNIT(bp->b_dev); } else { --- 254,256 ----- if (mi->mi_tab.b_errcnt == 2) { ! mtaddr->mtca = sc->sc_slave; } else { *************** *** 248,250 mtaddr->mtbc = bp->b_bcount; ! mtaddr->mtca = (1<<2)|MUUNIT(bp->b_dev); } --- 257,259 ----- mtaddr->mtbc = bp->b_bcount; ! mtaddr->mtca = (1<<2)|sc->sc_slave; } *************** *** 253,255 if (blkno < bdbtofsb(bp->b_blkno)) ! mtaddr->mtncs[MUUNIT(bp->b_dev)] = (min((unsigned)(bdbtofsb(bp->b_blkno) - blkno), 0377) << 8) | --- 262,264 ----- if (blkno < bdbtofsb(bp->b_blkno)) ! mtaddr->mtncs[sc->sc_slave] = (min((unsigned)(bdbtofsb(bp->b_blkno) - blkno), 0377) << 8) | *************** *** 257,259 else ! mtaddr->mtncs[MUUNIT(bp->b_dev)] = (min((unsigned)(blkno - bdbtofsb(bp->b_blkno)), 0377) << 8) | --- 266,268 ----- else ! mtaddr->mtncs[sc->sc_slave] = (min((unsigned)(blkno - bdbtofsb(bp->b_blkno)), 0377) << 8) | *************** *** 284,286 register struct buf *bp = mi->mi_tab.b_actf; ! register struct mu_softc *sc; --- 293,295 ----- register struct buf *bp = mi->mi_tab.b_actf; ! register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)]; *************** *** 287,289 /* I'M NOT SURE IF THIS SHOULD ALWAYS BE THE CASE SO FOR NOW... */ ! if ((mtaddr->mtca&3) != MUUNIT(bp->b_dev)) { printf("mt: wrong unit!\n"); --- 296,298 ----- /* I'M NOT SURE IF THIS SHOULD ALWAYS BE THE CASE SO FOR NOW... */ ! if ((mtaddr->mtca&3) != sc->sc_slave) { printf("mt: wrong unit!\n"); *************** *** 289,291 printf("mt: wrong unit!\n"); ! mtaddr->mtca = MUUNIT(bp->b_dev); } --- 298,300 ----- printf("mt: wrong unit!\n"); ! mtaddr->mtca = sc->sc_slave; } *************** *** 291,293 } - sc = &mu_softc[MUUNIT(bp->b_dev)]; sc->sc_erreg = mtaddr->mter; --- 300,301 ----- } sc->sc_erreg = mtaddr->mter; *************** *** 369,371 register struct mu_softc *sc; ! int er, fc, unit; --- 377,379 ----- register struct mu_softc *sc; ! int er, fc, slave; *************** *** 371,373 ! unit = (mtaddr->mtner >> 8) & 3; er = MASKREG(mtaddr->mtner); --- 379,381 ----- ! slave = (mtaddr->mtner >> 8) & 3; er = MASKREG(mtaddr->mtner); *************** *** 374,376 /* WILL THIS OCCUR IF ANOTHER DRIVE COMES ONLINE? */ ! if (bp == 0 || unit != MUUNIT(bp->b_dev)) { /* consistency check */ if ((er & MTER_INTCODE) != MTER_ONLINE) --- 382,387 ----- /* WILL THIS OCCUR IF ANOTHER DRIVE COMES ONLINE? */ ! if (bp == NULL) ! return (MBN_SKIP); ! sc = &mu_softc[MUUNIT(bp->b_dev)]; ! if (slave != sc->sc_slave) { /* consistency check */ if ((er & MTER_INTCODE) != MTER_ONLINE) *************** *** 376,378 if ((er & MTER_INTCODE) != MTER_ONLINE) ! printf("mt: unit %d random interrupt\n", unit); return (MBN_SKIP); --- 387,390 ----- if ((er & MTER_INTCODE) != MTER_ONLINE) ! printf("mt: unit %d random interrupt\n", ! MUUNIT(bp->b_dev)); return (MBN_SKIP); *************** *** 379,384 } ! if (bp == 0) ! return (MBN_SKIP); ! fc = (mtaddr->mtncs[unit] >> 8) & 0xff; ! sc = &mu_softc[unit]; sc->sc_erreg = er; --- 391,393 ----- } ! fc = (mtaddr->mtncs[slave] >> 8) & 0xff; sc->sc_erreg = er; *************** Here's the mass driver addition: *** 492,493 return (0); } --- 501,517 ----- return (0); + } + + /* + * Start a ``raw block transfer'' from kernel space (via the + * mass driver). + */ + mtmass(bp) + register struct buf *bp; + { + register struct mu_softc *sc; + + minphys(bp); + sc = &mu_softc[MUUNIT(bp->b_dev)]; + sc->sc_blkno = bdbtofsb(bp->b_blkno); + sc->sc_nxrec = sc->sc_blkno + 1; } RCS file: RCS/param.h,v retrieving revision 1.1 diff -b -c1 -r1.1 param.h *** /tmp/,RCSt1003120 Fri Jan 4 22:59:49 1985 --- param.h Wed Jan 2 09:52:11 1985 *************** We like more processes and more files per process; this *************** has nothing to do with the mass driver. *** 18,21 #define MSWAPX 15 /* pseudo mount table index for swapdev */ ! #define MAXUPRC 25 /* max processes per user */ ! #define NOFILE 20 /* max open files per process */ /* NOFILE MUST NOT BE >= 31; SEE pte.h */ --- 18,21 ----- #define MSWAPX 15 /* pseudo mount table index for swapdev */ ! #define MAXUPRC 40 /* max processes per user */ ! #define NOFILE 30 /* max open files per process (std=20) */ /* NOFILE MUST NOT BE >= 31; SEE pte.h */ *************** We like more groups too. I recall a problem with UPAGES *************** getting too big if you increase NGROUPS, so you might want *************** to avoid this. *** 23,25 #define NCARGS 10240 /* # characters in exec arglist */ ! #define NGROUPS 8 /* max number groups */ --- 23,25 ----- #define NCARGS 10240 /* # characters in exec arglist */ ! #define NGROUPS 16 /* max number groups (std=8)*/ *************** I have most of the clist routines in VAX assembly, so I *************** moved the definitions to a separate file. You probably *************** don't want to do this. *** 97,100 ! #define CBSIZE 28 /* number of chars in a clist block */ ! #define CROUND 0x1F /* clist rounding; sizeof(int *) + CBSIZE -1*/ --- 97,103 ----- ! #ifndef KERNEL ! #include ! #else ! #include "../h/cblock.h" ! #endif *************** Fixing some comments... *** 116,118 * file systems; however making it smaller make make some file ! * systems unmountable. * --- 119,122 ----- * file systems; however making it smaller make make some file ! * systems unmountable. Also, note that MAXBSIZE must be >= MINBSIZE ! * (defined in ../h/fs.h). * *************** More comments, related to the way things are after adding *************** the mass driver. Install these if you are installing the *************** mass driver. *** 118,119 * * Note that the blocked devices are assumed to have DEV_BSIZE --- 122,134 ----- * + * MAXBSIZE is probably much larger than the average file system + * block, and it makes more sense to allocate buffers and memory + * based on the average size than on the maximum size. AVGBSIZE + * should be set to the "average" block size on your file systems. + * Setting it too small will mean that buffer memory will be scarce, + * while setting it too large will mean that buffers themselves will + * be the scarce resource. + * + * N.B.: MAXBSIZE must be a multiple of CLBYTES. Also, if you + * increase MAXBSIZE, you may have to increase SYSPTSIZE. + * * Note that the blocked devices are assumed to have DEV_BSIZE *************** The change to MAXBSIZE and the definition of AVGBSIZE *************** for the new code in vax/machdep.c. (I.e., the former *************** goes with the latter.) *** 127,129 */ ! #define MAXBSIZE 8192 #define DEV_BSIZE 512 --- 142,145 ----- */ ! #define MAXBSIZE 16384 /* was 8192 */ ! #define AVGBSIZE 4096 #define DEV_BSIZE 512 RCS file: RCS/ts.c,v retrieving revision 1.1 diff -b -c1 -r1.1 ts.c *** /tmp/,RCSt1003186 Fri Jan 4 23:01:16 1985 --- ts.c Wed Jan 2 11:57:07 1985 *************** Yet another useless conf.h *** 16,18 #include "../h/dir.h" - #include "../h/conf.h" #include "../h/user.h" --- 16,17 ----- #include "../h/dir.h" #include "../h/user.h" *************** Yet another BRL csleep change to ignore *** 296,298 bp->b_flags |= B_WANTED; ! sleep((caddr_t)bp, PRIBIO); } --- 295,297 ----- bp->b_flags |= B_WANTED; ! csleep((caddr_t)bp, PRIBIO, "TAPE"); } *************** I like type names. *** 509,511 int tsunit; ! register state; --- 508,510 ----- int tsunit; ! register int state; *************** This is necessary for the mass driver 'cause we need to *************** know the state ``inside'' biodone()... biodone may wind *************** up invoking the strategy routine, and we don't want it *************** calling tsstart() if the tape is really busy. *** 533,535 state = um->um_tab.b_active; - um->um_tab.b_active = 0; /* --- 532,533 ----- state = um->um_tab.b_active; /* *************** Formatting, formatting! Sheesh. *** 575,577 */ ! if (state==SIO) { if (++um->um_tab.b_errcnt < 7) { --- 573,575 ----- */ ! if (state == SIO) { if (++um->um_tab.b_errcnt < 7) { *************** Better state info. *** 660,662 iodone(bp); ! if (um->um_tab.b_actf->b_actf == 0) return; --- 658,661 ----- iodone(bp); ! if (um->um_tab.b_actf->b_actf == 0) { ! um->um_tab.b_active = 0; return; *************** *** 662,663 return; opcont: --- 661,663 ----- return; + } opcont: *************** The mass driver entry point. *** 733,734 return (0); } --- 733,750 ----- return (0); + } + + /* + * Start a ``raw block transfer'' from kernel space (via the + * mass driver). Job is a combination minphys() and part of + * tsphys(). + */ + tsmass(bp) + register struct buf *bp; + { + register struct ts_softc *sc; + + minphys(bp); + sc = &ts_softc[TSUNIT(bp->b_dev)]; + sc->sc_blkno = bdbtofsb(bp->b_blkno); + sc->sc_nxrec = sc->sc_blkno + 1; } RCS file: RCS/ufs_machdep.c,v retrieving revision 1.1 diff -b -c1 -r1.1 ufs_machdep.c *** /tmp/,RCSt1003161 Fri Jan 4 23:00:57 1985 --- ufs_machdep.c Wed Jan 2 10:42:31 1985 *************** Still another useless conf.h! Sigh. *** 9,11 #include "../h/buf.h" - #include "../h/conf.h" #include "../h/proc.h" --- 9,10 ----- #include "../h/buf.h" #include "../h/proc.h" *************** Gripe if someone asks for more space than exists in any *************** one buffer. *** 30,31 sizealloc = roundup(size, CLBYTES); /* --- 29,33 ----- sizealloc = roundup(size, CLBYTES); + if (sizealloc > MAXBSIZE) + panic("allocbuf"); + /* *************** Minor style thingy. I prefer parallel construction... *** 69,71 tp->b_bufsize += take; ! bp->b_bufsize = bp->b_bufsize - take; if (bp->b_bcount > bp->b_bufsize) --- 71,73 ----- tp->b_bufsize += take; ! bp->b_bufsize -= take; if (bp->b_bcount > bp->b_bufsize) RCS file: RCS/vm_mem.c,v retrieving revision 1.1 diff -b -c1 -r1.1 vm_mem.c *** /tmp/,RCSt1003130 Fri Jan 4 23:00:00 1985 --- vm_mem.c Wed Jan 2 10:24:43 1985 *************** More BRL csleep stuff to ignore *** 39,41 while (freemem == 0) ! sleep((caddr_t)&freemem, PSWP+2); m = imin(size, freemem); --- 39,41 ----- while (freemem == 0) ! csleep((caddr_t)&freemem, PSWP+2, "FREEMEM"); m = imin(size, freemem); *************** The C-compiler-sign-extension-bug fix (1 of 2; the other *************** is in some incredibly similar piece of code somewhere else *************** that I don't particularly recall.) *** 251,252 } if (mfind(c->c_mdev == MSWAPX ? --- 251,253 ----- } + #ifdef lint if (mfind(c->c_mdev == MSWAPX ? *************** *** 255,256 panic("memall mfind"); c1->c_mdev = 0; --- 256,263 ----- panic("memall mfind"); + #else /* Avoid compiler sign extend bug */ + if (mfind(c->c_mdev == MSWAPX ? + swapdev : mount[c->c_mdev].m_dev, + c->c_blkno)) + panic("memall mfind"); + #endif lint c1->c_mdev = 0; *************** A side dish of changes to make meminit complain about *************** improperly sized core maps, and to (probably) make the *************** generated code smaller too. *** 518,520 /* ! * Initialize core map */ --- 525,528 ----- /* ! * Initialize core map. Print a warning message if the core map is ! * too small to map everything, or another if it's way too big. */ *************** *** 523,525 { ! register int i; register struct cmap *c; --- 531,533 ----- { ! register int i, lastcm; register struct cmap *c; *************** *** 530,535 ecmx = ecmap - cmap; ! if (ecmx < freemem / CLSIZE) ! freemem = ecmx * CLSIZE; ! for (i = 1; i <= freemem / CLSIZE; i++) { ! cmap[i-1].c_next = i; c = &cmap[i]; --- 538,549 ----- ecmx = ecmap - cmap; ! lastcm = freemem / CLSIZE; ! if (ecmx < lastcm) { ! printf("core map %d too small (lost %d bytes of user mem)\n", ! lastcm - ecmx, freemem - ecmx * CLSIZE); ! lastcm = ecmx; ! freemem = lastcm * CLSIZE; ! } ! else if (ecmx - 20 > lastcm) /* probably shouldn't happen */ ! printf("%d unused core map entries\n", ecmx - lastcm); ! for (i = 1; i <= lastcm; i++) { c = &cmap[i]; *************** *** 535,536 c = &cmap[i]; c->c_prev = i-1; --- 549,551 ----- c = &cmap[i]; + c[-1].c_next = i; c->c_prev = i-1; *************** *** 542,544 } ! cmap[freemem / CLSIZE].c_next = CMHEAD; for (i = 0; i < CMHSIZ; i++) --- 557,561 ----- } ! cmap[CMHEAD].c_prev = lastcm; ! cmap[CMHEAD].c_type = CSYS; ! cmap[lastcm].c_next = CMHEAD; for (i = 0; i < CMHSIZ; i++) *************** *** 545,548 cmhash[i] = ecmx; - cmap[CMHEAD].c_prev = freemem / CLSIZE; - cmap[CMHEAD].c_type = CSYS; avefree = freemem; --- 562,563 ----- cmhash[i] = ecmx; avefree = freemem; *************** Yet another BRL csleep to ignore *** 577,579 c->c_want = 1; ! sleep((caddr_t)c, PSWP+1); } --- 592,594 ----- c->c_want = 1; ! csleep((caddr_t)c, PSWP+1, "PAGE"); } RCS file: RCS/vmparam.h,v retrieving revision 1.1 diff -b -c1 -r1.1 vmparam.h *** /tmp/,RCSt1003173 Fri Jan 4 23:01:05 1985 --- vmparam.h Wed Jan 2 10:43:06 1985 *************** We have bigger data and stack limits. Ignore these unless *************** you REALLY know what you're doing here. *** 26,28 #ifndef MAXDSIZ ! #define MAXDSIZ (12*1024-32-SLOP) /* max data size (clicks) */ #endif --- 26,28 ----- #ifndef MAXDSIZ ! #define MAXDSIZ (16*2048-32-SLOP) /* max data size (clicks) */ #endif *************** *** 28,30 #endif ! #define MAXSSIZ (12*1024-32-SLOP) /* max stack size (clicks) */ --- 28,30 ----- #endif ! #define MAXSSIZ (6*2048-32-SLOP) /* max stack size (clicks) */ *************** Increase SYSPTSIZE to handle mapping those 16K buffers. *************** The comment is right, but making it work that way is hard. *** 34,36 /* SYSPTSIZE IS SILLY; IT SHOULD BE COMPUTED AT BOOT TIME */ ! #define SYSPTSIZE ((20+MAXUSERS)*NPTEPG) #define USRPTSIZE (8*NPTEPG) --- 34,36 ----- /* SYSPTSIZE IS SILLY; IT SHOULD BE COMPUTED AT BOOT TIME */ ! #define SYSPTSIZE ((40+MAXUSERS)*NPTEPG) #define USRPTSIZE (8*NPTEPG) *************** Not sure exactly what this does, but it affects the *************** printf about "should use interleaved swap". *** 114,116 */ ! #define LOTSOFMEM 2 --- 114,116 ----- */ ! #define LOTSOFMEM 3 //go.sysin dd * made=TRUE if [ $made = TRUE ]; then /bin/chmod 644 kernel_mods /bin/echo -n ' '; /bin/ls -ld kernel_mods fi -- (This line accidently left nonblank.) In-Real-Life: Chris Torek, Univ of MD Comp Sci Dept (301) 454-7690 UUCP: {seismo,allegra,brl-bmd}!umcp-cs!chris CSNet: chris@umcp-cs ARPA: chris@maryland