├── .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
    ├── lorem
    ├── motd
    ├── newmotd
    ├── script
    ├── serv.c
    ├── test.c
    ├── testshell.key
    └── testshell.sh
├── grade-lab1
├── grade-lab2
├── grade-lab3
├── grade-lab4
├── grade-lab5
├── gradelib.py
├── inc
    ├── COPYRIGHT
    ├── args.h
    ├── assert.h
    ├── elf.h
    ├── env.h
    ├── error.h
    ├── fd.h
    ├── fs.h
    ├── kbdreg.h
    ├── lib.h
    ├── memlayout.h
    ├── mmu.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
    ├── 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
    ├── picirq.c
    ├── picirq.h
    ├── pmap.c
    ├── pmap.h
    ├── printf.c
    ├── sched.c
    ├── sched.h
    ├── spinlock.c
    ├── spinlock.h
    ├── syscall.c
    ├── syscall.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
    ├── pageref.c
    ├── panic.c
    ├── pfentry.S
    ├── pgfault.c
    ├── pipe.c
    ├── printf.c
    ├── printfmt.c
    ├── readline.c
    ├── spawn.c
    ├── string.c
    ├── syscall.c
    └── wait.c
├── mergedep.pl
├── reports
    ├── Lab1.md
    ├── Lab2.md
    ├── Lab3.md
    ├── Lab4.md
    ├── Lab5.md
    └── img
    │   └── lab1-challenge.png
└── user
    ├── Makefrag
    ├── badsegment.c
    ├── breakpoint.c
    ├── buggyhello.c
    ├── buggyhello2.c
    ├── cat.c
    ├── divzero.c
    ├── dumbfork.c
    ├── echo.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
    ├── icode.c
    ├── idle.c
    ├── init.c
    ├── initsh.c
    ├── ls.c
    ├── lsfd.c
    ├── num.c
    ├── pingpong.c
    ├── pingpongs.c
    ├── primes.c
    ├── primespipe.c
    ├── priority.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
    ├── 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 | .vscode/
20 | 


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


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # MIT6.828Labs-JOS
 2 | 
 3 | This repository contains my solution to MIT6.828 Operating System Engineering Fall 2018 Lab 1-5. You can refer to the `report/` folder for my reports of each Lab.
 4 | 
 5 | WARNING: DO NOT COPY THIS REPOSITORY AS YOUR SOLUTION IF YOU ARE TAKING COURSES THAT USE THESE LABS AS ASSIGNMENTS!!!
 6 | 
 7 | ## Challenges
 8 | 
 9 | Most of the solutions on the Internet are missing challenges, but I have done some challenges in Lab 2-5, which might be useful for you. The challenges I solved are the following, you can refer to my reports and code for how I solved them.
10 | 
11 | ### Lab 1 - Colored Output to Console
12 | 
13 | > **Challenge.** Enhance the console to allow text to be printed in different colors. The traditional way to do this is to make it interpret [ANSI escape sequences](http://rrbrandt.dee.ufcg.edu.br/en/docs/ansi/) embedded in the text strings printed to the console, but you may use any mechanism you like. There is plenty of information on [the 6.828 reference page](https://pdos.csail.mit.edu/6.828/2018/reference.html) and elsewhere on the web on programming the VGA display hardware. If you're feeling really adventurous, you could try switching the VGA hardware into a graphics mode and making the console draw text onto the graphical frame buffer.
14 | 
15 | ### Lab 2 - More Useful JOS Monitor Commands
16 | 
17 | > **Challenge!** Extend the JOS kernel monitor with commands to:
18 | >
19 | > Display in a useful and easy-to-read format all of the physical page mappings (or lack thereof) that apply to a particular range of virtual/linear addresses in the currently active address space. For example, you might enter 'showmappings 0x3000 0x5000' to display the physical page mappings and corresponding permission bits that apply to the pages at virtual addresses 0x3000, 0x4000, and 0x5000.
20 | >
21 | > Explicitly set, clear, or change the permissions of any mapping in the current address space.
22 | >
23 | > Dump the contents of a range of memory given either a virtual or physical address range. Be sure the dump code behaves correctly when the range extends across page boundaries!
24 | > 
25 | > Do anything else that you think might be useful later for debugging the kernel. (There's a good chance it will be!)
26 | 
27 | ### Lab 3 - Breakpoints and Single Stepping
28 | 
29 | > **Challenge!** Modify the JOS kernel monitor so that you can 'continue' execution from the current location (e.g., after the int3, if the kernel monitor was invoked via the breakpoint exception), and so that you can single-step one instruction at a time. You will need to understand certain bits of the EFLAGS register in order to implement single-stepping.
30 | 
31 | ### Lab 4 - Fixed Priority Scheduling
32 | 
33 | > **Challenge!** Add a less trivial scheduling policy to the kernel, such as a fixed-priority scheduler that allows each environment to be assigned a priority and ensures that higher-priority environments are always chosen in preference to lower-priority environments.
34 | 
35 | ### Lab 5 - FIFO Disk Block Cache
36 | 
37 | > **Challenge!** The block cache has no eviction policy. Once a block gets faulted in to it, it never gets removed and will remain in memory forevermore. Add eviction to the buffer cache. Using the PTE_A "accessed" bits in the page tables, which the hardware sets on any access to a page, you can track approximate usage of disk blocks without the need to modify every place in the code that accesses the disk map region. Be careful with dirty blocks. 
38 | 


--------------------------------------------------------------------------------
/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/main.c:
--------------------------------------------------------------------------------
  1 | #include <inc/x86.h>
  2 | #include <inc/elf.h>
  3 | 
  4 | /**********************************************************************
  5 |  * This a dirt simple boot loader, whose sole job is to boot
  6 |  * an ELF kernel image from the first IDE hard disk.
  7 |  *
  8 |  * DISK LAYOUT
  9 |  *  * This program(boot.S and main.c) is the bootloader.  It should
 10 |  *    be stored in the first sector of the disk.
 11 |  *
 12 |  *  * The 2nd sector onward holds the kernel image.
 13 |  *
 14 |  *  * The kernel image must be in ELF format.
 15 |  *
 16 |  * BOOT UP STEPS
 17 |  *  * when the CPU boots it loads the BIOS into memory and executes it
 18 |  *
 19 |  *  * the BIOS intializes devices, sets of the interrupt routines, and
 20 |  *    reads the first sector of the boot device(e.g., hard-drive)
 21 |  *    into memory and jumps to it.
 22 |  *
 23 |  *  * Assuming this boot loader is stored in the first sector of the
 24 |  *    hard-drive, this code takes over...
 25 |  *
 26 |  *  * control starts in boot.S -- which sets up protected mode,
 27 |  *    and a stack so C code then run, then calls bootmain()
 28 |  *
 29 |  *  * bootmain() in this file takes over, reads in the kernel and jumps to it.
 30 |  **********************************************************************/
 31 | 
 32 | #define SECTSIZE	512
 33 | #define ELFHDR		((struct Elf *) 0x10000) // scratch space
 34 | 
 35 | void readsect(void*, uint32_t);
 36 | void readseg(uint32_t, uint32_t, uint32_t);
 37 | 
 38 | void
 39 | bootmain(void)
 40 | {
 41 | 	struct Proghdr *ph, *eph;
 42 | 	int i;
 43 | 
 44 | 	// read 1st page off disk
 45 | 	readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
 46 | 
 47 | 	// is this a valid ELF?
 48 | 	if (ELFHDR->e_magic != ELF_MAGIC)
 49 | 		goto bad;
 50 | 
 51 | 	// load each program segment (ignores ph flags)
 52 | 	ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
 53 | 	eph = ph + ELFHDR->e_phnum;
 54 | 	for (; ph < eph; ph++) {
 55 | 		// p_pa is the load address of this segment (as well
 56 | 		// as the physical address)
 57 | 		readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
 58 | 		for (i = 0; i < ph->p_memsz - ph->p_filesz; i++) {
 59 | 			*((char *) ph->p_pa + ph->p_filesz + i) = 0;
 60 | 		}
 61 | 	}
 62 | 
 63 | 	// call the entry point from the ELF header
 64 | 	// note: does not return!
 65 | 	((void (*)(void)) (ELFHDR->e_entry))();
 66 | 
 67 | bad:
 68 | 	outw(0x8A00, 0x8A00);
 69 | 	outw(0x8A00, 0x8E00);
 70 | 	while (1)
 71 | 		/* do nothing */;
 72 | }
 73 | 
 74 | // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
 75 | // Might copy more than asked
 76 | void
 77 | readseg(uint32_t pa, uint32_t count, uint32_t offset)
 78 | {
 79 | 	uint32_t end_pa;
 80 | 
 81 | 	end_pa = pa + count;
 82 | 
 83 | 	// round down to sector boundary
 84 | 	pa &= ~(SECTSIZE - 1);
 85 | 
 86 | 	// translate from bytes to sectors, and kernel starts at sector 1
 87 | 	offset = (offset / SECTSIZE) + 1;
 88 | 
 89 | 	// If this is too slow, we could read lots of sectors at a time.
 90 | 	// We'd write more to memory than asked, but it doesn't matter --
 91 | 	// we load in increasing order.
 92 | 	while (pa < end_pa) {
 93 | 		// Since we haven't enabled paging yet and we're using
 94 | 		// an identity segment mapping (see boot.S), we can
 95 | 		// use physical addresses directly.  This won't be the
 96 | 		// case once JOS enables the MMU.
 97 | 		readsect((uint8_t*) pa, offset);
 98 | 		pa += SECTSIZE;
 99 | 		offset++;
100 | 	}
101 | }
102 | 
103 | void
104 | waitdisk(void)
105 | {
106 | 	// wait for disk reaady
107 | 	while ((inb(0x1F7) & 0xC0) != 0x40)
108 | 		/* do nothing */;
109 | }
110 | 
111 | void
112 | readsect(void *dst, uint32_t offset)
113 | {
114 | 	// wait for disk to be ready
115 | 	waitdisk();
116 | 
117 | 	outb(0x1F2, 1);		// count = 1
118 | 	outb(0x1F3, offset);
119 | 	outb(0x1F4, offset >> 8);
120 | 	outb(0x1F5, offset >> 16);
121 | 	outb(0x1F6, (offset >> 24) | 0xE0);
122 | 	outb(0x1F7, 0x20);	// cmd 0x20 - read sectors
123 | 
124 | 	// wait for disk to be ready
125 | 	waitdisk();
126 | 
127 | 	// read a sector
128 | 	insl(0x1F0, dst, SECTSIZE/4);
129 | }
130 | 
131 | 


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


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


--------------------------------------------------------------------------------
/grade-lab3:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | from gradelib import *
  4 | 
  5 | r = Runner(save("jos.out"),
  6 |            stop_breakpoint("readline"))
  7 | 
  8 | @test(10)
  9 | def test_divzero():
 10 |     r.user_test("divzero")
 11 |     r.match('Incoming TRAP frame at 0xefffff..',
 12 |             'TRAP frame at 0xf.......',
 13 |             '  trap 0x00000000 Divide error',
 14 |             '  eip  0x008.....',
 15 |             '  ss   0x----0023',
 16 |             '.00001000. free env 00001000',
 17 |             no=['1/0 is ........!'])
 18 | 
 19 | @test(10)
 20 | def test_softint():
 21 |     r.user_test("softint")
 22 |     r.match('Welcome to the JOS kernel monitor!',
 23 |             'Incoming TRAP frame at 0xefffffbc',
 24 |             'TRAP frame at 0xf.......',
 25 |             '  trap 0x0000000d General Protection',
 26 |             '  eip  0x008.....',
 27 |             '  ss   0x----0023',
 28 |             '.00001000. free env 0000100')
 29 | 
 30 | @test(10)
 31 | def test_badsegment():
 32 |     r.user_test("badsegment")
 33 |     r.match('Incoming TRAP frame at 0xefffffbc',
 34 |             'TRAP frame at 0xf.......',
 35 |             '  trap 0x0000000d General Protection',
 36 |             '  err  0x00000028',
 37 |             '  eip  0x008.....',
 38 |             '  ss   0x----0023',
 39 |             '.00001000. free env 0000100')
 40 | 
 41 | end_part("A")
 42 | 
 43 | @test(5)
 44 | def test_faultread():
 45 |     r.user_test("faultread")
 46 |     r.match('.00001000. user fault va 00000000 ip 008.....',
 47 |             'Incoming TRAP frame at 0xefffffbc',
 48 |             'TRAP frame at 0xf.......',
 49 |             '  trap 0x0000000e Page Fault',
 50 |             '  err  0x00000004.*',
 51 |             '.00001000. free env 0000100',
 52 |             no=['I read ........ from location 0!'])
 53 | 
 54 | @test(5)
 55 | def test_faultreadkernel():
 56 |     r.user_test("faultreadkernel")
 57 |     r.match('.00001000. user fault va f0100000 ip 008.....',
 58 |             'Incoming TRAP frame at 0xefffffbc',
 59 |             'TRAP frame at 0xf.......',
 60 |             '  trap 0x0000000e Page Fault',
 61 |             '  err  0x00000005.*',
 62 |             '.00001000. free env 00001000',
 63 |             no=['I read ........ from location 0xf0100000!'])
 64 | 
 65 | @test(5)
 66 | def test_faultwrite():
 67 |     r.user_test("faultwrite")
 68 |     r.match('.00001000. user fault va 00000000 ip 008.....',
 69 |             'Incoming TRAP frame at 0xefffffbc',
 70 |             'TRAP frame at 0xf.......',
 71 |             '  trap 0x0000000e Page Fault',
 72 |             '  err  0x00000006.*',
 73 |             '.00001000. free env 0000100')
 74 | 
 75 | @test(5)
 76 | def test_faultwritekernel():
 77 |     r.user_test("faultwritekernel")
 78 |     r.match('.00001000. user fault va f0100000 ip 008.....',
 79 |             'Incoming TRAP frame at 0xefffffbc',
 80 |             'TRAP frame at 0xf.......',
 81 |             '  trap 0x0000000e Page Fault',
 82 |             '  err  0x00000007.*',
 83 |             '.00001000. free env 0000100')
 84 | 
 85 | @test(5)
 86 | def test_breakpoint():
 87 |     r.user_test("breakpoint")
 88 |     r.match('Welcome to the JOS kernel monitor!',
 89 |             'Incoming TRAP frame at 0xefffffbc',
 90 |             'TRAP frame at 0xf.......',
 91 |             '  trap 0x00000003 Breakpoint',
 92 |             '  eip  0x008.....',
 93 |             '  ss   0x----0023',
 94 |             no=['.00001000. free env 00001000'])
 95 | 
 96 | @test(5)
 97 | def test_testbss():
 98 |     r.user_test("testbss")
 99 |     r.match('Making sure bss works right...',
100 |             'Yes, good.  Now doing a wild write off the end...',
101 |             '.00001000. user fault va 00c..... ip 008.....',
102 |             '.00001000. free env 0000100')
103 | 
104 | @test(5)
105 | def test_hello():
106 |     r.user_test("hello")
107 |     r.match('.00000000. new env 00001000',
108 |             'hello, world',
109 |             'i am environment 00001000',
110 |             '.00001000. exiting gracefully',
111 |             '.00001000. free env 00001000',
112 |             'Destroyed the only environment - nothing more to do!')
113 | 
114 | @test(5)
115 | def test_buggyhello():
116 |     r.user_test("buggyhello")
117 |     r.match('.00001000. user_mem_check assertion failure for va 00000001',
118 |             '.00001000. free env 00001000')
119 | 
120 | @test(5)
121 | def test_buggyhello2():
122 |     r.user_test("buggyhello2")
123 |     r.match('.00001000. user_mem_check assertion failure for va 0....000',
124 |             '.00001000. free env 00001000',
125 |             no=['hello, world'])
126 | 
127 | @test(5)
128 | def test_evilhello():
129 |     r.user_test("evilhello")
130 |     r.match('.00001000. user_mem_check assertion failure for va f0100...',
131 |             '.00001000. free env 00001000')
132 | 
133 | end_part("B")
134 | 
135 | run_tests()
136 | 


--------------------------------------------------------------------------------
/grade-lab5:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | from gradelib import *
  4 | 
  5 | r = Runner(save("jos.out"),
  6 |            stop_breakpoint("readline"))
  7 | 
  8 | def matchtest(parent, name, *args, **kw):
  9 |     def do_test():
 10 |         r.match(*args, **kw)
 11 |     test(5, name, parent=parent)(do_test)
 12 | 
 13 | @test(5, "internal FS tests [fs/test.c]")
 14 | def test_fs():
 15 |     r.user_test("hello")
 16 | matchtest(test_fs, "fs i/o",
 17 |           "FS can do I/O")
 18 | matchtest(test_fs, "check_bc",
 19 |           "block cache is good")
 20 | matchtest(test_fs, "check_super",
 21 |           "superblock is good")
 22 | matchtest(test_fs, "check_bitmap",
 23 |           "bitmap is good")
 24 | matchtest(test_fs, "alloc_block",
 25 |           "alloc_block is good")
 26 | matchtest(test_fs, "file_open",
 27 |           "file_open is good")
 28 | matchtest(test_fs, "file_get_block",
 29 |           "file_get_block is good")
 30 | matchtest(test_fs, "file_flush/file_truncate/file rewrite",
 31 |           "file_flush is good",
 32 |           "file_truncate is good",
 33 |           "file rewrite is good")
 34 | 
 35 | @test(10, "testfile")
 36 | def test_testfile():
 37 |     r.user_test("testfile")
 38 | matchtest(test_testfile, "serve_open/file_stat/file_close",
 39 |           "serve_open is good",
 40 |           "file_stat is good",
 41 |           "file_close is good",
 42 |           "stale fileid is good")
 43 | matchtest(test_testfile, "file_read",
 44 |           "file_read is good")
 45 | matchtest(test_testfile, "file_write",
 46 |           "file_write is good")
 47 | matchtest(test_testfile, "file_read after file_write",
 48 |           "file_read after file_write is good")
 49 | matchtest(test_testfile, "open",
 50 |           "open is good")
 51 | matchtest(test_testfile, "large file",
 52 |           "large file is good")
 53 | 
 54 | @test(10, "spawn via spawnhello")
 55 | def test_spawn():
 56 |     r.user_test("spawnhello")
 57 |     r.match('i am parent environment 00001001',
 58 |             'hello, world',
 59 |             'i am environment 00001002',
 60 |             'No runnable environments in the system!')
 61 | 
 62 | @test(5, "Protection I/O space")
 63 | def test_faultio():
 64 |     r.user_test("spawnfaultio")
 65 |     r.match('TRAP')
 66 | 
 67 | @test(10, "PTE_SHARE [testpteshare]")
 68 | def test_pte_share():
 69 |     r.user_test("testpteshare")
 70 |     r.match('fork handles PTE_SHARE right',
 71 |             'spawn handles PTE_SHARE right')
 72 | 
 73 | @test(5, "PTE_SHARE [testfdsharing]")
 74 | def test_fd_share():
 75 |     r.user_test("testfdsharing")
 76 |     r.match('read in child succeeded',
 77 |             'read in parent succeeded')
 78 | 
 79 | @test(10, "start the shell [icode]")
 80 | def test_icode():
 81 |     r.user_test("icode")
 82 |     r.match('icode: read /motd',
 83 |             'This is /motd, the message of the day.',
 84 |             'icode: spawn /init',
 85 |             'init: running',
 86 |             'init: data seems okay',
 87 |             'icode: exiting',
 88 |             'init: bss seems okay',
 89 |             "init: args: 'init' 'initarg1' 'initarg2'",
 90 |             'init: running sh',
 91 |             '\$ ')
 92 | 
 93 | @test(15)
 94 | def test_testshell():
 95 |     r.user_test("testshell", timeout=60)
 96 |     r.match("shell ran correctly")
 97 | 
 98 | def gen_primes(n):
 99 |     rest = range(2, n)
100 |     while rest:
101 |         yield rest[0]
102 |         rest = [n for n in rest if n % rest[0]]
103 | 
104 | @test(10)
105 | def test_primespipe():
106 |     r.user_test("primespipe", stop_on_line("[0-9]{4}$"), timeout=120)
107 |     primes = set(gen_primes(1000))
108 |     nonprimes = set(range(1000)) - primes
109 |     r.match(no=["%d$" % np for np in nonprimes],
110 |             *["%d$" % p for p in primes])
111 | 
112 | run_tests()
113 | 


--------------------------------------------------------------------------------
/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;
14 | 	uint32_t e_shoff;
15 | 	uint32_t e_flags;
16 | 	uint16_t e_ehsize;
17 | 	uint16_t e_phentsize;
18 | 	uint16_t e_phnum;
19 | 	uint16_t e_shentsize;
20 | 	uint16_t e_shnum;
21 | 	uint16_t e_shstrndx;
22 | };
23 | 
24 | struct Proghdr {
25 | 	uint32_t p_type;
26 | 	uint32_t p_offset;
27 | 	uint32_t p_va;
28 | 	uint32_t p_pa;
29 | 	uint32_t p_filesz;
30 | 	uint32_t p_memsz;
31 | 	uint32_t p_flags;
32 | 	uint32_t p_align;
33 | };
34 | 
35 | struct Secthdr {
36 | 	uint32_t sh_name;
37 | 	uint32_t sh_type;
38 | 	uint32_t sh_flags;
39 | 	uint32_t sh_addr;
40 | 	uint32_t sh_offset;
41 | 	uint32_t sh_size;
42 | 	uint32_t sh_link;
43 | 	uint32_t sh_info;
44 | 	uint32_t sh_addralign;
45 | 	uint32_t sh_entsize;
46 | };
47 | 
48 | // Values for Proghdr::p_type
49 | #define ELF_PROG_LOAD		1
50 | 
51 | // Flag bits for Proghdr::p_flags
52 | #define ELF_PROG_FLAG_EXEC	1
53 | #define ELF_PROG_FLAG_WRITE	2
54 | #define ELF_PROG_FLAG_READ	4
55 | 
56 | // Values for Secthdr::sh_type
57 | #define ELF_SHT_NULL		0
58 | #define ELF_SHT_PROGBITS	1
59 | #define ELF_SHT_SYMTAB		2
60 | #define ELF_SHT_STRTAB		3
61 | 
62 | // Values for Secthdr::sh_name
63 | #define ELF_SHN_UNDEF		0
64 | 
65 | #endif /* !JOS_INC_ELF_H */
66 | 


--------------------------------------------------------------------------------
/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 | };
46 | 
47 | struct Env {
48 | 	struct Trapframe env_tf;	// Saved registers
49 | 	struct Env *env_link;		// Next free Env
50 | 	envid_t env_id;			// Unique environment identifier
51 | 	envid_t env_parent_id;		// env_id of this env's parent
52 | 	enum EnvType env_type;		// Indicates special system environments
53 | 	unsigned env_status;		// Status of the environment
54 | 	uint32_t env_priority;	// Priority of the environment(default 0, lowest)
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 Fd {
31 | 	int fd_dev_id;
32 | 	off_t fd_offset;
33 | 	int fd_omode;
34 | 	union {
35 | 		// File server files
36 | 		struct FdFile fd_file;
37 | 	};
38 | };
39 | 
40 | struct Stat {
41 | 	char st_name[MAXNAMELEN];
42 | 	off_t st_size;
43 | 	int st_isdir;
44 | 	struct Dev *st_dev;
45 | };
46 | 
47 | char*	fd2data(struct Fd *fd);
48 | int	fd2num(struct Fd *fd);
49 | int	fd_alloc(struct Fd **fd_store);
50 | int	fd_close(struct Fd *fd, bool must_exist);
51 | int	fd_lookup(int fdnum, struct Fd **fd_store);
52 | int	dev_lookup(int devid, struct Dev **dev_store);
53 | 
54 | extern struct Dev devfile;
55 | extern struct Dev devcons;
56 | extern struct Dev devpipe;
57 | 
58 | #endif	// not JOS_INC_FD_H
59 | 


--------------------------------------------------------------------------------
/inc/fs.h:
--------------------------------------------------------------------------------
  1 | // See COPYRIGHT for copyright information.
  2 | 
  3 | #ifndef JOS_INC_FS_H
  4 | #define JOS_INC_FS_H
  5 | 
  6 | #include <inc/types.h>
  7 | #include <inc/mmu.h>
  8 | 
  9 | // File nodes (both in-memory and on-disk)
 10 | 
 11 | // Bytes per file system block - same as page size
 12 | #define BLKSIZE		PGSIZE
 13 | #define BLKBITSIZE	(BLKSIZE * 8)
 14 | 
 15 | // Maximum size of a filename (a single path component), including null
 16 | // Must be a multiple of 4
 17 | #define MAXNAMELEN	128
 18 | 
 19 | // Maximum size of a complete pathname, including null
 20 | #define MAXPATHLEN	1024
 21 | 
 22 | // Number of block pointers in a File descriptor
 23 | #define NDIRECT		10
 24 | // Number of direct block pointers in an indirect block
 25 | #define NINDIRECT	(BLKSIZE / 4)
 26 | 
 27 | #define MAXFILESIZE	((NDIRECT + NINDIRECT) * BLKSIZE)
 28 | 
 29 | struct File {
 30 | 	char f_name[MAXNAMELEN];	// filename
 31 | 	off_t f_size;			// file size in bytes
 32 | 	uint32_t f_type;		// file type
 33 | 
 34 | 	// Block pointers.
 35 | 	// A block is allocated iff its value is != 0.
 36 | 	uint32_t f_direct[NDIRECT];	// direct blocks
 37 | 	uint32_t f_indirect;		// indirect block
 38 | 
 39 | 	// Pad out to 256 bytes; must do arithmetic in case we're compiling
 40 | 	// fsformat on a 64-bit machine.
 41 | 	uint8_t f_pad[256 - MAXNAMELEN - 8 - 4*NDIRECT - 4];
 42 | } __attribute__((packed));	// required only on some 64-bit machines
 43 | 
 44 | // An inode block contains exactly BLKFILES 'struct File's
 45 | #define BLKFILES	(BLKSIZE / sizeof(struct File))
 46 | 
 47 | // File types
 48 | #define FTYPE_REG	0	// Regular file
 49 | #define FTYPE_DIR	1	// Directory
 50 | 
 51 | 
 52 | // File system super-block (both in-memory and on-disk)
 53 | 
 54 | #define FS_MAGIC	0x4A0530AE	// related vaguely to 'J\0S!'
 55 | 
 56 | struct Super {
 57 | 	uint32_t s_magic;		// Magic number: FS_MAGIC
 58 | 	uint32_t s_nblocks;		// Total number of blocks on disk
 59 | 	struct File s_root;		// Root directory node
 60 | };
 61 | 
 62 | // Definitions for requests from clients to file system
 63 | enum {
 64 | 	FSREQ_OPEN = 1,
 65 | 	FSREQ_SET_SIZE,
 66 | 	// Read returns a Fsret_read on the request page
 67 | 	FSREQ_READ,
 68 | 	FSREQ_WRITE,
 69 | 	// Stat returns a Fsret_stat on the request page
 70 | 	FSREQ_STAT,
 71 | 	FSREQ_FLUSH,
 72 | 	FSREQ_REMOVE,
 73 | 	FSREQ_SYNC
 74 | };
 75 | 
 76 | union Fsipc {
 77 | 	struct Fsreq_open {
 78 | 		char req_path[MAXPATHLEN];
 79 | 		int req_omode;
 80 | 	} open;
 81 | 	struct Fsreq_set_size {
 82 | 		int req_fileid;
 83 | 		off_t req_size;
 84 | 	} set_size;
 85 | 	struct Fsreq_read {
 86 | 		int req_fileid;
 87 | 		size_t req_n;
 88 | 	} read;
 89 | 	struct Fsret_read {
 90 | 		char ret_buf[PGSIZE];
 91 | 	} readRet;
 92 | 	struct Fsreq_write {
 93 | 		int req_fileid;
 94 | 		size_t req_n;
 95 | 		char req_buf[PGSIZE - (sizeof(int) + sizeof(size_t))];
 96 | 	} write;
 97 | 	struct Fsreq_stat {
 98 | 		int req_fileid;
 99 | 	} stat;
100 | 	struct Fsret_stat {
101 | 		char ret_name[MAXNAMELEN];
102 | 		off_t ret_size;
103 | 		int ret_isdir;
104 | 	} statRet;
105 | 	struct Fsreq_flush {
106 | 		int req_fileid;
107 | 	} flush;
108 | 	struct Fsreq_remove {
109 | 		char req_path[MAXPATHLEN];
110 | 	} remove;
111 | 
112 | 	// Ensure Fsipc is one page
113 | 	char _pad[PGSIZE];
114 | };
115 | 
116 | #endif /* !JOS_INC_FS_H */
117 | 


--------------------------------------------------------------------------------
/inc/kbdreg.h:
--------------------------------------------------------------------------------
 1 | #ifndef JOS_KBDREG_H
 2 | #define JOS_KBDREG_H
 3 | 
 4 | // Special keycodes
 5 | #define KEY_HOME	0xE0
 6 | #define KEY_END		0xE1
 7 | #define KEY_UP		0xE2
 8 | #define KEY_DN		0xE3
 9 | #define KEY_LF		0xE4
10 | #define KEY_RT		0xE5
11 | #define KEY_PGUP	0xE6
12 | #define KEY_PGDN	0xE7
13 | #define KEY_INS		0xE8
14 | #define KEY_DEL		0xE9
15 | 
16 | 
17 | /* This is i8042reg.h + kbdreg.h from NetBSD. */
18 | 
19 | #define	KBSTATP		0x64	/* kbd controller status port(I) */
20 | #define	 KBS_DIB	0x01	/* kbd data in buffer */
21 | #define	 KBS_IBF	0x02	/* kbd input buffer low */
22 | #define	 KBS_WARM	0x04	/* kbd input buffer low */
23 | #define	 KBS_OCMD	0x08	/* kbd output buffer has command */
24 | #define	 KBS_NOSEC	0x10	/* kbd security lock not engaged */
25 | #define	 KBS_TERR	0x20	/* kbd transmission error or from mouse */
26 | #define	 KBS_RERR	0x40	/* kbd receive error */
27 | #define	 KBS_PERR	0x80	/* kbd parity error */
28 | 
29 | #define	KBCMDP		0x64	/* kbd controller port(O) */
30 | #define	 KBC_RAMREAD	0x20	/* read from RAM */
31 | #define	 KBC_RAMWRITE	0x60	/* write to RAM */
32 | #define	 KBC_AUXDISABLE	0xa7	/* disable auxiliary port */
33 | #define	 KBC_AUXENABLE	0xa8	/* enable auxiliary port */
34 | #define	 KBC_AUXTEST	0xa9	/* test auxiliary port */
35 | #define	 KBC_KBDECHO	0xd2	/* echo to keyboard port */
36 | #define	 KBC_AUXECHO	0xd3	/* echo to auxiliary port */
37 | #define	 KBC_AUXWRITE	0xd4	/* write to auxiliary port */
38 | #define	 KBC_SELFTEST	0xaa	/* start self-test */
39 | #define	 KBC_KBDTEST	0xab	/* test keyboard port */
40 | #define	 KBC_KBDDISABLE	0xad	/* disable keyboard port */
41 | #define	 KBC_KBDENABLE	0xae	/* enable keyboard port */
42 | #define	 KBC_PULSE0	0xfe	/* pulse output bit 0 */
43 | #define	 KBC_PULSE1	0xfd	/* pulse output bit 1 */
44 | #define	 KBC_PULSE2	0xfb	/* pulse output bit 2 */
45 | #define	 KBC_PULSE3	0xf7	/* pulse output bit 3 */
46 | 
47 | #define	KBDATAP		0x60	/* kbd data port(I) */
48 | #define	KBOUTP		0x60	/* kbd data port(O) */
49 | 
50 | #define	K_RDCMDBYTE	0x20
51 | #define	K_LDCMDBYTE	0x60
52 | 
53 | #define	KC8_TRANS	0x40	/* convert to old scan codes */
54 | #define	KC8_MDISABLE	0x20	/* disable mouse */
55 | #define	KC8_KDISABLE	0x10	/* disable keyboard */
56 | #define	KC8_IGNSEC	0x08	/* ignore security lock */
57 | #define	KC8_CPU		0x04	/* exit from protected mode reset */
58 | #define	KC8_MENABLE	0x02	/* enable mouse interrupt */
59 | #define	KC8_KENABLE	0x01	/* enable keyboard interrupt */
60 | #define	CMDBYTE		(KC8_TRANS|KC8_CPU|KC8_MENABLE|KC8_KENABLE)
61 | 
62 | /* keyboard commands */
63 | #define	KBC_RESET	0xFF	/* reset the keyboard */
64 | #define	KBC_RESEND	0xFE	/* request the keyboard resend the last byte */
65 | #define	KBC_SETDEFAULT	0xF6	/* resets keyboard to its power-on defaults */
66 | #define	KBC_DISABLE	0xF5	/* as per KBC_SETDEFAULT, but also disable key scanning */
67 | #define	KBC_ENABLE	0xF4	/* enable key scanning */
68 | #define	KBC_TYPEMATIC	0xF3	/* set typematic rate and delay */
69 | #define	KBC_SETTABLE	0xF0	/* set scancode translation table */
70 | #define	KBC_MODEIND	0xED	/* set mode indicators(i.e. LEDs) */
71 | #define	KBC_ECHO	0xEE	/* request an echo from the keyboard */
72 | 
73 | /* keyboard responses */
74 | #define	KBR_EXTENDED	0xE0	/* extended key sequence */
75 | #define	KBR_RESEND	0xFE	/* needs resend of command */
76 | #define	KBR_ACK		0xFA	/* received a valid command */
77 | #define	KBR_OVERRUN	0x00	/* flooded */
78 | #define	KBR_FAILURE	0xFD	/* diagnosic failure */
79 | #define	KBR_BREAK	0xF0	/* break code prefix - sent on key release */
80 | #define	KBR_RSTDONE	0xAA	/* reset complete */
81 | #define	KBR_ECHO	0xEE	/* echo response */
82 | 
83 | #endif /* !JOS_KBDREG_H */
84 | 


--------------------------------------------------------------------------------
/inc/lib.h:
--------------------------------------------------------------------------------
  1 | // Main public header file for our user-land support library,
  2 | // whose code lives in the lib directory.
  3 | // This library is roughly our OS's version of a standard C library,
  4 | // and is intended to be linked into all user-mode applications
  5 | // (NOT the kernel or boot loader).
  6 | 
  7 | #ifndef JOS_INC_LIB_H
  8 | #define JOS_INC_LIB_H 1
  9 | 
 10 | #include <inc/types.h>
 11 | #include <inc/stdio.h>
 12 | #include <inc/stdarg.h>
 13 | #include <inc/string.h>
 14 | #include <inc/error.h>
 15 | #include <inc/assert.h>
 16 | #include <inc/env.h>
 17 | #include <inc/memlayout.h>
 18 | #include <inc/syscall.h>
 19 | #include <inc/trap.h>
 20 | #include <inc/fs.h>
 21 | #include <inc/fd.h>
 22 | #include <inc/args.h>
 23 | 
 24 | #define USED(x)		(void)(x)
 25 | 
 26 | // main user program
 27 | void	umain(int argc, char **argv);
 28 | 
 29 | // libmain.c or entry.S
 30 | extern const char *binaryname;
 31 | extern const volatile struct Env *thisenv;
 32 | extern const volatile struct Env envs[NENV];
 33 | extern const volatile struct PageInfo pages[];
 34 | 
 35 | // exit.c
 36 | void	exit(void);
 37 | 
 38 | // pgfault.c
 39 | void	set_pgfault_handler(void (*handler)(struct UTrapframe *utf));
 40 | 
 41 | // readline.c
 42 | char*	readline(const char *buf);
 43 | 
 44 | // syscall.c
 45 | void	sys_cputs(const char *string, size_t len);
 46 | int	sys_cgetc(void);
 47 | envid_t	sys_getenvid(void);
 48 | int	sys_env_destroy(envid_t);
 49 | void	sys_yield(void);
 50 | static envid_t sys_exofork(void);
 51 | int	sys_env_set_status(envid_t env, int status);
 52 | int	sys_env_set_trapframe(envid_t env, struct Trapframe *tf);
 53 | int	sys_env_set_pgfault_upcall(envid_t env, void *upcall);
 54 | int sys_env_set_priority(envid_t envid, uint32_t priority);
 55 | int	sys_page_alloc(envid_t env, void *pg, int perm);
 56 | int	sys_page_map(envid_t src_env, void *src_pg,
 57 | 		     envid_t dst_env, void *dst_pg, int perm);
 58 | int	sys_page_unmap(envid_t env, void *pg);
 59 | int	sys_ipc_try_send(envid_t to_env, uint32_t value, void *pg, int perm);
 60 | int	sys_ipc_recv(void *rcv_pg);
 61 | 
 62 | // This must be inlined.  Exercise for reader: why?
 63 | static inline envid_t __attribute__((always_inline))
 64 | sys_exofork(void)
 65 | {
 66 | 	envid_t ret;
 67 | 	asm volatile("int %2"
 68 | 		     : "=a" (ret)
 69 | 		     : "a" (SYS_exofork), "i" (T_SYSCALL));
 70 | 	return ret;
 71 | }
 72 | 
 73 | // ipc.c
 74 | void	ipc_send(envid_t to_env, uint32_t value, void *pg, int perm);
 75 | int32_t ipc_recv(envid_t *from_env_store, void *pg, int *perm_store);
 76 | envid_t	ipc_find_env(enum EnvType type);
 77 | 
 78 | // fork.c
 79 | #define	PTE_SHARE	0x400
 80 | envid_t	fork(void);
 81 | envid_t	sfork(void);	// Challenge!
 82 | 
 83 | // fd.c
 84 | int	close(int fd);
 85 | ssize_t	read(int fd, void *buf, size_t nbytes);
 86 | ssize_t	write(int fd, const void *buf, size_t nbytes);
 87 | int	seek(int fd, off_t offset);
 88 | void	close_all(void);
 89 | ssize_t	readn(int fd, void *buf, size_t nbytes);
 90 | int	dup(int oldfd, int newfd);
 91 | int	fstat(int fd, struct Stat *statbuf);
 92 | int	stat(const char *path, struct Stat *statbuf);
 93 | 
 94 | // file.c
 95 | int	open(const char *path, int mode);
 96 | int	ftruncate(int fd, off_t size);
 97 | int	remove(const char *path);
 98 | int	sync(void);
 99 | 
100 | // pageref.c
101 | int	pageref(void *addr);
102 | 
103 | 
104 | // spawn.c
105 | envid_t	spawn(const char *program, const char **argv);
106 | envid_t	spawnl(const char *program, const char *arg0, ...);
107 | 
108 | // console.c
109 | void	cputchar(int c);
110 | int	getchar(void);
111 | int	iscons(int fd);
112 | int	opencons(void);
113 | 
114 | // pipe.c
115 | int	pipe(int pipefds[2]);
116 | int	pipeisclosed(int pipefd);
117 | 
118 | // wait.c
119 | void	wait(envid_t env);
120 | 
121 | /* File open modes */
122 | #define	O_RDONLY	0x0000		/* open for reading only */
123 | #define	O_WRONLY	0x0001		/* open for writing only */
124 | #define	O_RDWR		0x0002		/* open for reading and writing */
125 | #define	O_ACCMODE	0x0003		/* mask for above modes */
126 | 
127 | #define	O_CREAT		0x0100		/* create if nonexistent */
128 | #define	O_TRUNC		0x0200		/* truncate to zero length */
129 | #define	O_EXCL		0x0400		/* error if already exists */
130 | #define O_MKDIR		0x0800		/* create directory, not regular file */
131 | 
132 | #endif	// !JOS_INC_LIB_H
133 | 


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


--------------------------------------------------------------------------------
/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_env_set_priority,
21 | 	NSYSCALLS
22 | };
23 | 
24 | #endif /* !JOS_INC_SYSCALL_H */
25 | 


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


--------------------------------------------------------------------------------
/inc/x86.h:
--------------------------------------------------------------------------------
  1 | #ifndef JOS_INC_X86_H
  2 | #define JOS_INC_X86_H
  3 | 
  4 | #include <inc/types.h>
  5 | 
  6 | static inline void
  7 | breakpoint(void)
  8 | {
  9 | 	asm volatile("int3");
 10 | }
 11 | 
 12 | static inline uint8_t
 13 | inb(int port)
 14 | {
 15 | 	uint8_t data;
 16 | 	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
 17 | 	return data;
 18 | }
 19 | 
 20 | static inline void
 21 | insb(int port, void *addr, int cnt)
 22 | {
 23 | 	asm volatile("cld\n\trepne\n\tinsb"
 24 | 		     : "=D" (addr), "=c" (cnt)
 25 | 		     : "d" (port), "0" (addr), "1" (cnt)
 26 | 		     : "memory", "cc");
 27 | }
 28 | 
 29 | static inline uint16_t
 30 | inw(int port)
 31 | {
 32 | 	uint16_t data;
 33 | 	asm volatile("inw %w1,%0" : "=a" (data) : "d" (port));
 34 | 	return data;
 35 | }
 36 | 
 37 | static inline void
 38 | insw(int port, void *addr, int cnt)
 39 | {
 40 | 	asm volatile("cld\n\trepne\n\tinsw"
 41 | 		     : "=D" (addr), "=c" (cnt)
 42 | 		     : "d" (port), "0" (addr), "1" (cnt)
 43 | 		     : "memory", "cc");
 44 | }
 45 | 
 46 | static inline uint32_t
 47 | inl(int port)
 48 | {
 49 | 	uint32_t data;
 50 | 	asm volatile("inl %w1,%0" : "=a" (data) : "d" (port));
 51 | 	return data;
 52 | }
 53 | 
 54 | static inline void
 55 | insl(int port, void *addr, int cnt)
 56 | {
 57 | 	asm volatile("cld\n\trepne\n\tinsl"
 58 | 		     : "=D" (addr), "=c" (cnt)
 59 | 		     : "d" (port), "0" (addr), "1" (cnt)
 60 | 		     : "memory", "cc");
 61 | }
 62 | 
 63 | static inline void
 64 | outb(int port, uint8_t data)
 65 | {
 66 | 	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
 67 | }
 68 | 
 69 | static inline void
 70 | outsb(int port, const void *addr, int cnt)
 71 | {
 72 | 	asm volatile("cld\n\trepne\n\toutsb"
 73 | 		     : "=S" (addr), "=c" (cnt)
 74 | 		     : "d" (port), "0" (addr), "1" (cnt)
 75 | 		     : "cc");
 76 | }
 77 | 
 78 | static inline void
 79 | outw(int port, uint16_t data)
 80 | {
 81 | 	asm volatile("outw %0,%w1" : : "a" (data), "d" (port));
 82 | }
 83 | 
 84 | static inline void
 85 | outsw(int port, const void *addr, int cnt)
 86 | {
 87 | 	asm volatile("cld\n\trepne\n\toutsw"
 88 | 		     : "=S" (addr), "=c" (cnt)
 89 | 		     : "d" (port), "0" (addr), "1" (cnt)
 90 | 		     : "cc");
 91 | }
 92 | 
 93 | static inline void
 94 | outsl(int port, const void *addr, int cnt)
 95 | {
 96 | 	asm volatile("cld\n\trepne\n\toutsl"
 97 | 		     : "=S" (addr), "=c" (cnt)
 98 | 		     : "d" (port), "0" (addr), "1" (cnt)
 99 | 		     : "cc");
100 | }
101 | 
102 | static inline void
103 | outl(int port, uint32_t data)
104 | {
105 | 	asm volatile("outl %0,%w1" : : "a" (data), "d" (port));
106 | }
107 | 
108 | static inline void
109 | invlpg(void *addr)
110 | {
111 | 	asm volatile("invlpg (%0)" : : "r" (addr) : "memory");
112 | }
113 | 
114 | static inline void
115 | lidt(void *p)
116 | {
117 | 	asm volatile("lidt (%0)" : : "r" (p));
118 | }
119 | 
120 | static inline void
121 | lgdt(void *p)
122 | {
123 | 	asm volatile("lgdt (%0)" : : "r" (p));
124 | }
125 | 
126 | static inline void
127 | lldt(uint16_t sel)
128 | {
129 | 	asm volatile("lldt %0" : : "r" (sel));
130 | }
131 | 
132 | static inline void
133 | ltr(uint16_t sel)
134 | {
135 | 	asm volatile("ltr %0" : : "r" (sel));
136 | }
137 | 
138 | static inline void
139 | lcr0(uint32_t val)
140 | {
141 | 	asm volatile("movl %0,%%cr0" : : "r" (val));
142 | }
143 | 
144 | static inline uint32_t
145 | rcr0(void)
146 | {
147 | 	uint32_t val;
148 | 	asm volatile("movl %%cr0,%0" : "=r" (val));
149 | 	return val;
150 | }
151 | 
152 | static inline uint32_t
153 | rcr2(void)
154 | {
155 | 	uint32_t val;
156 | 	asm volatile("movl %%cr2,%0" : "=r" (val));
157 | 	return val;
158 | }
159 | 
160 | static inline void
161 | lcr3(uint32_t val)
162 | {
163 | 	asm volatile("movl %0,%%cr3" : : "r" (val));
164 | }
165 | 
166 | static inline uint32_t
167 | rcr3(void)
168 | {
169 | 	uint32_t val;
170 | 	asm volatile("movl %%cr3,%0" : "=r" (val));
171 | 	return val;
172 | }
173 | 
174 | static inline void
175 | lcr4(uint32_t val)
176 | {
177 | 	asm volatile("movl %0,%%cr4" : : "r" (val));
178 | }
179 | 
180 | static inline uint32_t
181 | rcr4(void)
182 | {
183 | 	uint32_t cr4;
184 | 	asm volatile("movl %%cr4,%0" : "=r" (cr4));
185 | 	return cr4;
186 | }
187 | 
188 | static inline void
189 | tlbflush(void)
190 | {
191 | 	uint32_t cr3;
192 | 	asm volatile("movl %%cr3,%0" : "=r" (cr3));
193 | 	asm volatile("movl %0,%%cr3" : : "r" (cr3));
194 | }
195 | 
196 | static inline uint32_t
197 | read_eflags(void)
198 | {
199 | 	uint32_t eflags;
200 | 	asm volatile("pushfl; popl %0" : "=r" (eflags));
201 | 	return eflags;
202 | }
203 | 
204 | static inline void
205 | write_eflags(uint32_t eflags)
206 | {
207 | 	asm volatile("pushl %0; popfl" : : "r" (eflags));
208 | }
209 | 
210 | static inline uint32_t
211 | read_ebp(void)
212 | {
213 | 	uint32_t ebp;
214 | 	asm volatile("movl %%ebp,%0" : "=r" (ebp));
215 | 	return ebp;
216 | }
217 | 
218 | static inline uint32_t
219 | read_esp(void)
220 | {
221 | 	uint32_t esp;
222 | 	asm volatile("movl %%esp,%0" : "=r" (esp));
223 | 	return esp;
224 | }
225 | 
226 | static inline void
227 | cpuid(uint32_t info, uint32_t *eaxp, uint32_t *ebxp, uint32_t *ecxp, uint32_t *edxp)
228 | {
229 | 	uint32_t eax, ebx, ecx, edx;
230 | 	asm volatile("cpuid"
231 | 		     : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
232 | 		     : "a" (info));
233 | 	if (eaxp)
234 | 		*eaxp = eax;
235 | 	if (ebxp)
236 | 		*ebxp = ebx;
237 | 	if (ecxp)
238 | 		*ecxp = ecx;
239 | 	if (edxp)
240 | 		*edxp = edx;
241 | }
242 | 
243 | static inline uint64_t
244 | read_tsc(void)
245 | {
246 | 	uint64_t tsc;
247 | 	asm volatile("rdtsc" : "=A" (tsc));
248 | 	return tsc;
249 | }
250 | 
251 | static inline uint32_t
252 | xchg(volatile uint32_t *addr, uint32_t newval)
253 | {
254 | 	uint32_t result;
255 | 
256 | 	// The + in "+m" denotes a read-modify-write operand.
257 | 	asm volatile("lock; xchgl %0, %1"
258 | 		     : "+m" (*addr), "=a" (result)
259 | 		     : "1" (newval)
260 | 		     : "cc");
261 | 	return result;
262 | }
263 | 
264 | #endif /* !JOS_INC_X86_H */
265 | 


--------------------------------------------------------------------------------
/kern/Makefrag:
--------------------------------------------------------------------------------
  1 | #
  2 | # Makefile fragment for 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 += kern
  9 | 
 10 | KERN_LDFLAGS := $(LDFLAGS) -T kern/kernel.ld -nostdlib
 11 | 
 12 | # entry.S must be first, so that it's the first code in the text segment!!!
 13 | #
 14 | # We also snatch the use of a couple handy source files
 15 | # from the lib directory, to avoid gratuitous code duplication.
 16 | KERN_SRCFILES :=	kern/entry.S \
 17 | 			kern/entrypgdir.c \
 18 | 			kern/init.c \
 19 | 			kern/console.c \
 20 | 			kern/monitor.c \
 21 | 			kern/pmap.c \
 22 | 			kern/env.c \
 23 | 			kern/kclock.c \
 24 | 			kern/picirq.c \
 25 | 			kern/printf.c \
 26 | 			kern/trap.c \
 27 | 			kern/trapentry.S \
 28 | 			kern/sched.c \
 29 | 			kern/syscall.c \
 30 | 			kern/kdebug.c \
 31 | 			lib/printfmt.c \
 32 | 			lib/readline.c \
 33 | 			lib/string.c
 34 | 
 35 | # Source files for LAB4
 36 | KERN_SRCFILES +=	kern/mpentry.S \
 37 | 			kern/mpconfig.c \
 38 | 			kern/lapic.c \
 39 | 			kern/spinlock.c
 40 | 
 41 | # Only build files if they exist.
 42 | KERN_SRCFILES := $(wildcard $(KERN_SRCFILES))
 43 | 
 44 | # Binary program images to embed within the kernel.
 45 | # Binary files for LAB3
 46 | KERN_BINFILES :=	user/hello \
 47 | 			user/buggyhello \
 48 | 			user/buggyhello2 \
 49 | 			user/evilhello \
 50 | 			user/testbss \
 51 | 			user/divzero \
 52 | 			user/breakpoint \
 53 | 			user/softint \
 54 | 			user/badsegment \
 55 | 			user/faultread \
 56 | 			user/faultreadkernel \
 57 | 			user/faultwrite \
 58 | 			user/faultwritekernel
 59 | 
 60 | # Binary files for LAB4
 61 | KERN_BINFILES +=	user/idle \
 62 | 			user/yield \
 63 | 			user/dumbfork \
 64 | 			user/stresssched \
 65 | 			user/faultdie \
 66 | 			user/faultregs \
 67 | 			user/faultalloc \
 68 | 			user/faultallocbad \
 69 | 			user/faultnostack \
 70 | 			user/faultbadhandler \
 71 | 			user/faultevilhandler \
 72 | 			user/forktree \
 73 | 			user/sendpage \
 74 | 			user/spin \
 75 | 			user/fairness \
 76 | 			user/pingpong \
 77 | 			user/pingpongs \
 78 | 			user/primes \
 79 | 			user/priority
 80 | 
 81 | # Binary files for LAB5
 82 | KERN_BINFILES +=	user/faultio\
 83 | 	      	user/spawnfaultio\
 84 | 	      	user/testfile \
 85 | 			user/spawnhello \
 86 | 			user/icode \
 87 | 			fs/fs
 88 | 
 89 | # Binary files for LAB5
 90 | KERN_BINFILES +=	user/testpteshare \
 91 | 			user/testfdsharing \
 92 | 			user/testpipe \
 93 | 			user/testpiperace \
 94 | 			user/testpiperace2 \
 95 | 			user/primespipe \
 96 | 			user/testkbd \
 97 | 			user/testshell
 98 | 			
 99 | KERN_OBJFILES := $(patsubst %.c, $(OBJDIR)/%.o, $(KERN_SRCFILES))
100 | KERN_OBJFILES := $(patsubst %.S, $(OBJDIR)/%.o, $(KERN_OBJFILES))
101 | KERN_OBJFILES := $(patsubst $(OBJDIR)/lib/%, $(OBJDIR)/kern/%, $(KERN_OBJFILES))
102 | 
103 | KERN_BINFILES := $(patsubst %, $(OBJDIR)/%, $(KERN_BINFILES))
104 | 
105 | # How to build kernel object files
106 | $(OBJDIR)/kern/%.o: kern/%.c $(OBJDIR)/.vars.KERN_CFLAGS
107 | 	@echo + cc $<
108 | 	@mkdir -p $(@D)
109 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
110 | 
111 | $(OBJDIR)/kern/%.o: kern/%.S $(OBJDIR)/.vars.KERN_CFLAGS
112 | 	@echo + as $<
113 | 	@mkdir -p $(@D)
114 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
115 | 
116 | $(OBJDIR)/kern/%.o: lib/%.c $(OBJDIR)/.vars.KERN_CFLAGS
117 | 	@echo + cc $<
118 | 	@mkdir -p $(@D)
119 | 	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
120 | 
121 | # Special flags for kern/init
122 | $(OBJDIR)/kern/init.o: override KERN_CFLAGS+=$(INIT_CFLAGS)
123 | $(OBJDIR)/kern/init.o: $(OBJDIR)/.vars.INIT_CFLAGS
124 | 
125 | # How to build the kernel itself
126 | $(OBJDIR)/kern/kernel: $(KERN_OBJFILES) $(KERN_BINFILES) kern/kernel.ld \
127 | 	  $(OBJDIR)/.vars.KERN_LDFLAGS
128 | 	@echo + ld $@
129 | 	$(V)$(LD) -o $@ $(KERN_LDFLAGS) $(KERN_OBJFILES) $(GCC_LIB) -b binary $(KERN_BINFILES)
130 | 	$(V)$(OBJDUMP) -S $@ > $@.asm
131 | 	$(V)$(NM) -n $@ > $@.sym
132 | 
133 | # How to build the kernel disk image
134 | $(OBJDIR)/kern/kernel.img: $(OBJDIR)/kern/kernel $(OBJDIR)/boot/boot
135 | 	@echo + mk $@
136 | 	$(V)dd if=/dev/zero of=$(OBJDIR)/kern/kernel.img~ count=10000 2>/dev/null
137 | 	$(V)dd if=$(OBJDIR)/boot/boot of=$(OBJDIR)/kern/kernel.img~ conv=notrunc 2>/dev/null
138 | 	$(V)dd if=$(OBJDIR)/kern/kernel of=$(OBJDIR)/kern/kernel.img~ seek=1 conv=notrunc 2>/dev/null
139 | 	$(V)mv $(OBJDIR)/kern/kernel.img~ $(OBJDIR)/kern/kernel.img
140 | 
141 | all: $(OBJDIR)/kern/kernel.img
142 | 
143 | grub: $(OBJDIR)/jos-grub
144 | 
145 | $(OBJDIR)/jos-grub: $(OBJDIR)/kern/kernel
146 | 	@echo + oc $@
147 | 	$(V)$(OBJCOPY) --adjust-vma=0x10000000 $^ $@
148 | 


--------------------------------------------------------------------------------
/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 | #define CRT_BLACK   0
21 | #define CRT_BLUE    1
22 | #define CRT_GREEN   2
23 | #define CRT_CYAN    3
24 | #define CRT_RED     4
25 | #define CRT_MAGENTA 5
26 | #define CRT_ORANGE  6
27 | #define CRT_WHITE   7
28 | 
29 | void cons_init(void);
30 | int cons_getc(void);
31 | 
32 | void kbd_intr(void); // irq 1
33 | void serial_intr(void); // irq 4
34 | 
35 | #endif /* _CONSOLE_H_ */
36 | 


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


--------------------------------------------------------------------------------
/kern/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/init.c:
--------------------------------------------------------------------------------
  1 | /* See COPYRIGHT for copyright information. */
  2 | 
  3 | #include <inc/stdio.h>
  4 | #include <inc/string.h>
  5 | #include <inc/assert.h>
  6 | 
  7 | #include <kern/monitor.h>
  8 | #include <kern/console.h>
  9 | #include <kern/pmap.h>
 10 | #include <kern/kclock.h>
 11 | #include <kern/env.h>
 12 | #include <kern/trap.h>
 13 | #include <kern/sched.h>
 14 | #include <kern/picirq.h>
 15 | #include <kern/cpu.h>
 16 | #include <kern/spinlock.h>
 17 | 
 18 | static void boot_aps(void);
 19 | 
 20 | 
 21 | // Test the stack backtrace function (lab 1 only)
 22 | void
 23 | test_backtrace(int x)
 24 | {
 25 | 	cprintf("entering test_backtrace %d\n", x);
 26 | 	if (x > 0)
 27 | 		test_backtrace(x-1);
 28 | 	else
 29 | 		mon_backtrace(0, 0, 0);
 30 | 	cprintf("leaving test_backtrace %d\n", x);
 31 | }
 32 | 
 33 | void
 34 | lab1_test(void)
 35 | {
 36 | 	// Print some strange stuff
 37 | 	cprintf("6828 decimal is %o octal!\n", 6828);
 38 | 	unsigned int i = 0x00646c72;
 39 |     cprintf("H%x Wo%s\n", 57616, &i);
 40 | 	cprintf("Printing colored strings: ");
 41 | 	cprintf("\x1b[31;40mRed ");
 42 | 	cprintf("\x1b[32;40mGreen ");
 43 | 	cprintf("\x1b[33;40mYellow ");
 44 | 	cprintf("\x1b[34;40mBlue ");
 45 | 	cprintf("\x1b[35;40mMagenta ");
 46 | 	cprintf("\x1b[36;40mCyan ");
 47 | 	cprintf("\x1b[37;40mWhite");
 48 | 	cprintf("\n");
 49 | 	cprintf("With background color: ");
 50 | 	cprintf("\x1b[31;32mRed ");
 51 | 	cprintf("\x1b[32;33mGreen ");
 52 | 	cprintf("\x1b[33;34mYellow ");
 53 | 	cprintf("\x1b[34;35mBlue ");
 54 | 	cprintf("\x1b[35;36mMagenta ");
 55 | 	cprintf("\x1b[36;37mCyan ");
 56 | 	cprintf("\x1b[37;40mWhite");
 57 | 	cprintf("\n");
 58 | 
 59 | 	// Test the stack backtrace function (lab 1 only)
 60 | 	test_backtrace(5);
 61 | }
 62 | 
 63 | void
 64 | i386_init(void)
 65 | {
 66 | 	// Initialize the console.
 67 | 	// Can't call cprintf until after we do this!
 68 | 	cons_init();
 69 | 
 70 | 	// lab1_test();
 71 | 
 72 | 	// Lab 2: Initialize memory
 73 | 	mem_init();
 74 | 
 75 | 	// Lab 3: user environment initialization functions
 76 | 	env_init();
 77 | 	trap_init();
 78 | 
 79 | 	// Lab 4 multiprocessor initialization functions
 80 | 	mp_init();
 81 | 	lapic_init();
 82 | 
 83 | 	// Lab 4 multitasking initialization functions
 84 | 	pic_init();
 85 | 
 86 | 	// Acquire the big kernel lock before waking up APs
 87 | 	// Your code here:
 88 | 	lock_kernel();
 89 | 
 90 | 	// Starting non-boot CPUs
 91 | 	boot_aps();
 92 | 
 93 | 	// Start fs.
 94 | 	ENV_CREATE(fs_fs, ENV_TYPE_FS);
 95 | 
 96 | #if defined(TEST)
 97 | 	// Don't touch -- used by grading script!
 98 | 	ENV_CREATE(TEST, ENV_TYPE_USER);
 99 | #else
100 | 	// Touch all you want.
101 | 	ENV_CREATE(user_icode, ENV_TYPE_USER);
102 | 	ENV_CREATE(user_dumbfork, ENV_TYPE_USER);
103 | #endif // TEST*
104 | 
105 | 	// Should not be necessary - drains keyboard because interrupt has given up.
106 | 	kbd_intr();
107 | 
108 | 	// Schedule and run the first user environment!
109 | 	sched_yield();
110 | }
111 | 
112 | // While boot_aps is booting a given CPU, it communicates the per-core
113 | // stack pointer that should be loaded by mpentry.S to that CPU in
114 | // this variable.
115 | void *mpentry_kstack;
116 | 
117 | // Start the non-boot (AP) processors.
118 | static void
119 | boot_aps(void)
120 | {
121 | 	extern unsigned char mpentry_start[], mpentry_end[];
122 | 	void *code;
123 | 	struct CpuInfo *c;
124 | 
125 | 	// Write entry code to unused memory at MPENTRY_PADDR
126 | 	code = KADDR(MPENTRY_PADDR);
127 | 	memmove(code, mpentry_start, mpentry_end - mpentry_start);
128 | 
129 | 	// Boot each AP one at a time
130 | 	for (c = cpus; c < cpus + ncpu; c++) {
131 | 		if (c == cpus + cpunum())  // We've started already.
132 | 			continue;
133 | 
134 | 		// Tell mpentry.S what stack to use 
135 | 		mpentry_kstack = percpu_kstacks[c - cpus] + KSTKSIZE;
136 | 		// Start the CPU at mpentry_start
137 | 		lapic_startap(c->cpu_id, PADDR(code));
138 | 		// Wait for the CPU to finish some basic setup in mp_main()
139 | 		while(c->cpu_status != CPU_STARTED)
140 | 			;
141 | 	}
142 | }
143 | 
144 | // Setup code for APs
145 | void
146 | mp_main(void)
147 | {
148 | 	// We are in high EIP now, safe to switch to kern_pgdir 
149 | 	lcr3(PADDR(kern_pgdir));
150 | 	cprintf("SMP: CPU %d starting\n", cpunum());
151 | 
152 | 	lapic_init();
153 | 	env_init_percpu();
154 | 	trap_init_percpu();
155 | 	xchg(&thiscpu->cpu_status, CPU_STARTED); // tell boot_aps() we're up
156 | 
157 | 	// Now that we have finished some basic setup, call sched_yield()
158 | 	// to start running processes on this CPU.  But make sure that
159 | 	// only one CPU can enter the scheduler at a time!
160 | 	//
161 | 	// Your code here:
162 | 	// cprintf("SMP: CPU %d waiting lock\n", cpunum());
163 | 	lock_kernel();
164 | 	// cprintf("SMP: CPU %d scheduling\n", cpunum());
165 | 	sched_yield();
166 | }
167 | 
168 | /*
169 |  * Variable panicstr contains argument to first call to panic; used as flag
170 |  * to indicate that the kernel has already called panic.
171 |  */
172 | const char *panicstr;
173 | 
174 | /*
175 |  * Panic is called on unresolvable fatal errors.
176 |  * It prints "panic: mesg", and then enters the kernel monitor.
177 |  */
178 | void
179 | _panic(const char *file, int line, const char *fmt,...)
180 | {
181 | 	va_list ap;
182 | 
183 | 	if (panicstr)
184 | 		goto dead;
185 | 	panicstr = fmt;
186 | 
187 | 	// Be extra sure that the machine is in as reasonable state
188 | 	asm volatile("cli; cld");
189 | 
190 | 	va_start(ap, fmt);
191 | 	cprintf("kernel panic on CPU %d at %s:%d: ", cpunum(), file, line);
192 | 	vcprintf(fmt, ap);
193 | 	cprintf("\n");
194 | 	va_end(ap);
195 | 
196 | dead:
197 | 	/* break into the kernel monitor */
198 | 	while (1)
199 | 		monitor(NULL);
200 | }
201 | 
202 | /* like panic, but don't */
203 | void
204 | _warn(const char *file, int line, const char *fmt,...)
205 | {
206 | 	va_list ap;
207 | 
208 | 	va_start(ap, fmt);
209 | 	cprintf("kernel warning at %s:%d: ", file, line);
210 | 	vcprintf(fmt, ap);
211 | 	cprintf("\n");
212 | 	va_end(ap);
213 | }
214 | 


--------------------------------------------------------------------------------
/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 | int mon_continue(int argc, char **argv, struct Trapframe *tf);
19 | int mon_singlestep(int argc, char **argv, struct Trapframe *tf);
20 | int mon_showmapping(int argc, char **argv, struct Trapframe *tf);
21 | int mon_phymem(int argc, char **argv, struct Trapframe *tf);
22 | int mon_virtmem(int argc, char **argv, struct Trapframe *tf);
23 | int mon_chgperm(int argc, char **argv, struct Trapframe *tf);
24 | 
25 | #endif	// !JOS_KERN_MONITOR_H
26 | 


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


--------------------------------------------------------------------------------
/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 | #endif // !__ASSEMBLER__
27 | 
28 | #endif // !JOS_KERN_PICIRQ_H
29 | 


--------------------------------------------------------------------------------
/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 | pde_t *get_curr_pde();
92 | pte_t *pgdir_walk(pde_t *pgdir, const void *va, int create);
93 | 
94 | #endif /* !JOS_KERN_PMAP_H */
95 | 


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


--------------------------------------------------------------------------------
/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 | 	envid_t curid = curenv ? (ENVX(curenv->env_id)) % NENV : 0;
 34 | 	envid_t id2run = -1;
 35 | 
 36 | 	if (curenv && curenv->env_status == ENV_RUNNING) {
 37 | 		id2run = curid;
 38 | 	}
 39 | 	
 40 | 	for (uint32_t i = 0; i < NENV; ++i) {
 41 | 		envid_t id = (curid + i) % NENV;
 42 | 		if (envs[id].env_status == ENV_RUNNABLE) {
 43 | 			if (id2run == -1
 44 | 				|| envs[id].env_priority >= envs[id2run].env_priority) {
 45 | 				id2run = id;
 46 | 			}
 47 | 		}
 48 | 	}
 49 | 
 50 | 	if (id2run != -1) {
 51 | 		// cprintf("cpunum: %d running %d(priority: %d)\n", 
 52 | 		 	// cpunum(), id2run, envs[id2run].env_priority);
 53 | 		env_run(&envs[id2run]);
 54 | 	}
 55 | 
 56 | 	// sched_halt never returns
 57 | 	sched_halt();
 58 | }
 59 | 
 60 | // Halt this CPU when there is nothing to do. Wait until the
 61 | // timer interrupt wakes it up. This function never returns.
 62 | //
 63 | void
 64 | sched_halt(void)
 65 | {
 66 | 	int i;
 67 | 
 68 | 	// For debugging and testing purposes, if there are no runnable
 69 | 	// environments in the system, then drop into the kernel monitor.
 70 | 	for (i = 0; i < NENV; i++) {
 71 | 		if ((envs[i].env_status == ENV_RUNNABLE ||
 72 | 		     envs[i].env_status == ENV_RUNNING ||
 73 | 		     envs[i].env_status == ENV_DYING))
 74 | 			break;
 75 | 	}
 76 | 	if (i == NENV) {
 77 | 		cprintf("No runnable environments in the system!\n");
 78 | 		while (1)
 79 | 			monitor(NULL);
 80 | 	}
 81 | 
 82 | 	// Mark that no environment is running on this CPU
 83 | 	curenv = NULL;
 84 | 	lcr3(PADDR(kern_pgdir));
 85 | 
 86 | 	// Mark that this CPU is in the HALT state, so that when
 87 | 	// timer interupts come in, we know we should re-acquire the
 88 | 	// big kernel lock
 89 | 	xchg(&thiscpu->cpu_status, CPU_HALTED);
 90 | 
 91 | 	// Release the big kernel lock as if we were "leaving" the kernel
 92 | 	unlock_kernel();
 93 | 
 94 | 	// Reset stack pointer, enable interrupts and then halt.
 95 | 	asm volatile (
 96 | 		"movl $0, %%ebp\n"
 97 | 		"movl %0, %%esp\n"
 98 | 		"pushl $0\n"
 99 | 		"pushl $0\n"
100 | 		// Uncomment the following line after completing exercise 13
101 | 		"sti\n"
102 | 		"1:\n"
103 | 		"hlt\n"
104 | 		"jmp 1b\n"
105 | 	: : "a" (thiscpu->cpu_ts.ts_esp0));
106 | }
107 | 
108 | 


--------------------------------------------------------------------------------
/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.c:
--------------------------------------------------------------------------------
  1 | // Mutual exclusion spin locks.
  2 | 
  3 | #include <inc/types.h>
  4 | #include <inc/assert.h>
  5 | #include <inc/x86.h>
  6 | #include <inc/memlayout.h>
  7 | #include <inc/string.h>
  8 | #include <kern/cpu.h>
  9 | #include <kern/spinlock.h>
 10 | #include <kern/kdebug.h>
 11 | 
 12 | // The big kernel lock
 13 | struct spinlock kernel_lock = {
 14 | #ifdef DEBUG_SPINLOCK
 15 | 	.name = "kernel_lock"
 16 | #endif
 17 | };
 18 | 
 19 | #ifdef DEBUG_SPINLOCK
 20 | // Record the current call stack in pcs[] by following the %ebp chain.
 21 | static void
 22 | get_caller_pcs(uint32_t pcs[])
 23 | {
 24 | 	uint32_t *ebp;
 25 | 	int i;
 26 | 
 27 | 	ebp = (uint32_t *)read_ebp();
 28 | 	for (i = 0; i < 10; i++){
 29 | 		if (ebp == 0 || ebp < (uint32_t *)ULIM)
 30 | 			break;
 31 | 		pcs[i] = ebp[1];          // saved %eip
 32 | 		ebp = (uint32_t *)ebp[0]; // saved %ebp
 33 | 	}
 34 | 	for (; i < 10; i++)
 35 | 		pcs[i] = 0;
 36 | }
 37 | 
 38 | // Check whether this CPU is holding the lock.
 39 | static int
 40 | holding(struct spinlock *lock)
 41 | {
 42 | 	return lock->locked && lock->cpu == thiscpu;
 43 | }
 44 | #endif
 45 | 
 46 | void
 47 | __spin_initlock(struct spinlock *lk, char *name)
 48 | {
 49 | 	lk->locked = 0;
 50 | #ifdef DEBUG_SPINLOCK
 51 | 	lk->name = name;
 52 | 	lk->cpu = 0;
 53 | #endif
 54 | }
 55 | 
 56 | // Acquire the lock.
 57 | // Loops (spins) until the lock is acquired.
 58 | // Holding a lock for a long time may cause
 59 | // other CPUs to waste time spinning to acquire it.
 60 | void
 61 | spin_lock(struct spinlock *lk)
 62 | {
 63 | #ifdef DEBUG_SPINLOCK
 64 | 	if (holding(lk))
 65 | 		panic("CPU %d cannot acquire %s: already holding", cpunum(), lk->name);
 66 | #endif
 67 | 
 68 | 	// The xchg is atomic.
 69 | 	// It also serializes, so that reads after acquire are not
 70 | 	// reordered before it. 
 71 | 	while (xchg(&lk->locked, 1) != 0)
 72 | 		asm volatile ("pause");
 73 | 
 74 | 	// Record info about lock acquisition for debugging.
 75 | #ifdef DEBUG_SPINLOCK
 76 | 	lk->cpu = thiscpu;
 77 | 	get_caller_pcs(lk->pcs);
 78 | #endif
 79 | }
 80 | 
 81 | // Release the lock.
 82 | void
 83 | spin_unlock(struct spinlock *lk)
 84 | {
 85 | #ifdef DEBUG_SPINLOCK
 86 | 	if (!holding(lk)) {
 87 | 		int i;
 88 | 		uint32_t pcs[10];
 89 | 		// Nab the acquiring EIP chain before it gets released
 90 | 		memmove(pcs, lk->pcs, sizeof pcs);
 91 | 		cprintf("CPU %d cannot release %s: held by CPU %d\nAcquired at:", 
 92 | 			cpunum(), lk->name, lk->cpu->cpu_id);
 93 | 		for (i = 0; i < 10 && pcs[i]; i++) {
 94 | 			struct Eipdebuginfo info;
 95 | 			if (debuginfo_eip(pcs[i], &info) >= 0)
 96 | 				cprintf("  %08x %s:%d: %.*s+%x\n", pcs[i],
 97 | 					info.eip_file, info.eip_line,
 98 | 					info.eip_fn_namelen, info.eip_fn_name,
 99 | 					pcs[i] - info.eip_fn_addr);
100 | 			else
101 | 				cprintf("  %08x\n", pcs[i]);
102 | 		}
103 | 		panic("spin_unlock");
104 | 	}
105 | 
106 | 	lk->pcs[0] = 0;
107 | 	lk->cpu = 0;
108 | #endif
109 | 
110 | 	// The xchg instruction is atomic (i.e. uses the "lock" prefix) with
111 | 	// respect to any other instruction which references the same memory.
112 | 	// x86 CPUs will not reorder loads/stores across locked instructions
113 | 	// (vol 3, 8.2.2). Because xchg() is implemented using asm volatile,
114 | 	// gcc will not reorder C statements across the xchg.
115 | 	xchg(&lk->locked, 0);
116 | }
117 | 


--------------------------------------------------------------------------------
/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/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 | #include <kern/picirq.h>
  8 | 
  9 | 
 10 | ###################################################################
 11 | # exceptions/interrupts
 12 | ###################################################################
 13 | 
 14 | /* TRAPHANDLER defines a globally-visible function for handling a trap.
 15 |  * It pushes a trap number onto the stack, then jumps to _alltraps.
 16 |  * Use TRAPHANDLER for traps where the CPU automatically pushes an error code.
 17 |  *
 18 |  * You shouldn't call a TRAPHANDLER function from C, but you may
 19 |  * need to _declare_ one in C (for instance, to get a function pointer
 20 |  * during IDT setup).  You can declare the function with
 21 |  *   void NAME();
 22 |  * where NAME is the argument passed to TRAPHANDLER.
 23 |  */
 24 | #define TRAPHANDLER(name, num)						\
 25 | 	.globl name;		/* define global symbol for 'name' */	\
 26 | 	.type name, @function;	/* symbol type is function */		\
 27 | 	.align 2;		/* align function definition */		\
 28 | 	name:			/* function starts here */		\
 29 | 	pushl $(num);							\
 30 | 	jmp _alltraps
 31 | 
 32 | /* Use TRAPHANDLER_NOEC for traps where the CPU doesn't push an error code.
 33 |  * It pushes a 0 in place of the error code, so the trap frame has the same
 34 |  * format in either case.
 35 |  */
 36 | #define TRAPHANDLER_NOEC(name, num)					\
 37 | 	.globl name;							\
 38 | 	.type name, @function;						\
 39 | 	.align 2;							\
 40 | 	name:								\
 41 | 	pushl $0;							\
 42 | 	pushl $(num);							\
 43 | 	jmp _alltraps
 44 | 
 45 | .text
 46 | 
 47 | /*
 48 |  * Lab 3: Your code here for generating entry points for the different traps.
 49 |  */
 50 | 
 51 | TRAPHANDLER_NOEC(handler_div, T_DIVIDE)
 52 | TRAPHANDLER_NOEC(handler_debug, T_DEBUG)
 53 | TRAPHANDLER_NOEC(handler_nmi, T_NMI)
 54 | TRAPHANDLER_NOEC(handler_brkpt, T_BRKPT)
 55 | TRAPHANDLER_NOEC(handler_oflow, T_OFLOW)
 56 | TRAPHANDLER_NOEC(handler_bound, T_BOUND)
 57 | TRAPHANDLER_NOEC(handler_illop, T_ILLOP)
 58 | TRAPHANDLER_NOEC(handler_device, T_DEVICE)
 59 | TRAPHANDLER(handler_dblflt, T_DBLFLT)
 60 | TRAPHANDLER(handler_tss, T_TSS)
 61 | TRAPHANDLER(handler_segnp, T_SEGNP)
 62 | TRAPHANDLER(handler_stack, T_STACK)
 63 | TRAPHANDLER(handler_gpflt, T_GPFLT)
 64 | TRAPHANDLER(handler_pgflt, T_PGFLT)
 65 | TRAPHANDLER_NOEC(handler_fperr, T_FPERR)
 66 | TRAPHANDLER(handler_align, T_ALIGN)
 67 | TRAPHANDLER_NOEC(handler_mchk, T_MCHK)
 68 | TRAPHANDLER_NOEC(handler_simderr, T_SIMDERR)
 69 | 
 70 | TRAPHANDLER_NOEC(handler_irq0, IRQ_OFFSET)
 71 | TRAPHANDLER_NOEC(handler_irq1, IRQ_OFFSET + 1)
 72 | TRAPHANDLER_NOEC(handler_irq2, IRQ_OFFSET + 2)
 73 | TRAPHANDLER_NOEC(handler_irq3, IRQ_OFFSET + 3)
 74 | TRAPHANDLER_NOEC(handler_irq4, IRQ_OFFSET + 4)
 75 | TRAPHANDLER_NOEC(handler_irq5, IRQ_OFFSET + 5)
 76 | TRAPHANDLER_NOEC(handler_irq6, IRQ_OFFSET + 6)
 77 | TRAPHANDLER_NOEC(handler_irq7, IRQ_OFFSET + 7)
 78 | TRAPHANDLER_NOEC(handler_irq8, IRQ_OFFSET + 8)
 79 | TRAPHANDLER_NOEC(handler_irq9, IRQ_OFFSET + 9)
 80 | TRAPHANDLER_NOEC(handler_irq10, IRQ_OFFSET + 10)
 81 | TRAPHANDLER_NOEC(handler_irq11, IRQ_OFFSET + 11)
 82 | TRAPHANDLER_NOEC(handler_irq12, IRQ_OFFSET + 12)
 83 | TRAPHANDLER_NOEC(handler_irq13, IRQ_OFFSET + 13)
 84 | TRAPHANDLER_NOEC(handler_irq14, IRQ_OFFSET + 14)
 85 | TRAPHANDLER_NOEC(handler_irq15, IRQ_OFFSET + 15)
 86 | 
 87 | TRAPHANDLER_NOEC(handler_syscall, T_SYSCALL)
 88 | TRAPHANDLER_NOEC(handler_default, T_DEFAULT)
 89 | 
 90 | /*
 91 |  * Lab 3: Your code here for _alltraps
 92 |  */
 93 | 
 94 | _alltraps:
 95 | 	pushl %ds
 96 | 	pushl %es
 97 | 	pushal 
 98 | 	movw $GD_KD, %ax
 99 | 	movw %ax, %ds
100 | 	movw %ax, %es
101 | 	pushl %esp
102 | 	call trap
103 | 
104 | .data
105 | 	.global hanlder_table
106 | handler_table:
107 | 	.space 4096
108 | 
109 | 
110 | 


--------------------------------------------------------------------------------
/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/pipe.c \
29 | 			lib/wait.c
30 | 
31 | LIB_OBJFILES := $(patsubst lib/%.c, $(OBJDIR)/lib/%.o, $(LIB_SRCFILES))
32 | LIB_OBJFILES := $(patsubst lib/%.S, $(OBJDIR)/lib/%.o, $(LIB_OBJFILES))
33 | 
34 | $(OBJDIR)/lib/%.o: lib/%.c $(OBJDIR)/.vars.USER_CFLAGS
35 | 	@echo + cc[USER] $<
36 | 	@mkdir -p $(@D)
37 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
38 | 
39 | $(OBJDIR)/lib/%.o: lib/%.S $(OBJDIR)/.vars.USER_CFLAGS
40 | 	@echo + as[USER] $<
41 | 	@mkdir -p $(@D)
42 | 	$(V)$(CC) -nostdinc $(USER_CFLAGS) -c -o $@ $<
43 | 
44 | $(OBJDIR)/lib/libjos.a: $(LIB_OBJFILES)
45 | 	@echo + ar $@
46 | 	$(V)$(AR) r $@ $(LIB_OBJFILES)
47 | 


--------------------------------------------------------------------------------
/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/fork.c:
--------------------------------------------------------------------------------
  1 | // implement fork from user space
  2 | 
  3 | #include <inc/string.h>
  4 | #include <inc/lib.h>
  5 | 
  6 | // PTE_COW marks copy-on-write page table entries.
  7 | // It is one of the bits explicitly allocated to user processes (PTE_AVAIL).
  8 | #define PTE_COW		0x800
  9 | 
 10 | //
 11 | // Custom page fault handler - if faulting page is copy-on-write,
 12 | // map in our own private writable copy.
 13 | //
 14 | static void
 15 | pgfault(struct UTrapframe *utf)
 16 | {
 17 | 	void *addr = (void *) utf->utf_fault_va;
 18 | 	uint32_t err = utf->utf_err;
 19 | 	int r;
 20 | 	envid_t envid = sys_getenvid();
 21 | 
 22 | 	// Check that the faulting access was (1) a write, and (2) to a
 23 | 	// copy-on-write page.  If not, panic.
 24 | 	// Hint:
 25 | 	//   Use the read-only page table mappings at uvpt
 26 | 	//   (see <inc/memlayout.h>).
 27 | 
 28 | 	// LAB 4: Your code here.
 29 | 	pte_t pte = uvpt[(uintptr_t)addr >> PGSHIFT];
 30 | 	if (!(err & FEC_WR)) {
 31 | 		panic("Page Fault at %08x which is not writeable\n", addr);
 32 | 	}
 33 | 	if (!(pte & PTE_COW)) {
 34 | 		cprintf("%08x\n", utf->utf_eip);
 35 | 		panic("Page Fault at %08x but not a COW page\n", addr);
 36 | 	}
 37 | 
 38 | 	// Allocate a new page, map it at a temporary location (PFTEMP),
 39 | 	// copy the data from the old page to the new page, then move the new
 40 | 	// page to the old page's address.
 41 | 	// Hint:
 42 | 	//   You should make three system calls.
 43 | 
 44 | 	// LAB 4: Your code here.
 45 | 	uint32_t perm =  PTE_U | PTE_P | PTE_W;
 46 | 	if ((r = sys_page_alloc(envid, PFTEMP, perm)) < 0) {
 47 | 		panic("sys_page_alloc: %e\n", r);
 48 | 	}
 49 | 	memmove((void*)PFTEMP, ROUNDDOWN(addr, PGSIZE), PGSIZE);
 50 | 	if ((r = sys_page_alloc(envid, ROUNDDOWN(addr, PGSIZE), perm)) < 0) {
 51 | 		panic("sys_page_alloc: %e\n", r);
 52 | 	}
 53 | 	memmove(ROUNDDOWN(addr, PGSIZE), (void*)PFTEMP, PGSIZE);
 54 | 	if ((r = sys_page_unmap(envid, (void*)PFTEMP)) < 0) {
 55 | 		panic("sys_page_umap: %e\n", r);
 56 | 	}
 57 | }
 58 | 
 59 | //
 60 | // Map our virtual page pn (address pn*PGSIZE) into the target envid
 61 | // at the same virtual address.  If the page is writable or copy-on-write,
 62 | // the new mapping must be created copy-on-write, and then our mapping must be
 63 | // marked copy-on-write as well.  (Exercise: Why do we need to mark ours
 64 | // copy-on-write again if it was already copy-on-write at the beginning of
 65 | // this function?)
 66 | //
 67 | // Returns: 0 on success, < 0 on error.
 68 | // It is also OK to panic on error.
 69 | //
 70 | static int
 71 | duppage(envid_t envid, unsigned pn)
 72 | {
 73 | 	int r;
 74 | 	uintptr_t addr = pn * PGSIZE;
 75 | 	pte_t pte = uvpt[pn];
 76 | 	envid_t srcid = sys_getenvid();
 77 | 	int perm;
 78 | 
 79 | 	// LAB 4: Your code here.
 80 | 	if (((pte & PTE_W) || (pte & PTE_COW)) && !(pte & PTE_SHARE)) {
 81 | 		pte = (pte & (~PTE_W)) | PTE_COW;
 82 | 		perm = pte & PTE_SYSCALL;
 83 | 		if ((r = sys_page_map(srcid, (void*)addr, envid, (void*)addr, perm)) < 0) {
 84 | 			panic("sys_page_map: %e\n", r);
 85 | 		}
 86 | 		if ((r = sys_page_map(srcid, (void*)addr, srcid, (void*)addr, perm)) < 0) {
 87 | 			panic("sys_page_map: %e\n", r);
 88 | 		}
 89 | 	} else {
 90 | 		perm = pte & PTE_SYSCALL;
 91 | 		if ((r = sys_page_map(srcid, (void*)addr, envid, (void*)addr, perm)) < 0) {
 92 | 			panic("sys_page_map: %e\n", r);
 93 | 		}
 94 | 	}
 95 | 	return 0;
 96 | }
 97 | 
 98 | //
 99 | // User-level fork with copy-on-write.
100 | // Set up our page fault handler appropriately.
101 | // Create a child.
102 | // Copy our address space and page fault handler setup to the child.
103 | // Then mark the child as runnable and return.
104 | //
105 | // Returns: child's envid to the parent, 0 to the child, < 0 on error.
106 | // It is also OK to panic on error.
107 | //
108 | // Hint:
109 | //   Use uvpd, uvpt, and duppage.
110 | //   Remember to fix "thisenv" in the child process.
111 | //   Neither user exception stack should ever be marked copy-on-write,
112 | //   so you must allocate a new page for the child's user exception stack.
113 | //
114 | envid_t
115 | fork(void)
116 | {
117 | 	// LAB 4: Your code here.
118 | 	envid_t child;
119 | 
120 | 	set_pgfault_handler(pgfault);
121 | 	
122 | 	if ((child = sys_exofork()) < 0) {
123 | 		panic("sys_exofork: %e\n", child);
124 | 	}
125 | 	
126 | 	if (child == 0) { // child
127 | 		thisenv = &envs[ENVX(sys_getenvid())];
128 | 		return 0;
129 | 	}
130 | 
131 | 	// parent
132 | 	for (int i = 0; i < NPDENTRIES; ++i) {
133 | 		if (!(uvpd[i] & PTE_P)) continue;
134 | 		for (int j = 0; j < NPTENTRIES; ++j) {
135 | 			uint32_t pn = i * NPDENTRIES + j;
136 | 			if (pn == ((UXSTACKTOP - PGSIZE) >> PGSHIFT)) continue;
137 | 			if (pn * PGSIZE >= UTOP) continue;
138 | 			if (!(uvpt[pn] & PTE_P)) continue;
139 | 			duppage(child, pn);
140 | 		}
141 | 	}
142 | 	
143 | 	extern void *_pgfault_upcall();
144 | 	sys_env_set_pgfault_upcall(child, _pgfault_upcall);
145 | 	sys_page_alloc(child, (void*)(UXSTACKTOP - PGSIZE), PTE_W | PTE_U | PTE_P);
146 | 	sys_env_set_status(child, ENV_RUNNABLE);
147 | 	return child;
148 | }
149 | 
150 | // Challenge!
151 | int
152 | sfork(void)
153 | {
154 | 	panic("sfork not implemented");
155 | 	return -E_INVAL;
156 | }
157 | 


--------------------------------------------------------------------------------
/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 | 	int ret = 0;
27 | 	if (pg == NULL) {
28 | 		ret = sys_ipc_recv((void*)KERNBASE + 1);
29 | 	} else {
30 | 		ret = sys_ipc_recv(pg);
31 | 	}
32 | 	if (ret != 0) {
33 | 		if (from_env_store) *from_env_store = 0;
34 | 		if (perm_store) *perm_store = 0;
35 | 		return ret;
36 | 	}
37 | 	if (from_env_store) *from_env_store = thisenv->env_ipc_from;
38 | 	if (perm_store) *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) pg = (void*)KERNBASE + 1;
55 | 	while (true) {
56 | 		int ret = sys_ipc_try_send(to_env, val, pg, perm);
57 | 		if (ret == 0) break;
58 | 		if (ret != -E_IPC_NOT_RECV) {
59 | 			panic("ipc_send: error\n");
60 | 		}
61 | 		sys_yield();
62 | 	}
63 | }
64 | 
65 | // Find the first environment of the given type.  We'll use this to
66 | // find special environments.
67 | // Returns 0 if no such environment exists.
68 | envid_t
69 | ipc_find_env(enum EnvType type)
70 | {
71 | 	int i;
72 | 	for (i = 0; i < NENV; i++)
73 | 		if (envs[i].env_type == type)
74 | 			return envs[i].env_id;
75 | 	return 0;
76 | }
77 | 


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


--------------------------------------------------------------------------------
/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/pfentry.S:
--------------------------------------------------------------------------------
 1 | #include <inc/mmu.h>
 2 | #include <inc/memlayout.h>
 3 | 
 4 | // Page fault upcall entrypoint.
 5 | 
 6 | // This is where we ask the kernel to redirect us to whenever we cause
 7 | // a page fault in user space (see the call to sys_set_pgfault_handler
 8 | // in pgfault.c).
 9 | //
10 | // When a page fault actually occurs, the kernel switches our ESP to
11 | // point to the user exception stack if we're not already on the user
12 | // exception stack, and then it pushes a UTrapframe onto our user
13 | // exception stack:
14 | //
15 | //	trap-time esp
16 | //	trap-time eflags
17 | //	trap-time eip
18 | //	utf_regs.reg_eax
19 | //	...
20 | //	utf_regs.reg_esi
21 | //	utf_regs.reg_edi
22 | //	utf_err (error code)
23 | //	utf_fault_va            <-- %esp
24 | //
25 | // If this is a recursive fault, the kernel will reserve for us a
26 | // blank word above the trap-time esp for scratch work when we unwind
27 | // the recursive call.
28 | //
29 | // We then have call up to the appropriate page fault handler in C
30 | // code, pointed to by the global variable '_pgfault_handler'.
31 | 
32 | .text
33 | .globl _pgfault_upcall
34 | _pgfault_upcall:
35 | 	// Call the C page fault handler.
36 | 	pushl %esp			// function argument: pointer to UTF
37 | 	movl _pgfault_handler, %eax
38 | 	call *%eax
39 | 	addl $4, %esp			// pop function argument
40 | 	
41 | 	// Now the C page fault handler has returned and you must return
42 | 	// to the trap time state.
43 | 	// Push trap-time %eip onto the trap-time stack.
44 | 	//
45 | 	// Explanation:
46 | 	//   We must prepare the trap-time stack for our eventual return to
47 | 	//   re-execute the instruction that faulted.
48 | 	//   Unfortunately, we can't return directly from the exception stack:
49 | 	//   We can't call 'jmp', since that requires that we load the address
50 | 	//   into a register, and all registers must have their trap-time
51 | 	//   values after the return.
52 | 	//   We can't call 'ret' from the exception stack either, since if we
53 | 	//   did, %esp would have the wrong value.
54 | 	//   So instead, we push the trap-time %eip onto the *trap-time* stack!
55 | 	//   Below we'll switch to that stack and call 'ret', which will
56 | 	//   restore %eip to its pre-fault value.
57 | 	//
58 | 	//   In the case of a recursive fault on the exception stack,
59 | 	//   note that the word we're pushing now will fit in the
60 | 	//   blank word that the kernel reserved for us.
61 | 	//
62 | 	// Throughout the remaining code, think carefully about what
63 | 	// registers are available for intermediate calculations.  You
64 | 	// may find that you have to rearrange your code in non-obvious
65 | 	// ways as registers become unavailable as scratch space.
66 | 	//
67 | 	// LAB 4: Your code here.
68 | 	movl 48(%esp), %eax // trap-time esp
69 | 	subl $4, %eax
70 | 	movl 40(%esp), %ebx // trap-time eip
71 | 	movl %ebx, (%eax)
72 | 	movl %eax, 48(%esp)
73 | 
74 | 	// Restore the trap-time registers.  After you do this, you
75 | 	// can no longer modify any general-purpose registers.
76 | 	// LAB 4: Your code here.
77 | 	addl $8, %esp
78 | 	popal
79 | 
80 | 	// Restore eflags from the stack.  After you do this, you can
81 | 	// no longer use arithmetic operations or anything else that
82 | 	// modifies eflags.
83 | 	// LAB 4: Your code here.
84 | 	addl $4, %esp
85 | 	popfl
86 | 
87 | 	// Switch back to the adjusted trap-time stack.
88 | 	// LAB 4: Your code here.
89 | 	popl %esp
90 | 
91 | 	// Return to re-execute the instruction that faulted.
92 | 	// LAB 4: Your code here.
93 | 	ret
94 | 


--------------------------------------------------------------------------------
/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 | 		envid_t envid = sys_getenvid();
33 | 		sys_page_alloc(envid, (void*)(UXSTACKTOP - PGSIZE), PTE_W | PTE_U | PTE_P);
34 | 		sys_env_set_pgfault_upcall(envid, _pgfault_upcall);
35 | 	}
36 | 
37 | 	// Save handler pointer for assembly to call.
38 | 	_pgfault_handler = handler;
39 | }
40 | 


--------------------------------------------------------------------------------
/lib/pipe.c:
--------------------------------------------------------------------------------
  1 | #include <inc/lib.h>
  2 | 
  3 | #define debug 0
  4 | 
  5 | static ssize_t devpipe_read(struct Fd *fd, void *buf, size_t n);
  6 | static ssize_t devpipe_write(struct Fd *fd, const void *buf, size_t n);
  7 | static int devpipe_stat(struct Fd *fd, struct Stat *stat);
  8 | static int devpipe_close(struct Fd *fd);
  9 | 
 10 | struct Dev devpipe =
 11 | {
 12 | 	.dev_id =	'p',
 13 | 	.dev_name =	"pipe",
 14 | 	.dev_read =	devpipe_read,
 15 | 	.dev_write =	devpipe_write,
 16 | 	.dev_close =	devpipe_close,
 17 | 	.dev_stat =	devpipe_stat,
 18 | };
 19 | 
 20 | #define PIPEBUFSIZ 32		// small to provoke races
 21 | 
 22 | struct Pipe {
 23 | 	off_t p_rpos;		// read position
 24 | 	off_t p_wpos;		// write position
 25 | 	uint8_t p_buf[PIPEBUFSIZ];	// data buffer
 26 | };
 27 | 
 28 | int
 29 | pipe(int pfd[2])
 30 | {
 31 | 	int r;
 32 | 	struct Fd *fd0, *fd1;
 33 | 	void *va;
 34 | 
 35 | 	// allocate the file descriptor table entries
 36 | 	if ((r = fd_alloc(&fd0)) < 0
 37 | 	    || (r = sys_page_alloc(0, fd0, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
 38 | 		goto err;
 39 | 
 40 | 	if ((r = fd_alloc(&fd1)) < 0
 41 | 	    || (r = sys_page_alloc(0, fd1, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
 42 | 		goto err1;
 43 | 
 44 | 	// allocate the pipe structure as first data page in both
 45 | 	va = fd2data(fd0);
 46 | 	if ((r = sys_page_alloc(0, va, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
 47 | 		goto err2;
 48 | 	if ((r = sys_page_map(0, va, 0, fd2data(fd1), PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
 49 | 		goto err3;
 50 | 
 51 | 	// set up fd structures
 52 | 	fd0->fd_dev_id = devpipe.dev_id;
 53 | 	fd0->fd_omode = O_RDONLY;
 54 | 
 55 | 	fd1->fd_dev_id = devpipe.dev_id;
 56 | 	fd1->fd_omode = O_WRONLY;
 57 | 
 58 | 	if (debug)
 59 | 		cprintf("[%08x] pipecreate %08x\n", thisenv->env_id, uvpt[PGNUM(va)]);
 60 | 
 61 | 	pfd[0] = fd2num(fd0);
 62 | 	pfd[1] = fd2num(fd1);
 63 | 	return 0;
 64 | 
 65 |     err3:
 66 | 	sys_page_unmap(0, va);
 67 |     err2:
 68 | 	sys_page_unmap(0, fd1);
 69 |     err1:
 70 | 	sys_page_unmap(0, fd0);
 71 |     err:
 72 | 	return r;
 73 | }
 74 | 
 75 | static int
 76 | _pipeisclosed(struct Fd *fd, struct Pipe *p)
 77 | {
 78 | 	int n, nn, ret;
 79 | 
 80 | 	while (1) {
 81 | 		n = thisenv->env_runs;
 82 | 		ret = pageref(fd) == pageref(p);
 83 | 		nn = thisenv->env_runs;
 84 | 		if (n == nn)
 85 | 			return ret;
 86 | 		if (n != nn && ret == 1)
 87 | 			cprintf("pipe race avoided\n", n, thisenv->env_runs, ret);
 88 | 	}
 89 | }
 90 | 
 91 | int
 92 | pipeisclosed(int fdnum)
 93 | {
 94 | 	struct Fd *fd;
 95 | 	struct Pipe *p;
 96 | 	int r;
 97 | 
 98 | 	if ((r = fd_lookup(fdnum, &fd)) < 0)
 99 | 		return r;
100 | 	p = (struct Pipe*) fd2data(fd);
101 | 	return _pipeisclosed(fd, p);
102 | }
103 | 
104 | static ssize_t
105 | devpipe_read(struct Fd *fd, void *vbuf, size_t n)
106 | {
107 | 	uint8_t *buf;
108 | 	size_t i;
109 | 	struct Pipe *p;
110 | 
111 | 	p = (struct Pipe*)fd2data(fd);
112 | 	if (debug)
113 | 		cprintf("[%08x] devpipe_read %08x %d rpos %d wpos %d\n",
114 | 			thisenv->env_id, uvpt[PGNUM(p)], n, p->p_rpos, p->p_wpos);
115 | 
116 | 	buf = vbuf;
117 | 	for (i = 0; i < n; i++) {
118 | 		while (p->p_rpos == p->p_wpos) {
119 | 			// pipe is empty
120 | 			// if we got any data, return it
121 | 			if (i > 0)
122 | 				return i;
123 | 			// if all the writers are gone, note eof
124 | 			if (_pipeisclosed(fd, p))
125 | 				return 0;
126 | 			// yield and see what happens
127 | 			if (debug)
128 | 				cprintf("devpipe_read yield\n");
129 | 			sys_yield();
130 | 		}
131 | 		// there's a byte.  take it.
132 | 		// wait to increment rpos until the byte is taken!
133 | 		buf[i] = p->p_buf[p->p_rpos % PIPEBUFSIZ];
134 | 		p->p_rpos++;
135 | 	}
136 | 	return i;
137 | }
138 | 
139 | static ssize_t
140 | devpipe_write(struct Fd *fd, const void *vbuf, size_t n)
141 | {
142 | 	const uint8_t *buf;
143 | 	size_t i;
144 | 	struct Pipe *p;
145 | 
146 | 	p = (struct Pipe*) fd2data(fd);
147 | 	if (debug)
148 | 		cprintf("[%08x] devpipe_write %08x %d rpos %d wpos %d\n",
149 | 			thisenv->env_id, uvpt[PGNUM(p)], n, p->p_rpos, p->p_wpos);
150 | 
151 | 	buf = vbuf;
152 | 	for (i = 0; i < n; i++) {
153 | 		while (p->p_wpos >= p->p_rpos + sizeof(p->p_buf)) {
154 | 			// pipe is full
155 | 			// if all the readers are gone
156 | 			// (it's only writers like us now),
157 | 			// note eof
158 | 			if (_pipeisclosed(fd, p))
159 | 				return 0;
160 | 			// yield and see what happens
161 | 			if (debug)
162 | 				cprintf("devpipe_write yield\n");
163 | 			sys_yield();
164 | 		}
165 | 		// there's room for a byte.  store it.
166 | 		// wait to increment wpos until the byte is stored!
167 | 		p->p_buf[p->p_wpos % PIPEBUFSIZ] = buf[i];
168 | 		p->p_wpos++;
169 | 	}
170 | 
171 | 	return i;
172 | }
173 | 
174 | static int
175 | devpipe_stat(struct Fd *fd, struct Stat *stat)
176 | {
177 | 	struct Pipe *p = (struct Pipe*) fd2data(fd);
178 | 	strcpy(stat->st_name, "<pipe>");
179 | 	stat->st_size = p->p_wpos - p->p_rpos;
180 | 	stat->st_isdir = 0;
181 | 	stat->st_dev = &devpipe;
182 | 	return 0;
183 | }
184 | 
185 | static int
186 | devpipe_close(struct Fd *fd)
187 | {
188 | 	(void) sys_page_unmap(0, fd);
189 | 	return sys_page_unmap(0, fd2data(fd));
190 | }
191 | 
192 | 


--------------------------------------------------------------------------------
/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/syscall.c:
--------------------------------------------------------------------------------
  1 | // System call stubs.
  2 | 
  3 | #include <inc/syscall.h>
  4 | #include <inc/lib.h>
  5 | 
  6 | static inline int32_t
  7 | syscall(int num, int check, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
  8 | {
  9 | 	int32_t ret;
 10 | 
 11 | 	// Generic system call: pass system call number in AX,
 12 | 	// up to five parameters in DX, CX, BX, DI, SI.
 13 | 	// Interrupt kernel with T_SYSCALL.
 14 | 	//
 15 | 	// The "volatile" tells the assembler not to optimize
 16 | 	// this instruction away just because we don't use the
 17 | 	// return value.
 18 | 	//
 19 | 	// The last clause tells the assembler that this can
 20 | 	// potentially change the condition codes and arbitrary
 21 | 	// memory locations.
 22 | 
 23 | 	asm volatile("int %1\n"
 24 | 		     : "=a" (ret)
 25 | 		     : "i" (T_SYSCALL),
 26 | 		       "a" (num),
 27 | 		       "d" (a1),
 28 | 		       "c" (a2),
 29 | 		       "b" (a3),
 30 | 		       "D" (a4),
 31 | 		       "S" (a5)
 32 | 		     : "cc", "memory");
 33 | 
 34 | 	if(check && ret > 0)
 35 | 		panic("syscall %d returned %d (> 0)", num, ret);
 36 | 
 37 | 	return ret;
 38 | }
 39 | 
 40 | void
 41 | sys_cputs(const char *s, size_t len)
 42 | {
 43 | 	syscall(SYS_cputs, 0, (uint32_t)s, len, 0, 0, 0);
 44 | }
 45 | 
 46 | int
 47 | sys_cgetc(void)
 48 | {
 49 | 	return syscall(SYS_cgetc, 0, 0, 0, 0, 0, 0);
 50 | }
 51 | 
 52 | int
 53 | sys_env_destroy(envid_t envid)
 54 | {
 55 | 	return syscall(SYS_env_destroy, 1, envid, 0, 0, 0, 0);
 56 | }
 57 | 
 58 | envid_t
 59 | sys_getenvid(void)
 60 | {
 61 | 	 return syscall(SYS_getenvid, 0, 0, 0, 0, 0, 0);
 62 | }
 63 | 
 64 | void
 65 | sys_yield(void)
 66 | {
 67 | 	syscall(SYS_yield, 0, 0, 0, 0, 0, 0);
 68 | }
 69 | 
 70 | int
 71 | sys_page_alloc(envid_t envid, void *va, int perm)
 72 | {
 73 | 	return syscall(SYS_page_alloc, 1, envid, (uint32_t) va, perm, 0, 0);
 74 | }
 75 | 
 76 | int
 77 | sys_page_map(envid_t srcenv, void *srcva, envid_t dstenv, void *dstva, int perm)
 78 | {
 79 | 	return syscall(SYS_page_map, 1, srcenv, (uint32_t) srcva, dstenv, (uint32_t) dstva, perm);
 80 | }
 81 | 
 82 | int
 83 | sys_page_unmap(envid_t envid, void *va)
 84 | {
 85 | 	return syscall(SYS_page_unmap, 1, envid, (uint32_t) va, 0, 0, 0);
 86 | }
 87 | 
 88 | // sys_exofork is inlined in lib.h
 89 | 
 90 | int
 91 | sys_env_set_status(envid_t envid, int status)
 92 | {
 93 | 	return syscall(SYS_env_set_status, 1, envid, status, 0, 0, 0);
 94 | }
 95 | 
 96 | int
 97 | sys_env_set_trapframe(envid_t envid, struct Trapframe *tf)
 98 | {
 99 | 	return syscall(SYS_env_set_trapframe, 1, envid, (uint32_t) tf, 0, 0, 0);
100 | }
101 | 
102 | int
103 | sys_env_set_priority(envid_t envid, uint32_t priority)
104 | {
105 | 	return syscall(SYS_env_set_priority, 1, envid, priority, 0, 0, 0);
106 | }
107 | 
108 | int
109 | sys_env_set_pgfault_upcall(envid_t envid, void *upcall)
110 | {
111 | 	return syscall(SYS_env_set_pgfault_upcall, 1, envid, (uint32_t) upcall, 0, 0, 0);
112 | }
113 | 
114 | int
115 | sys_ipc_try_send(envid_t envid, uint32_t value, void *srcva, int perm)
116 | {
117 | 	return syscall(SYS_ipc_try_send, 0, envid, value, (uint32_t) srcva, perm, 0);
118 | }
119 | 
120 | int
121 | sys_ipc_recv(void *dstva)
122 | {
123 | 	return syscall(SYS_ipc_recv, 1, (uint32_t)dstva, 0, 0, 0, 0);
124 | }
125 | 
126 | 


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


--------------------------------------------------------------------------------
/reports/img/lab1-challenge.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hehao98/MIT6.828Labs-JOS/72858cf1df4ec2e4809440da297bf1c9e42652e8/reports/img/lab1-challenge.png


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


--------------------------------------------------------------------------------
/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 | 	asm volatile("addl %eax, %eax");
10 | 	asm volatile("addl %eax, %eax");
11 | 	asm volatile("addl %eax, %eax");
12 | 	asm volatile("int $3");
13 | 	asm volatile("addl %eax, %eax");
14 | }
15 | 
16 | 


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


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


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


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


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


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


--------------------------------------------------------------------------------
/user/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);
16 | }
17 | 
18 | void
19 | umain(int argc, char **argv)
20 | {
21 | 	set_pgfault_handler(handler);
22 | 	cprintf("%s\n", (char*)0xDeadBeef);
23 | 	cprintf("%s\n", (char*)0xCafeBffe);
24 | }
25 | 


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


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


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


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


--------------------------------------------------------------------------------
/user/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 | 
21 |         cprintf("%s: made it here --- bug\n");
22 | }
23 | 


--------------------------------------------------------------------------------
/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/faultregs.c:
--------------------------------------------------------------------------------
  1 | // test register restore on user-level page fault return
  2 | 
  3 | #include <inc/lib.h>
  4 | 
  5 | struct regs
  6 | {
  7 | 	struct PushRegs regs;
  8 | 	uintptr_t eip;
  9 | 	uint32_t eflags;
 10 | 	uintptr_t esp;
 11 | };
 12 | 
 13 | #define SAVE_REGS(base) \
 14 | 	"\tmovl %%edi, "base"+0x00\n" \
 15 | 	"\tmovl %%esi, "base"+0x04\n" \
 16 | 	"\tmovl %%ebp, "base"+0x08\n" \
 17 | 	"\tmovl %%ebx, "base"+0x10\n" \
 18 | 	"\tmovl %%edx, "base"+0x14\n" \
 19 | 	"\tmovl %%ecx, "base"+0x18\n" \
 20 | 	"\tmovl %%eax, "base"+0x1c\n" \
 21 | 	"\tmovl %%esp, "base"+0x28\n"
 22 | 
 23 | #define LOAD_REGS(base) \
 24 | 	"\tmovl "base"+0x00, %%edi\n" \
 25 | 	"\tmovl "base"+0x04, %%esi\n" \
 26 | 	"\tmovl "base"+0x08, %%ebp\n" \
 27 | 	"\tmovl "base"+0x10, %%ebx\n" \
 28 | 	"\tmovl "base"+0x14, %%edx\n" \
 29 | 	"\tmovl "base"+0x18, %%ecx\n" \
 30 | 	"\tmovl "base"+0x1c, %%eax\n" \
 31 | 	"\tmovl "base"+0x28, %%esp\n"
 32 | 
 33 | static struct regs before, during, after;
 34 | 
 35 | static void
 36 | check_regs(struct regs* a, const char *an, struct regs* b, const char *bn,
 37 | 	   const char *testname)
 38 | {
 39 | 	int mismatch = 0;
 40 | 
 41 | 	cprintf("%-6s %-8s %-8s\n", "", an, bn);
 42 | 
 43 | #define CHECK(name, field)						\
 44 | 	do {								\
 45 | 		cprintf("%-6s %08x %08x ", #name, a->field, b->field);	\
 46 | 		if (a->field == b->field)				\
 47 | 			cprintf("OK\n");				\
 48 | 		else {							\
 49 | 			cprintf("MISMATCH\n");				\
 50 | 			mismatch = 1;					\
 51 | 		}							\
 52 | 	} while (0)
 53 | 
 54 | 	CHECK(edi, regs.reg_edi);
 55 | 	CHECK(esi, regs.reg_esi);
 56 | 	CHECK(ebp, regs.reg_ebp);
 57 | 	CHECK(ebx, regs.reg_ebx);
 58 | 	CHECK(edx, regs.reg_edx);
 59 | 	CHECK(ecx, regs.reg_ecx);
 60 | 	CHECK(eax, regs.reg_eax);
 61 | 	CHECK(eip, eip);
 62 | 	CHECK(eflags, eflags);
 63 | 	CHECK(esp, esp);
 64 | 
 65 | #undef CHECK
 66 | 
 67 | 	cprintf("Registers %s ", testname);
 68 | 	if (!mismatch)
 69 | 		cprintf("OK\n");
 70 | 	else
 71 | 		cprintf("MISMATCH\n");
 72 | }
 73 | 
 74 | static void
 75 | pgfault(struct UTrapframe *utf)
 76 | {
 77 | 	int r;
 78 | 
 79 | 	if (utf->utf_fault_va != (uint32_t)UTEMP)
 80 | 		panic("pgfault expected at UTEMP, got 0x%08x (eip %08x)",
 81 | 		      utf->utf_fault_va, utf->utf_eip);
 82 | 
 83 | 	// Check registers in UTrapframe
 84 | 	during.regs = utf->utf_regs;
 85 | 	during.eip = utf->utf_eip;
 86 | 	during.eflags = utf->utf_eflags & ~FL_RF;
 87 | 	during.esp = utf->utf_esp;
 88 | 	check_regs(&before, "before", &during, "during", "in UTrapframe");
 89 | 
 90 | 	// Map UTEMP so the write succeeds
 91 | 	if ((r = sys_page_alloc(0, UTEMP, PTE_U|PTE_P|PTE_W)) < 0)
 92 | 		panic("sys_page_alloc: %e", r);
 93 | }
 94 | 
 95 | void
 96 | umain(int argc, char **argv)
 97 | {
 98 | 	set_pgfault_handler(pgfault);
 99 | 
100 | 	asm volatile(
101 | 		// Light up eflags to catch more errors
102 | 		"\tpushl %%eax\n"
103 | 		"\tpushfl\n"
104 | 		"\tpopl %%eax\n"
105 | 		"\torl $0x8d5, %%eax\n"
106 | 		"\tpushl %%eax\n"
107 | 		"\tpopfl\n"
108 | 
109 | 		// Save before registers
110 | 		// eflags
111 | 		"\tmov %%eax, %0+0x24\n"
112 | 		// eip
113 | 		"\tleal 0f, %%eax\n"
114 | 		"\tmovl %%eax, %0+0x20\n"
115 | 		"\tpopl %%eax\n"
116 | 		// others
117 | 		SAVE_REGS("%0")
118 | 
119 | 		// Fault at UTEMP
120 | 		"\t0: movl $42, 0x400000\n"
121 | 
122 | 		// Save after registers (except eip and eflags)
123 | 		SAVE_REGS("%1")
124 | 		// Restore registers (except eip and eflags).  This
125 | 		// way, the test will run even if EIP is the *only*
126 | 		// thing restored correctly.
127 | 		LOAD_REGS("%0")
128 | 		// Save after eflags (now that stack is back); note
129 | 		// that we were very careful not to modify eflags in
130 | 		// since we saved it
131 | 		"\tpushl %%eax\n"
132 | 		"\tpushfl\n"
133 | 		"\tpopl %%eax\n"
134 | 		"\tmov %%eax, %1+0x24\n"
135 | 		"\tpopl %%eax\n"
136 | 		: : "m" (before), "m" (after) : "memory", "cc");
137 | 
138 | 	// Check UTEMP to roughly determine that EIP was restored
139 | 	// correctly (of course, we probably wouldn't get this far if
140 | 	// it weren't)
141 | 	if (*(int*)UTEMP != 42)
142 | 		cprintf("EIP after page-fault MISMATCH\n");
143 | 	after.eip = before.eip;
144 | 
145 | 	check_regs(&before, "before", &after, "after", "after page-fault");
146 | }
147 | 


--------------------------------------------------------------------------------
/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/priority.c:
--------------------------------------------------------------------------------
 1 | #include <inc/lib.h>
 2 | 
 3 | void
 4 | umain(int argc, char **argv)
 5 | {
 6 | 	envid_t child;
 7 |     int ret;
 8 | 
 9 |     ret = sys_env_set_priority(thisenv->env_id, 1);
10 |      if (ret < 0) {
11 |         panic("sys_env_set_priority: failed\n");
12 |     }
13 | 
14 | 	if ((child = fork()) == 0) {
15 | 		// child
16 |         for (int i = 0; i < 5; ++i) {
17 | 		    cprintf("Spinning child...\n");
18 |             sys_yield();
19 |         }
20 |         return;
21 | 	}
22 | 
23 | 	// parent
24 |     for (int i = 0; i < 5; ++i) {
25 |         cprintf("Spinning parent...\n");
26 |         sys_yield();
27 |     }
28 |     return;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/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/testfile.c:
--------------------------------------------------------------------------------
  1 | #include <inc/lib.h>
  2 | 
  3 | const char *msg = "This is the NEW message of the day!\n\n";
  4 | 
  5 | #define FVA ((struct Fd*)0xCCCCC000)
  6 | 
  7 | static int
  8 | xopen(const char *path, int mode)
  9 | {
 10 | 	extern union Fsipc fsipcbuf;
 11 | 	envid_t fsenv;
 12 | 	
 13 | 	strcpy(fsipcbuf.open.req_path, path);
 14 | 	fsipcbuf.open.req_omode = mode;
 15 | 
 16 | 	fsenv = ipc_find_env(ENV_TYPE_FS);
 17 | 	ipc_send(fsenv, FSREQ_OPEN, &fsipcbuf, PTE_P | PTE_W | PTE_U);
 18 | 	return ipc_recv(NULL, FVA, NULL);
 19 | }
 20 | 
 21 | void
 22 | umain(int argc, char **argv)
 23 | {
 24 | 	int r, f, i;
 25 | 	struct Fd *fd;
 26 | 	struct Fd fdcopy;
 27 | 	struct Stat st;
 28 | 	char buf[512];
 29 | 
 30 | 	// We open files manually first, to avoid the FD layer
 31 | 	if ((r = xopen("/not-found", O_RDONLY)) < 0 && r != -E_NOT_FOUND)
 32 | 		panic("serve_open /not-found: %e", r);
 33 | 	else if (r >= 0)
 34 | 		panic("serve_open /not-found succeeded!");
 35 | 
 36 | 	if ((r = xopen("/newmotd", O_RDONLY)) < 0)
 37 | 		panic("serve_open /newmotd: %e", r);
 38 | 	if (FVA->fd_dev_id != 'f' || FVA->fd_offset != 0 || FVA->fd_omode != O_RDONLY)
 39 | 		panic("serve_open did not fill struct Fd correctly\n");
 40 | 	cprintf("serve_open is good\n");
 41 | 
 42 | 	if ((r = devfile.dev_stat(FVA, &st)) < 0)
 43 | 		panic("file_stat: %e", r);
 44 | 	if (strlen(msg) != st.st_size)
 45 | 		panic("file_stat returned size %d wanted %d\n", st.st_size, strlen(msg));
 46 | 	cprintf("file_stat is good\n");
 47 | 
 48 | 	memset(buf, 0, sizeof buf);
 49 | 	if ((r = devfile.dev_read(FVA, buf, sizeof buf)) < 0)
 50 | 		panic("file_read: %e", r);
 51 | 	if (strcmp(buf, msg) != 0)
 52 | 		panic("file_read returned wrong data");
 53 | 	cprintf("file_read is good\n");
 54 | 
 55 | 	if ((r = devfile.dev_close(FVA)) < 0)
 56 | 		panic("file_close: %e", r);
 57 | 	cprintf("file_close is good\n");
 58 | 
 59 | 	// We're about to unmap the FD, but still need a way to get
 60 | 	// the stale filenum to serve_read, so we make a local copy.
 61 | 	// The file server won't think it's stale until we unmap the
 62 | 	// FD page.
 63 | 	fdcopy = *FVA;
 64 | 	sys_page_unmap(0, FVA);
 65 | 
 66 | 	if ((r = devfile.dev_read(&fdcopy, buf, sizeof buf)) != -E_INVAL)
 67 | 		panic("serve_read does not handle stale fileids correctly: %e", r);
 68 | 	cprintf("stale fileid is good\n");
 69 | 
 70 | 	// Try writing
 71 | 	if ((r = xopen("/new-file", O_RDWR|O_CREAT)) < 0)
 72 | 		panic("serve_open /new-file: %e", r);
 73 | 
 74 | 	if ((r = devfile.dev_write(FVA, msg, strlen(msg))) != strlen(msg))
 75 | 		panic("file_write: %e", r);
 76 | 	cprintf("file_write is good\n");
 77 | 
 78 | 	FVA->fd_offset = 0;
 79 | 	memset(buf, 0, sizeof buf);
 80 | 	if ((r = devfile.dev_read(FVA, buf, sizeof buf)) < 0)
 81 | 		panic("file_read after file_write: %e", r);
 82 | 	if (r != strlen(msg))
 83 | 		panic("file_read after file_write returned wrong length: %d", r);
 84 | 	if (strcmp(buf, msg) != 0)
 85 | 		panic("file_read after file_write returned wrong data");
 86 | 	cprintf("file_read after file_write is good\n");
 87 | 
 88 | 	// Now we'll try out open
 89 | 	if ((r = open("/not-found", O_RDONLY)) < 0 && r != -E_NOT_FOUND)
 90 | 		panic("open /not-found: %e", r);
 91 | 	else if (r >= 0)
 92 | 		panic("open /not-found succeeded!");
 93 | 
 94 | 	if ((r = open("/newmotd", O_RDONLY)) < 0)
 95 | 		panic("open /newmotd: %e", r);
 96 | 	fd = (struct Fd*) (0xD0000000 + r*PGSIZE);
 97 | 	if (fd->fd_dev_id != 'f' || fd->fd_offset != 0 || fd->fd_omode != O_RDONLY)
 98 | 		panic("open did not fill struct Fd correctly\n");
 99 | 	cprintf("open is good\n");
100 | 
101 | 	// Try files with indirect blocks
102 | 	if ((f = open("/big", O_WRONLY|O_CREAT)) < 0)
103 | 		panic("creat /big: %e", f);
104 | 	memset(buf, 0, sizeof(buf));
105 | 	for (i = 0; i < (NDIRECT*3)*BLKSIZE; i += sizeof(buf)) {
106 | 		*(int*)buf = i;
107 | 		if ((r = write(f, buf, sizeof(buf))) < 0)
108 | 			panic("write /big@%d: %e", i, r);
109 | 	}
110 | 	close(f);
111 | 
112 | 	if ((f = open("/big", O_RDONLY)) < 0)
113 | 		panic("open /big: %e", f);
114 | 	for (i = 0; i < (NDIRECT*3)*BLKSIZE; i += sizeof(buf)) {
115 | 		*(int*)buf = i;
116 | 		if ((r = readn(f, buf, sizeof(buf))) < 0)
117 | 			panic("read /big@%d: %e", i, r);
118 | 		if (r != sizeof(buf))
119 | 			panic("read /big from %d returned %d < %d bytes",
120 | 			      i, r, sizeof(buf));
121 | 		if (*(int*)buf != i)
122 | 			panic("read /big from %d returned bad data %d",
123 | 			      i, *(int*)buf);
124 | 	}
125 | 	close(f);
126 | 	cprintf("large file is good\n");
127 | }
128 | 
129 | 


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


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


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


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


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


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


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


--------------------------------------------------------------------------------
/user/testshell.c:
--------------------------------------------------------------------------------
 1 | #include <inc/x86.h>
 2 | #include <inc/lib.h>
 3 | 
 4 | void wrong(int, int, int);
 5 | 
 6 | void
 7 | umain(int argc, char **argv)
 8 | {
 9 | 	char c1, c2;
10 | 	int r, rfd, wfd, kfd, n1, n2, off, nloff;
11 | 	int pfds[2];
12 | 
13 | 	close(0);
14 | 	close(1);
15 | 	opencons();
16 | 	opencons();
17 | 
18 | 	if ((rfd = open("testshell.sh", O_RDONLY)) < 0)
19 | 		panic("open testshell.sh: %e", rfd);
20 | 	if ((wfd = pipe(pfds)) < 0)
21 | 		panic("pipe: %e", wfd);
22 | 	wfd = pfds[1];
23 | 
24 | 	cprintf("running sh -x < testshell.sh | cat\n");
25 | 	if ((r = fork()) < 0)
26 | 		panic("fork: %e", r);
27 | 	if (r == 0) {
28 | 		dup(rfd, 0);
29 | 		dup(wfd, 1);
30 | 		close(rfd);
31 | 		close(wfd);
32 | 		if ((r = spawnl("/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/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 | 


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