├── fs
    ├── newmotd
    ├── motd
    ├── testshell.sh
    ├── script
    ├── index.html
    ├── lorem
    ├── fs.h
    ├── test.c
    ├── Makefrag
    ├── ide.c
    └── testshell.key
├── conf
    ├── lab.mk
    └── env.mk
├── net
    ├── lwip
    │   ├── core
    │   │   └── ipv6
    │   │   │   ├── README
    │   │   │   └── ip6_addr.c
    │   ├── jos
    │   │   ├── jif
    │   │   │   └── jif.h
    │   │   ├── arch
    │   │   │   ├── perf.h
    │   │   │   ├── perror.h
    │   │   │   ├── setjmp.h
    │   │   │   ├── i386
    │   │   │   │   └── setjmp.h
    │   │   │   ├── sys_arch.h
    │   │   │   ├── thread.h
    │   │   │   ├── cc.h
    │   │   │   ├── longjmp.S
    │   │   │   └── threadq.h
    │   │   └── lwipopts.h
    │   ├── FILES
    │   ├── netif
    │   │   ├── FILES
    │   │   ├── ppp
    │   │   │   ├── vjbsdhdr.h
    │   │   │   ├── pppdebug.h
    │   │   │   ├── md5.h
    │   │   │   └── chpms.h
    │   │   └── loopif.c
    │   ├── include
    │   │   ├── lwip
    │   │   │   ├── init.h
    │   │   │   ├── def.h
    │   │   │   └── sio.h
    │   │   ├── netif
    │   │   │   ├── slipif.h
    │   │   │   └── loopif.h
    │   │   ├── ipv4
    │   │   │   └── lwip
    │   │   │   │   ├── inet_chksum.h
    │   │   │   │   └── ip_frag.h
    │   │   └── ipv6
    │   │   │   └── lwip
    │   │   │       └── inet.h
    │   ├── Makefrag
    │   └── api
    │   │   └── err.c
    ├── output.c
    ├── ns.h
    ├── timer.c
    ├── input.c
    ├── Makefrag
    └── testoutput.c
├── lib
    ├── exit.c
    ├── pageref.c
    ├── wait.c
    ├── panic.c
    ├── libmain.c
    ├── readline.c
    ├── entry.S
    ├── Makefrag
    ├── printf.c
    ├── pgfault.c
    ├── fprintf.c
    ├── args.c
    ├── ipc.c
    ├── console.c
    └── sockets.c
├── inc
    ├── malloc.h
    ├── stdarg.h
    ├── syscall.h
    ├── assert.h
    ├── partition.h
    ├── stdio.h
    ├── string.h
    ├── error.h
    ├── elf.h
    ├── fd.h
    ├── stab.h
    ├── types.h
    ├── ns.h
    ├── env.h
    ├── args.h
    └── trap.h
├── user
    ├── breakpoint.c
    ├── faultwrite.c
    ├── hello.c
    ├── softint.c
    ├── faultwritekernel.c
    ├── faultread.c
    ├── divzero.c
    ├── faultreadkernel.c
    ├── buggyhello.c
    ├── spawnhello.c
    ├── spawninit.c
    ├── badsegment.c
    ├── faultnostack.c
    ├── faultevilhandler.c
    ├── buggyhello2.c
    ├── evilhello.c
    ├── echo.c
    ├── yield.c
    ├── faultdie.c
    ├── faultbadhandler.c
    ├── testmalloc.c
    ├── idle.c
    ├── fairness.c
    ├── testkbd.c
    ├── initsh.c
    ├── pingpong.c
    ├── faultalloc.c
    ├── Makefrag
    ├── forktree.c
    ├── faultallocbad.c
    ├── icode.c
    ├── cat.c
    ├── testtime.c
    ├── testbss.c
    ├── spin.c
    ├── lsfd.c
    ├── pingpongs.c
    ├── num.c
    ├── stresssched.c
    ├── testptelibrary.c
    ├── writemotd.c
    ├── testpteshare.c
    ├── testfdsharing.c
    ├── sendpage.c
    ├── primes.c
    ├── testpipe.c
    ├── init.c
    ├── user.ld
    ├── echotest.c
    ├── ls.c
    ├── primespipe.c
    ├── testshell.c
    ├── testpiperace.c
    ├── testpiperace2.c
    ├── dumbfork.c
    └── echosrv.c
├── .gitignore
├── .dir-locals.el
├── kern
    ├── time.h
    ├── syscall.h
    ├── sched.h
    ├── kclock.c
    ├── time.c
    ├── kdebug.h
    ├── trap.h
    ├── pci.h
    ├── console.h
    ├── picirq.h
    ├── monitor.h
    ├── env.h
    ├── kclock.h
    ├── cpu.h
    ├── spinlock.h
    ├── kernel.ld
    ├── sched.c
    ├── picirq.c
    ├── pmap.h
    ├── mpentry.S
    ├── entry.S
    └── printf.c
├── boot
    ├── sign.pl
    ├── Makefrag
    └── boot.S
├── grade-lab2
├── .gdbinit.tmpl
├── CODING
├── grade-lab1
├── handin-prep
├── README.md
└── mergedep.pl


/fs/newmotd:
--------------------------------------------------------------------------------
1 | This is the NEW message of the day!
2 | 
3 | 


--------------------------------------------------------------------------------
/conf/lab.mk:
--------------------------------------------------------------------------------
1 | LAB=6
2 | PACKAGEDATE=Mon Nov 17 18:30:59 EST 2014
3 | 


--------------------------------------------------------------------------------
/net/lwip/core/ipv6/README:
--------------------------------------------------------------------------------
1 | IPv6 support in lwIP is very experimental.
2 | 


--------------------------------------------------------------------------------
/fs/motd:
--------------------------------------------------------------------------------
1 | This is /motd, the message of the day.
2 | 
3 | Welcome to the JOS kernel, now with a file system!
4 | 
5 | 


--------------------------------------------------------------------------------
/lib/exit.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <inc/lib.h>
 3 | 
 4 | void
 5 | exit(void)
 6 | {
 7 | 	close_all();
 8 | 	sys_env_destroy(0);
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/net/lwip/jos/jif/jif.h:
--------------------------------------------------------------------------------
1 | #include <lwip/netif.h>
2 | 
3 | void	jif_input(struct netif *netif, void *va);
4 | err_t	jif_init(struct netif *netif);
5 | 


--------------------------------------------------------------------------------
/inc/malloc.h:
--------------------------------------------------------------------------------
1 | #ifndef JOS_INC_MALLOC_H
2 | #define JOS_INC_MALLOC_H 1
3 | 
4 | void *malloc(size_t size);
5 | void free(void *addr);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/perf.h:
--------------------------------------------------------------------------------
1 | #ifndef LWIP_ARCH_PERF_H
2 | #define LWIP_ARCH_PERF_H
3 | 
4 | #define PERF_START
5 | #define PERF_STOP(x)
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/fs/testshell.sh:
--------------------------------------------------------------------------------
1 | echo hello world | cat
2 | cat lorem
3 | cat lorem |num
4 | cat lorem |num |num |num |num |num
5 | lsfd -1
6 | cat script
7 | sh <script
8 | 


--------------------------------------------------------------------------------
/fs/script:
--------------------------------------------------------------------------------
1 | echo This is from the script.
2 | cat lorem | num | cat
3 | echo These are my file descriptors.
4 | lsfd -1
5 | echo This is the end of the script.
6 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/perror.h:
--------------------------------------------------------------------------------
1 | #ifndef JOS_INC_PERROR_H
2 | #define JOS_INC_PERROR_H
3 | 
4 | void perror(const char *s);
5 | const char *e2s(int e);
6 | 
7 | #endif /* !JOS_INC_PERROR_H */
8 | 


--------------------------------------------------------------------------------
/user/breakpoint.c:
--------------------------------------------------------------------------------
 1 | // program to cause a breakpoint trap
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	asm volatile("int $3");
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/user/faultwrite.c:
--------------------------------------------------------------------------------
 1 | // buggy program - faults with a write to location zero
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	*(unsigned*)0 = 0;
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/user/hello.c:
--------------------------------------------------------------------------------
 1 | // hello, world
 2 | #include <inc/lib.h>
 3 | 
 4 | void
 5 | umain(int argc, char **argv)
 6 | {
 7 | 	cprintf("hello, world\n");
 8 | 	cprintf("i am environment %08x\n", thisenv->env_id);
 9 | }
10 | 


--------------------------------------------------------------------------------
/user/softint.c:
--------------------------------------------------------------------------------
 1 | // buggy program - causes an illegal software interrupt
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	asm volatile("int $14");	// page fault
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/user/faultwritekernel.c:
--------------------------------------------------------------------------------
 1 | // buggy program - faults with a write to a kernel location
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	*(unsigned*)0xf0100000 = 0;
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/fs/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | 	<title>jhttpd on JOS</title>
 4 | </head>
 5 | <body>
 6 | 	<center>
 7 | 		<h2>This file came from JOS.</h2>
 8 | 		<marquee>Cheesy web page!</marquee>
 9 | 	</center>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/user/faultread.c:
--------------------------------------------------------------------------------
 1 | // buggy program - faults with a read from location zero
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	cprintf("I read %08x from location 0!\n", *(unsigned*)0);
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/user/divzero.c:
--------------------------------------------------------------------------------
 1 | // buggy program - causes a divide by zero exception
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | int zero;
 6 | 
 7 | void
 8 | umain(int argc, char **argv)
 9 | {
10 | 	zero = 0;
11 | 	cprintf("1/0 is %08x!\n", 1/zero);
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/user/faultreadkernel.c:
--------------------------------------------------------------------------------
 1 | // buggy program - faults with a read from kernel space
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	cprintf("I read %08x from location 0xf0100000!\n", *(unsigned*)0xf0100000);
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/user/buggyhello.c:
--------------------------------------------------------------------------------
 1 | // buggy hello world -- unmapped pointer passed to kernel
 2 | // kernel should destroy user environment in response
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	sys_cputs((char*)1, 1);
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/lib/pageref.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | int
 4 | pageref(void *v)
 5 | {
 6 | 	pte_t pte;
 7 | 
 8 | 	if (!(uvpd[PDX(v)] & PTE_P))
 9 | 		return 0;
10 | 	pte = uvpt[PGNUM(v)];
11 | 	if (!(pte & PTE_P))
12 | 		return 0;
13 | 	return pages[PGNUM(pte)].pp_ref;
14 | }
15 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /obj
 2 | /jos.in
 3 | /jos.log
 4 | /jos.out
 5 | /jos.out.*
 6 | /jos.cmd
 7 | /.gdbinit
 8 | /wget.log
 9 | /qemu.pcap
10 | /qemu.pcap.*
11 | /qemu.out
12 | /qemu.log
13 | /gradelib.pyc
14 | /lab?-handin.tar.gz
15 | /lab?/
16 | /sol?/
17 | /myapi.key
18 | .suf
19 | 


--------------------------------------------------------------------------------
/user/spawnhello.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int r;
 7 | 	cprintf("i am parent environment %08x\n", thisenv->env_id);
 8 | 	if ((r = spawnl("hello", "hello", 0)) < 0)
 9 | 		panic("spawn(hello) failed: %e", r);
10 | }
11 | 


--------------------------------------------------------------------------------
/.dir-locals.el:
--------------------------------------------------------------------------------
 1 | ((nil
 2 |   (indent-tabs-mode . t)
 3 |   (tab-width . 8))
 4 |  (c-mode
 5 |   (c-file-style . "bsd")
 6 |   (c-basic-offset . 8))
 7 |  (shell-mode
 8 |   (sh-basic-offset . 8)
 9 |   (sh-indentation . 8))
10 |  (python-mode
11 |   (indent-tabs-mode . nil))
12 |  )
13 | 


--------------------------------------------------------------------------------
/user/spawninit.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int r;
 7 | 	cprintf("i am parent environment %08x\n", thisenv->env_id);
 8 | 	if ((r = spawnl("init", "init", "one", "two", 0)) < 0)
 9 | 		panic("spawnl(init) failed: %e", r);
10 | }
11 | 


--------------------------------------------------------------------------------
/user/badsegment.c:
--------------------------------------------------------------------------------
 1 | // program to cause a general protection exception
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	// Try to load the kernel's TSS selector into the DS register.
 9 | 	asm volatile("movw $0x28,%ax; movw %ax,%ds");
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/lib/wait.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | // Waits until 'envid' exits.
 4 | void
 5 | wait(envid_t envid)
 6 | {
 7 | 	const volatile struct Env *e;
 8 | 
 9 | 	assert(envid != 0);
10 | 	e = &envs[ENVX(envid)];
11 | 	while (e->env_id == envid && e->env_status != ENV_FREE)
12 | 		sys_yield();
13 | }
14 | 


--------------------------------------------------------------------------------
/user/faultnostack.c:
--------------------------------------------------------------------------------
 1 | // test user fault handler being called with no exception stack mapped
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void _pgfault_upcall();
 6 | 
 7 | void
 8 | umain(int argc, char **argv)
 9 | {
10 | 	sys_env_set_pgfault_upcall(0, (void*) _pgfault_upcall);
11 | 	*(int*)0 = 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/kern/time.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_TIME_H
 2 | #define JOS_KERN_TIME_H
 3 | #ifndef JOS_KERNEL
 4 | # error "This is a JOS kernel header; user programs should not #include it"
 5 | #endif
 6 | 
 7 | void time_init(void);
 8 | void time_tick(void);
 9 | unsigned int time_msec(void);
10 | 
11 | #endif /* JOS_KERN_TIME_H */
12 | 


--------------------------------------------------------------------------------
/user/faultevilhandler.c:
--------------------------------------------------------------------------------
 1 | // test evil pointer for user-level fault handler
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	sys_page_alloc(0, (void*) (UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W);
 9 | 	sys_env_set_pgfault_upcall(0, (void*) 0xF0100020);
10 | 	*(int*)0 = 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/setjmp.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_SETJMP_H
 2 | #define JOS_INC_SETJMP_H
 3 | 
 4 | #include <arch/i386/setjmp.h>
 5 | 
 6 | int  jos_setjmp(volatile struct jos_jmp_buf *buf);
 7 | void jos_longjmp(volatile struct jos_jmp_buf *buf, int val)
 8 | 	__attribute__((__noreturn__, JOS_LONGJMP_GCCATTR));
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/user/buggyhello2.c:
--------------------------------------------------------------------------------
 1 | // buggy hello world 2 -- pointed-to region extends into unmapped memory
 2 | // kernel should destroy user environment in response
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | const char *hello = "hello, world\n";
 7 | 
 8 | void
 9 | umain(int argc, char **argv)
10 | {
11 | 	sys_cputs(hello, 1024*1024);
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/user/evilhello.c:
--------------------------------------------------------------------------------
 1 | // evil hello world -- kernel pointer passed to kernel
 2 | // kernel should destroy user environment in response
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	// try to print the kernel entry point as a string!  mua ha ha!
10 | 	sys_cputs((char*)0xf010000c, 100);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/kern/syscall.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_SYSCALL_H
 2 | #define JOS_KERN_SYSCALL_H
 3 | #ifndef JOS_KERNEL
 4 | # error "This is a JOS kernel header; user programs should not #include it"
 5 | #endif
 6 | 
 7 | #include <inc/syscall.h>
 8 | 
 9 | int32_t syscall(uint32_t num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5);
10 | 
11 | #endif /* !JOS_KERN_SYSCALL_H */
12 | 


--------------------------------------------------------------------------------
/kern/sched.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_SCHED_H
 4 | #define JOS_KERN_SCHED_H
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | // This function does not return.
10 | void sched_yield(void) __attribute__((noreturn));
11 | 
12 | #endif	// !JOS_KERN_SCHED_H
13 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/i386/setjmp.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_MACHINE_SETJMP_H
 2 | #define JOS_MACHINE_SETJMP_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | #define JOS_LONGJMP_GCCATTR	regparm(2)
 7 | 
 8 | struct jos_jmp_buf {
 9 |     uint32_t jb_eip;
10 |     uint32_t jb_esp;
11 |     uint32_t jb_ebp;
12 |     uint32_t jb_ebx;
13 |     uint32_t jb_esi;
14 |     uint32_t jb_edi;
15 | };
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/inc/stdarg.h:
--------------------------------------------------------------------------------
 1 | /*	$NetBSD: stdarg.h,v 1.12 1995/12/25 23:15:31 mycroft Exp $	*/
 2 | 
 3 | #ifndef JOS_INC_STDARG_H
 4 | #define	JOS_INC_STDARG_H
 5 | 
 6 | typedef __builtin_va_list va_list;
 7 | 
 8 | #define va_start(ap, last) __builtin_va_start(ap, last)
 9 | 
10 | #define va_arg(ap, type) __builtin_va_arg(ap, type)
11 | 
12 | #define va_end(ap) __builtin_va_end(ap)
13 | 
14 | #endif	/* !JOS_INC_STDARG_H */
15 | 


--------------------------------------------------------------------------------
/user/echo.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int i, nflag;
 7 | 
 8 | 	nflag = 0;
 9 | 	if (argc > 1 && strcmp(argv[1], "-n") == 0) {
10 | 		nflag = 1;
11 | 		argc--;
12 | 		argv++;
13 | 	}
14 | 	for (i = 1; i < argc; i++) {
15 | 		if (i > 1)
16 | 			write(1, " ", 1);
17 | 		write(1, argv[i], strlen(argv[i]));
18 | 	}
19 | 	if (!nflag)
20 | 		write(1, "\n", 1);
21 | }
22 | 


--------------------------------------------------------------------------------
/user/yield.c:
--------------------------------------------------------------------------------
 1 | // yield the processor to other environments
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	int i;
 9 | 
10 | 	cprintf("Hello, I am environment %08x.\n", thisenv->env_id);
11 | 	for (i = 0; i < 5; i++) {
12 | 		sys_yield();
13 | 		cprintf("Back in environment %08x, iteration %d.\n",
14 | 			thisenv->env_id, i);
15 | 	}
16 | 	cprintf("All done in environment %08x.\n", thisenv->env_id);
17 | }
18 | 


--------------------------------------------------------------------------------
/kern/kclock.c:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | /* Support for reading the NVRAM from the real-time clock. */
 4 | 
 5 | #include <inc/x86.h>
 6 | 
 7 | #include <kern/kclock.h>
 8 | 
 9 | 
10 | unsigned
11 | mc146818_read(unsigned reg)
12 | {
13 | 	outb(IO_RTC, reg);
14 | 	return inb(IO_RTC+1);
15 | }
16 | 
17 | void
18 | mc146818_write(unsigned reg, unsigned datum)
19 | {
20 | 	outb(IO_RTC, reg);
21 | 	outb(IO_RTC+1, datum);
22 | }
23 | 


--------------------------------------------------------------------------------
/user/faultdie.c:
--------------------------------------------------------------------------------
 1 | // test user-level fault handler -- just exit when we fault
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | handler(struct UTrapframe *utf)
 7 | {
 8 | 	void *addr = (void*)utf->utf_fault_va;
 9 | 	uint32_t err = utf->utf_err;
10 | 	cprintf("i faulted at va %x, err %x\n", addr, err & 7);
11 | 	sys_env_destroy(sys_getenvid());
12 | }
13 | 
14 | void
15 | umain(int argc, char **argv)
16 | {
17 | 	set_pgfault_handler(handler);
18 | 	*(int*)0xDeadBeef = 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/kern/time.c:
--------------------------------------------------------------------------------
 1 | #include <kern/time.h>
 2 | #include <inc/assert.h>
 3 | 
 4 | static unsigned int ticks;
 5 | 
 6 | void
 7 | time_init(void)
 8 | {
 9 | 	ticks = 0;
10 | }
11 | 
12 | // This should be called once per timer interrupt.  A timer interrupt
13 | // fires every 10 ms.
14 | void
15 | time_tick(void)
16 | {
17 | 	ticks++;
18 | 	if (ticks * 10 < ticks)
19 | 		panic("time_tick: time overflowed");
20 | }
21 | 
22 | unsigned int
23 | time_msec(void)
24 | {
25 | 	return ticks * 10;
26 | }
27 | 


--------------------------------------------------------------------------------
/fs/lorem:
--------------------------------------------------------------------------------
 1 | Lorem ipsum dolor sit amet, consectetur
 2 | adipisicing elit, sed do eiusmod tempor
 3 | incididunt ut labore et dolore magna
 4 | aliqua. Ut enim ad minim veniam, quis
 5 | nostrud exercitation ullamco laboris
 6 | nisi ut aliquip ex ea commodo consequat.
 7 | Duis aute irure dolor in reprehenderit
 8 | in voluptate velit esse cillum dolore eu
 9 | fugiat nulla pariatur. Excepteur sint
10 | occaecat cupidatat non proident, sunt in
11 | culpa qui officia deserunt mollit anim
12 | id est laborum.
13 | 


--------------------------------------------------------------------------------
/boot/sign.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | 
 3 | open(BB, $ARGV[0]) || die "open $ARGV[0]: $!";
 4 | 
 5 | binmode BB;
 6 | my $buf;
 7 | read(BB, $buf, 1000);
 8 | $n = length($buf);
 9 | 
10 | if($n > 510){
11 | 	print STDERR "boot block too large: $n bytes (max 510)\n";
12 | 	exit 1;
13 | }
14 | 
15 | print STDERR "boot block is $n bytes (max 510)\n";
16 | 
17 | $buf .= "\0" x (510-$n);
18 | $buf .= "\x55\xAA";
19 | 
20 | open(BB, ">$ARGV[0]") || die "open >$ARGV[0]: $!";
21 | binmode BB;
22 | print BB $buf;
23 | close BB;
24 | 


--------------------------------------------------------------------------------
/user/faultbadhandler.c:
--------------------------------------------------------------------------------
 1 | // test bad pointer for user-level fault handler
 2 | // this is going to fault in the fault handler accessing eip (always!)
 3 | // so eventually the kernel kills it (PFM_KILL) because
 4 | // we outrun the stack with invocations of the user-level handler
 5 | 
 6 | #include <inc/lib.h>
 7 | 
 8 | void
 9 | umain(int argc, char **argv)
10 | {
11 | 	sys_page_alloc(0, (void*) (UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W);
12 | 	sys_env_set_pgfault_upcall(0, (void*) 0xDeadBeef);
13 | 	*(int*)0 = 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/net/output.c:
--------------------------------------------------------------------------------
 1 | #include "ns.h"
 2 | 
 3 | extern union Nsipc nsipcbuf;
 4 | 
 5 | void
 6 | output(envid_t ns_envid)
 7 | {
 8 | 	binaryname = "ns_output";
 9 | 
10 | 	// LAB 6: Your code here:
11 | 	// 	- read a packet from the network server
12 | 	//	- send the packet to the device driver
13 | 	uint32_t req;
14 | 
15 | 	while (1) {
16 | 		req = ipc_recv(0, &nsipcbuf, 0);
17 | 		if (req == NSREQ_OUTPUT) {
18 | 			while(sys_net_xmit(nsipcbuf.pkt.jp_data, nsipcbuf.pkt.jp_len) < 0) {
19 | 				sys_yield();
20 | 			}
21 | 		}
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/user/testmalloc.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	char *buf;
 7 | 	int n;
 8 | 	void *v;
 9 | 
10 | 	while (1) {
11 | 		buf = readline("> ");
12 | 		if (buf == 0)
13 | 			exit();
14 | 		if (memcmp(buf, "free ", 5) == 0) {
15 | 			v = (void*) strtol(buf + 5, 0, 0);
16 | 			free(v);
17 | 		} else if (memcmp(buf, "malloc ", 7) == 0) {
18 | 			n = strtol(buf + 7, 0, 0);
19 | 			v = malloc(n);
20 | 			printf("\t0x%x\n", (uintptr_t) v);
21 | 		} else
22 | 			printf("?unknown command\n");
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/net/lwip/FILES:
--------------------------------------------------------------------------------
 1 | api/      - The code for the high-level wrapper API. Not needed if
 2 |             you use the lowel-level call-back/raw API.
 3 | 
 4 | core/     - The core of the TPC/IP stack; protocol implementations,
 5 |             memory and buffer management, and the low-level raw API.
 6 | 
 7 | include/  - lwIP include files.
 8 | 
 9 | netif/    - Generic network interface device drivers are kept here,
10 |             as well as the ARP module.
11 | 
12 | For more information on the various subdirectories, check the FILES
13 | file in each directory.
14 | 


--------------------------------------------------------------------------------
/user/idle.c:
--------------------------------------------------------------------------------
 1 | // idle loop
 2 | 
 3 | #include <inc/x86.h>
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	binaryname = "idle";
10 | 
11 | 	// Loop forever, simply trying to yield to a different environment.
12 | 	// Instead of busy-waiting like this,
13 | 	// a better way would be to use the processor's HLT instruction
14 | 	// to cause the processor to stop executing until the next interrupt -
15 | 	// doing so allows the processor to conserve power more effectively.
16 | 	while (1) {
17 | 		sys_yield();
18 | 	}
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/sys_arch.h:
--------------------------------------------------------------------------------
 1 | #ifndef LWIP_ARCH_SYS_ARCH_H
 2 | #define LWIP_ARCH_SYS_ARCH_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | typedef	int sys_sem_t;
 7 | typedef int sys_mbox_t;
 8 | typedef int sys_thread_t;
 9 | 
10 | #define SYS_MBOX_NULL	(-1)
11 | #define SYS_SEM_NULL	(-1)
12 | 
13 | void lwip_core_lock(void);
14 | void lwip_core_unlock(void);
15 | void lwip_core_init(void);
16 | 
17 | #define SYS_ARCH_DECL_PROTECT(lev)
18 | #define SYS_ARCH_PROTECT(lev)
19 | #define SYS_ARCH_UNPROTECT(lev)
20 | 
21 | #define SYS_ARCH_NOWAIT  0xfffffffe
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/net/ns.h:
--------------------------------------------------------------------------------
 1 | #include <inc/ns.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | #define IP "10.0.2.15"
 5 | #define MASK "255.255.255.0"
 6 | #define DEFAULT "10.0.2.2"
 7 | 
 8 | #define TIMER_INTERVAL 250
 9 | 
10 | // Virtual address at which to receive page mappings containing client requests.
11 | #define QUEUE_SIZE	20
12 | #define REQVA		(0x0ffff000 - QUEUE_SIZE * PGSIZE)
13 | 
14 | /* timer.c */
15 | void timer(envid_t ns_envid, uint32_t initial_to);
16 | 
17 | /* input.c */
18 | void input(envid_t ns_envid);
19 | 
20 | /* output.c */
21 | void output(envid_t ns_envid);
22 | 
23 | 


--------------------------------------------------------------------------------
/inc/syscall.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_SYSCALL_H
 2 | #define JOS_INC_SYSCALL_H
 3 | 
 4 | /* system call numbers */
 5 | enum {
 6 | 	SYS_cputs = 0,
 7 | 	SYS_cgetc,
 8 | 	SYS_getenvid,
 9 | 	SYS_env_destroy,
10 | 	SYS_page_alloc,
11 | 	SYS_page_map,
12 | 	SYS_page_unmap,
13 | 	SYS_exofork,
14 | 	SYS_env_set_status,
15 | 	SYS_env_set_trapframe,
16 | 	SYS_env_set_pgfault_upcall,
17 | 	SYS_yield,
18 | 	SYS_ipc_try_send,
19 | 	SYS_ipc_recv,
20 | 	SYS_time_msec,
21 | 	SYS_net_xmit,
22 | 	SYS_net_recv,
23 | 	SYS_net_get_mac,
24 | 	NSYSCALLS
25 | };
26 | 
27 | #endif /* !JOS_INC_SYSCALL_H */
28 | 


--------------------------------------------------------------------------------
/user/fairness.c:
--------------------------------------------------------------------------------
 1 | // Demonstrate lack of fairness in IPC.
 2 | // Start three instances of this program as envs 1, 2, and 3.
 3 | // (user/idle is env 0).
 4 | 
 5 | #include <inc/lib.h>
 6 | 
 7 | void
 8 | umain(int argc, char **argv)
 9 | {
10 | 	envid_t who, id;
11 | 
12 | 	id = sys_getenvid();
13 | 
14 | 	if (thisenv == &envs[1]) {
15 | 		while (1) {
16 | 			ipc_recv(&who, 0, 0);
17 | 			cprintf("%x recv from %x\n", id, who);
18 | 		}
19 | 	} else {
20 | 		cprintf("%x loop sending to %x\n", id, envs[1].env_id);
21 | 		while (1)
22 | 			ipc_send(envs[1].env_id, 0, 0, 0);
23 | 	}
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/thread.h:
--------------------------------------------------------------------------------
 1 | #ifndef LWIP_ARCH_THREAD_H
 2 | #define LWIP_ARCH_THREAD_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | typedef uint32_t thread_id_t;
 7 | 
 8 | void thread_init(void);
 9 | thread_id_t thread_id(void);
10 | void thread_wakeup(volatile uint32_t *addr);
11 | void thread_wait(volatile uint32_t *addr, uint32_t val, uint32_t msec);
12 | int thread_wakeups_pending(void);
13 | int thread_onhalt(void (*fun)(thread_id_t));
14 | int thread_create(thread_id_t *tid, const char *name, 
15 | 		void (*entry)(uint32_t), uint32_t arg);
16 | void thread_yield(void);
17 | void thread_halt(void);
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/user/testkbd.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <inc/lib.h>
 3 | 
 4 | void
 5 | umain(int argc, char **argv)
 6 | {
 7 | 	int i, r;
 8 | 
 9 | 	// Spin for a bit to let the console quiet
10 | 	for (i = 0; i < 10; ++i)
11 | 		sys_yield();
12 | 
13 | 	close(0);
14 | 	if ((r = opencons()) < 0)
15 | 		panic("opencons: %e", r);
16 | 	if (r != 0)
17 | 		panic("first opencons used fd %d", r);
18 | 	if ((r = dup(0, 1)) < 0)
19 | 		panic("dup: %e", r);
20 | 
21 | 	for(;;){
22 | 		char *buf;
23 | 
24 | 		buf = readline("Type a line: ");
25 | 		if (buf != NULL)
26 | 			fprintf(1, "%s\n", buf);
27 | 		else
28 | 			fprintf(1, "(end of file received)\n");
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/panic.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <inc/lib.h>
 3 | 
 4 | /*
 5 |  * Panic is called on unresolvable fatal errors.
 6 |  * It prints "panic: <message>", then causes a breakpoint exception,
 7 |  * which causes JOS to enter the JOS kernel monitor.
 8 |  */
 9 | void
10 | _panic(const char *file, int line, const char *fmt, ...)
11 | {
12 | 	va_list ap;
13 | 
14 | 	va_start(ap, fmt);
15 | 
16 | 	// Print the panic message
17 | 	cprintf("[%08x] user panic in %s at %s:%d: ",
18 | 		sys_getenvid(), binaryname, file, line);
19 | 	vcprintf(fmt, ap);
20 | 	cprintf("\n");
21 | 
22 | 	// Cause a breakpoint exception
23 | 	while (1)
24 | 		asm volatile("int3");
25 | }
26 | 
27 | 


--------------------------------------------------------------------------------
/user/initsh.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int i, r, x, want;
 7 | 
 8 | 	cprintf("initsh: running sh\n");
 9 | 
10 | 	// being run directly from kernel, so no file descriptors open yet
11 | 	close(0);
12 | 	if ((r = opencons()) < 0)
13 | 		panic("opencons: %e", r);
14 | 	if (r != 0)
15 | 		panic("first opencons used fd %d", r);
16 | 	if ((r = dup(0, 1)) < 0)
17 | 		panic("dup: %e", r);
18 | 	while (1) {
19 | 		cprintf("init: starting sh\n");
20 | 		r = spawnl("/sh", "sh", (char*)0);
21 | 		if (r < 0) {
22 | 			cprintf("init: spawn sh: %e\n", r);
23 | 			continue;
24 | 		}
25 | 		wait(r);
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/user/pingpong.c:
--------------------------------------------------------------------------------
 1 | // Ping-pong a counter between two processes.
 2 | // Only need to start one of these -- splits into two with fork.
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	envid_t who;
10 | 
11 | 	if ((who = fork()) != 0) {
12 | 		// get the ball rolling
13 | 		cprintf("send 0 from %x to %x\n", sys_getenvid(), who);
14 | 		ipc_send(who, 0, 0, 0);
15 | 	}
16 | 
17 | 	while (1) {
18 | 		uint32_t i = ipc_recv(&who, 0, 0);
19 | 		cprintf("%x got %d from %x\n", sys_getenvid(), i, who);
20 | 		if (i == 10)
21 | 			return;
22 | 		i++;
23 | 		ipc_send(who, i, 0, 0);
24 | 		if (i == 10)
25 | 			return;
26 | 	}
27 | 
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/user/faultalloc.c:
--------------------------------------------------------------------------------
 1 | // test user-level fault handler -- alloc pages to fix faults
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | void
 6 | handler(struct UTrapframe *utf)
 7 | {
 8 | 	int r;
 9 | 	void *addr = (void*)utf->utf_fault_va;
10 | 
11 | 	cprintf("fault %x\n", addr);
12 | 	if ((r = sys_page_alloc(0, ROUNDDOWN(addr, PGSIZE),
13 | 				PTE_P|PTE_U|PTE_W)) < 0)
14 | 		panic("allocating at %x in page fault handler: %e", addr, r);
15 | 	snprintf((char*) addr, 100, "this string was faulted in at %x", addr);
16 | }
17 | 
18 | void
19 | umain(int argc, char **argv)
20 | {
21 | 	set_pgfault_handler(handler);
22 | 	cprintf("%s\n", (char*)0xDeadBeef);
23 | 	cprintf("%s\n", (char*)0xCafeBffe);
24 | }
25 | 


--------------------------------------------------------------------------------
/kern/kdebug.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_KDEBUG_H
 2 | #define JOS_KERN_KDEBUG_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | // Debug information about a particular instruction pointer
 7 | struct Eipdebuginfo {
 8 | 	const char *eip_file;		// Source code filename for EIP
 9 | 	int eip_line;			// Source code linenumber for EIP
10 | 
11 | 	const char *eip_fn_name;	// Name of function containing EIP
12 | 					//  - Note: not null terminated!
13 | 	int eip_fn_namelen;		// Length of function name
14 | 	uintptr_t eip_fn_addr;		// Address of start of function
15 | 	int eip_fn_narg;		// Number of function arguments
16 | };
17 | 
18 | int debuginfo_eip(uintptr_t eip, struct Eipdebuginfo *info);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/user/Makefrag:
--------------------------------------------------------------------------------
 1 | OBJDIRS += user
 2 | 
 3 | USERLIBS += lwip
 4 | 
 5 | USERLIBS += jos
 6 | 
 7 | $(OBJDIR)/user/%.o: user/%.c $(OBJDIR)/.vars.USER_CFLAGS
 8 | 	@echo + cc[USER] $<
 9 | 	@mkdir -p $(@D)
10 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
11 | 
12 | $(OBJDIR)/user/%: $(OBJDIR)/user/%.o $(OBJDIR)/lib/entry.o $(USERLIBS:%=$(OBJDIR)/lib/lib%.a) user/user.ld
13 | 	@echo + ld $@
14 | 	$(V)$(LD) -o $@.debug $(ULDFLAGS) $(LDFLAGS) -nostdlib $(OBJDIR)/lib/entry.o $@.o -L$(OBJDIR)/lib $(USERLIBS:%=-l%) $(GCC_LIB)
15 | 	$(V)$(OBJDUMP) -S $@.debug > $@.asm
16 | 	$(V)$(NM) -n $@.debug > $@.sym
17 | 	$(V)$(OBJCOPY) -R .stab -R .stabstr --add-gnu-debuglink=$(basename $@.debug) $@.debug $@
18 | 
19 | 


--------------------------------------------------------------------------------
/inc/assert.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_INC_ASSERT_H
 4 | #define JOS_INC_ASSERT_H
 5 | 
 6 | #include <inc/stdio.h>
 7 | 
 8 | void _warn(const char*, int, const char*, ...);
 9 | void _panic(const char*, int, const char*, ...) __attribute__((noreturn));
10 | 
11 | #define warn(...) _warn(__FILE__, __LINE__, __VA_ARGS__)
12 | #define panic(...) _panic(__FILE__, __LINE__, __VA_ARGS__)
13 | 
14 | #define assert(x)		\
15 | 	do { if (!(x)) panic("assertion failed: %s", #x); } while (0)
16 | 
17 | // static_assert(x) will generate a compile-time error if 'x' is false.
18 | #define static_assert(x)	switch (x) case 0: case (x):
19 | 
20 | #endif /* !JOS_INC_ASSERT_H */
21 | 


--------------------------------------------------------------------------------
/kern/trap.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_TRAP_H
 4 | #define JOS_KERN_TRAP_H
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | #include <inc/trap.h>
10 | #include <inc/mmu.h>
11 | 
12 | /* The kernel's interrupt descriptor table */
13 | extern struct Gatedesc idt[];
14 | extern struct Pseudodesc idt_pd;
15 | 
16 | void trap_init(void);
17 | void trap_init_percpu(void);
18 | void print_regs(struct PushRegs *regs);
19 | void print_trapframe(struct Trapframe *tf);
20 | void page_fault_handler(struct Trapframe *);
21 | void backtrace(struct Trapframe *);
22 | 
23 | #endif /* JOS_KERN_TRAP_H */
24 | 


--------------------------------------------------------------------------------
/kern/pci.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_PCI_H
 2 | #define JOS_KERN_PCI_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | // PCI subsystem interface
 7 | enum { pci_res_bus, pci_res_mem, pci_res_io, pci_res_max };
 8 | 
 9 | struct pci_bus;
10 | 
11 | struct pci_func {
12 |     struct pci_bus *bus;	// Primary bus for bridges
13 | 
14 |     uint32_t dev;
15 |     uint32_t func;
16 | 
17 |     uint32_t dev_id;
18 |     uint32_t dev_class;
19 | 
20 |     uint32_t reg_base[6];
21 |     uint32_t reg_size[6];
22 |     uint8_t irq_line;
23 | };
24 | 
25 | struct pci_bus {
26 |     struct pci_func *parent_bridge;
27 |     uint32_t busno;
28 | };
29 | 
30 | int  pci_init(void);
31 | void pci_func_enable(struct pci_func *f);
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/user/forktree.c:
--------------------------------------------------------------------------------
 1 | // Fork a binary tree of processes and display their structure.
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | #define DEPTH 3
 6 | 
 7 | void forktree(const char *cur);
 8 | 
 9 | void
10 | forkchild(const char *cur, char branch)
11 | {
12 | 	char nxt[DEPTH+1];
13 | 
14 | 	if (strlen(cur) >= DEPTH)
15 | 		return;
16 | 
17 | 	snprintf(nxt, DEPTH+1, "%s%c", cur, branch);
18 | 	if (fork() == 0) {
19 | 		forktree(nxt);
20 | 		exit();
21 | 	}
22 | }
23 | 
24 | void
25 | forktree(const char *cur)
26 | {
27 | 	cprintf("%04x: I am '%s'\n", sys_getenvid(), cur);
28 | 
29 | 	forkchild(cur, '0');
30 | 	forkchild(cur, '1');
31 | }
32 | 
33 | void
34 | umain(int argc, char **argv)
35 | {
36 | 	forktree("");
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/user/faultallocbad.c:
--------------------------------------------------------------------------------
 1 | // test user-level fault handler -- alloc pages to fix faults
 2 | // doesn't work because we sys_cputs instead of cprintf (exercise: why?)
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | handler(struct UTrapframe *utf)
 8 | {
 9 | 	int r;
10 | 	void *addr = (void*)utf->utf_fault_va;
11 | 
12 | 	cprintf("fault %x\n", addr);
13 | 	if ((r = sys_page_alloc(0, ROUNDDOWN(addr, PGSIZE),
14 | 				PTE_P|PTE_U|PTE_W)) < 0)
15 | 		panic("allocating at %x in page fault handler: %e", addr, r);
16 | 	snprintf((char*) addr, 100, "this string was faulted in at %x", addr);
17 | }
18 | 
19 | void
20 | umain(int argc, char **argv)
21 | {
22 | 	set_pgfault_handler(handler);
23 | 	sys_cputs((char*)0xDEADBEEF, 4);
24 | }
25 | 


--------------------------------------------------------------------------------
/user/icode.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int fd, n, r;
 7 | 	char buf[512+1];
 8 | 
 9 | 	binaryname = "icode";
10 | 
11 | 	cprintf("icode startup\n");
12 | 
13 | 	cprintf("icode: open /motd\n");
14 | 	if ((fd = open("/motd", O_RDONLY)) < 0)
15 | 		panic("icode: open /motd: %e", fd);
16 | 
17 | 	cprintf("icode: read /motd\n");
18 | 	while ((n = read(fd, buf, sizeof buf-1)) > 0)
19 | 		sys_cputs(buf, n);
20 | 
21 | 	cprintf("icode: close /motd\n");
22 | 	close(fd);
23 | 
24 | 	cprintf("icode: spawn /init\n");
25 | 	if ((r = spawnl("/init", "init", "initarg1", "initarg2", (char*)0)) < 0)
26 | 		panic("icode: spawn /init: %e", r);
27 | 
28 | 	cprintf("icode: exiting\n");
29 | }
30 | 


--------------------------------------------------------------------------------
/user/cat.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | char buf[8192];
 4 | 
 5 | void
 6 | cat(int f, char *s)
 7 | {
 8 | 	long n;
 9 | 	int r;
10 | 
11 | 	while ((n = read(f, buf, (long)sizeof(buf))) > 0)
12 | 		if ((r = write(1, buf, n)) != n)
13 | 			panic("write error copying %s: %e", s, r);
14 | 	if (n < 0)
15 | 		panic("error reading %s: %e", s, n);
16 | }
17 | 
18 | void
19 | umain(int argc, char **argv)
20 | {
21 | 	int f, i;
22 | 
23 | 	binaryname = "cat";
24 | 	if (argc == 1)
25 | 		cat(0, "<stdin>");
26 | 	else
27 | 		for (i = 1; i < argc; i++) {
28 | 			f = open(argv[i], O_RDONLY);
29 | 			if (f < 0)
30 | 				printf("can't open %s: %e\n", argv[i], f);
31 | 			else {
32 | 				cat(f, argv[i]);
33 | 				close(f);
34 | 			}
35 | 		}
36 | }
37 | 


--------------------------------------------------------------------------------
/net/timer.c:
--------------------------------------------------------------------------------
 1 | #include "ns.h"
 2 | 
 3 | void
 4 | timer(envid_t ns_envid, uint32_t initial_to) {
 5 | 	int r;
 6 | 	uint32_t stop = sys_time_msec() + initial_to;
 7 | 
 8 | 	binaryname = "ns_timer";
 9 | 
10 | 	while (1) {
11 | 		while((r = sys_time_msec()) < stop && r >= 0) {
12 | 			sys_yield();
13 | 		}
14 | 		if (r < 0)
15 | 			panic("sys_time_msec: %e", r);
16 | 
17 | 		ipc_send(ns_envid, NSREQ_TIMER, 0, 0);
18 | 
19 | 		while (1) {
20 | 			uint32_t to, whom;
21 | 			to = ipc_recv((int32_t *) &whom, 0, 0);
22 | 
23 | 			if (whom != ns_envid) {
24 | 				cprintf("NS TIMER: timer thread got IPC message from env %x not NS\n", whom);
25 | 				continue;
26 | 			}
27 | 
28 | 			stop = sys_time_msec() + to;
29 | 			break;
30 | 		}
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/user/testtime.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | #include <inc/x86.h>
 3 | 
 4 | void
 5 | sleep(int sec)
 6 | {
 7 | 	unsigned now = sys_time_msec();
 8 | 	unsigned end = now + sec * 1000;
 9 | 
10 | 	if ((int)now < 0 && (int)now > -MAXERROR)
11 | 		panic("sys_time_msec: %e", (int)now);
12 | 	if (end < now)
13 | 		panic("sleep: wrap");
14 | 
15 | 	while (sys_time_msec() < end)
16 | 		sys_yield();
17 | }
18 | 
19 | void
20 | umain(int argc, char **argv)
21 | {
22 | 	int i;
23 | 
24 | 	// Wait for the console to calm down
25 | 	for (i = 0; i < 50; i++)
26 | 		sys_yield();
27 | 
28 | 	cprintf("starting count down: ");
29 | 	for (i = 5; i >= 0; i--) {
30 | 		cprintf("%d ", i);
31 | 		sleep(1);
32 | 	}
33 | 	cprintf("\n");
34 | 	breakpoint();
35 | }
36 | 


--------------------------------------------------------------------------------
/lib/libmain.c:
--------------------------------------------------------------------------------
 1 | // Called from entry.S to get us going.
 2 | // entry.S already took care of defining envs, pages, uvpd, and uvpt.
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | extern void umain(int argc, char **argv);
 7 | 
 8 | const volatile struct Env *thisenv;
 9 | const char *binaryname = "<unknown>";
10 | 
11 | void
12 | libmain(int argc, char **argv)
13 | {
14 | 	// set thisenv to point at our Env structure in envs[].
15 | 	// LAB 3: Your code here.
16 | 	thisenv = (struct Env *) envs + ENVX(sys_getenvid());
17 | 
18 | 	// save the name of the program so that panic() can use it
19 | 	if (argc > 0)
20 | 		binaryname = argv[0];
21 | 
22 | 	// call user main routine
23 | 	umain(argc, argv);
24 | 
25 | 	// exit gracefully
26 | 	exit();
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/user/testbss.c:
--------------------------------------------------------------------------------
 1 | // test reads and writes to a large bss
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | #define ARRAYSIZE (1024*1024)
 6 | 
 7 | uint32_t bigarray[ARRAYSIZE];
 8 | 
 9 | void
10 | umain(int argc, char **argv)
11 | {
12 | 	int i;
13 | 
14 | 	cprintf("Making sure bss works right...\n");
15 | 	for (i = 0; i < ARRAYSIZE; i++)
16 | 		if (bigarray[i] != 0)
17 | 			panic("bigarray[%d] isn't cleared!\n", i);
18 | 	for (i = 0; i < ARRAYSIZE; i++)
19 | 		bigarray[i] = i;
20 | 	for (i = 0; i < ARRAYSIZE; i++)
21 | 		if (bigarray[i] != i)
22 | 			panic("bigarray[%d] didn't hold its value!\n", i);
23 | 
24 | 	cprintf("Yes, good.  Now doing a wild write off the end...\n");
25 | 	bigarray[ARRAYSIZE+1024] = 0;
26 | 	panic("SHOULD HAVE TRAPPED!!!");
27 | }
28 | 


--------------------------------------------------------------------------------
/user/spin.c:
--------------------------------------------------------------------------------
 1 | // Test preemption by forking off a child process that just spins forever.
 2 | // Let it run for a couple time slices, then kill it.
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	envid_t env;
10 | 
11 | 	cprintf("I am the parent.  Forking the child...\n");
12 | 	if ((env = fork()) == 0) {
13 | 		cprintf("I am the child.  Spinning...\n");
14 | 		while (1)
15 | 			/* do nothing */;
16 | 	}
17 | 
18 | 	cprintf("I am the parent.  Running the child...\n");
19 | 	sys_yield();
20 | 	sys_yield();
21 | 	sys_yield();
22 | 	sys_yield();
23 | 	sys_yield();
24 | 	sys_yield();
25 | 	sys_yield();
26 | 	sys_yield();
27 | 
28 | 	cprintf("I am the parent.  Killing the child...\n");
29 | 	sys_env_destroy(env);
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/kern/console.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef _CONSOLE_H_
 4 | #define _CONSOLE_H_
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | #include <inc/types.h>
10 | 
11 | #define MONO_BASE	0x3B4
12 | #define MONO_BUF	0xB0000
13 | #define CGA_BASE	0x3D4
14 | #define CGA_BUF		0xB8000
15 | 
16 | #define CRT_ROWS	25
17 | #define CRT_COLS	80
18 | #define CRT_SIZE	(CRT_ROWS * CRT_COLS)
19 | 
20 | void cons_init(void);
21 | int cons_getc(void);
22 | 
23 | void kbd_intr(void); // irq 1
24 | void serial_intr(void); // irq 4
25 | 
26 | void cons_ctrl_putc(int c);
27 | void cons_disp_putc(int c);
28 | 
29 | typedef enum {NORMAL, START, ESCAPING, OVERFLOW} ansi_state;
30 | 
31 | #endif /* _CONSOLE_H_ */
32 | 


--------------------------------------------------------------------------------
/conf/env.mk:
--------------------------------------------------------------------------------
 1 | # env.mk - configuration variables for the JOS lab
 2 | 
 3 | # '$(V)' controls whether the lab makefiles print verbose commands (the
 4 | # actual shell commands run by Make), as well as the "overview" commands
 5 | # (such as '+ cc lib/readline.c').
 6 | #
 7 | # For overview commands only, the line should read 'V = @'.
 8 | # For overview and verbose commands, the line should read 'V ='.
 9 | V = @
10 | 
11 | # If your system-standard GNU toolchain is ELF-compatible, then comment
12 | # out the following line to use those tools (as opposed to the i386-jos-elf
13 | # tools that the 6.828 make system looks for by default).
14 | #
15 | # GCCPREFIX=''
16 | 
17 | # If the makefile cannot find your QEMU binary, uncomment the
18 | # following line and set it to the full path to QEMU.
19 | #
20 | # QEMU=
21 | 


--------------------------------------------------------------------------------
/net/input.c:
--------------------------------------------------------------------------------
 1 | #include "ns.h"
 2 | 
 3 | extern union Nsipc nsipcbuf;
 4 | 
 5 | void
 6 | input(envid_t ns_envid)
 7 | {
 8 | 	binaryname = "ns_input";
 9 | 
10 | 	// LAB 6: Your code here:
11 | 	// 	- read a packet from the device driver
12 | 	//	- send it to the network server
13 | 	// Hint: When you IPC a page to the network server, it will be
14 | 	// reading from it for a while, so don't immediately receive
15 | 	// another packet in to the same physical page.
16 | 
17 | 	while(1) {
18 | 	    while(sys_page_alloc(0, &nsipcbuf, PTE_U | PTE_P | PTE_W) < 0);
19 | 	    while((nsipcbuf.pkt.jp_len = sys_net_recv(nsipcbuf.pkt.jp_data)) < 0) {
20 | 	    		// cprintf("haha\n");
21 | 				sys_yield();
22 | 		}
23 | 		while (sys_ipc_try_send(ns_envid, NSREQ_INPUT, &nsipcbuf, PTE_U | PTE_P | PTE_W) < 0);
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/user/lsfd.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | usage(void)
 5 | {
 6 | 	cprintf("usage: lsfd [-1]\n");
 7 | 	exit();
 8 | }
 9 | 
10 | void
11 | umain(int argc, char **argv)
12 | {
13 | 	int i, usefprint = 0;
14 | 	struct Stat st;
15 | 	struct Argstate args;
16 | 
17 | 	argstart(&argc, argv, &args);
18 | 	while ((i = argnext(&args)) >= 0)
19 | 		if (i == '1')
20 | 			usefprint = 1;
21 | 		else
22 | 			usage();
23 | 
24 | 	for (i = 0; i < 32; i++)
25 | 		if (fstat(i, &st) >= 0) {
26 | 			if (usefprint)
27 | 				fprintf(1, "fd %d: name %s isdir %d size %d dev %s\n",
28 | 					i, st.st_name, st.st_isdir,
29 | 					st.st_size, st.st_dev->dev_name);
30 | 			else
31 | 				cprintf("fd %d: name %s isdir %d size %d dev %s\n",
32 | 					i, st.st_name, st.st_isdir,
33 | 					st.st_size, st.st_dev->dev_name);
34 | 		}
35 | }
36 | 


--------------------------------------------------------------------------------
/grade-lab2:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | from gradelib import *
 4 | 
 5 | r = Runner(save("jos.out"),
 6 |            stop_breakpoint("readline"))
 7 | 
 8 | @test(0, "running JOS")
 9 | def test_jos():
10 |     r.run_qemu()
11 | 
12 | @test(20, "Physical page allocator", parent=test_jos)
13 | def test_check_page_alloc():
14 |     r.match(r"check_page_alloc\(\) succeeded!")
15 | 
16 | @test(20, "Page management", parent=test_jos)
17 | def test_check_page():
18 |     r.match(r"check_page\(\) succeeded!")
19 | 
20 | @test(20, "Kernel page directory", parent=test_jos)
21 | def test_check_kern_pgdir():
22 |     r.match(r"check_kern_pgdir\(\) succeeded!")
23 | 
24 | @test(10, "Page management 2", parent=test_jos)
25 | def test_check_page_installed_pgdir():
26 |     r.match(r"check_page_installed_pgdir\(\) succeeded!")
27 | 
28 | run_tests()
29 | 


--------------------------------------------------------------------------------
/kern/picirq.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_PICIRQ_H
 4 | #define JOS_KERN_PICIRQ_H
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | #define MAX_IRQS	16	// Number of IRQs
10 | 
11 | // I/O Addresses of the two 8259A programmable interrupt controllers
12 | #define IO_PIC1		0x20	// Master (IRQs 0-7)
13 | #define IO_PIC2		0xA0	// Slave (IRQs 8-15)
14 | 
15 | #define IRQ_SLAVE	2	// IRQ at which slave connects to master
16 | 
17 | 
18 | #ifndef __ASSEMBLER__
19 | 
20 | #include <inc/types.h>
21 | #include <inc/x86.h>
22 | 
23 | extern uint16_t irq_mask_8259A;
24 | void pic_init(void);
25 | void irq_setmask_8259A(uint16_t mask);
26 | void irq_eoi(void);
27 | #endif // !__ASSEMBLER__
28 | 
29 | #endif // !JOS_KERN_PICIRQ_H
30 | 


--------------------------------------------------------------------------------
/user/pingpongs.c:
--------------------------------------------------------------------------------
 1 | // Ping-pong a counter between two shared-memory processes.
 2 | // Only need to start one of these -- splits into two with sfork.
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | uint32_t val;
 7 | 
 8 | void
 9 | umain(int argc, char **argv)
10 | {
11 | 	envid_t who;
12 | 	uint32_t i;
13 | 
14 | 	i = 0;
15 | 	if ((who = sfork()) != 0) {
16 | 		cprintf("i am %08x; thisenv is %p\n", sys_getenvid(), thisenv);
17 | 		// get the ball rolling
18 | 		cprintf("send 0 from %x to %x\n", sys_getenvid(), who);
19 | 		ipc_send(who, 0, 0, 0);
20 | 	}
21 | 
22 | 	while (1) {
23 | 		ipc_recv(&who, 0, 0);
24 | 		cprintf("%x got %d from %x (thisenv is %p %x)\n", sys_getenvid(), val, who, thisenv, thisenv->env_id);
25 | 		if (val == 10)
26 | 			return;
27 | 		++val;
28 | 		ipc_send(who, 0, 0, 0);
29 | 		if (val == 10)
30 | 			return;
31 | 	}
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/cc.h:
--------------------------------------------------------------------------------
 1 | #ifndef LWIP_ARCH_CC_H
 2 | #define LWIP_ARCH_CC_H
 3 | 
 4 | #include <inc/types.h>
 5 | #include <inc/assert.h>
 6 | 
 7 | typedef uint32_t u32_t;
 8 | typedef int32_t s32_t;
 9 | 
10 | typedef uint64_t u64_t;
11 | typedef int64_t s64_t;
12 | 
13 | typedef uint16_t u16_t;
14 | typedef int16_t s16_t;
15 | 
16 | typedef uint8_t u8_t;
17 | typedef int8_t s8_t;
18 | 
19 | typedef uintptr_t mem_ptr_t;
20 | 
21 | #define PACK_STRUCT_FIELD(x)	x
22 | #define PACK_STRUCT_STRUCT
23 | #define PACK_STRUCT_BEGIN
24 | #define PACK_STRUCT_END
25 | 
26 | #define S16_F	"d"
27 | #define U16_F	"u"
28 | #define X16_F	"x"
29 | 
30 | #define S32_F	"d"
31 | #define U32_F	"u"
32 | #define X32_F	"x"
33 | 
34 | #define LWIP_PLATFORM_DIAG(x)	cprintf x
35 | #define LWIP_PLATFORM_ASSERT(x)	panic(x)
36 | 
37 | #ifndef BYTE_ORDER
38 | #define BYTE_ORDER LITTLE_ENDIAN
39 | #endif
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/user/num.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | int bol = 1;
 4 | int line = 0;
 5 | 
 6 | void
 7 | num(int f, const char *s)
 8 | {
 9 | 	long n;
10 | 	int r;
11 | 	char c;
12 | 
13 | 	while ((n = read(f, &c, 1)) > 0) {
14 | 		if (bol) {
15 | 			printf("%5d ", ++line);
16 | 			bol = 0;
17 | 		}
18 | 		if ((r = write(1, &c, 1)) != 1)
19 | 			panic("write error copying %s: %e", s, r);
20 | 		if (c == '\n')
21 | 			bol = 1;
22 | 	}
23 | 	if (n < 0)
24 | 		panic("error reading %s: %e", s, n);
25 | }
26 | 
27 | void
28 | umain(int argc, char **argv)
29 | {
30 | 	int f, i;
31 | 
32 | 	binaryname = "num";
33 | 	if (argc == 1)
34 | 		num(0, "<stdin>");
35 | 	else
36 | 		for (i = 1; i < argc; i++) {
37 | 			f = open(argv[i], O_RDONLY);
38 | 			if (f < 0)
39 | 				panic("can't open %s: %e", argv[i], f);
40 | 			else {
41 | 				num(f, argv[i]);
42 | 				close(f);
43 | 			}
44 | 		}
45 | 	exit();
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/longjmp.S:
--------------------------------------------------------------------------------
 1 | #ifndef _ALIGN_TEXT
 2 | #define _ALIGN_TEXT .align 16, 0x90
 3 | #endif
 4 | 
 5 | #define ENTRY(x) \
 6 |         .text; _ALIGN_TEXT; .globl x; .type x,@function; x:
 7 | 
 8 | 
 9 | ENTRY(jos_setjmp)
10 | 	movl	4(%esp), %ecx	// jos_jmp_buf
11 | 
12 | 	movl	0(%esp), %edx	// %eip as pushed by call
13 | 	movl	%edx,  0(%ecx)
14 | 
15 | 	leal	4(%esp), %edx	// where %esp will point when we return
16 | 	movl	%edx,  4(%ecx)
17 | 
18 | 	movl	%ebp,  8(%ecx)
19 | 	movl	%ebx, 12(%ecx)
20 | 	movl	%esi, 16(%ecx)
21 | 	movl	%edi, 20(%ecx)
22 | 
23 | 	movl	$0, %eax
24 | 	ret
25 | 
26 | ENTRY(jos_longjmp)
27 | 	// %eax is the jos_jmp_buf*
28 | 	// %edx is the return value
29 | 
30 | 	movl	 0(%eax), %ecx	// %eip
31 | 	movl	 4(%eax), %esp
32 | 	movl	 8(%eax), %ebp
33 | 	movl	12(%eax), %ebx
34 | 	movl	16(%eax), %esi
35 | 	movl	20(%eax), %edi
36 | 
37 | 	movl	%edx, %eax
38 | 	jmp	*%ecx
39 | 
40 | 


--------------------------------------------------------------------------------
/lib/readline.c:
--------------------------------------------------------------------------------
 1 | #include <inc/stdio.h>
 2 | #include <inc/error.h>
 3 | 
 4 | #define BUFLEN 1024
 5 | static char buf[BUFLEN];
 6 | 
 7 | char *
 8 | readline(const char *prompt)
 9 | {
10 | 	int i, c, echoing;
11 | 
12 | #if JOS_KERNEL
13 | 	if (prompt != NULL)
14 | 		cprintf("%s", prompt);
15 | #else
16 | 	if (prompt != NULL)
17 | 		fprintf(1, "%s", prompt);
18 | #endif
19 | 
20 | 	i = 0;
21 | 	echoing = iscons(0);
22 | 	while (1) {
23 | 		c = getchar();
24 | 		if (c < 0) {
25 | 			if (c != -E_EOF)
26 | 				cprintf("read error: %e\n", c);
27 | 			return NULL;
28 | 		} else if ((c == '\b' || c == '\x7f') && i > 0) {
29 | 			if (echoing)
30 | 				cputchar('\b');
31 | 			i--;
32 | 		} else if (c >= ' ' && i < BUFLEN-1) {
33 | 			if (echoing)
34 | 				cputchar(c);
35 | 			buf[i++] = c;
36 | 		} else if (c == '\n' || c == '\r') {
37 | 			if (echoing)
38 | 				cputchar('\n');
39 | 			buf[i] = 0;
40 | 			return buf;
41 | 		}
42 | 	}
43 | }
44 | 
45 | 


--------------------------------------------------------------------------------
/inc/partition.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_PARTITION_H
 2 | #define JOS_INC_PARTITION_H
 3 | #include <inc/types.h>
 4 | 
 5 | /*
 6 |  * This file contains definitions for x86 partition tables, and comes from
 7 |  * Mike Mammarella.
 8 |  */
 9 | 
10 | // Offset of 1st partition descriptor in a partition sector
11 | #define PTABLE_OFFSET		446
12 | // 2-byte partition table magic number location and value
13 | #define PTABLE_MAGIC_OFFSET	510
14 | #define PTABLE_MAGIC		"\x55\xAA"
15 | 
16 | // Partition type constants
17 | #define PTYPE_JOS_KERN		0x27	// JOS kernel
18 | #define PTYPE_JOSFS		0x28	// JOS file system
19 | // Extended partition identifiers
20 | #define PTYPE_DOS_EXTENDED	0x05
21 | #define PTYPE_W95_EXTENDED	0x0F
22 | #define PTYPE_LINUX_EXTENDED	0x85
23 | 
24 | struct Partitiondesc {
25 | 	uint8_t boot;
26 | 	uint8_t chs_begin[3];
27 | 	uint8_t type;
28 | 	uint8_t chs_end[3];
29 | 	uint32_t lba_start;
30 | 	uint32_t lba_length;
31 | };
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/user/stresssched.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | volatile int counter;
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	int i, j;
 9 | 	int seen;
10 | 	envid_t parent = sys_getenvid();
11 | 
12 | 	// Fork several environments
13 | 	for (i = 0; i < 20; i++)
14 | 		if (fork() == 0)
15 | 			break;
16 | 	if (i == 20) {
17 | 		sys_yield();
18 | 		return;
19 | 	}
20 | 
21 | 	// Wait for the parent to finish forking
22 | 	while (envs[ENVX(parent)].env_status != ENV_FREE)
23 | 		asm volatile("pause");
24 | 
25 | 	// Check that one environment doesn't run on two CPUs at once
26 | 	for (i = 0; i < 10; i++) {
27 | 		sys_yield();
28 | 		for (j = 0; j < 10000; j++)
29 | 			counter++;
30 | 	}
31 | 
32 | 	if (counter != 10*10000)
33 | 		panic("ran on two CPUs at once (counter is %d)", counter);
34 | 
35 | 	// Check that we see environments running on different CPUs
36 | 	cprintf("[%08x] stresssched on CPU %d\n", thisenv->env_id, thisenv->env_cpunum);
37 | 
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/lib/entry.S:
--------------------------------------------------------------------------------
 1 | #include <inc/mmu.h>
 2 | #include <inc/memlayout.h>
 3 | 
 4 | .data
 5 | // Define the global symbols 'envs', 'pages', 'uvpt', and 'uvpd'
 6 | // so that they can be used in C as if they were ordinary global arrays.
 7 | 	.globl envs
 8 | 	.set envs, UENVS
 9 | 	.globl pages
10 | 	.set pages, UPAGES
11 | 	.globl uvpt
12 | 	.set uvpt, UVPT
13 | 	.globl uvpd
14 | 	.set uvpd, (UVPT+(UVPT>>12)*4)
15 | 
16 | 
17 | // Entrypoint - this is where the kernel (or our parent environment)
18 | // starts us running when we are initially loaded into a new environment.
19 | .text
20 | .globl _start
21 | _start:
22 | 	// See if we were started with arguments on the stack
23 | 	cmpl $USTACKTOP, %esp
24 | 	jne args_exist
25 | 
26 | 	// If not, push dummy argc/argv arguments.
27 | 	// This happens when we are loaded by the kernel,
28 | 	// because the kernel does not know about passing arguments.
29 | 	pushl $0
30 | 	pushl $0
31 | 
32 | args_exist:
33 | 	call libmain
34 | 1:	jmp 1b
35 | 
36 | 


--------------------------------------------------------------------------------
/inc/stdio.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_STDIO_H
 2 | #define JOS_INC_STDIO_H
 3 | 
 4 | #include <inc/stdarg.h>
 5 | 
 6 | #ifndef NULL
 7 | #define NULL	((void *) 0)
 8 | #endif /* !NULL */
 9 | 
10 | // lib/stdio.c
11 | void	cputchar(int c);
12 | int	getchar(void);
13 | int	iscons(int fd);
14 | 
15 | // lib/printfmt.c
16 | void	printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...);
17 | void	vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list);
18 | int	snprintf(char *str, int size, const char *fmt, ...);
19 | int	vsnprintf(char *str, int size, const char *fmt, va_list);
20 | 
21 | // lib/printf.c
22 | int	cprintf(const char *fmt, ...);
23 | int	vcprintf(const char *fmt, va_list);
24 | 
25 | // lib/fprintf.c
26 | int	printf(const char *fmt, ...);
27 | int	fprintf(int fd, const char *fmt, ...);
28 | int	vfprintf(int fd, const char *fmt, va_list);
29 | 
30 | // lib/readline.c
31 | char*	readline(const char *prompt);
32 | 
33 | #endif /* !JOS_INC_STDIO_H */
34 | 


--------------------------------------------------------------------------------
/inc/string.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_STRING_H
 2 | #define JOS_INC_STRING_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | int	strlen(const char *s);
 7 | int	strnlen(const char *s, size_t size);
 8 | char *	strcpy(char *dst, const char *src);
 9 | char *	strncpy(char *dst, const char *src, size_t size);
10 | char *	strcat(char *dst, const char *src);
11 | size_t	strlcpy(char *dst, const char *src, size_t size);
12 | int	strcmp(const char *s1, const char *s2);
13 | int	strncmp(const char *s1, const char *s2, size_t size);
14 | char *	strchr(const char *s, char c);
15 | char *	strfind(const char *s, char c);
16 | 
17 | void *	memset(void *dst, int c, size_t len);
18 | void *	memcpy(void *dst, const void *src, size_t len);
19 | void *	memmove(void *dst, const void *src, size_t len);
20 | int	memcmp(const void *s1, const void *s2, size_t len);
21 | void *	memfind(const void *s, int c, size_t len);
22 | 
23 | long	strtol(const char *s, char **endptr, int base);
24 | 
25 | #endif /* not JOS_INC_STRING_H */
26 | 


--------------------------------------------------------------------------------
/.gdbinit.tmpl:
--------------------------------------------------------------------------------
 1 | set $lastcs = -1
 2 | 
 3 | define hook-stop
 4 |   # There doesn't seem to be a good way to detect if we're in 16- or
 5 |   # 32-bit mode, but we always run with CS == 8 in 32-bit mode.
 6 |   if $cs == 8 || $cs == 27
 7 |     if $lastcs != 8 && $lastcs != 27
 8 |       set architecture i386
 9 |     end
10 |     x/i $pc
11 |   else
12 |     if $lastcs == -1 || $lastcs == 8 || $lastcs == 27
13 |       set architecture i8086
14 |     end
15 |     # Translate the segment:offset into a physical address
16 |     printf "[%4x:%4x] ", $cs, $eip
17 |     x/i $cs*16+$eip
18 |   end
19 |   set $lastcs = $cs
20 | end
21 | 
22 | echo + target remote localhost:1234\n
23 | target remote localhost:1234
24 | 
25 | # If this fails, it's probably because your GDB doesn't support ELF.
26 | # Look at the tools page at
27 | #  http://pdos.csail.mit.edu/6.828/2009/tools.html
28 | # for instructions on building GDB with ELF support.
29 | echo + symbol-file obj/kern/kernel\n
30 | symbol-file obj/kern/kernel
31 | 


--------------------------------------------------------------------------------
/boot/Makefrag:
--------------------------------------------------------------------------------
 1 | #
 2 | # Makefile fragment for the JOS kernel.
 3 | # This is NOT a complete makefile;
 4 | # you must run GNU make in the top-level directory
 5 | # where the GNUmakefile is located.
 6 | #
 7 | 
 8 | OBJDIRS += boot
 9 | 
10 | BOOT_OBJS := $(OBJDIR)/boot/boot.o $(OBJDIR)/boot/main.o
11 | 
12 | $(OBJDIR)/boot/%.o: boot/%.c
13 | 	@echo + cc -Os $<
14 | 	@mkdir -p $(@D)
15 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -Os -c -o $@ $<
16 | 
17 | $(OBJDIR)/boot/%.o: boot/%.S
18 | 	@echo + as $<
19 | 	@mkdir -p $(@D)
20 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
21 | 
22 | $(OBJDIR)/boot/main.o: boot/main.c
23 | 	@echo + cc -Os $<
24 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -Os -c -o $(OBJDIR)/boot/main.o boot/main.c
25 | 
26 | $(OBJDIR)/boot/boot: $(BOOT_OBJS)
27 | 	@echo + ld boot/boot
28 | 	$(V)$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 -o $@.out $^
29 | 	$(V)$(OBJDUMP) -S $@.out >$@.asm
30 | 	$(V)$(OBJCOPY) -S -O binary -j .text $@.out $@
31 | 	$(V)perl boot/sign.pl $(OBJDIR)/boot/boot
32 | 
33 | 


--------------------------------------------------------------------------------
/kern/monitor.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_MONITOR_H
 2 | #define JOS_KERN_MONITOR_H
 3 | #ifndef JOS_KERNEL
 4 | # error "This is a JOS kernel header; user programs should not #include it"
 5 | #endif
 6 | 
 7 | struct Trapframe;
 8 | 
 9 | // Activate the kernel monitor,
10 | // optionally providing a trap frame indicating the current state
11 | // (NULL if none).
12 | void monitor(struct Trapframe *tf);
13 | 
14 | // Functions implementing monitor commands.
15 | int mon_help(int argc, char **argv, struct Trapframe *tf);
16 | int mon_kerninfo(int argc, char **argv, struct Trapframe *tf);
17 | int mon_backtrace(int argc, char **argv, struct Trapframe *tf);
18 | 
19 | // Functions for page managment debugging
20 | int mon_showmappings(int argc, char **argv, struct Trapframe *tf);
21 | int mon_setperm(int argc, char **argv, struct Trapframe *tf);
22 | int mon_dumpva(int argc, char **argv, struct Trapframe *tf);
23 | int mon_dumppa(int argc, char **argv, struct Trapframe *tf);
24 | 
25 | #endif	// !JOS_KERN_MONITOR_H
26 | 


--------------------------------------------------------------------------------
/user/testptelibrary.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | #define VA ((char *) 0xA0000000)
 4 | const char *msg = "hello, world\n";
 5 | const char *msg2 = "goodbye, world\n";
 6 | 
 7 | void childofspawn(void);
 8 | 
 9 | void
10 | umain(int argc, char **argv)
11 | {
12 | 	int r;
13 | 
14 | 	if (argc != 0)
15 | 		childofspawn();
16 | 
17 | 	if ((r = sys_page_alloc(0, VA, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
18 | 		panic("sys_page_alloc: %e", r);
19 | 
20 | 	// check fork
21 | 	if ((r = fork()) < 0)
22 | 		panic("fork: %e", r);
23 | 	if (r == 0) {
24 | 		strcpy(VA, msg);
25 | 		exit();
26 | 	}
27 | 	wait(r);
28 | 	cprintf("fork handles PTE_SHARE %s\n", strcmp(VA, msg) == 0 ? "right" : "wrong");
29 | 
30 | 	// check spawn
31 | 	if ((r = spawnl("/testptelibrary", "testptelibrary", "arg", 0)) < 0)
32 | 		panic("spawn: %e", r);
33 | 	wait(r);
34 | 	cprintf("spawn handles PTE_SHARE %s\n", strcmp(VA, msg2) == 0 ? "right" : "wrong");
35 | }
36 | 
37 | void
38 | childofspawn(void)
39 | {
40 | 	strcpy(VA, msg2);
41 | 	exit();
42 | }
43 | 


--------------------------------------------------------------------------------
/user/writemotd.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int rfd, wfd;
 7 | 	char buf[512];
 8 | 	int n, r;
 9 | 
10 | 	if ((rfd = open("/newmotd", O_RDONLY)) < 0)
11 | 		panic("open /newmotd: %e", rfd);
12 | 	if ((wfd = open("/motd", O_RDWR)) < 0)
13 | 		panic("open /motd: %e", wfd);
14 | 	cprintf("file descriptors %d %d\n", rfd, wfd);
15 | 	if (rfd == wfd)
16 | 		panic("open /newmotd and /motd give same file descriptor");
17 | 
18 | 	cprintf("OLD MOTD\n===\n");
19 | 	while ((n = read(wfd, buf, sizeof buf-1)) > 0)
20 | 		sys_cputs(buf, n);
21 | 	cprintf("===\n");
22 | 	seek(wfd, 0);
23 | 
24 | 	if ((r = ftruncate(wfd, 0)) < 0)
25 | 		panic("truncate /motd: %e", r);
26 | 
27 | 	cprintf("NEW MOTD\n===\n");
28 | 	while ((n = read(rfd, buf, sizeof buf-1)) > 0) {
29 | 		sys_cputs(buf, n);
30 | 		if ((r = write(wfd, buf, n)) != n)
31 | 			panic("write /motd: %e", r);
32 | 	}
33 | 	cprintf("===\n");
34 | 
35 | 	if (n < 0)
36 | 		panic("read /newmotd: %e", n);
37 | 
38 | 	close(rfd);
39 | 	close(wfd);
40 | }
41 | 


--------------------------------------------------------------------------------
/user/testpteshare.c:
--------------------------------------------------------------------------------
 1 | #include <inc/x86.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | #define VA	((char *) 0xA0000000)
 5 | const char *msg = "hello, world\n";
 6 | const char *msg2 = "goodbye, world\n";
 7 | 
 8 | void childofspawn(void);
 9 | 
10 | void
11 | umain(int argc, char **argv)
12 | {
13 | 	int r;
14 | 
15 | 	if (argc != 0)
16 | 		childofspawn();
17 | 
18 | 	if ((r = sys_page_alloc(0, VA, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
19 | 		panic("sys_page_alloc: %e", r);
20 | 
21 | 	// check fork
22 | 	if ((r = fork()) < 0)
23 | 		panic("fork: %e", r);
24 | 	if (r == 0) {
25 | 		strcpy(VA, msg);
26 | 		exit();
27 | 	}
28 | 	wait(r);
29 | 	cprintf("fork handles PTE_SHARE %s\n", strcmp(VA, msg) == 0 ? "right" : "wrong");
30 | 
31 | 	// check spawn
32 | 	if ((r = spawnl("/testpteshare", "testpteshare", "arg", 0)) < 0)
33 | 		panic("spawn: %e", r);
34 | 	wait(r);
35 | 	cprintf("spawn handles PTE_SHARE %s\n", strcmp(VA, msg2) == 0 ? "right" : "wrong");
36 | 
37 | 	breakpoint();
38 | }
39 | 
40 | void
41 | childofspawn(void)
42 | {
43 | 	strcpy(VA, msg2);
44 | 	exit();
45 | }
46 | 


--------------------------------------------------------------------------------
/user/testfdsharing.c:
--------------------------------------------------------------------------------
 1 | #include <inc/x86.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | char buf[512], buf2[512];
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	int fd, r, n, n2;
10 | 
11 | 	if ((fd = open("motd", O_RDONLY)) < 0)
12 | 		panic("open motd: %e", fd);
13 | 	seek(fd, 0);
14 | 	if ((n = readn(fd, buf, sizeof buf)) <= 0)
15 | 		panic("readn: %e", n);
16 | 
17 | 	if ((r = fork()) < 0)
18 | 		panic("fork: %e", r);
19 | 	if (r == 0) {
20 | 		seek(fd, 0);
21 | 		cprintf("going to read in child (might page fault if your sharing is buggy)\n");
22 | 		if ((n2 = readn(fd, buf2, sizeof buf2)) != n)
23 | 			panic("read in parent got %d, read in child got %d", n, n2);
24 | 		if (memcmp(buf, buf2, n) != 0)
25 | 			panic("read in parent got different bytes from read in child");
26 | 		cprintf("read in child succeeded\n");
27 | 		seek(fd, 0);
28 | 		close(fd);
29 | 		exit();
30 | 	}
31 | 	wait(r);
32 | 	if ((n2 = readn(fd, buf2, sizeof buf2)) != n)
33 | 		panic("read in parent got %d, then got %d", n, n2);
34 | 	cprintf("read in parent succeeded\n");
35 | 	close(fd);
36 | 
37 | 	breakpoint();
38 | }
39 | 


--------------------------------------------------------------------------------
/net/Makefrag:
--------------------------------------------------------------------------------
 1 | 
 2 | include net/lwip/Makefrag
 3 | 
 4 | NET_SRCFILES :=		net/timer.c \
 5 | 			net/input.c \
 6 | 			net/output.c
 7 | 
 8 | NET_OBJFILES := $(patsubst net/%.c, $(OBJDIR)/net/%.o, $(NET_SRCFILES))
 9 | 
10 | $(OBJDIR)/net/%.o: net/%.c net/ns.h $(OBJDIR)/.vars.USER_CFLAGS $(OBJDIR)/.vars.NET_CFLAGS
11 | 	@echo + cc[USER] $<
12 | 	@mkdir -p $(@D)
13 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) $(NET_CFLAGS) -c -o $@ $<
14 | 
15 | $(OBJDIR)/net/ns: $(OBJDIR)/net/serv.o $(NET_OBJFILES) $(OBJDIR)/lib/entry.o $(OBJDIR)/lib/libjos.a $(OBJDIR)/lib/liblwip.a user/user.ld
16 | 	@echo + ld $@
17 | 	$(V)$(LD) -o $@ $(ULDFLAGS) $(LDFLAGS) -nostdlib \
18 | 		$(OBJDIR)/lib/entry.o $< $(NET_OBJFILES) \
19 | 		-L$(OBJDIR)/lib -llwip -ljos $(GCC_LIB)
20 | 	$(V)$(OBJDUMP) -S $@ >$@.asm
21 | 
22 | $(OBJDIR)/net/test%: $(OBJDIR)/net/test%.o $(NET_OBJFILES) $(OBJDIR)/lib/entry.o $(OBJDIR)/lib/libjos.a $(OBJDIR)/lib/liblwip.a user/user.ld
23 | 	@echo + ld $@
24 | 	$(V)$(LD) -o $@ $(ULDFLAGS) $(LDFLAGS) -nostdlib \
25 | 		$(OBJDIR)/lib/entry.o $< $(NET_OBJFILES) \
26 | 		-L$(OBJDIR)/lib -llwip -ljos $(GCC_LIB)
27 | 	$(V)$(OBJDUMP) -S $@ >$@.asm
28 | 


--------------------------------------------------------------------------------
/net/testoutput.c:
--------------------------------------------------------------------------------
 1 | #include "ns.h"
 2 | 
 3 | #ifndef TESTOUTPUT_COUNT
 4 | #define TESTOUTPUT_COUNT 10
 5 | #endif
 6 | 
 7 | static envid_t output_envid;
 8 | 
 9 | static struct jif_pkt *pkt = (struct jif_pkt*)REQVA;
10 | 
11 | 
12 | void
13 | umain(int argc, char **argv)
14 | {
15 | 	envid_t ns_envid = sys_getenvid();
16 | 	int i, r;
17 | 
18 | 	binaryname = "testoutput";
19 | 
20 | 	output_envid = fork();
21 | 	if (output_envid < 0)
22 | 		panic("error forking");
23 | 	else if (output_envid == 0) {
24 | 		output(ns_envid);
25 | 		return;
26 | 	}
27 | 
28 | 	for (i = 0; i < TESTOUTPUT_COUNT; i++) {
29 | 		if ((r = sys_page_alloc(0, pkt, PTE_P|PTE_U|PTE_W)) < 0)
30 | 			panic("sys_page_alloc: %e", r);
31 | 		pkt->jp_len = snprintf(pkt->jp_data,
32 | 				       PGSIZE - sizeof(pkt->jp_len),
33 | 				       "Packet %02d", i);
34 | 		cprintf("Transmitting packet %d\n", i);
35 | 		ipc_send(output_envid, NSREQ_OUTPUT, pkt, PTE_P|PTE_W|PTE_U);
36 | 		sys_page_unmap(0, pkt);
37 | 	}
38 | 
39 | 	// Spin for a while, just in case IPC's or packets need to be flushed
40 | 	for (i = 0; i < TESTOUTPUT_COUNT*2; i++)
41 | 		sys_yield();
42 | }
43 | 


--------------------------------------------------------------------------------
/inc/error.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_INC_ERROR_H
 4 | #define JOS_INC_ERROR_H
 5 | 
 6 | enum {
 7 | 	// Kernel error codes -- keep in sync with list in lib/printfmt.c.
 8 | 	E_UNSPECIFIED	= 1,	// Unspecified or unknown problem
 9 | 	E_BAD_ENV	,	// Environment doesn't exist or otherwise
10 | 				// cannot be used in requested action
11 | 	E_INVAL		,	// Invalid parameter
12 | 	E_NO_MEM	,	// Request failed due to memory shortage
13 | 	E_NO_FREE_ENV	,	// Attempt to create a new environment beyond
14 | 				// the maximum allowed
15 | 	E_FAULT		,	// Memory fault
16 | 
17 | 	E_IPC_NOT_RECV	,	// Attempt to send to env that is not recving
18 | 	E_EOF		,	// Unexpected end of file
19 | 
20 | 	// File system error codes -- only seen in user-level
21 | 	E_NO_DISK	,	// No free space left on disk
22 | 	E_MAX_OPEN	,	// Too many files are open
23 | 	E_NOT_FOUND	, 	// File or block not found
24 | 	E_BAD_PATH	,	// Bad path
25 | 	E_FILE_EXISTS	,	// File already exists
26 | 	E_NOT_EXEC	,	// File not a valid executable
27 | 	E_NOT_SUPP	,	// Operation not supported
28 | 
29 | 	MAXERROR
30 | };
31 | 
32 | #endif	// !JOS_INC_ERROR_H */
33 | 


--------------------------------------------------------------------------------
/net/lwip/netif/FILES:
--------------------------------------------------------------------------------
 1 | This directory contains generic network interface device drivers that
 2 | do not contain any hardware or architecture specific code. The files
 3 | are:
 4 | 
 5 | etharp.c
 6 |           Implements the ARP (Address Resolution Protocol) over
 7 |           Ethernet. The code in this file should be used together with
 8 |           Ethernet device drivers. Note that this module has been
 9 |           largely made Ethernet independent so you should be able to
10 |           adapt this for other link layers (such as Firewire).
11 | 
12 | ethernetif.c
13 |           An example of how an Ethernet device driver could look. This
14 |           file can be used as a "skeleton" for developing new Ethernet
15 |           network device drivers. It uses the etharp.c ARP code.
16 | 
17 | loopif.c
18 |           A "loopback" network interface driver. It requires configuration
19 |           through the define LWIP_LOOPIF_MULTITHREADING (see opt.h).
20 | 
21 | slipif.c
22 |           A generic implementation of the SLIP (Serial Line IP)
23 |           protocol. It requires a sio (serial I/O) module to work.
24 | 
25 | ppp/      Point-to-Point Protocol stack
26 | 


--------------------------------------------------------------------------------
/user/sendpage.c:
--------------------------------------------------------------------------------
 1 | // Test Conversation between parent and child environment
 2 | // Contributed by Varun Agrawal at Stony Brook
 3 | 
 4 | #include <inc/lib.h>
 5 | 
 6 | const char *str1 = "hello child environment! how are you?";
 7 | const char *str2 = "hello parent environment! I'm good.";
 8 | 
 9 | #define TEMP_ADDR	((char*)0xa00000)
10 | #define TEMP_ADDR_CHILD	((char*)0xb00000)
11 | 
12 | void
13 | umain(int argc, char **argv)
14 | {
15 | 	envid_t who;
16 | 
17 | 	if ((who = fork()) == 0) {
18 | 		// Child
19 | 		ipc_recv(&who, TEMP_ADDR_CHILD, 0);
20 | 		cprintf("%x got message: %s\n", who, TEMP_ADDR_CHILD);
21 | 		if (strncmp(TEMP_ADDR_CHILD, str1, strlen(str1)) == 0)
22 | 			cprintf("child received correct message\n");
23 | 
24 | 		memcpy(TEMP_ADDR_CHILD, str2, strlen(str2) + 1);
25 | 		ipc_send(who, 0, TEMP_ADDR_CHILD, PTE_P | PTE_W | PTE_U);
26 | 		return;
27 | 	}
28 | 
29 | 	// Parent
30 | 	sys_page_alloc(thisenv->env_id, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
31 | 	memcpy(TEMP_ADDR, str1, strlen(str1) + 1);
32 | 	ipc_send(who, 0, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
33 | 
34 | 	ipc_recv(&who, TEMP_ADDR, 0);
35 | 	cprintf("%x got message: %s\n", who, TEMP_ADDR);
36 | 	if (strncmp(TEMP_ADDR, str2, strlen(str2)) == 0)
37 | 		cprintf("parent received correct message\n");
38 | 	return;
39 | }
40 | 


--------------------------------------------------------------------------------
/kern/env.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_ENV_H
 4 | #define JOS_KERN_ENV_H
 5 | 
 6 | #include <inc/env.h>
 7 | #include <kern/cpu.h>
 8 | 
 9 | extern struct Env *envs;		// All environments
10 | #define curenv (thiscpu->cpu_env)		// Current environment
11 | extern struct Segdesc gdt[];
12 | 
13 | void	env_init(void);
14 | void	env_init_percpu(void);
15 | int	env_alloc(struct Env **e, envid_t parent_id);
16 | void	env_free(struct Env *e);
17 | void	env_create(uint8_t *binary, enum EnvType type);
18 | void	env_destroy(struct Env *e);	// Does not return if e == curenv
19 | 
20 | int	envid2env(envid_t envid, struct Env **env_store, bool checkperm);
21 | // The following two functions do not return
22 | void	env_run(struct Env *e) __attribute__((noreturn));
23 | void	env_pop_tf(struct Trapframe *tf) __attribute__((noreturn));
24 | 
25 | // Without this extra macro, we couldn't pass macros like TEST to
26 | // ENV_CREATE because of the C pre-processor's argument prescan rule.
27 | #define ENV_PASTE3(x, y, z) x ## y ## z
28 | 
29 | #define ENV_CREATE(x, type)						\
30 | 	do {								\
31 | 		extern uint8_t ENV_PASTE3(_binary_obj_, x, _start)[];	\
32 | 		env_create(ENV_PASTE3(_binary_obj_, x, _start),		\
33 | 			   type);					\
34 | 	} while (0)
35 | 
36 | #endif // !JOS_KERN_ENV_H
37 | 


--------------------------------------------------------------------------------
/kern/kclock.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_KCLOCK_H
 4 | #define JOS_KERN_KCLOCK_H
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | #define	IO_RTC		0x070		/* RTC port */
10 | 
11 | #define	MC_NVRAM_START	0xe	/* start of NVRAM: offset 14 */
12 | #define	MC_NVRAM_SIZE	50	/* 50 bytes of NVRAM */
13 | 
14 | /* NVRAM bytes 7 & 8: base memory size */
15 | #define NVRAM_BASELO	(MC_NVRAM_START + 7)	/* low byte; RTC off. 0x15 */
16 | #define NVRAM_BASEHI	(MC_NVRAM_START + 8)	/* high byte; RTC off. 0x16 */
17 | 
18 | /* NVRAM bytes 9 & 10: extended memory size */
19 | #define NVRAM_EXTLO	(MC_NVRAM_START + 9)	/* low byte; RTC off. 0x17 */
20 | #define NVRAM_EXTHI	(MC_NVRAM_START + 10)	/* high byte; RTC off. 0x18 */
21 | 
22 | /* NVRAM bytes 34 and 35: extended memory POSTed size */
23 | #define NVRAM_PEXTLO	(MC_NVRAM_START + 34)	/* low byte; RTC off. 0x30 */
24 | #define NVRAM_PEXTHI	(MC_NVRAM_START + 35)	/* high byte; RTC off. 0x31 */
25 | 
26 | /* NVRAM byte 36: current century.  (please increment in Dec99!) */
27 | #define NVRAM_CENTURY	(MC_NVRAM_START + 36)	/* RTC offset 0x32 */
28 | 
29 | unsigned mc146818_read(unsigned reg);
30 | void mc146818_write(unsigned reg, unsigned datum);
31 | 
32 | #endif	// !JOS_KERN_KCLOCK_H
33 | 


--------------------------------------------------------------------------------
/lib/Makefrag:
--------------------------------------------------------------------------------
 1 | OBJDIRS += lib
 2 | 
 3 | LIB_SRCFILES :=		lib/console.c \
 4 | 			lib/libmain.c \
 5 | 			lib/exit.c \
 6 | 			lib/panic.c \
 7 | 			lib/printf.c \
 8 | 			lib/printfmt.c \
 9 | 			lib/readline.c \
10 | 			lib/string.c \
11 | 			lib/syscall.c
12 | 
13 | LIB_SRCFILES :=		$(LIB_SRCFILES) \
14 | 			lib/pgfault.c \
15 | 			lib/pfentry.S \
16 | 			lib/fork.c \
17 | 			lib/ipc.c
18 | 
19 | LIB_SRCFILES :=		$(LIB_SRCFILES) \
20 | 			lib/args.c \
21 | 			lib/fd.c \
22 | 			lib/file.c \
23 | 			lib/fprintf.c \
24 | 			lib/pageref.c \
25 | 			lib/spawn.c
26 | 
27 | LIB_SRCFILES :=		$(LIB_SRCFILES) \
28 | 			lib/sockets.c \
29 | 			lib/nsipc.c \
30 | 			lib/malloc.c
31 | LIB_SRCFILES :=		$(LIB_SRCFILES) \
32 | 			lib/pipe.c \
33 | 			lib/wait.c
34 | 
35 | LIB_OBJFILES := $(patsubst lib/%.c, $(OBJDIR)/lib/%.o, $(LIB_SRCFILES))
36 | LIB_OBJFILES := $(patsubst lib/%.S, $(OBJDIR)/lib/%.o, $(LIB_OBJFILES))
37 | 
38 | $(OBJDIR)/lib/%.o: lib/%.c $(OBJDIR)/.vars.USER_CFLAGS
39 | 	@echo + cc[USER] $<
40 | 	@mkdir -p $(@D)
41 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
42 | 
43 | $(OBJDIR)/lib/%.o: lib/%.S $(OBJDIR)/.vars.USER_CFLAGS
44 | 	@echo + as[USER] $<
45 | 	@mkdir -p $(@D)
46 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
47 | 
48 | $(OBJDIR)/lib/libjos.a: $(LIB_OBJFILES)
49 | 	@echo + ar $@
50 | 	$(V)$(AR) r $@ $(LIB_OBJFILES)
51 | 


--------------------------------------------------------------------------------
/kern/cpu.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef JOS_INC_CPU_H
 3 | #define JOS_INC_CPU_H
 4 | 
 5 | #include <inc/types.h>
 6 | #include <inc/memlayout.h>
 7 | #include <inc/mmu.h>
 8 | #include <inc/env.h>
 9 | 
10 | // Maximum number of CPUs
11 | #define NCPU  8
12 | 
13 | // Values of status in struct Cpu
14 | enum {
15 | 	CPU_UNUSED = 0,
16 | 	CPU_STARTED,
17 | 	CPU_HALTED,
18 | };
19 | 
20 | // Per-CPU state
21 | struct CpuInfo {
22 | 	uint8_t cpu_id;                 // Local APIC ID; index into cpus[] below
23 | 	volatile unsigned cpu_status;   // The status of the CPU
24 | 	struct Env *cpu_env;            // The currently-running environment.
25 | 	struct Taskstate cpu_ts;        // Used by x86 to find stack for interrupt
26 | };
27 | 
28 | // Initialized in mpconfig.c
29 | extern struct CpuInfo cpus[NCPU];
30 | extern int ncpu;                    // Total number of CPUs in the system
31 | extern struct CpuInfo *bootcpu;     // The boot-strap processor (BSP)
32 | extern physaddr_t lapicaddr;        // Physical MMIO address of the local APIC
33 | 
34 | // Per-CPU kernel stacks
35 | extern unsigned char percpu_kstacks[NCPU][KSTKSIZE];
36 | 
37 | int cpunum(void);
38 | #define thiscpu (&cpus[cpunum()])
39 | 
40 | void mp_init(void);
41 | void lapic_init(void);
42 | void lapic_startap(uint8_t apicid, uint32_t addr);
43 | void lapic_eoi(void);
44 | void lapic_ipi(int vector);
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/CODING:
--------------------------------------------------------------------------------
 1 | JOS CODING STANDARDS
 2 | 
 3 | It's easier on everyone if all authors working on a shared
 4 | code base are consistent in the way they write their programs.
 5 | We have the following conventions in our code:
 6 | 
 7 | * No space after the name of a function in a call
 8 |   For example, printf("hello") not printf ("hello").
 9 | 
10 | * One space after keywords "if", "for", "while", "switch".
11 |   For example, if (x) not if(x).
12 | 
13 | * Space before braces.
14 |   For example, if (x) { not if (x){.
15 | 
16 | * Function names are all lower-case separated by underscores.
17 | 
18 | * Beginning-of-line indentation via tabs, not spaces.
19 | 
20 | * Preprocessor macros are always UPPERCASE.
21 |   There are a few grandfathered exceptions: assert, panic,
22 |   static_assert, offsetof.
23 | 
24 | * Pointer types have spaces: (uint16_t *) not (uint16_t*).
25 | 
26 | * Multi-word names are lower_case_with_underscores.
27 | 
28 | * Comments in imported code are usually C /* ... */ comments.
29 |   Comments in new code are C++ style //.
30 | 
31 | * In a function definition, the function name starts a new line.
32 |   Then you can grep -n '^foo' */*.c to find the definition of foo.
33 | 
34 | * Functions that take no arguments are declared f(void) not f().
35 | 
36 | The included .dir-locals.el file will automatically set up the basic
37 | indentation style in Emacs.
38 | 


--------------------------------------------------------------------------------
/kern/spinlock.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_SPINLOCK_H
 2 | #define JOS_INC_SPINLOCK_H
 3 | 
 4 | #include <inc/types.h>
 5 | 
 6 | // Comment this to disable spinlock debugging
 7 | #define DEBUG_SPINLOCK
 8 | 
 9 | // Mutual exclusion lock.
10 | struct spinlock {
11 | 	unsigned locked;       // Is the lock held?
12 | 
13 | #ifdef DEBUG_SPINLOCK
14 | 	// For debugging:
15 | 	char *name;            // Name of lock.
16 | 	struct CpuInfo *cpu;   // The CPU holding the lock.
17 | 	uintptr_t pcs[10];     // The call stack (an array of program counters)
18 | 	                       // that locked the lock.
19 | #endif
20 | };
21 | 
22 | void __spin_initlock(struct spinlock *lk, char *name);
23 | void spin_lock(struct spinlock *lk);
24 | void spin_unlock(struct spinlock *lk);
25 | 
26 | #define spin_initlock(lock)   __spin_initlock(lock, #lock)
27 | 
28 | extern struct spinlock kernel_lock;
29 | 
30 | static inline void
31 | lock_kernel(void)
32 | {
33 | 	spin_lock(&kernel_lock);
34 | }
35 | 
36 | static inline void
37 | unlock_kernel(void)
38 | {
39 | 	spin_unlock(&kernel_lock);
40 | 
41 | 	// Normally we wouldn't need to do this, but QEMU only runs
42 | 	// one CPU at a time and has a long time-slice.  Without the
43 | 	// pause, this CPU is likely to reacquire the lock before
44 | 	// another CPU has even been given a chance to acquire it.
45 | 	asm volatile("pause");
46 | }
47 | 
48 | #endif
49 | 


--------------------------------------------------------------------------------
/user/primes.c:
--------------------------------------------------------------------------------
 1 | // Concurrent version of prime sieve of Eratosthenes.
 2 | // Invented by Doug McIlroy, inventor of Unix pipes.
 3 | // See http://swtch.com/~rsc/thread/.
 4 | // The picture halfway down the page and the text surrounding it
 5 | // explain what's going on here.
 6 | //
 7 | // Since NENVS is 1024, we can print 1022 primes before running out.
 8 | // The remaining two environments are the integer generator at the bottom
 9 | // of main and user/idle.
10 | 
11 | #include <inc/lib.h>
12 | 
13 | unsigned
14 | primeproc(void)
15 | {
16 | 	int i, id, p;
17 | 	envid_t envid;
18 | 
19 | 	// fetch a prime from our left neighbor
20 | top:
21 | 	p = ipc_recv(&envid, 0, 0);
22 | 	cprintf("CPU %d: %d ", thisenv->env_cpunum, p);
23 | 
24 | 	// fork a right neighbor to continue the chain
25 | 	if ((id = fork()) < 0)
26 | 		panic("fork: %e", id);
27 | 	if (id == 0)
28 | 		goto top;
29 | 
30 | 	// filter out multiples of our prime
31 | 	while (1) {
32 | 		i = ipc_recv(&envid, 0, 0);
33 | 		if (i % p)
34 | 			ipc_send(id, i, 0, 0);
35 | 	}
36 | }
37 | 
38 | void
39 | umain(int argc, char **argv)
40 | {
41 | 	int i, id;
42 | 
43 | 	// fork the first prime process in the chain
44 | 	if ((id = fork()) < 0)
45 | 		panic("fork: %e", id);
46 | 	if (id == 0)
47 | 		primeproc();
48 | 
49 | 	// feed all the integers through
50 | 	for (i = 2; ; i++)
51 | 		ipc_send(id, i, 0, 0);
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/lib/printf.c:
--------------------------------------------------------------------------------
 1 | // Implementation of cprintf console output for user environments,
 2 | // based on printfmt() and the sys_cputs() system call.
 3 | //
 4 | // cprintf is a debugging statement, not a generic output statement.
 5 | // It is very important that it always go to the console, especially when
 6 | // debugging file descriptor code!
 7 | 
 8 | #include <inc/types.h>
 9 | #include <inc/stdio.h>
10 | #include <inc/stdarg.h>
11 | #include <inc/lib.h>
12 | 
13 | 
14 | // Collect up to 256 characters into a buffer
15 | // and perform ONE system call to print all of them,
16 | // in order to make the lines output to the console atomic
17 | // and prevent interrupts from causing context switches
18 | // in the middle of a console output line and such.
19 | struct printbuf {
20 | 	int idx;	// current buffer index
21 | 	int cnt;	// total bytes printed so far
22 | 	char buf[256];
23 | };
24 | 
25 | 
26 | static void
27 | putch(int ch, struct printbuf *b)
28 | {
29 | 	b->buf[b->idx++] = ch;
30 | 	if (b->idx == 256-1) {
31 | 		sys_cputs(b->buf, b->idx);
32 | 		b->idx = 0;
33 | 	}
34 | 	b->cnt++;
35 | }
36 | 
37 | int
38 | vcprintf(const char *fmt, va_list ap)
39 | {
40 | 	struct printbuf b;
41 | 
42 | 	b.idx = 0;
43 | 	b.cnt = 0;
44 | 	vprintfmt((void*)putch, &b, fmt, ap);
45 | 	sys_cputs(b.buf, b.idx);
46 | 
47 | 	return b.cnt;
48 | }
49 | 
50 | int
51 | cprintf(const char *fmt, ...)
52 | {
53 | 	va_list ap;
54 | 	int cnt;
55 | 
56 | 	va_start(ap, fmt);
57 | 	cnt = vcprintf(fmt, ap);
58 | 	va_end(ap);
59 | 
60 | 	return cnt;
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/inc/elf.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_ELF_H
 2 | #define JOS_INC_ELF_H
 3 | 
 4 | #define ELF_MAGIC 0x464C457FU	/* "\x7FELF" in little endian */
 5 | 
 6 | struct Elf {
 7 | 	uint32_t e_magic;	// must equal ELF_MAGIC
 8 | 	uint8_t e_elf[12];
 9 | 	uint16_t e_type;
10 | 	uint16_t e_machine;
11 | 	uint32_t e_version;
12 | 	uint32_t e_entry;
13 | 	uint32_t e_phoff;
14 | 	uint32_t e_shoff;
15 | 	uint32_t e_flags;
16 | 	uint16_t e_ehsize;
17 | 	uint16_t e_phentsize;
18 | 	uint16_t e_phnum;
19 | 	uint16_t e_shentsize;
20 | 	uint16_t e_shnum;
21 | 	uint16_t e_shstrndx;
22 | };
23 | 
24 | struct Proghdr {
25 | 	uint32_t p_type;
26 | 	uint32_t p_offset;
27 | 	uint32_t p_va;
28 | 	uint32_t p_pa;
29 | 	uint32_t p_filesz;
30 | 	uint32_t p_memsz;
31 | 	uint32_t p_flags;
32 | 	uint32_t p_align;
33 | };
34 | 
35 | struct Secthdr {
36 | 	uint32_t sh_name;
37 | 	uint32_t sh_type;
38 | 	uint32_t sh_flags;
39 | 	uint32_t sh_addr;
40 | 	uint32_t sh_offset;
41 | 	uint32_t sh_size;
42 | 	uint32_t sh_link;
43 | 	uint32_t sh_info;
44 | 	uint32_t sh_addralign;
45 | 	uint32_t sh_entsize;
46 | };
47 | 
48 | // Values for Proghdr::p_type
49 | #define ELF_PROG_LOAD		1
50 | 
51 | // Flag bits for Proghdr::p_flags
52 | #define ELF_PROG_FLAG_EXEC	1
53 | #define ELF_PROG_FLAG_WRITE	2
54 | #define ELF_PROG_FLAG_READ	4
55 | 
56 | // Values for Secthdr::sh_type
57 | #define ELF_SHT_NULL		0
58 | #define ELF_SHT_PROGBITS	1
59 | #define ELF_SHT_SYMTAB		2
60 | #define ELF_SHT_STRTAB		3
61 | 
62 | // Values for Secthdr::sh_name
63 | #define ELF_SHN_UNDEF		0
64 | 
65 | #endif /* !JOS_INC_ELF_H */
66 | 


--------------------------------------------------------------------------------
/lib/pgfault.c:
--------------------------------------------------------------------------------
 1 | // User-level page fault handler support.
 2 | // Rather than register the C page fault handler directly with the
 3 | // kernel as the page fault handler, we register the assembly language
 4 | // wrapper in pfentry.S, which in turns calls the registered C
 5 | // function.
 6 | 
 7 | #include <inc/lib.h>
 8 | 
 9 | 
10 | // Assembly language pgfault entrypoint defined in lib/pfentry.S.
11 | extern void _pgfault_upcall(void);
12 | 
13 | // Pointer to currently installed C-language pgfault handler.
14 | void (*_pgfault_handler)(struct UTrapframe *utf);
15 | 
16 | //
17 | // Set the page fault handler function.
18 | // If there isn't one yet, _pgfault_handler will be 0.
19 | // The first time we register a handler, we need to
20 | // allocate an exception stack (one page of memory with its top
21 | // at UXSTACKTOP), and tell the kernel to call the assembly-language
22 | // _pgfault_upcall routine when a page fault occurs.
23 | //
24 | void
25 | set_pgfault_handler(void (*handler)(struct UTrapframe *utf))
26 | {
27 | 	int r;
28 | 
29 | 	if (_pgfault_handler == 0) {
30 | 		// First time through!
31 | 		// LAB 4: Your code here.
32 | 		cprintf("started at %p\n", UXSTACKTOP - PGSIZE);
33 | 		if (sys_page_alloc(0, (void *)(UXSTACKTOP - PGSIZE), PTE_P | PTE_U | PTE_W))
34 | 		{
35 | 			panic("sys_page_alloc failed.");
36 | 		}
37 | 	}
38 | 	// Save handler pointer for assembly to call.
39 | 	_pgfault_handler = handler;
40 | 	if (sys_env_set_pgfault_upcall(0, _pgfault_upcall) < 0)
41 | 		panic("sys_env_set_pgfault_upcall failed");
42 | }
43 | 


--------------------------------------------------------------------------------
/grade-lab1:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | import re
 4 | from gradelib import *
 5 | 
 6 | r = Runner(save("jos.out"),
 7 |            stop_breakpoint("readline"))
 8 | 
 9 | @test(0, "running JOS")
10 | def test_jos():
11 |     r.run_qemu()
12 | 
13 | @test(20, parent=test_jos)
14 | def test_printf():
15 |     r.match("6828 decimal is 15254 octal!")
16 | 
17 | BACKTRACE_RE = r"^ *ebp +f01[0-9a-z]{5} +eip +f0100[0-9a-z]{3} +args +([0-9a-z]+)"
18 | 
19 | @test(10, parent=test_jos)
20 | def test_backtrace_count():
21 |     matches = re.findall(BACKTRACE_RE, r.qemu.output, re.MULTILINE)
22 |     assert_equal(len(matches), 8)
23 | 
24 | @test(10, parent=test_jos)
25 | def test_backtrace_arguments():
26 |     matches = re.findall(BACKTRACE_RE, r.qemu.output, re.MULTILINE)
27 |     assert_equal("\n".join(matches[:7]),
28 |                  "\n".join("%08x" % n for n in [0,0,1,2,3,4,5]))
29 | 
30 | @test(5, parent=test_jos)
31 | def test_backtrace_symbols():
32 |     matches = re.findall(r"kern/init.c:[0-9]+: +([^+]*)\+", r.qemu.output)
33 |     assert_equal("\n".join(matches[:7]),
34 |                  "\n".join(["test_backtrace"] * 6 + ["i386_init"]))
35 | 
36 | @test(5, parent=test_jos)
37 | def test_backtrace_lines():
38 |     matches = re.findall(r"([^ ]*init.c:([0-9]+):) +test_backtrace\+", r.qemu.output)
39 |     assert matches, "No line numbers"
40 |     if any(int(m[1]) < 5 or int(m[1]) > 50 for m in matches):
41 |         assert_equal("\n".join(m[0] for m in matches),
42 |                      "Line numbers between 5 and 50")
43 | 
44 | run_tests()
45 | 


--------------------------------------------------------------------------------
/kern/kernel.ld:
--------------------------------------------------------------------------------
 1 | /* Simple linker script for the JOS kernel.
 2 |    See the GNU ld 'info' manual ("info ld") to learn the syntax. */
 3 | 
 4 | OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
 5 | OUTPUT_ARCH(i386)
 6 | ENTRY(_start)
 7 | 
 8 | SECTIONS
 9 | {
10 | 	/* Link the kernel at this address: "." means the current address */
11 | 	. = 0xF0100000;
12 | 
13 | 	/* AT(...) gives the load address of this section, which tells
14 | 	   the boot loader where to load the kernel in physical memory */
15 | 	.text : AT(0x100000) {
16 | 		*(.text .stub .text.* .gnu.linkonce.t.*)
17 | 	}
18 | 
19 | 	PROVIDE(etext = .);	/* Define the 'etext' symbol to this value */
20 | 
21 | 	.rodata : {
22 | 		*(.rodata .rodata.* .gnu.linkonce.r.*)
23 | 	}
24 | 
25 | 	/* Include debugging information in kernel memory */
26 | 	.stab : {
27 | 		PROVIDE(__STAB_BEGIN__ = .);
28 | 		*(.stab);
29 | 		PROVIDE(__STAB_END__ = .);
30 | 		BYTE(0)		/* Force the linker to allocate space
31 | 				   for this section */
32 | 	}
33 | 
34 | 	.stabstr : {
35 | 		PROVIDE(__STABSTR_BEGIN__ = .);
36 | 		*(.stabstr);
37 | 		PROVIDE(__STABSTR_END__ = .);
38 | 		BYTE(0)		/* Force the linker to allocate space
39 | 				   for this section */
40 | 	}
41 | 
42 | 	/* Adjust the address for the data segment to the next page */
43 | 	. = ALIGN(0x1000);
44 | 
45 | 	/* The data segment */
46 | 	.data : {
47 | 		*(.data)
48 | 	}
49 | 
50 | 	PROVIDE(edata = .);
51 | 
52 | 	.bss : {
53 | 		*(.bss)
54 | 	}
55 | 
56 | 	PROVIDE(end = .);
57 | 
58 | 	/DISCARD/ : {
59 | 		*(.eh_frame .note.GNU-stack)
60 | 	}
61 | }
62 | 


--------------------------------------------------------------------------------
/net/lwip/jos/arch/threadq.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_THREADQ_H
 2 | #define JOS_INC_THREADQ_H
 3 | 
 4 | #include <arch/thread.h>
 5 | #include <arch/setjmp.h>
 6 | 
 7 | #define THREAD_NUM_ONHALT 4
 8 | enum { name_size = 32 };
 9 | enum { stack_size = PGSIZE };
10 | 
11 | struct thread_context;
12 | 
13 | struct thread_queue
14 | {
15 |     struct thread_context *tq_first;
16 |     struct thread_context *tq_last;
17 | };
18 | 
19 | struct thread_context {
20 |     thread_id_t		tc_tid;
21 |     void		*tc_stack_bottom;
22 |     char 		tc_name[name_size];
23 |     void		(*tc_entry)(uint32_t);
24 |     uint32_t		tc_arg;
25 |     struct jos_jmp_buf	tc_jb;
26 |     volatile uint32_t	*tc_wait_addr;
27 |     volatile char	tc_wakeup;
28 |     void		(*tc_onhalt[THREAD_NUM_ONHALT])(thread_id_t);
29 |     int			tc_nonhalt;
30 |     struct thread_context *tc_queue_link;
31 | };
32 | 
33 | static inline void 
34 | threadq_init(struct thread_queue *tq)
35 | {
36 |     tq->tq_first = 0;
37 |     tq->tq_last = 0;
38 | }
39 | 
40 | static inline void
41 | threadq_push(struct thread_queue *tq, struct thread_context *tc)
42 | {
43 |     tc->tc_queue_link = 0;
44 |     if (!tq->tq_first) {
45 | 	tq->tq_first = tc;
46 | 	tq->tq_last = tc;
47 |     } else {
48 | 	tq->tq_last->tc_queue_link = tc;
49 | 	tq->tq_last = tc;
50 |     }
51 | }
52 | 
53 | static inline struct thread_context *
54 | threadq_pop(struct thread_queue *tq)
55 | {
56 |     if (!tq->tq_first)
57 | 	return 0;
58 | 
59 |     struct thread_context *tc = tq->tq_first;
60 |     tq->tq_first = tc->tc_queue_link;
61 |     tc->tc_queue_link = 0;
62 |     return tc;
63 | }
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/user/testpipe.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | char *msg = "Now is the time for all good men to come to the aid of their party.";
 4 | 
 5 | void
 6 | umain(int argc, char **argv)
 7 | {
 8 | 	char buf[100];
 9 | 	int i, pid, p[2];
10 | 
11 | 	binaryname = "pipereadeof";
12 | 
13 | 	if ((i = pipe(p)) < 0)
14 | 		panic("pipe: %e", i);
15 | 
16 | 	if ((pid = fork()) < 0)
17 | 		panic("fork: %e", i);
18 | 
19 | 	if (pid == 0) {
20 | 		cprintf("[%08x] pipereadeof close %d\n", thisenv->env_id, p[1]);
21 | 		close(p[1]);
22 | 		cprintf("[%08x] pipereadeof readn %d\n", thisenv->env_id, p[0]);
23 | 		i = readn(p[0], buf, sizeof buf-1);
24 | 		if (i < 0)
25 | 			panic("read: %e", i);
26 | 		buf[i] = 0;
27 | 		if (strcmp(buf, msg) == 0)
28 | 			cprintf("\npipe read closed properly\n");
29 | 		else
30 | 			cprintf("\ngot %d bytes: %s\n", i, buf);
31 | 		exit();
32 | 	} else {
33 | 		cprintf("[%08x] pipereadeof close %d\n", thisenv->env_id, p[0]);
34 | 		close(p[0]);
35 | 		cprintf("[%08x] pipereadeof write %d\n", thisenv->env_id, p[1]);
36 | 		if ((i = write(p[1], msg, strlen(msg))) != strlen(msg))
37 | 			panic("write: %e", i);
38 | 		close(p[1]);
39 | 	}
40 | 	wait(pid);
41 | 
42 | 	binaryname = "pipewriteeof";
43 | 	if ((i = pipe(p)) < 0)
44 | 		panic("pipe: %e", i);
45 | 
46 | 	if ((pid = fork()) < 0)
47 | 		panic("fork: %e", i);
48 | 
49 | 	if (pid == 0) {
50 | 		close(p[0]);
51 | 		while (1) {
52 | 			cprintf(".");
53 | 			if (write(p[1], "x", 1) != 1)
54 | 				break;
55 | 		}
56 | 		cprintf("\npipe write closed properly\n");
57 | 		exit();
58 | 	}
59 | 	close(p[0]);
60 | 	close(p[1]);
61 | 	wait(pid);
62 | 
63 | 	cprintf("pipe tests passed\n");
64 | }
65 | 


--------------------------------------------------------------------------------
/user/init.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | struct {
 4 | 	char msg1[5000];
 5 | 	char msg2[1000];
 6 | } data = {
 7 | 	"this is initialized data",
 8 | 	"so is this"
 9 | };
10 | 
11 | char bss[6000];
12 | 
13 | int
14 | sum(const char *s, int n)
15 | {
16 | 	int i, tot = 0;
17 | 	for (i = 0; i < n; i++)
18 | 		tot ^= i * s[i];
19 | 	return tot;
20 | }
21 | 
22 | void
23 | umain(int argc, char **argv)
24 | {
25 | 	int i, r, x, want;
26 | 	char args[256];
27 | 
28 | 	cprintf("init: running\n");
29 | 
30 | 	want = 0xf989e;
31 | 	if ((x = sum((char*)&data, sizeof data)) != want)
32 | 		cprintf("init: data is not initialized: got sum %08x wanted %08x\n",
33 | 			x, want);
34 | 	else
35 | 		cprintf("init: data seems okay\n");
36 | 	if ((x = sum(bss, sizeof bss)) != 0)
37 | 		cprintf("bss is not initialized: wanted sum 0 got %08x\n", x);
38 | 	else
39 | 		cprintf("init: bss seems okay\n");
40 | 
41 | 	// output in one syscall per line to avoid output interleaving 
42 | 	strcat(args, "init: args:");
43 | 	for (i = 0; i < argc; i++) {
44 | 		strcat(args, " '");
45 | 		strcat(args, argv[i]);
46 | 		strcat(args, "'");
47 | 	}
48 | 	cprintf("%s\n", args);
49 | 
50 | 	cprintf("init: running sh\n");
51 | 
52 | 	// being run directly from kernel, so no file descriptors open yet
53 | 	close(0);
54 | 	if ((r = opencons()) < 0)
55 | 		panic("opencons: %e", r);
56 | 	if (r != 0)
57 | 		panic("first opencons used fd %d", r);
58 | 	if ((r = dup(0, 1)) < 0)
59 | 		panic("dup: %e", r);
60 | 	while (1) {
61 | 		cprintf("init: starting sh\n");
62 | 		r = spawnl("/sh", "sh", (char*)0);
63 | 		if (r < 0) {
64 | 			cprintf("init: spawn sh: %e\n", r);
65 | 			continue;
66 | 		}
67 | 		wait(r);
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/fs/fs.h:
--------------------------------------------------------------------------------
 1 | #include <inc/fs.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | #define SECTSIZE	512			// bytes per disk sector
 5 | #define BLKSECTS	(BLKSIZE / SECTSIZE)	// sectors per block
 6 | 
 7 | /* Disk block n, when in memory, is mapped into the file system
 8 |  * server's address space at DISKMAP + (n*BLKSIZE). */
 9 | #define DISKMAP		0x10000000
10 | 
11 | /* Maximum disk size we can handle (3GB) */
12 | #define DISKSIZE	0xC0000000
13 | 
14 | struct Super *super;		// superblock
15 | uint32_t *bitmap;		// bitmap blocks mapped in memory
16 | 
17 | /* ide.c */
18 | bool	ide_probe_disk1(void);
19 | void	ide_set_disk(int diskno);
20 | void	ide_set_partition(uint32_t first_sect, uint32_t nsect);
21 | int	ide_read(uint32_t secno, void *dst, size_t nsecs);
22 | int	ide_write(uint32_t secno, const void *src, size_t nsecs);
23 | 
24 | /* bc.c */
25 | void*	diskaddr(uint32_t blockno);
26 | bool	va_is_mapped(void *va);
27 | bool	va_is_dirty(void *va);
28 | void	flush_block(void *addr);
29 | void	bc_init(void);
30 | 
31 | /* fs.c */
32 | void	fs_init(void);
33 | int	file_get_block(struct File *f, uint32_t file_blockno, char **pblk);
34 | int	file_create(const char *path, struct File **f);
35 | int	file_open(const char *path, struct File **f);
36 | ssize_t	file_read(struct File *f, void *buf, size_t count, off_t offset);
37 | int	file_write(struct File *f, const void *buf, size_t count, off_t offset);
38 | int	file_set_size(struct File *f, off_t newsize);
39 | void	file_flush(struct File *f);
40 | int	file_remove(const char *path);
41 | void	fs_sync(void);
42 | 
43 | /* int	map_block(uint32_t); */
44 | bool	block_is_free(uint32_t blockno);
45 | int	alloc_block(void);
46 | 
47 | /* test.c */
48 | void	fs_test(void);
49 | 
50 | 


--------------------------------------------------------------------------------
/inc/fd.h:
--------------------------------------------------------------------------------
 1 | // Public definitions for the POSIX-like file descriptor emulation layer
 2 | // that our user-land support library implements for the use of applications.
 3 | // See the code in the lib directory for the implementation details.
 4 | 
 5 | #ifndef JOS_INC_FD_H
 6 | #define JOS_INC_FD_H
 7 | 
 8 | #include <inc/types.h>
 9 | #include <inc/fs.h>
10 | 
11 | struct Fd;
12 | struct Stat;
13 | struct Dev;
14 | 
15 | // Per-device-class file descriptor operations
16 | struct Dev {
17 | 	int dev_id;
18 | 	const char *dev_name;
19 | 	ssize_t (*dev_read)(struct Fd *fd, void *buf, size_t len);
20 | 	ssize_t (*dev_write)(struct Fd *fd, const void *buf, size_t len);
21 | 	int (*dev_close)(struct Fd *fd);
22 | 	int (*dev_stat)(struct Fd *fd, struct Stat *stat);
23 | 	int (*dev_trunc)(struct Fd *fd, off_t length);
24 | };
25 | 
26 | struct FdFile {
27 | 	int id;
28 | };
29 | 
30 | struct FdSock {
31 | 	int sockid;
32 | };
33 | 
34 | struct Fd {
35 | 	int fd_dev_id;
36 | 	off_t fd_offset;
37 | 	int fd_omode;
38 | 	union {
39 | 		// File server files
40 | 		struct FdFile fd_file;
41 | 		// Network sockets
42 | 		struct FdSock fd_sock;
43 | 	};
44 | };
45 | 
46 | struct Stat {
47 | 	char st_name[MAXNAMELEN];
48 | 	off_t st_size;
49 | 	int st_isdir;
50 | 	struct Dev *st_dev;
51 | };
52 | 
53 | char*	fd2data(struct Fd *fd);
54 | int	fd2num(struct Fd *fd);
55 | int	fd_alloc(struct Fd **fd_store);
56 | int	fd_close(struct Fd *fd, bool must_exist);
57 | int	fd_lookup(int fdnum, struct Fd **fd_store);
58 | int	dev_lookup(int devid, struct Dev **dev_store);
59 | 
60 | extern struct Dev devfile;
61 | extern struct Dev devsock;
62 | extern struct Dev devcons;
63 | extern struct Dev devpipe;
64 | 
65 | #endif	// not JOS_INC_FD_H
66 | 


--------------------------------------------------------------------------------
/lib/fprintf.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | // Collect up to 256 characters into a buffer
 4 | // and perform ONE system call to print all of them,
 5 | // in order to make the lines output to the console atomic
 6 | // and prevent interrupts from causing context switches
 7 | // in the middle of a console output line and such.
 8 | struct printbuf {
 9 | 	int fd;		// file descriptor
10 | 	int idx;	// current buffer index
11 | 	ssize_t result;	// accumulated results from write
12 | 	int error;	// first error that occurred
13 | 	char buf[256];
14 | };
15 | 
16 | 
17 | static void
18 | writebuf(struct printbuf *b)
19 | {
20 | 	if (b->error > 0) {
21 | 		ssize_t result = write(b->fd, b->buf, b->idx);
22 | 		if (result > 0)
23 | 			b->result += result;
24 | 		if (result != b->idx) // error, or wrote less than supplied
25 | 			b->error = (result < 0 ? result : 0);
26 | 	}
27 | }
28 | 
29 | static void
30 | putch(int ch, void *thunk)
31 | {
32 | 	struct printbuf *b = (struct printbuf *) thunk;
33 | 	b->buf[b->idx++] = ch;
34 | 	if (b->idx == 256) {
35 | 		writebuf(b);
36 | 		b->idx = 0;
37 | 	}
38 | }
39 | 
40 | int
41 | vfprintf(int fd, const char *fmt, va_list ap)
42 | {
43 | 	struct printbuf b;
44 | 
45 | 	b.fd = fd;
46 | 	b.idx = 0;
47 | 	b.result = 0;
48 | 	b.error = 1;
49 | 	vprintfmt(putch, &b, fmt, ap);
50 | 	if (b.idx > 0)
51 | 		writebuf(&b);
52 | 
53 | 	return (b.result ? b.result : b.error);
54 | }
55 | 
56 | int
57 | fprintf(int fd, const char *fmt, ...)
58 | {
59 | 	va_list ap;
60 | 	int cnt;
61 | 
62 | 	va_start(ap, fmt);
63 | 	cnt = vfprintf(fd, fmt, ap);
64 | 	va_end(ap);
65 | 
66 | 	return cnt;
67 | }
68 | 
69 | int
70 | printf(const char *fmt, ...)
71 | {
72 | 	va_list ap;
73 | 	int cnt;
74 | 
75 | 	va_start(ap, fmt);
76 | 	cnt = vfprintf(1, fmt, ap);
77 | 	va_end(ap);
78 | 
79 | 	return cnt;
80 | }
81 | 
82 | 


--------------------------------------------------------------------------------
/lib/args.c:
--------------------------------------------------------------------------------
 1 | #include <inc/args.h>
 2 | #include <inc/string.h>
 3 | 
 4 | void
 5 | argstart(int *argc, char **argv, struct Argstate *args)
 6 | {
 7 | 	args->argc = argc;
 8 | 	args->argv = (const char **) argv;
 9 | 	args->curarg = (*argc > 1 && argv ? "" : 0);
10 | 	args->argvalue = 0;
11 | }
12 | 
13 | int
14 | argnext(struct Argstate *args)
15 | {
16 | 	int arg;
17 | 
18 | 	args->argvalue = 0;
19 | 
20 | 	// Done processing arguments if args->curarg == 0
21 | 	if (args->curarg == 0)
22 | 		return -1;
23 | 
24 | 	if (!*args->curarg) {
25 | 		// Need to process the next argument
26 | 		// Check for end of argument list
27 | 		if (*args->argc == 1
28 | 		    || args->argv[1][0] != '-'
29 | 		    || args->argv[1][1] == '\0')
30 | 			goto endofargs;
31 | 		// Shift arguments down one
32 | 		args->curarg = args->argv[1] + 1;
33 | 		memmove(args->argv + 1, args->argv + 2, sizeof(const char *) * (*args->argc - 1));
34 | 		(*args->argc)--;
35 | 		// Check for "--": end of argument list
36 | 		if (args->curarg[0] == '-' && args->curarg[1] == '\0')
37 | 			goto endofargs;
38 | 	}
39 | 
40 | 	arg = (unsigned char) *args->curarg;
41 | 	args->curarg++;
42 | 	return arg;
43 | 
44 |     endofargs:
45 | 	args->curarg = 0;
46 | 	return -1;
47 | }
48 | 
49 | char *
50 | argvalue(struct Argstate *args)
51 | {
52 | 	return (char*) (args->argvalue ? args->argvalue : argnextvalue(args));
53 | }
54 | 
55 | char *
56 | argnextvalue(struct Argstate *args)
57 | {
58 | 	if (!args->curarg)
59 | 		return 0;
60 | 	if (*args->curarg) {
61 | 		args->argvalue = args->curarg;
62 | 		args->curarg = "";
63 | 	} else if (*args->argc > 1) {
64 | 		args->argvalue = args->argv[1];
65 | 		memmove(args->argv + 1, args->argv + 2, sizeof(const char *) * (*args->argc - 1));
66 | 		(*args->argc)--;
67 | 	} else {
68 | 		args->argvalue = 0;
69 | 		args->curarg = 0;
70 | 	}
71 | 	return (char*) args->argvalue;
72 | }
73 | 
74 | 


--------------------------------------------------------------------------------
/handin-prep:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | KEYFILE="$HOME/.ssh/id_rsa"
 4 | BASE_URL="https://pdos.csail.mit.edu/6.828/submit/"
 5 | PK_URL="$BASE_URL""setpubkey"
 6 | SSH_HOST="josgit@am.csail.mit.edu"
 7 | GIT_URL="ssh://$SSH_HOST/joslab.git"
 8 | REPO="handin"
 9 | 
10 | # generate key pairs if not exist
11 | if ! test -r "$KEYFILE"; then
12 |     read -p "SSH key file $KEYFILE does not exist, generate one? [Y/n]" r
13 |     test "$r" = y -o "$r" = Y -o -z "$r" || exit 0
14 | 
15 |     mkdir -p "`dirname $KEYFILE`"
16 |     if ! ssh-keygen -t rsa -N '' -C '' -f "$KEYFILE"; then
17 |         echo "$0: cannot generate key pairs"
18 |         exit 1
19 |     fi
20 | fi
21 | 
22 | # retrieve and display public key
23 | pubkey=$(ssh-keygen -y -f "$KEYFILE")
24 | if test -z "$pubkey"; then
25 |     echo "$0: cannot retrieve public key from $KEYFILE"
26 |     exit 1
27 | fi
28 | echo "Using public key from $KEYFILE:"
29 | echo "$pubkey" 
30 | read -p "Continue? [Y/n]" r
31 | test "$r" = y -o "$r" = Y -o -z "$r" || exit 0
32 | 
33 | # login to server
34 | echo
35 | echo "Login to 6.828 submission website."
36 | echo "If you do not have an account yet, sign up at $BASE_URL"
37 | echo "before continuing."
38 | read -p  "Username ($USER): " username
39 | test -n "$username" || username="$USER"
40 | test -n "$username" || exit 0
41 | stty -echo
42 | read -p "Password: " password
43 | stty echo
44 | test -n "$password" || exit 0
45 | echo
46 | 
47 | resp=$(curl -sSk -F "u=$username" -F "p=$password" -F "k=$pubkey" "$PK_URL")
48 | if test "$resp" != "OK"; then
49 |     test -z "$resp" || echo "$resp"
50 |     exit 1
51 | fi
52 | echo "Your public key has been successfully updated."
53 | 
54 | # config git
55 | echo "Setting up hand-in Git repository..."
56 | echo "Adding remote repository $GIT_URL as '$REPO'."
57 | git remote rm "$REPO" 2> /dev/null
58 | git remote add "$REPO" "$GIT_URL" || exit 1
59 | echo "Done! Use 'make handin' to submit your lab code."
60 | echo
61 | 


--------------------------------------------------------------------------------
/user/user.ld:
--------------------------------------------------------------------------------
 1 | /* Simple linker script for JOS user-level programs.
 2 |    See the GNU ld 'info' manual ("info ld") to learn the syntax. */
 3 | 
 4 | OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
 5 | OUTPUT_ARCH(i386)
 6 | ENTRY(_start)
 7 | 
 8 | SECTIONS
 9 | {
10 | 	/* Load programs at this address: "." means the current address */
11 | 	. = 0x800020;
12 | 
13 | 	.text : {
14 | 		*(.text .stub .text.* .gnu.linkonce.t.*)
15 | 	}
16 | 
17 | 	PROVIDE(etext = .);	/* Define the 'etext' symbol to this value */
18 | 
19 | 	.rodata : {
20 | 		*(.rodata .rodata.* .gnu.linkonce.r.*)
21 | 	}
22 | 
23 | 	/* Adjust the address for the data segment to the next page */
24 | 	. = ALIGN(0x1000);
25 | 
26 | 	.data : {
27 | 		*(.data)
28 | 	}
29 | 
30 | 	PROVIDE(edata = .);
31 | 
32 | 	.bss : {
33 | 		*(.bss)
34 | 	}
35 | 
36 | 	PROVIDE(end = .);
37 | 
38 | 
39 | 	/* Place debugging symbols so that they can be found by
40 | 	 * the kernel debugger.
41 | 	 * Specifically, the four words at 0x200000 mark the beginning of
42 | 	 * the stabs, the end of the stabs, the beginning of the stabs
43 | 	 * string table, and the end of the stabs string table, respectively.
44 | 	 */
45 | 
46 | 	.stab_info 0x200000 : {
47 | 		LONG(__STAB_BEGIN__);
48 | 		LONG(__STAB_END__);
49 | 		LONG(__STABSTR_BEGIN__);
50 | 		LONG(__STABSTR_END__);
51 | 	}
52 | 
53 | 	.stab : {
54 | 		__STAB_BEGIN__ = DEFINED(__STAB_BEGIN__) ? __STAB_BEGIN__ : .;
55 | 		*(.stab);
56 | 		__STAB_END__ = DEFINED(__STAB_END__) ? __STAB_END__ : .;
57 | 		BYTE(0)		/* Force the linker to allocate space
58 | 				   for this section */
59 | 	}
60 | 
61 | 	.stabstr : {
62 | 		__STABSTR_BEGIN__ = DEFINED(__STABSTR_BEGIN__) ? __STABSTR_BEGIN__ : .;
63 | 		*(.stabstr);
64 | 		__STABSTR_END__ = DEFINED(__STABSTR_END__) ? __STABSTR_END__ : .;
65 | 		BYTE(0)		/* Force the linker to allocate space
66 | 				   for this section */
67 | 	}
68 | 
69 | 	/DISCARD/ : {
70 | 		*(.eh_frame .note.GNU-stack .comment)
71 | 	}
72 | }
73 | 


--------------------------------------------------------------------------------
/user/echotest.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | #include <lwip/sockets.h>
 3 | #include <lwip/inet.h>
 4 | 
 5 | #define BUFFSIZE 32
 6 | #define IPADDR "10.0.2.15"
 7 | #define PORT 10000
 8 | 
 9 | const char *msg = "Hello world!\n";
10 | 
11 | static void
12 | die(char *m)
13 | {
14 | 	cprintf("%s\n", m);
15 | 	exit();
16 | }
17 | 
18 | void umain(int argc, char **argv)
19 | {
20 | 	int sock;
21 | 	struct sockaddr_in echoserver;
22 | 	char buffer[BUFFSIZE];
23 | 	unsigned int echolen;
24 | 	int received = 0;
25 | 
26 | 	cprintf("Connecting to:\n");
27 | 	cprintf("\tip address %s = %x\n", IPADDR, inet_addr(IPADDR));
28 | 
29 | 	// Create the TCP socket
30 | 	if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
31 | 		die("Failed to create socket");
32 | 
33 | 	cprintf("opened socket\n");
34 | 
35 | 	// Construct the server sockaddr_in structure
36 | 	memset(&echoserver, 0, sizeof(echoserver));       // Clear struct
37 | 	echoserver.sin_family = AF_INET;                  // Internet/IP
38 | 	echoserver.sin_addr.s_addr = inet_addr(IPADDR);   // IP address
39 | 	echoserver.sin_port = htons(PORT);		  // server port
40 | 
41 | 	cprintf("trying to connect to server\n");
42 | 
43 | 	// Establish connection
44 | 	if (connect(sock, (struct sockaddr *) &echoserver, sizeof(echoserver)) < 0)
45 | 		die("Failed to connect with server");
46 | 
47 | 	cprintf("connected to server\n");
48 | 
49 | 	// Send the word to the server
50 | 	echolen = strlen(msg);
51 | 	if (write(sock, msg, echolen) != echolen)
52 | 		die("Mismatch in number of sent bytes");
53 | 
54 | 	// Receive the word back from the server
55 | 	cprintf("Received: \n");
56 | 	while (received < echolen) {
57 | 		int bytes = 0;
58 | 		if ((bytes = read(sock, buffer, BUFFSIZE-1)) < 1) {
59 | 			die("Failed to receive bytes from server");
60 | 		}
61 | 		received += bytes;
62 | 		buffer[bytes] = '\0';        // Assure null terminated string
63 | 		cprintf(buffer);
64 | 	}
65 | 	cprintf("\n");
66 | 
67 | 	close(sock);
68 | }
69 | 


--------------------------------------------------------------------------------
/user/ls.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | int flag[256];
 4 | 
 5 | void lsdir(const char*, const char*);
 6 | void ls1(const char*, bool, off_t, const char*);
 7 | 
 8 | void
 9 | ls(const char *path, const char *prefix)
10 | {
11 | 	int r;
12 | 	struct Stat st;
13 | 
14 | 	if ((r = stat(path, &st)) < 0)
15 | 		panic("stat %s: %e", path, r);
16 | 	if (st.st_isdir && !flag['d'])
17 | 		lsdir(path, prefix);
18 | 	else
19 | 		ls1(0, st.st_isdir, st.st_size, path);
20 | }
21 | 
22 | void
23 | lsdir(const char *path, const char *prefix)
24 | {
25 | 	int fd, n;
26 | 	struct File f;
27 | 
28 | 	if ((fd = open(path, O_RDONLY)) < 0)
29 | 		panic("open %s: %e", path, fd);
30 | 	while ((n = readn(fd, &f, sizeof f)) == sizeof f)
31 | 		if (f.f_name[0])
32 | 			ls1(prefix, f.f_type==FTYPE_DIR, f.f_size, f.f_name);
33 | 	if (n > 0)
34 | 		panic("short read in directory %s", path);
35 | 	if (n < 0)
36 | 		panic("error reading directory %s: %e", path, n);
37 | }
38 | 
39 | void
40 | ls1(const char *prefix, bool isdir, off_t size, const char *name)
41 | {
42 | 	const char *sep;
43 | 
44 | 	if(flag['l'])
45 | 		printf("%11d %c ", size, isdir ? 'd' : '-');
46 | 	if(prefix) {
47 | 		if (prefix[0] && prefix[strlen(prefix)-1] != '/')
48 | 			sep = "/";
49 | 		else
50 | 			sep = "";
51 | 		printf("%s%s", prefix, sep);
52 | 	}
53 | 	printf("%s", name);
54 | 	if(flag['F'] && isdir)
55 | 		printf("/");
56 | 	printf("\n");
57 | }
58 | 
59 | void
60 | usage(void)
61 | {
62 | 	printf("usage: ls [-dFl] [file...]\n");
63 | 	exit();
64 | }
65 | 
66 | void
67 | umain(int argc, char **argv)
68 | {
69 | 	int i;
70 | 	struct Argstate args;
71 | 
72 | 	argstart(&argc, argv, &args);
73 | 	while ((i = argnext(&args)) >= 0)
74 | 		switch (i) {
75 | 		case 'd':
76 | 		case 'F':
77 | 		case 'l':
78 | 			flag[i]++;
79 | 			break;
80 | 		default:
81 | 			usage();
82 | 		}
83 | 
84 | 	if (argc == 1)
85 | 		ls("/", "");
86 | 	else {
87 | 		for (i = 1; i < argc; i++)
88 | 			ls(argv[i], argv[i]);
89 | 	}
90 | }
91 | 
92 | 


--------------------------------------------------------------------------------
/user/primespipe.c:
--------------------------------------------------------------------------------
 1 | // Concurrent version of prime sieve of Eratosthenes.
 2 | // Invented by Doug McIlroy, inventor of Unix pipes.
 3 | // See http://swtch.com/~rsc/thread/.
 4 | // The picture halfway down the page and the text surrounding it
 5 | // explain what's going on here.
 6 | //
 7 | // Since NENVS is 1024, we can print 1022 primes before running out.
 8 | // The remaining two environments are the integer generator at the bottom
 9 | // of main and user/idle.
10 | 
11 | #include <inc/lib.h>
12 | 
13 | unsigned
14 | primeproc(int fd)
15 | {
16 | 	int i, id, p, pfd[2], wfd, r;
17 | 
18 | 	// fetch a prime from our left neighbor
19 | top:
20 | 	if ((r = readn(fd, &p, 4)) != 4)
21 | 		panic("primeproc could not read initial prime: %d, %e", r, r >= 0 ? 0 : r);
22 | 
23 | 	cprintf("%d\n", p);
24 | 
25 | 	// fork a right neighbor to continue the chain
26 | 	if ((i=pipe(pfd)) < 0)
27 | 		panic("pipe: %e", i);
28 | 	if ((id = fork()) < 0)
29 | 		panic("fork: %e", id);
30 | 	if (id == 0) {
31 | 		close(fd);
32 | 		close(pfd[1]);
33 | 		fd = pfd[0];
34 | 		goto top;
35 | 	}
36 | 
37 | 	close(pfd[0]);
38 | 	wfd = pfd[1];
39 | 
40 | 	// filter out multiples of our prime
41 | 	for (;;) {
42 | 		if ((r=readn(fd, &i, 4)) != 4)
43 | 			panic("primeproc %d readn %d %d %e", p, fd, r, r >= 0 ? 0 : r);
44 | 		if (i%p)
45 | 			if ((r=write(wfd, &i, 4)) != 4)
46 | 				panic("primeproc %d write: %d %e", p, r, r >= 0 ? 0 : r);
47 | 	}
48 | }
49 | 
50 | void
51 | umain(int argc, char **argv)
52 | {
53 | 	int i, id, p[2], r;
54 | 
55 | 	binaryname = "primespipe";
56 | 
57 | 	if ((i=pipe(p)) < 0)
58 | 		panic("pipe: %e", i);
59 | 
60 | 	// fork the first prime process in the chain
61 | 	if ((id=fork()) < 0)
62 | 		panic("fork: %e", id);
63 | 
64 | 	if (id == 0) {
65 | 		close(p[1]);
66 | 		primeproc(p[0]);
67 | 	}
68 | 
69 | 	close(p[0]);
70 | 
71 | 	// feed all the integers through
72 | 	for (i=2;; i++)
73 | 		if ((r=write(p[1], &i, 4)) != 4)
74 | 			panic("generator write: %d, %e", r, r >= 0 ? 0 : r);
75 | }
76 | 
77 | 


--------------------------------------------------------------------------------
/user/testshell.c:
--------------------------------------------------------------------------------
 1 | #include <inc/x86.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | void wrong(int, int, int);
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	char c1, c2;
10 | 	int r, rfd, wfd, kfd, n1, n2, off, nloff;
11 | 	int pfds[2];
12 | 
13 | 	close(0);
14 | 	close(1);
15 | 	opencons();
16 | 	opencons();
17 | 
18 | 	if ((rfd = open("testshell.sh", O_RDONLY)) < 0)
19 | 		panic("open testshell.sh: %e", rfd);
20 | 	if ((wfd = pipe(pfds)) < 0)
21 | 		panic("pipe: %e", wfd);
22 | 	wfd = pfds[1];
23 | 
24 | 	cprintf("running sh -x < testshell.sh | cat\n");
25 | 	if ((r = fork()) < 0)
26 | 		panic("fork: %e", r);
27 | 	if (r == 0) {
28 | 		dup(rfd, 0);
29 | 		dup(wfd, 1);
30 | 		close(rfd);
31 | 		close(wfd);
32 | 		if ((r = spawnl("/sh", "sh", "-x", 0)) < 0)
33 | 			panic("spawn: %e", r);
34 | 		close(0);
35 | 		close(1);
36 | 		wait(r);
37 | 		exit();
38 | 	}
39 | 	close(rfd);
40 | 	close(wfd);
41 | 
42 | 	rfd = pfds[0];
43 | 	if ((kfd = open("testshell.key", O_RDONLY)) < 0)
44 | 		panic("open testshell.key for reading: %e", kfd);
45 | 
46 | 	nloff = 0;
47 | 	for (off=0;; off++) {
48 | 		n1 = read(rfd, &c1, 1);
49 | 		n2 = read(kfd, &c2, 1);
50 | 		if (n1 < 0)
51 | 			panic("reading testshell.out: %e", n1);
52 | 		if (n2 < 0)
53 | 			panic("reading testshell.key: %e", n2);
54 | 		if (n1 == 0 && n2 == 0)
55 | 			break;
56 | 		if (n1 != 1 || n2 != 1 || c1 != c2)
57 | 			wrong(rfd, kfd, nloff);
58 | 		if (c1 == '\n')
59 | 			nloff = off+1;
60 | 	}
61 | 	cprintf("shell ran correctly\n");
62 | 
63 | 	breakpoint();
64 | }
65 | 
66 | void
67 | wrong(int rfd, int kfd, int off)
68 | {
69 | 	char buf[100];
70 | 	int n;
71 | 
72 | 	seek(rfd, off);
73 | 	seek(kfd, off);
74 | 
75 | 	cprintf("shell produced incorrect output.\n");
76 | 	cprintf("expected:\n===\n");
77 | 	while ((n = read(kfd, buf, sizeof buf-1)) > 0)
78 | 		sys_cputs(buf, n);
79 | 	cprintf("===\ngot:\n===\n");
80 | 	while ((n = read(rfd, buf, sizeof buf-1)) > 0)
81 | 		sys_cputs(buf, n);
82 | 	cprintf("===\n");
83 | 	exit();
84 | }
85 | 
86 | 


--------------------------------------------------------------------------------
/user/testpiperace.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	int p[2], r, pid, i, max;
 7 | 	void *va;
 8 | 	struct Fd *fd;
 9 | 	const volatile struct Env *kid;
10 | 
11 | 	cprintf("testing for dup race...\n");
12 | 	if ((r = pipe(p)) < 0)
13 | 		panic("pipe: %e", r);
14 | 	max = 200;
15 | 	if ((r = fork()) < 0)
16 | 		panic("fork: %e", r);
17 | 	if (r == 0) {
18 | 		close(p[1]);
19 | 		//
20 | 		// Now the ref count for p[0] will toggle between 2 and 3
21 | 		// as the parent dups and closes it (there's a close implicit in dup).
22 | 		//
23 | 		// The ref count for p[1] is 1.
24 | 		// Thus the ref count for the underlying pipe structure
25 | 		// will toggle between 3 and 4.
26 | 		//
27 | 		// If a clock interrupt catches close between unmapping
28 | 		// the pipe structure and unmapping the fd, we'll have
29 | 		// a ref count for p[0] of 3, a ref count for p[1] of 1,
30 | 		// and a ref count for the pipe structure of 3, which is
31 | 		// a no-no.
32 | 		//
33 | 		// If a clock interrupt catches dup between mapping the
34 | 		// fd and mapping the pipe structure, we'll have the same
35 | 		// ref counts, still a no-no.
36 | 		//
37 | 		for (i=0; i<max; i++) {
38 | 			if(pipeisclosed(p[0])){
39 | 				cprintf("RACE: pipe appears closed\n");
40 | 				exit();
41 | 			}
42 | 			sys_yield();
43 | 		}
44 | 		// do something to be not runnable besides exiting
45 | 		ipc_recv(0,0,0);
46 | 	}
47 | 	pid = r;
48 | 	cprintf("pid is %d\n", pid);
49 | 	va = 0;
50 | 	kid = &envs[ENVX(pid)];
51 | 	cprintf("kid is %d\n", kid-envs);
52 | 	dup(p[0], 10);
53 | 	while (kid->env_status == ENV_RUNNABLE)
54 | 		dup(p[0], 10);
55 | 
56 | 	cprintf("child done with loop\n");
57 | 	if (pipeisclosed(p[0]))
58 | 		panic("somehow the other end of p[0] got closed!");
59 | 	if ((r = fd_lookup(p[0], &fd)) < 0)
60 | 		panic("cannot look up p[0]: %e", r);
61 | 	va = fd2data(fd);
62 | 	if (pageref(va) != 3+1)
63 | 		cprintf("\nchild detected race\n");
64 | 	else
65 | 		cprintf("\nrace didn't happen\n", max);
66 | }
67 | 


--------------------------------------------------------------------------------
/net/lwip/include/lwip/init.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | #ifndef __LWIP_INIT_H__
33 | #define __LWIP_INIT_H__
34 | 
35 | #include "lwip/opt.h"
36 | 
37 | #ifdef __cplusplus
38 | extern "C" {
39 | #endif
40 | 
41 | /* Modules initialization */
42 | void lwip_init(void);
43 | 
44 | #ifdef __cplusplus
45 | }
46 | #endif
47 | 
48 | #endif /* __LWIP_INIT_H__ */
49 | 


--------------------------------------------------------------------------------
/net/lwip/include/lwip/def.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | #ifndef __LWIP_DEF_H__
33 | #define __LWIP_DEF_H__
34 | 
35 | /* this might define NULL already */
36 | #include "lwip/arch.h"
37 | 
38 | #define LWIP_MAX(x , y)  (((x) > (y)) ? (x) : (y))
39 | #define LWIP_MIN(x , y)  (((x) < (y)) ? (x) : (y))
40 | 
41 | #ifndef NULL
42 | #define NULL ((void *)0)
43 | #endif
44 | 
45 | 
46 | #endif /* __LWIP_DEF_H__ */
47 | 
48 | 


--------------------------------------------------------------------------------
/fs/test.c:
--------------------------------------------------------------------------------
 1 | #include <inc/x86.h>
 2 | #include <inc/string.h>
 3 | 
 4 | #include "fs.h"
 5 | 
 6 | static char *msg = "This is the NEW message of the day!\n\n";
 7 | 
 8 | void
 9 | fs_test(void)
10 | {
11 | 	struct File *f;
12 | 	int r;
13 | 	char *blk;
14 | 	uint32_t *bits;
15 | 
16 | 	// back up bitmap
17 | 	if ((r = sys_page_alloc(0, (void*) PGSIZE, PTE_P|PTE_U|PTE_W)) < 0)
18 | 		panic("sys_page_alloc: %e", r);
19 | 	bits = (uint32_t*) PGSIZE;
20 | 	memmove(bits, bitmap, PGSIZE);
21 | 	// allocate block
22 | 	if ((r = alloc_block()) < 0)
23 | 		panic("alloc_block: %e", r);
24 | 	// check that block was free
25 | 	assert(bits[r/32] & (1 << (r%32)));
26 | 	// and is not free any more
27 | 	assert(!(bitmap[r/32] & (1 << (r%32))));
28 | 	cprintf("alloc_block is good\n");
29 | 
30 | 	if ((r = file_open("/not-found", &f)) < 0 && r != -E_NOT_FOUND)
31 | 		panic("file_open /not-found: %e", r);
32 | 	else if (r == 0)
33 | 		panic("file_open /not-found succeeded!");
34 | 	if ((r = file_open("/newmotd", &f)) < 0)
35 | 		panic("file_open /newmotd: %e", r);
36 | 	cprintf("file_open is good\n");
37 | 
38 | 	if ((r = file_get_block(f, 0, &blk)) < 0)
39 | 		panic("file_get_block: %e", r);
40 | 	if (strcmp(blk, msg) != 0)
41 | 		panic("file_get_block returned wrong data");
42 | 	cprintf("file_get_block is good\n");
43 | 
44 | 	*(volatile char*)blk = *(volatile char*)blk;
45 | 	assert((uvpt[PGNUM(blk)] & PTE_D));
46 | 	file_flush(f);
47 | 	assert(!(uvpt[PGNUM(blk)] & PTE_D));
48 | 	cprintf("file_flush is good\n");
49 | 
50 | 	if ((r = file_set_size(f, 0)) < 0)
51 | 		panic("file_set_size: %e", r);
52 | 	assert(f->f_direct[0] == 0);
53 | 	assert(!(uvpt[PGNUM(f)] & PTE_D));
54 | 	cprintf("file_truncate is good\n");
55 | 
56 | 	if ((r = file_set_size(f, strlen(msg))) < 0)
57 | 		panic("file_set_size 2: %e", r);
58 | 	assert(!(uvpt[PGNUM(f)] & PTE_D));
59 | 	if ((r = file_get_block(f, 0, &blk)) < 0)
60 | 		panic("file_get_block 2: %e", r);
61 | 	strcpy(blk, msg);
62 | 	assert((uvpt[PGNUM(blk)] & PTE_D));
63 | 	file_flush(f);
64 | 	assert(!(uvpt[PGNUM(blk)] & PTE_D));
65 | 	assert(!(uvpt[PGNUM(f)] & PTE_D));
66 | 	cprintf("file rewrite is good\n");
67 | }
68 | 


--------------------------------------------------------------------------------
/inc/stab.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_STAB_H
 2 | #define JOS_STAB_H
 3 | #include <inc/types.h>
 4 | 
 5 | // <inc/stab.h>
 6 | // STABS debugging info
 7 | 
 8 | // The JOS kernel debugger can understand some debugging information
 9 | // in the STABS format.  For more information on this format, see
10 | // http://sourceware.org/gdb/onlinedocs/stabs.html
11 | 
12 | // The constants below define some symbol types used by various debuggers
13 | // and compilers.  JOS uses the N_SO, N_SOL, N_FUN, and N_SLINE types.
14 | 
15 | #define	N_GSYM		0x20	// global symbol
16 | #define	N_FNAME		0x22	// F77 function name
17 | #define	N_FUN		0x24	// procedure name
18 | #define	N_STSYM		0x26	// data segment variable
19 | #define	N_LCSYM		0x28	// bss segment variable
20 | #define	N_MAIN		0x2a	// main function name
21 | #define	N_PC		0x30	// global Pascal symbol
22 | #define	N_RSYM		0x40	// register variable
23 | #define	N_SLINE		0x44	// text segment line number
24 | #define	N_DSLINE	0x46	// data segment line number
25 | #define	N_BSLINE	0x48	// bss segment line number
26 | #define	N_SSYM		0x60	// structure/union element
27 | #define	N_SO		0x64	// main source file name
28 | #define	N_LSYM		0x80	// stack variable
29 | #define	N_BINCL		0x82	// include file beginning
30 | #define	N_SOL		0x84	// included source file name
31 | #define	N_PSYM		0xa0	// parameter variable
32 | #define	N_EINCL		0xa2	// include file end
33 | #define	N_ENTRY		0xa4	// alternate entry point
34 | #define	N_LBRAC		0xc0	// left bracket
35 | #define	N_EXCL		0xc2	// deleted include file
36 | #define	N_RBRAC		0xe0	// right bracket
37 | #define	N_BCOMM		0xe2	// begin common
38 | #define	N_ECOMM		0xe4	// end common
39 | #define	N_ECOML		0xe8	// end common (local name)
40 | #define	N_LENG		0xfe	// length of preceding entry
41 | 
42 | // Entries in the STABS table are formatted as follows.
43 | struct Stab {
44 | 	uint32_t n_strx;	// index into string table of name
45 | 	uint8_t n_type;         // type of symbol
46 | 	uint8_t n_other;        // misc info (usually empty)
47 | 	uint16_t n_desc;        // description field
48 | 	uintptr_t n_value;	// value of symbol
49 | };
50 | 
51 | #endif /* !JOS_STAB_H */
52 | 


--------------------------------------------------------------------------------
/net/lwip/include/netif/slipif.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001, Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  *
 5 |  * Redistribution and use in source and binary forms, with or without 
 6 |  * modification, are permitted provided that the following conditions 
 7 |  * are met: 
 8 |  * 1. Redistributions of source code must retain the above copyright 
 9 |  *    notice, this list of conditions and the following disclaimer. 
10 |  * 2. Redistributions in binary form must reproduce the above copyright 
11 |  *    notice, this list of conditions and the following disclaimer in the 
12 |  *    documentation and/or other materials provided with the distribution. 
13 |  * 3. Neither the name of the Institute nor the names of its contributors 
14 |  *    may be used to endorse or promote products derived from this software 
15 |  *    without specific prior written permission. 
16 |  *
17 |  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
18 |  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
19 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
20 |  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
21 |  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
22 |  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
23 |  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
24 |  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
25 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
26 |  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
27 |  * SUCH DAMAGE. 
28 |  *
29 |  * This file is part of the lwIP TCP/IP stack.
30 |  * 
31 |  * Author: Adam Dunkels <adam@sics.se>
32 |  *
33 |  */
34 | #ifndef __NETIF_SLIPIF_H__
35 | #define __NETIF_SLIPIF_H__
36 | 
37 | #include "lwip/netif.h"
38 | 
39 | #ifdef __cplusplus
40 | extern "C" {
41 | #endif
42 | 
43 | err_t slipif_init(struct netif * netif);
44 | 
45 | #ifdef __cplusplus
46 | }
47 | #endif
48 |  
49 | #endif 
50 | 
51 | 


--------------------------------------------------------------------------------
/net/lwip/jos/lwipopts.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_LWIP_LWIPOPTS_H
 2 | #define JOS_LWIP_LWIPOPTS_H
 3 | 
 4 | // Huge hack to include memcpy. Since this is the only file that is
 5 | // consistently included in all of lwip, a definition of memcpy can be added
 6 | // here to make it lwip visible. I am hiding lwip because JOS seems to want to
 7 | // do so. There is a declaration of memcpy in JOS but not a definition.
 8 | #include <inc/types.h>
 9 | void *memcpy(void *dst, const void *src, size_t n);
10 | 
11 | //#define NO_SYS 1
12 | 
13 | #define LWIP_STATS		0
14 | #define LWIP_STATS_DISPLAY	0
15 | #define LWIP_DHCP		1
16 | #define LWIP_COMPAT_SOCKETS	0
17 | //#define SYS_LIGHTWEIGHT_PROT	1
18 | #define LWIP_PROVIDE_ERRNO      1
19 | 
20 | // Various tuning knobs, see:
21 | // http://lists.gnu.org/archive/html/lwip-users/2006-11/msg00007.html
22 | 
23 | #define MEM_ALIGNMENT		4
24 | 
25 | #define MEMP_NUM_PBUF		64
26 | #define MEMP_NUM_UDP_PCB	8
27 | #define MEMP_NUM_TCP_PCB	32
28 | #define MEMP_NUM_TCP_PCB_LISTEN	16
29 | #define MEMP_NUM_TCP_SEG	TCP_SND_QUEUELEN// at least as big as TCP_SND_QUEUELEN
30 | #define MEMP_NUM_NETBUF		128
31 | #define MEMP_NUM_NETCONN	32
32 | #define MEMP_NUM_SYS_TIMEOUT    6
33 | 
34 | #define PER_TCP_PCB_BUFFER	(16 * 4096)
35 | #define MEM_SIZE		(PER_TCP_PCB_BUFFER*MEMP_NUM_TCP_SEG + 4096*MEMP_NUM_TCP_SEG)
36 | 
37 | #define PBUF_POOL_SIZE		512
38 | #define PBUF_POOL_BUFSIZE	2000
39 | 
40 | #define TCP_MSS			1460
41 | #define TCP_WND			24000
42 | #define TCP_SND_BUF		(16 * TCP_MSS)
43 | // lwip prints a warning if TCP_SND_QUEUELEN < (2 * TCP_SND_BUF/TCP_MSS), 
44 | // but 16 is faster.. 
45 | #define TCP_SND_QUEUELEN	(2 * TCP_SND_BUF/TCP_MSS)
46 | //#define TCP_SND_QUEUELEN	16
47 | 
48 | // Print error messages when we run out of memory
49 | #define LWIP_DEBUG	1
50 | //#define TCP_DEBUG	LWIP_DBG_ON
51 | //#define MEMP_DEBUG	LWIP_DBG_ON
52 | //#define SOCKETS_DEBUG	LWIP_DBG_ON
53 | //#define DBG_TYPES_ON	LWIP_DBG_ON
54 | //#define PBUF_DEBUG      LWIP_DBG_ON
55 | //#define API_LIB_DEBUG   LWIP_DBG_ON
56 | 
57 | #define DBG_MIN_LEVEL	DBG_LEVEL_SERIOUS
58 | #define LWIP_DBG_MIN_LEVEL	0
59 | #define MEMP_SANITY_CHECK	0
60 | 
61 | #define ERRNO
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/net/lwip/Makefrag:
--------------------------------------------------------------------------------
 1 | LWIP_INCLUDES := \
 2 | 	-I$(TOP)/net/lwip/include \
 3 | 	-I$(TOP)/net/lwip/include/ipv4 \
 4 | 	-I$(TOP)/net/lwip/ext \
 5 | 	-I$(TOP)/net/lwip/jos \
 6 | 	-I$(TOP)/inc/
 7 | 
 8 | OBJDIRS += \
 9 | 	net/lwip \
10 | 	net/lwip/api \
11 | 	net/lwip/core \
12 | 	net/lwip/core/ipv4 \
13 | 	net/lwip/netif \
14 | 	net/lwip/jos/arch \
15 | 	net/lwip/jos/jif \
16 | 	net/lwip/jos/api
17 | 
18 | USER_INC += $(LWIP_INCLUDES)
19 | 
20 | LWIP_SRCFILES += \
21 | 	net/lwip/api/api_lib.c \
22 | 	net/lwip/api/api_msg.c \
23 | 	net/lwip/api/err.c \
24 | 	net/lwip/api/sockets.c \
25 | 	net/lwip/api/tcpip.c \
26 | 	net/lwip/api/netbuf.c \
27 | 	net/lwip/core/init.c \
28 | 	net/lwip/core/tcp_in.c \
29 | 	net/lwip/core/dhcp.c \
30 | 	net/lwip/core/mem.c \
31 | 	net/lwip/core/memp.c \
32 | 	net/lwip/core/netif.c \
33 | 	net/lwip/core/pbuf.c \
34 | 	net/lwip/core/raw.c \
35 | 	net/lwip/core/stats.c \
36 | 	net/lwip/core/sys.c \
37 | 	net/lwip/core/tcp.c \
38 | 	net/lwip/core/ipv4/ip_addr.c \
39 | 	net/lwip/core/ipv4/icmp.c \
40 | 	net/lwip/core/ipv4/ip.c \
41 | 	net/lwip/core/ipv4/ip_frag.c \
42 | 	net/lwip/core/ipv4/inet_chksum.c \
43 | 	net/lwip/core/ipv4/inet.c \
44 | 	net/lwip/core/tcp_out.c \
45 | 	net/lwip/core/udp.c \
46 | 	net/lwip/netif/etharp.c \
47 | 	net/lwip/netif/loopif.c \
48 | 	net/lwip/jos/arch/sys_arch.c \
49 | 	net/lwip/jos/arch/thread.c \
50 | 	net/lwip/jos/arch/longjmp.S \
51 | 	net/lwip/jos/arch/perror.c \
52 | 	net/lwip/jos/jif/jif.c \
53 | #	net/lwip/jos/jif/tun.c \
54 | 	net/lwip/jos/api/lsocket.c \
55 | 	net/lwip/jos/api/lwipinit.c
56 | 
57 | LWIP_OBJFILES := $(patsubst %.c, $(OBJDIR)/%.o, $(LWIP_SRCFILES))
58 | LWIP_OBJFILES := $(patsubst %.S, $(OBJDIR)/%.o, $(LWIP_OBJFILES))
59 | 
60 | $(OBJDIR)/net/lwip/%.o: net/lwip/%.c $(OBJDIR)/.vars.USER_CFLAGS
61 | 	@echo + cc[USER] $<
62 | 	$(V)mkdir -p $(@D)
63 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) $(USER_INC) -c -o $@ $<
64 | 
65 | $(OBJDIR)/net/lwip/%.o: net/lwip/%.S $(OBJDIR)/.vars.USER_CFLAGS
66 | 	@echo + as[USER] $<
67 | 	@mkdir -p $(@D)
68 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
69 | 
70 | $(OBJDIR)/lib/liblwip.a: $(LWIP_OBJFILES)
71 | 	@echo + ar $@
72 | 	$(V)mkdir -p $(@D)
73 | 	$(V)$(AR) r $@ $(LWIP_OBJFILES)
74 | 


--------------------------------------------------------------------------------
/user/testpiperace2.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <inc/lib.h>
 3 | 
 4 | void
 5 | umain(int argc, char **argv)
 6 | {
 7 | 	int p[2], r, i;
 8 | 	struct Fd *fd;
 9 | 	const volatile struct Env *kid;
10 | 
11 | 	cprintf("testing for pipeisclosed race...\n");
12 | 	if ((r = pipe(p)) < 0)
13 | 		panic("pipe: %e", r);
14 | 	if ((r = fork()) < 0)
15 | 		panic("fork: %e", r);
16 | 	if (r == 0) {
17 | 		// child just dups and closes repeatedly,
18 | 		// yielding so the parent can see
19 | 		// the fd state between the two.
20 | 		close(p[1]);
21 | 		for (i = 0; i < 200; i++) {
22 | 			if (i % 10 == 0)
23 | 				cprintf("%d.", i);
24 | 			// dup, then close.  yield so that other guy will
25 | 			// see us while we're between them.
26 | 			dup(p[0], 10);
27 | 			sys_yield();
28 | 			close(10);
29 | 			sys_yield();
30 | 		}
31 | 		exit();
32 | 	}
33 | 
34 | 	// We hold both p[0] and p[1] open, so pipeisclosed should
35 | 	// never return false.
36 | 	//
37 | 	// Now the ref count for p[0] will toggle between 2 and 3
38 | 	// as the child dups and closes it.
39 | 	// The ref count for p[1] is 1.
40 | 	// Thus the ref count for the underlying pipe structure
41 | 	// will toggle between 3 and 4.
42 | 	//
43 | 	// If pipeisclosed checks pageref(p[0]) and gets 3, and
44 | 	// then the child closes, and then pipeisclosed checks
45 | 	// pageref(pipe structure) and gets 3, then it will return true
46 | 	// when it shouldn't.
47 | 	//
48 | 	// If pipeisclosed checks pageref(pipe structure) and gets 3,
49 | 	// and then the child dups, and then pipeisclosed checks
50 | 	// pageref(p[0]) and gets 3, then it will return true when
51 | 	// it shouldn't.
52 | 	//
53 | 	// So either way, pipeisclosed is going give a wrong answer.
54 | 	//
55 | 	kid = &envs[ENVX(r)];
56 | 	while (kid->env_status == ENV_RUNNABLE)
57 | 		if (pipeisclosed(p[0]) != 0) {
58 | 			cprintf("\nRACE: pipe appears closed\n");
59 | 			sys_env_destroy(r);
60 | 			exit();
61 | 		}
62 | 	cprintf("child done with loop\n");
63 | 	if (pipeisclosed(p[0]))
64 | 		panic("somehow the other end of p[0] got closed!");
65 | 	if ((r = fd_lookup(p[0], &fd)) < 0)
66 | 		panic("cannot look up p[0]: %e", r);
67 | 	(void) fd2data(fd);
68 | 	cprintf("race didn't happen\n");
69 | }
70 | 


--------------------------------------------------------------------------------
/net/lwip/include/netif/loopif.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | #ifndef __NETIF_LOOPIF_H__
33 | #define __NETIF_LOOPIF_H__
34 | 
35 | #include "lwip/opt.h"
36 | #include "lwip/netif.h"
37 | #include "lwip/err.h"
38 | 
39 | #ifdef __cplusplus
40 | extern "C" {
41 | #endif
42 | 
43 | #if !LWIP_NETIF_LOOPBACK_MULTITHREADING
44 | #define loopif_poll netif_poll
45 | #endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
46 | 
47 | err_t loopif_init(struct netif *netif);
48 | 
49 | #ifdef __cplusplus
50 | }
51 | #endif
52 | 
53 | #endif /* __NETIF_LOOPIF_H__ */
54 | 


--------------------------------------------------------------------------------
/inc/types.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_TYPES_H
 2 | #define JOS_INC_TYPES_H
 3 | 
 4 | #ifndef NULL
 5 | #define NULL ((void*) 0)
 6 | #endif
 7 | 
 8 | // Represents true-or-false values
 9 | typedef _Bool bool;
10 | enum { false, true };
11 | 
12 | // Explicitly-sized versions of integer types
13 | typedef __signed char int8_t;
14 | typedef unsigned char uint8_t;
15 | typedef short int16_t;
16 | typedef unsigned short uint16_t;
17 | typedef int int32_t;
18 | typedef unsigned int uint32_t;
19 | typedef long long int64_t;
20 | typedef unsigned long long uint64_t;
21 | 
22 | // Pointers and addresses are 32 bits long.
23 | // We use pointer types to represent virtual addresses,
24 | // uintptr_t to represent the numerical values of virtual addresses,
25 | // and physaddr_t to represent physical addresses.
26 | typedef int32_t intptr_t;
27 | typedef uint32_t uintptr_t;
28 | typedef uint32_t physaddr_t;
29 | 
30 | // Page numbers are 32 bits long.
31 | typedef uint32_t ppn_t;
32 | 
33 | // size_t is used for memory object sizes.
34 | typedef uint32_t size_t;
35 | // ssize_t is a signed version of ssize_t, used in case there might be an
36 | // error return.
37 | typedef int32_t ssize_t;
38 | 
39 | // off_t is used for file offsets and lengths.
40 | typedef int32_t off_t;
41 | 
42 | // Efficient min and max operations
43 | #define MIN(_a, _b)						\
44 | ({								\
45 | 	typeof(_a) __a = (_a);					\
46 | 	typeof(_b) __b = (_b);					\
47 | 	__a <= __b ? __a : __b;					\
48 | })
49 | #define MAX(_a, _b)						\
50 | ({								\
51 | 	typeof(_a) __a = (_a);					\
52 | 	typeof(_b) __b = (_b);					\
53 | 	__a >= __b ? __a : __b;					\
54 | })
55 | 
56 | // Rounding operations (efficient when n is a power of 2)
57 | // Round down to the nearest multiple of n
58 | #define ROUNDDOWN(a, n)						\
59 | ({								\
60 | 	uint32_t __a = (uint32_t) (a);				\
61 | 	(typeof(a)) (__a - __a % (n));				\
62 | })
63 | // Round up to the nearest multiple of n
64 | #define ROUNDUP(a, n)						\
65 | ({								\
66 | 	uint32_t __n = (uint32_t) (n);				\
67 | 	(typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n));	\
68 | })
69 | 
70 | // Return the offset of 'member' relative to the beginning of a struct type
71 | #define offsetof(type, member)  ((size_t) (&((type*)0)->member))
72 | 
73 | #endif /* !JOS_INC_TYPES_H */
74 | 


--------------------------------------------------------------------------------
/fs/Makefrag:
--------------------------------------------------------------------------------
 1 | 
 2 | OBJDIRS += fs
 3 | 
 4 | FSOFILES := 		$(OBJDIR)/fs/ide.o \
 5 | 			$(OBJDIR)/fs/bc.o \
 6 | 			$(OBJDIR)/fs/fs.o \
 7 | 			$(OBJDIR)/fs/serv.o \
 8 | 			$(OBJDIR)/fs/test.o \
 9 | 
10 | USERAPPS := 		$(OBJDIR)/user/init
11 | 
12 | FSIMGTXTFILES :=	fs/newmotd \
13 | 			fs/motd
14 | 
15 | FSIMGTXTFILES :=	$(FSIMGTXTFILES) \
16 | 			fs/index.html
17 | 
18 | USERAPPS :=		$(USERAPPS) \
19 | 			$(OBJDIR)/user/cat \
20 | 			$(OBJDIR)/user/echo \
21 | 			$(OBJDIR)/user/init \
22 | 			$(OBJDIR)/user/ls \
23 | 			$(OBJDIR)/user/lsfd \
24 | 			$(OBJDIR)/user/num \
25 | 			$(OBJDIR)/user/forktree \
26 | 			$(OBJDIR)/user/primes \
27 | 			$(OBJDIR)/user/primespipe \
28 | 			$(OBJDIR)/user/sh \
29 | 			$(OBJDIR)/user/testfdsharing \
30 | 			$(OBJDIR)/user/testkbd \
31 | 			$(OBJDIR)/user/testpipe \
32 | 			$(OBJDIR)/user/testpteshare \
33 | 			$(OBJDIR)/user/testshell \
34 | 			$(OBJDIR)/user/hello \
35 | 
36 | FSIMGTXTFILES :=	$(FSIMGTXTFILES) \
37 | 			fs/lorem \
38 | 			fs/script \
39 | 			fs/testshell.key \
40 | 			fs/testshell.sh
41 | 
42 | 
43 | FSIMGFILES := $(FSIMGTXTFILES) $(USERAPPS)
44 | 
45 | $(OBJDIR)/fs/%.o: fs/%.c fs/fs.h inc/lib.h $(OBJDIR)/.vars.USER_CFLAGS
46 | 	@echo + cc[USER] $<
47 | 	@mkdir -p $(@D)
48 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
49 | 
50 | $(OBJDIR)/fs/fs: $(FSOFILES) $(OBJDIR)/lib/entry.o $(OBJDIR)/lib/libjos.a user/user.ld
51 | 	@echo + ld $@
52 | 	$(V)mkdir -p $(@D)
53 | 	$(V)$(LD) -o $@ $(ULDFLAGS) $(LDFLAGS) -nostdlib \
54 | 		$(OBJDIR)/lib/entry.o $(FSOFILES) \
55 | 		-L$(OBJDIR)/lib -ljos $(GCC_LIB)
56 | 	$(V)$(OBJDUMP) -S $@ >$@.asm
57 | 
58 | # How to build the file system image
59 | $(OBJDIR)/fs/fsformat: fs/fsformat.c
60 | 	@echo + mk $(OBJDIR)/fs/fsformat
61 | 	$(V)mkdir -p $(@D)
62 | 	$(V)$(NCC) $(NATIVE_CFLAGS) -o $(OBJDIR)/fs/fsformat fs/fsformat.c
63 | 
64 | $(OBJDIR)/fs/clean-fs.img: $(OBJDIR)/fs/fsformat $(FSIMGFILES)
65 | 	@echo + mk $(OBJDIR)/fs/clean-fs.img
66 | 	$(V)mkdir -p $(@D)
67 | 	$(V)$(OBJDIR)/fs/fsformat $(OBJDIR)/fs/clean-fs.img 1024 $(FSIMGFILES)
68 | 
69 | $(OBJDIR)/fs/fs.img: $(OBJDIR)/fs/clean-fs.img
70 | 	@echo + cp $(OBJDIR)/fs/clean-fs.img $@
71 | 	$(V)cp $(OBJDIR)/fs/clean-fs.img $@
72 | 
73 | all: $(OBJDIR)/fs/fs.img
74 | 
75 | #all: $(addsuffix .sym, $(USERAPPS))
76 | 
77 | #all: $(addsuffix .asm, $(USERAPPS))
78 | 
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | This is Jackie Yang's repo for Peking University OS Lab course.
 2 | ==========
 3 | The course material is adapted from 2014 MIT 6.828.
 4 | ----------
 5 | 
 6 | ### Introduction
 7 | 
 8 | This is my repo for Peking University OS Labs course. Peking University OS Lab (Honor Track) course. This course adapted contents from 2014 MIT 6.828, so this should also be helpful for other students studing any MIT 6.828 like courses.
 9 | 
10 | I post it here to as a reference for future attendents of this course. During my own experence of completing those labs, I found other's repo extremely helpful. I hope that my homework can also be helpful to others, especially in the following aspects:
11 | 
12 | * A insight of what completed code should looks like.
13 | * A correct version to be compare to when debugging an extremely concealed bug.
14 | * A reference of programming style. (I tried to program a clean and decent code throughtout every lab. Hope you can do it better.)
15 | 
16 | In the meanwhile, I disapprove the following way of using this repo:
17 | 
18 | * Source for plagiarize homework
19 | 
20 | Hope you have a good experence in completing those labs. Don't forget to star me if you find this helpful.
21 | 
22 | ### Status
23 | 
24 | All the labs (including lab 6) are finished. According to course requirement, I have also finished at least one challenge for each lab.
25 | 
26 | ### Usage
27 | 
28 | If you would like to find code for a specific lab, please look at the corresponding branch.
29 | 
30 | If you would like to find code for a specific exercise, please find the corresponding commit and look at code diff.
31 | 
32 | For example, lab 4's code can be found at [lab4](https://github.com/valkjsaaa/PKU-OS-Labs/tree/lab4). Exercise 10's code change can be found at [Exercise 10](https://github.com/valkjsaaa/PKU-OS-Labs/commit/b05c386ff814dfdc3a5f4040bbfd5f12ce59d8e8).
33 | 
34 | ### Notice
35 | 
36 | Some commits(exercises) might have bug that are fixed in latter commit(exercise). One way to deal with this problem is to look at the relevent lines in master repository. This repository can pass all the grade script in all labs, and thus less bug. You can alos look at line blame in this repo to find out if there is a bug fix later commit.
37 | 
38 | ### Pull requests are welcome
39 | 
40 | If you finished another challenge or find a bug in my code and willing to share with others, feel free to send a pull request :)


--------------------------------------------------------------------------------
/user/dumbfork.c:
--------------------------------------------------------------------------------
 1 | // Ping-pong a counter between two processes.
 2 | // Only need to start one of these -- splits into two, crudely.
 3 | 
 4 | #include <inc/string.h>
 5 | #include <inc/lib.h>
 6 | 
 7 | envid_t dumbfork(void);
 8 | 
 9 | void
10 | umain(int argc, char **argv)
11 | {
12 | 	envid_t who;
13 | 	int i;
14 | 
15 | 	// fork a child process
16 | 	who = dumbfork();
17 | 
18 | 	// print a message and yield to the other a few times
19 | 	for (i = 0; i < (who ? 10 : 20); i++) {
20 | 		cprintf("%d: I am the %s!\n", i, who ? "parent" : "child");
21 | 		sys_yield();
22 | 	}
23 | }
24 | 
25 | void
26 | duppage(envid_t dstenv, void *addr)
27 | {
28 | 	int r;
29 | 
30 | 	// This is NOT what you should do in your fork.
31 | 	if ((r = sys_page_alloc(dstenv, addr, PTE_P|PTE_U|PTE_W)) < 0)
32 | 		panic("sys_page_alloc: %e", r);
33 | 	if ((r = sys_page_map(dstenv, addr, 0, UTEMP, PTE_P|PTE_U|PTE_W)) < 0)
34 | 		panic("sys_page_map: %e", r);
35 | 	memmove(UTEMP, addr, PGSIZE);
36 | 	if ((r = sys_page_unmap(0, UTEMP)) < 0)
37 | 		panic("sys_page_unmap: %e", r);
38 | }
39 | 
40 | envid_t
41 | dumbfork(void)
42 | {
43 | 	envid_t envid;
44 | 	uint8_t *addr;
45 | 	int r;
46 | 	extern unsigned char end[];
47 | 
48 | 	// Allocate a new child environment.
49 | 	// The kernel will initialize it with a copy of our register state,
50 | 	// so that the child will appear to have called sys_exofork() too -
51 | 	// except that in the child, this "fake" call to sys_exofork()
52 | 	// will return 0 instead of the envid of the child.
53 | 	envid = sys_exofork();
54 | 	if (envid < 0)
55 | 		panic("sys_exofork: %e", envid);
56 | 	if (envid == 0) {
57 | 		// We're the child.
58 | 		// The copied value of the global variable 'thisenv'
59 | 		// is no longer valid (it refers to the parent!).
60 | 		// Fix it and return 0.
61 | 		thisenv = &envs[ENVX(sys_getenvid())];
62 | 		return 0;
63 | 	}
64 | 
65 | 	// We're the parent.
66 | 	// Eagerly copy our entire address space into the child.
67 | 	// This is NOT what you should do in your fork implementation.
68 | 	for (addr = (uint8_t*) UTEXT; addr < end; addr += PGSIZE)
69 | 		duppage(envid, addr);
70 | 
71 | 	// Also copy the stack we are currently running on.
72 | 	duppage(envid, ROUNDDOWN(&addr, PGSIZE));
73 | 
74 | 	// Start the child environment running
75 | 	if ((r = sys_env_set_status(envid, ENV_RUNNABLE)) < 0)
76 | 		panic("sys_env_set_status: %e", r);
77 | 
78 | 	return envid;
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/inc/ns.h:
--------------------------------------------------------------------------------
  1 | // See COPYRIGHT for copyright information.
  2 | 
  3 | #ifndef JOS_INC_NS_H
  4 | #define JOS_INC_NS_H
  5 | 
  6 | #include <inc/types.h>
  7 | #include <inc/mmu.h>
  8 | #include <lwip/sockets.h>
  9 | 
 10 | struct jif_pkt {
 11 | 	int jp_len;
 12 | 	char jp_data[0];
 13 | };
 14 | 
 15 | // Definitions for requests from clients to network server
 16 | enum {
 17 | 	// The following messages pass a page containing an Nsipc.
 18 | 	// Accept returns a Nsret_accept on the request page.
 19 | 	NSREQ_ACCEPT = 1,
 20 | 	NSREQ_BIND,
 21 | 	NSREQ_SHUTDOWN,
 22 | 	NSREQ_CLOSE,
 23 | 	NSREQ_CONNECT,
 24 | 	NSREQ_LISTEN,
 25 | 	// Recv returns a Nsret_recv on the request page.
 26 | 	NSREQ_RECV,
 27 | 	NSREQ_SEND,
 28 | 	NSREQ_SOCKET,
 29 | 
 30 | 	// The following two messages pass a page containing a struct jif_pkt
 31 | 	NSREQ_INPUT,
 32 | 	// NSREQ_OUTPUT, unlike all other messages, is sent *from* the
 33 | 	// network server, to the output environment
 34 | 	NSREQ_OUTPUT,
 35 | 
 36 | 	// The following message passes no page
 37 | 	NSREQ_TIMER,
 38 | };
 39 | 
 40 | union Nsipc {
 41 | 	struct Nsreq_accept {
 42 | 		int req_s;
 43 | 		socklen_t req_addrlen;
 44 | 	} accept;
 45 | 
 46 | 	struct Nsret_accept {
 47 | 		struct sockaddr ret_addr;
 48 | 		socklen_t ret_addrlen;
 49 | 	} acceptRet;
 50 | 
 51 | 	struct Nsreq_bind {
 52 | 		int req_s;
 53 | 		struct sockaddr req_name;
 54 | 		socklen_t req_namelen;
 55 | 	} bind;
 56 | 
 57 | 	struct Nsreq_shutdown {
 58 | 		int req_s;
 59 | 		int req_how;
 60 | 	} shutdown;
 61 | 
 62 | 	struct Nsreq_close {
 63 | 		int req_s;
 64 | 	} close;
 65 | 
 66 | 	struct Nsreq_connect {
 67 | 		int req_s;
 68 | 		struct sockaddr req_name;
 69 | 		socklen_t req_namelen;
 70 | 	} connect;
 71 | 
 72 | 	struct Nsreq_listen {
 73 | 		int req_s;
 74 | 		int req_backlog;
 75 | 	} listen;
 76 | 
 77 | 	struct Nsreq_recv {
 78 | 		int req_s;
 79 | 		int req_len;
 80 | 		unsigned int req_flags;
 81 | 	} recv;
 82 | 
 83 | 	struct Nsret_recv {
 84 | 		char ret_buf[0];
 85 | 	} recvRet;
 86 | 
 87 | 	struct Nsreq_send {
 88 | 		int req_s;
 89 | 		int req_size;
 90 | 		unsigned int req_flags;
 91 | 		char req_buf[0];
 92 | 	} send;
 93 | 
 94 | 	struct Nsreq_socket {
 95 | 		int req_domain;
 96 | 		int req_type;
 97 | 		int req_protocol;
 98 | 	} socket;
 99 | 
100 | 	struct jif_pkt pkt;
101 | 
102 | 	// Ensure Nsipc is one page
103 | 	char _pad[PGSIZE];
104 | };
105 | 
106 | #endif // !JOS_INC_NS_H
107 | 


--------------------------------------------------------------------------------
/net/lwip/include/ipv4/lwip/inet_chksum.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | #ifndef __LWIP_INET_CHKSUM_H__
33 | #define __LWIP_INET_CHKSUM_H__
34 | 
35 | #include "lwip/opt.h"
36 | 
37 | #include "lwip/pbuf.h"
38 | #include "lwip/ip_addr.h"
39 | 
40 | #ifdef __cplusplus
41 | extern "C" {
42 | #endif
43 | 
44 | u16_t inet_chksum(void *dataptr, u16_t len);
45 | u16_t inet_chksum_pbuf(struct pbuf *p);
46 | u16_t inet_chksum_pseudo(struct pbuf *p,
47 |        struct ip_addr *src, struct ip_addr *dest,
48 |        u8_t proto, u16_t proto_len);
49 | u16_t inet_chksum_pseudo_partial(struct pbuf *p,
50 |        struct ip_addr *src, struct ip_addr *dest,
51 |        u8_t proto, u16_t proto_len, u16_t chksum_len);
52 | 
53 | #ifdef __cplusplus
54 | }
55 | #endif
56 | 
57 | #endif /* __LWIP_INET_H__ */
58 | 
59 | 


--------------------------------------------------------------------------------
/inc/env.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_INC_ENV_H
 4 | #define JOS_INC_ENV_H
 5 | 
 6 | #include <inc/types.h>
 7 | #include <inc/trap.h>
 8 | #include <inc/memlayout.h>
 9 | 
10 | typedef int32_t envid_t;
11 | 
12 | // An environment ID 'envid_t' has three parts:
13 | //
14 | // +1+---------------21-----------------+--------10--------+
15 | // |0|          Uniqueifier             |   Environment    |
16 | // | |                                  |      Index       |
17 | // +------------------------------------+------------------+
18 | //                                       \--- ENVX(eid) --/
19 | //
20 | // The environment index ENVX(eid) equals the environment's offset in the
21 | // 'envs[]' array.  The uniqueifier distinguishes environments that were
22 | // created at different times, but share the same environment index.
23 | //
24 | // All real environments are greater than 0 (so the sign bit is zero).
25 | // envid_ts less than 0 signify errors.  The envid_t == 0 is special, and
26 | // stands for the current environment.
27 | 
28 | #define LOG2NENV		10
29 | #define NENV			(1 << LOG2NENV)
30 | #define ENVX(envid)		((envid) & (NENV - 1))
31 | 
32 | // Values of env_status in struct Env
33 | enum {
34 | 	ENV_FREE = 0,
35 | 	ENV_DYING,
36 | 	ENV_RUNNABLE,
37 | 	ENV_RUNNING,
38 | 	ENV_NOT_RUNNABLE
39 | };
40 | 
41 | // Special environment types
42 | enum EnvType {
43 | 	ENV_TYPE_USER = 0,
44 | 	ENV_TYPE_FS,		// File system server
45 | 	ENV_TYPE_NS,		// Network server
46 | };
47 | 
48 | struct Env {
49 | 	struct Trapframe env_tf;	// Saved registers
50 | 	struct Env *env_link;		// Next free Env
51 | 	envid_t env_id;			// Unique environment identifier
52 | 	envid_t env_parent_id;		// env_id of this env's parent
53 | 	enum EnvType env_type;		// Indicates special system environments
54 | 	unsigned env_status;		// Status of the environment
55 | 	uint32_t env_runs;		// Number of times environment has run
56 | 	int env_cpunum;			// The CPU that the env is running on
57 | 
58 | 	// Address space
59 | 	pde_t *env_pgdir;		// Kernel virtual address of page dir
60 | 
61 | 	// Exception handling
62 | 	void *env_pgfault_upcall;	// Page fault upcall entry point
63 | 
64 | 	// Lab 4 IPC
65 | 	bool env_ipc_recving;		// Env is blocked receiving
66 | 	void *env_ipc_dstva;		// VA at which to map received page
67 | 	uint32_t env_ipc_value;		// Data value sent to us
68 | 	envid_t env_ipc_from;		// envid of the sender
69 | 	int env_ipc_perm;		// Perm of page mapping received
70 | };
71 | 
72 | #endif // !JOS_INC_ENV_H
73 | 


--------------------------------------------------------------------------------
/user/echosrv.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | #include <lwip/sockets.h>
 3 | #include <lwip/inet.h>
 4 | 
 5 | #define PORT 7
 6 | 
 7 | #define BUFFSIZE 32
 8 | #define MAXPENDING 5    // Max connection requests
 9 | 
10 | static void
11 | die(char *m)
12 | {
13 | 	cprintf("%s\n", m);
14 | 	exit();
15 | }
16 | 
17 | void
18 | handle_client(int sock)
19 | {
20 | 	char buffer[BUFFSIZE];
21 | 	int received = -1;
22 | 	// Receive message
23 | 	if ((received = read(sock, buffer, BUFFSIZE)) < 0)
24 | 		die("Failed to receive initial bytes from client");
25 | 
26 | 	// Send bytes and check for more incoming data in loop
27 | 	while (received > 0) {
28 | 		// Send back received data
29 | 		if (write(sock, buffer, received) != received)
30 | 			die("Failed to send bytes to client");
31 | 
32 | 		// Check for more data
33 | 		if ((received = read(sock, buffer, BUFFSIZE)) < 0)
34 | 			die("Failed to receive additional bytes from client");
35 | 	}
36 | 	close(sock);
37 | }
38 | 
39 | void
40 | umain(int argc, char **argv)
41 | {
42 | 	int serversock, clientsock;
43 | 	struct sockaddr_in echoserver, echoclient;
44 | 	char buffer[BUFFSIZE];
45 | 	unsigned int echolen;
46 | 	int received = 0;
47 | 
48 | 	// Create the TCP socket
49 | 	if ((serversock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
50 | 		die("Failed to create socket");
51 | 
52 | 	cprintf("opened socket\n");
53 | 
54 | 	// Construct the server sockaddr_in structure
55 | 	memset(&echoserver, 0, sizeof(echoserver));       // Clear struct
56 | 	echoserver.sin_family = AF_INET;                  // Internet/IP
57 | 	echoserver.sin_addr.s_addr = htonl(INADDR_ANY);   // IP address
58 | 	echoserver.sin_port = htons(PORT);		  // server port
59 | 
60 | 	cprintf("trying to bind\n");
61 | 
62 | 	// Bind the server socket
63 | 	if (bind(serversock, (struct sockaddr *) &echoserver,
64 | 		 sizeof(echoserver)) < 0) {
65 | 		die("Failed to bind the server socket");
66 | 	}
67 | 
68 | 	// Listen on the server socket
69 | 	if (listen(serversock, MAXPENDING) < 0)
70 | 		die("Failed to listen on server socket");
71 | 
72 | 	cprintf("bound\n");
73 | 
74 | 	// Run until canceled
75 | 	while (1) {
76 | 		unsigned int clientlen = sizeof(echoclient);
77 | 		// Wait for client connection
78 | 		if ((clientsock =
79 | 		     accept(serversock, (struct sockaddr *) &echoclient,
80 | 			    &clientlen)) < 0) {
81 | 			die("Failed to accept client connection");
82 | 		}
83 | 		cprintf("Client connected: %s\n", inet_ntoa(echoclient.sin_addr));
84 | 		handle_client(clientsock);
85 | 	}
86 | 
87 | 	close(serversock);
88 | 
89 | }
90 | 


--------------------------------------------------------------------------------
/lib/ipc.c:
--------------------------------------------------------------------------------
 1 | // User-level IPC library routines
 2 | 
 3 | #include <inc/lib.h>
 4 | 
 5 | // Receive a value via IPC and return it.
 6 | // If 'pg' is nonnull, then any page sent by the sender will be mapped at
 7 | //	that address.
 8 | // If 'from_env_store' is nonnull, then store the IPC sender's envid in
 9 | //	*from_env_store.
10 | // If 'perm_store' is nonnull, then store the IPC sender's page permission
11 | //	in *perm_store (this is nonzero iff a page was successfully
12 | //	transferred to 'pg').
13 | // If the system call fails, then store 0 in *fromenv and *perm (if
14 | //	they're nonnull) and return the error.
15 | // Otherwise, return the value sent by the sender
16 | //
17 | // Hint:
18 | //   Use 'thisenv' to discover the value and who sent it.
19 | //   If 'pg' is null, pass sys_ipc_recv a value that it will understand
20 | //   as meaning "no page".  (Zero is not the right value, since that's
21 | //   a perfectly valid place to map a page.)
22 | int32_t
23 | ipc_recv(envid_t *from_env_store, void *pg, int *perm_store)
24 | {
25 | 	// LAB 4: Your code here.
26 | 	if (!pg)
27 | 	{
28 | 		pg = (void *)0xFFFFFFFF;
29 | 	}
30 | 	if (sys_ipc_recv(pg))
31 | 	{
32 | 		*from_env_store = 0;
33 | 		*perm_store = 0;
34 | 		return -E_INVAL;
35 | 	}
36 | 	if (perm_store)
37 | 	{
38 | 		*perm_store = thisenv->env_ipc_perm;
39 | 	}
40 | 	if (from_env_store)
41 | 	{
42 | 		*from_env_store = thisenv->env_ipc_from;
43 | 	}
44 | 	return thisenv->env_ipc_value;
45 | }
46 | 
47 | // Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'.
48 | // This function keeps trying until it succeeds.
49 | // It should panic() on any error other than -E_IPC_NOT_RECV.
50 | //
51 | // Hint:
52 | //   Use sys_yield() to be CPU-friendly.
53 | //   If 'pg' is null, pass sys_ipc_try_send a value that it will understand
54 | //   as meaning "no page".  (Zero is not the right value.)
55 | void
56 | ipc_send(envid_t to_env, uint32_t val, void *pg, int perm)
57 | {
58 | 	// LAB 4: Your code here.
59 | 	if (!pg)
60 |         pg = (void *)UTOP;
61 | 	int result;
62 | 	while((result = sys_ipc_try_send(to_env, val, pg, perm)) == -E_IPC_NOT_RECV) {
63 | 	    sys_yield();
64 | 	}
65 | 	if (result)
66 | 	{
67 | 		panic("ipc_send: %e", result);
68 | 	}
69 | }
70 | 
71 | // Find the first environment of the given type.  We'll use this to
72 | // find special environments.
73 | // Returns 0 if no such environment exists.
74 | envid_t
75 | ipc_find_env(enum EnvType type)
76 | {
77 | 	int i;
78 | 	for (i = 0; i < NENV; i++)
79 | 		if (envs[i].env_type == type)
80 | 			return envs[i].env_id;
81 | 	return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/inc/args.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_ARGS_H
 2 | #define JOS_INC_ARGS_H
 3 | 
 4 | struct Argstate;
 5 | 
 6 | // JOS command-line parsing functions.
 7 | 
 8 | // Initializes the Argstate buffer from argc and argv.
 9 | // (Note: it is safe to use a 'const char **' for argv.)
10 | void argstart(int *argc, char **argv, struct Argstate *args);
11 | 
12 | // Returns the next flag in the argument list,
13 | // or -1 if there are no more flags.
14 | //
15 | // Flags stop at a non-flag (anything that doesn't start with '-'),
16 | // at the end of the argument list, before "-", or after "--",
17 | // whichever comes first.  Any "--" argument is not returned.
18 | //
19 | // Consumes arguments from the argc/argv array passed in to argstart.
20 | // If you argstart with an argc/argv array of ["sh", "-i", "foo"],
21 | // the first call to argnext will return 'i' and change the array to
22 | // ["sh", "foo"].  Thus, when argnext returns -1, the argc/argv array
23 | // contains just the non-flag arguments.
24 | int argnext(struct Argstate *);
25 | 
26 | // Returns the next value for the current flag, or 0 if it has no value.
27 | // For example, given an argument list ["-fval1", "val2", "val3"],
28 | // a call to argnext() will return 'f', after which repeated calls to
29 | // argnextvalue will return "val1", "val2", and "val3".
30 | // Consumes arguments from the argc/argv array.
31 | char *argnextvalue(struct Argstate *);
32 | 
33 | // Returns the current flag's value, or 0 if it has no value.
34 | // Behaves like argnextvalue, except that repeated calls to argvalue will
35 | // return the same value.
36 | char *argvalue(struct Argstate *);
37 | 
38 | // Example:
39 | //
40 | //	#include <inc/lib.h>
41 | //
42 | //	void
43 | //	umain(int argc, char **argv)
44 | //	{
45 | //		int i;
46 | //		struct Argstate args;
47 | //
48 | //		argstart(&argc, argv, &args);
49 | //		while ((i = argnext(&args)) >= 0)
50 | //			switch (i) {
51 | //			case 'r':
52 | //			case 'x':
53 | //				cprintf("'-%c' flag\n", i);
54 | //				break;
55 | //			case 'f':
56 | //				cprintf("'-f %s' flag\n", argvalue(&args));
57 | //				break;
58 | //			default:
59 | //				cprintf("unknown flag\n");
60 | //			}
61 | //
62 | //		for (i = 1; i < argc; i++)
63 | //			cprintf("argument '%s'\n", argv[i]);
64 | //	}
65 | //
66 | // If this program is run with the arguments
67 | // ["-rx", "-f", "foo", "--", "-r", "duh"]
68 | // it will print out
69 | //	'-r' flag
70 | //	'-x' flag
71 | //	'-f foo' flag
72 | //	argument '-r'
73 | //	argument 'duh'
74 | 
75 | struct Argstate {
76 | 	int *argc;
77 | 	const char **argv;
78 | 	const char *curarg;
79 | 	const char *argvalue;
80 | };
81 | 
82 | #endif
83 | 


--------------------------------------------------------------------------------
/net/lwip/netif/ppp/vjbsdhdr.h:
--------------------------------------------------------------------------------
 1 | #ifndef VJBSDHDR_H
 2 | #define VJBSDHDR_H
 3 | 
 4 | #include "lwip/tcp.h"
 5 | 
 6 | /*
 7 |  * Structure of an internet header, naked of options.
 8 |  *
 9 |  * We declare ip_len and ip_off to be short, rather than u_short
10 |  * pragmatically since otherwise unsigned comparisons can result
11 |  * against negative integers quite easily, and fail in subtle ways.
12 |  */
13 | PACK_STRUCT_BEGIN
14 | struct ip
15 | {
16 | #if defined(NO_CHAR_BITFIELDS)
17 |   u_char   ip_hl_v;  /* bug in GCC for mips means the bitfield stuff will sometimes break - so we use a char for both and get round it with macro's instead... */
18 | #else
19 | #if BYTE_ORDER == LITTLE_ENDIAN
20 |   unsigned ip_hl:4,              /* header length */
21 |            ip_v :4;              /* version */
22 | #elif BYTE_ORDER == BIG_ENDIAN 
23 |   unsigned ip_v :4,              /* version */
24 |            ip_hl:4;              /* header length */
25 | #else
26 |   COMPLAIN - NO BYTE ORDER SELECTED!
27 | #endif
28 | #endif
29 |   u_char  ip_tos;                /* type of service */
30 |   u_short ip_len;                /* total length */
31 |   u_short ip_id;                 /* identification */
32 |   u_short ip_off;                /* fragment offset field */
33 | #define  IP_DF 0x4000            /* dont fragment flag */
34 | #define  IP_MF 0x2000            /* more fragments flag */
35 | #define  IP_OFFMASK 0x1fff       /* mask for fragmenting bits */
36 |   u_char  ip_ttl;                /* time to live */
37 |   u_char  ip_p;                  /* protocol */
38 |   u_short ip_sum;                /* checksum */
39 |   struct  in_addr ip_src,ip_dst; /* source and dest address */
40 | };
41 | PACK_STRUCT_END
42 | 
43 | typedef u32_t tcp_seq;
44 | 
45 | /*
46 |  * TCP header.
47 |  * Per RFC 793, September, 1981.
48 |  */
49 | PACK_STRUCT_BEGIN
50 | struct tcphdr  
51 | {
52 |   u_short  th_sport;    /* source port */
53 |   u_short  th_dport;    /* destination port */
54 |   tcp_seq  th_seq;      /* sequence number */
55 |   tcp_seq  th_ack;      /* acknowledgement number */
56 | #if defined(NO_CHAR_BITFIELDS)
57 |   u_char   th_x2_off;
58 | #else
59 | #if BYTE_ORDER == LITTLE_ENDIAN
60 |   unsigned th_x2 :4,    /* (unused) */
61 |            th_off:4;    /* data offset */
62 | #endif
63 | #if BYTE_ORDER == BIG_ENDIAN 
64 |   unsigned th_off:4,    /* data offset */
65 |            th_x2 :4;    /* (unused) */
66 | #endif
67 | #endif
68 |   u_char   th_flags;
69 |   u_short  th_win;      /* window */
70 |   u_short  th_sum;      /* checksum */
71 |   u_short  th_urp;      /* urgent pointer */
72 | };
73 | PACK_STRUCT_END
74 | 
75 | #endif /* VJBSDHDR_H */
76 | 


--------------------------------------------------------------------------------
/net/lwip/netif/loopif.c:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file
 3 |  * Loop Interface
 4 |  *
 5 |  */
 6 | 
 7 | /*
 8 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 9 |  * All rights reserved. 
10 |  * 
11 |  * Redistribution and use in source and binary forms, with or without modification, 
12 |  * are permitted provided that the following conditions are met:
13 |  *
14 |  * 1. Redistributions of source code must retain the above copyright notice,
15 |  *    this list of conditions and the following disclaimer.
16 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
17 |  *    this list of conditions and the following disclaimer in the documentation
18 |  *    and/or other materials provided with the distribution.
19 |  * 3. The name of the author may not be used to endorse or promote products
20 |  *    derived from this software without specific prior written permission. 
21 |  *
22 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
23 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
24 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
25 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
26 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
27 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
28 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
29 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
30 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
31 |  * OF SUCH DAMAGE.
32 |  *
33 |  * This file is part of the lwIP TCP/IP stack.
34 |  * 
35 |  * Author: Adam Dunkels <adam@sics.se>
36 |  *
37 |  */
38 | #include "lwip/opt.h"
39 | 
40 | #if LWIP_HAVE_LOOPIF
41 | 
42 | #include "netif/loopif.h"
43 | #include "lwip/snmp.h"
44 | 
45 | /**
46 |  * Initialize a lwip network interface structure for a loopback interface
47 |  *
48 |  * @param netif the lwip network interface structure for this loopif
49 |  * @return ERR_OK if the loopif is initialized
50 |  *         ERR_MEM if private data couldn't be allocated
51 |  */
52 | err_t
53 | loopif_init(struct netif *netif)
54 | {
55 |   /* initialize the snmp variables and counters inside the struct netif
56 |    * ifSpeed: no assumption can be made!
57 |    */
58 |   NETIF_INIT_SNMP(netif, snmp_ifType_softwareLoopback, 0);
59 | 
60 |   netif->name[0] = 'l';
61 |   netif->name[1] = 'o';
62 |   netif->output = netif_loop_output;
63 |   return ERR_OK;
64 | }
65 | 
66 | #endif /* LWIP_HAVE_LOOPIF */
67 | 


--------------------------------------------------------------------------------
/fs/ide.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Minimal PIO-based (non-interrupt-driven) IDE driver code.
  3 |  * For information about what all this IDE/ATA magic means,
  4 |  * see the materials available on the class references page.
  5 |  */
  6 | 
  7 | #include "fs.h"
  8 | #include <inc/x86.h>
  9 | 
 10 | #define IDE_BSY		0x80
 11 | #define IDE_DRDY	0x40
 12 | #define IDE_DF		0x20
 13 | #define IDE_ERR		0x01
 14 | 
 15 | static int diskno = 1;
 16 | 
 17 | static int
 18 | ide_wait_ready(bool check_error)
 19 | {
 20 | 	int r;
 21 | 
 22 | 	while (((r = inb(0x1F7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
 23 | 		/* do nothing */;
 24 | 
 25 | 	if (check_error && (r & (IDE_DF|IDE_ERR)) != 0)
 26 | 		return -1;
 27 | 	return 0;
 28 | }
 29 | 
 30 | bool
 31 | ide_probe_disk1(void)
 32 | {
 33 | 	int r, x;
 34 | 
 35 | 	// wait for Device 0 to be ready
 36 | 	ide_wait_ready(0);
 37 | 
 38 | 	// switch to Device 1
 39 | 	outb(0x1F6, 0xE0 | (1<<4));
 40 | 
 41 | 	// check for Device 1 to be ready for a while
 42 | 	for (x = 0;
 43 | 	     x < 1000 && ((r = inb(0x1F7)) & (IDE_BSY|IDE_DF|IDE_ERR)) != 0;
 44 | 	     x++)
 45 | 		/* do nothing */;
 46 | 
 47 | 	// switch back to Device 0
 48 | 	outb(0x1F6, 0xE0 | (0<<4));
 49 | 
 50 | 	cprintf("Device 1 presence: %d\n", (x < 1000));
 51 | 	return (x < 1000);
 52 | }
 53 | 
 54 | void
 55 | ide_set_disk(int d)
 56 | {
 57 | 	if (d != 0 && d != 1)
 58 | 		panic("bad disk number");
 59 | 	diskno = d;
 60 | }
 61 | 
 62 | 
 63 | int
 64 | ide_read(uint32_t secno, void *dst, size_t nsecs)
 65 | {
 66 | 	int r;
 67 | 
 68 | 	assert(nsecs <= 256);
 69 | 
 70 | 	ide_wait_ready(0);
 71 | 
 72 | 	outb(0x1F2, nsecs);
 73 | 	outb(0x1F3, secno & 0xFF);
 74 | 	outb(0x1F4, (secno >> 8) & 0xFF);
 75 | 	outb(0x1F5, (secno >> 16) & 0xFF);
 76 | 	outb(0x1F6, 0xE0 | ((diskno&1)<<4) | ((secno>>24)&0x0F));
 77 | 	outb(0x1F7, 0x20);	// CMD 0x20 means read sector
 78 | 
 79 | 	for (; nsecs > 0; nsecs--, dst += SECTSIZE) {
 80 | 		if ((r = ide_wait_ready(1)) < 0)
 81 | 			return r;
 82 | 		insl(0x1F0, dst, SECTSIZE/4);
 83 | 	}
 84 | 
 85 | 	return 0;
 86 | }
 87 | 
 88 | int
 89 | ide_write(uint32_t secno, const void *src, size_t nsecs)
 90 | {
 91 | 	int r;
 92 | 
 93 | 	assert(nsecs <= 256);
 94 | 
 95 | 	ide_wait_ready(0);
 96 | 
 97 | 	outb(0x1F2, nsecs);
 98 | 	outb(0x1F3, secno & 0xFF);
 99 | 	outb(0x1F4, (secno >> 8) & 0xFF);
100 | 	outb(0x1F5, (secno >> 16) & 0xFF);
101 | 	outb(0x1F6, 0xE0 | ((diskno&1)<<4) | ((secno>>24)&0x0F));
102 | 	outb(0x1F7, 0x30);	// CMD 0x30 means write sector
103 | 
104 | 	for (; nsecs > 0; nsecs--, src += SECTSIZE) {
105 | 		if ((r = ide_wait_ready(1)) < 0)
106 | 			return r;
107 | 		outsl(0x1F0, src, SECTSIZE/4);
108 | 	}
109 | 
110 | 	return 0;
111 | }
112 | 
113 | 


--------------------------------------------------------------------------------
/mergedep.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | # Copyright 2003 Bryan Ford
 3 | # Distributed under the GNU General Public License.
 4 | #
 5 | # Usage: mergedep <main-depfile> [<new-depfiles> ...]
 6 | #
 7 | # This script merges the contents of all <new-depfiles> specified
 8 | # on the command line into the single file <main-depfile>,
 9 | # which may or may not previously exist.
10 | # Dependencies in the <new-depfiles> will override
11 | # any existing dependencies for the same targets in <main-depfile>.
12 | # The <new-depfiles> are deleted after <main-depfile> is updated.
13 | #
14 | # The <new-depfiles> are typically generated by GCC with the -MD option,
15 | # and the <main-depfile> is typically included from a Makefile,
16 | # as shown here for GNU 'make':
17 | #
18 | #	.deps: $(wildcard *.d)
19 | #		perl mergedep $@ $^
20 | #	-include .deps
21 | #
22 | # This script properly handles multiple dependencies per <new-depfile>,
23 | # including dependencies having no target,
24 | # so it is compatible with GCC3's -MP option.
25 | #
26 | 
27 | sub readdeps {
28 | 	my $filename = shift;
29 | 
30 | 	open(DEPFILE, $filename) or return 0;
31 | 	while (<DEPFILE>) {
32 | 		if (/([^:]*):([^\\:]*)([\\]?)$/) {
33 | 			my $target = $1;
34 | 			my $deplines = $2;
35 | 			my $slash = $3;
36 | 			while ($slash ne '') {
37 | 				$_ = <DEPFILE>;
38 | 				defined($_) or die
39 | 					"Unterminated dependency in $filename";
40 | 				/(^[ \t][^\\]*)([\\]?)$/ or die
41 | 					"Bad continuation line in $filename";
42 | 				$deplines = "$deplines\\\n$1";
43 | 				$slash = $2;
44 | 			}
45 | 			#print "DEPENDENCY [[$target]]: [[$deplines]]\n";
46 | 			$dephash{$target} = $deplines;
47 | 		} elsif (/^[#]?[ \t]*$/) {
48 | 			# ignore blank lines and comments
49 | 		} else {
50 | 			die "Bad dependency line in $filename: $_";
51 | 		}
52 | 	}
53 | 	close DEPFILE;
54 | 	return 1;
55 | }
56 | 
57 | 
58 | if ($#ARGV < 0) {
59 | 	print "Usage: mergedep <main-depfile> [<new-depfiles> ..]\n";
60 | 	exit(1);
61 | }
62 | 
63 | %dephash = ();
64 | 
65 | # Read the main dependency file
66 | $maindeps = $ARGV[0];
67 | readdeps($maindeps);
68 | 
69 | # Read and merge in the new dependency files
70 | foreach $i (1 .. $#ARGV) {
71 | 	readdeps($ARGV[$i]) or die "Can't open $ARGV[$i]";
72 | }
73 | 
74 | # Update the main dependency file
75 | open(DEPFILE, ">$maindeps.tmp") or die "Can't open output file $maindeps.tmp";
76 | foreach $target (keys %dephash) {
77 | 	print DEPFILE "$target:$dephash{$target}";
78 | }
79 | close DEPFILE;
80 | rename("$maindeps.tmp", "$maindeps") or die "Can't overwrite $maindeps";
81 | 
82 | # Finally, delete the new dependency files
83 | foreach $i (1 .. $#ARGV) {
84 | 	unlink($ARGV[$i]) or print "Error removing $ARGV[$i]\n";
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/net/lwip/include/ipv6/lwip/inet.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | #ifndef __LWIP_INET_H__
33 | #define __LWIP_INET_H__
34 | 
35 | #include "lwip/opt.h"
36 | #include "lwip/pbuf.h"
37 | #include "lwip/ip_addr.h"
38 | 
39 | #ifdef __cplusplus
40 | extern "C" {
41 | #endif
42 | 
43 | u16_t inet_chksum(void *data, u16_t len);
44 | u16_t inet_chksum_pbuf(struct pbuf *p);
45 | u16_t inet_chksum_pseudo(struct pbuf *p,
46 |        struct ip_addr *src, struct ip_addr *dest,
47 |        u8_t proto, u32_t proto_len);
48 | 
49 | u32_t inet_addr(const char *cp);
50 | s8_t inet_aton(const char *cp, struct in_addr *addr);
51 | 
52 | #ifndef _MACHINE_ENDIAN_H_
53 | #ifndef _NETINET_IN_H
54 | #ifndef _LINUX_BYTEORDER_GENERIC_H
55 | u16_t htons(u16_t n);
56 | u16_t ntohs(u16_t n);
57 | u32_t htonl(u32_t n);
58 | u32_t ntohl(u32_t n);
59 | #endif /* _LINUX_BYTEORDER_GENERIC_H */
60 | #endif /* _NETINET_IN_H */
61 | #endif /* _MACHINE_ENDIAN_H_ */
62 | 
63 | #ifdef __cplusplus
64 | }
65 | #endif
66 | 
67 | #endif /* __LWIP_INET_H__ */
68 | 
69 | 


--------------------------------------------------------------------------------
/kern/sched.c:
--------------------------------------------------------------------------------
 1 | #include <inc/assert.h>
 2 | #include <inc/x86.h>
 3 | #include <kern/spinlock.h>
 4 | #include <kern/env.h>
 5 | #include <kern/pmap.h>
 6 | #include <kern/monitor.h>
 7 | 
 8 | void sched_halt(void);
 9 | 
10 | // Choose a user environment to run and run it.
11 | void
12 | sched_yield(void)
13 | {
14 | 	struct Env *idle;
15 | 
16 | 	// Implement simple round-robin scheduling.
17 | 	//
18 | 	// Search through 'envs' for an ENV_RUNNABLE environment in
19 | 	// circular fashion starting just after the env this CPU was
20 | 	// last running.  Switch to the first such environment found.
21 | 	//
22 | 	// If no envs are runnable, but the environment previously
23 | 	// running on this CPU is still ENV_RUNNING, it's okay to
24 | 	// choose that environment.
25 | 	//
26 | 	// Never choose an environment that's currently running on
27 | 	// another CPU (env_status == ENV_RUNNING). If there are
28 | 	// no runnable environments, simply drop through to the code
29 | 	// below to halt the cpu.
30 | 
31 | 	// LAB 4: Your code here.
32 | 
33 | 	int curenv_idx = curenv ? ENVX(curenv->env_id) : 0;
34 | 	int i;
35 | 	for (i = 0; i < NENV; ++i)
36 | 	{
37 | 		int env_idx = ENVX(curenv_idx + i);
38 | 		if (envs[env_idx].env_status == ENV_RUNNABLE)
39 | 		{
40 | 			env_run(&envs[env_idx]);
41 | 		}
42 | 	}
43 | 	if (curenv && curenv->env_status == ENV_RUNNING)
44 | 	{
45 | 		env_run(curenv);
46 | 	}
47 | 
48 | 	// sched_halt never returns
49 | 	sched_halt();
50 | }
51 | 
52 | // Halt this CPU when there is nothing to do. Wait until the
53 | // timer interrupt wakes it up. This function never returns.
54 | //
55 | void
56 | sched_halt(void)
57 | {
58 | 	int i;
59 | 
60 | 	// For debugging and testing purposes, if there are no runnable
61 | 	// environments in the system, then drop into the kernel monitor.
62 | 	for (i = 0; i < NENV; i++) {
63 | 		if ((envs[i].env_status == ENV_RUNNABLE ||
64 | 		     envs[i].env_status == ENV_RUNNING ||
65 | 		     envs[i].env_status == ENV_DYING))
66 | 			break;
67 | 	}
68 | 	if (i == NENV) {
69 | 		cprintf("No runnable environments in the system!\n");
70 | 		while (1)
71 | 			monitor(NULL);
72 | 	}
73 | 
74 | 	// Mark that no environment is running on this CPU
75 | 	curenv = NULL;
76 | 	lcr3(PADDR(kern_pgdir));
77 | 
78 | 	// Mark that this CPU is in the HALT state, so that when
79 | 	// timer interupts come in, we know we should re-acquire the
80 | 	// big kernel lock
81 | 	xchg(&thiscpu->cpu_status, CPU_HALTED);
82 | 
83 | 	// Release the big kernel lock as if we were "leaving" the kernel
84 | 	unlock_kernel();
85 | 
86 | 	// Reset stack pointer, enable interrupts and then halt.
87 | 	asm volatile (
88 | 		"movl $0, %%ebp\n"
89 | 		"movl %0, %%esp\n"
90 | 		"pushl $0\n"
91 | 		"pushl $0\n"
92 | 		"sti\n"
93 | 		"1:\n"
94 | 		"hlt\n"
95 | 		"jmp 1b\n"
96 | 	: : "a" (thiscpu->cpu_ts.ts_esp0));
97 | }
98 | 
99 | 


--------------------------------------------------------------------------------
/net/lwip/include/ipv4/lwip/ip_frag.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Jani Monoses <jani@iv.ro>
30 |  *
31 |  */
32 | 
33 | #ifndef __LWIP_IP_FRAG_H__
34 | #define __LWIP_IP_FRAG_H__
35 | 
36 | #include "lwip/opt.h"
37 | #include "lwip/err.h"
38 | #include "lwip/pbuf.h"
39 | #include "lwip/netif.h"
40 | #include "lwip/ip_addr.h"
41 | #include "lwip/ip.h"
42 | 
43 | #ifdef __cplusplus
44 | extern "C" {
45 | #endif
46 | 
47 | #if IP_REASSEMBLY
48 | /* The IP reassembly timer interval in milliseconds. */
49 | #define IP_TMR_INTERVAL 1000
50 | 
51 | /* IP reassembly helper struct.
52 |  * This is exported because memp needs to know the size.
53 |  */
54 | struct ip_reassdata {
55 |   struct ip_reassdata *next;
56 |   struct pbuf *p;
57 |   struct ip_hdr iphdr;
58 |   u16_t datagram_len;
59 |   u8_t flags;
60 |   u8_t timer;
61 | };
62 | 
63 | void ip_reass_init(void);
64 | void ip_reass_tmr(void);
65 | struct pbuf * ip_reass(struct pbuf *p);
66 | #endif /* IP_REASSEMBLY */
67 | 
68 | #if IP_FRAG
69 | err_t ip_frag(struct pbuf *p, struct netif *netif, struct ip_addr *dest);
70 | #endif /* IP_FRAG */
71 | 
72 | #ifdef __cplusplus
73 | }
74 | #endif
75 | 
76 | #endif /* __LWIP_IP_FRAG_H__ */
77 | 


--------------------------------------------------------------------------------
/kern/picirq.c:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #include <inc/assert.h>
 4 | #include <inc/trap.h>
 5 | 
 6 | #include <kern/picirq.h>
 7 | 
 8 | 
 9 | // Current IRQ mask.
10 | // Initial IRQ mask has interrupt 2 enabled (for slave 8259A).
11 | uint16_t irq_mask_8259A = 0xFFFF & ~(1<<IRQ_SLAVE);
12 | static bool didinit;
13 | 
14 | /* Initialize the 8259A interrupt controllers. */
15 | void
16 | pic_init(void)
17 | {
18 | 	didinit = 1;
19 | 
20 | 	// mask all interrupts
21 | 	outb(IO_PIC1+1, 0xFF);
22 | 	outb(IO_PIC2+1, 0xFF);
23 | 
24 | 	// Set up master (8259A-1)
25 | 
26 | 	// ICW1:  0001g0hi
27 | 	//    g:  0 = edge triggering, 1 = level triggering
28 | 	//    h:  0 = cascaded PICs, 1 = master only
29 | 	//    i:  0 = no ICW4, 1 = ICW4 required
30 | 	outb(IO_PIC1, 0x11);
31 | 
32 | 	// ICW2:  Vector offset
33 | 	outb(IO_PIC1+1, IRQ_OFFSET);
34 | 
35 | 	// ICW3:  bit mask of IR lines connected to slave PICs (master PIC),
36 | 	//        3-bit No of IR line at which slave connects to master(slave PIC).
37 | 	outb(IO_PIC1+1, 1<<IRQ_SLAVE);
38 | 
39 | 	// ICW4:  000nbmap
40 | 	//    n:  1 = special fully nested mode
41 | 	//    b:  1 = buffered mode
42 | 	//    m:  0 = slave PIC, 1 = master PIC
43 | 	//	  (ignored when b is 0, as the master/slave role
44 | 	//	  can be hardwired).
45 | 	//    a:  1 = Automatic EOI mode
46 | 	//    p:  0 = MCS-80/85 mode, 1 = intel x86 mode
47 | 	outb(IO_PIC1+1, 0x3);
48 | 
49 | 	// Set up slave (8259A-2)
50 | 	outb(IO_PIC2, 0x11);			// ICW1
51 | 	outb(IO_PIC2+1, IRQ_OFFSET + 8);	// ICW2
52 | 	outb(IO_PIC2+1, IRQ_SLAVE);		// ICW3
53 | 	// NB Automatic EOI mode doesn't tend to work on the slave.
54 | 	// Linux source code says it's "to be investigated".
55 | 	outb(IO_PIC2+1, 0x01);			// ICW4
56 | 
57 | 	// OCW3:  0ef01prs
58 | 	//   ef:  0x = NOP, 10 = clear specific mask, 11 = set specific mask
59 | 	//    p:  0 = no polling, 1 = polling mode
60 | 	//   rs:  0x = NOP, 10 = read IRR, 11 = read ISR
61 | 	outb(IO_PIC1, 0x68);             /* clear specific mask */
62 | 	outb(IO_PIC1, 0x0a);             /* read IRR by default */
63 | 
64 | 	outb(IO_PIC2, 0x68);               /* OCW3 */
65 | 	outb(IO_PIC2, 0x0a);               /* OCW3 */
66 | 
67 | 	if (irq_mask_8259A != 0xFFFF)
68 | 		irq_setmask_8259A(irq_mask_8259A);
69 | }
70 | 
71 | void
72 | irq_setmask_8259A(uint16_t mask)
73 | {
74 | 	int i;
75 | 	irq_mask_8259A = mask;
76 | 	if (!didinit)
77 | 		return;
78 | 	outb(IO_PIC1+1, (char)mask);
79 | 	outb(IO_PIC2+1, (char)(mask >> 8));
80 | 	cprintf("enabled interrupts:");
81 | 	for (i = 0; i < 16; i++)
82 | 		if (~mask & (1<<i))
83 | 			cprintf(" %d", i);
84 | 	cprintf("\n");
85 | }
86 | 
87 | void
88 | irq_eoi(void)
89 | {
90 | 	// OCW2: rse00xxx
91 | 	//   r: rotate
92 | 	//   s: specific
93 | 	//   e: end-of-interrupt
94 | 	// xxx: specific interrupt line
95 | 	outb(IO_PIC1, 0x20);
96 | 	outb(IO_PIC2, 0x20);
97 | }
98 | 


--------------------------------------------------------------------------------
/net/lwip/include/lwip/sio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  */
29 | 
30 | /*
31 |  * This is the interface to the platform specific serial IO module
32 |  * It needs to be implemented by those platforms which need SLIP or PPP
33 |  */
34 | 
35 | #ifndef __SIO_H__
36 | #define __SIO_H__
37 | 
38 | #include "lwip/arch.h"
39 | 
40 | #ifdef __cplusplus
41 | extern "C" {
42 | #endif
43 | 
44 | /* If you want to define sio_fd_t elsewhere or differently,
45 |    define this in your cc.h file. */
46 | #ifndef __sio_fd_t_defined
47 | typedef void * sio_fd_t;
48 | #endif
49 | 
50 | /* The following functions can be defined to something else in your cc.h file
51 |    or be implemented in your custom sio.c file. */
52 | 
53 | #ifndef sio_open
54 | sio_fd_t sio_open(u8_t);
55 | #endif
56 | 
57 | #ifndef sio_send
58 | void sio_send(u8_t, sio_fd_t);
59 | #endif
60 | 
61 | #ifndef sio_recv
62 | u8_t sio_recv(sio_fd_t);
63 | #endif
64 | 
65 | #ifndef sio_read
66 | u32_t sio_read(sio_fd_t, u8_t *, u32_t);
67 | #endif
68 | 
69 | #ifndef sio_write
70 | u32_t sio_write(sio_fd_t, u8_t *, u32_t);
71 | #endif
72 | 
73 | #ifndef sio_read_abort
74 | void sio_read_abort(sio_fd_t);
75 | #endif
76 | 
77 | #ifdef __cplusplus
78 | }
79 | #endif
80 | 
81 | #endif /* __SIO_H__ */
82 | 


--------------------------------------------------------------------------------
/kern/pmap.h:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #ifndef JOS_KERN_PMAP_H
 4 | #define JOS_KERN_PMAP_H
 5 | #ifndef JOS_KERNEL
 6 | # error "This is a JOS kernel header; user programs should not #include it"
 7 | #endif
 8 | 
 9 | #include <inc/memlayout.h>
10 | #include <inc/assert.h>
11 | #include <kern/monitor.h>
12 | 
13 | struct Env;
14 | 
15 | extern char bootstacktop[], bootstack[];
16 | 
17 | extern struct PageInfo *pages;
18 | extern size_t npages;
19 | 
20 | extern pde_t *kern_pgdir;
21 | 
22 | 
23 | /* This macro takes a kernel virtual address -- an address that points above
24 |  * KERNBASE, where the machine's maximum 256MB of physical memory is mapped --
25 |  * and returns the corresponding physical address.  It panics if you pass it a
26 |  * non-kernel virtual address.
27 |  */
28 | #define PADDR(kva) _paddr(__FILE__, __LINE__, kva)
29 | 
30 | static inline physaddr_t
31 | _paddr(const char *file, int line, void *kva)
32 | {
33 | 	if ((uint32_t)kva < KERNBASE)
34 | 		_panic(file, line, "PADDR called with invalid kva %08lx", kva);
35 | 	return (physaddr_t)kva - KERNBASE;
36 | }
37 | 
38 | /* This macro takes a physical address and returns the corresponding kernel
39 |  * virtual address.  It panics if you pass an invalid physical address. */
40 | #define KADDR(pa) _kaddr(__FILE__, __LINE__, pa)
41 | 
42 | static inline void*
43 | _kaddr(const char *file, int line, physaddr_t pa)
44 | {
45 | 	if (PGNUM(pa) >= npages)
46 | 		_panic(file, line, "KADDR called with invalid pa %08lx", pa);
47 | 	return (void *)(pa + KERNBASE);
48 | }
49 | 
50 | 
51 | enum {
52 | 	// For page_alloc, zero the returned physical page.
53 | 	ALLOC_ZERO = 1<<0,
54 | };
55 | 
56 | void	mem_init(void);
57 | 
58 | void	page_init(void);
59 | struct PageInfo *page_alloc(int alloc_flags);
60 | void	page_free(struct PageInfo *pp);
61 | int	page_insert(pde_t *pgdir, struct PageInfo *pp, void *va, int perm);
62 | void	page_remove(pde_t *pgdir, void *va);
63 | struct PageInfo *page_lookup(pde_t *pgdir, void *va, pte_t **pte_store);
64 | void	page_decref(struct PageInfo *pp);
65 | 
66 | void	tlb_invalidate(pde_t *pgdir, void *va);
67 | 
68 | void *	mmio_map_region(physaddr_t pa, size_t size);
69 | 
70 | int	user_mem_check(struct Env *env, const void *va, size_t len, int perm);
71 | void	user_mem_assert(struct Env *env, const void *va, size_t len, int perm);
72 | 
73 | static inline physaddr_t
74 | page2pa(struct PageInfo *pp)
75 | {
76 | 	return (pp - pages) << PGSHIFT;
77 | }
78 | 
79 | static inline struct PageInfo*
80 | pa2page(physaddr_t pa)
81 | {
82 | 	if (PGNUM(pa) >= npages)
83 | 		panic("pa2page called with invalid pa");
84 | 	return &pages[PGNUM(pa)];
85 | }
86 | 
87 | static inline void*
88 | page2kva(struct PageInfo *pp)
89 | {
90 | 	return KADDR(page2pa(pp));
91 | }
92 | 
93 | pte_t *pgdir_walk(pde_t *pgdir, const void *va, int create);
94 | 
95 | #endif /* !JOS_KERN_PMAP_H */
96 | 


--------------------------------------------------------------------------------
/inc/trap.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_TRAP_H
 2 | #define JOS_INC_TRAP_H
 3 | 
 4 | // Trap numbers
 5 | // These are processor defined:
 6 | #define T_DIVIDE     0		// divide error
 7 | #define T_DEBUG      1		// debug exception
 8 | #define T_NMI        2		// non-maskable interrupt
 9 | #define T_BRKPT      3		// breakpoint
10 | #define T_OFLOW      4		// overflow
11 | #define T_BOUND      5		// bounds check
12 | #define T_ILLOP      6		// illegal opcode
13 | #define T_DEVICE     7		// device not available
14 | #define T_DBLFLT     8		// double fault
15 | /* #define T_COPROC  9 */	// reserved (not generated by recent processors)
16 | #define T_TSS       10		// invalid task switch segment
17 | #define T_SEGNP     11		// segment not present
18 | #define T_STACK     12		// stack exception
19 | #define T_GPFLT     13		// general protection fault
20 | #define T_PGFLT     14		// page fault
21 | /* #define T_RES    15 */	// reserved
22 | #define T_FPERR     16		// floating point error
23 | #define T_ALIGN     17		// aligment check
24 | #define T_MCHK      18		// machine check
25 | #define T_SIMDERR   19		// SIMD floating point error
26 | 
27 | // These are arbitrarily chosen, but with care not to overlap
28 | // processor defined exceptions or interrupt vectors.
29 | #define T_SYSCALL   48		// system call
30 | #define T_DEFAULT   500		// catchall
31 | 
32 | #define IRQ_OFFSET	32	// IRQ 0 corresponds to int IRQ_OFFSET
33 | 
34 | // Hardware IRQ numbers. We receive these as (IRQ_OFFSET+IRQ_WHATEVER)
35 | #define IRQ_TIMER        0
36 | #define IRQ_KBD          1
37 | #define IRQ_SERIAL       4
38 | #define IRQ_SPURIOUS     7
39 | #define IRQ_IDE         14
40 | #define IRQ_ERROR       19
41 | 
42 | #ifndef __ASSEMBLER__
43 | 
44 | #include <inc/types.h>
45 | 
46 | struct PushRegs {
47 | 	/* registers as pushed by pusha */
48 | 	uint32_t reg_edi;
49 | 	uint32_t reg_esi;
50 | 	uint32_t reg_ebp;
51 | 	uint32_t reg_oesp;		/* Useless */
52 | 	uint32_t reg_ebx;
53 | 	uint32_t reg_edx;
54 | 	uint32_t reg_ecx;
55 | 	uint32_t reg_eax;
56 | } __attribute__((packed));
57 | 
58 | struct Trapframe {
59 | 	struct PushRegs tf_regs;
60 | 	uint16_t tf_es;
61 | 	uint16_t tf_padding1;
62 | 	uint16_t tf_ds;
63 | 	uint16_t tf_padding2;
64 | 	uint32_t tf_trapno;
65 | 	/* below here defined by x86 hardware */
66 | 	uint32_t tf_err;
67 | 	uintptr_t tf_eip;
68 | 	uint16_t tf_cs;
69 | 	uint16_t tf_padding3;
70 | 	uint32_t tf_eflags;
71 | 	/* below here only when crossing rings, such as from user to kernel */
72 | 	uintptr_t tf_esp;
73 | 	uint16_t tf_ss;
74 | 	uint16_t tf_padding4;
75 | } __attribute__((packed));
76 | 
77 | struct UTrapframe {
78 | 	/* information about the fault */
79 | 	uint32_t utf_fault_va;	/* va for T_PGFLT, 0 otherwise */
80 | 	uint32_t utf_err;
81 | 	/* trap-time return state */
82 | 	struct PushRegs utf_regs;
83 | 	uintptr_t utf_eip;
84 | 	uint32_t utf_eflags;
85 | 	/* the trap-time stack to return to */
86 | 	uintptr_t utf_esp;
87 | } __attribute__((packed));
88 | 
89 | #endif /* !__ASSEMBLER__ */
90 | 
91 | #endif /* !JOS_INC_TRAP_H */
92 | 


--------------------------------------------------------------------------------
/lib/console.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <inc/string.h>
  3 | #include <inc/lib.h>
  4 | 
  5 | void
  6 | cputchar(int ch)
  7 | {
  8 | 	char c = ch;
  9 | 
 10 | 	// Unlike standard Unix's putchar,
 11 | 	// the cputchar function _always_ outputs to the system console.
 12 | 	sys_cputs(&c, 1);
 13 | }
 14 | 
 15 | int
 16 | getchar(void)
 17 | {
 18 | 	unsigned char c;
 19 | 	int r;
 20 | 
 21 | 	// JOS does, however, support standard _input_ redirection,
 22 | 	// allowing the user to redirect script files to the shell and such.
 23 | 	// getchar() reads a character from file descriptor 0.
 24 | 	r = read(0, &c, 1);
 25 | 	if (r < 0)
 26 | 		return r;
 27 | 	if (r < 1)
 28 | 		return -E_EOF;
 29 | 	return c;
 30 | }
 31 | 
 32 | 
 33 | // "Real" console file descriptor implementation.
 34 | // The putchar/getchar functions above will still come here by default,
 35 | // but now can be redirected to files, pipes, etc., via the fd layer.
 36 | 
 37 | static ssize_t devcons_read(struct Fd*, void*, size_t);
 38 | static ssize_t devcons_write(struct Fd*, const void*, size_t);
 39 | static int devcons_close(struct Fd*);
 40 | static int devcons_stat(struct Fd*, struct Stat*);
 41 | 
 42 | struct Dev devcons =
 43 | {
 44 | 	.dev_id =	'c',
 45 | 	.dev_name =	"cons",
 46 | 	.dev_read =	devcons_read,
 47 | 	.dev_write =	devcons_write,
 48 | 	.dev_close =	devcons_close,
 49 | 	.dev_stat =	devcons_stat
 50 | };
 51 | 
 52 | int
 53 | iscons(int fdnum)
 54 | {
 55 | 	int r;
 56 | 	struct Fd *fd;
 57 | 
 58 | 	if ((r = fd_lookup(fdnum, &fd)) < 0)
 59 | 		return r;
 60 | 	return fd->fd_dev_id == devcons.dev_id;
 61 | }
 62 | 
 63 | int
 64 | opencons(void)
 65 | {
 66 | 	int r;
 67 | 	struct Fd* fd;
 68 | 
 69 | 	if ((r = fd_alloc(&fd)) < 0)
 70 | 		return r;
 71 | 	if ((r = sys_page_alloc(0, fd, PTE_P|PTE_U|PTE_W|PTE_SHARE)) < 0)
 72 | 		return r;
 73 | 	fd->fd_dev_id = devcons.dev_id;
 74 | 	fd->fd_omode = O_RDWR;
 75 | 	return fd2num(fd);
 76 | }
 77 | 
 78 | static ssize_t
 79 | devcons_read(struct Fd *fd, void *vbuf, size_t n)
 80 | {
 81 | 	int c;
 82 | 
 83 | 	if (n == 0)
 84 | 		return 0;
 85 | 
 86 | 	while ((c = sys_cgetc()) == 0)
 87 | 		sys_yield();
 88 | 	if (c < 0)
 89 | 		return c;
 90 | 	if (c == 0x04)	// ctl-d is eof
 91 | 		return 0;
 92 | 	*(char*)vbuf = c;
 93 | 	return 1;
 94 | }
 95 | 
 96 | static ssize_t
 97 | devcons_write(struct Fd *fd, const void *vbuf, size_t n)
 98 | {
 99 | 	int tot, m;
100 | 	char buf[128];
101 | 
102 | 	// mistake: have to nul-terminate arg to sys_cputs,
103 | 	// so we have to copy vbuf into buf in chunks and nul-terminate.
104 | 	for (tot = 0; tot < n; tot += m) {
105 | 		m = n - tot;
106 | 		if (m > sizeof(buf) - 1)
107 | 			m = sizeof(buf) - 1;
108 | 		memmove(buf, (char*)vbuf + tot, m);
109 | 		sys_cputs(buf, m);
110 | 	}
111 | 	return tot;
112 | }
113 | 
114 | static int
115 | devcons_close(struct Fd *fd)
116 | {
117 | 	USED(fd);
118 | 
119 | 	return 0;
120 | }
121 | 
122 | static int
123 | devcons_stat(struct Fd *fd, struct Stat *stat)
124 | {
125 | 	strcpy(stat->st_name, "<cons>");
126 | 	return 0;
127 | }
128 | 
129 | 


--------------------------------------------------------------------------------
/net/lwip/core/ipv6/ip6_addr.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 3 |  * All rights reserved. 
 4 |  * 
 5 |  * Redistribution and use in source and binary forms, with or without modification, 
 6 |  * are permitted provided that the following conditions are met:
 7 |  *
 8 |  * 1. Redistributions of source code must retain the above copyright notice,
 9 |  *    this list of conditions and the following disclaimer.
10 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
11 |  *    this list of conditions and the following disclaimer in the documentation
12 |  *    and/or other materials provided with the distribution.
13 |  * 3. The name of the author may not be used to endorse or promote products
14 |  *    derived from this software without specific prior written permission. 
15 |  *
16 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
17 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
18 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
19 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
20 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
21 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
22 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
23 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
24 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
25 |  * OF SUCH DAMAGE.
26 |  *
27 |  * This file is part of the lwIP TCP/IP stack.
28 |  * 
29 |  * Author: Adam Dunkels <adam@sics.se>
30 |  *
31 |  */
32 | 
33 | #include "lwip/opt.h"
34 | #include "lwip/ip_addr.h"
35 | #include "lwip/inet.h"
36 | 
37 | u8_t
38 | ip_addr_netcmp(struct ip_addr *addr1, struct ip_addr *addr2,
39 |                 struct ip_addr *mask)
40 | {
41 |   return((addr1->addr[0] & mask->addr[0]) == (addr2->addr[0] & mask->addr[0]) &&
42 |          (addr1->addr[1] & mask->addr[1]) == (addr2->addr[1] & mask->addr[1]) &&
43 |          (addr1->addr[2] & mask->addr[2]) == (addr2->addr[2] & mask->addr[2]) &&
44 |          (addr1->addr[3] & mask->addr[3]) == (addr2->addr[3] & mask->addr[3]));
45 |         
46 | }
47 | 
48 | u8_t
49 | ip_addr_cmp(struct ip_addr *addr1, struct ip_addr *addr2)
50 | {
51 |   return(addr1->addr[0] == addr2->addr[0] &&
52 |          addr1->addr[1] == addr2->addr[1] &&
53 |          addr1->addr[2] == addr2->addr[2] &&
54 |          addr1->addr[3] == addr2->addr[3]);
55 | }
56 | 
57 | void
58 | ip_addr_set(struct ip_addr *dest, struct ip_addr *src)
59 | {
60 |   SMEMCPY(dest, src, sizeof(struct ip_addr));
61 |   /*  dest->addr[0] = src->addr[0];
62 |   dest->addr[1] = src->addr[1];
63 |   dest->addr[2] = src->addr[2];
64 |   dest->addr[3] = src->addr[3];*/
65 | }
66 | 
67 | u8_t
68 | ip_addr_isany(struct ip_addr *addr)
69 | {
70 |   if (addr == NULL) return 1;
71 |   return((addr->addr[0] | addr->addr[1] | addr->addr[2] | addr->addr[3]) == 0);
72 | }
73 | 


--------------------------------------------------------------------------------
/lib/sockets.c:
--------------------------------------------------------------------------------
  1 | #include <inc/lib.h>
  2 | #include <lwip/sockets.h>
  3 | 
  4 | static ssize_t devsock_read(struct Fd *fd, void *buf, size_t n);
  5 | static ssize_t devsock_write(struct Fd *fd, const void *buf, size_t n);
  6 | static int devsock_close(struct Fd *fd);
  7 | static int devsock_stat(struct Fd *fd, struct Stat *stat);
  8 | 
  9 | struct Dev devsock =
 10 | {
 11 | 	.dev_id =	's',
 12 | 	.dev_name =	"sock",
 13 | 	.dev_read =	devsock_read,
 14 | 	.dev_write =	devsock_write,
 15 | 	.dev_close =	devsock_close,
 16 | 	.dev_stat =	devsock_stat,
 17 | };
 18 | 
 19 | static int
 20 | fd2sockid(int fd)
 21 | {
 22 | 	struct Fd *sfd;
 23 | 	int r;
 24 | 
 25 | 	if ((r = fd_lookup(fd, &sfd)) < 0)
 26 | 		return r;
 27 | 	if (sfd->fd_dev_id != devsock.dev_id)
 28 | 		return -E_NOT_SUPP;
 29 | 	return sfd->fd_sock.sockid;
 30 | }
 31 | 
 32 | static int
 33 | alloc_sockfd(int sockid)
 34 | {
 35 | 	struct Fd *sfd;
 36 | 	int r;
 37 | 
 38 | 	if ((r = fd_alloc(&sfd)) < 0
 39 | 	    || (r = sys_page_alloc(0, sfd, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0) {
 40 | 		nsipc_close(sockid);
 41 | 		return r;
 42 | 	}
 43 | 
 44 | 	sfd->fd_dev_id = devsock.dev_id;
 45 | 	sfd->fd_omode = O_RDWR;
 46 | 	sfd->fd_sock.sockid = sockid;
 47 | 	return fd2num(sfd);
 48 | }
 49 | 
 50 | int
 51 | accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 52 | {
 53 | 	int r;
 54 | 	if ((r = fd2sockid(s)) < 0)
 55 | 		return r;
 56 | 	if ((r = nsipc_accept(r, addr, addrlen)) < 0)
 57 | 		return r;
 58 | 	return alloc_sockfd(r);
 59 | }
 60 | 
 61 | int
 62 | bind(int s, struct sockaddr *name, socklen_t namelen)
 63 | {
 64 | 	int r;
 65 | 	if ((r = fd2sockid(s)) < 0)
 66 | 		return r;
 67 | 	return nsipc_bind(r, name, namelen);
 68 | }
 69 | 
 70 | int
 71 | shutdown(int s, int how)
 72 | {
 73 | 	int r;
 74 | 	if ((r = fd2sockid(s)) < 0)
 75 | 		return r;
 76 | 	return nsipc_shutdown(r, how);
 77 | }
 78 | 
 79 | static int
 80 | devsock_close(struct Fd *fd)
 81 | {
 82 | 	if (pageref(fd) == 1)
 83 | 		return nsipc_close(fd->fd_sock.sockid);
 84 | 	else
 85 | 		return 0;
 86 | }
 87 | 
 88 | int
 89 | connect(int s, const struct sockaddr *name, socklen_t namelen)
 90 | {
 91 | 	int r;
 92 | 	if ((r = fd2sockid(s)) < 0)
 93 | 		return r;
 94 | 	return nsipc_connect(r, name, namelen);
 95 | }
 96 | 
 97 | int
 98 | listen(int s, int backlog)
 99 | {
100 | 	int r;
101 | 	if ((r = fd2sockid(s)) < 0)
102 | 		return r;
103 | 	return nsipc_listen(r, backlog);
104 | }
105 | 
106 | static ssize_t
107 | devsock_read(struct Fd *fd, void *buf, size_t n)
108 | {
109 | 	return nsipc_recv(fd->fd_sock.sockid, buf, n, 0);
110 | }
111 | 
112 | static ssize_t
113 | devsock_write(struct Fd *fd, const void *buf, size_t n)
114 | {
115 | 	return nsipc_send(fd->fd_sock.sockid, buf, n, 0);
116 | }
117 | 
118 | static int
119 | devsock_stat(struct Fd *fd, struct Stat *stat)
120 | {
121 | 	strcpy(stat->st_name, "<sock>");
122 | 	return 0;
123 | }
124 | 
125 | int
126 | socket(int domain, int type, int protocol)
127 | {
128 | 	int r;
129 | 	if ((r = nsipc_socket(domain, type, protocol)) < 0)
130 | 		return r;
131 | 	return alloc_sockfd(r);
132 | }
133 | 


--------------------------------------------------------------------------------
/net/lwip/netif/ppp/pppdebug.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 | * pppdebug.h - System debugging utilities.
 3 | *
 4 | * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
 5 | * portions Copyright (c) 1998 Global Election Systems Inc.
 6 | * portions Copyright (c) 2001 by Cognizant Pty Ltd.
 7 | *
 8 | * The authors hereby grant permission to use, copy, modify, distribute,
 9 | * and license this software and its documentation for any purpose, provided
10 | * that existing copyright notices are retained in all copies and that this
11 | * notice and the following disclaimer are included verbatim in any 
12 | * distributions. No written agreement, license, or royalty fee is required
13 | * for any of the authorized uses.
14 | *
15 | * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
16 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
18 | * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
19 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | *
26 | ******************************************************************************
27 | * REVISION HISTORY (please don't use tabs!)
28 | *
29 | * 03-01-01 Marc Boucher <marc@mbsi.ca>
30 | *   Ported to lwIP.
31 | * 98-07-29 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
32 | *   Original.
33 | *
34 | *****************************************************************************
35 | */
36 | #ifndef PPPDEBUG_H
37 | #define PPPDEBUG_H
38 | 
39 | /************************
40 | *** PUBLIC DATA TYPES ***
41 | ************************/
42 | /* Trace levels. */
43 | typedef enum {
44 | LOG_CRITICAL = 0,
45 | LOG_ERR      = 1,
46 | LOG_NOTICE   = 2,
47 | LOG_WARNING  = 3,
48 | LOG_INFO     = 5,
49 | LOG_DETAIL   = 6,
50 | LOG_DEBUG    = 7
51 | } LogCodes;
52 | 
53 | 
54 | /***********************
55 | *** PUBLIC FUNCTIONS ***
56 | ***********************/
57 | /*
58 |  * ppp_trace - a form of printf to send tracing information to stderr
59 |  */
60 | void ppp_trace(int level, const char *format,...);
61 | 
62 | #define TRACELCP PPP_DEBUG
63 | 
64 | #if PPP_DEBUG
65 | 
66 | #define AUTHDEBUG(a) ppp_trace a
67 | #define IPCPDEBUG(a) ppp_trace a
68 | #define UPAPDEBUG(a) ppp_trace a
69 | #define LCPDEBUG(a)  ppp_trace a
70 | #define FSMDEBUG(a)  ppp_trace a
71 | #define CHAPDEBUG(a) ppp_trace a
72 | #define PPPDEBUG(a)  ppp_trace a
73 | 
74 | #else /* PPP_DEBUG */
75 | 
76 | #define AUTHDEBUG(a)
77 | #define IPCPDEBUG(a)
78 | #define UPAPDEBUG(a)
79 | #define LCPDEBUG(a)
80 | #define FSMDEBUG(a)
81 | #define CHAPDEBUG(a)
82 | #define PPPDEBUG(a)
83 | 
84 | #endif /* PPP_DEBUG */
85 | 
86 | #endif /* PPPDEBUG_H */
87 | 


--------------------------------------------------------------------------------
/kern/mpentry.S:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #include <inc/mmu.h>
 4 | #include <inc/memlayout.h>
 5 | 
 6 | ###################################################################
 7 | # entry point for APs
 8 | ###################################################################
 9 | 
10 | # Each non-boot CPU ("AP") is started up in response to a STARTUP
11 | # IPI from the boot CPU.  Section B.4.2 of the Multi-Processor
12 | # Specification says that the AP will start in real mode with CS:IP
13 | # set to XY00:0000, where XY is an 8-bit value sent with the
14 | # STARTUP. Thus this code must start at a 4096-byte boundary.
15 | #
16 | # Because this code sets DS to zero, it must run from an address in
17 | # the low 2^16 bytes of physical memory.
18 | #
19 | # boot_aps() (in init.c) copies this code to MPENTRY_PADDR (which
20 | # satisfies the above restrictions).  Then, for each AP, it stores the
21 | # address of the pre-allocated per-core stack in mpentry_kstack, sends
22 | # the STARTUP IPI, and waits for this code to acknowledge that it has
23 | # started (which happens in mp_main in init.c).
24 | #
25 | # This code is similar to boot/boot.S except that
26 | #    - it does not need to enable A20
27 | #    - it uses MPBOOTPHYS to calculate absolute addresses of its
28 | #      symbols, rather than relying on the linker to fill them
29 | 
30 | #define RELOC(x) ((x) - KERNBASE)
31 | #define MPBOOTPHYS(s) ((s) - mpentry_start + MPENTRY_PADDR)
32 | 
33 | .set PROT_MODE_CSEG, 0x8	# kernel code segment selector
34 | .set PROT_MODE_DSEG, 0x10	# kernel data segment selector
35 | 
36 | .code16           
37 | .globl mpentry_start
38 | mpentry_start:
39 | 	cli            
40 | 
41 | 	xorw    %ax, %ax
42 | 	movw    %ax, %ds
43 | 	movw    %ax, %es
44 | 	movw    %ax, %ss
45 | 
46 | 	lgdt    MPBOOTPHYS(gdtdesc)
47 | 	movl    %cr0, %eax
48 | 	orl     $CR0_PE, %eax
49 | 	movl    %eax, %cr0
50 | 
51 | 	ljmpl   $(PROT_MODE_CSEG), $(MPBOOTPHYS(start32))
52 | 
53 | .code32
54 | start32:
55 | 	movw    $(PROT_MODE_DSEG), %ax
56 | 	movw    %ax, %ds
57 | 	movw    %ax, %es
58 | 	movw    %ax, %ss
59 | 	movw    $0, %ax
60 | 	movw    %ax, %fs
61 | 	movw    %ax, %gs
62 | 
63 | 	# Set up initial page table. We cannot use kern_pgdir yet because
64 | 	# we are still running at a low EIP.
65 | 	movl    $(RELOC(entry_pgdir)), %eax
66 | 	movl    %eax, %cr3
67 | 	# Turn on paging.
68 | 	movl    %cr0, %eax
69 | 	orl     $(CR0_PE|CR0_PG|CR0_WP), %eax
70 | 	movl    %eax, %cr0
71 | 
72 | 	# Switch to the per-cpu stack allocated in boot_aps()
73 | 	movl    mpentry_kstack, %esp
74 | 	movl    $0x0, %ebp       # nuke frame pointer
75 | 
76 | 	# Call mp_main().  (Exercise for the reader: why the indirect call?)
77 | 	movl    $mp_main, %eax
78 | 	call    *%eax
79 | 
80 | 	# If mp_main returns (it shouldn't), loop.
81 | spin:
82 | 	jmp     spin
83 | 
84 | # Bootstrap GDT
85 | .p2align 2					# force 4 byte alignment
86 | gdt:
87 | 	SEG_NULL				# null seg
88 | 	SEG(STA_X|STA_R, 0x0, 0xffffffff)	# code seg
89 | 	SEG(STA_W, 0x0, 0xffffffff)		# data seg
90 | 
91 | gdtdesc:
92 | 	.word   0x17				# sizeof(gdt) - 1
93 | 	.long   MPBOOTPHYS(gdt)			# address gdt
94 | 
95 | .globl mpentry_end
96 | mpentry_end:
97 | 	nop
98 | 


--------------------------------------------------------------------------------
/net/lwip/netif/ppp/md5.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  ***********************************************************************
 3 |  ** md5.h -- header file for implementation of MD5                    **
 4 |  ** RSA Data Security, Inc. MD5 Message-Digest Algorithm              **
 5 |  ** Created: 2/17/90 RLR                                              **
 6 |  ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version               **
 7 |  ** Revised (for MD5): RLR 4/27/91                                    **
 8 |  **   -- G modified to have y&~z instead of y&z                       **
 9 |  **   -- FF, GG, HH modified to add in last register done             **
10 |  **   -- Access pattern: round 2 works mod 5, round 3 works mod 3     **
11 |  **   -- distinct additive constant for each step                     **
12 |  **   -- round 4 added, working mod 7                                 **
13 |  ***********************************************************************
14 |  */
15 | 
16 | /*
17 |  ***********************************************************************
18 |  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved.  **
19 |  **                                                                   **
20 |  ** License to copy and use this software is granted provided that    **
21 |  ** it is identified as the "RSA Data Security, Inc. MD5 Message-     **
22 |  ** Digest Algorithm" in all material mentioning or referencing this  **
23 |  ** software or this function.                                        **
24 |  **                                                                   **
25 |  ** License is also granted to make and use derivative works          **
26 |  ** provided that such works are identified as "derived from the RSA  **
27 |  ** Data Security, Inc. MD5 Message-Digest Algorithm" in all          **
28 |  ** material mentioning or referencing the derived work.              **
29 |  **                                                                   **
30 |  ** RSA Data Security, Inc. makes no representations concerning       **
31 |  ** either the merchantability of this software or the suitability    **
32 |  ** of this software for any particular purpose.  It is provided "as  **
33 |  ** is" without express or implied warranty of any kind.              **
34 |  **                                                                   **
35 |  ** These notices must be retained in any copies of any part of this  **
36 |  ** documentation and/or software.                                    **
37 |  ***********************************************************************
38 |  */
39 | 
40 | #ifndef MD5_H
41 | #define MD5_H
42 | 
43 | /* Data structure for MD5 (Message-Digest) computation */
44 | typedef struct {
45 |   u32_t i[2];               /* number of _bits_ handled mod 2^64 */
46 |   u32_t buf[4];             /* scratch buffer */
47 |   unsigned char in[64];     /* input buffer */
48 |   unsigned char digest[16]; /* actual digest after MD5Final call */
49 | } MD5_CTX;
50 | 
51 | void MD5Init  ( MD5_CTX *mdContext);
52 | void MD5Update( MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen);
53 | void MD5Final ( unsigned char hash[], MD5_CTX *mdContext);
54 | 
55 | #endif /* MD5_H */
56 | 


--------------------------------------------------------------------------------
/fs/testshell.key:
--------------------------------------------------------------------------------
 1 | # echo hello world | cat
 2 | hello world
 3 | # cat lorem
 4 | Lorem ipsum dolor sit amet, consectetur
 5 | adipisicing elit, sed do eiusmod tempor
 6 | incididunt ut labore et dolore magna
 7 | aliqua. Ut enim ad minim veniam, quis
 8 | nostrud exercitation ullamco laboris
 9 | nisi ut aliquip ex ea commodo consequat.
10 | Duis aute irure dolor in reprehenderit
11 | in voluptate velit esse cillum dolore eu
12 | fugiat nulla pariatur. Excepteur sint
13 | occaecat cupidatat non proident, sunt in
14 | culpa qui officia deserunt mollit anim
15 | id est laborum.
16 | # cat lorem |num
17 |     1 Lorem ipsum dolor sit amet, consectetur
18 |     2 adipisicing elit, sed do eiusmod tempor
19 |     3 incididunt ut labore et dolore magna
20 |     4 aliqua. Ut enim ad minim veniam, quis
21 |     5 nostrud exercitation ullamco laboris
22 |     6 nisi ut aliquip ex ea commodo consequat.
23 |     7 Duis aute irure dolor in reprehenderit
24 |     8 in voluptate velit esse cillum dolore eu
25 |     9 fugiat nulla pariatur. Excepteur sint
26 |    10 occaecat cupidatat non proident, sunt in
27 |    11 culpa qui officia deserunt mollit anim
28 |    12 id est laborum.
29 | # cat lorem |num |num |num |num |num
30 |     1     1     1     1     1 Lorem ipsum dolor sit amet, consectetur
31 |     2     2     2     2     2 adipisicing elit, sed do eiusmod tempor
32 |     3     3     3     3     3 incididunt ut labore et dolore magna
33 |     4     4     4     4     4 aliqua. Ut enim ad minim veniam, quis
34 |     5     5     5     5     5 nostrud exercitation ullamco laboris
35 |     6     6     6     6     6 nisi ut aliquip ex ea commodo consequat.
36 |     7     7     7     7     7 Duis aute irure dolor in reprehenderit
37 |     8     8     8     8     8 in voluptate velit esse cillum dolore eu
38 |     9     9     9     9     9 fugiat nulla pariatur. Excepteur sint
39 |    10    10    10    10    10 occaecat cupidatat non proident, sunt in
40 |    11    11    11    11    11 culpa qui officia deserunt mollit anim
41 |    12    12    12    12    12 id est laborum.
42 | # lsfd -1
43 | fd 0: name testshell.sh isdir 0 size 113 dev file
44 | fd 1: name <pipe> isdir 0 size 32 dev pipe
45 | fd 3: name <pipe> isdir 0 size 32 dev pipe
46 | # cat script
47 | echo This is from the script.
48 | cat lorem | num | cat
49 | echo These are my file descriptors.
50 | lsfd -1
51 | echo This is the end of the script.
52 | # sh <script
53 | This is from the script.
54 |     1 Lorem ipsum dolor sit amet, consectetur
55 |     2 adipisicing elit, sed do eiusmod tempor
56 |     3 incididunt ut labore et dolore magna
57 |     4 aliqua. Ut enim ad minim veniam, quis
58 |     5 nostrud exercitation ullamco laboris
59 |     6 nisi ut aliquip ex ea commodo consequat.
60 |     7 Duis aute irure dolor in reprehenderit
61 |     8 in voluptate velit esse cillum dolore eu
62 |     9 fugiat nulla pariatur. Excepteur sint
63 |    10 occaecat cupidatat non proident, sunt in
64 |    11 culpa qui officia deserunt mollit anim
65 |    12 id est laborum.
66 | These are my file descriptors.
67 | fd 0: name script isdir 0 size 132 dev file
68 | fd 1: name <pipe> isdir 0 size 32 dev pipe
69 | fd 3: name <pipe> isdir 0 size 32 dev pipe
70 | This is the end of the script.
71 | 


--------------------------------------------------------------------------------
/boot/boot.S:
--------------------------------------------------------------------------------
 1 | #include <inc/mmu.h>
 2 | 
 3 | # Start the CPU: switch to 32-bit protected mode, jump into C.
 4 | # The BIOS loads this code from the first sector of the hard disk into
 5 | # memory at physical address 0x7c00 and starts executing in real mode
 6 | # with %cs=0 %ip=7c00.
 7 | 
 8 | .set PROT_MODE_CSEG, 0x8         # kernel code segment selector
 9 | .set PROT_MODE_DSEG, 0x10        # kernel data segment selector
10 | .set CR0_PE_ON,      0x1         # protected mode enable flag
11 | 
12 | .globl start
13 | start:
14 |   .code16                     # Assemble for 16-bit mode
15 |   cli                         # Disable interrupts
16 |   cld                         # String operations increment
17 | 
18 |   # Set up the important data segment registers (DS, ES, SS).
19 |   xorw    %ax,%ax             # Segment number zero
20 |   movw    %ax,%ds             # -> Data Segment
21 |   movw    %ax,%es             # -> Extra Segment
22 |   movw    %ax,%ss             # -> Stack Segment
23 | 
24 |   # Enable A20:
25 |   #   For backwards compatibility with the earliest PCs, physical
26 |   #   address line 20 is tied low, so that addresses higher than
27 |   #   1MB wrap around to zero by default.  This code undoes this.
28 | seta20.1:
29 |   inb     $0x64,%al               # Wait for not busy
30 |   testb   $0x2,%al
31 |   jnz     seta20.1
32 | 
33 |   movb    $0xd1,%al               # 0xd1 -> port 0x64
34 |   outb    %al,$0x64
35 | 
36 | seta20.2:
37 |   inb     $0x64,%al               # Wait for not busy
38 |   testb   $0x2,%al
39 |   jnz     seta20.2
40 | 
41 |   movb    $0xdf,%al               # 0xdf -> port 0x60
42 |   outb    %al,$0x60
43 | 
44 |   # Switch from real to protected mode, using a bootstrap GDT
45 |   # and segment translation that makes virtual addresses 
46 |   # identical to their physical addresses, so that the 
47 |   # effective memory map does not change during the switch.
48 |   lgdt    gdtdesc
49 |   movl    %cr0, %eax
50 |   orl     $CR0_PE_ON, %eax
51 |   movl    %eax, %cr0
52 |   
53 |   # Jump to next instruction, but in 32-bit code segment.
54 |   # Switches processor into 32-bit mode.
55 |   ljmp    $PROT_MODE_CSEG, $protcseg
56 | 
57 |   .code32                     # Assemble for 32-bit mode
58 | protcseg:
59 |   # Set up the protected-mode data segment registers
60 |   movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
61 |   movw    %ax, %ds                # -> DS: Data Segment
62 |   movw    %ax, %es                # -> ES: Extra Segment
63 |   movw    %ax, %fs                # -> FS
64 |   movw    %ax, %gs                # -> GS
65 |   movw    %ax, %ss                # -> SS: Stack Segment
66 |   
67 |   # Set up the stack pointer and call into C.
68 |   movl    $start, %esp
69 |   call bootmain
70 | 
71 |   # If bootmain returns (it shouldn't), loop.
72 | spin:
73 |   jmp spin
74 | 
75 | # Bootstrap GDT
76 | .p2align 2                                # force 4 byte alignment
77 | gdt:
78 |   SEG_NULL				# null seg
79 |   SEG(STA_X|STA_R, 0x0, 0xffffffff)	# code seg
80 |   SEG(STA_W, 0x0, 0xffffffff)	        # data seg
81 | 
82 | gdtdesc:
83 |   .word   0x17                            # sizeof(gdt) - 1
84 |   .long   gdt                             # address gdt
85 | 
86 | 


--------------------------------------------------------------------------------
/net/lwip/netif/ppp/chpms.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************
 2 | * chpms.h - Network Microsoft Challenge Handshake Protocol header file.
 3 | *
 4 | * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
 5 | * portions Copyright (c) 1998 Global Election Systems Inc.
 6 | *
 7 | * The authors hereby grant permission to use, copy, modify, distribute,
 8 | * and license this software and its documentation for any purpose, provided
 9 | * that existing copyright notices are retained in all copies and that this
10 | * notice and the following disclaimer are included verbatim in any 
11 | * distributions. No written agreement, license, or royalty fee is required
12 | * for any of the authorized uses.
13 | *
14 | * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
15 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
17 | * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
18 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | *
25 | ******************************************************************************
26 | * REVISION HISTORY
27 | *
28 | * 03-01-01 Marc Boucher <marc@mbsi.ca>
29 | *   Ported to lwIP.
30 | * 98-01-30 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
31 | *   Original built from BSD network code.
32 | ******************************************************************************/
33 | /*
34 |  * chap.h - Challenge Handshake Authentication Protocol definitions.
35 |  *
36 |  * Copyright (c) 1995 Eric Rosenquist, Strata Software Limited.
37 |  * http://www.strataware.com/
38 |  *
39 |  * All rights reserved.
40 |  *
41 |  * Redistribution and use in source and binary forms are permitted
42 |  * provided that the above copyright notice and this paragraph are
43 |  * duplicated in all such forms and that any documentation,
44 |  * advertising materials, and other materials related to such
45 |  * distribution and use acknowledge that the software was developed
46 |  * by Eric Rosenquist.  The name of the author may not be used to
47 |  * endorse or promote products derived from this software without
48 |  * specific prior written permission.
49 |  *
50 |  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
51 |  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
52 |  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
53 |  *
54 |  * $Id: chpms.h,v 1.5 2007/12/19 20:47:23 fbernon Exp $
55 |  */
56 | 
57 | #ifndef CHPMS_H
58 | #define CHPMS_H
59 | 
60 | #define MAX_NT_PASSWORD 256 /* Maximum number of (Unicode) chars in an NT password */
61 | 
62 | void ChapMS (chap_state *, char *, int, char *, int);
63 | 
64 | #endif /* CHPMS_H */
65 | 


--------------------------------------------------------------------------------
/net/lwip/api/err.c:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file
 3 |  * Error Management module
 4 |  *
 5 |  */
 6 | 
 7 | /*
 8 |  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 9 |  * All rights reserved. 
10 |  * 
11 |  * Redistribution and use in source and binary forms, with or without modification, 
12 |  * are permitted provided that the following conditions are met:
13 |  *
14 |  * 1. Redistributions of source code must retain the above copyright notice,
15 |  *    this list of conditions and the following disclaimer.
16 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
17 |  *    this list of conditions and the following disclaimer in the documentation
18 |  *    and/or other materials provided with the distribution.
19 |  * 3. The name of the author may not be used to endorse or promote products
20 |  *    derived from this software without specific prior written permission. 
21 |  *
22 |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
23 |  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
24 |  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
25 |  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
26 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
27 |  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
28 |  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
29 |  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
30 |  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
31 |  * OF SUCH DAMAGE.
32 |  *
33 |  * This file is part of the lwIP TCP/IP stack.
34 |  * 
35 |  * Author: Adam Dunkels <adam@sics.se>
36 |  *
37 |  */
38 | 
39 | #include "lwip/err.h"
40 | 
41 | #ifdef LWIP_DEBUG
42 | 
43 | static const char *err_strerr[] = {
44 |            "Ok.",                    /* ERR_OK          0  */
45 |            "Out of memory error.",   /* ERR_MEM        -1  */
46 |            "Buffer error.",          /* ERR_BUF        -2  */
47 |            "Timeout.",               /* ERR_TIMEOUT    -3 */
48 |            "Routing problem.",       /* ERR_RTE        -4  */
49 |            "Connection aborted.",    /* ERR_ABRT       -5  */
50 |            "Connection reset.",      /* ERR_RST        -6  */
51 |            "Connection closed.",     /* ERR_CLSD       -7  */
52 |            "Not connected.",         /* ERR_CONN       -8  */
53 |            "Illegal value.",         /* ERR_VAL        -9  */
54 |            "Illegal argument.",      /* ERR_ARG        -10 */
55 |            "Address in use.",        /* ERR_USE        -11 */
56 |            "Low-level netif error.", /* ERR_IF         -12 */
57 |            "Already connected.",     /* ERR_ISCONN     -13 */
58 |            "Operation in progress."  /* ERR_INPROGRESS -14 */
59 | };
60 | 
61 | /**
62 |  * Convert an lwip internal error to a string representation.
63 |  *
64 |  * @param err an lwip internal err_t
65 |  * @return a string representation for err
66 |  */
67 | const char *
68 | lwip_strerr(err_t err)
69 | {
70 |   return err_strerr[-err];
71 | 
72 | }
73 | 
74 | #endif /* LWIP_DEBUG */
75 | 


--------------------------------------------------------------------------------
/kern/entry.S:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #include <inc/mmu.h>
 4 | #include <inc/memlayout.h>
 5 | #include <inc/trap.h>
 6 | 
 7 | # Shift Right Logical 
 8 | #define SRL(val, shamt)		(((val) >> (shamt)) & ~(-1 << (32 - (shamt))))
 9 | 
10 | 
11 | ###################################################################
12 | # The kernel (this code) is linked at address ~(KERNBASE + 1 Meg), 
13 | # but the bootloader loads it at address ~1 Meg.
14 | #	
15 | # RELOC(x) maps a symbol x from its link address to its actual
16 | # location in physical memory (its load address).	 
17 | ###################################################################
18 | 
19 | #define	RELOC(x) ((x) - KERNBASE)
20 | 
21 | #define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
22 | #define MULTIBOOT_HEADER_FLAGS (0)
23 | #define CHECKSUM (-(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS))
24 | 
25 | ###################################################################
26 | # entry point
27 | ###################################################################
28 | 
29 | .text
30 | 
31 | # The Multiboot header
32 | .align 4
33 | .long MULTIBOOT_HEADER_MAGIC
34 | .long MULTIBOOT_HEADER_FLAGS
35 | .long CHECKSUM
36 | 
37 | # '_start' specifies the ELF entry point.  Since we haven't set up
38 | # virtual memory when the bootloader enters this code, we need the
39 | # bootloader to jump to the *physical* address of the entry point.
40 | .globl		_start
41 | _start = RELOC(entry)
42 | 
43 | .globl entry
44 | entry:
45 | 	movw	$0x1234,0x472			# warm boot
46 | 
47 | 	# We haven't set up virtual memory yet, so we're running from
48 | 	# the physical address the boot loader loaded the kernel at: 1MB
49 | 	# (plus a few bytes).  However, the C code is linked to run at
50 | 	# KERNBASE+1MB.  Hence, we set up a trivial page directory that
51 | 	# translates virtual addresses [KERNBASE, KERNBASE+4MB) to
52 | 	# physical addresses [0, 4MB).  This 4MB region will be
53 | 	# sufficient until we set up our real page table in mem_init
54 | 	# in lab 2.
55 | 
56 | 	# Load the physical address of entry_pgdir into cr3.  entry_pgdir
57 | 	# is defined in entrypgdir.c.
58 | 	movl	$(RELOC(entry_pgdir)), %eax
59 | 	movl	%eax, %cr3
60 | 	# Turn on paging.
61 | 	movl	%cr0, %eax
62 | 	orl	$(CR0_PE|CR0_PG|CR0_WP), %eax
63 | 	movl	%eax, %cr0
64 | 
65 | 	# Now paging is enabled, but we're still running at a low EIP
66 | 	# (why is this okay?).  Jump up above KERNBASE before entering
67 | 	# C code.
68 | 	mov	$relocated, %eax
69 | 	jmp	*%eax
70 | relocated:
71 | 
72 | 	# Clear the frame pointer register (EBP)
73 | 	# so that once we get into debugging C code,
74 | 	# stack backtraces will be terminated properly.
75 | 	movl	$0x0,%ebp			# nuke frame pointer
76 | 
77 | 	# Set the stack pointer
78 | 	movl	$(bootstacktop),%esp
79 | 
80 | 	# now to C code
81 | 	call	i386_init
82 | 
83 | 	# Should never get here, but in case we do, just spin.
84 | spin:	jmp	spin
85 | 
86 | 
87 | .data
88 | ###################################################################
89 | # boot stack
90 | ###################################################################
91 | 	.p2align	PGSHIFT		# force page alignment
92 | 	.globl		bootstack
93 | bootstack:
94 | 	.space		KSTKSIZE
95 | 	.globl		bootstacktop   
96 | bootstacktop:
97 | 
98 | 


--------------------------------------------------------------------------------
/kern/printf.c:
--------------------------------------------------------------------------------
  1 | // Simple implementation of cprintf console output for the kernel,
  2 | // based on printfmt() and the kernel console's cputchar().
  3 | 
  4 | #include <inc/types.h>
  5 | #include <inc/stdio.h>
  6 | #include <inc/stdarg.h>
  7 | #include <kern/console.h>
  8 | 
  9 | char ansi_fmt_buffer[100];
 10 | uint16_t ansi_fmt_ptr = 0;
 11 | 
 12 | uint16_t foreground_color = 7;
 13 | uint16_t background_color = 0;
 14 | 
 15 | /** map ansi color index to cga palette index */
 16 | static const uint8_t ansi_to_cga[16] = {
 17 | 	0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15
 18 | };
 19 | 
 20 | ansi_state state = NORMAL;
 21 | 
 22 | bool 
 23 | is_char(int ch)
 24 | {
 25 | 	return (ch>=0x41&&ch<=0x5A)||(ch>=0x61&&ch<=0x7A);
 26 | }
 27 | 
 28 | bool 
 29 | is_digit(int ch)
 30 | {
 31 | 	return (ch>=0x30&&ch<=0x39);
 32 | }
 33 | 
 34 | int 
 35 | parse_int(char* start, char* end){
 36 | 	int result = 0;
 37 | 	for (start; start < end; ++start)
 38 | 	{
 39 | 		if(is_digit(*start)) {
 40 | 			result *= 10;
 41 | 			result += *start-0x30;
 42 | 		}
 43 | 	}
 44 | 	return result;
 45 | }
 46 | 
 47 | void
 48 | apply_ansi_color(int color_idx)
 49 | {
 50 | 	if(color_idx>=30 && color_idx<40) {
 51 | 		foreground_color = ansi_to_cga[color_idx-30];
 52 | 	}
 53 | 	else if(color_idx>=40 && color_idx<50){
 54 | 		background_color = ansi_to_cga[color_idx-40];
 55 | 	}
 56 | 	return;
 57 | }
 58 | 
 59 | void
 60 | apply_ansi_control(char * control_string, char command)
 61 | {
 62 | 	char* back = control_string;
 63 | 	if(command == 'm') {
 64 | 		for (back; *back; ++back)
 65 | 		{
 66 | 			if(*back == ';'){
 67 | 				apply_ansi_color(parse_int(control_string, back));
 68 | 				control_string = back+1;
 69 | 			}
 70 | 		}
 71 | 		if(control_string<back) {
 72 | 			apply_ansi_color(parse_int(control_string, back));
 73 | 		}
 74 | 	}
 75 | 	return;
 76 | }
 77 | 
 78 | static void
 79 | putch(int ch, int *cnt)
 80 | {
 81 | 	*cnt++;
 82 | 	cons_ctrl_putc(ch);
 83 | 	switch(state){
 84 | 		case NORMAL:
 85 | 		{
 86 | 			if( ch == '\x1B' ) {
 87 | 				state = START;
 88 | 			}
 89 | 			else {
 90 | 				cons_disp_putc(ch);
 91 | 			}
 92 | 			break;
 93 | 		}
 94 | 		case START:{
 95 | 			if(ch == '['){
 96 | 				state = ESCAPING;
 97 | 			}else{
 98 | 				cons_disp_putc('\x1B');
 99 | 				cons_disp_putc(ch);
100 | 			}
101 | 		}
102 | 		case ESCAPING:
103 | 		{
104 | 			if(is_char(ch)) {
105 | 				ansi_fmt_buffer[ansi_fmt_ptr] = '\0';
106 | 				apply_ansi_control(ansi_fmt_buffer, ch);
107 | 				ansi_fmt_ptr = 0;
108 | 				state = NORMAL;
109 | 			}else if(ansi_fmt_ptr == 99){
110 | 				state = OVERFLOW;
111 | 			}else{
112 | 				ansi_fmt_buffer[ansi_fmt_ptr] = ch;
113 | 				ansi_fmt_ptr++;
114 | 				state = ESCAPING;
115 | 			}
116 | 		}
117 | 		case OVERFLOW:
118 | 		{
119 | 			if(is_char(ch)) {
120 | 				state = NORMAL;
121 | 			}
122 | 		}
123 | 	}
124 | }
125 | 
126 | int
127 | vcprintf(const char *fmt, va_list ap)
128 | {
129 | 	int cnt = 0;
130 | 
131 | 	vprintfmt((void*)putch, &cnt, fmt, ap);
132 | 	return cnt;
133 | }
134 | 
135 | int
136 | cprintf(const char *fmt, ...)
137 | {
138 | 	va_list ap;
139 | 	int cnt;
140 | 
141 | 	va_start(ap, fmt);
142 | 	cnt = vcprintf(fmt, ap);
143 | 	va_end(ap);
144 | 
145 | 	return cnt;
146 | }
147 | 
148 | 


--------------------------------------------------------------------------------