? gnu/lib/libbfd/arch/hppa ? gnu/usr.bin/binutils/common/arch/hppa ? gnu/usr.bin/binutils/gas/arch/hppa ? gnu/usr.bin/binutils/gprof/arch/hppa ? gnu/usr.bin/binutils/ld/arch/hppa ? sys/arch/hp700/conf/ZOOROPA ? sys/arch/hp700/conf/PLAIN-D ? sys/arch/hp700/conf/SUNRISE ? sys/dev/ic/stivar.h ? sys/dev/ic/stireg.h ? sys/dev/ic/sti.c Index: etc/mtree/NetBSD.dist =================================================================== RCS file: /cvsroot/basesrc/etc/mtree/NetBSD.dist,v retrieving revision 1.197 diff -u -r1.197 NetBSD.dist --- etc/mtree/NetBSD.dist 2002/06/29 17:27:43 1.197 +++ etc/mtree/NetBSD.dist 2002/11/14 16:23:02 @@ -408,6 +408,7 @@ ./usr/share/man/cat4/arm32 ./usr/share/man/cat4/atari ./usr/share/man/cat4/hp300 +./usr/share/man/cat4/hp700 ./usr/share/man/cat4/i386 ./usr/share/man/cat4/mac68k ./usr/share/man/cat4/macppc @@ -480,6 +481,7 @@ ./usr/share/man/cat9/amiga ./usr/share/man/cat9/atari ./usr/share/man/cat9/hp300 +./usr/share/man/cat9/hp700 ./usr/share/man/cat9/i386 ./usr/share/man/cat9/mac68k ./usr/share/man/cat9/pc532 @@ -501,6 +503,7 @@ ./usr/share/man/man4/arm32 ./usr/share/man/man4/atari ./usr/share/man/man4/hp300 +./usr/share/man/man4/hp700 ./usr/share/man/man4/i386 ./usr/share/man/man4/mac68k ./usr/share/man/man4/macppc @@ -573,6 +576,7 @@ ./usr/share/man/man9/amiga ./usr/share/man/man9/atari ./usr/share/man/man9/hp300 +./usr/share/man/man9/hp700 ./usr/share/man/man9/i386 ./usr/share/man/man9/mac68k ./usr/share/man/man9/pc532 @@ -594,6 +598,7 @@ ./usr/share/man/html4/arm32 ./usr/share/man/html4/atari ./usr/share/man/html4/hp300 +./usr/share/man/html4/hp700 ./usr/share/man/html4/i386 ./usr/share/man/html4/mac68k ./usr/share/man/html4/macppc @@ -666,6 +671,7 @@ ./usr/share/man/html9/amiga ./usr/share/man/html9/atari ./usr/share/man/html9/hp300 +./usr/share/man/html9/hp700 ./usr/share/man/html9/i386 ./usr/share/man/html9/mac68k ./usr/share/man/html9/pc532 Index: gnu/usr.bin/groff/Makefile =================================================================== RCS file: /cvsroot/gnusrc/gnu/usr.bin/groff/Makefile,v retrieving revision 1.12 diff -u -r1.12 Makefile --- gnu/usr.bin/groff/Makefile 2001/04/19 14:40:40 1.12 +++ gnu/usr.bin/groff/Makefile 2002/11/14 16:24:15 @@ -5,6 +5,11 @@ indxbib lkbib lookbib man mm nroff pfbtops pic refer \ tbl tfmtodit tmac troff +# XXX fredette - never commit: +.if ${MACHINE_ARCH} == "hppa" +SUBDIR= +.endif + # afmtodit is a perl script; xditview an X program (we can't assume X is # installed); NetBSD has its own soelim. MISC= afmtodit xditview soelim Index: libexec/ld.elf_so/arch/hppa/hppa_reloc.c =================================================================== RCS file: /cvsroot/basesrc/libexec/ld.elf_so/arch/hppa/hppa_reloc.c,v retrieving revision 1.1 diff -u -r1.1 hppa_reloc.c --- libexec/ld.elf_so/arch/hppa/hppa_reloc.c 2002/07/10 15:12:38 1.1 +++ libexec/ld.elf_so/arch/hppa/hppa_reloc.c 2002/11/14 16:24:28 @@ -333,5 +333,64 @@ where[1] = func_sl; if (addrp != NULL) *addrp = (caddr_t)where; + +#if 1 + /* + * Flush the PLT stub that's before the GOT. + */ + /* + * XXX fredette - I struggled with this for days. + * Without this flushing, my 735/99 (with separate + * 256K instruction and data caches) would see + * all-bits-zero words for instructions in the PLT + * stub, causing break traps. + * + * After reading and rereading the rules for + * instruction- and data-cache movein, I can't see + * why any flushing of the PLT stub is needed, since + * I never write to the instruction part of the stub. + * + * Sure, I write the data parts of the stub, and I + * write data into the GOT near the stub, but unless + * there's some sort of cache line sharing/copying + * between the I and D caches, the first time that + * control transfers to the stub, the line should get + * moved-in from main memory into the I-cache, even if + * the line is also present and dirty in the D-cache. + * + * If someone has any ideas, please experiment. + * This flushing almost certainly hurts performance. + */ + __asm __volatile( + " copy %0, %%r22 \n" + " fdc,m %1(%0) \n" + " fdc,m %1(%0) \n" + " fdc,m %1(%0) \n" + " fdc,m %1(%0) \n" + " fdc,m %1(%0) \n" + " fdc,m %1(%0) \n" + " nop \n" + " nop \n" + " sync \n" + " syncdma \n" + " nop \n" + " nop \n" + " fic,m %1(%%r22) \n" + " fic,m %1(%%r22) \n" + " fic,m %1(%%r22) \n" + " fic,m %1(%%r22) \n" + " fic,m %1(%%r22) \n" + " fic,m %1(%%r22) \n" + " nop \n" + " nop \n" + " sync \n" + " syncdma \n" + " nop \n" + " nop \n" + : /* no outputs */ + : "r" ((Elf_Addr)HPPA_OBJ_GOT(obj)), "r" ((int) -16) + : "r22"); +#endif + return 0; } Index: regress/lib/libc/Makefile =================================================================== RCS file: /cvsroot/basesrc/regress/lib/libc/Makefile,v retrieving revision 1.29 diff -u -r1.29 Makefile --- regress/lib/libc/Makefile 2002/07/05 15:42:41 1.29 +++ regress/lib/libc/Makefile 2002/11/14 16:24:29 @@ -3,7 +3,9 @@ SUBDIR+= _setjmp clone db div divrem \ gen getaddrinfo hsearch int_fmtio md5sha popen regex rpc \ setjmp sigsetjmp string sys time -.if (${MACHINE_ARCH} != "vax" && ${MACHINE_ARCH} != "m68000") +.if (${MACHINE_ARCH} != "hppa" && \ + ${MACHINE_ARCH} != "m68000" && \ + ${MACHINE_ARCH} != "vax") SUBDIR+= ieeefp .endif .if (${MACHINE_ARCH} != "vax") Index: sys/arch/hp700/hp700/machdep.c =================================================================== RCS file: /cvsroot/syssrc/sys/arch/hp700/hp700/machdep.c,v retrieving revision 1.4 diff -u -r1.4 machdep.c --- sys/arch/hp700/hp700/machdep.c 2002/08/25 20:20:01 1.4 +++ sys/arch/hp700/hp700/machdep.c 2002/11/14 16:24:48 @@ -1419,9 +1419,16 @@ if (howto & RB_HALT) { haltsys: +#ifndef DEBUG printf("System halted!\n"); __asm __volatile("stwas %0, 0(%1)" :: "r" (CMD_STOP), "r" (LBCAST_ADDR + iomod_command)); +#else /* DEBUG */ + printf("rebooting..."); + DELAY(1000000); + __asm __volatile("stwas %0, 0(%1)" + :: "r" (CMD_RESET), "r" (LBCAST_ADDR + iomod_command)); +#endif /* DEBUG */ } else { printf("rebooting..."); DELAY(1000000); Index: sys/arch/hppa/hppa/trap.c =================================================================== RCS file: /cvsroot/syssrc/sys/arch/hppa/hppa/trap.c,v retrieving revision 1.4 diff -u -r1.4 trap.c --- sys/arch/hppa/hppa/trap.c 2002/08/19 15:07:33 1.4 +++ sys/arch/hppa/hppa/trap.c 2002/11/14 16:24:50 @@ -636,13 +636,38 @@ if (trap_kdebug(type, va, frame)) return; else if (type == T_DATALIGN) - panic ("trap: %s at 0x%x", tts, (u_int) va); - else - panic ("trap: no debugger for \"%s\" (%d)", tts, type); + panic ("trap: %s at 0x%x at %x:%08x (%08x)", tts, (u_int) va, + frame->tf_iisq_head, frame->tf_iioq_head, frame->tf_iir); + else { + extern vaddr_t hpt_base; + extern vsize_t hpt_mask; + printf("isr %08x ior %08x r24 %08x cr28 %08x\nvtop %08x mask %08x hpt_base %08x hpt_mask %08x\n", frame->tf_isr, frame->tf_ior, frame->tf_arg2, frame->tf_cr28, frame->tf_vtop, frame->tf_hptm, (u_int) hpt_base, (u_int) hpt_mask); + panic ("trap: no debugger for \"%s\" (%d) at %x:%08x (%08x)", + tts, type, + frame->tf_iisq_head, frame->tf_iioq_head, frame->tf_iir); + } break; case T_IBREAK | T_USER: case T_DBREAK | T_USER: +#if 1 + space = frame->tf_iisq_head; + va = frame->tf_iioq_head & ~HPPA_PC_PRIV_MASK; + printf("%s at 0x%x:0x%x, iir=0x%08x\n", tts, space, (u_int)va, + frame->tf_iir); + __asm __volatile( + " mtsp %1, %%sr1 \n" + " ldw 0(%%sr1, %2), %0\n" + : "=r" (opcode) : "r" (space), "r" (va)); + printf("first ld yields 0x%08x\n", opcode); + fcacheall(); + __asm __volatile( + " mtsp %1, %%sr1 \n" + " ldw 0(%%sr1, %2), %0\n" + : "=r" (opcode) : "r" (space), "r" (va)); + printf("second ld yields 0x%08x\n", opcode); + ret = 0; +#endif /* pass to user debugger */ break; Index: sys/conf/files =================================================================== RCS file: /cvsroot/syssrc/sys/conf/files,v retrieving revision 1.540 diff -u -r1.540 files --- sys/conf/files 2002/07/02 20:27:45 1.540 +++ sys/conf/files 2002/11/14 16:25:02 @@ -373,7 +373,7 @@ device lfmiop: scsi file dev/ic/lfmiop.c lfmiop -# Symbios/NCR 53c710 SCSI controllers +# Symbios/NCR 53c700/53c710 SCSI controllers # device osiop: scsi file dev/ic/osiop.c osiop @@ -773,6 +773,10 @@ # device igsfb: wsemuldisplaydev, wsrasteremulops, rasops8 file dev/ic/igsfb.c igsfb +# STI (HP graphics) +# +device sti: wsemuldisplaydev +file dev/ic/sti.c sti & (sti_pci|sti_sgc) needs-flag # Attributes which machine-independent bus support can be attached to. # These should be defined here, because some of these busses can have Index: sys/dev/ic/osiop.c =================================================================== RCS file: /cvsroot/syssrc/sys/dev/ic/osiop.c,v retrieving revision 1.9 diff -u -r1.9 osiop.c --- sys/dev/ic/osiop.c 2002/04/05 18:27:54 1.9 +++ sys/dev/ic/osiop.c 2002/11/14 16:25:04 @@ -98,10 +98,14 @@ #include #include +#include #include #include +/* 53C700 script */ +#include + /* 53C710 script */ #include @@ -116,6 +120,7 @@ void osiop_init(struct osiop_softc *); void osiop_reset(struct osiop_softc *); void osiop_resetbus(struct osiop_softc *); +void osiop_write_dsa(struct osiop_softc *, struct osiop_acb *); void osiop_start(struct osiop_softc *); int osiop_checkintr(struct osiop_softc *, u_int8_t, u_int8_t, u_int8_t, int *); void osiop_select(struct osiop_softc *); @@ -191,6 +196,8 @@ #define OSIOP_TRACE(a,b,c,d) #endif +#define SIZEOF_ARRAY(a) (sizeof(a) / sizeof(a[0])) + void osiop_attach(sc) struct osiop_softc *sc; @@ -230,8 +237,68 @@ /* * Copy and sync script + */ + switch(sc->sc_rev) { + case OSIOP_VARIANT_NCR53C700: + + /* Copy the raw script. */ + memcpy(sc->sc_script, oosiop_script, sizeof(oosiop_script)); + + /* + * The 53c700 can't do relative jumps, so we have to + * adjust all script offsets used in the script. + */ + for(i = 0; i < SIZEOF_ARRAY(LABELPATCHES); i++) + sc->sc_script[LABELPATCHES[i]] += sc->sc_scrdma->dm_segs[0].ds_addr; + + /* + * Certain block transfer instructions in our script + * always involve the same count of bytes; these + * correspond to the constant .count values set up + * in the ACB data structure below. For example, + * all data structures always have a status.count value + * of one. We take advantage of these constant values + * to fix up all count values in instructions that we + * can now, leaving us only to fix up their address + * values at transfer time. + * + * We can't do this all of the time - for example, + * the counts for command and scatter/gather need + * to be set at script-runtime. + * + * Note that the script offsets we have are for + * data pointers only. I didn't bother creating + * externals for the data counts, because count + * and pointer are always used together. The count + * immediately precedes the pointer in the script. + * We also take advantage of the fact that the + * count fields in the unfixed script are zero. + */ +#define FIXED_COUNT(name, count) \ + for(i = 0; i < SIZEOF_ARRAY(name); i++) \ + sc->sc_script[name[i] - 1] |= (count) + FIXED_COUNT(E_ds_Status_Used, 1); + FIXED_COUNT(E_ds_Msg_Used, 1); + FIXED_COUNT(E_ds_MsgIn_Used, 1); + FIXED_COUNT(E_ds_ExtMsg_Used, 1); + FIXED_COUNT(E_ds_SyncMsg_Used, 3); +#undef FIXED_COUNT + break; + + case OSIOP_VARIANT_NCR53C710: + memcpy(sc->sc_script, osiop_script, sizeof(osiop_script)); + break; + } + + /* + * If the byte order of the chip is not the same as + * the byte order of the CPU, we need to byteswap + * the script. */ - memcpy(sc->sc_script, osiop_script, sizeof(osiop_script)); + if (sc->sc_byteorder != OSIOP_BYTEORDER_NATIVE) { + for(i = 0; i < SIZEOF_ARRAY(osiop_script); i++) + sc->sc_script[i] = bswap32(sc->sc_script[i]); + } bus_dmamap_sync(sc->sc_dmat, sc->sc_scrdma, 0, sizeof(osiop_script), BUS_DMASYNC_PREWRITE); @@ -324,8 +391,19 @@ acb++; } - printf(": NCR53C710 rev %d, %dMHz, SCSI ID %d\n", - osiop_read_1(sc, OSIOP_CTEST8) >> 4, sc->sc_clock_freq, sc->sc_id); + printf(": "); + switch(sc->sc_rev) { + case OSIOP_VARIANT_NCR53C700: + printf("NCR53C700 rev %d", + osiop_read_1(sc, OSIOP_CTEST7) >> 4); + break; + case OSIOP_VARIANT_NCR53C710: + printf("NCR53C710 rev %d", + osiop_read_1(sc, OSIOP_CTEST8) >> 4); + break; + } + printf(", %dMHz, SCSI ID %d\n", + sc->sc_clock_freq, sc->sc_id); /* * Initialize all @@ -548,6 +626,7 @@ i--; } sstat0 = osiop_read_1(sc, OSIOP_SSTAT0); + delay(25); dstat = osiop_read_1(sc, OSIOP_DSTAT); if (osiop_checkintr(sc, istat, dstat, sstat0, &status)) { if (acb != sc->sc_nexus) @@ -832,6 +911,8 @@ struct osiop_acb *acb; int i, s; u_int8_t stat; + bus_size_t rst_reg, dmode_reg; + u_int8_t rst_bit; #ifdef OSIOP_DEBUG printf("%s: resetting chip\n", sc->sc_dev.dv_xname); @@ -850,11 +931,23 @@ osiop_write_1(sc, OSIOP_ISTAT, osiop_read_1(sc, OSIOP_ISTAT) | OSIOP_ISTAT_ABRT); /* reset chip */ - osiop_write_1(sc, OSIOP_ISTAT, - osiop_read_1(sc, OSIOP_ISTAT) | OSIOP_ISTAT_RST); + switch(sc->sc_rev) { + case OSIOP_VARIANT_NCR53C700: + rst_reg = OSIOP_DCNTL; + rst_bit = OSIOP_DCNTL_RST; + dmode_reg = OSIOP_DMODE_53C700; + break; + case OSIOP_VARIANT_NCR53C710: + rst_reg = OSIOP_ISTAT; + rst_bit = OSIOP_ISTAT_RST; + dmode_reg = OSIOP_DMODE_53C710; + break; + } + osiop_write_1(sc, rst_reg, + osiop_read_1(sc, rst_reg) | rst_bit); delay(100); - osiop_write_1(sc, OSIOP_ISTAT, - osiop_read_1(sc, OSIOP_ISTAT) & ~OSIOP_ISTAT_RST); + osiop_write_1(sc, rst_reg, + osiop_read_1(sc, rst_reg) & ~rst_bit); delay(100); /* @@ -864,14 +957,15 @@ OSIOP_ARB_FULL | OSIOP_SCNTL0_EPC | OSIOP_SCNTL0_EPG); osiop_write_1(sc, OSIOP_SCNTL1, OSIOP_SCNTL1_ESR); osiop_write_1(sc, OSIOP_DCNTL, sc->sc_dcntl); - osiop_write_1(sc, OSIOP_DMODE, OSIOP_DMODE_BL4); + osiop_write_1(sc, dmode_reg, OSIOP_DMODE_BL4); /* don't enable interrupts yet */ osiop_write_1(sc, OSIOP_SIEN, 0x00); osiop_write_1(sc, OSIOP_DIEN, 0x00); osiop_write_1(sc, OSIOP_SCID, OSIOP_SCID_VALUE(sc->sc_id)); osiop_write_1(sc, OSIOP_DWT, 0x00); - osiop_write_1(sc, OSIOP_CTEST0, osiop_read_1(sc, OSIOP_CTEST0) - | OSIOP_CTEST0_BTD | OSIOP_CTEST0_EAN); + if (sc->sc_rev != OSIOP_VARIANT_NCR53C700) + osiop_write_1(sc, OSIOP_CTEST0, osiop_read_1(sc, OSIOP_CTEST0) + | OSIOP_CTEST0_BTD | OSIOP_CTEST0_EAN); osiop_write_1(sc, OSIOP_CTEST7, osiop_read_1(sc, OSIOP_CTEST7) | sc->sc_ctest7); @@ -885,6 +979,7 @@ stat = osiop_read_1(sc, OSIOP_ISTAT); if (stat & OSIOP_ISTAT_SIP) osiop_read_1(sc, OSIOP_SSTAT0); + delay(25); if (stat & OSIOP_ISTAT_DIP) osiop_read_1(sc, OSIOP_DSTAT); @@ -912,8 +1007,10 @@ /* enable SCSI and DMA interrupts */ sc->sc_sien = OSIOP_SIEN_M_A | OSIOP_SIEN_STO | /*OSIOP_SIEN_SEL |*/ OSIOP_SIEN_SGE | OSIOP_SIEN_UDC | OSIOP_SIEN_RST | OSIOP_SIEN_PAR; - sc->sc_dien = OSIOP_DIEN_BF | OSIOP_DIEN_ABRT | OSIOP_DIEN_SIR | + sc->sc_dien = OSIOP_DIEN_ABRT | OSIOP_DIEN_SIR | /*OSIOP_DIEN_WTD |*/ OSIOP_DIEN_IID; + if (sc->sc_rev != OSIOP_VARIANT_NCR53C700) + sc->sc_dien |= OSIOP_DIEN_BF; osiop_write_1(sc, OSIOP_SIEN, sc->sc_sien); osiop_write_1(sc, OSIOP_DIEN, sc->sc_dien); } @@ -932,6 +1029,90 @@ } /* + * On the 53c710, this loads the DSA with the address of the + * data structure we'd like our script to use. On the 53c700, + * since it doesn't have a DSA, we have to stuff the values + * in the data structure directly into the script. + */ + +void +osiop_write_dsa(sc, acb) + struct osiop_softc *sc; + struct osiop_acb *acb; +{ + int i; + int off; + u_int32_t inst; + int need_swap; + struct osiop_ds *ds = acb->ds; + + switch(sc->sc_rev) { + case OSIOP_VARIANT_NCR53C700: + + need_swap = (sc->sc_byteorder != OSIOP_BYTEORDER_NATIVE); + + for(i = 0; i < SIZEOF_ARRAY(E_ds_Device_Used); i++) { + off = E_ds_Device_Used[i] - 1; + inst = oosiop_script[off] | (ds->scsi_addr & 0x00ff0000); + sc->sc_script[off] = (need_swap ? bswap32(inst) : inst); + } + + /* Some macros for clarity. */ +#define FOREACH_OFF(sym, body) do { \ + for(i = 0; i < SIZEOF_ARRAY(sym); i++) { off = sym[i]; body; } \ +} while(/* CONSTCOND */ 0) +#define STUFF_ADDR(what) \ + inst = ds->what.addr; \ + sc->sc_script[off] = (need_swap ? bswap32(inst) : inst) +#define STUFF_FULL(what) \ + inst = ds->what.addr; \ + sc->sc_script[off--] = (need_swap ? bswap32(inst) : inst); \ + inst = oosiop_script[off] | ds->what.count; \ + sc->sc_script[off] = (need_swap ? bswap32(inst) : inst) + + FOREACH_OFF(E_ds_MsgOut_Used, STUFF_FULL(id)); + FOREACH_OFF(E_ds_Cmd_Used, STUFF_FULL(cmd)); + FOREACH_OFF(E_ds_Status_Used, STUFF_ADDR(status)); + FOREACH_OFF(E_ds_Msg_Used, STUFF_ADDR(msg)); + FOREACH_OFF(E_ds_MsgIn_Used, STUFF_ADDR(msgin)); + FOREACH_OFF(E_ds_ExtMsg_Used, STUFF_ADDR(extmsg)); + FOREACH_OFF(E_ds_SyncMsg_Used, STUFF_ADDR(synmsg)); + + /* + * The DMA scatter/gather buffers are handled + * differently. To avoid a bunch of external + * symbols in the script (OSIOP_NSG of them) + * there is only E_ds_Data1_Used, with exactly + * OSIOP_NSG * 2 references. We rely on the + * scripts compiler laying out the _Used + * array such that _Used[0] and _Used[OSIOP_NSG] + * are really ds_Data1, [1] and [OSIOP_NSG + 1] + * are really ds_Data2, etc. + */ + for(i = 0; i < OSIOP_NSG; i++) { + off = E_ds_Data1_Used[i]; + STUFF_FULL(data[i]); + off = E_ds_Data1_Used[OSIOP_NSG + i]; + STUFF_FULL(data[i]); + } + +#undef FOREACH_OFF +#undef STUFF_COUNT +#undef STUFF_FULL + + /* Resync the script. */ + bus_dmamap_sync(sc->sc_dmat, sc->sc_scrdma, + 0, sizeof(oosiop_script), BUS_DMASYNC_PREWRITE); + + break; + case OSIOP_VARIANT_NCR53C710: + osiop_write_4(sc, OSIOP_DSA, + sc->sc_dsdma->dm_segs[0].ds_addr + acb->dsoffset); + break; + } +} + +/* * Setup Data Storage for 53C710 and start SCRIPTS processing */ @@ -956,7 +1137,8 @@ printf("istat %02x sfbr %02x lcrc %02x sien %02x dien %02x\n", osiop_read_1(sc, OSIOP_ISTAT), osiop_read_1(sc, OSIOP_SFBR), - osiop_read_1(sc, OSIOP_LCRC), + (sc->sc_rev == OSIOP_VARIANT_NCR53C700 + ? 0 : osiop_read_1(sc, OSIOP_LCRC)), osiop_read_1(sc, OSIOP_SIEN), osiop_read_1(sc, OSIOP_DIEN)); #ifdef DDB @@ -1072,14 +1254,14 @@ sc->sc_dev.dv_xname); osiop_write_4(sc, OSIOP_TEMP, 0); osiop_write_1(sc, OSIOP_SBCL, ti->sbcl); - osiop_write_4(sc, OSIOP_DSA, - dsdma->dm_segs[0].ds_addr + acb->dsoffset); + osiop_write_dsa(sc, acb); osiop_write_4(sc, OSIOP_DSP, sc->sc_scrdma->dm_segs[0].ds_addr + Ent_scripts); OSIOP_TRACE('s', 1, 0, 0); } else { if ((osiop_read_1(sc, OSIOP_ISTAT) & OSIOP_ISTAT_CON) == 0) { - osiop_write_1(sc, OSIOP_ISTAT, OSIOP_ISTAT_SIGP); + if (sc->sc_rev != OSIOP_VARIANT_NCR53C700) + osiop_write_1(sc, OSIOP_ISTAT, OSIOP_ISTAT_SIGP); OSIOP_TRACE('s', 2, 0, 0); } else { OSIOP_TRACE('s', 3, @@ -1109,17 +1291,29 @@ bus_addr_t scraddr = sc->sc_scrdma->dm_segs[0].ds_addr; int target = 0; int dfifo, dbc, intcode, sstat1; + bus_size_t clf_reg; + u_int8_t clf_bit; + u_int8_t dfifo_bo; dfifo = osiop_read_1(sc, OSIOP_DFIFO); dbc = osiop_read_4(sc, OSIOP_DBC) & 0x00ffffff; sstat1 = osiop_read_1(sc, OSIOP_SSTAT1); - osiop_write_1(sc, OSIOP_CTEST8, - osiop_read_1(sc, OSIOP_CTEST8) | OSIOP_CTEST8_CLF); + if (sc->sc_rev == OSIOP_VARIANT_NCR53C700) { + clf_reg = OSIOP_DFIFO; + clf_bit = OSIOP_DFIFO_CLF; + dfifo_bo = OSIOP_DFIFO_BO_53C700; + } else { + clf_reg = OSIOP_CTEST8; + clf_bit = OSIOP_CTEST8_CLF; + dfifo_bo = OSIOP_DFIFO_BO_53C710; + } + osiop_write_1(sc, clf_reg, + osiop_read_1(sc, clf_reg) | clf_bit); while ((osiop_read_1(sc, OSIOP_CTEST1) & OSIOP_CTEST1_FMT) != OSIOP_CTEST1_FMT) ; - osiop_write_1(sc, OSIOP_CTEST8, - osiop_read_1(sc, OSIOP_CTEST8) & ~OSIOP_CTEST8_CLF); + osiop_write_1(sc, clf_reg, + osiop_read_1(sc, clf_reg) & ~clf_bit); intcode = osiop_read_4(sc, OSIOP_DSPS); #ifdef OSIOP_DEBUG osiopints++; @@ -1156,7 +1350,8 @@ /* Normal completion status, or check condition */ struct osiop_tinfo *ti; #ifdef OSIOP_DEBUG - if (osiop_read_4(sc, OSIOP_DSA) != + if (sc->sc_rev != OSIOP_VARIANT_NCR53C700 && + osiop_read_4(sc, OSIOP_DSA) != dsdma->dm_segs[0].ds_addr + acb->dsoffset) { printf("osiop: invalid dsa: %x %lx\n", osiop_read_4(sc, OSIOP_DSA), @@ -1248,7 +1443,7 @@ sc->sc_dev.dv_xname); #endif if (acb->datalen > 0) { - int adjust = (dfifo - (dbc & 0x7f)) & 0x7f; + int adjust = (dfifo - (dbc & dfifo_bo)) & dfifo_bo; if (sstat1 & OSIOP_SSTAT1_ORF) adjust++; if (sstat1 & OSIOP_SSTAT1_OLF) @@ -1519,7 +1714,10 @@ return (0); } if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_reconnect) { - int reselid = ffs(osiop_read_4(sc, OSIOP_SCRATCH) & 0xff) - 1; + /* XXX this needs to be addressed for the 53c700 */ + int reselid = ffs((sc->sc_rev == OSIOP_VARIANT_NCR53C700 ? + osiop_read_1(sc, OSIOP_SFBR) : + osiop_read_4(sc, OSIOP_SCRATCH) & 0xff)) - 1; int reselun = osiop_read_1(sc, OSIOP_SFBR) & 0x07; #ifdef OSIOP_DEBUG u_int8_t resmsg; @@ -1565,8 +1763,7 @@ sc->sc_nexus = acb; sc->sc_flags |= acb->intstat; acb->intstat = 0; - osiop_write_4(sc, OSIOP_DSA, - dsdma->dm_segs[0].ds_addr + acb->dsoffset); + osiop_write_dsa(sc, acb); osiop_write_1(sc, OSIOP_SXFER, sc->sc_tinfo[reselid].sxfer); osiop_write_1(sc, OSIOP_SBCL, @@ -1617,8 +1814,7 @@ } target = sc->sc_nexus->xs->xs_periph->periph_target; osiop_write_4(sc, OSIOP_TEMP, 0); - osiop_write_4(sc, OSIOP_DSA, - dsdma->dm_segs[0].ds_addr + sc->sc_nexus->dsoffset); + osiop_write_dsa(sc, sc->sc_nexus); osiop_write_1(sc, OSIOP_SXFER, sc->sc_tinfo[target].sxfer); osiop_write_1(sc, OSIOP_SBCL, sc->sc_tinfo[target].sbcl); osiop_write_4(sc, OSIOP_DSP, scraddr + Ent_scripts); @@ -1683,7 +1879,8 @@ printf("osiop_chkintr: istat %x dstat %x sstat0 %x " "dsps %x dsa %x sbcl %x sts %x msg %x %x sfbr %x\n", istat, dstat, sstat0, intcode, - osiop_read_4(sc, OSIOP_DSA), + (sc->sc_rev == OSIOP_VARIANT_NCR53C700 + ? 0: osiop_read_4(sc, OSIOP_DSA)), osiop_read_1(sc, OSIOP_SBCL), ds->stat[0], ds->msgbuf[0], ds->msgbuf[1], osiop_read_1(sc, OSIOP_SFBR)); @@ -1810,7 +2007,8 @@ periph->periphtarget, osiop_read_1(sc, OSIOP_SBCL), osiop_read_1(sc, OSIOP_SFBR), - osiop_read_1(sc, OSIOP_LCRC), + (sc->sc_rev == OSIOP_VARIANT_NCR53C700 + ? 0 : osiop_read_1(sc, OSIOP_LCRC)), osiop_read_4(sc, OSIOP_DSP) - sc->sc_scrdma->dm_segs[0].ds_addr); } Index: sys/dev/ic/osiopreg.h =================================================================== RCS file: /cvsroot/syssrc/sys/dev/ic/osiopreg.h,v retrieving revision 1.1 diff -u -r1.1 osiopreg.h --- sys/dev/ic/osiopreg.h 2001/04/30 04:47:51 1.1 +++ sys/dev/ic/osiopreg.h 2002/11/14 16:25:04 @@ -108,9 +108,10 @@ #define OSIOP_DSPS 0x30 /* rw: DMA SCRIPTS Pointer Save reg */ +#define OSIOP_DMODE_53C700 (0x34+BL0) /* rw: DMA Mode reg */ #define OSIOP_SCRATCH 0x34 /* rw: Scratch register */ -#define OSIOP_DMODE (0x38+BL0) /* rw: DMA Mode reg */ +#define OSIOP_DMODE_53C710 (0x38+BL0) /* rw: DMA Mode reg */ #define OSIOP_DIEN (0x38+BL1) /* rw: DMA Interrupt Enable */ #define OSIOP_DWT (0x38+BL2) /* rw: DMA Watchdog Timer */ #define OSIOP_DCNTL (0x38+BL3) /* rw: DMA Control reg */ @@ -318,8 +319,10 @@ /* DMA FIFO register (dfifo) */ -#define OSIOP_DFIFO_FLF 0x80 /* Flush (spill) DMA FIFO */ -#define OSIOP_DFIFO_BO 0x7f /* FIFO byte offset counter */ +#define OSIOP_DFIFO_FLF 0x80 /* Flush (spill) DMA FIFO (53C700 only) */ +#define OSIOP_DFIFO_CLF 0x40 /* Clear DMA FIFO (53C700 only) */ +#define OSIOP_DFIFO_BO_53C710 0x7f /* FIFO byte offset counter */ +#define OSIOP_DFIFO_BO_53C700 0x3f /* FIFO byte offset counter */ /* Interrupt status register (istat) */ @@ -375,4 +378,5 @@ #define OSIOP_DCNTL_LLM 0x08 /* Enable SCSI Low-level mode */ #define OSIOP_DCNTL_STD 0x04 /* Start DMA operation */ #define OSIOP_DCNTL_FA 0x02 /* Fast arbitration */ -#define OSIOP_DCNTL_COM 0x01 /* 53C700 Compatibility */ +#define OSIOP_DCNTL_RST 0x01 /* Software reset (53C700 only) */ +#define OSIOP_DCNTL_COM 0x01 /* 53C700 Compatibility (53C710 only) */ Index: sys/dev/ic/osiopvar.h =================================================================== RCS file: /cvsroot/syssrc/sys/dev/ic/osiopvar.h,v retrieving revision 1.3 diff -u -r1.3 osiopvar.h --- sys/dev/ic/osiopvar.h 2002/05/14 02:58:35 1.3 +++ sys/dev/ic/osiopvar.h 2002/11/14 16:25:04 @@ -65,14 +65,18 @@ */ #define osiop_read_1(sc, reg) \ - bus_space_read_1((sc)->sc_bst, (sc)->sc_reg, reg) + bus_space_read_1((sc)->sc_bst, (sc)->sc_reg, reg ^ sc->sc_byteorder) #define osiop_write_1(sc, reg, val) \ - bus_space_write_1((sc)->sc_bst, (sc)->sc_reg, reg, val) + bus_space_write_1((sc)->sc_bst, (sc)->sc_reg, reg ^ sc->sc_byteorder, val) #define osiop_read_4(sc, reg) \ - bus_space_read_4((sc)->sc_bst, (sc)->sc_reg, reg) + (sc->sc_byteorder ? \ + bswap32(bus_space_read_4((sc)->sc_bst, (sc)->sc_reg, reg)) : \ + bus_space_read_4((sc)->sc_bst, (sc)->sc_reg, reg)) + #define osiop_write_4(sc, reg, val) \ - bus_space_write_4((sc)->sc_bst, (sc)->sc_reg, reg, val) + bus_space_write_4((sc)->sc_bst, (sc)->sc_reg, reg, \ + (sc->sc_byteorder ? bswap32(val) : val)) /* * The largest single request will be MAXPHYS bytes which will require @@ -222,6 +226,12 @@ int sc_clock_freq; int sc_tcp[4]; + int sc_rev; +#define OSIOP_VARIANT_NCR53C700 (0) +#define OSIOP_VARIANT_NCR53C710 (1) + bus_size_t sc_byteorder; +#define OSIOP_BYTEORDER_NATIVE (0x00) +#define OSIOP_BYTEORDER_NONNATIVE (0x03) int sc_flags; #define OSIOP_INTSOFF 0x80 /* Interrupts turned off */ #define OSIOP_INTDEFER 0x40 /* MD interrupt has been deferred */ Index: sys/kern/exec_elf_common.c =================================================================== RCS file: /cvsroot/syssrc/sys/kern/exec_elf_common.c,v retrieving revision 1.15 diff -u -r1.15 exec_elf_common.c --- sys/kern/exec_elf_common.c 2002/05/31 16:49:12 1.15 +++ sys/kern/exec_elf_common.c 2002/11/14 16:25:06 @@ -62,6 +62,9 @@ int exec_elf_setup_stack(struct proc *p, struct exec_package *epp) { + u_long max_stack_size; + u_long access_linear_min, access_size; + u_long noaccess_linear_min, noaccess_size; #ifndef USRSTACK32 #define USRSTACK32 (0x00000000ffffffffL&~PGOFSET) @@ -69,11 +72,13 @@ if (epp->ep_flags & EXEC_32) { epp->ep_minsaddr = USRSTACK32; - epp->ep_maxsaddr = epp->ep_minsaddr - MAXSSIZ; + max_stack_size = MAXSSIZ; } else { - epp->ep_maxsaddr = USRSTACK - MAXSSIZ; epp->ep_minsaddr = USRSTACK; + max_stack_size = MAXSSIZ; } + epp->ep_maxsaddr = (u_long)STACK_GROW(epp->ep_minsaddr, + max_stack_size); epp->ep_ssize = p->p_rlimit[RLIMIT_STACK].rlim_cur; /* @@ -83,15 +88,16 @@ * * arguably, it could be made into one, but that would require the * addition of another mapping proc, which is unnecessary - * - * note that in memory, things assumed to be: 0 ... ep_maxsaddr - * ep_minsaddr */ - NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, - ((epp->ep_minsaddr - epp->ep_ssize) - epp->ep_maxsaddr), - epp->ep_maxsaddr, NULLVP, 0, VM_PROT_NONE); - NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, epp->ep_ssize, - (epp->ep_minsaddr - epp->ep_ssize), NULLVP, 0, + access_size = epp->ep_ssize; + access_linear_min = (u_long)STACK_ALLOC(epp->ep_minsaddr, access_size); + noaccess_size = max_stack_size - access_size; + noaccess_linear_min = (u_long)STACK_ALLOC(STACK_GROW(epp->ep_minsaddr, + access_size), noaccess_size); + NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, noaccess_size, + noaccess_linear_min, NULLVP, 0, VM_PROT_NONE); + NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, access_size, + access_linear_min, NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE); return 0; Index: sys/kern/genassym.sh =================================================================== RCS file: /cvsroot/syssrc/sys/kern/genassym.sh,v retrieving revision 1.11 diff -u -r1.11 genassym.sh --- sys/kern/genassym.sh 2001/09/24 00:20:11 1.11 +++ sys/kern/genassym.sh 2002/11/14 16:25:06 @@ -107,7 +107,10 @@ } /^member[ \t]/ { - $0 = "define " $2 " offsetof(struct " structname ", " $2 ")"; + if (NF > 2) + $0 = "define " $2 " offsetof(struct " structname ", " $3 ")"; + else + $0 = "define " $2 " offsetof(struct " structname ", " $2 ")"; # fall through } Index: sys/kern/init_main.c =================================================================== RCS file: /cvsroot/syssrc/sys/kern/init_main.c,v retrieving revision 1.201 diff -u -r1.201 init_main.c --- sys/kern/init_main.c 2002/06/17 16:22:50 1.201 +++ sys/kern/init_main.c 2002/11/14 16:25:06 @@ -598,17 +598,17 @@ /* * Need just enough stack to hold the faked-up "execve()" arguments. */ - addr = USRSTACK - PAGE_SIZE; + addr = (vaddr_t)STACK_ALLOC(USRSTACK, PAGE_SIZE); if (uvm_map(&p->p_vmspace->vm_map, &addr, PAGE_SIZE, NULL, UVM_UNKNOWN_OFFSET, 0, UVM_MAPFLAG(UVM_PROT_ALL, UVM_PROT_ALL, UVM_INH_COPY, UVM_ADV_NORMAL, UVM_FLAG_FIXED|UVM_FLAG_OVERLAY|UVM_FLAG_COPYONW)) != 0) panic("init: couldn't allocate argument space"); - p->p_vmspace->vm_maxsaddr = (caddr_t)addr; + p->p_vmspace->vm_maxsaddr = (caddr_t)STACK_MAX(addr, PAGE_SIZE); for (pathp = &initpaths[0]; (path = *pathp) != NULL; pathp++) { - ucp = (char *)(addr + PAGE_SIZE); + ucp = (char *)USRSTACK; /* * Construct the boot flag argument. @@ -637,8 +637,9 @@ #ifdef DEBUG printf("init: copying out flags `%s' %d\n", flags, i); #endif - (void)copyout((caddr_t)flags, (caddr_t)(ucp -= i), i); - arg1 = ucp; + arg1 = STACK_ALLOC(ucp, i); + ucp = STACK_MAX(arg1, i); + (void)copyout((caddr_t)flags, arg1, i); } /* @@ -648,29 +649,27 @@ #ifdef DEBUG printf("init: copying out path `%s' %d\n", path, i); #endif - (void)copyout((caddr_t)path, (caddr_t)(ucp -= i), i); - arg0 = ucp; + arg0 = STACK_ALLOC(ucp, i); + ucp = STACK_MAX(arg0, i); + (void)copyout((caddr_t)path, arg0, i); /* * Move out the arg pointers. */ - uap = (char **)((long)ucp & ~ALIGNBYTES); - (void)suword((caddr_t)--uap, 0); /* terminator */ - if (options != 0) - (void)suword((caddr_t)--uap, (long)arg1); + ucp = (caddr_t)STACK_ALIGN(ucp, ALIGNBYTES); + uap = (char **)STACK_ALLOC(ucp, sizeof(char *) * 3); + SCARG(&args, path) = arg0; + SCARG(&args, argp) = uap; + SCARG(&args, envp) = NULL; slash = strrchr(path, '/'); if (slash) - (void)suword((caddr_t)--uap, + (void)suword((caddr_t)uap++, (long)arg0 + (slash + 1 - path)); else - (void)suword((caddr_t)--uap, (long)arg0); - - /* - * Point at the arguments. - */ - SCARG(&args, path) = arg0; - SCARG(&args, argp) = uap; - SCARG(&args, envp) = NULL; + (void)suword((caddr_t)uap++, (long)arg0); + if (options != 0) + (void)suword((caddr_t)uap++, (long)arg1); + (void)suword((caddr_t)uap++, 0); /* terminator */ /* * Now try to exec the program. If can't for any reason Index: sys/kern/kern_exec.c =================================================================== RCS file: /cvsroot/syssrc/sys/kern/kern_exec.c,v retrieving revision 1.152 diff -u -r1.152 kern_exec.c --- sys/kern/kern_exec.c 2002/04/23 15:11:25 1.152 +++ sys/kern/kern_exec.c 2002/11/14 16:25:07 @@ -545,7 +545,36 @@ arginfo.ps_nargvstr = argc; arginfo.ps_nenvstr = envc; - stack = (char *) (vm->vm_minsaddr - len); + stack = (char *)STACK_ALLOC(STACK_GROW(vm->vm_minsaddr, + sizeof(struct ps_strings) + szsigcode), + len - (sizeof(struct ps_strings) + szsigcode)); +#ifdef __MACHINE_STACK_GROWS_UP + /* + * The copyargs call always copies into lower addresses + * first, moving towards higher addresses, starting with + * the stack pointer that we give. When the stack grows + * down, this puts argc/argv/envp very shallow on the + * stack, right at the first user stack pointer, and puts + * STACKGAPLEN very deep in the stack. When the stack + * grows up, the situation is reversed. + * + * Normally, this is no big deal. But the ld_elf.so _rtld() + * function expects to be called with a single pointer to + * a region that has a few words it can stash values into, + * followed by argc/argv/envp. When the stack grows down, + * it's easy to decrement the stack pointer a little bit to + * allocate the space for these few words and pass the new + * stack pointer to _rtld. When the stack grows up, however, + * a few words before argc is part of the signal trampoline, + * so we have a problem. + * + * Instead of changing how _rtld works, we take the easy way + * out and steal 32 bytes before we call copyargs. This + * space is effectively stolen from STACKGAPLEN. + */ + stack += 32; +#endif /* __MACHINE_STACK_GROWS_UP */ + /* Now copy argc, args & environ to new stack */ error = (*pack.ep_es->es_copyargs)(&pack, &arginfo, &stack, argp); if (error) { @@ -553,11 +582,11 @@ goto exec_abort; } /* Move the stack back to original point */ - stack = (char *) (vm->vm_minsaddr - len); + stack = (char *)STACK_GROW(vm->vm_minsaddr, len); /* fill process ps_strings info */ - p->p_psstr = (struct ps_strings *)(vm->vm_minsaddr - - sizeof(struct ps_strings)); + p->p_psstr = (struct ps_strings *)STACK_ALLOC(vm->vm_minsaddr, + sizeof(struct ps_strings)); p->p_psargv = offsetof(struct ps_strings, ps_argvstr); p->p_psnargv = offsetof(struct ps_strings, ps_nargvstr); p->p_psenv = offsetof(struct ps_strings, ps_envstr); @@ -573,9 +602,10 @@ /* copy out the process's signal trapoline code */ if (szsigcode) { + p->p_sigctx.ps_sigcode = STACK_ALLOC(STACK_MAX(p->p_psstr, + sizeof(struct ps_strings)), szsigcode); if ((error = copyout((char *)pack.ep_es->es_emul->e_sigcode, - p->p_sigctx.ps_sigcode = (char *)p->p_psstr - szsigcode, - szsigcode)) != 0) { + p->p_sigctx.ps_sigcode, szsigcode)) != 0) { DPRINTF(("execve: sig trampoline copyout failed\n")); goto exec_abort; } Index: sys/sys/cdefs_elf.h =================================================================== RCS file: /cvsroot/syssrc/sys/sys/cdefs_elf.h,v retrieving revision 1.11 diff -u -r1.11 cdefs_elf.h --- sys/sys/cdefs_elf.h 2002/01/27 07:19:25 1.11 +++ sys/sys/cdefs_elf.h 2002/11/14 16:25:08 @@ -38,6 +38,14 @@ #define _C_LABEL_STRING(x) x #endif +#ifdef __ASM_DELIMITER +#ifndef __STDC__ +#error "__ASM_DELIMITER needs __STDC__" +#endif +#else +#define __ASM_DELIMITER " ; " +#endif + #if __STDC__ #define ___RENAME(x) __asm__(___STRING(_C_LABEL(x))) #else @@ -59,13 +67,13 @@ #ifndef __DO_NOT_DO_WEAK__ #define __weak_alias(alias,sym) \ - __asm__(".weak " _C_LABEL_STRING(#alias) " ; " \ + __asm__(".weak " _C_LABEL_STRING(#alias) __ASM_DELIMITER \ _C_LABEL_STRING(#alias) " = " _C_LABEL_STRING(#sym)); #endif /* !__DO_NOT_DO_WEAK__ */ #define __weak_extern(sym) \ __asm__(".weak " _C_LABEL_STRING(#sym)); #define __warn_references(sym,msg) \ - __asm__(".section .gnu.warning." #sym " ; .ascii \"" msg "\" ; .text"); + __asm__(".section .gnu.warning." #sym __ASM_DELIMITER ".ascii \"" msg "\"" __ASM_DELIMITER ".text"); #else /* !__STDC__ */ @@ -94,7 +102,7 @@ #if __STDC__ #define __SECTIONSTRING(_sec, _str) \ - __asm__(".section " #_sec " ; .asciz \"" _str "\" ; .text") + __asm__(".section " #_sec __ASM_DELIMITER ".asciz \"" _str "\"" __ASM_DELIMITER ".text") #else #define __SECTIONSTRING(_sec, _str) \ __asm__(".section _sec ; .asciz _str ; .text") Index: sys/sys/param.h =================================================================== RCS file: /cvsroot/syssrc/sys/sys/param.h,v retrieving revision 1.143 diff -u -r1.143 param.h --- sys/sys/param.h 2002/07/06 01:31:33 1.143 +++ sys/sys/param.h 2002/11/14 16:25:08 @@ -145,6 +145,37 @@ #include /* + * Stack macros. On most architectures, the stack grows down, + * towards lower addresses; it is the rare architecture where + * it grows up, towards higher addresses. + * + * STACK_GROW and STACK_SHRINK adjust a stack pointer by some + * size, no questions asked. STACK_ALIGN aligns a stack pointer. + * + * STACK_ALLOC returns a pointer to allocated stack space of + * some size; given such a pointer and a size, STACK_MAX gives + * the maximum (in the "maxsaddr" sense) stack address of the + * allocated memory. + */ +#ifdef _KERNEL +#ifdef __MACHINE_STACK_GROWS_UP +#define STACK_GROW(sp, _size) (((caddr_t)(sp)) + (_size)) +#define STACK_SHRINK(sp, _size) (((caddr_t)(sp)) - (_size)) +#define STACK_ALIGN(sp, bytes) \ + ((caddr_t)((((unsigned long)(sp)) + (bytes)) & ~(bytes))) +#define STACK_ALLOC(sp, _size) ((caddr_t)(sp)) +#define STACK_MAX(p, _size) (((caddr_t)(p)) + (_size)) +#else +#define STACK_GROW(sp, _size) (((caddr_t)(sp)) - (_size)) +#define STACK_SHRINK(sp, _size) (((caddr_t)(sp)) + (_size)) +#define STACK_ALIGN(sp, bytes) \ + ((caddr_t)(((unsigned long)(sp)) & ~(bytes))) +#define STACK_ALLOC(sp, _size) (((caddr_t)(sp)) - (_size)) +#define STACK_MAX(p, _size) ((caddr_t)(p)) +#endif +#endif /* _KERNEL */ + +/* * Priorities. Note that with 32 run queues, differences less than 4 are * insignificant. */ Index: sys/ufs/ext2fs/ext2fs_subr.c =================================================================== RCS file: /cvsroot/syssrc/sys/ufs/ext2fs/ext2fs_subr.c,v retrieving revision 1.6 diff -u -r1.6 ext2fs_subr.c --- sys/ufs/ext2fs/ext2fs_subr.c 2001/11/08 02:39:07 1.6 +++ sys/ufs/ext2fs/ext2fs_subr.c 2002/11/14 16:25:09 @@ -112,7 +112,7 @@ vprint("Disk overlap", vp); printf("\tstart %d, end %d overlap start %d, end %ld\n", start, last, ep->b_blkno, - ep->b_blkno + btodb(ep->b_bcount) - 1); + (long) ep->b_blkno + btodb(ep->b_bcount) - 1); panic("Disk buffer overlap"); } }