Index: Makefile =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/Makefile,v retrieving revision 1.11 diff -u -r1.11 Makefile --- Makefile 2001/03/07 02:08:40 1.11 +++ Makefile 2001/06/14 22:23:43 @@ -19,7 +19,7 @@ HOSTCC = gcc HOSTCFLAGS = -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -CROSS_COMPILE = /usr/local/bin/vax-dec-linux- +CROSS_COMPILE = /usr/local/vax-tools/bin/vax-dec-linux- # # Include the make variables (CC, etc...) Index: Rules.make =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/Rules.make,v retrieving revision 1.3 diff -u -r1.3 Rules.make --- Rules.make 2001/03/04 23:42:52 1.3 +++ Rules.make 2001/06/14 22:23:44 @@ -52,9 +52,9 @@ %.i: %.c $(CPP) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) $< > $@ - +#$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -c -o $@ $< -Wa,-adnhls=$*.lst -g %.o: %.c - $(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -c -o $@ $< -Wa,-adnhls=$*.lst -g + $(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -c -o $@ $< -g @ ( \ echo 'ifeq ($(strip $(subst $(comma),:,$(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@))),$$(strip $$(subst $$(comma),:,$$(CFLAGS) $$(EXTRA_CFLAGS) $$(CFLAGS_$@))))' ; \ echo 'FILES_FLAGS_UP_TO_DATE += $@' ; \ Index: Documentation/vax/process.txt =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/Documentation/vax/process.txt,v retrieving revision 1.1 diff -u -r1.1 process.txt --- Documentation/vax/process.txt 2001/06/10 16:07:58 1.1 +++ Documentation/vax/process.txt 2001/06/14 22:23:46 @@ -8,7 +8,7 @@ The P0 space goes from 0 -> 0x40000000 P1 space goes from 0x40000000 -> 0x80000000 -We currently allocate 48MB of memory per process, similiar to the NetBSD schemx. +We currently allocate 48MB of memory per process, similiar to the NetBSD scheme NetBSD allocate as follows, Index: arch/vax/boot/mmstart.S =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/boot/mmstart.S,v retrieving revision 1.1 diff -u -r1.1 mmstart.S --- arch/vax/boot/mmstart.S 2001/01/17 16:13:57 1.1 +++ arch/vax/boot/mmstart.S 2001/06/14 22:23:49 @@ -61,6 +61,7 @@ mtpr $0, $PR_TBIA # clear translation buffer mtpr $1, $PR_MAPEN # switch on mm. + jmp (r6) halt vreloc: # made it. now fixup sp fp and stack frame @@ -68,6 +69,7 @@ mtpr $PAGE_OFFSET, $PR_P0BR # Clear out P0BR, P0LR - do not mtpr $0, $PR_P0LR # need them anymore + mtpr $0, $PR_TBIA # clear translation buffer ret .globl PK_str1 Index: arch/vax/boot/tmp_init.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/boot/tmp_init.c,v retrieving revision 1.9 diff -u -r1.9 tmp_init.c --- arch/vax/boot/tmp_init.c 2001/03/04 23:45:50 1.9 +++ arch/vax/boot/tmp_init.c 2001/06/14 22:23:50 @@ -28,6 +28,7 @@ #include #include #include +#include #include @@ -119,6 +120,18 @@ in post_vm_init(). Otherwise, implement mv->console_init() which will be called later. */ + + /* Stick some sane values in these */ + swapper_pg_dir[0].br=PAGE_OFFSET; + swapper_pg_dir[0].lr=0; + swapper_pg_dir[1].br=PAGE_OFFSET; + swapper_pg_dir[1].lr=0x40000; + + __mtpr(swapper_pg_dir[0].br, PR_P0BR ); + __mtpr(swapper_pg_dir[0].lr * 8, PR_P0LR ); + __mtpr(swapper_pg_dir[1].br, PR_P1BR ); + __mtpr(swapper_pg_dir[1].lr * 8, PR_P1LR ); + mv->post_vm_init(); #ifdef __SMP__ @@ -143,6 +156,7 @@ printk("CPU type: %s, SID: %08x\n", mv->cpu_type_str(), vax_cpu.sid); printk("calling start_kernel...\n"); + flush_tlb(); start_kernel(); } Index: arch/vax/kernel/cpu_ka42.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/kernel/cpu_ka42.c,v retrieving revision 1.4 diff -u -r1.4 cpu_ka42.c --- arch/vax/kernel/cpu_ka42.c 2001/02/22 22:36:42 1.4 +++ arch/vax/kernel/cpu_ka42.c 2001/06/14 22:23:50 @@ -58,17 +58,29 @@ mv_ka42.sidex = *(unsigned int *)CVAX_SIDEX_ADDR; } -void ka42_post_vm_init(void) -{ #define KA42_CADR_S2E 0x80 #define KA42_CADR_S1E 0x40 #define KA42_CADR_ISE 0x20 #define KA42_CADR_DSE 0x10 - __mtpr(KA42_CADR_S2E|KA42_CADR_S1E|KA42_CADR_ISE|KA42_CADR_DSE, PR_CADR); + +#define PARCTL_CPEN 2 +#define PARCTL_DPEN 1 + +void ka42_post_vm_init(void) +{ + struct vs_cpu *ka42_cpu; + + ka42_cpu=(struct vs_cpu *)ioremap(VSA_BASE_REGS, 128); + ka42_cpu->vc_vdcorg=0; + ka42_cpu->vc_parctl=PARCTL_CPEN | PARCTL_DPEN; + + iounmap((void *)ka42_cpu); + + __mtpr(KA42_CADR_S2E|KA42_CADR_S1E|KA42_CADR_ISE|KA42_CADR_DSE, PR_CADR); - init_dz11_console(0x200A0000, 3); + init_dz11_console(0x200A0000, 3); - dz_serial_console_init(0, 0); + dz_serial_console_init(0, 0); } void ka42_init_devices(void) Index: arch/vax/kernel/entry.S =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/kernel/entry.S,v retrieving revision 1.4 diff -u -r1.4 entry.S --- arch/vax/kernel/entry.S 2001/05/27 12:34:13 1.4 +++ arch/vax/kernel/entry.S 2001/06/14 22:23:51 @@ -128,7 +128,7 @@ /* Restore registers R1 up to FP */ popr $0x3ffe - /* The stack now looks like: + /* The stack now looks like: SP: saved SP for previous mode +4 saved PC (maybe modified by exception handler) @@ -139,13 +139,14 @@ ... saved PC (original saved by CPU) saved PSL */ - + /* Copy duplicate saved PC (part of the struct pt_regs) down over the original saved PC saved by the CPU. This allows the exception handlers to change the PC of the code that triggered the exception. This is tricky because of the exception info that may be present on the stack. First get the size of the exception info into R0 */ movl *16(sp), r0 + /* Now move the saved PC down over the original (the 20-byte offset takes care of skipping over the top 5 items on the stack, and then Index: arch/vax/kernel/interrupt.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/kernel/interrupt.c,v retrieving revision 1.11 diff -u -r1.11 interrupt.c --- arch/vax/kernel/interrupt.c 2001/05/27 13:25:29 1.11 +++ arch/vax/kernel/interrupt.c 2001/06/14 22:23:52 @@ -216,15 +216,18 @@ offsetof(struct stray_handler, flags)); vec_num = handler - stray_handlers; + if (autoprobing && vec_num >= FIRST_ADAPTER_VECTOR) { + // printk("\nAutoprobing 0x%04x (SCB offset 0x%04x)\n", vec_num, vec_num*4); stray_handlers[vec_num].flags |= STRAY_EXCEPTION_FIRED; return 0; } printk("\nUnhandled interrupt or exception number 0x%04x (SCB offset 0x%04x)\n", vec_num, vec_num*4); - +/* return 0;*/ +#if 1 printk("\nStack dump:\n"); dump_stack(DUMP_STACK_CALLER); @@ -232,6 +235,7 @@ show_cpu_regs(); machine_halt(); +#endif } @@ -539,7 +543,7 @@ int i; int flags; - save_and_cli(flags); + save_and_cli(flags); for (i=FIRST_ADAPTER_VECTOR; i #include #include - #include #include @@ -162,7 +161,7 @@ pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) { - asm(" clrl -(sp) \n + asm(" clrl -(sp) \n movl %0, -(sp) \n pushl $0x2 \n movl sp, ap \n Index: arch/vax/kernel/setup.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/kernel/setup.c,v retrieving revision 1.7 diff -u -r1.7 setup.c --- arch/vax/kernel/setup.c 2001/02/21 00:20:30 1.7 +++ arch/vax/kernel/setup.c 2001/06/14 22:23:54 @@ -19,7 +19,7 @@ #include #include #include - +#include #define COMMAND_LINE_SIZE 256 static char command_line[COMMAND_LINE_SIZE]; @@ -64,7 +64,7 @@ * atp -- have a temporary one. * Shouldn't we use strcpy here? */ - memcpy(command_line, "root=/dev/nfs nfsroot=/tftpboot/vaxroot\0",54); + memcpy(command_line, "root=/dev/nfs rw nfsroot=/tftpboot/vaxroot console=/dev/ttyS1\0",60); *cmdline_p = command_line; /* Save unparsed command line copy for /proc/cmdline */ memcpy(saved_command_line, command_line, COMMAND_LINE_SIZE); @@ -118,7 +118,9 @@ /* No root filesystem yet */ ROOT_DEV = NODEV; - + /* Inserted by D.A. - 8 Jun 2001 - THIS IS NECESSARY + if not correct */ + flush_tlb(); /* * Identify the flock of penguins. */ Index: arch/vax/kernel/syscall.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/kernel/syscall.c,v retrieving revision 1.3 diff -u -r1.3 syscall.c --- arch/vax/kernel/syscall.c 2001/01/29 00:58:54 1.3 +++ arch/vax/kernel/syscall.c 2001/06/14 22:23:54 @@ -27,6 +27,7 @@ #include "interrupt.h" /* Local, private definitions */ +/*#define VAX_DEBUG_SYSCALL 0*/ /* This is the handler for the CHMK (change mode to kernel) trap. Later we'll probably re-write this in asm. */ @@ -40,6 +41,7 @@ chmk_arg = *(unsigned int *)(excep_info); + if (chmk_arg >= NR_syscalls) { regs->r0 = -ENOSYS; return; @@ -50,7 +52,9 @@ if (regs->psl.prevmode == PSL_MODE_USER) { /* syscall came from user mode */ - +#ifdef VAX_DEBUG_SYSCALL + printk("Dispatching syscall from user %d %8lX %8lX %8lX\n", chmk_arg, user_ap, regs->sp, __mfpr(PR_USP)); +#endif if (user_ap >= (unsigned int *)0x80000000) { regs->r0 = -EFAULT; return; @@ -60,12 +64,13 @@ reaches up into S0 space because we've got a guard page at 0x80000000 that will cause an exception in the movc3 below that copies the argument list */ - if (get_user(nr_args, user_ap)) { regs->r0 = -EFAULT; return; } - +#ifdef VAX_DEBUG_SYSCALL + printk("after get_user %d\n", nr_args); +#endif /* The SP value in the pt_regs structure should really be the user stack pointer, not the kernel stack pointer */ regs->sp = __mfpr(PR_USP); @@ -76,10 +81,11 @@ any access checks */ nr_args = *user_ap; +#ifdef VAX_DEBUG_SYSCALL + printk("Dispatching syscall from kernel %d args %d\n", chmk_arg, nr_args); +#endif } -/* printk("Dispatching syscall %d with %d args\n", chmk_arg, nr_args); */ - /* We pass all the user-supplied args plus the pointer to the regs to the syscall function. If the syscall is implemented in the core kernel, then it will ignore the additional @@ -114,8 +120,9 @@ "g"(*sys_call_table[chmk_arg]), "g"(-EFAULT) : "r0","r1","r2","r3","r4","r5" /* clobbers*/ ); - -/* printk("syscall %d returned %ld (0x%08lx)\n", chmk_arg, regs->r0, regs->r0); */ +#ifdef VAX_DEBUG_SYSCALL + printk("syscall %d returned %ld (0x%08lx)\n", chmk_arg, regs->r0, regs->r0); +#endif return; } @@ -227,6 +234,7 @@ struct file * file = NULL; unsigned long error = -EFAULT; + // printk("sys_mmap, %8lX, sz:%d, prot:%d flags:%d fd:%d offset:%d\n", addr, len, prot,flags, fd, offset); lock_kernel(); if (!(flags & MAP_ANONYMOUS)) { error = -EBADF; Index: arch/vax/mm/fault.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/mm/fault.c,v retrieving revision 1.5 diff -u -r1.5 fault.c --- arch/vax/mm/fault.c 2001/05/20 13:25:11 1.5 +++ arch/vax/mm/fault.c 2001/06/14 22:23:55 @@ -56,7 +56,8 @@ struct mm_struct *mm = NULL; unsigned fixup; - printk("mmfault: fault at %8X\n", address); + printk("mmfault: fault in pid %d at %8lX %d %8lX\n",tsk->pid, address, reason, regs->pc); + // printk("mmfault: P0BR %8X, P0LR %8X P1BR %8X, P1LR %8X\n", __mfpr(PR_P0BR), __mfpr(PR_P0LR),__mfpr(PR_P1BR), __mfpr(PR_P1LR)); /* This check, and the mm != NULL checks later, will be removed later, once we actually have a 'current' properly defined */ if (tsk != NULL) { @@ -110,7 +111,7 @@ up(&mm->mmap_sem); if (user_mode(regs)) { - printk("do_page_fault: sending SIGSEGV\n"); + // printk("do_page_fault: sending SIGSEGV\n"); force_sig(SIGSEGV, current); return; } @@ -119,6 +120,7 @@ /* Are we prepared to handle this fault as an exception? */ if ((fixup = search_exception_table(regs->pc)) != 0) { regs->pc = fixup; + printk("got no context return\n"); return; } @@ -147,6 +149,7 @@ { current->policy |= SCHED_YIELD; schedule(); + printk("going to survive\n"); goto survive; } up(&mm->mmap_sem); @@ -213,9 +216,9 @@ accvios in the page fault handler. It will have to go eventually as it's not SMP safe */ if (!active) { - /* active = 1;*/ + active = 1; do_page_fault(info, regs); - printk("finished fault\n"); + // printk("finished fault\n"); active = 0; } else { Index: arch/vax/mm/init.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/mm/init.c,v retrieving revision 1.10 diff -u -r1.10 init.c --- arch/vax/mm/init.c 2001/05/27 13:20:30 1.10 +++ arch/vax/mm/init.c 2001/06/14 22:23:55 @@ -68,6 +68,8 @@ #define kill_page(pg) #endif +extern unsigned long vmallocmap_base; + void mem_init(void) { max_mapnr = num_physpages = max_low_pfn; @@ -75,10 +77,11 @@ /* this will put all low memory onto the freelists */ totalram_pages += free_all_bootmem(); high_memory = (void *) __va((max_low_pfn) * PAGE_SIZE); - + printk("max low pfn is %8lX\n", max_low_pfn << PAGE_SHIFT); + printk("VMALLOC_START is %p\n", VMALLOC_START); + printk("vmallocmap_base is %8lX, sbr %8lX, diff %8lX\n", vmallocmap_base, swapper_pg_dir[2].br, (vmallocmap_base-swapper_pg_dir[2].br)<<(PAGELET_SHIFT-2)); printk("Memory: %luk/%luk available\n", (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), max_mapnr << (PAGE_SHIFT-10)); - return; } @@ -134,7 +137,8 @@ } return NULL; } - +extern unsigned long vmallocmap_base; +extern unsigned long vmallocmap_end; /* remap a given page to be part of a contiguous page table for p0/1 space */ void remap_and_clear_pte_page(pgd_t *pagetable, pte_t *page, unsigned long pte_page) { @@ -146,24 +150,29 @@ /* address in S0 space is page pointer */ /* find the entry in the SPTE corresponding to this page */ - S0pte = (pte_t *)((__pa(page) >> PAGELET_SHIFT)+sys_pgd->br); - printk("remap: virt addr %p, pteval %8lX , S0pte %p, %8lX\n", page, pte_val(*page), S0pte, pte_val(*S0pte)); + page_physical_address=__pa(page); + S0pte = pte_offset(sys_pgd, page_physical_address); + // S0pte = (pte_t *)((__pa(page) >> PAGE_SHIFT)+sys_pgd->br); + // printk("remap: virt addr %8lX, %8lX, %8lX, S0pte %p, %8lX\n", vmallocmap_base, (unsigned long)page, ((unsigned long)S0pte)-vmallocmap_base, S0pte, pte_val(*S0pte)); if (!pte_present(*S0pte)) { - unsigned long phy_addr; pgd_t *ret = (pgd_t *)__get_free_page(GFP_KERNEL); /* we have address in S0 of free page */ /* need to remap this free page to the address in S0 where we are */ /* Get the phy address of the page */ //spte = pte_offset(sys_pgd, ((unsigned long)ret - PAGE_OFFSET)); - clear_page((void *)ret); + + clear_page(ret); pte_clear(S0pte); + tpte = __mk_pte((void *)ret, (pgprot_t)PAGE_KERNEL); set_pte(S0pte, tpte); /* grab a free page */ + flush_tlb(); printk("S0 page invalid, %p %8lX\n", ret, pte_val(tpte)); + return; } /* zero out these pte's */ Index: arch/vax/mm/ioremap.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/arch/vax/mm/ioremap.c,v retrieving revision 1.5 diff -u -r1.5 ioremap.c --- arch/vax/mm/ioremap.c 2001/05/19 12:03:00 1.5 +++ arch/vax/mm/ioremap.c 2001/06/14 22:23:56 @@ -125,7 +125,7 @@ __flush_tlb_one(virt_start + (i< @@ -14,7 +16,7 @@ { /* P0BR and P1BR are virtual addresses */ tsk->thread.pcb.p0br = (pgdir[0]).br; - tsk->thread.pcb.p0lr = (pgdir[0]).lr * 8; + tsk->thread.pcb.p0lr = (pgdir[0]).lr * 8 | 0x04000000; tsk->thread.pcb.p1br = (pgdir[1]).br; tsk->thread.pcb.p1lr = (pgdir[1]).lr * 8; @@ -53,5 +55,147 @@ } while(pgtable_cache_size > low); } return freed; + +} + +#if 0 +/* Need to alloc a pte from the vmallocmap for the address given, + as the vmallocmap is in the SPTE we need to locate the correct + entry in the map and allocate it */ +pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address) +{ + unsigned long pte_number, pte_page, pte_page_offset; + pte_t *p; + pgd_t *pgdptr = (pgd_t *)pmd; + pte_t *page; + + pte_number = (address >> PAGE_SHIFT); + pte_page = (pte_number >> SIZEOF_PTR_LOG2); + pte_page_offset = pte_number & (PTRS_PER_PTE - 1); + + printk("Got pte_alloc_kernel called %8X %8X\n", pte_number, pte_page); + printk("pgdptr lr %8X, br %8X\n", pgdptr->lr, pgdptr->br); + + if ((pte_number) < (pgdptr->lr>>3)) { + printk("Returning %8X \n", pte_offset(pmd, address); + return pte_offset(pmd, address); + // return (pte_t *) (pgdptr->br + pte_number*BYTES_PER_PTE_T); + } + else return NULL; } +pte_t * pte_alloc(pmd_t * pmd, unsigned long address) +{ + /* calculate the offset of the requested pte in this pagetable page */ + unsigned long pte_number, pte_page, pte_page_offset; + pgd_t *pgdptr = (pgd_t *)pmd; + pte_t *newpte= NULL; + + printk("Got pte_alloc called %8lX, pgd br %8lX, lr %8lX\n", address, pgdptr->lr, pgdptr->br); + if (address < 0x40000000) + { + pte_number = (address >> PAGE_SHIFT); + pte_page = (pte_number >> SIZEOF_PTE_LOG2); + pte_page_offset = pte_number & (PTRS_PER_PTE - 1); + if ((pte_number) < (pgdptr->lr)) { + newpte = (pte_t *) (pgdptr->br + pte_number*BYTES_PER_PTE_T); + } + } + else + { + address-=0x40000000; + pte_number = (address>>PAGE_SHIFT); + pte_page = (pte_number >> SIZEOF_PTE_LOG2); + pte_page_offset = pte_number & (PTRS_PER_PTE - 1); + printk("pte_number %8lX, pte_page %8lX, pte_pg_off %8lX\n", pte_number, pte_page, pte_page_offset); + if ((pte_number) > (pgdptr->lr)) { + newpte = pte_offset(pmd, address); + // newpte = (pte_t *) (pgdptr->br + pte_number*BYTES_PER_PTE_T); + } + + } + + if (newpte) + { + printk("pte_alloc newpte has %p\n", pte_val(*newpte)); + pte_clear(newpte); + printk("pte_alloc returning %8lX\n", newpte); + /* make sure a page in S0 space is mapped */ + remap_and_clear_pte_page((pgd_t *)pmd, newpte, pte_page); + } + return newpte; + +#if 0 + /* do we have a pgd base and length set ? */ + /* The p0br and p1br should be setup at process initialisation. */ + + if (pmd_none(*pmd)) { + + return NULL; + } + + /* do we need to allocate another page(s) */ + + + /* this is already inside the page table region, and allocated */ + /* return the virtual address of the pte. (base registers for p0 and p1 */ + /* refer to virtual addresses in S0 space) so no _va() is needed */ + + + + /* The address lies outside the current page table - by how much?*/ + /* FIXME: Maximum task size, defined by max p0 pagetable size */ + /* number of pages to allocate */ + t2 = ((pte_number - pgdptr->lr) >> SIZEOF_PTE_LOG2) + 1 ; + + while (t2--) { + /* grab a page off the quicklist */ + page = get_pte_fast(); + /* or allocate a new one if none left */ + if (!page) page = get_pte_slow(pmd, address); + + /* run out of pages - out of memory */ + /* FIXME: is there anything else we need to do to signal failure?*/ + if (!page) { + printk("%s:%d: run out of free pages building page table at pte %08lx.\n", __FILE__, __LINE__, pgdptr->lr); + return NULL; + } + /* map this page into the S0 page table at the right point */ + // remap_and_clear_pte_page((pgd_t *)pmd, page, pte_page); + + /* add this page of PTEs to the length register */ + /* FIXME: handle reverse P1 region... */ + pgdptr->lr += PTRS_PER_PTE; + } + return (pte_t *)( pgdptr->br + pte_number*BYTES_PER_PTE_T); +#endif +} + +extern pgd_t *get_pgd_slow(void) +{ + /* + * this is rather wasteful, as only 6 longwords are + * used in the entire 4kb page. Perhaps we can do something + * smarter here by using the quicklists to pack the pgds into + * a single page. + */ + pgd_t *ret = (pgd_t *)__get_free_page(GFP_KERNEL); + + if (ret) { + /* Allocate space for the p0/p1 page tables */ + /* allocate 192 pages at 4096 bytes each for page tables? */ + ret[0].br = (unsigned long)vmalloc(192 * PAGE_SIZE); + ret[0].lr = ((160*PAGE_SIZE)>>SIZEOF_PTE_LOG2); + /* the p1br needs to be set back from the end of the p1 ptes */ + ret[1].br = (ret[0].br - 0x800000) + (192*PAGE_SIZE); + ret[1].lr = 0x40000-((32*PAGE_SIZE)>>SIZEOF_PTE_LOG2); + printk("get_pgd: p0: %8lX, %8lX, p1: %8lX, %8lx\n", ret[0].br, ret[0].lr, ret[1].br, ret[1].lr); + + /* set p0 and p1 regions to empty values */ + //memset(ret, 0, USER_PTRS_PER_PGD * sizeof(pgd_t)); + /* set the s0 region, from the master copy in swapper_pg_dir */ + memcpy(ret + USER_PTRS_PER_PGD, swapper_pg_dir + USER_PTRS_PER_PGD, (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t)); + } + return ret; +} +#endif Index: drivers/char/tty_io.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/drivers/char/tty_io.c,v retrieving revision 1.4 diff -u -r1.4 tty_io.c --- drivers/char/tty_io.c 2001/02/26 02:28:27 1.4 +++ drivers/char/tty_io.c 2001/06/14 22:24:02 @@ -1310,7 +1310,9 @@ if (device == SYSCONS_DEV) { struct console *c = console_drivers; while(c && !c->device) - c = c->next; + { + c = c->next; + } if (!c) return -ENODEV; device = c->device(c); Index: drivers/net/vaxlance.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/drivers/net/vaxlance.c,v retrieving revision 1.10 diff -u -r1.10 vaxlance.c --- drivers/net/vaxlance.c 2001/03/07 02:15:34 1.10 +++ drivers/net/vaxlance.c 2001/06/14 22:24:07 @@ -1028,6 +1028,9 @@ iounmap(esar); lp->vsbus_int=5; +#ifdef CONFIG_VSBUS +/* vsbus_probe_irq_on();*/ +#endif #ifdef VAX_LANCE_AUTOPROBE_IRQ @@ -1038,6 +1041,12 @@ lance_stop(ll); + writereg(&ll->rap, LE_CSR0); + writereg(&ll->rdp, LE_C0_INEA|LE_C0_INIT); +#ifdef CONFIG_VSBUS + /*lp->vsbus_int=vsbus_probe_irq_report();*/ +#endif + /* Shouldn't we really load CSR1/2 with the address of a reasonable init block, just in case the LANCE goes and does something wild with whatever garbage it's currently Index: drivers/vsbus/vsbus.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/drivers/vsbus/vsbus.c,v retrieving revision 1.3 diff -u -r1.3 vsbus.c --- drivers/vsbus/vsbus.c 2001/02/26 11:31:35 1.3 +++ drivers/vsbus/vsbus.c 2001/06/14 22:24:10 @@ -8,6 +8,8 @@ */ #include #include +#include +#include struct vsbus { struct vs_cpu *vs_cpu_ptr; @@ -17,10 +19,22 @@ int vsbus_setup(void) { + unsigned long irqs; + sys_vs.vs_cpu_ptr=(void *)ioremap(VSA_BASE_REGS, 128); - sys_vs.vs_cpu_ptr->vc_intclr=0xFF; + irqs=probe_irq_on(); + sys_vs.vs_cpu_ptr->vc_intmsk=0; + sys_vs.vs_cpu_ptr->vc_intclr=0xFF; + // printk("vsbus: Getting Interrupt Mask\n"); + udelay(100000); + sys_vs.vs_mask=sys_vs.vs_cpu_ptr->vc_intreq; + sys_vs.vs_cpu_ptr->vc_intmsk=0; /*~sys_vs.vs_mask;*/ + + probe_irq_off(irqs); + printk("vsbus: interrupt mask %x\n", sys_vs.vs_mask); + return 0; } @@ -38,7 +52,20 @@ return 0; } -int vsbus_probe_irq(void) +int vsbus_probe_irq_on(void) { + printk("vsbus: probing set mask ~%2X\n", sys_vs.vs_mask); + sys_vs.vs_cpu_ptr->vc_intmsk = ~sys_vs.vs_mask; + sys_vs.vs_cpu_ptr->vc_intclr=0xff; return 0; +} + +unsigned char vsbus_probe_irq_report(void) +{ + unsigned char x, y; + + x=sys_vs.vs_cpu_ptr->vc_intreq; + y = x & ~sys_vs.vs_mask; + printk("vsbus: probe returning %2X, %2X\n", x, y); + return y; } Index: fs/binfmt_elf.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/fs/binfmt_elf.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 binfmt_elf.c --- fs/binfmt_elf.c 2001/02/25 23:14:46 1.1.1.2 +++ fs/binfmt_elf.c 2001/06/14 22:24:12 @@ -129,10 +129,18 @@ if (k_platform) { platform_len = strlen(k_platform) + 1; u_platform = p - platform_len; + printk("k_platform is %02X %02X %02X %02X\n", k_platform[0], k_platform[1], k_platform[2], k_platform[3]); + // dump_cur_regs(0); __copy_to_user(u_platform, k_platform, platform_len); + // hex_dump((void *)0x811a3fc0, 64); + printk("u_platform is %02X %02X %02X %02X\n", u_platform[0], u_platform[1], u_platform[2], u_platform[3]); + { + /* dump some tables out here maybe */ + + } } else u_platform = p; - + /* * Force 16 byte _final_ alignment here for generality. * Leave an extra 16 bytes free so that on the PowerPC we @@ -146,7 +154,6 @@ csp -= (!ibcs ? 3 : 1); /* argc itself */ if ((unsigned long)csp & 15UL) sp -= ((unsigned long)csp & 15UL) / sizeof(*sp); - /* * Put the ELF interpreter info on the stack */ @@ -204,6 +211,7 @@ } __put_user(NULL, envp); current->mm->env_end = (unsigned long) p; + return sp; } @@ -287,7 +295,7 @@ elf_type |= MAP_FIXED; map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type); - + if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) { load_addr = map_addr - ELF_PAGESTART(vaddr); load_addr_set = 1; @@ -608,7 +616,6 @@ for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) { int elf_prot = 0, elf_flags; unsigned long vaddr; - if (elf_ppnt->p_type != PT_LOAD) continue; @@ -622,7 +629,6 @@ if (elf_ex.e_type == ET_EXEC || load_addr_set) { elf_flags |= MAP_FIXED; } - error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags); if (!load_addr_set) { @@ -690,6 +696,7 @@ compute_creds(bprm); current->flags &= ~PF_FORKNOEXEC; + bprm->p = (unsigned long) create_elf_tables((char *)bprm->p, bprm->argc, @@ -724,7 +731,6 @@ printk("(start_stack) %lx\n" , (long) current->mm->start_stack); printk("(brk) %lx\n" , (long) current->mm->brk); #endif - if ( current->personality == PER_SVR4 ) { /* Why this, you ask??? Well SVr4 maps page 0 as read-only, @@ -732,6 +738,7 @@ Since we do not have the power to recompile these, we emulate the SVr4 behavior. Sigh. */ /* N.B. Shouldn't the size here be PAGE_SIZE?? */ + down(¤t->mm->mmap_sem); error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC, MAP_FIXED | MAP_PRIVATE, 0); @@ -752,6 +759,7 @@ if (current->ptrace & PT_PTRACED) send_sig(SIGTRAP, current, 0); retval = 0; + out: return retval; Index: fs/devices.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/fs/devices.c,v retrieving revision 1.1.1.1 diff -u -r1.1.1.1 devices.c --- fs/devices.c 2001/01/14 16:25:21 1.1.1.1 +++ fs/devices.c 2001/06/14 22:24:14 @@ -146,6 +146,7 @@ int ret = -ENODEV; filp->f_op = get_chrfops(MAJOR(inode->i_rdev), MINOR(inode->i_rdev)); + printk("In CHRDEV_OPEN %d %d %p\n", MAJOR(inode->i_rdev), MINOR(inode->i_rdev), filp->f_op->open); if (filp->f_op) { ret = 0; if (filp->f_op->open != NULL) { Index: fs/exec.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/fs/exec.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 exec.c --- fs/exec.c 2001/02/25 23:14:45 1.1.1.2 +++ fs/exec.c 2001/06/14 22:24:16 @@ -281,6 +281,7 @@ } flush_dcache_page(page); flush_page_to_ram(page); + printk("page %p, num %d ,pte_val %8lX\n",page, page-mem_map,pte_mkdirty(pte_mkwrite(mk_pte(page, PAGE_COPY)))); set_pte(pte, pte_mkdirty(pte_mkwrite(mk_pte(page, PAGE_COPY)))); /* no need for flush_tlb */ } @@ -292,7 +293,6 @@ int i; stack_base = STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE; - bprm->p += stack_base; if (bprm->loader) bprm->loader += stack_base; @@ -307,6 +307,7 @@ mpnt->vm_mm = current->mm; mpnt->vm_start = PAGE_MASK & (unsigned long) bprm->p; mpnt->vm_end = STACK_TOP; + mpnt->vm_page_prot = PAGE_COPY; mpnt->vm_flags = VM_STACK_FLAGS; mpnt->vm_ops = NULL; @@ -392,7 +393,6 @@ exit_mmap(old_mm); return 0; } - mm = mm_alloc(); if (mm) { struct mm_struct *active_mm; @@ -867,7 +867,6 @@ fput(file); return bprm.envc; } - retval = prepare_binprm(&bprm); if (retval < 0) goto out; Index: fs/namei.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/fs/namei.c,v retrieving revision 1.1.1.1 diff -u -r1.1.1.1 namei.c --- fs/namei.c 2001/01/14 16:25:10 1.1.1.1 +++ fs/namei.c 2001/06/14 22:24:20 @@ -117,6 +117,7 @@ len = TASK_SIZE - (unsigned long) filename; retval = strncpy_from_user((char *)page, filename, len); + if (retval > 0) { if (retval < len) return 0; Index: fs/open.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/fs/open.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 open.c --- fs/open.c 2001/02/25 23:14:45 1.1.1.2 +++ fs/open.c 2001/06/14 22:24:21 @@ -624,6 +624,7 @@ namei_flags |= 2; error = open_namei(filename, namei_flags, mode, &nd); + if (!error) return dentry_open(nd.dentry, nd.mnt, flags); @@ -662,7 +663,7 @@ goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); - + return f; cleanup_all: @@ -676,6 +677,7 @@ cleanup_dentry: dput(dentry); mntput(mnt); + return ERR_PTR(error); } @@ -689,7 +691,7 @@ error = -EMFILE; write_lock(&files->file_lock); - + repeat: fd = find_next_zero_bit(files->open_fds, files->max_fdset, @@ -763,6 +765,7 @@ out: putname(tmp); } + return fd; out_error: Index: include/asm-vax/system.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/system.h,v retrieving revision 1.3 diff -u -r1.3 system.h --- include/asm-vax/system.h 2001/01/23 23:55:57 1.3 +++ include/asm-vax/system.h 2001/06/14 22:24:27 @@ -20,16 +20,17 @@ * files, so it does only defines, not any C code. */ -/* FIXME: these are wrong */ -#define KERNEL_START (PAGE_OFFSET+0x300000) -#define SWAPPER_PGD (PAGE_OFFSET+0x300000) -#define INIT_STACK (PAGE_OFFSET+0x302000) -#define EMPTY_PGT (PAGE_OFFSET+0x304000) -#define EMPTY_PGE (PAGE_OFFSET+0x308000) -#define ZERO_PGE (PAGE_OFFSET+0x30A000) - -#define START_ADDR (PAGE_OFFSET+0x310000) - +/* FIXME: these are wrong - these don't seem to be used in 2.4 */ +/* + #define KERNEL_START (PAGE_OFFSET+0x300000) + #define SWAPPER_PGD (PAGE_OFFSET+0x300000) + #define INIT_STACK (PAGE_OFFSET+0x302000) + #define EMPTY_PGT (PAGE_OFFSET+0x304000) + #define EMPTY_PGE (PAGE_OFFSET+0x308000) + #define ZERO_PGE (PAGE_OFFSET+0x30A000) + + #define START_ADDR (PAGE_OFFSET+0x310000) +*/ #ifndef __ASSEMBLY__ @@ -142,7 +143,6 @@ #define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr)))) #define tas(ptr) (xchg((ptr),1)) - struct __xchg_dummy { unsigned long a[100]; }; #define __xg(x) ((struct __xchg_dummy *)(x)) Index: include/asm-vax/vsa.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/vsa.h,v retrieving revision 1.3 diff -u -r1.3 vsa.h --- include/asm-vax/vsa.h 2001/02/22 22:20:31 1.3 +++ include/asm-vax/vsa.h 2001/06/14 22:24:28 @@ -8,12 +8,21 @@ struct vs_cpu { unsigned long vs_hltcod; unsigned long vc_410msr; - unsigned long vc_410cear; /* VS2K */ - unsigned char vc_intmsk; /* Interrupt mask register */ - unsigned char vc_vdcorg; /* Mono display origin */ - unsigned char vc_vdcsel; /* Video interrupt select */ - unsigned char vc_intreq; /* Interrupt request register */ + unsigned long vc_410cear; /* VS2K */ + unsigned char vc_intmsk; /* Interrupt mask register */ + unsigned char vc_vdcorg; /* Mono display origin */ + unsigned char vc_vdcsel; /* Video interrupt select */ + unsigned char vc_intreq; /* Interrupt request register */ #define vc_intclr vc_intreq + unsigned short vc_diagdsp; + unsigned short pad4; + unsigned long vc_parctl; +#define vc_bwf0 vc_parctl + unsigned short pad5; + unsigned short pad6; + unsigned short vc_diagtimu; + unsigned short vc_diagtme; +#define vc_diagtimm vc_diagtme }; extern int vsbus_setup(void); Index: include/asm-vax/mm/pagelet_pgd.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/mm/pagelet_pgd.h,v retrieving revision 1.1 diff -u -r1.1 pagelet_pgd.h --- include/asm-vax/mm/pagelet_pgd.h 2001/02/15 01:17:23 1.1 +++ include/asm-vax/mm/pagelet_pgd.h 2001/06/14 22:24:28 @@ -56,7 +56,7 @@ set_page_dir( tsk, pgdir) - +#define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1)) /* hmm, our pgd_t is 8 bytes long. FIXME: check pgd_index gives the right answer */ /* to find an entry in a page-table-directory */ #define pgd_offset(mm, address) ((mm)->pgd + pgd_index(address)) @@ -65,7 +65,7 @@ #define pgd_offset_k(address) pgd_offset(&init_mm, address) /* to find an entry in a page-table-directory */ -#define pgd_index(address) ((address >> PGDIR_SHIFT) & (PTRS_PER_PGD-1)) + #define __pgd_offset(address) pgd_index(address) #endif Index: include/asm-vax/mm/pagelet_pte.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/mm/pagelet_pte.h,v retrieving revision 1.3 diff -u -r1.3 pagelet_pte.h --- include/asm-vax/mm/pagelet_pte.h 2001/05/27 12:51:25 1.3 +++ include/asm-vax/mm/pagelet_pte.h 2001/06/14 22:24:29 @@ -1,5 +1,6 @@ #ifndef _VAX_MM_PAGELET_PTE_H #define _VAX_MM_PAGELET_PTE_H +#include /* * pagelet_pte.h * @@ -69,8 +70,8 @@ #define PTE_MASK (~((2<<5)-1)) /* to find an entry in a page-table */ -#define PAGE_PTR(address) \ -((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTE_LOG2)&PTE_MASK&~PAGE_MASK) +/*#define PAGE_PTR(address) \ + ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTE_LOG2)&PTE_MASK&~PAGE_MASK)*/ /* Certain architectures need to do special things when PTEs @@ -100,6 +101,8 @@ ptep->pte5 = pte_val(pte)+5; ptep->pte6 = pte_val(pte)+6; ptep->pte7 = pte_val(pte)+7; + __mtpr(0, PR_TBIA); + } /* * Conversion functions: convert a page and protection to a page entry, @@ -130,7 +133,7 @@ return pte; } -#define pte_page(x) (mem_map+(unsigned long)((pte_val(x) >> PAGE_SHIFT))) +#define pte_page(x) (mem_map+(unsigned long)(((pte_val(x) & PAGE_PFN_MASK) >> (PAGE_SHIFT - PAGELET_SHIFT)))) @@ -157,6 +160,7 @@ ptep->pte5 = 0; ptep->pte6 = 0; ptep->pte7 = 0; + __mtpr(0, PR_TBIA); } #define PTE_INIT(x) pte_clear(x) @@ -263,7 +267,10 @@ static inline int pte_present(pte_t pte) { return (pte_val(pte) & _PAGE_VALID); } /* find an entry in a pagetable */ +#define PAGEDIR_TOP 0x40000000 +#define PAGEDIR_TOP_MASK PAGEDIR_TOP-1 + #define pte_offset(pmd, address) \ -((pte_t *) ( ((pgd_t *)(pmd))->br + (address >> PAGE_SHIFT)*BYTES_PER_PTE_T)) +((pte_t *) ( ((pgd_t *)(pmd))->br + ((((address) & 0x3fffffff) >> PAGE_SHIFT)*BYTES_PER_PTE_T))) #endif Index: include/asm-vax/mm/pgalloc.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/mm/pgalloc.h,v retrieving revision 1.4 diff -u -r1.4 pgalloc.h --- include/asm-vax/mm/pgalloc.h 2001/05/19 12:05:51 1.4 +++ include/asm-vax/mm/pgalloc.h 2001/06/14 22:24:30 @@ -195,6 +195,10 @@ * boot time, and disallow dynamic expansion. atp Feb 2001. * * - we still need to implement this ... linux still calls it .. + * implemented as follows: + * is the page in the currently allocated system page table? + * if it is return the proper page. + * otherwise return NULL * - D.A. May 2001. */ extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address) @@ -215,6 +219,15 @@ * We grab a random page. The only catch is that it must be virtually * contiguous within the P0 or P1 page tables, which are held in S0 * space. So, we remap the page table area in S0 space too. + * + * ignore above comments they map to the #if 0 code at the end + * I've removed them until Andy arrives back and thinks up a more + * appropriate way or more flexible method.. + * My method is , check is page in P0 or P1 page space, + * find the PTE into these spaces (newpte) + * Check is the S0 page mapped in where newpte will be stored + * and clear the pte + * - D.A. May 2001 */ extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address) { @@ -239,8 +252,9 @@ pte_number = (address>>PAGE_SHIFT); pte_page = (pte_number >> SIZEOF_PTE_LOG2); pte_page_offset = pte_number & (PTRS_PER_PTE - 1); - if ((pte_number) > (pgdptr->lr)) { + if ((pte_number) >= (pgdptr->lr)) { newpte = pte_offset(pmd, address); + printk("new pte in P1, addr %8lX %8lX %8lX\n", address, pte_number, pgdptr->br); } } Index: include/asm-vax/mm/tlb.h =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/include/asm-vax/mm/tlb.h,v retrieving revision 1.1 diff -u -r1.1 tlb.h --- include/asm-vax/mm/tlb.h 2001/02/15 01:17:23 1.1 +++ include/asm-vax/mm/tlb.h 2001/06/14 22:24:30 @@ -37,11 +37,13 @@ __flush_tlb(); } +/* FIXME: probably need to flush a TLB per HWpage in the Linux page -D.A. */ static inline void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr) { if (vma->vm_mm == current->mm) - __flush_tlb_one(addr); + __flush_tlb(); + // __flush_tlb_one(addr); } static inline void flush_tlb_range(struct mm_struct *mm, @@ -144,6 +146,7 @@ * page table is going away? I don't think so... * But what if two processes are sharing this mm_struct and * are currently running on two different CPUs? */ + flush_tlb(); } Index: init/main.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/init/main.c,v retrieving revision 1.2 diff -u -r1.2 main.c --- init/main.c 2001/02/18 20:37:38 1.2 +++ init/main.c 2001/06/14 22:25:38 @@ -135,7 +135,7 @@ char root_device_name[64]; -static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, }; +static char * argv_init[MAX_INIT_ARGS+2] = { "sh", NULL, }; static char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, }; static int __init profile_setup(char *str) @@ -605,6 +605,7 @@ * make syscalls (and thus be locked). */ smp_init(); + // flush_tlb(); kernel_thread(init, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL); unlock_kernel(); current->need_resched = 1; @@ -766,6 +767,7 @@ static int init(void * unused) { + int ret; lock_kernel(); do_basic_setup(); @@ -777,11 +779,16 @@ free_initmem(); unlock_kernel(); - if (open("/dev/console", O_RDWR, 0) < 0) - printk("Warning: unable to open an initial console.\n"); - + ret=open("/dev/console", O_RDWR, 0); + if (ret < 0) + printk("Warning: unable to open an initial console.%d\n",ret); + dump_cur_regs(0); + sync(); + dump_cur_regs(0); (void) dup(0); + (void) dup(0); + /* * We try each of these until one succeeds. Index: kernel/fork.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/kernel/fork.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 fork.c --- kernel/fork.c 2001/02/25 23:14:48 1.1.1.2 +++ kernel/fork.c 2001/06/14 22:25:38 @@ -308,7 +308,6 @@ mm = allocate_mm(); if (!mm) goto fail_nomem; - /* Copy the current MM stuff.. */ memcpy(mm, oldmm, sizeof(*mm)); if (!mm_init(mm)) Index: mm/filemap.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/mm/filemap.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 filemap.c --- mm/filemap.c 2001/02/25 23:14:48 1.1.1.2 +++ mm/filemap.c 2001/06/14 22:25:44 @@ -505,7 +505,7 @@ if (PageLocked(page)) BUG(); - + // printk("Adding to pgcache %p\n", page); flags = page->flags & ~((1 << PG_uptodate) | (1 << PG_error) | (1 << PG_dirty) | (1 << PG_referenced) | (1 << PG_arch_1)); page->flags = flags | (1 << PG_locked); page_cache_get(page); @@ -1434,6 +1434,7 @@ struct page *page, **hash, *old_page; unsigned long size, pgoff; + pgoff = ((address - area->vm_start) >> PAGE_CACHE_SHIFT) + area->vm_pgoff; retry_all: @@ -1442,6 +1443,7 @@ * accessible.. */ size = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; + // printk("filemap_nopage called %8lX %8lX %8lX %8lX %8lX\n", address, pgoff, inode->i_size, size, area->vm_start); if ((pgoff >= size) && (area->vm_mm == current->mm)) return NULL; @@ -1453,7 +1455,7 @@ page = __find_get_page(mapping, pgoff, hash); if (!page) goto no_cached_page; - + // printk("page in cache %p\n", page); /* * Ok, found a page in the page cache, now we need to check * that it's up-to-date. @@ -1496,6 +1498,7 @@ * Otherwise, we're off the end of a privately mapped file, * so we need to map a zero page. */ + // printk("no cached page %8lX", size); if ((pgoff < size) && !VM_RandomReadHint(area)) error = read_cluster_nonblocking(file, pgoff, size); else @@ -1519,6 +1522,7 @@ return NULL; page_not_uptodate: + // printk("page isn't up to date\n"); lock_page(page); /* Did it get unhashed while we waited for it? */ Index: mm/memory.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/mm/memory.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 memory.c --- mm/memory.c 2001/02/25 23:14:48 1.1.1.2 +++ mm/memory.c 2001/06/14 22:25:47 @@ -159,12 +159,12 @@ src_pgd = pgd_offset(src, address)-1; dst_pgd = pgd_offset(dst, address)-1; - + for (;;) { pmd_t * src_pmd, * dst_pmd; src_pgd++; dst_pgd++; - + /* copy_pmd_range */ if (pgd_none(*src_pgd)) @@ -184,7 +184,6 @@ src_pmd = pmd_offset(src_pgd, address); dst_pmd = pmd_offset(dst_pgd, address); - do { pte_t * src_pte, * dst_pte; @@ -207,7 +206,7 @@ src_pte = pte_offset(src_pmd, address); dst_pte = pte_offset(dst_pmd, address); - + spin_lock(&src->page_table_lock); do { pte_t pte = *src_pte; @@ -1068,10 +1067,16 @@ { struct page *page = NULL; pte_t entry = pte_wrprotect(mk_pte(ZERO_PAGE(addr), vma->vm_page_prot)); + // printk("do anon page called %d\n", write_access); if (write_access) { + page = alloc_page(GFP_HIGHUSER); + //printk("do anon page: page is %p %8lX\n", page, addr); if (!page) - return -1; + { + printk("returning -1\n"); + return -1; + } clear_user_highpage(page, addr); entry = pte_mkwrite(pte_mkdirty(mk_pte(page, vma->vm_page_prot))); mm->rss++; @@ -1080,6 +1085,7 @@ set_pte(page_table, entry); /* No need to invalidate - it was non-present before */ update_mmu_cache(vma, addr, entry); + // printk("returning 1, %8lX %p %p %8lX\n", pte_val(*page_table), page_table, mem_map, ZERO_PAGE(addr)); return 1; /* Minor fault */ } @@ -1100,6 +1106,7 @@ struct page * new_page; pte_t entry; + // printk("Got do_no_page %d\n", write_access); if (!vma->vm_ops || !vma->vm_ops->nopage) return do_anonymous_page(mm, vma, page_table, write_access, address); @@ -1109,10 +1116,16 @@ * essentially an early COW detection. */ new_page = vma->vm_ops->nopage(vma, address & PAGE_MASK, (vma->vm_flags & VM_SHARED)?0:write_access); - if (new_page == NULL) /* no page was available -- SIGBUS */ - return 0; + if (new_page == NULL) /* no page was available -- SIGBUS */ + { + // printk("do_no_page returning 0\n"); + return 0; + } if (new_page == NOPAGE_OOM) + { + // printk("do_no_page returning -1\n"); return -1; + } ++mm->rss; /* * This silly early PAGE_DIRTY setting removes a race @@ -1132,6 +1145,7 @@ } else if (page_count(new_page) > 1 && !(vma->vm_flags & VM_SHARED)) entry = pte_wrprotect(entry); + set_pte(page_table, entry); /* no need to invalidate: a not-present page shouldn't be cached */ update_mmu_cache(vma, address, entry); @@ -1167,6 +1181,7 @@ * and the SMP-safe atomic PTE updates. */ spin_lock(&mm->page_table_lock); + entry = *pte; if (!pte_present(entry)) { /* @@ -1174,13 +1189,17 @@ * and the PTE updates will not touch it later. So * drop the lock. */ + spin_unlock(&mm->page_table_lock); + printk("No pte present\n"); if (pte_none(entry)) return do_no_page(mm, vma, address, write_access, pte); + printk("CAll do swap page\n"); return do_swap_page(mm, vma, address, pte, pte_to_swp_entry(entry), write_access); } - + if (write_access) { + printk("write access is requested, calling do_wp_page \n"); if (!pte_write(entry)) return do_wp_page(mm, vma, address, pte, entry); @@ -1205,11 +1224,16 @@ current->state = TASK_RUNNING; pgd = pgd_offset(mm, address); pmd = pmd_alloc(pgd, address); - + + printk("Before IF statement in handle_mm_fault, %8lX %8lX %p %8X\n", pgd[0].br, pgd[0].lr, pmd, address); if (pmd) { pte_t * pte = pte_alloc(pmd, address); + printk("Calling handle pte_fault %p\n", pte); if (pte) + { + ret = handle_pte_fault(mm, vma, address, write_access, pte); + } } return ret; } Index: mm/mmap.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/mm/mmap.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 mmap.c --- mm/mmap.c 2001/02/25 23:14:48 1.1.1.2 +++ mm/mmap.c 2001/06/14 22:25:49 @@ -265,6 +265,7 @@ return -EINVAL; } else { addr = get_unmapped_area(addr, len); + // printk("unmapped area returned %8lX\n", addr); if (!addr) return -ENOMEM; } @@ -365,6 +366,7 @@ mm->locked_vm += len >> PAGE_SHIFT; make_pages_present(addr, addr + len); } + // printk("do_mmap returning %8lX\n", addr); return addr; unmap_and_free_vma: Index: mm/vmalloc.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/mm/vmalloc.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 vmalloc.c --- mm/vmalloc.c 2001/02/25 23:14:48 1.1.1.2 +++ mm/vmalloc.c 2001/06/14 22:25:49 @@ -107,6 +107,8 @@ page = alloc_page(gfp_mask); if (!page) return -ENOMEM; + clear_page(page_address(page)); + set_pte(pte, mk_pte(page, prot)); address += PAGE_SIZE; pte++; @@ -122,12 +124,16 @@ end = address + size; if (end > PGDIR_SIZE) end = PGDIR_SIZE; + do { pte_t * pte = pte_alloc_kernel(pmd, address); if (!pte) return -ENOMEM; if (alloc_area_pte(pte, address, end - address, gfp_mask, prot)) return -ENOMEM; + // printk("pte %p, addr: %8lX\n", pte, address); + //hex_dump((void *)0x802115F8, 64); + address = (address + PMD_SIZE) & PMD_MASK; pmd++; } while (address < end); @@ -150,12 +156,16 @@ pmd = pmd_alloc_kernel(dir, address); ret = -ENOMEM; if (!pmd) + { + printk("__vmalloc no pmd\n"); break; + } ret = -ENOMEM; if (alloc_area_pmd(pmd, address, end - address, gfp_mask, prot)) - break; - + {printk("__vmalloc alloc_area_pmd\n"); + break; + } address = (address + PGDIR_SIZE) & PGDIR_MASK; dir++; @@ -229,7 +239,7 @@ { void * addr; struct vm_struct *area; - + int ret; size = PAGE_ALIGN(size); if (!size || (size >> PAGE_SHIFT) > num_physpages) { BUG(); @@ -237,10 +247,16 @@ } area = get_vm_area(size, VM_ALLOC); if (!area) + { + printk("__vmalloc after get_vm_area returning NULL\n"); return NULL; + } addr = area->addr; - if (vmalloc_area_pages(VMALLOC_VMADDR(addr), size, gfp_mask, prot)) { + + ret = vmalloc_area_pages(VMALLOC_VMADDR(addr), size, gfp_mask, prot); + if (ret) { vfree(addr); + printk("__vmalloc after vmalloc_area_pages returning %d\n", ret); return NULL; } return addr; Index: net/core/dev.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/net/core/dev.c,v retrieving revision 1.1.1.1 diff -u -r1.1.1.1 dev.c --- net/core/dev.c 2001/01/14 20:24:26 1.1.1.1 +++ net/core/dev.c 2001/06/14 22:25:55 @@ -1162,9 +1162,9 @@ } drop: + netdev_rx_stat[this_cpu].dropped++; local_irq_restore(flags); - kfree_skb(skb); return NET_RX_DROP; } Index: net/ipv4/devinet.c =================================================================== RCS file: /cvsroot/linux-vax/kernel-2.4/net/ipv4/devinet.c,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 devinet.c --- net/ipv4/devinet.c 2001/02/25 23:14:55 1.1.1.2 +++ net/ipv4/devinet.c 2001/06/14 22:25:57 @@ -441,9 +441,9 @@ static __inline__ int inet_abc_len(u32 addr) { + if (ZERONET(addr)) return 0; - addr = ntohl(addr); if (IN_CLASSA(addr)) return 8; @@ -478,7 +478,6 @@ if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) return -EFAULT; ifr.ifr_name[IFNAMSIZ-1] = 0; - colon = strchr(ifr.ifr_name, ':'); if (colon) *colon = 0; @@ -570,6 +569,7 @@ break; case SIOCSIFADDR: /* Set interface address (and family) */ + if (inet_abc_len(sin->sin_addr.s_addr) < 0) { ret = -EINVAL; break;