├── .dir-locals.el
├── .gdbinit.tmpl
├── .gitignore
├── CODING
├── GNUmakefile
├── README.md
├── boot
    ├── Makefrag
    ├── boot.S
    ├── main.c
    └── sign.pl
├── conf
    ├── env.mk
    └── lab.mk
├── fs
    ├── Makefrag
    ├── bc.c
    ├── fs.c
    ├── fs.h
    ├── fsformat.c
    ├── ide.c
    ├── index.html
    ├── lorem
    ├── motd
    ├── newmotd
    ├── script
    ├── serv.c
    ├── test.c
    ├── testshell.key
    └── testshell.sh
├── grade-lab1
├── grade-lab2
├── grade-lab3
├── grade-lab4
├── grade-lab5
├── grade-lab6
├── gradelib.py
├── inc
    ├── COPYRIGHT
    ├── args.h
    ├── assert.h
    ├── elf.h
    ├── env.h
    ├── error.h
    ├── fd.h
    ├── fs.h
    ├── kbdreg.h
    ├── lib.h
    ├── malloc.h
    ├── memlayout.h
    ├── mmu.h
    ├── ns.h
    ├── partition.h
    ├── stab.h
    ├── stdarg.h
    ├── stdio.h
    ├── string.h
    ├── syscall.h
    ├── trap.h
    ├── types.h
    └── x86.h
├── kern
    ├── COPYRIGHT
    ├── Makefrag
    ├── console.c
    ├── console.h
    ├── cpu.h
    ├── e1000.c
    ├── e1000.h
    ├── entry.S
    ├── entrypgdir.c
    ├── env.c
    ├── env.h
    ├── init.c
    ├── kclock.c
    ├── kclock.h
    ├── kdebug.c
    ├── kdebug.h
    ├── kernel.ld
    ├── lapic.c
    ├── monitor.c
    ├── monitor.h
    ├── mpconfig.c
    ├── mpentry.S
    ├── 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
└── 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
    ├── faultio.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
    ├── spawnfaultio.c
    ├── spawnhello.c
    ├── spawninit.c
    ├── spin.c
    ├── stresssched.c
    ├── testbss.c
    ├── testfdsharing.c
    ├── testfile.c
    ├── testkbd.c
    ├── testmalloc.c
    ├── testpipe.c
    ├── testpiperace.c
    ├── testpiperace2.c
    ├── testptelibrary.c
    ├── testpteshare.c
    ├── testshell.c
    ├── testtime.c
    ├── user.ld
    ├── writemotd.c
    └── yield.c


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


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


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


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # mit 6.828 2018
 2 | 
 3 | ---
 4 | 本仓库是mit 6.828 2018年秋季操作系统课程的全部实现，课程主页：[https://pdos.csail.mit.edu/6.828/2018/schedule.html][1]。本实验总共分为6个lab，每个lab的解析和总结记录在blog中。上完这门课大概花了280多个番茄时，收获很大，希望更多的人能接触这类优秀的课程。
 5 | 
 6 | 
 7 | 1. [lab1:C, Assembly, Tools, and Bootstrapping][2]
 8 | 2. [lab2:Memory management][3]
 9 | 3. [lab3:User Environments][4]
10 | 4. [lab4:Preemptive Multitasking][5]
11 | 5. [lab5:File system, Spawn and Shell][6]
12 | 6. [lab6:Network Driver][7]
13 | 
14 | Enjoy it~
15 | 
16 | 
17 |   [1]: https://pdos.csail.mit.edu/6.828/2018/schedule.html
18 |   [2]: https://www.cnblogs.com/gatsby123/p/9759153.html
19 |   [3]: https://www.cnblogs.com/gatsby123/p/9832223.html
20 |   [4]: https://www.cnblogs.com/gatsby123/p/9838304.html
21 |   [5]: https://www.cnblogs.com/gatsby123/p/9930630.html
22 |   [6]: https://www.cnblogs.com/gatsby123/p/9950705.html
23 |   [7]: https://www.cnblogs.com/gatsby123/p/10080311.html


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


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


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


--------------------------------------------------------------------------------
/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=6
2 | PACKAGEDATE=Wed Oct 24 20:46:05 EDT 2018
3 | 


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


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


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


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


--------------------------------------------------------------------------------
/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/newmotd:
--------------------------------------------------------------------------------
1 | This is the NEW message of the day!
2 | 
3 | 


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


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


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


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


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


--------------------------------------------------------------------------------
/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 | 	uint32_t e_entry;
13 | 	uint32_t e_phoff;	//program header offset
14 | 	uint32_t e_shoff;	//section header offset
15 | 	uint32_t e_flags;
16 | 	uint16_t e_ehsize;	//this header size
17 | 	uint16_t e_phentsize;	//program header size
18 | 	uint16_t e_phnum;		//number of program headers
19 | 	uint16_t e_shentsize;	//section header size
20 | 	uint16_t e_shnum;		//number of section headers
21 | 	uint16_t e_shstrndx;	//section header string table idnex
22 | };
23 | 
24 | struct Proghdr {		//program header结构，《程序员自我修养》p165
25 | 	uint32_t p_type;	//类型，LOAD类型的常量为1
26 | 	uint32_t p_offset;	//该Segment在文件中的偏移
27 | 	uint32_t p_va;		//该Segment第一个字节在虚拟地址空间的起始位置
28 | 	uint32_t p_pa;		//该Segment的物理装载地址
29 | 	uint32_t p_filesz;	//在ELF文件中的大小
30 | 	uint32_t p_memsz;	//在虚拟地址空间占用的大小，可能大于p_filez，比如BSS
31 | 	uint32_t p_flags;	//权限属性
32 | 	uint32_t p_align;	//对齐属性
33 | };
34 | 
35 | struct Secthdr {			//段表的每一项结构
36 | 	uint32_t sh_name;		//段名
37 | 	uint32_t sh_type;		//段的类型
38 | 	uint32_t sh_flags;		//段的标志
39 | 	uint32_t sh_addr;		//虚拟地址
40 | 	uint32_t sh_offset;		//该段在文件中的偏移
41 | 	uint32_t sh_size;		//段的长度
42 | 	uint32_t sh_link;		//段链接信息
43 | 	uint32_t sh_info;		//段链接信息
44 | 	uint32_t sh_addralign;	//短地址对齐
45 | 	uint32_t sh_entsize;	//Section Entry Size
46 | };
47 | 
48 | // Values for Proghdr::p_type
49 | #define ELF_PROG_LOAD		1
50 | 
51 | // Flag bits for Proghdr::p_flags
52 | #define ELF_PROG_FLAG_EXEC	1
53 | #define ELF_PROG_FLAG_WRITE	2
54 | #define ELF_PROG_FLAG_READ	4
55 | 
56 | // Values for Secthdr::sh_type	//段类型，对应Secthdr的sh_type字段
57 | #define ELF_SHT_NULL		0	//无效段
58 | #define ELF_SHT_PROGBITS	1	//代码段或者代码段
59 | #define ELF_SHT_SYMTAB		2	//符号表
60 | #define ELF_SHT_STRTAB		3	//字符串表
61 | 
62 | // Values for Secthdr::sh_name
63 | #define ELF_SHN_UNDEF		0
64 | 
65 | #endif /* !JOS_INC_ELF_H */
66 | 


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


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


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


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


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


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


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


--------------------------------------------------------------------------------
/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/console.c
11 | void	cputchar(int c);
12 | int	getchar(void);
13 | int	iscons(int fd);
14 | 
15 | // lib/printfmt.c
16 | void	printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...);
17 | void	vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list);
18 | int	snprintf(char *str, int size, const char *fmt, ...);
19 | int	vsnprintf(char *str, int size, const char *fmt, va_list);
20 | 
21 | // lib/printf.c
22 | int	cprintf(const char *fmt, ...);
23 | int	vcprintf(const char *fmt, va_list);
24 | 
25 | // lib/fprintf.c
26 | int	printf(const char *fmt, ...);
27 | int	fprintf(int fd, const char *fmt, ...);
28 | int	vfprintf(int fd, const char *fmt, va_list);
29 | 
30 | // lib/readline.c
31 | char*	readline(const char *prompt);
32 | 
33 | #endif /* !JOS_INC_STDIO_H */
34 | 


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


--------------------------------------------------------------------------------
/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_pkt_send,
22 | 	SYS_pkt_recv,
23 | 	NSYSCALLS
24 | };
25 | 
26 | #endif /* !JOS_INC_SYSCALL_H */
27 | 


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


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


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


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


--------------------------------------------------------------------------------
/kern/kclock.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 (between 1MB and 16MB) */
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 38 and 39: extended memory size (between 16MB and 4G) */
23 | #define NVRAM_EXT16LO	(MC_NVRAM_START + 38)	/* low byte; RTC off. 0x34 */
24 | #define NVRAM_EXT16HI	(MC_NVRAM_START + 39)	/* high byte; RTC off. 0x35 */
25 | 
26 | unsigned mc146818_read(unsigned reg);
27 | void mc146818_write(unsigned reg, unsigned datum);
28 | 
29 | #endif	// !JOS_KERN_KCLOCK_H
30 | 


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


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


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


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


--------------------------------------------------------------------------------
/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 | 
21 | 	vprintfmt((void*)putch, &cnt, fmt, ap);
22 | 	return cnt;
23 | }
24 | 
25 | int
26 | cprintf(const char *fmt, ...)
27 | {
28 | 	va_list ap;
29 | 	int cnt;
30 | 
31 | 	va_start(ap, fmt);
32 | 	cnt = vcprintf(fmt, ap);
33 | 	va_end(ap);
34 | 
35 | 	return cnt;
36 | }
37 | 
38 | 


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


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


--------------------------------------------------------------------------------
/kern/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 | 
 7 | 
 8 | 
 9 | ###################################################################
10 | # exceptions/interrupts
11 | ###################################################################
12 | 
13 | /* TRAPHANDLER defines a globally-visible function for handling a trap.
14 |  * It pushes a trap number onto the stack, then jumps to _alltraps.
15 |  * Use TRAPHANDLER for traps where the CPU automatically pushes an error code.
16 |  *
17 |  * You shouldn't call a TRAPHANDLER function from C, but you may
18 |  * need to _declare_ one in C (for instance, to get a function pointer
19 |  * during IDT setup).  You can declare the function with
20 |  *   void NAME();
21 |  * where NAME is the argument passed to TRAPHANDLER.
22 |  */
23 | #define TRAPHANDLER(name, num)						\
24 | 	.globl name;		/* define global symbol for 'name' */	\
25 | 	.type name, @function;	/* symbol type is function */		\
26 | 	.align 2;		/* align function definition */		\
27 | 	name:			/* function starts here */		\
28 | 	pushl $(num);							\
29 | 	jmp _alltraps
30 | 
31 | /* Use TRAPHANDLER_NOEC for traps where the CPU doesn't push an error code.
32 |  * It pushes a 0 in place of the error code, so the trap frame has the same
33 |  * format in either case.
34 |  */
35 | #define TRAPHANDLER_NOEC(name, num)					\
36 | 	.globl name;							\
37 | 	.type name, @function;						\
38 | 	.align 2;							\
39 | 	name:								\
40 | 	pushl $0;							\
41 | 	pushl $(num);							\
42 | 	jmp _alltraps
43 | 
44 | .text
45 | 
46 | /*
47 |  * Lab 3: Your code here for generating entry points for the different traps.
48 |  */
49 | 	TRAPHANDLER_NOEC(th0, 0)
50 | 	TRAPHANDLER_NOEC(th1, 1)
51 | 	TRAPHANDLER_NOEC(th3, 3)
52 | 	TRAPHANDLER_NOEC(th4, 4)
53 | 	TRAPHANDLER_NOEC(th5, 5)
54 | 	TRAPHANDLER_NOEC(th6, 6)
55 | 	TRAPHANDLER_NOEC(th7, 7)
56 | 	TRAPHANDLER(th8, 8)
57 | 	TRAPHANDLER_NOEC(th9, 9)
58 | 	TRAPHANDLER(th10, 10)
59 | 	TRAPHANDLER(th11, 11)
60 | 	TRAPHANDLER(th12, 12)
61 | 	TRAPHANDLER(th13, 13)
62 | 	TRAPHANDLER(th14, 14)
63 | 	TRAPHANDLER_NOEC(th16, 16)
64 | 
65 | 	TRAPHANDLER_NOEC(th32, IRQ_OFFSET)
66 | 	TRAPHANDLER_NOEC(th33, IRQ_OFFSET + 1)
67 | 	TRAPHANDLER_NOEC(th34, IRQ_OFFSET + 2)
68 | 	TRAPHANDLER_NOEC(th35, IRQ_OFFSET + 3)
69 | 	TRAPHANDLER_NOEC(th36, IRQ_OFFSET + 4)
70 | 	TRAPHANDLER_NOEC(th37, IRQ_OFFSET + 5)
71 | 	TRAPHANDLER_NOEC(th38, IRQ_OFFSET + 6)
72 | 	TRAPHANDLER_NOEC(th39, IRQ_OFFSET + 7)
73 | 	TRAPHANDLER_NOEC(th40, IRQ_OFFSET + 8)
74 | 	TRAPHANDLER_NOEC(th41, IRQ_OFFSET + 9)
75 | 	TRAPHANDLER_NOEC(th42, IRQ_OFFSET + 10)
76 | 	TRAPHANDLER_NOEC(th43, IRQ_OFFSET + 11)
77 | 	TRAPHANDLER_NOEC(th44, IRQ_OFFSET + 12)
78 | 	TRAPHANDLER_NOEC(th45, IRQ_OFFSET + 13)
79 | 	TRAPHANDLER_NOEC(th46, IRQ_OFFSET + 14)
80 | 	TRAPHANDLER_NOEC(th47, IRQ_OFFSET + 15)
81 | 
82 | 	TRAPHANDLER_NOEC(th_syscall, T_SYSCALL)
83 | 
84 | /*
85 |  * Lab 3: Your code here for _alltraps
86 |  */
87 | 	//参考inc/trap.h中的Trapframe结构。tf_ss，tf_esp，tf_eflags，tf_cs，tf_eip，tf_err由处理器压入，所以现在只需要压入剩下寄存器（%ds,%es,通用寄存器）
88 | 	//切换到内核数据段
89 | 	_alltraps:
90 | 	pushl %ds
91 | 	pushl %es
92 | 	pushal
93 | 	pushl $GD_KD
94 | 	popl %ds
95 | 	pushl $GD_KD
96 | 	popl %es
97 | 	pushl %esp				//压入trap()的参数tf，%esp指向Trapframe结构的起始地址
98 | 	call trap
99 | 


--------------------------------------------------------------------------------
/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+(UVPT>>12)*4)
15 | 
16 | 
17 | // Entrypoint - this is where the kernel (or our parent environment)
18 | // starts us running when we are initially loaded into a new environment.
19 | .text
20 | .globl _start
21 | _start:
22 | 	// See if we were started with arguments on the stack
23 | 	cmpl $USTACKTOP, %esp
24 | 	jne args_exist
25 | 
26 | 	// If not, push dummy argc/argv arguments.
27 | 	// This happens when we are loaded by the kernel,
28 | 	// because the kernel does not know about passing arguments.
29 | 	pushl $0
30 | 	pushl $0
31 | 
32 | args_exist:
33 | 	call libmain
34 | 1:	jmp 1b
35 | 
36 | 


--------------------------------------------------------------------------------
/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/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 | 
 5 | // Receive a value via IPC and return it.
 6 | // If 'pg' is nonnull, then any page sent by the sender will be mapped at
 7 | //	that address.
 8 | // If 'from_env_store' is nonnull, then store the IPC sender's envid in
 9 | //	*from_env_store.
10 | // If 'perm_store' is nonnull, then store the IPC sender's page permission
11 | //	in *perm_store (this is nonzero iff a page was successfully
12 | //	transferred to 'pg').
13 | // If the system call fails, then store 0 in *fromenv and *perm (if
14 | //	they're nonnull) and return the error.
15 | // Otherwise, return the value sent by the sender
16 | //
17 | // Hint:
18 | //   Use 'thisenv' to discover the value and who sent it.
19 | //   If 'pg' is null, pass sys_ipc_recv a value that it will understand
20 | //   as meaning "no page".  (Zero is not the right value, since that's
21 | //   a perfectly valid place to map a page.)
22 | int32_t
23 | ipc_recv(envid_t *from_env_store, void *pg, int *perm_store)
24 | {
25 | 	// LAB 4: Your code here.
26 | 	if (pg == NULL) {
27 | 		pg = (void *)-1;
28 | 	}
29 | 	int r = sys_ipc_recv(pg);
30 | 	if (r < 0) {				//系统调用失败
31 | 		if (from_env_store) *from_env_store = 0;
32 | 		if (perm_store) *perm_store = 0;
33 | 		return r;
34 | 	}
35 | 	if (from_env_store)
36 | 		*from_env_store = thisenv->env_ipc_from;
37 | 	if (perm_store)
38 | 		*perm_store = thisenv->env_ipc_perm;
39 | 	return thisenv->env_ipc_value;
40 | }
41 | 
42 | // Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'.
43 | // This function keeps trying until it succeeds.
44 | // It should panic() on any error other than -E_IPC_NOT_RECV.
45 | //
46 | // Hint:
47 | //   Use sys_yield() to be CPU-friendly.
48 | //   If 'pg' is null, pass sys_ipc_try_send a value that it will understand
49 | //   as meaning "no page".  (Zero is not the right value.)
50 | void
51 | ipc_send(envid_t to_env, uint32_t val, void *pg, int perm)
52 | {
53 | 	// LAB 4: Your code here.
54 | 	if (pg == NULL) {
55 | 		pg = (void *)-1;
56 | 	}
57 | 	int r;
58 | 	while(1) {
59 | 		r = sys_ipc_try_send(to_env, val, pg, perm);
60 | 		if (r == 0) {		//发送成功
61 | 			return;
62 | 		} else if (r == -E_IPC_NOT_RECV) {	//接收进程没有准备好
63 | 			sys_yield();
64 | 		} else {			//其它错误
65 | 			panic("ipc_send():%e", r);
66 | 		}
67 | 	}
68 | }
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 | 	return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/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 | 	envid_t envid = sys_getenvid();
17 | 	thisenv = envs + ENVX(envid);
18 | 
19 | 	// save the name of the program so that panic() can use it
20 | 	if (argc > 0)
21 | 		binaryname = argv[0];
22 | 
23 | 	// call user main routine
24 | 	umain(argc, argv);
25 | 
26 | 	// exit gracefully
27 | 	exit();
28 | }
29 | 
30 | 


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


--------------------------------------------------------------------------------
/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 | 		int r = sys_page_alloc(0, (void *)(UXSTACKTOP-PGSIZE), PTE_W | PTE_U | PTE_P);	//为当前进程分配异常栈
33 | 		if (r < 0) {
34 | 			panic("set_pgfault_handler:sys_page_alloc failed");;
35 | 		}
36 | 		sys_env_set_pgfault_upcall(0, _pgfault_upcall);		//系统调用，设置进程的env_pgfault_upcall属性
37 | 	}
38 | 
39 | 	// Save handler pointer for assembly to call.
40 | 	_pgfault_handler = handler;
41 | }
42 | 


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


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


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


--------------------------------------------------------------------------------
/net/input.c:
--------------------------------------------------------------------------------
 1 | #include "ns.h"
 2 | #include "kern/e1000.h"
 3 | 
 4 | extern union Nsipc nsipcbuf;
 5 | 
 6 | 
 7 |  void
 8 | sleep(int msec)
 9 | {
10 |        unsigned now = sys_time_msec();
11 |        unsigned end = now + msec;
12 | 
13 |        if ((int)now < 0 && (int)now > -MAXERROR)
14 |                panic("sys_time_msec: %e", (int)now);
15 | 
16 |        while (sys_time_msec() < end)
17 |                sys_yield();
18 | }
19 | 
20 | void
21 | input(envid_t ns_envid)
22 | {
23 | 	binaryname = "ns_input";
24 | 
25 | 	// LAB 6: Your code here:
26 | 	// 	- read a packet from the device driver
27 | 	//	- send it to the network server
28 | 	// Hint: When you IPC a page to the network server, it will be
29 | 	// reading from it for a while, so don't immediately receive
30 | 	// another packet in to the same physical page.
31 | 
32 |   size_t len;
33 |   char buf[RX_PKT_SIZE];
34 |   while (1) {
35 | 		if (sys_pkt_recv(buf, &len) < 0) {
36 | 			continue;
37 |     }
38 | 		memcpy(nsipcbuf.pkt.jp_data, buf, len);
39 | 		nsipcbuf.pkt.jp_len = len;
40 |     ipc_send(ns_envid, NSREQ_INPUT, &nsipcbuf, PTE_P|PTE_U|PTE_W);
41 | 		sleep(50);
42 |   }
43 | }
44 | 


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


--------------------------------------------------------------------------------
/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/netbuf.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_NETBUF_H__
33 | #define __LWIP_NETBUF_H__
34 | 
35 | #include "lwip/opt.h"
36 | #include "lwip/pbuf.h"
37 | 
38 | #ifdef __cplusplus
39 | extern "C" {
40 | #endif
41 | 
42 | struct netbuf {
43 |   struct pbuf *p, *ptr;
44 |   struct ip_addr *addr;
45 |   u16_t port;
46 | };
47 | 
48 | /* Network buffer functions: */
49 | struct netbuf *   netbuf_new      (void);
50 | void              netbuf_delete   (struct netbuf *buf);
51 | void *            netbuf_alloc    (struct netbuf *buf, u16_t size);
52 | void              netbuf_free     (struct netbuf *buf);
53 | err_t             netbuf_ref      (struct netbuf *buf,
54 |            const void *dataptr, u16_t size);
55 | void              netbuf_chain    (struct netbuf *head,
56 |            struct netbuf *tail);
57 | 
58 | u16_t             netbuf_len      (struct netbuf *buf);
59 | err_t             netbuf_data     (struct netbuf *buf,
60 |            void **dataptr, u16_t *len);
61 | s8_t              netbuf_next     (struct netbuf *buf);
62 | void              netbuf_first    (struct netbuf *buf);
63 | 
64 | 
65 | #define netbuf_copy_partial(buf, dataptr, len, offset) \
66 |   pbuf_copy_partial((buf)->p, (dataptr), (len), (offset))
67 | #define netbuf_copy(buf,dataptr,len) netbuf_copy_partial(buf, dataptr, len, 0)
68 | #define netbuf_len(buf)              ((buf)->p->tot_len)
69 | #define netbuf_fromaddr(buf)         ((buf)->addr)
70 | #define netbuf_fromport(buf)         ((buf)->port)
71 | 
72 | #ifdef __cplusplus
73 | }
74 | #endif
75 | 
76 | #endif /* __LWIP_NETBUF_H__ */
77 | 


--------------------------------------------------------------------------------
/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 |     uint32_t jb_eip;
10 |     uint32_t jb_esp;
11 |     uint32_t jb_ebp;
12 |     uint32_t jb_ebx;
13 |     uint32_t jb_esi;
14 |     uint32_t jb_edi;
15 | };
16 | 
17 | #endif
18 | 


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


--------------------------------------------------------------------------------
/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)(uint32_t), uint32_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)(uint32_t);
24 |     uint32_t		tc_arg;
25 |     struct jos_jmp_buf	tc_jb;
26 |     volatile uint32_t	*tc_wait_addr;
27 |     volatile char	tc_wakeup;
28 |     void		(*tc_onhalt[THREAD_NUM_ONHALT])(thread_id_t);
29 |     int			tc_nonhalt;
30 |     struct thread_context *tc_queue_link;
31 | };
32 | 
33 | static inline void 
34 | threadq_init(struct thread_queue *tq)
35 | {
36 |     tq->tq_first = 0;
37 |     tq->tq_last = 0;
38 | }
39 | 
40 | static inline void
41 | threadq_push(struct thread_queue *tq, struct thread_context *tc)
42 | {
43 |     tc->tc_queue_link = 0;
44 |     if (!tq->tq_first) {
45 | 	tq->tq_first = tc;
46 | 	tq->tq_last = tc;
47 |     } else {
48 | 	tq->tq_last->tc_queue_link = tc;
49 | 	tq->tq_last = tc;
50 |     }
51 | }
52 | 
53 | static inline struct thread_context *
54 | threadq_pop(struct thread_queue *tq)
55 | {
56 |     if (!tq->tq_first)
57 | 	return 0;
58 | 
59 |     struct thread_context *tc = tq->tq_first;
60 |     tq->tq_first = tc->tc_queue_link;
61 |     tc->tc_queue_link = 0;
62 |     return tc;
63 | }
64 | 
65 | #endif
66 | 


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


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


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


--------------------------------------------------------------------------------
/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 | #include "inc/lib.h"
 3 | 
 4 | extern union Nsipc nsipcbuf;
 5 | 
 6 | void
 7 | output(envid_t ns_envid)
 8 | {
 9 | 	binaryname = "ns_output";
10 | 
11 | 	// LAB 6: Your code here:
12 | 	// 	- read a packet from the network server
13 | 	//	- send the packet to the device driver
14 | 	uint32_t whom;
15 | 	int perm;
16 | 	int32_t req;
17 | 
18 | 	while (1) {
19 | 		req = ipc_recv((envid_t *)&whom, &nsipcbuf, &perm);
20 | 		if (req != NSREQ_OUTPUT) {
21 | 			cprintf("not a nsreq output\n");
22 | 			continue;
23 | 		}
24 | 
25 |     	struct jif_pkt *pkt = &(nsipcbuf.pkt);
26 |     	while (sys_pkt_send(pkt->jp_data, pkt->jp_len) < 0) {
27 |        		sys_yield();
28 |     	}	
29 | 	}
30 | }
31 | 


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


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


--------------------------------------------------------------------------------
/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)	//这里第三个参数0代表当前用户环境，具体看envid2env()实现。
34 | 		panic("sys_page_map: %e", r);				//效果是使当前环境UTEMP指向和dstenv环境addr相同的内存处
35 | 	memmove(UTEMP, addr, PGSIZE);					//将当前环境地址addr处的一页拷贝到当前环境地址UTMEP处（当前环境地址UTEMP和dstenv环境地址addr共享同一物理页）
36 | 	if ((r = sys_page_unmap(0, UTEMP)) < 0)			//效果就是当前环境地址addr和dstenv环境地址addr指向的一页的内容是一样的，但是它们不是同一物理页
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*)0xf010000c, 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);	//虽然0xCafeB000开始的页已经分配，但是将this string was faulted in at %x
16 | }																			//写到0xCafeBffe地址处还是会超出一页，引发缺页中断，所以还需分配0xCafeC000开始的页
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/faultio.c:
--------------------------------------------------------------------------------
 1 | // test user-level fault handler -- alloc pages to fix faults
 2 | 
 3 | #include <inc/lib.h>
 4 | #include <inc/x86.h>
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 |         int x, r;
10 | 	int nsecs = 1;
11 | 	int secno = 0;
12 | 	int diskno = 1;
13 | 
14 | 	if (read_eflags() & FL_IOPL_3)
15 | 		cprintf("eflags wrong\n");
16 | 
17 | 	// this outb to select disk 1 should result in a general protection
18 | 	// fault, because user-level code shouldn't be able to use the io space.
19 | 	outb(0x1F6, 0xE0 | (1<<4));
20 | 	uint16_t cs = read_cs();
21 | 	cprintf("iopl = %d, cs = %d\n", read_eflags() & FL_IOPL_3, cs);
22 |         cprintf("%s: made it here --- bug\n");
23 | }
24 | 


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


--------------------------------------------------------------------------------
/user/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("/sh", "sh", (char*)0);
63 | 		if (r < 0) {
64 | 			cprintf("init: spawn sh: %e\n", r);
65 | 			continue;
66 | 		}
67 | 		wait(r);
68 | 	}
69 | }
70 | 


--------------------------------------------------------------------------------
/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 NENV 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 NENV 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(str2) + 1);
25 | 		ipc_send(who, 0, TEMP_ADDR_CHILD, PTE_P | PTE_W | PTE_U);
26 | 		return;
27 | 	}
28 | 
29 | 	// Parent
30 | 	sys_page_alloc(thisenv->env_id, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
31 | 	memcpy(TEMP_ADDR, str1, strlen(str1) + 1);
32 | 	ipc_send(who, 0, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
33 | 
34 | 	ipc_recv(&who, TEMP_ADDR, 0);
35 | 	cprintf("%x got message: %s\n", who, TEMP_ADDR);
36 | 	if (strncmp(TEMP_ADDR, str2, strlen(str2)) == 0)
37 | 		cprintf("parent received correct message\n");
38 | 	return;
39 | }
40 | 


--------------------------------------------------------------------------------
/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/spawnfaultio.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("faultio", "faultio", 0)) < 0)
 9 | 		panic("spawn(faultio) failed: %e", r);
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("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)		//VA指向的物理页是共享的
19 | 		panic("sys_page_alloc: %e", r);
20 | 
21 | 	// check fork
22 | 	if ((r = fork()) < 0)				//在fork()时，子进程和父进程共享标识PTE_SHARE的页
23 | 		panic("fork: %e", r);
24 | 	if (r == 0) {						//子进程
25 | 		strcpy(VA, msg);				//向子进程的VA虚拟地址处拷贝msg
26 | 		exit();
27 | 	}
28 | 	wait(r);				//等子进程执行完毕
29 | 	cprintf("fork handles PTE_SHARE %s\n", strcmp(VA, msg) == 0 ? "right" : "wrong");	//父进程检查VA虚拟地址处是否也能感受到子进程写入的msg字符串
30 | 
31 | 	// check spawn
32 | 	if ((r = spawnl("/testpteshare", "testpteshare", "arg", 0)) < 0)		
33 | 		panic("spawn: %e", r);
34 | 	wait(r);
35 | 	cprintf("spawn handles PTE_SHARE %s\n", strcmp(VA, msg2) == 0 ? "right" : "wrong");
36 | 
37 | 	breakpoint();
38 | }
39 | 
40 | void
41 | childofspawn(void)
42 | {
43 | 	strcpy(VA, msg2);
44 | 	exit();
45 | }
46 | 


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


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


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


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