├── .bochsrc.tmpl
├── .dir-locals.el
├── .gdbinit.tmpl
├── .gitignore
├── CODING
├── GNUmakefile
├── bochs_readme
├── boot
    ├── Makefrag
    ├── boot.S
    ├── main.c
    └── sign.pl
├── challenge1.txt
├── challenge2.txt
├── challenge3.txt
├── challenge4.txt
├── challenge5.txt
├── challenge6.txt
├── challenge7.txt
├── conf
    ├── env.mk
    └── lab.mk
├── fs
    ├── Makefrag
    ├── bc.c
    ├── fs.c
    ├── fs.h
    ├── fsformat.c
    ├── ide.c
    ├── index.html
    ├── lorem
    ├── motd
    ├── motd_guest
    ├── newmotd
    ├── robig
    ├── script
    ├── serv.c
    ├── test.c
    ├── testshell.key
    ├── testshell.sh
    └── vmx_host.c
├── grade-lab1
├── grade-lab2
├── grade-lab3
├── grade-lab4
├── grade-lab5
├── grade-lab6
├── grade-lab8
├── gradelib.py
├── guest_boot
    ├── Makefrag
    ├── boot.S
    └── sign.pl
├── handin-prep
├── inc
    ├── COPYRIGHT
    ├── args.h
    ├── assert.h
    ├── elf.h
    ├── env.h
    ├── ept.h
    ├── error.h
    ├── fd.h
    ├── fs.h
    ├── kbdreg.h
    ├── lib.h
    ├── malloc.h
    ├── memlayout.h
    ├── mmu.h
    ├── ns.h
    ├── queue.h
    ├── stab.h
    ├── stdarg.h
    ├── stdio.h
    ├── string.h
    ├── syscall.h
    ├── trap.h
    ├── types.h
    ├── vmx.h
    └── x86.h
├── kern
    ├── COPYRIGHT
    ├── Makefrag
    ├── bootstrap.S
    ├── console.c
    ├── console.h
    ├── cpu.h
    ├── dwarf.h
    ├── dwarf_api.h
    ├── dwarf_define.h
    ├── dwarf_elf.h
    ├── dwarf_error.h
    ├── dwarf_lineno.h
    ├── e1000.c
    ├── e1000.h
    ├── elf_rw.c
    ├── entry.S
    ├── env.c
    ├── env.h
    ├── guest_kernel.ld
    ├── init.c
    ├── kclock.c
    ├── kclock.h
    ├── kdebug.c
    ├── kdebug.h
    ├── kernel.ld
    ├── lapic.c
    ├── libdwarf_frame.c
    ├── libdwarf_lineno.c
    ├── libdwarf_rw.c
    ├── macro.h
    ├── monitor.c
    ├── monitor.h
    ├── mpconfig.c
    ├── mpentry.S
    ├── multiboot.h
    ├── pci.c
    ├── pci.h
    ├── pcireg.h
    ├── picirq.c
    ├── picirq.h
    ├── pmap.c
    ├── pmap.h
    ├── printf.c
    ├── sched.c
    ├── sched.h
    ├── spinlock.c
    ├── spinlock.h
    ├── syscall.c
    ├── syscall.h
    ├── time.c
    ├── time.h
    ├── trap.c
    ├── trap.h
    └── trapentry.S
├── lib
    ├── Makefrag
    ├── args.c
    ├── console.c
    ├── entry.S
    ├── exit.c
    ├── fd.c
    ├── file.c
    ├── fork.c
    ├── fprintf.c
    ├── ipc.c
    ├── libmain.c
    ├── malloc.c
    ├── nsipc.c
    ├── pageref.c
    ├── panic.c
    ├── pfentry.S
    ├── pgfault.c
    ├── pipe.c
    ├── printf.c
    ├── printfmt.c
    ├── readline.c
    ├── sockets.c
    ├── spawn.c
    ├── string.c
    ├── syscall.c
    └── wait.c
├── mergedep.pl
├── net
    ├── Makefrag
    ├── input.c
    ├── lwip
    │   ├── FILES
    │   ├── Makefrag
    │   ├── api
    │   │   ├── api_lib.c
    │   │   ├── api_msg.c
    │   │   ├── err.c
    │   │   ├── netbuf.c
    │   │   ├── netdb.c
    │   │   ├── netifapi.c
    │   │   ├── sockets.c
    │   │   └── tcpip.c
    │   ├── core
    │   │   ├── dhcp.c
    │   │   ├── dns.c
    │   │   ├── init.c
    │   │   ├── ipv4
    │   │   │   ├── autoip.c
    │   │   │   ├── icmp.c
    │   │   │   ├── igmp.c
    │   │   │   ├── inet.c
    │   │   │   ├── inet_chksum.c
    │   │   │   ├── ip.c
    │   │   │   ├── ip_addr.c
    │   │   │   └── ip_frag.c
    │   │   ├── ipv6
    │   │   │   ├── README
    │   │   │   ├── icmp6.c
    │   │   │   ├── inet6.c
    │   │   │   ├── ip6.c
    │   │   │   └── ip6_addr.c
    │   │   ├── mem.c
    │   │   ├── memp.c
    │   │   ├── netif.c
    │   │   ├── pbuf.c
    │   │   ├── raw.c
    │   │   ├── snmp
    │   │   │   ├── asn1_dec.c
    │   │   │   ├── asn1_enc.c
    │   │   │   ├── mib2.c
    │   │   │   ├── mib_structs.c
    │   │   │   ├── msg_in.c
    │   │   │   └── msg_out.c
    │   │   ├── stats.c
    │   │   ├── sys.c
    │   │   ├── tcp.c
    │   │   ├── tcp_in.c
    │   │   ├── tcp_out.c
    │   │   └── udp.c
    │   ├── include
    │   │   ├── ipv4
    │   │   │   └── lwip
    │   │   │   │   ├── autoip.h
    │   │   │   │   ├── icmp.h
    │   │   │   │   ├── igmp.h
    │   │   │   │   ├── inet.h
    │   │   │   │   ├── inet_chksum.h
    │   │   │   │   ├── ip.h
    │   │   │   │   ├── ip_addr.h
    │   │   │   │   └── ip_frag.h
    │   │   ├── ipv6
    │   │   │   └── lwip
    │   │   │   │   ├── icmp.h
    │   │   │   │   ├── inet.h
    │   │   │   │   ├── ip.h
    │   │   │   │   └── ip_addr.h
    │   │   ├── lwip
    │   │   │   ├── api.h
    │   │   │   ├── api_msg.h
    │   │   │   ├── arch.h
    │   │   │   ├── debug.h
    │   │   │   ├── def.h
    │   │   │   ├── dhcp.h
    │   │   │   ├── dns.h
    │   │   │   ├── err.h
    │   │   │   ├── init.h
    │   │   │   ├── mem.h
    │   │   │   ├── memp.h
    │   │   │   ├── memp_std.h
    │   │   │   ├── netbuf.h
    │   │   │   ├── netdb.h
    │   │   │   ├── netif.h
    │   │   │   ├── netifapi.h
    │   │   │   ├── opt.h
    │   │   │   ├── pbuf.h
    │   │   │   ├── raw.h
    │   │   │   ├── sio.h
    │   │   │   ├── snmp.h
    │   │   │   ├── snmp_asn1.h
    │   │   │   ├── snmp_msg.h
    │   │   │   ├── snmp_structs.h
    │   │   │   ├── sockets.h
    │   │   │   ├── stats.h
    │   │   │   ├── sys.h
    │   │   │   ├── tcp.h
    │   │   │   ├── tcpip.h
    │   │   │   └── udp.h
    │   │   └── netif
    │   │   │   ├── etharp.h
    │   │   │   ├── loopif.h
    │   │   │   ├── ppp_oe.h
    │   │   │   └── slipif.h
    │   ├── jos
    │   │   ├── arch
    │   │   │   ├── cc.h
    │   │   │   ├── i386
    │   │   │   │   └── setjmp.h
    │   │   │   ├── longjmp.S
    │   │   │   ├── perf.h
    │   │   │   ├── perror.c
    │   │   │   ├── perror.h
    │   │   │   ├── queue.h
    │   │   │   ├── setjmp.h
    │   │   │   ├── sys_arch.c
    │   │   │   ├── sys_arch.h
    │   │   │   ├── thread.c
    │   │   │   ├── thread.h
    │   │   │   └── threadq.h
    │   │   ├── jif
    │   │   │   ├── jif.c
    │   │   │   └── jif.h
    │   │   └── lwipopts.h
    │   └── netif
    │   │   ├── FILES
    │   │   ├── etharp.c
    │   │   ├── ethernetif.c
    │   │   ├── loopif.c
    │   │   ├── ppp
    │   │       ├── auth.c
    │   │       ├── auth.h
    │   │       ├── chap.c
    │   │       ├── chap.h
    │   │       ├── chpms.c
    │   │       ├── chpms.h
    │   │       ├── fsm.c
    │   │       ├── fsm.h
    │   │       ├── ipcp.c
    │   │       ├── ipcp.h
    │   │       ├── lcp.c
    │   │       ├── lcp.h
    │   │       ├── magic.c
    │   │       ├── magic.h
    │   │       ├── md5.c
    │   │       ├── md5.h
    │   │       ├── pap.c
    │   │       ├── pap.h
    │   │       ├── ppp.c
    │   │       ├── ppp.h
    │   │       ├── ppp_oe.c
    │   │       ├── pppdebug.h
    │   │       ├── randm.c
    │   │       ├── randm.h
    │   │       ├── vj.c
    │   │       ├── vj.h
    │   │       └── vjbsdhdr.h
    │   │   └── slipif.c
    ├── ns.h
    ├── output.c
    ├── serv.c
    ├── testinput.c
    ├── testoutput.c
    └── timer.c
├── slack.txt
├── user
    ├── Makefrag
    ├── badsegment.c
    ├── breakpoint.c
    ├── buggyhello.c
    ├── buggyhello2.c
    ├── cat.c
    ├── divzero.c
    ├── dumbfork.c
    ├── echo.c
    ├── echosrv.c
    ├── echotest.c
    ├── evilhello.c
    ├── fairness.c
    ├── faultalloc.c
    ├── faultallocbad.c
    ├── faultbadhandler.c
    ├── faultdie.c
    ├── faultevilhandler.c
    ├── faultnostack.c
    ├── faultread.c
    ├── faultreadkernel.c
    ├── faultregs.c
    ├── faultwrite.c
    ├── faultwritekernel.c
    ├── forktree.c
    ├── hello.c
    ├── httpd.c
    ├── icode.c
    ├── idle.c
    ├── init.c
    ├── initsh.c
    ├── ls.c
    ├── lsfd.c
    ├── num.c
    ├── pingpong.c
    ├── pingpongs.c
    ├── primes.c
    ├── primespipe.c
    ├── sendpage.c
    ├── sh.c
    ├── softint.c
    ├── spawnhello.c
    ├── spawninit.c
    ├── spin.c
    ├── stresssched.c
    ├── testbss.c
    ├── testfdsharing.c
    ├── testfile.c
    ├── testfilero.c
    ├── testkbd.c
    ├── testmalloc.c
    ├── testpipe.c
    ├── testpiperace.c
    ├── testpiperace2.c
    ├── testptelibrary.c
    ├── testpteshare.c
    ├── testshell.c
    ├── testtime.c
    ├── user.ld
    ├── vmm.c
    ├── vmmanager.c
    ├── writemotd.c
    └── yield.c
└── vmm
    ├── .gitignore
    ├── Makefrag
    ├── ept.c
    ├── ept.h
    ├── jos_boot.S
    ├── vmexits.c
    ├── vmexits.h
    ├── vmx.c
    ├── vmx.h
    └── vmx_asm.h


/.bochsrc.tmpl:
--------------------------------------------------------------------------------
 1 | # configuration file generated by Bochs
 2 | plugin_ctrl: unmapped=1, biosdev=1, speaker=1, extfpuirq=1, parallel=1, serial=1
 3 | config_interface: textconfig
 4 | display_library: x
 5 | memory: host=128, guest=128
 6 | romimage: file="/usr/share/bochs/BIOS-bochs-latest"
 7 | vgaromimage: file="/usr/share/bochs/VGABIOS-lgpl-latest"
 8 | boot: floppy, disk
 9 | floppy_bootsig_check: disabled=0
10 | # no floppya
11 | # no floppyb
12 | ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
13 | ata0-master: type=disk, path="path_to_kernel_img", mode=flat, cylinders=1, heads=1, spt=32, model="Generic 1234", biosdetect=auto, translation=auto
14 | ata0-slave: type=disk, path="path_to_disk_img", mode=flat, cylinders=1, heads=1, spt=32, model="Generic 1234", biosdetect=auto, translation=auto
15 | ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
16 | ata1-master: type=none
17 | ata1-slave: type=none
18 | ata2: enabled=0
19 | ata3: enabled=0
20 | pci: enabled=1, chipset=i440fx
21 | vga: extension=vbe, update_freq=5
22 | cpu: count=1, ips=4000000, model=bx_generic, reset_on_triple_fault=0, cpuid_limit_winnt=0, ignore_bad_msrs=1, mwait_is_nop=0
23 | cpuid: level=6, stepping=3, model=3, family=6, vendor_string="AuthenticAMD", brand_string="AMD Athlon(tm) processor"
24 | cpuid: mmx=1, apic=xapic, simd=sse2, sse4a=0, misaligned_sse=0, sep=1, movbe=0, adx=0
25 | cpuid: aes=0, xsave=0, xsaveopt=0, x86_64=1, 1g_pages=0, pcid=0, fsgsbase=0, smep=0
26 | cpuid: smap=0, mwait=1, vmx=2
27 | #, svm=0
28 | print_timestamps: enabled=0
29 | # no gdb stub
30 | port_e9_hack: enabled=0
31 | private_colormap: enabled=0
32 | clock: sync=none, time0=local, rtc_sync=0
33 | # no cmosimage
34 | # no loader
35 | log: bochs.log
36 | logprefix: %t%e%d
37 | debug: action=ignore
38 | info: action=report
39 | error: action=report
40 | panic: action=ask
41 | keyboard: type=mf, serial_delay=250, paste_delay=100000, user_shortcut=none
42 | mouse: type=ps2, enabled=0, toggle=ctrl+mbutton
43 | parport1: enabled=1, file=bochs.out
44 | parport2: enabled=0
45 | com1: enabled=1, mode=null, dev=none
46 | com2: enabled=0
47 | com3: enabled=0
48 | com4: enabled=0
49 | 


--------------------------------------------------------------------------------
/.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 | 


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


--------------------------------------------------------------------------------
/.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 | /conf/lab.mk
18 | *~
19 | vivek.map
20 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/bochs_readme:
--------------------------------------------------------------------------------
 1 | To successfully debug the lab8, we have to rebuild the bochs with gdb stubs support. We can download bochs source code from http://sourceforge.net/projects/bochs/files/bochs/2.6.7/
 2 | 
 3 | After downloading and decompressing the bochs-2.6.7.tar.gz, we have to do some configuration to enable needed features of bochs with the following command:
 4 | 
 5 | ./configure --enable-x86-64 --enable-vmx=2 --enable-gdb-stub --enable-pci --enable-e1000 --enable-fpu --with-all-libs --prefix=/usr
 6 | 
 7 | Then we can make the bochs. Errors in the make process are mainly caused by missing some supporting libraries in your system. Installing build-essentials, g++, libgtk2.0-dev, libxrandr-dev, and xorg-dev may help.
 8 | 
 9 | When make finished, you can install following command to install the bochs: sudo make install
10 | 


--------------------------------------------------------------------------------
/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 | OBJDIRS += boot
 8 | 
 9 | BOOT_OBJS := $(OBJDIR)/boot/boot.o $(OBJDIR)/boot/main.o
10 | 
11 | $(OBJDIR)/boot/%.o: boot/%.c
12 | 	@echo + cc -Os $<
13 | 	@mkdir -p $(@D)
14 | 	$(V)$(CC) -nostdinc $(BOOT_CFLAGS) -Os -c -o $@ $<
15 | 
16 | $(OBJDIR)/boot/%.o: boot/%.S
17 | 	@echo + as $<
18 | 	@mkdir -p $(@D)
19 | 	$(V)$(CC) -nostdinc $(BOOT_CFLAGS) -c -o $@ $<
20 | 
21 | $(OBJDIR)/boot/boot: $(BOOT_OBJS)
22 | 	@echo + ld $(OBJDIR)/boot/boot
23 | 	$(V)$(LD) $(BOOT_LDFLAGS) -N -e start -Ttext 0x7c00 -o $@.out $^
24 | 	$(V)$(OBJDUMP) -S $@.out >$@.asm
25 | 	$(V)$(OBJCOPY) -S -O binary -j .text $@.out $@
26 | 	$(V)perl boot/sign.pl $(OBJDIR)/boot/boot
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/challenge1.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 1 handin, as well
2 | as the problem number.
3 | 


--------------------------------------------------------------------------------
/challenge2.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 2 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/challenge3.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 3 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/challenge4.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 4 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/challenge5.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 5 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/challenge6.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 6 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/challenge7.txt:
--------------------------------------------------------------------------------
1 | List challenge problems completed as part of the lab 7 handin, as well
2 | as the problem number.  If you worked any previous lab challenges and
3 | submitted them with this lab, list them here, along with the lab number.
4 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/conf/lab.mk:
--------------------------------------------------------------------------------
1 | LAB=8
2 | PACKAGEDATE=Wed Mar 14 19:12:24 EDT 2018
3 | 


--------------------------------------------------------------------------------
/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 | int    ide_read(uint32_t secno, void *dst, size_t nsecs);
21 | int    ide_write(uint32_t secno, const void *src, size_t nsecs);
22 | 
23 | /* bc.c */
24 | void*  diskaddr(uint64_t blockno);
25 | bool   va_is_mapped(void *va);
26 | bool   va_is_dirty(void *va);
27 | void   flush_block(void *addr);
28 | void   bc_init(void);
29 | 
30 | /* fs.c */
31 | void   fs_init(void);
32 | int    file_get_block(struct File *f, uint32_t file_blockno, char **pblk);
33 | int    file_create(const char *path, struct File **f);
34 | int    file_open(const char *path, struct File **f);
35 | ssize_t file_read(struct File *f, void *buf, size_t count, off_t offset);
36 | int    file_write(struct File *f, const void *buf, size_t count, off_t offset);
37 | int    file_set_size(struct File *f, off_t newsize);
38 | void   file_flush(struct File *f);
39 | int    file_remove(const char *path);
40 | void   fs_sync(void);
41 | int    file_block_walk(struct File *f, uint32_t filebno, uint32_t **ppdiskbno, bool alloc);
42 | /* int	map_block(uint32_t); */
43 | bool   block_is_free(uint32_t blockno);
44 | int    alloc_block(void);
45 | 
46 | /* test.c */
47 | void   fs_test(void);
48 | 
49 | #ifdef VMM_GUEST
50 | /* vmx_host.c */
51 | uint64_t get_host_fd(); 
52 | int    host_read(uint32_t secno, void *dst, size_t nsecs);
53 | int    host_write(uint32_t secno, const void *src, size_t nsecs);
54 | void   host_ipc_init();
55 | #endif
56 | 
57 | 


--------------------------------------------------------------------------------
/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 | int
 63 | ide_read(uint32_t secno, void *dst, size_t nsecs)
 64 | {
 65 | 	int r;
 66 | 
 67 | 	assert(nsecs <= 256);
 68 | 
 69 | 	ide_wait_ready(0);
 70 | 
 71 | 	outb(0x1F2, nsecs);
 72 | 	outb(0x1F3, secno & 0xFF);
 73 | 	outb(0x1F4, (secno >> 8) & 0xFF);
 74 | 	outb(0x1F5, (secno >> 16) & 0xFF);
 75 | 	outb(0x1F6, 0xE0 | ((diskno&1)<<4) | ((secno>>24)&0x0F));
 76 | 	outb(0x1F7, 0x20);	// CMD 0x20 means read sector
 77 | 
 78 | 	for (; nsecs > 0; nsecs--, dst += SECTSIZE) {
 79 | 		if ((r = ide_wait_ready(1)) < 0)
 80 | 			return r;
 81 | 		insw(0x1F0, dst, SECTSIZE/2);
 82 | 	}
 83 | 
 84 | 	return 0;
 85 | }
 86 | 
 87 | int
 88 | ide_write(uint32_t secno, const void *src, size_t nsecs)
 89 | {
 90 | 	int r;
 91 | 
 92 | 	assert(nsecs <= 256);
 93 | 
 94 | 	ide_wait_ready(0);
 95 | 
 96 | 	outb(0x1F2, nsecs);
 97 | 	outb(0x1F3, secno & 0xFF);
 98 | 	outb(0x1F4, (secno >> 8) & 0xFF);
 99 | 	outb(0x1F5, (secno >> 16) & 0xFF);
100 | 	outb(0x1F6, 0xE0 | ((diskno&1)<<4) | ((secno>>24)&0x0F));
101 | 	outb(0x1F7, 0x30);	// CMD 0x30 means write sector
102 | 
103 | 	for (; nsecs > 0; nsecs--, src += SECTSIZE) {
104 | 		if ((r = ide_wait_ready(1)) < 0)
105 | 			return r;
106 | 		outsw(0x1F0, src, SECTSIZE/2);
107 | 	}
108 | 
109 | 	return 0;
110 | }
111 | 
112 | 


--------------------------------------------------------------------------------
/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 |     <blink>Cheesy web page!</blink>
 9 | </center>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/fs/motd_guest:
--------------------------------------------------------------------------------
 1 | 
 2 | This is /motd, the message of the day.
 3 | 
 4 | Welcome to the JOS guest kernel.
 5 | 
 6 | What is the tortoise standing on?
 7 | You are very clever, young man, very clever,
 8 | said the old lady. But it is turtles all the way
 9 | down!
10 | 
11 | 


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


--------------------------------------------------------------------------------
/fs/robig:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/oscarlab/hoss/69da6bc905ba0db77db6809985b34b28e347eb01/fs/robig


--------------------------------------------------------------------------------
/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 | 


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


--------------------------------------------------------------------------------
/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/vmx_host.c:
--------------------------------------------------------------------------------
 1 | #ifdef VMM_GUEST
 2 | // Forward FS read/writes to the host instead of the IDE disk.
 3 | 
 4 | #include "fs.h"
 5 | 
 6 | #include  <inc/vmx.h>
 7 | #include <inc/fs.h>
 8 | #include <inc/lib.h>
 9 | 
10 | #define HOST_FS_FILE "/vmm/fs.img"
11 | 
12 | static struct Fd *host_fd;
13 | static union Fsipc host_fsipcbuf __attribute__((aligned(PGSIZE)));
14 | 
15 | static int
16 | host_fsipc(unsigned type, void *dstva)
17 | {
18 | 	ipc_host_send(VMX_HOST_FS_ENV, type, &host_fsipcbuf, PTE_P | PTE_W | PTE_U);
19 | 	return ipc_host_recv(dstva);
20 | }
21 | 
22 | 
23 | uint64_t
24 | get_host_fd()
25 | {
26 | 	return (uint64_t) host_fd;
27 | }
28 | 
29 | int
30 | host_read(uint32_t secno, void *dst, size_t nsecs)
31 | {
32 | 	int r, read = 0;
33 | 
34 | 	if(host_fd->fd_file.id == 0) {
35 | 		host_ipc_init();
36 | 	}
37 | 
38 | 	host_fd->fd_offset = secno * SECTSIZE;
39 | 	// read from the host, 2 sectors at a time.
40 | 	for(; nsecs > 0; nsecs-=2) {
41 | 
42 | 		host_fsipcbuf.read.req_fileid = host_fd->fd_file.id;
43 | 		host_fsipcbuf.read.req_n = SECTSIZE * 2;
44 | 		if ((r = host_fsipc(FSREQ_READ, NULL)) < 0)
45 | 			return r;
46 | 		// FIXME: Handle case where r < SECTSIZE * 2;
47 | 		memmove(dst+read, &host_fsipcbuf, r);
48 | 		read += SECTSIZE * 2;
49 | 	}
50 | 
51 | 	return 0;
52 | }
53 | 
54 | int
55 | host_write(uint32_t secno, const void *src, size_t nsecs)
56 | {
57 | 	int r, written = 0;
58 | 
59 | 	if(host_fd->fd_file.id == 0) {
60 | 		host_ipc_init();
61 | 	}
62 | 
63 | 	host_fd->fd_offset = secno * SECTSIZE;
64 | 	for(; nsecs > 0; nsecs-=2) {
65 | 		host_fsipcbuf.write.req_fileid = host_fd->fd_file.id;
66 | 		host_fsipcbuf.write.req_n = SECTSIZE * 2;
67 | 		memmove(host_fsipcbuf.write.req_buf, src+written, SECTSIZE * 2);
68 | 		if ((r = host_fsipc(FSREQ_WRITE, NULL)) < 0)
69 | 			return r;
70 | 		written += SECTSIZE * 2;
71 | 	}
72 | 	return 0;
73 | }
74 | 
75 | void
76 | host_ipc_init()
77 | {
78 | 	int r;
79 | 	int vmdisk_number;
80 | 	char path_string[50];
81 | 	if ((r = fd_alloc(&host_fd)) < 0)
82 | 		panic("Couldn't allocate an fd!");
83 | 	asm("vmcall":"=a"(vmdisk_number): "0"(VMX_VMCALL_GETDISKIMGNUM));
84 | 	snprintf(path_string, 50, "/vmm/fs%d.img", vmdisk_number);
85 | 	strcpy(host_fsipcbuf.open.req_path, path_string);
86 | 	host_fsipcbuf.open.req_omode = O_RDWR;
87 | 
88 | 	if ((r = host_fsipc(FSREQ_OPEN, host_fd)) < 0) {
89 | 		fd_close(host_fd, 0);
90 | 		panic("Couldn't open host file!");
91 | 	}
92 | 
93 | }
94 | 
95 | #endif
96 | 


--------------------------------------------------------------------------------
/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"^ *rbp +00000080042[0-9a-z]{5} +rip +000000800420[0-1][0-9a-z]{3}"
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(r"kern/init.c:[0-9]+: +test_backtrace\+[0-9]{16} +args:[0-9] +([0-9a-f]{16})", r.qemu.output, re.MULTILINE)
27 |     assert_equal("\n".join(matches[:7]),
28 |                  "\n".join("%016x" % n for n in [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 |     matches = re.findall(r"kern/monitor.c:[0-9]+: +([^+]*)\+", r.qemu.output)
36 |     assert_equal("\n".join(matches),
37 |                  "\n".join(["mon_backtrace"]))
38 | 
39 | @test(5, parent=test_jos)
40 | def test_backtrace_lines():
41 |     matches = re.findall(r"([^ ]*init.c:([0-9]+):) +test_backtrace\+", r.qemu.output)
42 |     assert matches, "No line numbers"
43 |     code = open('kern/init.c').read().split('\n');
44 |     begin = 0
45 |     end = 0
46 |     for i in range(len(code)):
47 |         if code[i].startswith('test_backtrace('):
48 | 		begin = i + 2
49 | 	if begin > 0 and code[i].startswith('}'):
50 | 		end = i
51 |     if any(int(m[1]) < begin or int(m[1]) > end for m in matches):
52 |         assert_equal("\n".join(m[0] for m in matches),
53 |                      "Line numbers between 5 and 50")
54 | 
55 | run_tests()
56 | 


--------------------------------------------------------------------------------
/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_boot_pml4e\(\) succeeded!")
23 | 
24 | run_tests()
25 | 


--------------------------------------------------------------------------------
/grade-lab8:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | from gradelib import *
 4 | 
 5 | r = Runner(save("jos.out"),
 6 |            stop_breakpoint("readline"))
 7 | 
 8 | def matchtest(parent, name, *args, **kw):
 9 |     def do_test():
10 |         r.match(*args, **kw)
11 |     test(5, name, parent=parent)(do_test)
12 | 
13 | @test(0, "VMM Tests")
14 | def test_vm():
15 |     r.user_test("vmm")
16 | matchtest(test_vm, "sys_ept_map seems to work correctly")
17 | 
18 | matchtest(test_vm, "VMX extension hidden from guest")
19 | 
20 | matchtest(test_vm, "turtles all the way")
21 | 
22 | run_tests()
23 | 


--------------------------------------------------------------------------------
/guest_boot/Makefrag:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/guest_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 gboot_start
13 | gboot_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 | # Switch from real to protected mode, using a bootstrap GDT
25 | # and segment translation that makes virtual addresses 
26 | # identical to their physical addresses, so that the 
27 | # effective memory map does not change during the switch.
28 | lgdt    gdtdesc
29 | movl    %cr0, %eax
30 | orl     $CR0_PE_ON, %eax
31 | movl    %eax, %cr0
32 | 
33 | # Jump to next instruction, but in 32-bit code segment.
34 | # Switches processor into 32-bit mode.
35 | ljmp    $PROT_MODE_CSEG, $protcseg
36 | 
37 | .code32                     # Assemble for 32-bit mode
38 | protcseg:
39 | # Set up the protected-mode data segment registers
40 | movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
41 | movw    %ax, %ds                # -> DS: Data Segment
42 | movw    %ax, %es                # -> ES: Extra Segment
43 | movw    %ax, %fs                # -> FS
44 | movw    %ax, %gs                # -> GS
45 | movw    %ax, %ss                # -> SS: Stack Segment
46 | 
47 | mov $0x100000,%eax
48 | jmp *%eax
49 | 
50 | # If bootmain returns (it shouldn't), loop.
51 | spin:
52 | jmp spin
53 | 
54 | # Bootstrap GDT
55 | .p2align 2                                # force 4 byte alignment
56 | gdt:
57 | SEG_NULL				# null seg
58 | SEG(STA_X|STA_R, 0x0, 0xffffffff)	# code seg
59 | SEG(STA_W, 0x0, 0xffffffff)	        # data seg
60 | gdtdesc:
61 | .word   0x17                           # sizeof(gdt) - 1
62 | .long   gdt                             # address gdt
63 | 


--------------------------------------------------------------------------------
/guest_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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 	uint64_t e_entry;
13 | 	uint64_t e_phoff;
14 | 	uint64_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_flags;
27 | 	uint64_t p_offset;
28 | 	uint64_t p_va;
29 | 	uint64_t p_pa;
30 | 	uint64_t p_filesz;
31 | 	uint64_t p_memsz;
32 | 	uint64_t p_align;
33 | };
34 | 
35 | struct Secthdr {
36 | 	uint32_t sh_name;
37 | 	uint32_t sh_type;
38 | 	uint64_t sh_flags;
39 | 	uint64_t sh_addr;
40 | 	uint64_t sh_offset;
41 | 	uint64_t sh_size;
42 | 	uint32_t sh_link;
43 | 	uint32_t sh_info;
44 | 	uint64_t sh_addralign;
45 | 	uint64_t sh_entsize;
46 | };
47 | 
48 | 
49 | // Values for Proghdr::p_type
50 | #define ELF_PROG_LOAD		1
51 | 
52 | // Flag bits for Proghdr::p_flags
53 | #define ELF_PROG_FLAG_EXEC	1
54 | #define ELF_PROG_FLAG_WRITE	2
55 | #define ELF_PROG_FLAG_READ	4
56 | 
57 | // Values for Secthdr::sh_type
58 | #define ELF_SHT_NULL		0
59 | #define ELF_SHT_PROGBITS	1
60 | #define ELF_SHT_SYMTAB		2
61 | #define ELF_SHT_STRTAB		3
62 | 
63 | // Values for Secthdr::sh_name
64 | #define ELF_SHN_UNDEF		0
65 | 
66 | #endif /* !JOS_INC_ELF_H */
67 | 


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


--------------------------------------------------------------------------------
/inc/ept.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_EPT_H
 2 | #define JOS_INC_EPT_H
 3 | 
 4 | #define __EPTE_READ	0x01
 5 | #define __EPTE_WRITE	0x02
 6 | #define __EPTE_EXEC	0x04
 7 | #define __EPTE_IPAT	0x40
 8 | #define __EPTE_SZ	0x80
 9 | #define __EPTE_A	0x100
10 | #define __EPTE_D	0x200
11 | #define __EPTE_TYPE(n)	(((n) & 0x7) << 3)
12 | 
13 | enum {
14 | 	 EPTE_TYPE_UC = 0, /* uncachable */
15 | 	 EPTE_TYPE_WC = 1, /* write combining */
16 | 	 EPTE_TYPE_WT = 4, /* write through */
17 | 	 EPTE_TYPE_WP = 5, /* write protected */
18 | 	 EPTE_TYPE_WB = 6, /* write back */
19 | };
20 | 
21 | #define __EPTE_NONE	0
22 | #define __EPTE_FULL	(__EPTE_READ | __EPTE_WRITE | __EPTE_EXEC)
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/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	= 2,	// Environment doesn't exist or otherwise
10 | 				// cannot be used in requested action
11 | 	E_INVAL		= 3,	// Invalid parameter
12 | 	E_NO_MEM	= 4,	// Request failed due to memory shortage
13 | 	E_NO_FREE_ENV	= 5,	// Attempt to create a new environment beyond
14 | 				// the maximum allowed
15 | 	E_FAULT		= 6,	// Memory fault
16 | 	E_NO_SYS	= 7,	// Unimplemented system call
17 | 
18 | 	E_IPC_NOT_RECV	= 8,	// Attempt to send to env that is not recving
19 | 	E_EOF		= 9,	// Unexpected end of file
20 | 
21 | 	// File system error codes -- only seen in user-level
22 | 	E_NO_DISK	= 10,	// No free space left on disk
23 | 	E_MAX_OPEN	= 11,	// Too many files are open
24 | 	E_NOT_FOUND	= 12, 	// File or block not found
25 | 	E_BAD_PATH	= 13,	// Bad path
26 | 	E_FILE_EXISTS	= 14,	// File already exists
27 | 	E_NOT_EXEC	= 15,	// File not a valid executable
28 | 	E_NOT_SUPP	= 16,	// Operation not supported
29 | 	// VMM error codes.
30 | 	E_NO_VMX = 17,    // The processor doesn't support VMX or 
31 | 	// is turned off in the BIOS
32 | 	E_NO_EPT = 18,
33 | 	E_VMX_ON = 19,    // Couldn't transition the cpu to VMX root mode
34 | 	E_VMCS_INIT = 20, // Couldn't init the VMCS region
35 | 	E_NO_ENT = 21,
36 | 	MAXERROR
37 | };
38 | 
39 | #endif	// !JOS_INC_ERROR_H */
40 | 


--------------------------------------------------------------------------------
/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 | uint64_t	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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 	} accept;
 44 | 
 45 | 	struct Nsret_accept {
 46 | 		struct sockaddr ret_addr;
 47 | 		socklen_t ret_addrlen;
 48 | 	} acceptRet;
 49 | 
 50 | 	struct Nsreq_bind {
 51 | 		int req_s;
 52 | 		struct sockaddr req_name;
 53 | 		socklen_t req_namelen;
 54 | 	} bind;
 55 | 
 56 | 	struct Nsreq_shutdown {
 57 | 		int req_s;
 58 | 		int req_how;
 59 | 	} shutdown;
 60 | 
 61 | 	struct Nsreq_close {
 62 | 		int req_s;
 63 | 	} close;
 64 | 
 65 | 	struct Nsreq_connect {
 66 | 		int req_s;
 67 | 		struct sockaddr req_name;
 68 | 		socklen_t req_namelen;
 69 | 	} connect;
 70 | 
 71 | 	struct Nsreq_listen {
 72 | 		int req_s;
 73 | 		int req_backlog;
 74 | 	} listen;
 75 | 
 76 | 	struct Nsreq_recv {
 77 | 		int req_s;
 78 | 		int req_len;
 79 | 		unsigned int req_flags;
 80 | 	} recv;
 81 | 
 82 | 	struct Nsret_recv {
 83 | 		char ret_buf[0];
 84 | 	} recvRet;
 85 | 
 86 | 	struct Nsreq_send {
 87 | 		int req_s;
 88 | 		int req_size;
 89 | 		unsigned int req_flags;
 90 | 		char req_buf[0];
 91 | 	} send;
 92 | 
 93 | 	struct Nsreq_socket {
 94 | 		int req_domain;
 95 | 		int req_type;
 96 | 		int req_protocol;
 97 | 	} socket;
 98 | 
 99 | 	struct jif_pkt pkt;
100 | 
101 | 	// Ensure Nsipc is one page
102 | 	char _pad[PGSIZE];
103 | };
104 | 
105 | #endif // !JOS_INC_NS_H
106 | 


--------------------------------------------------------------------------------
/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 | 	uint32_t n_value;	// value of symbol
49 | };
50 | 
51 | #endif /* !JOS_STAB_H */
52 | 


--------------------------------------------------------------------------------
/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 | 
 7 | typedef __builtin_va_list va_list;
 8 | 
 9 | #define va_start(ap, last) __builtin_va_start(ap, last)
10 | 
11 | #define va_arg(ap, type) __builtin_va_arg(ap, type)
12 | 
13 | #define va_end(ap) __builtin_va_end(ap)
14 | 
15 | #define va_copy(d,s)    __builtin_va_copy(d,s)
16 | 
17 | #endif	/* !JOS_INC_STDARG_H */
18 | 


--------------------------------------------------------------------------------
/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 | char *  strstr(const char *in, const char *str);
25 | 
26 | #endif /* not JOS_INC_STRING_H */
27 | 


--------------------------------------------------------------------------------
/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_ept_map,
22 | 	SYS_env_mkguest,
23 | #ifndef VMM_GUEST
24 | 	SYS_vmx_list_vms,
25 | 	SYS_vmx_sel_resume,
26 | 	SYS_vmx_get_vmdisk_number,
27 | 	SYS_vmx_incr_vmdisk_number,
28 | #endif
29 | 	NSYSCALLS
30 | };
31 | 
32 | #endif /* !JOS_INC_SYSCALL_H */
33 | 


--------------------------------------------------------------------------------
/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 uint64_t uintptr_t;
28 | typedef uint64_t physaddr_t;
29 | 
30 | // Page numbers are 32 bits long.
31 | typedef uint64_t ppn_t;
32 | 
33 | // size_t is used for memory object sizes.
34 | typedef uint64_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 | 	uint64_t __a = (uint64_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 | 	uint64_t __n = (uint64_t) (n);				\
67 | 	(typeof(a)) (ROUNDDOWN((uint64_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 | 


--------------------------------------------------------------------------------
/inc/vmx.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_INC_VMX_H
 2 | #define JOS_INC_VMX_H
 3 | 
 4 | #define GUEST_MEM_SZ 16 * 1024 * 1024
 5 | #define MAX_MSR_COUNT ( PGSIZE / 2 ) / ( 128 / 8 )
 6 | 
 7 | #ifndef __ASSEMBLER__
 8 | 
 9 | struct VmxGuestInfo {
10 | 	int64_t phys_sz;
11 | 	uintptr_t *vmcs;
12 | 
13 | 	// Exception bitmap.
14 | 	uint32_t exception_bmap;
15 | 	// I/O bitmap.
16 | 	uint64_t *io_bmap_a;
17 | 	uint64_t *io_bmap_b;
18 | 	// MSR load/store area.
19 | 	int msr_count;
20 | 	uintptr_t *msr_host_area;
21 | 	uintptr_t *msr_guest_area;
22 | 	int vcpunum;
23 | };
24 | 
25 | #endif
26 | 
27 | #if defined(VMM_GUEST) || defined(VMM_HOST)
28 | 
29 | // VMCALLs
30 | #define VMX_VMCALL_MBMAP 0x1
31 | #define VMX_VMCALL_IPCSEND 0x2
32 | #define VMX_VMCALL_IPCRECV 0x3
33 | #define VMX_VMCALL_LAPICEOI 0x4
34 | #define VMX_VMCALL_BACKTOHOST 0x5
35 | #define VMX_VMCALL_GETDISKIMGNUM 0x6
36 | #define VMX_VMCALL_ALLOC_CPU 0x7
37 | #define VMX_VMCALL_GUEST_YIELD 0x8
38 | #define VMX_VMCALL_CPUNUM 0x9
39 | 
40 | #define VMX_HOST_FS_ENV 0x1
41 | 
42 | #endif
43 | #endif
44 | 


--------------------------------------------------------------------------------
/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 | #endif /* _CONSOLE_H_ */
27 | 


--------------------------------------------------------------------------------
/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 | #define NCPU  4
11 | 
12 | 
13 | 
14 | // Values of status in struct Cpu
15 | enum {
16 | 	CPU_UNUSED = 0,
17 | 	CPU_STARTED,
18 | 	CPU_HALTED,
19 | };
20 | 
21 | // Per-CPU state
22 | struct CpuInfo {
23 | 	uint8_t cpu_id;                 // Local APIC ID; index into cpus[] below
24 | 	volatile unsigned cpu_status;   // The status of the CPU
25 | 	struct Env *cpu_env;            // The currently-running environment.
26 | 	struct Taskstate cpu_ts;        // Used by x86 to find stack for interrupt
27 |     bool is_vmx_root;               // Is the CPU in VMX root mode?
28 |     uintptr_t vmxon_region;         // KVA of vmxon region.
29 | };
30 | 
31 | // Initialized in mpconfig.c
32 | extern struct CpuInfo cpus[NCPU];
33 | extern int ncpu;                    // Total number of CPUs in the system
34 | extern struct CpuInfo *bootcpu;     // The boot-strap processor (BSP)
35 | extern physaddr_t lapicaddr;        // Physical MMIO address of the local APIC
36 | 
37 | // Per-CPU kernel stacks
38 | extern unsigned char percpu_kstacks[NCPU][KSTKSIZE];
39 | 
40 | int cpunum(void);
41 | #define thiscpu (&cpus[cpunum()])
42 | 
43 | void mp_init(void);
44 | void lapic_init(void);
45 | void lapic_startap(uint8_t apicid, uint32_t addr);
46 | void lapic_eoi(void);
47 | void lapic_ipi(int vector);
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/kern/dwarf_api.h:
--------------------------------------------------------------------------------
 1 | #ifndef DWARF_API_H
 2 | #define DWARF_API_H
 3 | #include <kern/kdebug.h>
 4 | 
 5 | extern uintptr_t read_section_headers(uintptr_t, uintptr_t);
 6 | extern void find_debug_sections(uintptr_t);
 7 | extern int dwarf_get_pc_info(uintptr_t addr, struct Ripdebuginfo *info);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/kern/dwarf_error.h:
--------------------------------------------------------------------------------
 1 | #ifndef DWARF_ERROR_H_
 2 | #define DWARF_ERROR_H_
 3 | 
 4 | #define DW_DLV_NO_ENTRY  -1
 5 | #define DW_DLV_OK         0
 6 | #define DW_DLV_ERROR      1
 7 | 
 8 | enum {
 9 |         DW_DLE_NONE,                    /* No error. */
10 |         DW_DLE_ERROR,                   /* An error! */
11 |         DW_DLE_ARGUMENT,                /* Invalid argument. */
12 |         DW_DLE_DEBUG_INFO_NULL,         /* Debug info NULL. */
13 |         DW_DLE_NO_ENTRY,                /* No entry. */
14 |         DW_DLE_MEMORY,                  /* Insufficient memory. */
15 |         DW_DLE_ELF,                     /* ELF error. */
16 |         DW_DLE_CU_LENGTH_ERROR,         /* Invalid compilation unit data. */
17 |         DW_DLE_VERSION_STAMP_ERROR,     /* Invalid version. */
18 |         DW_DLE_DEBUG_ABBREV_NULL,       /* Abbrev not found. */
19 |         DW_DLE_DIE_NO_CU_CONTEXT,       /* No current compilation unit. */
20 |         DW_DLE_LOC_EXPR_BAD,            /* Invalid location expression. */
21 |         DW_DLE_EXPR_LENGTH_BAD,         /* Invalid DWARF expression. */
22 |         DW_DLE_DEBUG_LOC_SECTION_SHORT, /* Loclist section too short. */
23 |         DW_DLE_ATTR_FORM_BAD,           /* Invalid attribute form. */
24 |         DW_DLE_DEBUG_LINE_LENGTH_BAD,   /* Line info section too short. */
25 |         DW_DLE_LINE_FILE_NUM_BAD,       /* Invalid file number. */
26 |         DW_DLE_DIR_INDEX_BAD,           /* Invalid dir index. */
27 |         DW_DLE_DEBUG_FRAME_LENGTH_BAD,  /* Frame section too short. */
28 |         DW_DLE_NO_CIE_FOR_FDE,          /* CIE not found for certain FDE. */
29 |         DW_DLE_FRAME_AUGMENTATION_UNKNOWN, /* Unknown CIE augmentation. */
30 |         DW_DLE_FRAME_INSTR_EXEC_ERROR,  /* Frame instruction exec error. */
31 |         DW_DLE_FRAME_VERSION_BAD,       /* Invalid frame section version. */
32 |         DW_DLE_FRAME_TABLE_COL_BAD,     /* Invalid table column. */
33 |         DW_DLE_DF_REG_NUM_TOO_HIGH,     /* Insufficient regtable space. */
34 |         DW_DLE_PC_NOT_IN_FDE_RANGE,     /* PC requested not in the FDE range. */
35 |         DW_DLE_ARANGE_OFFSET_BAD,       /* Invalid arange offset. */
36 |         DW_DLE_DEBUG_MACRO_INCONSISTENT,/* Invalid macinfo data. */
37 |         DW_DLE_ELF_SECT_ERR,            /* Application callback failed. */
38 |         DW_DLE_NUM                      /* Max error number. */
39 | };
40 | 
41 | #define DWARF_SET_ERROR(x, y ,z)  {  }
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/kern/dwarf_lineno.h:
--------------------------------------------------------------------------------
 1 | #ifndef DWARF_LINENO_H
 2 | // External functions used
 3 | extern Dwarf_Attribute *_dwarf_attr_find(Dwarf_Die *, uint16_t);
 4 | 
 5 | 
 6 | //Functions declared in this module
 7 | static int _dwarf_lineno_add_file(Dwarf_LineInfo, uint8_t **, const char *, Dwarf_Error *, Dwarf_Debug);
 8 | 
 9 | static int
10 | _dwarf_lineno_run_program(Dwarf_CU *cu, Dwarf_LineInfo li, uint8_t *p,
11 |     uint8_t *pe, Dwarf_Addr pc, Dwarf_Error *error);
12 | 
13 | static int
14 | _dwarf_lineno_add_file(Dwarf_LineInfo li, uint8_t **p, const char *compdir,
15 |     Dwarf_Error *error, Dwarf_Debug dbg);
16 | 
17 | int
18 | _dwarf_lineno_init(Dwarf_Die *die, uint64_t offset, Dwarf_LineInfo linfo, Dwarf_Addr pc, Dwarf_Error *error);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/kern/e1000.c:
--------------------------------------------------------------------------------
1 | #include <kern/e1000.h>
2 | 
3 | // LAB 6: Your driver code here
4 | 


--------------------------------------------------------------------------------
/kern/e1000.h:
--------------------------------------------------------------------------------
1 | #ifndef JOS_KERN_E1000_H
2 | #define JOS_KERN_E1000_H
3 | 
4 | #endif	// JOS_KERN_E1000_H
5 | 


--------------------------------------------------------------------------------
/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 | int env_guest_alloc(struct Env **newenv_store, envid_t parent_id);
26 | 
27 | // Without this extra macro, we couldn't pass macros like TEST to
28 | // ENV_CREATE because of the C pre-processor's argument prescan rule.
29 | #define ENV_PASTE3(x, y, z) x ## y ## z
30 | 
31 | #ifndef VMM_GUEST
32 | #define ENV_CREATE(x, type)						\
33 | 	do {								\
34 | 		extern uint8_t ENV_PASTE3(_binary_obj_, x, _start)[];	\
35 | 		env_create(ENV_PASTE3(_binary_obj_, x, _start),		\
36 | 			   type);					\
37 | 	} while (0)
38 | #else
39 | #define ENV_CREATE(x, type)						\
40 | 	do {								\
41 | 		extern uint8_t ENV_PASTE3(_binary_vmm_guest_obj_, x, _start)[];	\
42 | 		env_create(ENV_PASTE3(_binary_vmm_guest_obj_, x, _start),		\
43 | 			   type);					\
44 | 	} while (0)
45 | #endif //!VMM_GUEST
46 | 
47 | #endif // !JOS_KERN_ENV_H
48 | 


--------------------------------------------------------------------------------
/kern/guest_kernel.ld:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Simple linker script for the JOS kernel.
 3 |    See the GNU ld 'info' manual ("info ld") to learn the syntax. */
 4 | 
 5 | OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
 6 | OUTPUT_ARCH(i386:x86-64)
 7 | ENTRY(_head64)
 8 | /* STARTUP(vmm/guest/obj/kern/bootstrap.o) */
 9 | 
10 | SECTIONS
11 | {
12 |     . = 0x100000;
13 | 
14 |     .bootstrap : {
15 |         vmm/guest/obj/kern/bootstrap.o (.text .data .bss)
16 |     }
17 |     
18 | 	/* Link the kernel at this address: "." means the current address */
19 | 	. = 0x8004200000;
20 | 
21 | 	.text : AT(0x200000) {
22 | 		*(EXCLUDE_FILE(vmm/guest/obj/kern/bootstrap.o) .text .stub .text.* .gnu.linkonce.t.*)
23 | 	}
24 | 
25 | 	PROVIDE(etext = .);	/* Define the 'etext' symbol to this value */
26 | 
27 | 	.rodata : {
28 | 		*(EXCLUDE_FILE(vmm/guest/obj/kern/bootstrap.o) .rodata .rodata.* .gnu.linkonce.r.*)
29 | 	}
30 | 
31 | 	/* Adjust the address for the data segment to the next page */
32 | 	. = ALIGN(0x1000);
33 | 
34 | 	/* The data segment */
35 | 	.data : {
36 | 		*(EXCLUDE_FILE(vmm/guest/obj/kern/bootstrap.o) .data)
37 | 	}
38 | 
39 | 	PROVIDE(edata = .);
40 | 
41 | 	.bss : {
42 | 		*(EXCLUDE_FILE(vmm/guest/obj/kern/bootstrap.o) .bss)
43 | 	}
44 | 
45 | 	PROVIDE(end = .);
46 | 
47 | 	/* "Borrowed" from Linux kernel */
48 | 	/* Include debugging information in kernel memory */
49 |         /* DWARF 1 */                                           
50 | 	.debug          0 : { *(.debug) }
51 |         .line           0 : { *(.line) }
52 |         /* GNU DWARF 1 extensions */
53 |         .debug_srcinfo  0 : { *(.debug_srcinfo) }
54 |         .debug_sfnames  0 : { *(.debug_sfnames) }
55 |         /* DWARF 1.1 and DWARF 2 */
56 |         .debug_aranges  0 : { *(.debug_aranges) }
57 |         .debug_pubnames 0 : { *(.debug_pubnames) }
58 |         /* DWARF 2 */
59 |         .debug_info     0 : { *(.debug_info
60 |         .gnu.linkonce.wi.*) }
61 |         .debug_abbrev   0 : { *(.debug_abbrev) }
62 |         .debug_line     0 : { *(.debug_line) }
63 |         .debug_frame    0 : { *(.debug_frame) }
64 |         .debug_str      0 : { *(.debug_str) }
65 |         .debug_loc      0 : { *(.debug_loc) }
66 |         .debug_macinfo  0 : { *(.debug_macinfo) }
67 |         /* SGI/MIPS DWARF 2 extensions */ 
68 |         .debug_weaknames 0 : { *(.debug_weaknames) }
69 |         .debug_funcnames 0 : { *(.debug_funcnames) }
70 |         .debug_typenames 0 : { *(.debug_typenames) }
71 |         .debug_varnames  0 : { *(.debug_varnames) }
72 | 
73 | 	/DISCARD/ : {
74 | 		*(.eh_frame .note.GNU-stack)
75 | 	}
76 | }
77 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 bytes 38 39: extended memory >16M in blocks of 64K */
27 | #define NVRAM_EXTGT16LO (MC_NVRAM_START + 38)   /* low byte. 0x34 */
28 | #define NVRAM_EXTGT16HI (MC_NVRAM_START + 39)   /* high byte. 0x35 */
29 | 
30 | /* NVRAM byte 36: current century.  (please increment in Dec99!) */
31 | #define NVRAM_CENTURY	(MC_NVRAM_START + 36)	/* RTC offset 0x32 */
32 | 
33 | unsigned mc146818_read(unsigned reg);
34 | void mc146818_write(unsigned reg, unsigned datum);
35 | 
36 | #endif	// !JOS_KERN_KCLOCK_H
37 | 


--------------------------------------------------------------------------------
/kern/kdebug.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KERN_KDEBUG_H
 2 | #define JOS_KERN_KDEBUG_H
 3 | 
 4 | #include <inc/types.h>
 5 | #include <kern/dwarf.h>
 6 | 
 7 | // Debug information about a particular instruction pointer
 8 | struct Ripdebuginfo {
 9 | 	const char *rip_file;		// Source code filename for RIP
10 | 	int rip_line;			// Source code linenumber for RIP
11 | 
12 | 	const char *rip_fn_name;	// Name of function containing RIP
13 | 					//  - Note: not null terminated!
14 | 	int rip_fn_namelen;		// Length of function name
15 | 	uintptr_t rip_fn_addr;		// Address of start of function
16 | 	int rip_fn_narg;		// Number of function arguments
17 | 	int size_fn_arg[10];		// Sizes of each of function arguments
18 | 	uintptr_t offset_fn_arg[10];	// Offset of each of function arguments (from CFA)
19 | 	Dwarf_Regtable reg_table;
20 | };
21 | 
22 | int debuginfo_rip(uintptr_t rip, struct Ripdebuginfo *info);
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/kern/kernel.ld:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Simple linker script for the JOS kernel.
 3 |    See the GNU ld 'info' manual ("info ld") to learn the syntax. */
 4 | 
 5 | OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
 6 | OUTPUT_ARCH(i386:x86-64)
 7 | ENTRY(_head64)
 8 | /* STARTUP(obj/kern/bootstrap.o) */
 9 | 
10 | SECTIONS
11 | {
12 | 	. = 0x100000;
13 | 
14 | 	.bootstrap : {
15 | 		obj/kern/bootstrap.o (.text .data .bss)
16 | 	}
17 | 
18 | 	/* Link the kernel at this address: "." means the current address */
19 | 	. = 0x8004200000;
20 | 
21 | 	.text : AT(0x200000) {
22 | 		*(EXCLUDE_FILE(obj/kern/bootstrap.o) .text .stub .text.* .gnu.linkonce.t.*)
23 | 	}
24 | 
25 | 	PROVIDE(etext = .);	/* Define the 'etext' symbol to this value */
26 | 
27 | 	.rodata : {
28 | 		*(EXCLUDE_FILE(obj/kern/bootstrap.o) .rodata .rodata.* .gnu.linkonce.r.*)
29 | 	}
30 | 
31 | 	/* Adjust the address for the data segment to the next page */
32 | 	. = ALIGN(0x1000);
33 | 
34 | 	/* The data segment */
35 | 	.data : {
36 | 		*(EXCLUDE_FILE(obj/kern/bootstrap.o) .data)
37 | 	}
38 | 
39 | 	PROVIDE(edata = .);
40 | 
41 | 	.bss : {
42 | 		*(EXCLUDE_FILE(obj/kern/bootstrap.o) .bss)
43 | 	}
44 | 
45 | 	PROVIDE(end = .);
46 | 
47 | 	/* "Borrowed" from Linux kernel */
48 | 	/* Include debugging information in kernel memory */
49 | 	/* DWARF 1 */                                           
50 | 	.debug          0 : { *(.debug) }
51 | 	.line           0 : { *(.line) }
52 | 	/* GNU DWARF 1 extensions */
53 | 	.debug_srcinfo  0 : { *(.debug_srcinfo) }
54 | 	.debug_sfnames  0 : { *(.debug_sfnames) }
55 | 	/* DWARF 1.1 and DWARF 2 */
56 | 	.debug_aranges  0 : { *(.debug_aranges) }
57 | 	.debug_pubnames 0 : { *(.debug_pubnames) }
58 | 	/* DWARF 2 */
59 | 	.debug_info     0 : { *(.debug_info
60 | 	.gnu.linkonce.wi.*) }
61 | 	.debug_abbrev   0 : { *(.debug_abbrev) }
62 | 	.debug_line     0 : { *(.debug_line) }
63 | 	.debug_frame    0 : { *(.debug_frame) }
64 | 	.debug_str      0 : { *(.debug_str) }
65 | 	.debug_loc      0 : { *(.debug_loc) }
66 | 	.debug_macinfo  0 : { *(.debug_macinfo) }
67 | 	/* SGI/MIPS DWARF 2 extensions */ 
68 | 	.debug_weaknames 0 : { *(.debug_weaknames) }
69 | 	.debug_funcnames 0 : { *(.debug_funcnames) }
70 | 	.debug_typenames 0 : { *(.debug_typenames) }
71 | 	.debug_varnames  0 : { *(.debug_varnames) }
72 | 
73 | 	/DISCARD/ : {
74 | 		*(.note.GNU-stack)
75 | 	}
76 | }
77 | 


--------------------------------------------------------------------------------
/kern/macro.h:
--------------------------------------------------------------------------------
 1 | #define PUSHA        \
 2 |     subq $120,%rsp  ; \
 3 |     movq %rax,112(%rsp); \
 4 |     movq %rbx,104(%rsp); \
 5 |     movq %rcx,96(%rsp); \
 6 |     movq %rdx,88(%rsp); \
 7 |     movq %rbp,80(%rsp); \
 8 |     movq %rdi,72(%rsp); \
 9 |     movq %rsi,64(%rsp); \
10 |     movq %r8,56(%rsp); \
11 |     movq %r9,48(%rsp); \
12 |     movq %r10,40(%rsp); \
13 |     movq %r11,32(%rsp); \
14 |     movq %r12,24(%rsp); \
15 |     movq %r13,16(%rsp); \
16 |     movq %r14,8(%rsp); \
17 |     movq %r15,0(%rsp);
18 | 
19 | #define POPA \
20 | 	"\tmovq 0(%%rsp),%%r15\n" \
21 | 	"\tmovq 8(%%rsp),%%r14\n" \
22 | 	"\tmovq 16(%%rsp),%%r13\n" \
23 | 	"\tmovq 24(%%rsp),%%r12\n" \
24 | 	"\tmovq 32(%%rsp),%%r11\n" \
25 | 	"\tmovq 40(%%rsp),%%r10\n" \
26 | 	"\tmovq 48(%%rsp),%%r9\n" \
27 | 	"\tmovq 56(%%rsp),%%r8\n" \
28 | 	"\tmovq 64(%%rsp),%%rsi\n" \
29 | 	"\tmovq 72(%%rsp),%%rdi\n" \
30 | 	"\tmovq 80(%%rsp),%%rbp\n" \
31 | 	"\tmovq 88(%%rsp),%%rdx\n" \
32 | 	"\tmovq 96(%%rsp),%%rcx\n" \
33 | 	"\tmovq 104(%%rsp),%%rbx\n" \
34 | 	"\tmovq 112(%%rsp),%%rax\n" \
35 | 	"\taddq $120,%%rsp\n"
36 | 
37 | #define POPA_ \
38 |     movq 0(%rsp),%r15;    \
39 |     movq 8(%rsp),%r14;  \
40 |     movq 16(%rsp),%r13; \
41 |     movq 24(%rsp),%r12;  \
42 |     movq 32(%rsp),%r11; \
43 |     movq 40(%rsp),%r10; \
44 |     movq 48(%rsp),%r9; \
45 |     movq 56(%rsp),%r8; \
46 |     movq 64(%rsp),%rsi; \
47 |     movq 72(%rsp),%rdi; \
48 |     movq 80(%rsp),%rbp; \
49 |     movq 88(%rsp),%rdx; \
50 |     movq 96(%rsp),%rcx; \
51 |     movq 104(%rsp),%rbx; \
52 |     movq 112(%rsp),%rax; \
53 |     addq $120,%rsp;
54 | 


--------------------------------------------------------------------------------
/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 | #endif	// !JOS_KERN_MONITOR_H
20 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 
 8 | 
 9 | static void
10 | putch(int ch, int *cnt)
11 | {
12 | 	cputchar(ch);
13 | 	*cnt++;
14 | }
15 | 
16 | int
17 | vcprintf(const char *fmt, va_list ap)
18 | {
19 | 	int cnt = 0;
20 | 	va_list aq;
21 | 	va_copy(aq,ap);
22 | 	vprintfmt((void*)putch, &cnt, fmt, aq);
23 | 	va_end(aq);
24 | 	return cnt;
25 | 
26 | }
27 | 
28 | int
29 | cprintf(const char *fmt, ...)
30 | {
31 | 	va_list ap;
32 | 	int cnt;
33 | 	va_start(ap, fmt);
34 | 	va_list aq;
35 | 	va_copy(aq,ap);
36 | 	cnt = vcprintf(fmt, aq);
37 | 	va_end(aq);
38 | 
39 | 	return cnt;
40 | }
41 | 
42 | 


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


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | int64_t syscall(uint64_t num, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5);
10 | 
11 | #endif /* !JOS_KERN_SYSCALL_H */
12 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/trapentry.S:
--------------------------------------------------------------------------------
 1 | /* See COPYRIGHT for copyright information. */
 2 | 
 3 | #include <inc/mmu.h>
 4 | #include <inc/memlayout.h>
 5 | #include <inc/trap.h>
 6 | #include <kern/macro.h>
 7 | 
 8 | #include <kern/picirq.h>
 9 | 
10 | 
11 | ###################################################################
12 | # exceptions/interrupts
13 | ###################################################################
14 | 
15 | /* TRAPHANDLER defines a globally-visible function for handling a trap.
16 |  * It pushes a trap number onto the stack, then jumps to _alltraps.
17 |  * Use TRAPHANDLER for traps where the CPU automatically pushes an error code.
18 |  *
19 |  * You shouldn't call a TRAPHANDLER function from C, but you may
20 |  * need to _declare_ one in C (for instance, to get a function pointer
21 |  * during IDT setup).  You can declare the function with
22 |  *   void NAME();
23 |  * where NAME is the argument passed to TRAPHANDLER.
24 |  */
25 | #define TRAPHANDLER(name, num)						\
26 | 	.globl name;		/* define global symbol for 'name' */	\
27 | 	.type name, @function;	/* symbol type is function */		\
28 | 	.align 2;		/* align function definition */		\
29 | 	name:			/* function starts here */		\
30 | 	pushq $(num);							\
31 | 	jmp _alltraps
32 | 
33 | /* Use TRAPHANDLER_NOEC for traps where the CPU doesn't push an error code.
34 |  * It pushes a 0 in place of the error code, so the trap frame has the same
35 |  * format in either case.
36 |  */
37 | #define TRAPHANDLER_NOEC(name, num)					\
38 | 	.globl name;							\
39 | 	.type name, @function;						\
40 | 	.align 2;							\
41 | 	name:								\
42 | 	pushq $0;							\
43 | 	pushq $(num);							\
44 | 	jmp _alltraps
45 | 
46 | .text
47 | 
48 | /*
49 |  * Lab 3: Your code here for generating entry points for the different traps.
50 |    Find the PUSHA,POPA macros in kern/macro.h. Since amd64 doesn't support
51 |    pusha,popa so you will find these macros handy.
52 |  */
53 | 
54 | 
55 | 
56 | /*
57 |  * Lab 3: Your code here for _alltraps
58 |  *
59 |  * Hint: Be sure to review the x64 calling convention from lab1
60 |  *       for how to pass a pointer to the trapframe.
61 |  */
62 | 
63 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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+0x80000000
15 | 	.globl  uvpde
16 | 	.set    uvpde,uvpd+0x400000
17 | 	.globl  uvpml4e
18 | 	.set    uvpml4e,uvpde+0x2000
19 | 
20 | 
21 | // Entrypoint - this is where the kernel (or our parent environment)
22 | // starts us running when we are initially loaded into a new environment.
23 | .text
24 | .globl _start
25 | _start:
26 | 	// See if we were started with arguments on the stack
27 | 	movabs $USTACKTOP, %rax
28 | 	cmpq %rax,%rsp
29 | 	jne args_exist
30 | 
31 | 	// If not, push dummy argc/argv arguments.
32 | 	// This happens when we are loaded by the kernel,
33 | 	// because the kernel does not know about passing arguments.
34 | 	pushq $0
35 | 	pushq $0
36 | 
37 | args_exist:
38 | 	movq 8(%rsp), %rsi
39 | 	movq (%rsp), %rdi
40 | 	call libmain
41 | 1:	jmp 1b
42 | 
43 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/lib/fork.c:
--------------------------------------------------------------------------------
 1 | // implement fork from user space
 2 | 
 3 | #include <inc/string.h>
 4 | #include <inc/lib.h>
 5 | 
 6 | // PTE_COW marks copy-on-write page table entries.
 7 | // It is one of the bits explicitly allocated to user processes (PTE_AVAIL).
 8 | #define PTE_COW		0x800
 9 | 
10 | //
11 | // Custom page fault handler - if faulting page is copy-on-write,
12 | // map in our own private writable copy.
13 | //
14 | static void
15 | pgfault(struct UTrapframe *utf)
16 | {
17 | 	void *addr = (void *) utf->utf_fault_va;
18 | 	uint32_t err = utf->utf_err;
19 | 	int r;
20 | 
21 | 	// Check that the faulting access was (1) a write, and (2) to a
22 | 	// copy-on-write page.  If not, panic.
23 | 	// Hint:
24 | 	//   Use the read-only page table mappings at uvpt
25 | 	//   (see <inc/memlayout.h>).
26 | 
27 | 	// LAB 4: Your code here.
28 | 
29 | 	// Allocate a new page, map it at a temporary location (PFTEMP),
30 | 	// copy the data from the old page to the new page, then move the new
31 | 	// page to the old page's address.
32 | 	// Hint:
33 | 	//   You should make three system calls.
34 | 	//   No need to explicitly delete the old page's mapping.
35 | 
36 | 	// LAB 4: Your code here.
37 | 
38 | 	panic("pgfault not implemented");
39 | }
40 | 
41 | //
42 | // Map our virtual page pn (address pn*PGSIZE) into the target envid
43 | // at the same virtual address.  If the page is writable or copy-on-write,
44 | // the new mapping must be created copy-on-write, and then our mapping must be
45 | // marked copy-on-write as well.  (Exercise: Why do we need to mark ours
46 | // copy-on-write again if it was already copy-on-write at the beginning of
47 | // this function?)
48 | //
49 | // Returns: 0 on success, < 0 on error.
50 | // It is also OK to panic on error.
51 | //
52 | static int
53 | duppage(envid_t envid, unsigned pn)
54 | {
55 | 	int r;
56 | 
57 | 	// LAB 4: Your code here.
58 | 	panic("duppage not implemented");
59 | 	return 0;
60 | }
61 | 
62 | //
63 | // User-level fork with copy-on-write.
64 | // Set up our page fault handler appropriately.
65 | // Create a child.
66 | // Copy our address space and page fault handler setup to the child.
67 | // Then mark the child as runnable and return.
68 | //
69 | // Returns: child's envid to the parent, 0 to the child, < 0 on error.
70 | // It is also OK to panic on error.
71 | //
72 | // Hint:
73 | //   Use uvpd, uvpt, and duppage.
74 | //   Remember to fix "thisenv" in the child process.
75 | //   Neither user exception stack should ever be marked copy-on-write,
76 | //   so you must allocate a new page for the child's user exception stack.
77 | //
78 | envid_t
79 | fork(void)
80 | {
81 | 	// LAB 4: Your code here.
82 | 	panic("fork not implemented");
83 | }
84 | 
85 | // Challenge!
86 | int
87 | sfork(void)
88 | {
89 | 	panic("sfork not implemented");
90 | 	return -E_INVAL;
91 | }
92 | 


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


--------------------------------------------------------------------------------
/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 = 0;
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 | 


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


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 		panic("set_pgfault_handler not implemented");
33 | 	}
34 | 
35 | 	// Save handler pointer for assembly to call.
36 | 	_pgfault_handler = handler;
37 | }
38 | 


--------------------------------------------------------------------------------
/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 |     va_list aq;
42 |     va_copy(aq,ap);
43 |     b.idx = 0;
44 |     b.cnt = 0;
45 |     vprintfmt((void*)putch, &b, fmt, aq);
46 |     sys_cputs(b.buf, b.idx);
47 |     va_end(aq);
48 | 
49 |     return b.cnt;
50 | }
51 | 
52 |     int
53 | cprintf(const char *fmt, ...)
54 | {
55 |     va_list ap;
56 |     int cnt;
57 |     va_list aq;
58 |     va_start(ap, fmt);
59 |     va_copy(aq,ap);
60 |     cnt = vcprintf(fmt, aq);
61 |     va_end(aq);
62 | 
63 |     return cnt;
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 -ljos -llwip $(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 user/user.ld
23 | 	@echo + ld $@
24 | 	$(V)$(LD) -o $@ $(ULDFLAGS) $(LDFLAGS) -nostdlib \
25 | 		$(OBJDIR)/lib/entry.o $< $(NET_OBJFILES) \
26 | 		-L$(OBJDIR)/lib -ljos -llwip $(GCC_LIB)
27 | 	$(V)$(OBJDUMP) -S $@ >$@.asm
28 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


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


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 |     uint64_t jb_rip;
10 |     uint64_t jb_rsp;
11 |     uint64_t jb_rbp;
12 |     uint64_t jb_rbx;
13 |     uint64_t jb_rsi;
14 |     uint64_t jb_rdi;
15 |     uint64_t jb_r15;
16 |     uint64_t jb_r14;
17 |     uint64_t jb_r13;
18 |     uint64_t jb_r12;
19 |     uint64_t jb_r11;
20 |     uint64_t jb_r10;
21 |     uint64_t jb_r9;
22 |     uint64_t jb_r8;
23 | };
24 | 
25 | #endif
26 | 


--------------------------------------------------------------------------------
/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 | 	//movq	4(%esp), %ecx	// jos_jmp_buf
11 | 
12 | 	movq	%rdi, %rcx	// jos_jmp_buf
13 | 	movq	0(%rsp), %rdx	// %rip as pushed by call
14 | 	movq	%rdx,  0(%rcx)
15 | 
16 | 	leaq	8(%rsp), %rdx	// where %esp will point when we return
17 | 	movq	%rdx,  8(%rcx)
18 | 
19 | 	movq	%rbp,  16(%rcx)
20 | 	movq	%rbx, 24(%rcx)
21 | 	movq	%rsi, 32(%rcx)
22 | 	movq	%rdi, 40(%rcx)
23 | 	movq	%r15, 48(%rcx)
24 | 	movq	%r14, 56(%rcx)
25 | 	movq	%r13, 64(%rcx)
26 | 	movq	%r12, 72(%rcx)
27 | 	movq	%r11, 80(%rcx)
28 | 	movq	%r10, 88(%rcx)
29 | 	movq	%r9, 96(%rcx)
30 | 	movq	%r8, 104(%rcx)
31 | 
32 | 	movq	$0, %rax
33 | 	ret
34 | 
35 | ENTRY(jos_longjmp)
36 | 	// %eax is the jos_jmp_buf*
37 | 	// %edx is the return value
38 | 	movq     %rdi, %rax
39 | 	movq	 %rsi, %rdx
40 | 	movq	 0(%rax), %rcx	// %rip
41 | 	movq	 8(%rax), %rsp
42 | 	movq	 16(%rax), %rbp
43 | 	movq	24(%rax), %rbx
44 | 	movq	32(%rax), %rsi
45 | 	movq	40(%rax), %rdi
46 | 	movq	48(%rax), %r15
47 | 	movq	56(%rax), %r14
48 | 	movq	64(%rax), %r13
49 | 	movq	72(%rax), %r12
50 | 	movq	80(%rax), %r11
51 | 	movq	88(%rax), %r10
52 | 	movq	96(%rax), %r9
53 | 	movq	104(%rax), %r8
54 | 
55 | 	movq	%rdx, %rax
56 | 	jmp	*%rcx
57 | 
58 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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)(uint64_t), uint64_t arg);
16 | void thread_yield(void);
17 | void thread_halt(void);
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/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)(uint64_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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | }
14 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/slack.txt:
--------------------------------------------------------------------------------
1 | Late Hours Taken for Lab 1: 
2 | Late Hours Taken for Lab 2: 
3 | Late Hours Taken for Lab 3: 
4 | Late Hours Taken for Lab 4: 
5 | Late Hours Taken for Lab 5: 
6 | Late Hours Taken for Lab 6: 
7 | 
8 | 


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


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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/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*)0x800420000c, 100);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 0x8004000000!\n", *(unsigned*)0x8004000000);
 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/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*)0x8004000000 = 0;
 9 | }
10 | 
11 | 


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


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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("/bin/sh", "sh", (char*)0);
63 | 		if (r < 0) {
64 | 			cprintf("init: spawn sh: %e\n", r);
65 | 			continue;
66 | 		}
67 | 		cprintf("init waiting\n");
68 | 		wait(r);
69 | #ifdef VMM_GUEST
70 | 		break;
71 | #endif
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/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/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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(str1) + 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 | 
41 | 


--------------------------------------------------------------------------------
/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/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("/bin/hello", "hello", 0)) < 0)
 9 | 		panic("spawn(hello) failed: %e", r);
10 | }
11 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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/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("/bin/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/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("/bin/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/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 | 


--------------------------------------------------------------------------------
/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("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
 5 | OUTPUT_ARCH(i386:x86-64)
 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 | /* 	QUAD(__STAB_BEGIN__); */
48 | /* 	QUAD(__STAB_END__); */
49 | /* 	QUAD(__STABSTR_BEGIN__); */
50 | /* 	QUAD(__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)		/1* Force the linker to allocate space */
58 | /* 			   for this section *1/ */
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)		/1* Force the linker to allocate space */
66 | /* 			   for this section *1/ */
67 | /* } */
68 | 
69 | /DISCARD/ : {
70 |     *(.note.GNU-stack .comment)
71 | }
72 | }
73 | 


--------------------------------------------------------------------------------
/user/vmm.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | #include <inc/vmx.h>
 3 | #include <inc/elf.h>
 4 | #include <inc/ept.h>
 5 | #include <inc/stdio.h>
 6 | 
 7 | #define GUEST_KERN "/vmm/kernel"
 8 | #define GUEST_BOOT "/vmm/boot"
 9 | 
10 | #define JOS_ENTRY 0x7000
11 | 
12 | // Map a region of file fd into the guest at guest physical address gpa.
13 | // The file region to map should start at fileoffset and be length filesz.
14 | // The region to map in the guest should be memsz.  The region can span multiple pages.
15 | //
16 | // Return 0 on success, <0 on failure.
17 | //
18 | static int
19 | map_in_guest( envid_t guest, uintptr_t gpa, size_t memsz, 
20 | 	      int fd, size_t filesz, off_t fileoffset ) {
21 | 	/* Your code here */
22 | 	return -E_NO_SYS;
23 | 
24 | } 
25 | 
26 | // Read the ELF headers of kernel file specified by fname,
27 | // mapping all valid segments into guest physical memory as appropriate.
28 | //
29 | // Return 0 on success, <0 on error
30 | //
31 | // Hint: compare with ELF parsing in env.c, and use map_in_guest for each segment.
32 | static int
33 | copy_guest_kern_gpa( envid_t guest, char* fname ) {
34 | 
35 | 	/* Your code here */
36 | 	return -E_NO_SYS;
37 | }
38 | 
39 | void
40 | umain(int argc, char **argv) {
41 | 	int ret;
42 | 	envid_t guest;
43 | 	char filename_buffer[50];	//buffer to save the path 
44 | 	int vmdisk_number;
45 | 	int r;
46 | 	if ((ret = sys_env_mkguest( GUEST_MEM_SZ, JOS_ENTRY )) < 0) {
47 | 		cprintf("Error creating a guest OS env: %e\n", ret );
48 | 		exit();
49 | 	}
50 | 	guest = ret;
51 | 
52 | 	// Copy the guest kernel code into guest phys mem.
53 | 	if((ret = copy_guest_kern_gpa(guest, GUEST_KERN)) < 0) {
54 | 		cprintf("Error copying page into the guest - %d\n.", ret);
55 | 		exit();
56 | 	}
57 | 
58 | 	// Now copy the bootloader.
59 | 	int fd;
60 | 	if ((fd = open( GUEST_BOOT, O_RDONLY)) < 0 ) {
61 | 		cprintf("open %s for read: %e\n", GUEST_BOOT, fd );
62 | 		exit();
63 | 	}
64 | 
65 | 	// sizeof(bootloader) < 512.
66 | 	if ((ret = map_in_guest(guest, JOS_ENTRY, 512, fd, 512, 0)) < 0) {
67 | 		cprintf("Error mapping bootloader into the guest - %d\n.", ret);
68 | 		exit();
69 | 	}
70 | #ifndef VMM_GUEST	
71 | 	sys_vmx_incr_vmdisk_number();	//increase the vmdisk number
72 | 	//create a new guest disk image
73 | 	
74 | 	vmdisk_number = sys_vmx_get_vmdisk_number();
75 | 	snprintf(filename_buffer, 50, "/vmm/fs%d.img", vmdisk_number);
76 | 	
77 | 	cprintf("Creating a new virtual HDD at /vmm/fs%d.img\n", vmdisk_number);
78 |         r = copy("vmm/clean-fs.img", filename_buffer);
79 |         
80 |         if (r < 0) {
81 |         	cprintf("Create new virtual HDD failed: %e\n", r);
82 |         	exit();
83 |         }
84 |         
85 |         cprintf("Create VHD finished\n");
86 | #endif
87 | 	// Mark the guest as runnable.
88 | 	sys_env_set_status(guest, ENV_RUNNABLE);
89 | 	wait(guest);
90 | }
91 | 
92 | 
93 | 


--------------------------------------------------------------------------------
/user/vmmanager.c:
--------------------------------------------------------------------------------
 1 | #ifndef VMM_GUEST
 2 | #include <inc/lib.h>
 3 | 
 4 | void
 5 | umain(int argc, char **argv)
 6 | {
 7 | 	char *buf;
 8 | 	sys_vmx_list_vms();
 9 | 	buf = readline("Please select a VM to resume: ");
10 | 	while (!(strlen(buf) == 1
11 | 		&& buf[0] >= '1' 
12 | 		&& buf[0] <= '9')) {
13 | error:		cprintf("Please enter a correct vm number\n");
14 | 		buf = readline("Please select a VM to resume: ");
15 | 	}
16 | 	
17 | 	if (sys_vmx_sel_resume(buf[0] - '1' + 1)) {
18 | 		cprintf("Press Enter to Continue\n");
19 | 	}
20 | 	else {		
21 | 		goto error;
22 | 	}
23 | 	
24 | }
25 | #endif
26 | 
27 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/vmm/.gitignore:
--------------------------------------------------------------------------------
1 | guest
2 | 


--------------------------------------------------------------------------------
/vmm/Makefrag:
--------------------------------------------------------------------------------
 1 | 
 2 | $(GUESTDIR)/$(OBJDIR)/kern/kernel:
 3 | 	$(MAKE) GUEST_KERN=true
 4 | 
 5 | $(GUESTDIR)/$(OBJDIR)/boot/%.o: guest_boot/%.S
 6 | 	@echo + as $<
 7 | 	@mkdir -p $(@D)
 8 | 	$(V)$(CC) -nostdinc $(BOOT_CFLAGS) -c -o $@ $<
 9 | 
10 | $(GUESTDIR)/$(OBJDIR)/boot/boot: $(GUESTDIR)/$(OBJDIR)/boot/boot.o
11 | 	@echo + ld $(GUESTDIR)/$(OBJDIR)/boot/boot
12 | 	$(V)$(LD) $(BOOT_LDFLAGS) -N -e gboot_start -Ttext 0x7000 -o $@.out $^
13 | 	$(V)$(OBJDUMP) -S $@.out >$@.asm
14 | 	$(V)$(OBJCOPY) -S -O binary -j .text $@.out $@
15 | 	$(V)perl boot/sign.pl $(GUESTDIR)/$(OBJDIR)/boot/boot
16 | 


--------------------------------------------------------------------------------
/vmm/ept.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef JOS_VMX_EPT_H
 3 | #define JOS_VMX_EPT_H
 4 | 
 5 | #include <inc/mmu.h>
 6 | #include <vmm/vmx.h>
 7 | #include <inc/ept.h>
 8 | 
 9 | typedef uint64_t epte_t;
10 | 
11 | int ept_map_hva2gpa( epte_t* eptrt, void* hva, void* gpa, int perm, int overwrite );
12 | int ept_alloc_static(epte_t *eptrt, struct VmxGuestInfo *ginfo);
13 | void free_guest_mem(epte_t* eptrt);
14 | void ept_gpa2hva(epte_t* eptrt, void *gpa, void **hva);
15 | int ept_page_insert(epte_t* eptrt, struct PageInfo* pp, void* gpa, int perm);
16 | 
17 | #define EPT_LEVELS 4
18 | 
19 | #define VMX_EPT_FAULT_READ	0x01
20 | #define VMX_EPT_FAULT_WRITE	0x02
21 | #define VMX_EPT_FAULT_INS	0x04
22 | 
23 | 
24 | #define EPTE_ADDR	(~(PGSIZE - 1))
25 | #define EPTE_FLAGS	(PGSIZE - 1)
26 | 
27 | #define ADDR_TO_IDX(pa, n) \
28 |     ((((uint64_t) (pa)) >> (12 + 9 * (n))) & ((1 << 9) - 1))
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/vmm/jos_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 gboot_start
13 | gboot_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 | # Switch from real to protected mode, using a bootstrap GDT
25 | # and segment translation that makes virtual addresses 
26 | # identical to their physical addresses, so that the 
27 | # effective memory map does not change during the switch.
28 | lgdt    gdtdesc
29 | movl    %cr0, %eax
30 | orl     $CR0_PE_ON, %eax
31 | movl    %eax, %cr0
32 | 
33 | # Jump to next instruction, but in 32-bit code segment.
34 | # Switches processor into 32-bit mode.
35 | ljmp    $PROT_MODE_CSEG, $protcseg
36 | 
37 | .code32                     # Assemble for 32-bit mode
38 | protcseg:
39 | # Set up the protected-mode data segment registers
40 | movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
41 | movw    %ax, %ds                # -> DS: Data Segment
42 | movw    %ax, %es                # -> ES: Extra Segment
43 | movw    %ax, %fs                # -> FS
44 | movw    %ax, %gs                # -> GS
45 | movw    %ax, %ss                # -> SS: Stack Segment
46 | 
47 | mov $0x100000,%eax
48 | jmp *%eax
49 | 
50 | # If bootmain returns (it shouldn't), loop.
51 | spin:
52 | jmp spin
53 | 
54 | # Bootstrap GDT
55 | .p2align 2                                # force 4 byte alignment
56 | gdt:
57 | SEG_NULL				# null seg
58 | SEG(STA_X|STA_R, 0x0, 0xffffffff)	# code seg
59 | SEG(STA_W, 0x0, 0xffffffff)	        # data seg
60 | gdtdesc:
61 | .word   0x17                           # sizeof(gdt) - 1
62 | .long   gdt                             # address gdt
63 | 


--------------------------------------------------------------------------------
/vmm/vmexits.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <inc/trap.h>
 3 | bool handle_interrupt_window(struct Trapframe *tf, struct VmxGuestInfo *ginfo, uint32_t host_vector);
 4 | bool handle_interrupts(struct Trapframe *tf, struct VmxGuestInfo *ginfo, uint32_t host_vector);
 5 | bool handle_eptviolation(uint64_t *eptrt, struct VmxGuestInfo *ginfo);
 6 | bool handle_rdmsr(struct Trapframe *tf, struct VmxGuestInfo *ginfo);
 7 | bool handle_wrmsr(struct Trapframe *tf, struct VmxGuestInfo *ginfo);
 8 | bool handle_ioinstr(struct Trapframe *tf, struct VmxGuestInfo *ginfo);
 9 | bool handle_cpuid(struct Trapframe *tf, struct VmxGuestInfo *ginfo);
10 | bool handle_vmcall(struct Trapframe *tf, struct VmxGuestInfo *gInfo, uint64_t *eptrt );
11 | 


--------------------------------------------------------------------------------
/vmm/vmx_asm.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_VMM_ASM_H
 2 | #define JOS_VMM_ASM_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/types.h>
 8 | 
 9 | static __inline uint8_t vmxon( physaddr_t vmxon_region ) __attribute((always_inline));
10 | static __inline uint8_t vmclear( physaddr_t vmcs_region ) __attribute((always_inline));
11 | static __inline uint8_t vmptrld( physaddr_t vmcs_region ) __attribute((always_inline));
12 | 
13 | 
14 | static __inline uint8_t
15 | vmxon( physaddr_t vmxon_region ) {
16 | 	uint8_t error = 0;
17 | 
18 |     __asm __volatile("clc; vmxon %1; setna %0"
19 |             : "=q"( error ) : "m" ( vmxon_region ): "cc" );
20 |     return error;
21 | }
22 | 
23 | static __inline uint8_t
24 | vmclear( physaddr_t vmcs_region ) {
25 | 	uint8_t error = 0;
26 | 
27 |     __asm __volatile("clc; vmclear %1; setna %0"
28 |             : "=q"( error ) : "m" ( vmcs_region ) : "cc");
29 |     return error;
30 | }
31 | 
32 | static __inline uint8_t
33 | vmptrld( physaddr_t vmcs_region ) {
34 | 	uint8_t error = 0;
35 | 
36 |     __asm __volatile("clc; vmptrld %1; setna %0"
37 |             : "=q"( error ) : "m" ( vmcs_region ) : "cc");
38 |     return error;
39 | }
40 | 
41 | static __inline uint8_t
42 | vmlaunch() {
43 | 	uint8_t error = 0;
44 | 
45 |     __asm __volatile("clc; vmlaunch; setna %0"
46 |             : "=q"( error ) :: "cc");
47 |     return error;
48 | }
49 | 
50 | #endif
51 | 


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