diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..718f193aab178abbed59fb1831fa6cf925010f1b
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 SKTT1Ryze/hustccc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..a8676d518f9578bc9a6d688b929fac7de3e9ffef
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,264 @@
+
+#platform := k210
+platform := qemu
+# mode := debug
+mode := release
+K=kernel
+U=xv6-user
+T=target
+
+OBJS =
+ifeq ($(platform), k210)
+OBJS += $K/entry_k210.o
+else
+OBJS += $K/entry_qemu.o
+endif
+
+OBJS += \
+ $K/printf.o \
+ $K/kalloc.o \
+ $K/intr.o \
+ $K/spinlock.o \
+ $K/string.o \
+ $K/main.o \
+ $K/vm.o \
+ $K/proc.o \
+ $K/swtch.o \
+ $K/trampoline.o \
+ $K/trap.o \
+ $K/syscall.o \
+ $K/sysproc.o \
+ $K/bio.o \
+ $K/sleeplock.o \
+ $K/file.o \
+ $K/pipe.o \
+ $K/exec.o \
+ $K/sysfile.o \
+ $K/kernelvec.o \
+ $K/timer.o \
+ $K/disk.o \
+ $K/fat32.o \
+ $K/plic.o \
+ $K/console.o
+
+ifeq ($(platform), k210)
+OBJS += \
+ $K/spi.o \
+ $K/gpiohs.o \
+ $K/fpioa.o \
+ $K/utils.o \
+ $K/sdcard.o \
+ $K/dmac.o \
+ $K/sysctl.o \
+
+else
+OBJS += \
+ $K/virtio_disk.o \
+ #$K/uart.o \
+
+endif
+
+QEMU = qemu-system-riscv64
+
+ifeq ($(platform), k210)
+RUSTSBI = ./bootloader/SBI/sbi-k210
+else
+RUSTSBI = ./bootloader/SBI/sbi-qemu
+endif
+
+# TOOLPREFIX := riscv64-unknown-elf-
+TOOLPREFIX := riscv64-linux-gnu-
+CC = $(TOOLPREFIX)gcc
+AS = $(TOOLPREFIX)gas
+LD = $(TOOLPREFIX)ld
+OBJCOPY = $(TOOLPREFIX)objcopy
+OBJDUMP = $(TOOLPREFIX)objdump
+
+CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb -g
+CFLAGS += -MD
+CFLAGS += -mcmodel=medany
+CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax
+CFLAGS += -I.
+CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
+
+ifeq ($(mode), debug)
+CFLAGS += -DDEBUG
+endif
+
+ifeq ($(platform), qemu)
+CFLAGS += -D QEMU
+endif
+
+LDFLAGS = -z max-page-size=4096
+
+ifeq ($(platform), k210)
+linker = ./linker/k210.ld
+endif
+
+ifeq ($(platform), qemu)
+linker = ./linker/qemu.ld
+endif
+
+
+all: build
+ mv $T/kernel $T/kernel-qemu
+ cp $T/kernel-qemu kernel-qemu
+#local test
+local:
+ @make clean
+ @make build
+ @make fs
+
+# Compile Kernel
+$T/kernel: $(OBJS) $(linker) $U/initcode
+ @if [ ! -d "./target" ]; then mkdir target; fi
+ @$(LD) $(LDFLAGS) -T $(linker) -o $T/kernel $(OBJS)
+ @$(OBJDUMP) -S $T/kernel > $T/kernel.asm
+ @$(OBJDUMP) -t $T/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $T/kernel.sym
+
+build: $T/kernel userprogs
+
+# Compile RustSBI
+RUSTSBI:
+ifeq ($(platform), k210)
+ @cd ./bootloader/SBI/rustsbi-k210 && cargo build && cp ./target/riscv64gc-unknown-none-elf/debug/rustsbi-k210 ../sbi-k210
+ @$(OBJDUMP) -S ./bootloader/SBI/sbi-k210 > $T/rustsbi-k210.asm
+else
+ @cd ./bootloader/SBI/rustsbi-qemu && cargo build && cp ./target/riscv64gc-unknown-none-elf/debug/rustsbi-qemu ../sbi-qemu
+ @$(OBJDUMP) -S ./bootloader/SBI/sbi-qemu > $T/rustsbi-qemu.asm
+endif
+
+rustsbi-clean:
+ @cd ./bootloader/SBI/rustsbi-k210 && cargo clean
+ @cd ./bootloader/SBI/rustsbi-qemu && cargo clean
+
+image = $T/kernel.bin
+k210 = $T/k210.bin
+k210-serialport := /dev/ttyUSB0
+
+ifndef CPUS
+CPUS := 1
+endif
+
+QEMUOPTS = -machine virt -kernel $T/kernel -m 32M -nographic
+
+# use multi-core
+QEMUOPTS += -smp $(CPUS)
+
+QEMUOPTS += -bios $(RUSTSBI)
+
+# import virtual disk image
+QEMUOPTS += -drive file=fs.img,if=none,format=raw,id=x0
+QEMUOPTS += -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0
+
+run: build
+ifeq ($(platform), k210)
+ @$(OBJCOPY) $T/kernel --strip-all -O binary $(image)
+ @$(OBJCOPY) $(RUSTSBI) --strip-all -O binary $(k210)
+ @dd if=$(image) of=$(k210) bs=128k seek=1
+ @$(OBJDUMP) -D -b binary -m riscv $(k210) > $T/k210.asm
+ @chmod 777 $(k210-serialport)
+ @python3 ./tools/kflash.py -p $(k210-serialport) -b 1500000 -t $(k210)
+else
+ @$(QEMU) $(QEMUOPTS)
+endif
+
+$U/initcode: $U/initcode.S
+ $(CC) $(CFLAGS) -march=rv64g -nostdinc -I. -Ikernel -c $U/initcode.S -o $U/initcode.o
+ $(LD) $(LDFLAGS) -N -e start -Ttext 0 -o $U/initcode.out $U/initcode.o
+ $(OBJCOPY) -S -O binary $U/initcode.out $U/initcode
+ $(OBJDUMP) -S $U/initcode.o > $U/initcode.asm
+
+tags: $(OBJS) _init
+ @etags *.S *.c
+
+ULIB = $U/ulib.o $U/usys.o $U/printf.o $U/umalloc.o
+
+_%: %.o $(ULIB)
+ $(LD) $(LDFLAGS) -N -e main -Ttext 0 -o $@ $^
+ $(OBJDUMP) -S $@ > $*.asm
+ $(OBJDUMP) -t $@ | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $*.sym
+
+$U/usys.S : $U/usys.pl
+ @perl $U/usys.pl > $U/usys.S
+
+$U/usys.o : $U/usys.S
+ $(CC) $(CFLAGS) -c -o $U/usys.o $U/usys.S
+
+$U/_forktest: $U/forktest.o $(ULIB)
+ # forktest has less library code linked in - needs to be small
+ # in order to be able to max out the proc table.
+ $(LD) $(LDFLAGS) -N -e main -Ttext 0 -o $U/_forktest $U/forktest.o $U/ulib.o $U/usys.o
+ $(OBJDUMP) -S $U/_forktest > $U/forktest.asm
+
+# Prevent deletion of intermediate files, e.g. cat.o, after first build, so
+# that disk image changes after first build are persistent until clean. More
+# details:
+# http://www.gnu.org/software/make/manual/html_node/Chained-Rules.html
+.PRECIOUS: %.o
+
+UPROGS=\
+ $U/_init\
+ $U/_sh\
+ $U/_cat\
+ $U/_echo\
+ $U/_grep\
+ $U/_ls\
+ $U/_kill\
+ $U/_mkdir\
+ $U/_xargs\
+ $U/_sleep\
+ $U/_find\
+ $U/_rm\
+ $U/_wc\
+ $U/_test\
+ $U/_usertests\
+ $U/_strace\
+ $U/_mv\
+ $U/_sysinfo\
+ # $U/_forktest\
+ # $U/_ln\
+ # $U/_stressfs\
+ # $U/_grind\
+ # $U/_zombie\
+
+userprogs: $(UPROGS)
+
+dst=/mnt
+
+# @sudo cp $U/_init $(dst)/init
+# @sudo cp $U/_sh $(dst)/sh
+# Make fs image
+fs: $(UPROGS)
+ @if [ ! -f "fs.img" ]; then \
+ echo "making fs image..."; \
+ dd if=/dev/zero of=fs.img bs=512k count=512; \
+ mkfs.vfat -F 32 fs.img; fi
+ @mount fs.img $(dst)
+ @if [ ! -d "$(dst)/bin" ]; then mkdir $(dst)/bin; fi
+ @cp README $(dst)/README
+ @for file in $$( ls $U/_* ); do \
+ cp $$file $(dst)/$${file#$U/_};\
+ cp $$file $(dst)/bin/$${file#$U/_}; done
+ @cp -r ./riscv64 $(dst)
+ @umount $(dst)
+
+
+# Write mounted sdcard
+sdcard: userprogs
+ @if [ ! -d "$(dst)/bin" ]; then mkdir $(dst)/bin; fi
+ @for file in $$( ls $U/_* ); do \
+ cp $$file $(dst)/bin/$${file#$U/_}; done
+ @cp $U/_init $(dst)/init
+ @cp $U/_sh $(dst)/sh
+ @cp README $(dst)/README
+
+clean:
+ rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \
+ */*.o */*.d */*.asm */*.sym \
+ $T/* \
+ $U/initcode $U/initcode.out \
+ $K/kernel \
+ .gdbinit \
+ $U/usys.S \
+ $(UPROGS)
diff --git a/debug/kendryte_openocd/openocd b/debug/kendryte_openocd/openocd
new file mode 100644
index 0000000000000000000000000000000000000000..8bb4ab414d2024fbfeb29ed85cb18f89d28c1f76
Binary files /dev/null and b/debug/kendryte_openocd/openocd differ
diff --git a/debug/openocd_cfg/ft2232c.cfg b/debug/openocd_cfg/ft2232c.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d2d405ede48e77d774f5a84dbd4d2da2ea4b6fdb
--- /dev/null
+++ b/debug/openocd_cfg/ft2232c.cfg
@@ -0,0 +1,6 @@
+interface ftdi
+ftdi_vid_pid 0x0403 0x6010
+
+ftdi_layout_init 0xfff8 0xfffb
+ftdi_layout_signal nTRST -data 0x0100 -oe 0x0100
+ftdi_layout_signal nSRST -data 0x0200 -oe 0x0200
\ No newline at end of file
diff --git a/debug/openocd_cfg/k210.cfg b/debug/openocd_cfg/k210.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..556a43fb217d4981444b6422a025794a3f4a4ea8
--- /dev/null
+++ b/debug/openocd_cfg/k210.cfg
@@ -0,0 +1,21 @@
+# debug adapter
+source [find ft2232c.cfg]
+
+transport select jtag
+adapter_khz 10000
+
+# server port
+gdb_port 3333
+telnet_port 4444
+
+# add cpu target
+set _CHIPNAME riscv
+
+jtag newtap $_CHIPNAME cpu -irlen 5 -expected-id 0x04e4796b
+
+set _TARGETNAME $_CHIPNAME.cpu
+target create $_TARGETNAME riscv -chain-position $_TARGETNAME
+
+# command
+init
+halt
\ No newline at end of file
diff --git a/debug/openocd_cfg/openocd_ftdi.cfg b/debug/openocd_cfg/openocd_ftdi.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..609ac2f003661f4a275b484c725f09f817715d32
--- /dev/null
+++ b/debug/openocd_cfg/openocd_ftdi.cfg
@@ -0,0 +1,42 @@
+interface ftdi
+
+ftdi_vid_pid 0x0403 0x6010
+
+#func io dir val
+#TCK 0 1 0
+#TDI 1 1 0
+#TDO 2 1 0
+#TMS 3 0 1
+#RST 4 1 1
+
+# val dir
+#ftdi_layout_init 0x0028 0x002b
+#åªæœ‰jtagio分é…
+ftdi_layout_init 0x00e8 0x00eb
+
+#ftdi_layout_init 0x0808 0x0a1b
+#ftdi_layout_signal nSRST -oe 0x0200
+#ftdi_layout_signal nTRST -data 0x0100 -oe 0x0100
+#ftdi_layout_signal LED -data 0x0800
+
+transport select jtag
+ftdi_tdo_sample_edge falling
+adapter_khz 64000
+
+gdb_port 3333
+telnet_port 4444
+
+set _CHIPNAME riscv
+
+jtag newtap $_CHIPNAME cpu -irlen 5 -expected-id 0x04e4796b
+
+set _TARGETNAME $_CHIPNAME.cpu
+target create $_TARGETNAME riscv -chain-position $_TARGETNAME
+
+#if {[ info exists pulse_srst]} {
+# ftdi_set_signal nSRST 0
+# ftdi_set_signal nSRST z
+#}
+
+init
+halt
diff --git a/fs.img b/fs.img
new file mode 100644
index 0000000000000000000000000000000000000000..53c6e961896d7a345001215407449555d4ebc40b
Binary files /dev/null and b/fs.img differ
diff --git a/target/kernel b/target/kernel
new file mode 100644
index 0000000000000000000000000000000000000000..8f76b33d7e4d95bf2914fe456b592ee5b5e709c9
Binary files /dev/null and b/target/kernel differ
diff --git a/target/kernel.asm b/target/kernel.asm
new file mode 100644
index 0000000000000000000000000000000000000000..0f578432bea6d25c1375e761b9aaf3c1a0b799d8
--- /dev/null
+++ b/target/kernel.asm
@@ -0,0 +1,15557 @@
+
+target/kernel: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000080200000 <_entry>:
+ 80200000: 00150293 addi t0,a0,1
+ 80200004: 02ba slli t0,t0,0xe
+ 80200006: 0000c117 auipc sp,0xc
+ 8020000a: d2213103 ld sp,-734(sp) # 8020bd28 <_GLOBAL_OFFSET_TABLE_+0x50>
+ 8020000e: 9116 add sp,sp,t0
+ 80200010: 1d5000ef jal ra,802009e4 <main>
+
+0000000080200014 <loop>:
+ 80200014: a001 j 80200014 <loop>
+
+0000000080200016 <printint>:
+ }
+}
+
+static void
+printint(int xx, int base, int sign)
+{
+ 80200016: 7179 addi sp,sp,-48
+ 80200018: f406 sd ra,40(sp)
+ 8020001a: f022 sd s0,32(sp)
+ 8020001c: ec26 sd s1,24(sp)
+ 8020001e: e84a sd s2,16(sp)
+ 80200020: 1800 addi s0,sp,48
+ char buf[16];
+ int i;
+ uint x;
+
+ if(sign && (sign = xx < 0))
+ 80200022: c219 beqz a2,80200028 <printint+0x12>
+ 80200024: 08054663 bltz a0,802000b0 <printint+0x9a>
+ x = -xx;
+ else
+ x = xx;
+ 80200028: 2501 sext.w a0,a0
+ 8020002a: 4881 li a7,0
+
+ i = 0;
+ 8020002c: fd040913 addi s2,s0,-48
+ x = xx;
+ 80200030: 86ca mv a3,s2
+ i = 0;
+ 80200032: 4701 li a4,0
+ do {
+ buf[i++] = digits[x % base];
+ 80200034: 2581 sext.w a1,a1
+ 80200036: 00009617 auipc a2,0x9
+ 8020003a: 34a60613 addi a2,a2,842 # 80209380 <digits>
+ 8020003e: 883a mv a6,a4
+ 80200040: 2705 addiw a4,a4,1
+ 80200042: 02b577bb remuw a5,a0,a1
+ 80200046: 1782 slli a5,a5,0x20
+ 80200048: 9381 srli a5,a5,0x20
+ 8020004a: 97b2 add a5,a5,a2
+ 8020004c: 0007c783 lbu a5,0(a5)
+ 80200050: 00f68023 sb a5,0(a3)
+ } while((x /= base) != 0);
+ 80200054: 0005079b sext.w a5,a0
+ 80200058: 02b5553b divuw a0,a0,a1
+ 8020005c: 0685 addi a3,a3,1
+ 8020005e: feb7f0e3 bgeu a5,a1,8020003e <printint+0x28>
+
+ if(sign)
+ 80200062: 00088c63 beqz a7,8020007a <printint+0x64>
+ buf[i++] = '-';
+ 80200066: fe070793 addi a5,a4,-32
+ 8020006a: 00878733 add a4,a5,s0
+ 8020006e: 02d00793 li a5,45
+ 80200072: fef70823 sb a5,-16(a4)
+ 80200076: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 8020007a: 02e05563 blez a4,802000a4 <printint+0x8e>
+ 8020007e: fd040493 addi s1,s0,-48
+ 80200082: 94ba add s1,s1,a4
+ 80200084: 197d addi s2,s2,-1
+ 80200086: 993a add s2,s2,a4
+ 80200088: 377d addiw a4,a4,-1
+ 8020008a: 1702 slli a4,a4,0x20
+ 8020008c: 9301 srli a4,a4,0x20
+ 8020008e: 40e90933 sub s2,s2,a4
+ consputc(buf[i]);
+ 80200092: fff4c503 lbu a0,-1(s1)
+ 80200096: 00007097 auipc ra,0x7
+ 8020009a: 014080e7 jalr 20(ra) # 802070aa <consputc>
+ while(--i >= 0)
+ 8020009e: 14fd addi s1,s1,-1
+ 802000a0: ff2499e3 bne s1,s2,80200092 <printint+0x7c>
+}
+ 802000a4: 70a2 ld ra,40(sp)
+ 802000a6: 7402 ld s0,32(sp)
+ 802000a8: 64e2 ld s1,24(sp)
+ 802000aa: 6942 ld s2,16(sp)
+ 802000ac: 6145 addi sp,sp,48
+ 802000ae: 8082 ret
+ x = -xx;
+ 802000b0: 40a0053b negw a0,a0
+ if(sign && (sign = xx < 0))
+ 802000b4: 4885 li a7,1
+ x = -xx;
+ 802000b6: bf9d j 8020002c <printint+0x16>
+
+00000000802000b8 <printstring>:
+void printstring(const char* s) {
+ 802000b8: 1101 addi sp,sp,-32
+ 802000ba: ec06 sd ra,24(sp)
+ 802000bc: e822 sd s0,16(sp)
+ 802000be: e426 sd s1,8(sp)
+ 802000c0: 1000 addi s0,sp,32
+ 802000c2: 84aa mv s1,a0
+ while (*s)
+ 802000c4: 00054503 lbu a0,0(a0)
+ 802000c8: c909 beqz a0,802000da <printstring+0x22>
+ consputc(*s++);
+ 802000ca: 0485 addi s1,s1,1
+ 802000cc: 00007097 auipc ra,0x7
+ 802000d0: fde080e7 jalr -34(ra) # 802070aa <consputc>
+ while (*s)
+ 802000d4: 0004c503 lbu a0,0(s1)
+ 802000d8: f96d bnez a0,802000ca <printstring+0x12>
+}
+ 802000da: 60e2 ld ra,24(sp)
+ 802000dc: 6442 ld s0,16(sp)
+ 802000de: 64a2 ld s1,8(sp)
+ 802000e0: 6105 addi sp,sp,32
+ 802000e2: 8082 ret
+
+00000000802000e4 <backtrace>:
+ for(;;)
+ ;
+}
+
+void backtrace()
+{
+ 802000e4: 7179 addi sp,sp,-48
+ 802000e6: f406 sd ra,40(sp)
+ 802000e8: f022 sd s0,32(sp)
+ 802000ea: ec26 sd s1,24(sp)
+ 802000ec: e84a sd s2,16(sp)
+ 802000ee: e44e sd s3,8(sp)
+ 802000f0: 1800 addi s0,sp,48
+
+static inline uint64
+r_fp()
+{
+ uint64 x;
+ asm volatile("mv %0, s0" : "=r" (x) );
+ 802000f2: 8922 mv s2,s0
+ uint64 *fp = (uint64 *)r_fp();
+ 802000f4: 84ca mv s1,s2
+ uint64 *bottom = (uint64 *)PGROUNDUP((uint64)fp);
+ 802000f6: 6785 lui a5,0x1
+ 802000f8: 17fd addi a5,a5,-1 # fff <_entry-0x801ff001>
+ 802000fa: 993e add s2,s2,a5
+ 802000fc: 77fd lui a5,0xfffff
+ 802000fe: 00f97933 and s2,s2,a5
+ printf("backtrace:\n");
+ 80200102: 00009517 auipc a0,0x9
+ 80200106: efe50513 addi a0,a0,-258 # 80209000 <etext>
+ 8020010a: 00000097 auipc ra,0x0
+ 8020010e: 084080e7 jalr 132(ra) # 8020018e <printf>
+ while (fp < bottom) {
+ 80200112: 0324f263 bgeu s1,s2,80200136 <backtrace+0x52>
+ uint64 ra = *(fp - 1);
+ printf("%p\n", ra - 4);
+ 80200116: 00009997 auipc s3,0x9
+ 8020011a: 4d298993 addi s3,s3,1234 # 802095e8 <digits+0x268>
+ 8020011e: ff84b583 ld a1,-8(s1)
+ 80200122: 15f1 addi a1,a1,-4
+ 80200124: 854e mv a0,s3
+ 80200126: 00000097 auipc ra,0x0
+ 8020012a: 068080e7 jalr 104(ra) # 8020018e <printf>
+ fp = (uint64 *)*(fp - 2);
+ 8020012e: ff04b483 ld s1,-16(s1)
+ while (fp < bottom) {
+ 80200132: ff24e6e3 bltu s1,s2,8020011e <backtrace+0x3a>
+ }
+}
+ 80200136: 70a2 ld ra,40(sp)
+ 80200138: 7402 ld s0,32(sp)
+ 8020013a: 64e2 ld s1,24(sp)
+ 8020013c: 6942 ld s2,16(sp)
+ 8020013e: 69a2 ld s3,8(sp)
+ 80200140: 6145 addi sp,sp,48
+ 80200142: 8082 ret
+
+0000000080200144 <panic>:
+{
+ 80200144: 1101 addi sp,sp,-32
+ 80200146: ec06 sd ra,24(sp)
+ 80200148: e822 sd s0,16(sp)
+ 8020014a: e426 sd s1,8(sp)
+ 8020014c: 1000 addi s0,sp,32
+ 8020014e: 84aa mv s1,a0
+ printf("panic: ");
+ 80200150: 00009517 auipc a0,0x9
+ 80200154: ec050513 addi a0,a0,-320 # 80209010 <etext+0x10>
+ 80200158: 00000097 auipc ra,0x0
+ 8020015c: 036080e7 jalr 54(ra) # 8020018e <printf>
+ printf(s);
+ 80200160: 8526 mv a0,s1
+ 80200162: 00000097 auipc ra,0x0
+ 80200166: 02c080e7 jalr 44(ra) # 8020018e <printf>
+ printf("\n");
+ 8020016a: 00009517 auipc a0,0x9
+ 8020016e: f6e50513 addi a0,a0,-146 # 802090d8 <etext+0xd8>
+ 80200172: 00000097 auipc ra,0x0
+ 80200176: 01c080e7 jalr 28(ra) # 8020018e <printf>
+ backtrace();
+ 8020017a: 00000097 auipc ra,0x0
+ 8020017e: f6a080e7 jalr -150(ra) # 802000e4 <backtrace>
+ panicked = 1; // freeze uart output from other CPUs
+ 80200182: 4785 li a5,1
+ 80200184: 00014717 auipc a4,0x14
+ 80200188: e6f72e23 sw a5,-388(a4) # 80214000 <panicked>
+ for(;;)
+ 8020018c: a001 j 8020018c <panic+0x48>
+
+000000008020018e <printf>:
+{
+ 8020018e: 7131 addi sp,sp,-192
+ 80200190: fc86 sd ra,120(sp)
+ 80200192: f8a2 sd s0,112(sp)
+ 80200194: f4a6 sd s1,104(sp)
+ 80200196: f0ca sd s2,96(sp)
+ 80200198: ecce sd s3,88(sp)
+ 8020019a: e8d2 sd s4,80(sp)
+ 8020019c: e4d6 sd s5,72(sp)
+ 8020019e: e0da sd s6,64(sp)
+ 802001a0: fc5e sd s7,56(sp)
+ 802001a2: f862 sd s8,48(sp)
+ 802001a4: f466 sd s9,40(sp)
+ 802001a6: f06a sd s10,32(sp)
+ 802001a8: ec6e sd s11,24(sp)
+ 802001aa: 0100 addi s0,sp,128
+ 802001ac: 8a2a mv s4,a0
+ 802001ae: e40c sd a1,8(s0)
+ 802001b0: e810 sd a2,16(s0)
+ 802001b2: ec14 sd a3,24(s0)
+ 802001b4: f018 sd a4,32(s0)
+ 802001b6: f41c sd a5,40(s0)
+ 802001b8: 03043823 sd a6,48(s0)
+ 802001bc: 03143c23 sd a7,56(s0)
+ locking = pr.locking;
+ 802001c0: 00014d97 auipc s11,0x14
+ 802001c4: e60dad83 lw s11,-416(s11) # 80214020 <pr+0x18>
+ if(locking)
+ 802001c8: 020d9b63 bnez s11,802001fe <printf+0x70>
+ if (fmt == 0)
+ 802001cc: 040a0263 beqz s4,80200210 <printf+0x82>
+ va_start(ap, fmt);
+ 802001d0: 00840793 addi a5,s0,8
+ 802001d4: f8f43423 sd a5,-120(s0)
+ for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
+ 802001d8: 000a4503 lbu a0,0(s4)
+ 802001dc: 14050f63 beqz a0,8020033a <printf+0x1ac>
+ 802001e0: 4981 li s3,0
+ if(c != '%'){
+ 802001e2: 02500a93 li s5,37
+ switch(c){
+ 802001e6: 07000b93 li s7,112
+ consputc('x');
+ 802001ea: 4d41 li s10,16
+ consputc(digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 802001ec: 00009b17 auipc s6,0x9
+ 802001f0: 194b0b13 addi s6,s6,404 # 80209380 <digits>
+ switch(c){
+ 802001f4: 07300c93 li s9,115
+ 802001f8: 06400c13 li s8,100
+ 802001fc: a82d j 80200236 <printf+0xa8>
+ acquire(&pr.lock);
+ 802001fe: 00014517 auipc a0,0x14
+ 80200202: e0a50513 addi a0,a0,-502 # 80214008 <pr>
+ 80200206: 00000097 auipc ra,0x0
+ 8020020a: 4c0080e7 jalr 1216(ra) # 802006c6 <acquire>
+ 8020020e: bf7d j 802001cc <printf+0x3e>
+ panic("null fmt");
+ 80200210: 00009517 auipc a0,0x9
+ 80200214: e1050513 addi a0,a0,-496 # 80209020 <etext+0x20>
+ 80200218: 00000097 auipc ra,0x0
+ 8020021c: f2c080e7 jalr -212(ra) # 80200144 <panic>
+ consputc(c);
+ 80200220: 00007097 auipc ra,0x7
+ 80200224: e8a080e7 jalr -374(ra) # 802070aa <consputc>
+ for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
+ 80200228: 2985 addiw s3,s3,1
+ 8020022a: 013a07b3 add a5,s4,s3
+ 8020022e: 0007c503 lbu a0,0(a5) # fffffffffffff000 <ebss_clear+0xffffffff7fdd9000>
+ 80200232: 10050463 beqz a0,8020033a <printf+0x1ac>
+ if(c != '%'){
+ 80200236: ff5515e3 bne a0,s5,80200220 <printf+0x92>
+ c = fmt[++i] & 0xff;
+ 8020023a: 2985 addiw s3,s3,1
+ 8020023c: 013a07b3 add a5,s4,s3
+ 80200240: 0007c783 lbu a5,0(a5)
+ 80200244: 0007849b sext.w s1,a5
+ if(c == 0)
+ 80200248: cbed beqz a5,8020033a <printf+0x1ac>
+ switch(c){
+ 8020024a: 05778a63 beq a5,s7,8020029e <printf+0x110>
+ 8020024e: 02fbf663 bgeu s7,a5,8020027a <printf+0xec>
+ 80200252: 09978863 beq a5,s9,802002e2 <printf+0x154>
+ 80200256: 07800713 li a4,120
+ 8020025a: 0ce79563 bne a5,a4,80200324 <printf+0x196>
+ printint(va_arg(ap, int), 16, 1);
+ 8020025e: f8843783 ld a5,-120(s0)
+ 80200262: 00878713 addi a4,a5,8
+ 80200266: f8e43423 sd a4,-120(s0)
+ 8020026a: 4605 li a2,1
+ 8020026c: 85ea mv a1,s10
+ 8020026e: 4388 lw a0,0(a5)
+ 80200270: 00000097 auipc ra,0x0
+ 80200274: da6080e7 jalr -602(ra) # 80200016 <printint>
+ break;
+ 80200278: bf45 j 80200228 <printf+0x9a>
+ switch(c){
+ 8020027a: 09578f63 beq a5,s5,80200318 <printf+0x18a>
+ 8020027e: 0b879363 bne a5,s8,80200324 <printf+0x196>
+ printint(va_arg(ap, int), 10, 1);
+ 80200282: f8843783 ld a5,-120(s0)
+ 80200286: 00878713 addi a4,a5,8
+ 8020028a: f8e43423 sd a4,-120(s0)
+ 8020028e: 4605 li a2,1
+ 80200290: 45a9 li a1,10
+ 80200292: 4388 lw a0,0(a5)
+ 80200294: 00000097 auipc ra,0x0
+ 80200298: d82080e7 jalr -638(ra) # 80200016 <printint>
+ break;
+ 8020029c: b771 j 80200228 <printf+0x9a>
+ printptr(va_arg(ap, uint64));
+ 8020029e: f8843783 ld a5,-120(s0)
+ 802002a2: 00878713 addi a4,a5,8
+ 802002a6: f8e43423 sd a4,-120(s0)
+ 802002aa: 0007b903 ld s2,0(a5)
+ consputc('0');
+ 802002ae: 03000513 li a0,48
+ 802002b2: 00007097 auipc ra,0x7
+ 802002b6: df8080e7 jalr -520(ra) # 802070aa <consputc>
+ consputc('x');
+ 802002ba: 07800513 li a0,120
+ 802002be: 00007097 auipc ra,0x7
+ 802002c2: dec080e7 jalr -532(ra) # 802070aa <consputc>
+ 802002c6: 84ea mv s1,s10
+ consputc(digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 802002c8: 03c95793 srli a5,s2,0x3c
+ 802002cc: 97da add a5,a5,s6
+ 802002ce: 0007c503 lbu a0,0(a5)
+ 802002d2: 00007097 auipc ra,0x7
+ 802002d6: dd8080e7 jalr -552(ra) # 802070aa <consputc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 802002da: 0912 slli s2,s2,0x4
+ 802002dc: 34fd addiw s1,s1,-1
+ 802002de: f4ed bnez s1,802002c8 <printf+0x13a>
+ 802002e0: b7a1 j 80200228 <printf+0x9a>
+ if((s = va_arg(ap, char*)) == 0)
+ 802002e2: f8843783 ld a5,-120(s0)
+ 802002e6: 00878713 addi a4,a5,8
+ 802002ea: f8e43423 sd a4,-120(s0)
+ 802002ee: 6384 ld s1,0(a5)
+ 802002f0: cc89 beqz s1,8020030a <printf+0x17c>
+ for(; *s; s++)
+ 802002f2: 0004c503 lbu a0,0(s1)
+ 802002f6: d90d beqz a0,80200228 <printf+0x9a>
+ consputc(*s);
+ 802002f8: 00007097 auipc ra,0x7
+ 802002fc: db2080e7 jalr -590(ra) # 802070aa <consputc>
+ for(; *s; s++)
+ 80200300: 0485 addi s1,s1,1
+ 80200302: 0004c503 lbu a0,0(s1)
+ 80200306: f96d bnez a0,802002f8 <printf+0x16a>
+ 80200308: b705 j 80200228 <printf+0x9a>
+ s = "(null)";
+ 8020030a: 00009497 auipc s1,0x9
+ 8020030e: d0e48493 addi s1,s1,-754 # 80209018 <etext+0x18>
+ for(; *s; s++)
+ 80200312: 02800513 li a0,40
+ 80200316: b7cd j 802002f8 <printf+0x16a>
+ consputc('%');
+ 80200318: 8556 mv a0,s5
+ 8020031a: 00007097 auipc ra,0x7
+ 8020031e: d90080e7 jalr -624(ra) # 802070aa <consputc>
+ break;
+ 80200322: b719 j 80200228 <printf+0x9a>
+ consputc('%');
+ 80200324: 8556 mv a0,s5
+ 80200326: 00007097 auipc ra,0x7
+ 8020032a: d84080e7 jalr -636(ra) # 802070aa <consputc>
+ consputc(c);
+ 8020032e: 8526 mv a0,s1
+ 80200330: 00007097 auipc ra,0x7
+ 80200334: d7a080e7 jalr -646(ra) # 802070aa <consputc>
+ break;
+ 80200338: bdc5 j 80200228 <printf+0x9a>
+ if(locking)
+ 8020033a: 020d9163 bnez s11,8020035c <printf+0x1ce>
+}
+ 8020033e: 70e6 ld ra,120(sp)
+ 80200340: 7446 ld s0,112(sp)
+ 80200342: 74a6 ld s1,104(sp)
+ 80200344: 7906 ld s2,96(sp)
+ 80200346: 69e6 ld s3,88(sp)
+ 80200348: 6a46 ld s4,80(sp)
+ 8020034a: 6aa6 ld s5,72(sp)
+ 8020034c: 6b06 ld s6,64(sp)
+ 8020034e: 7be2 ld s7,56(sp)
+ 80200350: 7c42 ld s8,48(sp)
+ 80200352: 7ca2 ld s9,40(sp)
+ 80200354: 7d02 ld s10,32(sp)
+ 80200356: 6de2 ld s11,24(sp)
+ 80200358: 6129 addi sp,sp,192
+ 8020035a: 8082 ret
+ release(&pr.lock);
+ 8020035c: 00014517 auipc a0,0x14
+ 80200360: cac50513 addi a0,a0,-852 # 80214008 <pr>
+ 80200364: 00000097 auipc ra,0x0
+ 80200368: 3b6080e7 jalr 950(ra) # 8020071a <release>
+}
+ 8020036c: bfc9 j 8020033e <printf+0x1b0>
+
+000000008020036e <printfinit>:
+
+void
+printfinit(void)
+{
+ 8020036e: 1141 addi sp,sp,-16
+ 80200370: e406 sd ra,8(sp)
+ 80200372: e022 sd s0,0(sp)
+ 80200374: 0800 addi s0,sp,16
+ initlock(&pr.lock, "pr");
+ 80200376: 00009597 auipc a1,0x9
+ 8020037a: cba58593 addi a1,a1,-838 # 80209030 <etext+0x30>
+ 8020037e: 00014517 auipc a0,0x14
+ 80200382: c8a50513 addi a0,a0,-886 # 80214008 <pr>
+ 80200386: 00000097 auipc ra,0x0
+ 8020038a: 2fc080e7 jalr 764(ra) # 80200682 <initlock>
+ pr.locking = 1; // changed, used to be 1
+ 8020038e: 4785 li a5,1
+ 80200390: 00014717 auipc a4,0x14
+ 80200394: c8f72823 sw a5,-880(a4) # 80214020 <pr+0x18>
+}
+ 80200398: 60a2 ld ra,8(sp)
+ 8020039a: 6402 ld s0,0(sp)
+ 8020039c: 0141 addi sp,sp,16
+ 8020039e: 8082 ret
+
+00000000802003a0 <print_logo>:
+
+#ifdef QEMU
+void print_logo() {
+ 802003a0: 1141 addi sp,sp,-16
+ 802003a2: e406 sd ra,8(sp)
+ 802003a4: e022 sd s0,0(sp)
+ 802003a6: 0800 addi s0,sp,16
+ printf(" (`-. (`-. .-') ('-. _ .-')\n");
+ 802003a8: 00009517 auipc a0,0x9
+ 802003ac: c9050513 addi a0,a0,-880 # 80209038 <etext+0x38>
+ 802003b0: 00000097 auipc ra,0x0
+ 802003b4: dde080e7 jalr -546(ra) # 8020018e <printf>
+ printf(" ( OO ). _(OO )_ .( OO) _( OO) ( '.( OO )_ \n");
+ 802003b8: 00009517 auipc a0,0x9
+ 802003bc: cd050513 addi a0,a0,-816 # 80209088 <etext+0x88>
+ 802003c0: 00000097 auipc ra,0x0
+ 802003c4: dce080e7 jalr -562(ra) # 8020018e <printf>
+ printf("(_/. \\_)-. ,--(_/ ,. \\ ,--. (_)---\\_) (,------. ,--. ,--.) ,--. ,--. \n");
+ 802003c8: 00009517 auipc a0,0x9
+ 802003cc: d1850513 addi a0,a0,-744 # 802090e0 <etext+0xe0>
+ 802003d0: 00000097 auipc ra,0x0
+ 802003d4: dbe080e7 jalr -578(ra) # 8020018e <printf>
+ printf(" \\ `.' / \\ \\ /(__/ / .' .-') ' .-. ' | .---' | `.' | | | | | \n");
+ 802003d8: 00009517 auipc a0,0x9
+ 802003dc: d6850513 addi a0,a0,-664 # 80209140 <etext+0x140>
+ 802003e0: 00000097 auipc ra,0x0
+ 802003e4: dae080e7 jalr -594(ra) # 8020018e <printf>
+ printf(" \\ /\\ \\ \\ / / . / -. _( OO) ,| | | | | | | | | | | .-')\n");
+ 802003e8: 00009517 auipc a0,0x9
+ 802003ec: db850513 addi a0,a0,-584 # 802091a0 <etext+0x1a0>
+ 802003f0: 00000097 auipc ra,0x0
+ 802003f4: d9e080e7 jalr -610(ra) # 8020018e <printf>
+ printf(" \\ \\ | \\ ' /, | .-. ' (,------. (_| | | | (| '--. | |'.'| | | |_|( OO )\n");
+ 802003f8: 00009517 auipc a0,0x9
+ 802003fc: e0850513 addi a0,a0,-504 # 80209200 <etext+0x200>
+ 80200400: 00000097 auipc ra,0x0
+ 80200404: d8e080e7 jalr -626(ra) # 8020018e <printf>
+ printf(" .' \\_) \\ /__)' \\ | | '------' | | | | | .--' | | | | | | | `-' /\n");
+ 80200408: 00009517 auipc a0,0x9
+ 8020040c: e5850513 addi a0,a0,-424 # 80209260 <etext+0x260>
+ 80200410: 00000097 auipc ra,0x0
+ 80200414: d7e080e7 jalr -642(ra) # 8020018e <printf>
+ printf(" / .'. \\ \\ / \\ `' / ' '-' '-. | `---. | | | | (' '-'(_.-'\n");
+ 80200418: 00009517 auipc a0,0x9
+ 8020041c: ea850513 addi a0,a0,-344 # 802092c0 <etext+0x2c0>
+ 80200420: 00000097 auipc ra,0x0
+ 80200424: d6e080e7 jalr -658(ra) # 8020018e <printf>
+ printf("'--' '--' `-' `----' `-----'--' `------' `--' `--' `-----'\n");
+ 80200428: 00009517 auipc a0,0x9
+ 8020042c: ef850513 addi a0,a0,-264 # 80209320 <etext+0x320>
+ 80200430: 00000097 auipc ra,0x0
+ 80200434: d5e080e7 jalr -674(ra) # 8020018e <printf>
+}
+ 80200438: 60a2 ld ra,8(sp)
+ 8020043a: 6402 ld s0,0(sp)
+ 8020043c: 0141 addi sp,sp,16
+ 8020043e: 8082 ret
+
+0000000080200440 <kfree>:
+// which normally should have been returned by a
+// call to kalloc(). (The exception is when
+// initializing the allocator; see kinit above.)
+void
+kfree(void *pa)
+{
+ 80200440: 1101 addi sp,sp,-32
+ 80200442: ec06 sd ra,24(sp)
+ 80200444: e822 sd s0,16(sp)
+ 80200446: e426 sd s1,8(sp)
+ 80200448: e04a sd s2,0(sp)
+ 8020044a: 1000 addi s0,sp,32
+ struct run *r;
+
+ if(((uint64)pa % PGSIZE) != 0 || (char*)pa < kernel_end || (uint64)pa >= PHYSTOP)
+ 8020044c: 03451793 slli a5,a0,0x34
+ 80200450: e3ad bnez a5,802004b2 <kfree+0x72>
+ 80200452: 84aa mv s1,a0
+ 80200454: 0000c797 auipc a5,0xc
+ 80200458: 8ac7b783 ld a5,-1876(a5) # 8020bd00 <_GLOBAL_OFFSET_TABLE_+0x28>
+ 8020045c: 04f56b63 bltu a0,a5,802004b2 <kfree+0x72>
+ 80200460: 40300793 li a5,1027
+ 80200464: 07d6 slli a5,a5,0x15
+ 80200466: 04f57663 bgeu a0,a5,802004b2 <kfree+0x72>
+ panic("kfree");
+
+ // Fill with junk to catch dangling refs.
+ memset(pa, 1, PGSIZE);
+ 8020046a: 6605 lui a2,0x1
+ 8020046c: 4585 li a1,1
+ 8020046e: 00000097 auipc ra,0x0
+ 80200472: 2f4080e7 jalr 756(ra) # 80200762 <memset>
+
+ r = (struct run*)pa;
+
+ acquire(&kmem.lock);
+ 80200476: 00014917 auipc s2,0x14
+ 8020047a: bb290913 addi s2,s2,-1102 # 80214028 <kmem>
+ 8020047e: 854a mv a0,s2
+ 80200480: 00000097 auipc ra,0x0
+ 80200484: 246080e7 jalr 582(ra) # 802006c6 <acquire>
+ r->next = kmem.freelist;
+ 80200488: 01893783 ld a5,24(s2)
+ 8020048c: e09c sd a5,0(s1)
+ kmem.freelist = r;
+ 8020048e: 00993c23 sd s1,24(s2)
+ kmem.npage++;
+ 80200492: 02093783 ld a5,32(s2)
+ 80200496: 0785 addi a5,a5,1
+ 80200498: 02f93023 sd a5,32(s2)
+ release(&kmem.lock);
+ 8020049c: 854a mv a0,s2
+ 8020049e: 00000097 auipc ra,0x0
+ 802004a2: 27c080e7 jalr 636(ra) # 8020071a <release>
+}
+ 802004a6: 60e2 ld ra,24(sp)
+ 802004a8: 6442 ld s0,16(sp)
+ 802004aa: 64a2 ld s1,8(sp)
+ 802004ac: 6902 ld s2,0(sp)
+ 802004ae: 6105 addi sp,sp,32
+ 802004b0: 8082 ret
+ panic("kfree");
+ 802004b2: 00009517 auipc a0,0x9
+ 802004b6: ee650513 addi a0,a0,-282 # 80209398 <digits+0x18>
+ 802004ba: 00000097 auipc ra,0x0
+ 802004be: c8a080e7 jalr -886(ra) # 80200144 <panic>
+
+00000000802004c2 <freerange>:
+{
+ 802004c2: 7179 addi sp,sp,-48
+ 802004c4: f406 sd ra,40(sp)
+ 802004c6: f022 sd s0,32(sp)
+ 802004c8: ec26 sd s1,24(sp)
+ 802004ca: e84a sd s2,16(sp)
+ 802004cc: e44e sd s3,8(sp)
+ 802004ce: e052 sd s4,0(sp)
+ 802004d0: 1800 addi s0,sp,48
+ p = (char*)PGROUNDUP((uint64)pa_start);
+ 802004d2: 6785 lui a5,0x1
+ 802004d4: fff78713 addi a4,a5,-1 # fff <_entry-0x801ff001>
+ 802004d8: 00e504b3 add s1,a0,a4
+ 802004dc: 777d lui a4,0xfffff
+ 802004de: 8cf9 and s1,s1,a4
+ for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
+ 802004e0: 94be add s1,s1,a5
+ 802004e2: 0095ee63 bltu a1,s1,802004fe <freerange+0x3c>
+ 802004e6: 892e mv s2,a1
+ kfree(p);
+ 802004e8: 7a7d lui s4,0xfffff
+ for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
+ 802004ea: 6985 lui s3,0x1
+ kfree(p);
+ 802004ec: 01448533 add a0,s1,s4
+ 802004f0: 00000097 auipc ra,0x0
+ 802004f4: f50080e7 jalr -176(ra) # 80200440 <kfree>
+ for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
+ 802004f8: 94ce add s1,s1,s3
+ 802004fa: fe9979e3 bgeu s2,s1,802004ec <freerange+0x2a>
+}
+ 802004fe: 70a2 ld ra,40(sp)
+ 80200500: 7402 ld s0,32(sp)
+ 80200502: 64e2 ld s1,24(sp)
+ 80200504: 6942 ld s2,16(sp)
+ 80200506: 69a2 ld s3,8(sp)
+ 80200508: 6a02 ld s4,0(sp)
+ 8020050a: 6145 addi sp,sp,48
+ 8020050c: 8082 ret
+
+000000008020050e <kinit>:
+{
+ 8020050e: 1101 addi sp,sp,-32
+ 80200510: ec06 sd ra,24(sp)
+ 80200512: e822 sd s0,16(sp)
+ 80200514: e426 sd s1,8(sp)
+ 80200516: 1000 addi s0,sp,32
+ initlock(&kmem.lock, "kmem");
+ 80200518: 00014497 auipc s1,0x14
+ 8020051c: b1048493 addi s1,s1,-1264 # 80214028 <kmem>
+ 80200520: 00009597 auipc a1,0x9
+ 80200524: e8058593 addi a1,a1,-384 # 802093a0 <digits+0x20>
+ 80200528: 8526 mv a0,s1
+ 8020052a: 00000097 auipc ra,0x0
+ 8020052e: 158080e7 jalr 344(ra) # 80200682 <initlock>
+ kmem.freelist = 0;
+ 80200532: 0004bc23 sd zero,24(s1)
+ kmem.npage = 0;
+ 80200536: 0204b023 sd zero,32(s1)
+ freerange(kernel_end, (void*)PHYSTOP);
+ 8020053a: 40300593 li a1,1027
+ 8020053e: 05d6 slli a1,a1,0x15
+ 80200540: 0000b517 auipc a0,0xb
+ 80200544: 7c053503 ld a0,1984(a0) # 8020bd00 <_GLOBAL_OFFSET_TABLE_+0x28>
+ 80200548: 00000097 auipc ra,0x0
+ 8020054c: f7a080e7 jalr -134(ra) # 802004c2 <freerange>
+}
+ 80200550: 60e2 ld ra,24(sp)
+ 80200552: 6442 ld s0,16(sp)
+ 80200554: 64a2 ld s1,8(sp)
+ 80200556: 6105 addi sp,sp,32
+ 80200558: 8082 ret
+
+000000008020055a <kalloc>:
+// Allocate one 4096-byte page of physical memory.
+// Returns a pointer that the kernel can use.
+// Returns 0 if the memory cannot be allocated.
+void *
+kalloc(void)
+{
+ 8020055a: 1101 addi sp,sp,-32
+ 8020055c: ec06 sd ra,24(sp)
+ 8020055e: e822 sd s0,16(sp)
+ 80200560: e426 sd s1,8(sp)
+ 80200562: 1000 addi s0,sp,32
+ struct run *r;
+
+ acquire(&kmem.lock);
+ 80200564: 00014497 auipc s1,0x14
+ 80200568: ac448493 addi s1,s1,-1340 # 80214028 <kmem>
+ 8020056c: 8526 mv a0,s1
+ 8020056e: 00000097 auipc ra,0x0
+ 80200572: 158080e7 jalr 344(ra) # 802006c6 <acquire>
+ r = kmem.freelist;
+ 80200576: 6c84 ld s1,24(s1)
+ if(r) {
+ 80200578: c89d beqz s1,802005ae <kalloc+0x54>
+ kmem.freelist = r->next;
+ 8020057a: 609c ld a5,0(s1)
+ 8020057c: 00014517 auipc a0,0x14
+ 80200580: aac50513 addi a0,a0,-1364 # 80214028 <kmem>
+ 80200584: ed1c sd a5,24(a0)
+ kmem.npage--;
+ 80200586: 711c ld a5,32(a0)
+ 80200588: 17fd addi a5,a5,-1
+ 8020058a: f11c sd a5,32(a0)
+ }
+ release(&kmem.lock);
+ 8020058c: 00000097 auipc ra,0x0
+ 80200590: 18e080e7 jalr 398(ra) # 8020071a <release>
+
+ if(r)
+ memset((char*)r, 5, PGSIZE); // fill with junk
+ 80200594: 6605 lui a2,0x1
+ 80200596: 4595 li a1,5
+ 80200598: 8526 mv a0,s1
+ 8020059a: 00000097 auipc ra,0x0
+ 8020059e: 1c8080e7 jalr 456(ra) # 80200762 <memset>
+ return (void*)r;
+}
+ 802005a2: 8526 mv a0,s1
+ 802005a4: 60e2 ld ra,24(sp)
+ 802005a6: 6442 ld s0,16(sp)
+ 802005a8: 64a2 ld s1,8(sp)
+ 802005aa: 6105 addi sp,sp,32
+ 802005ac: 8082 ret
+ release(&kmem.lock);
+ 802005ae: 00014517 auipc a0,0x14
+ 802005b2: a7a50513 addi a0,a0,-1414 # 80214028 <kmem>
+ 802005b6: 00000097 auipc ra,0x0
+ 802005ba: 164080e7 jalr 356(ra) # 8020071a <release>
+ if(r)
+ 802005be: b7d5 j 802005a2 <kalloc+0x48>
+
+00000000802005c0 <freemem_amount>:
+
+uint64
+freemem_amount(void)
+{
+ 802005c0: 1141 addi sp,sp,-16
+ 802005c2: e422 sd s0,8(sp)
+ 802005c4: 0800 addi s0,sp,16
+ return kmem.npage << PGSHIFT;
+}
+ 802005c6: 00014517 auipc a0,0x14
+ 802005ca: a8253503 ld a0,-1406(a0) # 80214048 <kmem+0x20>
+ 802005ce: 0532 slli a0,a0,0xc
+ 802005d0: 6422 ld s0,8(sp)
+ 802005d2: 0141 addi sp,sp,16
+ 802005d4: 8082 ret
+
+00000000802005d6 <push_off>:
+// it takes two pop_off()s to undo two push_off()s. Also, if interrupts
+// are initially off, then push_off, pop_off leaves them off.
+
+void
+push_off(void)
+{
+ 802005d6: 1101 addi sp,sp,-32
+ 802005d8: ec06 sd ra,24(sp)
+ 802005da: e822 sd s0,16(sp)
+ 802005dc: e426 sd s1,8(sp)
+ 802005de: 1000 addi s0,sp,32
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 802005e0: 100024f3 csrr s1,sstatus
+ 802005e4: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() & ~SSTATUS_SIE);
+ 802005e8: 9bf5 andi a5,a5,-3
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 802005ea: 10079073 csrw sstatus,a5
+ int old = intr_get();
+
+ intr_off();
+ //printf("\e[32mpush_off()\e[0m: cpuid(): %d\n", cpuid());
+ if(mycpu()->noff == 0)
+ 802005ee: 00001097 auipc ra,0x1
+ 802005f2: 432080e7 jalr 1074(ra) # 80201a20 <mycpu>
+ 802005f6: 5d3c lw a5,120(a0)
+ 802005f8: cf89 beqz a5,80200612 <push_off+0x3c>
+ mycpu()->intena = old;
+ mycpu()->noff += 1;
+ 802005fa: 00001097 auipc ra,0x1
+ 802005fe: 426080e7 jalr 1062(ra) # 80201a20 <mycpu>
+ 80200602: 5d3c lw a5,120(a0)
+ 80200604: 2785 addiw a5,a5,1
+ 80200606: dd3c sw a5,120(a0)
+}
+ 80200608: 60e2 ld ra,24(sp)
+ 8020060a: 6442 ld s0,16(sp)
+ 8020060c: 64a2 ld s1,8(sp)
+ 8020060e: 6105 addi sp,sp,32
+ 80200610: 8082 ret
+ mycpu()->intena = old;
+ 80200612: 00001097 auipc ra,0x1
+ 80200616: 40e080e7 jalr 1038(ra) # 80201a20 <mycpu>
+ return (x & SSTATUS_SIE) != 0;
+ 8020061a: 8085 srli s1,s1,0x1
+ 8020061c: 8885 andi s1,s1,1
+ 8020061e: dd64 sw s1,124(a0)
+ 80200620: bfe9 j 802005fa <push_off+0x24>
+
+0000000080200622 <pop_off>:
+
+void
+pop_off(void)
+{
+ 80200622: 1141 addi sp,sp,-16
+ 80200624: e406 sd ra,8(sp)
+ 80200626: e022 sd s0,0(sp)
+ 80200628: 0800 addi s0,sp,16
+ struct cpu *c = mycpu();
+ 8020062a: 00001097 auipc ra,0x1
+ 8020062e: 3f6080e7 jalr 1014(ra) # 80201a20 <mycpu>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80200632: 100027f3 csrr a5,sstatus
+ return (x & SSTATUS_SIE) != 0;
+ 80200636: 8b89 andi a5,a5,2
+
+ //printf("\e[31mpop_off()\e[0m: cpuid(): %d\n", cpuid());
+ if(intr_get())
+ 80200638: e78d bnez a5,80200662 <pop_off+0x40>
+ panic("pop_off - interruptible");
+ if(c->noff < 1) {
+ 8020063a: 5d3c lw a5,120(a0)
+ 8020063c: 02f05b63 blez a5,80200672 <pop_off+0x50>
+ //printf("c->noff = %d\n", c->noff);
+ panic("pop_off");
+ }
+ //printf("c->noff: %d\n", c->noff);
+ //printf("c: %x\n", c);
+ c->noff -= 1;
+ 80200640: 37fd addiw a5,a5,-1
+ 80200642: 0007871b sext.w a4,a5
+ 80200646: dd3c sw a5,120(a0)
+ if(c->noff == 0 && c->intena)
+ 80200648: eb09 bnez a4,8020065a <pop_off+0x38>
+ 8020064a: 5d7c lw a5,124(a0)
+ 8020064c: c799 beqz a5,8020065a <pop_off+0x38>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 8020064e: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() | SSTATUS_SIE);
+ 80200652: 0027e793 ori a5,a5,2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 80200656: 10079073 csrw sstatus,a5
+ intr_on();
+}
+ 8020065a: 60a2 ld ra,8(sp)
+ 8020065c: 6402 ld s0,0(sp)
+ 8020065e: 0141 addi sp,sp,16
+ 80200660: 8082 ret
+ panic("pop_off - interruptible");
+ 80200662: 00009517 auipc a0,0x9
+ 80200666: d4650513 addi a0,a0,-698 # 802093a8 <digits+0x28>
+ 8020066a: 00000097 auipc ra,0x0
+ 8020066e: ada080e7 jalr -1318(ra) # 80200144 <panic>
+ panic("pop_off");
+ 80200672: 00009517 auipc a0,0x9
+ 80200676: d4e50513 addi a0,a0,-690 # 802093c0 <digits+0x40>
+ 8020067a: 00000097 auipc ra,0x0
+ 8020067e: aca080e7 jalr -1334(ra) # 80200144 <panic>
+
+0000000080200682 <initlock>:
+#include "include/intr.h"
+#include "include/printf.h"
+
+void
+initlock(struct spinlock *lk, char *name)
+{
+ 80200682: 1141 addi sp,sp,-16
+ 80200684: e422 sd s0,8(sp)
+ 80200686: 0800 addi s0,sp,16
+ lk->name = name;
+ 80200688: e50c sd a1,8(a0)
+ lk->locked = 0;
+ 8020068a: 00052023 sw zero,0(a0)
+ lk->cpu = 0;
+ 8020068e: 00053823 sd zero,16(a0)
+}
+ 80200692: 6422 ld s0,8(sp)
+ 80200694: 0141 addi sp,sp,16
+ 80200696: 8082 ret
+
+0000000080200698 <holding>:
+// Interrupts must be off.
+int
+holding(struct spinlock *lk)
+{
+ int r;
+ r = (lk->locked && lk->cpu == mycpu());
+ 80200698: 411c lw a5,0(a0)
+ 8020069a: e399 bnez a5,802006a0 <holding+0x8>
+ 8020069c: 4501 li a0,0
+ return r;
+}
+ 8020069e: 8082 ret
+{
+ 802006a0: 1101 addi sp,sp,-32
+ 802006a2: ec06 sd ra,24(sp)
+ 802006a4: e822 sd s0,16(sp)
+ 802006a6: e426 sd s1,8(sp)
+ 802006a8: 1000 addi s0,sp,32
+ r = (lk->locked && lk->cpu == mycpu());
+ 802006aa: 6904 ld s1,16(a0)
+ 802006ac: 00001097 auipc ra,0x1
+ 802006b0: 374080e7 jalr 884(ra) # 80201a20 <mycpu>
+ 802006b4: 40a48533 sub a0,s1,a0
+ 802006b8: 00153513 seqz a0,a0
+}
+ 802006bc: 60e2 ld ra,24(sp)
+ 802006be: 6442 ld s0,16(sp)
+ 802006c0: 64a2 ld s1,8(sp)
+ 802006c2: 6105 addi sp,sp,32
+ 802006c4: 8082 ret
+
+00000000802006c6 <acquire>:
+{
+ 802006c6: 1101 addi sp,sp,-32
+ 802006c8: ec06 sd ra,24(sp)
+ 802006ca: e822 sd s0,16(sp)
+ 802006cc: e426 sd s1,8(sp)
+ 802006ce: 1000 addi s0,sp,32
+ 802006d0: 84aa mv s1,a0
+ push_off(); // disable interrupts to avoid deadlock.
+ 802006d2: 00000097 auipc ra,0x0
+ 802006d6: f04080e7 jalr -252(ra) # 802005d6 <push_off>
+ if(holding(lk))
+ 802006da: 8526 mv a0,s1
+ 802006dc: 00000097 auipc ra,0x0
+ 802006e0: fbc080e7 jalr -68(ra) # 80200698 <holding>
+ while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
+ 802006e4: 4705 li a4,1
+ if(holding(lk))
+ 802006e6: e115 bnez a0,8020070a <acquire+0x44>
+ while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
+ 802006e8: 87ba mv a5,a4
+ 802006ea: 0cf4a7af amoswap.w.aq a5,a5,(s1)
+ 802006ee: 2781 sext.w a5,a5
+ 802006f0: ffe5 bnez a5,802006e8 <acquire+0x22>
+ __sync_synchronize();
+ 802006f2: 0ff0000f fence
+ lk->cpu = mycpu();
+ 802006f6: 00001097 auipc ra,0x1
+ 802006fa: 32a080e7 jalr 810(ra) # 80201a20 <mycpu>
+ 802006fe: e888 sd a0,16(s1)
+}
+ 80200700: 60e2 ld ra,24(sp)
+ 80200702: 6442 ld s0,16(sp)
+ 80200704: 64a2 ld s1,8(sp)
+ 80200706: 6105 addi sp,sp,32
+ 80200708: 8082 ret
+ panic("acquire");
+ 8020070a: 00009517 auipc a0,0x9
+ 8020070e: cbe50513 addi a0,a0,-834 # 802093c8 <digits+0x48>
+ 80200712: 00000097 auipc ra,0x0
+ 80200716: a32080e7 jalr -1486(ra) # 80200144 <panic>
+
+000000008020071a <release>:
+{
+ 8020071a: 1101 addi sp,sp,-32
+ 8020071c: ec06 sd ra,24(sp)
+ 8020071e: e822 sd s0,16(sp)
+ 80200720: e426 sd s1,8(sp)
+ 80200722: 1000 addi s0,sp,32
+ 80200724: 84aa mv s1,a0
+ if(!holding(lk))
+ 80200726: 00000097 auipc ra,0x0
+ 8020072a: f72080e7 jalr -142(ra) # 80200698 <holding>
+ 8020072e: c115 beqz a0,80200752 <release+0x38>
+ lk->cpu = 0;
+ 80200730: 0004b823 sd zero,16(s1)
+ __sync_synchronize();
+ 80200734: 0ff0000f fence
+ __sync_lock_release(&lk->locked);
+ 80200738: 0f50000f fence iorw,ow
+ 8020073c: 0804a02f amoswap.w zero,zero,(s1)
+ pop_off();
+ 80200740: 00000097 auipc ra,0x0
+ 80200744: ee2080e7 jalr -286(ra) # 80200622 <pop_off>
+}
+ 80200748: 60e2 ld ra,24(sp)
+ 8020074a: 6442 ld s0,16(sp)
+ 8020074c: 64a2 ld s1,8(sp)
+ 8020074e: 6105 addi sp,sp,32
+ 80200750: 8082 ret
+ panic("release");
+ 80200752: 00009517 auipc a0,0x9
+ 80200756: c7e50513 addi a0,a0,-898 # 802093d0 <digits+0x50>
+ 8020075a: 00000097 auipc ra,0x0
+ 8020075e: 9ea080e7 jalr -1558(ra) # 80200144 <panic>
+
+0000000080200762 <memset>:
+#include "include/types.h"
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 80200762: 1141 addi sp,sp,-16
+ 80200764: e422 sd s0,8(sp)
+ 80200766: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 80200768: ca19 beqz a2,8020077e <memset+0x1c>
+ 8020076a: 87aa mv a5,a0
+ 8020076c: 1602 slli a2,a2,0x20
+ 8020076e: 9201 srli a2,a2,0x20
+ 80200770: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 80200774: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 80200778: 0785 addi a5,a5,1
+ 8020077a: fee79de3 bne a5,a4,80200774 <memset+0x12>
+ }
+ return dst;
+}
+ 8020077e: 6422 ld s0,8(sp)
+ 80200780: 0141 addi sp,sp,16
+ 80200782: 8082 ret
+
+0000000080200784 <memcmp>:
+
+int
+memcmp(const void *v1, const void *v2, uint n)
+{
+ 80200784: 1141 addi sp,sp,-16
+ 80200786: e422 sd s0,8(sp)
+ 80200788: 0800 addi s0,sp,16
+ const uchar *s1, *s2;
+
+ s1 = v1;
+ s2 = v2;
+ while(n-- > 0){
+ 8020078a: ca05 beqz a2,802007ba <memcmp+0x36>
+ 8020078c: fff6069b addiw a3,a2,-1 # fff <_entry-0x801ff001>
+ 80200790: 1682 slli a3,a3,0x20
+ 80200792: 9281 srli a3,a3,0x20
+ 80200794: 0685 addi a3,a3,1
+ 80200796: 96aa add a3,a3,a0
+ if(*s1 != *s2)
+ 80200798: 00054783 lbu a5,0(a0)
+ 8020079c: 0005c703 lbu a4,0(a1)
+ 802007a0: 00e79863 bne a5,a4,802007b0 <memcmp+0x2c>
+ return *s1 - *s2;
+ s1++, s2++;
+ 802007a4: 0505 addi a0,a0,1
+ 802007a6: 0585 addi a1,a1,1
+ while(n-- > 0){
+ 802007a8: fed518e3 bne a0,a3,80200798 <memcmp+0x14>
+ }
+
+ return 0;
+ 802007ac: 4501 li a0,0
+ 802007ae: a019 j 802007b4 <memcmp+0x30>
+ return *s1 - *s2;
+ 802007b0: 40e7853b subw a0,a5,a4
+}
+ 802007b4: 6422 ld s0,8(sp)
+ 802007b6: 0141 addi sp,sp,16
+ 802007b8: 8082 ret
+ return 0;
+ 802007ba: 4501 li a0,0
+ 802007bc: bfe5 j 802007b4 <memcmp+0x30>
+
+00000000802007be <memmove>:
+
+void*
+memmove(void *dst, const void *src, uint n)
+{
+ 802007be: 1141 addi sp,sp,-16
+ 802007c0: e422 sd s0,8(sp)
+ 802007c2: 0800 addi s0,sp,16
+ const char *s;
+ char *d;
+
+ s = src;
+ d = dst;
+ if(s < d && s + n > d){
+ 802007c4: 02a5e563 bltu a1,a0,802007ee <memmove+0x30>
+ s += n;
+ d += n;
+ while(n-- > 0)
+ *--d = *--s;
+ } else
+ while(n-- > 0)
+ 802007c8: fff6069b addiw a3,a2,-1
+ 802007cc: ce11 beqz a2,802007e8 <memmove+0x2a>
+ 802007ce: 1682 slli a3,a3,0x20
+ 802007d0: 9281 srli a3,a3,0x20
+ 802007d2: 0685 addi a3,a3,1
+ 802007d4: 96ae add a3,a3,a1
+ 802007d6: 87aa mv a5,a0
+ *d++ = *s++;
+ 802007d8: 0585 addi a1,a1,1
+ 802007da: 0785 addi a5,a5,1
+ 802007dc: fff5c703 lbu a4,-1(a1)
+ 802007e0: fee78fa3 sb a4,-1(a5)
+ while(n-- > 0)
+ 802007e4: fed59ae3 bne a1,a3,802007d8 <memmove+0x1a>
+
+ return dst;
+}
+ 802007e8: 6422 ld s0,8(sp)
+ 802007ea: 0141 addi sp,sp,16
+ 802007ec: 8082 ret
+ if(s < d && s + n > d){
+ 802007ee: 02061713 slli a4,a2,0x20
+ 802007f2: 9301 srli a4,a4,0x20
+ 802007f4: 00e587b3 add a5,a1,a4
+ 802007f8: fcf578e3 bgeu a0,a5,802007c8 <memmove+0xa>
+ d += n;
+ 802007fc: 972a add a4,a4,a0
+ while(n-- > 0)
+ 802007fe: fff6069b addiw a3,a2,-1
+ 80200802: d27d beqz a2,802007e8 <memmove+0x2a>
+ 80200804: 02069613 slli a2,a3,0x20
+ 80200808: 9201 srli a2,a2,0x20
+ 8020080a: fff64613 not a2,a2
+ 8020080e: 963e add a2,a2,a5
+ *--d = *--s;
+ 80200810: 17fd addi a5,a5,-1
+ 80200812: 177d addi a4,a4,-1 # ffffffffffffefff <ebss_clear+0xffffffff7fdd8fff>
+ 80200814: 0007c683 lbu a3,0(a5)
+ 80200818: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 8020081c: fef61ae3 bne a2,a5,80200810 <memmove+0x52>
+ 80200820: b7e1 j 802007e8 <memmove+0x2a>
+
+0000000080200822 <memcpy>:
+
+// memcpy exists to placate GCC. Use memmove.
+void*
+memcpy(void *dst, const void *src, uint n)
+{
+ 80200822: 1141 addi sp,sp,-16
+ 80200824: e406 sd ra,8(sp)
+ 80200826: e022 sd s0,0(sp)
+ 80200828: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 8020082a: 00000097 auipc ra,0x0
+ 8020082e: f94080e7 jalr -108(ra) # 802007be <memmove>
+}
+ 80200832: 60a2 ld ra,8(sp)
+ 80200834: 6402 ld s0,0(sp)
+ 80200836: 0141 addi sp,sp,16
+ 80200838: 8082 ret
+
+000000008020083a <strncmp>:
+
+int
+strncmp(const char *p, const char *q, uint n)
+{
+ 8020083a: 1141 addi sp,sp,-16
+ 8020083c: e422 sd s0,8(sp)
+ 8020083e: 0800 addi s0,sp,16
+ while(n > 0 && *p && *p == *q)
+ 80200840: ce11 beqz a2,8020085c <strncmp+0x22>
+ 80200842: 00054783 lbu a5,0(a0)
+ 80200846: cf89 beqz a5,80200860 <strncmp+0x26>
+ 80200848: 0005c703 lbu a4,0(a1)
+ 8020084c: 00f71a63 bne a4,a5,80200860 <strncmp+0x26>
+ n--, p++, q++;
+ 80200850: 367d addiw a2,a2,-1
+ 80200852: 0505 addi a0,a0,1
+ 80200854: 0585 addi a1,a1,1
+ while(n > 0 && *p && *p == *q)
+ 80200856: f675 bnez a2,80200842 <strncmp+0x8>
+ if(n == 0)
+ return 0;
+ 80200858: 4501 li a0,0
+ 8020085a: a809 j 8020086c <strncmp+0x32>
+ 8020085c: 4501 li a0,0
+ 8020085e: a039 j 8020086c <strncmp+0x32>
+ if(n == 0)
+ 80200860: ca09 beqz a2,80200872 <strncmp+0x38>
+ return (uchar)*p - (uchar)*q;
+ 80200862: 00054503 lbu a0,0(a0)
+ 80200866: 0005c783 lbu a5,0(a1)
+ 8020086a: 9d1d subw a0,a0,a5
+}
+ 8020086c: 6422 ld s0,8(sp)
+ 8020086e: 0141 addi sp,sp,16
+ 80200870: 8082 ret
+ return 0;
+ 80200872: 4501 li a0,0
+ 80200874: bfe5 j 8020086c <strncmp+0x32>
+
+0000000080200876 <strncpy>:
+
+char*
+strncpy(char *s, const char *t, int n)
+{
+ 80200876: 1141 addi sp,sp,-16
+ 80200878: e422 sd s0,8(sp)
+ 8020087a: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while(n-- > 0 && (*s++ = *t++) != 0)
+ 8020087c: 872a mv a4,a0
+ 8020087e: 8832 mv a6,a2
+ 80200880: 367d addiw a2,a2,-1
+ 80200882: 01005963 blez a6,80200894 <strncpy+0x1e>
+ 80200886: 0705 addi a4,a4,1
+ 80200888: 0005c783 lbu a5,0(a1)
+ 8020088c: fef70fa3 sb a5,-1(a4)
+ 80200890: 0585 addi a1,a1,1
+ 80200892: f7f5 bnez a5,8020087e <strncpy+0x8>
+ ;
+ while(n-- > 0)
+ 80200894: 86ba mv a3,a4
+ 80200896: 00c05c63 blez a2,802008ae <strncpy+0x38>
+ *s++ = 0;
+ 8020089a: 0685 addi a3,a3,1
+ 8020089c: fe068fa3 sb zero,-1(a3)
+ while(n-- > 0)
+ 802008a0: 40d707bb subw a5,a4,a3
+ 802008a4: 37fd addiw a5,a5,-1
+ 802008a6: 010787bb addw a5,a5,a6
+ 802008aa: fef048e3 bgtz a5,8020089a <strncpy+0x24>
+ return os;
+}
+ 802008ae: 6422 ld s0,8(sp)
+ 802008b0: 0141 addi sp,sp,16
+ 802008b2: 8082 ret
+
+00000000802008b4 <safestrcpy>:
+
+// Like strncpy but guaranteed to NUL-terminate.
+char*
+safestrcpy(char *s, const char *t, int n)
+{
+ 802008b4: 1141 addi sp,sp,-16
+ 802008b6: e422 sd s0,8(sp)
+ 802008b8: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ if(n <= 0)
+ 802008ba: 02c05363 blez a2,802008e0 <safestrcpy+0x2c>
+ 802008be: fff6069b addiw a3,a2,-1
+ 802008c2: 1682 slli a3,a3,0x20
+ 802008c4: 9281 srli a3,a3,0x20
+ 802008c6: 96ae add a3,a3,a1
+ 802008c8: 87aa mv a5,a0
+ return os;
+ while(--n > 0 && (*s++ = *t++) != 0)
+ 802008ca: 00d58963 beq a1,a3,802008dc <safestrcpy+0x28>
+ 802008ce: 0585 addi a1,a1,1
+ 802008d0: 0785 addi a5,a5,1
+ 802008d2: fff5c703 lbu a4,-1(a1)
+ 802008d6: fee78fa3 sb a4,-1(a5)
+ 802008da: fb65 bnez a4,802008ca <safestrcpy+0x16>
+ ;
+ *s = 0;
+ 802008dc: 00078023 sb zero,0(a5)
+ return os;
+}
+ 802008e0: 6422 ld s0,8(sp)
+ 802008e2: 0141 addi sp,sp,16
+ 802008e4: 8082 ret
+
+00000000802008e6 <strlen>:
+
+int
+strlen(const char *s)
+{
+ 802008e6: 1141 addi sp,sp,-16
+ 802008e8: e422 sd s0,8(sp)
+ 802008ea: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 802008ec: 00054783 lbu a5,0(a0)
+ 802008f0: cf91 beqz a5,8020090c <strlen+0x26>
+ 802008f2: 0505 addi a0,a0,1
+ 802008f4: 87aa mv a5,a0
+ 802008f6: 4685 li a3,1
+ 802008f8: 9e89 subw a3,a3,a0
+ 802008fa: 00f6853b addw a0,a3,a5
+ 802008fe: 0785 addi a5,a5,1
+ 80200900: fff7c703 lbu a4,-1(a5)
+ 80200904: fb7d bnez a4,802008fa <strlen+0x14>
+ ;
+ return n;
+}
+ 80200906: 6422 ld s0,8(sp)
+ 80200908: 0141 addi sp,sp,16
+ 8020090a: 8082 ret
+ for(n = 0; s[n]; n++)
+ 8020090c: 4501 li a0,0
+ 8020090e: bfe5 j 80200906 <strlen+0x20>
+
+0000000080200910 <wnstr>:
+
+// convert uchar string into wide char string
+void wnstr(wchar *dst, char const *src, int len) {
+ 80200910: 1141 addi sp,sp,-16
+ 80200912: e422 sd s0,8(sp)
+ 80200914: 0800 addi s0,sp,16
+ while (len -- && *src) {
+ 80200916: c20d beqz a2,80200938 <wnstr+0x28>
+ 80200918: 02061793 slli a5,a2,0x20
+ 8020091c: 01f7d613 srli a2,a5,0x1f
+ 80200920: 00c50733 add a4,a0,a2
+ 80200924: 0005c783 lbu a5,0(a1)
+ 80200928: cb81 beqz a5,80200938 <wnstr+0x28>
+ *(uchar*)dst = *src++;
+ 8020092a: 0585 addi a1,a1,1
+ 8020092c: 00f50023 sb a5,0(a0)
+ dst ++;
+ 80200930: 0509 addi a0,a0,2
+ while (len -- && *src) {
+ 80200932: fee519e3 bne a0,a4,80200924 <wnstr+0x14>
+ dst ++;
+ 80200936: 853a mv a0,a4
+ }
+
+ *dst = 0;
+ 80200938: 00051023 sh zero,0(a0)
+}
+ 8020093c: 6422 ld s0,8(sp)
+ 8020093e: 0141 addi sp,sp,16
+ 80200940: 8082 ret
+
+0000000080200942 <snstr>:
+
+// convert wide char string into uchar string
+void snstr(char *dst, wchar const *src, int len) {
+ 80200942: 1141 addi sp,sp,-16
+ 80200944: e422 sd s0,8(sp)
+ 80200946: 0800 addi s0,sp,16
+ while (len -- && *src) {
+ 80200948: fff6071b addiw a4,a2,-1
+ 8020094c: 02061693 slli a3,a2,0x20
+ 80200950: 9281 srli a3,a3,0x20
+ 80200952: 96aa add a3,a3,a0
+ 80200954: c61d beqz a2,80200982 <snstr+0x40>
+ 80200956: 0005d783 lhu a5,0(a1)
+ 8020095a: cb89 beqz a5,8020096c <snstr+0x2a>
+ *dst++ = (uchar)(*src & 0xff);
+ 8020095c: 0505 addi a0,a0,1
+ 8020095e: fef50fa3 sb a5,-1(a0)
+ src ++;
+ 80200962: 0589 addi a1,a1,2
+ while (len -- && *src) {
+ 80200964: 377d addiw a4,a4,-1
+ 80200966: fed518e3 bne a0,a3,80200956 <snstr+0x14>
+ *dst++ = (uchar)(*src & 0xff);
+ 8020096a: 8536 mv a0,a3
+ }
+ while(len-- > 0)
+ 8020096c: 02071793 slli a5,a4,0x20
+ 80200970: 9381 srli a5,a5,0x20
+ 80200972: 97aa add a5,a5,a0
+ 80200974: 00e05763 blez a4,80200982 <snstr+0x40>
+ *dst++ = 0;
+ 80200978: 0505 addi a0,a0,1
+ 8020097a: fe050fa3 sb zero,-1(a0)
+ while(len-- > 0)
+ 8020097e: fea79de3 bne a5,a0,80200978 <snstr+0x36>
+}
+ 80200982: 6422 ld s0,8(sp)
+ 80200984: 0141 addi sp,sp,16
+ 80200986: 8082 ret
+
+0000000080200988 <wcsncmp>:
+
+int wcsncmp(wchar const *s1, wchar const *s2, int len) {
+ 80200988: 1141 addi sp,sp,-16
+ 8020098a: e422 sd s0,8(sp)
+ 8020098c: 0800 addi s0,sp,16
+ 8020098e: 872a mv a4,a0
+ int ret = 0;
+
+ while (len-- && *s1) {
+ 80200990: 02061793 slli a5,a2,0x20
+ 80200994: 01f7d613 srli a2,a5,0x1f
+ 80200998: 962e add a2,a2,a1
+ 8020099a: 00c58f63 beq a1,a2,802009b8 <wcsncmp+0x30>
+ 8020099e: 00075783 lhu a5,0(a4)
+ 802009a2: cb89 beqz a5,802009b4 <wcsncmp+0x2c>
+ ret = (int)(*s1++ - *s2++);
+ 802009a4: 0709 addi a4,a4,2
+ 802009a6: 0589 addi a1,a1,2
+ 802009a8: ffe5d683 lhu a3,-2(a1)
+ 802009ac: 40d7853b subw a0,a5,a3
+ if (ret) break;
+ 802009b0: d56d beqz a0,8020099a <wcsncmp+0x12>
+ 802009b2: a021 j 802009ba <wcsncmp+0x32>
+ 802009b4: 4501 li a0,0
+ 802009b6: a011 j 802009ba <wcsncmp+0x32>
+ 802009b8: 4501 li a0,0
+ }
+
+ return ret;
+}
+ 802009ba: 6422 ld s0,8(sp)
+ 802009bc: 0141 addi sp,sp,16
+ 802009be: 8082 ret
+
+00000000802009c0 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 802009c0: 1141 addi sp,sp,-16
+ 802009c2: e422 sd s0,8(sp)
+ 802009c4: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 802009c6: 00054783 lbu a5,0(a0)
+ 802009ca: cb99 beqz a5,802009e0 <strchr+0x20>
+ if(*s == c)
+ 802009cc: 00f58763 beq a1,a5,802009da <strchr+0x1a>
+ for(; *s; s++)
+ 802009d0: 0505 addi a0,a0,1
+ 802009d2: 00054783 lbu a5,0(a0)
+ 802009d6: fbfd bnez a5,802009cc <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 802009d8: 4501 li a0,0
+ 802009da: 6422 ld s0,8(sp)
+ 802009dc: 0141 addi sp,sp,16
+ 802009de: 8082 ret
+ return 0;
+ 802009e0: 4501 li a0,0
+ 802009e2: bfe5 j 802009da <strchr+0x1a>
+
+00000000802009e4 <main>:
+
+volatile static int started = 0;
+
+void
+main(unsigned long hartid, unsigned long dtb_pa)
+{
+ 802009e4: 1101 addi sp,sp,-32
+ 802009e6: ec06 sd ra,24(sp)
+ 802009e8: e822 sd s0,16(sp)
+ 802009ea: 1000 addi s0,sp,32
+ asm volatile("mv tp, %0" : : "r" (hartid & 0x1));
+ 802009ec: 00157793 andi a5,a0,1
+ 802009f0: 823e mv tp,a5
+ started = 1;
+ }
+ else
+ {
+ // hart 1
+ while (started == 0)
+ 802009f2: 00013717 auipc a4,0x13
+ 802009f6: 65e70713 addi a4,a4,1630 # 80214050 <started>
+ if (hartid == 0) {
+ 802009fa: cd15 beqz a0,80200a36 <main+0x52>
+ while (started == 0)
+ 802009fc: 431c lw a5,0(a4)
+ 802009fe: 2781 sext.w a5,a5
+ 80200a00: dff5 beqz a5,802009fc <main+0x18>
+ ;
+ __sync_synchronize();
+ 80200a02: 0ff0000f fence
+ #ifdef DEBUG
+ printf("hart %d enter main()...\n", hartid);
+ #endif
+ kvminithart();
+ 80200a06: 00000097 auipc ra,0x0
+ 80200a0a: 0de080e7 jalr 222(ra) # 80200ae4 <kvminithart>
+ trapinithart();
+ 80200a0e: 00002097 auipc ra,0x2
+ 80200a12: f10080e7 jalr -240(ra) # 8020291e <trapinithart>
+ plicinithart(); // ask PLIC for device interrupts
+ 80200a16: 00006097 auipc ra,0x6
+ 80200a1a: 452080e7 jalr 1106(ra) # 80206e68 <plicinithart>
+ printf("hart 1 init done\n");
+ 80200a1e: 00009517 auipc a0,0x9
+ 80200a22: 9d250513 addi a0,a0,-1582 # 802093f0 <digits+0x70>
+ 80200a26: fffff097 auipc ra,0xfffff
+ 80200a2a: 768080e7 jalr 1896(ra) # 8020018e <printf>
+ }
+ scheduler();
+ 80200a2e: 00001097 auipc ra,0x1
+ 80200a32: 6ca080e7 jalr 1738(ra) # 802020f8 <scheduler>
+ consoleinit();
+ 80200a36: 00007097 auipc ra,0x7
+ 80200a3a: 844080e7 jalr -1980(ra) # 8020727a <consoleinit>
+ printfinit(); // init a lock for printf
+ 80200a3e: 00000097 auipc ra,0x0
+ 80200a42: 930080e7 jalr -1744(ra) # 8020036e <printfinit>
+ print_logo();
+ 80200a46: 00000097 auipc ra,0x0
+ 80200a4a: 95a080e7 jalr -1702(ra) # 802003a0 <print_logo>
+ kinit(); // physical page allocator
+ 80200a4e: 00000097 auipc ra,0x0
+ 80200a52: ac0080e7 jalr -1344(ra) # 8020050e <kinit>
+ kvminit(); // create kernel page table
+ 80200a56: 00000097 auipc ra,0x0
+ 80200a5a: 2d8080e7 jalr 728(ra) # 80200d2e <kvminit>
+ kvminithart(); // turn on paging
+ 80200a5e: 00000097 auipc ra,0x0
+ 80200a62: 086080e7 jalr 134(ra) # 80200ae4 <kvminithart>
+ timerinit(); // init a lock for timer
+ 80200a66: 00005097 auipc ra,0x5
+ 80200a6a: 9b8080e7 jalr -1608(ra) # 8020541e <timerinit>
+ trapinithart(); // install kernel trap vector, including interrupt handler
+ 80200a6e: 00002097 auipc ra,0x2
+ 80200a72: eb0080e7 jalr -336(ra) # 8020291e <trapinithart>
+ procinit();
+ 80200a76: 00001097 auipc ra,0x1
+ 80200a7a: f24080e7 jalr -220(ra) # 8020199a <procinit>
+ plicinit();
+ 80200a7e: 00006097 auipc ra,0x6
+ 80200a82: 3d2080e7 jalr 978(ra) # 80206e50 <plicinit>
+ plicinithart();
+ 80200a86: 00006097 auipc ra,0x6
+ 80200a8a: 3e2080e7 jalr 994(ra) # 80206e68 <plicinithart>
+ disk_init();
+ 80200a8e: 00005097 auipc ra,0x5
+ 80200a92: a2c080e7 jalr -1492(ra) # 802054ba <disk_init>
+ binit(); // buffer cache
+ 80200a96: 00003097 auipc ra,0x3
+ 80200a9a: d1c080e7 jalr -740(ra) # 802037b2 <binit>
+ fileinit(); // file table
+ 80200a9e: 00003097 auipc ra,0x3
+ 80200aa2: 120080e7 jalr 288(ra) # 80203bbe <fileinit>
+ userinit(); // first user process
+ 80200aa6: 00001097 auipc ra,0x1
+ 80200aaa: 2a4080e7 jalr 676(ra) # 80201d4a <userinit>
+ printf("hart 0 init done\n");
+ 80200aae: 00009517 auipc a0,0x9
+ 80200ab2: 92a50513 addi a0,a0,-1750 # 802093d8 <digits+0x58>
+ 80200ab6: fffff097 auipc ra,0xfffff
+ 80200aba: 6d8080e7 jalr 1752(ra) # 8020018e <printf>
+ unsigned long mask = 1 << i;
+ 80200abe: 4789 li a5,2
+ 80200ac0: fef43423 sd a5,-24(s0)
+ SBI_CALL_0(SBI_CLEAR_IPI);
+}
+
+static inline void sbi_send_ipi(const unsigned long *hart_mask)
+{
+ SBI_CALL_1(SBI_SEND_IPI, hart_mask);
+ 80200ac4: fe840513 addi a0,s0,-24
+ 80200ac8: 4581 li a1,0
+ 80200aca: 4601 li a2,0
+ 80200acc: 4681 li a3,0
+ 80200ace: 4891 li a7,4
+ 80200ad0: 00000073 ecall
+ __sync_synchronize();
+ 80200ad4: 0ff0000f fence
+ started = 1;
+ 80200ad8: 4785 li a5,1
+ 80200ada: 00013717 auipc a4,0x13
+ 80200ade: 56f72b23 sw a5,1398(a4) # 80214050 <started>
+ 80200ae2: b7b1 j 80200a2e <main+0x4a>
+
+0000000080200ae4 <kvminithart>:
+
+// Switch h/w page table register to the kernel's page table,
+// and enable paging.
+void
+kvminithart()
+{
+ 80200ae4: 1141 addi sp,sp,-16
+ 80200ae6: e422 sd s0,8(sp)
+ 80200ae8: 0800 addi s0,sp,16
+ w_satp(MAKE_SATP(kernel_pagetable));
+ 80200aea: 00013797 auipc a5,0x13
+ 80200aee: 56e7b783 ld a5,1390(a5) # 80214058 <kernel_pagetable>
+ 80200af2: 83b1 srli a5,a5,0xc
+ 80200af4: 577d li a4,-1
+ 80200af6: 177e slli a4,a4,0x3f
+ 80200af8: 8fd9 or a5,a5,a4
+ asm volatile("csrw satp, %0" : : "r" (x));
+ 80200afa: 18079073 csrw satp,a5
+static inline void
+sfence_vma()
+{
+ // the zero, zero means flush all TLB entries.
+ // asm volatile("sfence.vma zero, zero");
+ asm volatile("sfence.vma");
+ 80200afe: 12000073 sfence.vma
+ // reg_info();
+ sfence_vma();
+ #ifdef DEBUG
+ printf("kvminithart\n");
+ #endif
+}
+ 80200b02: 6422 ld s0,8(sp)
+ 80200b04: 0141 addi sp,sp,16
+ 80200b06: 8082 ret
+
+0000000080200b08 <walk>:
+// 21..29 -- 9 bits of level-1 index.
+// 12..20 -- 9 bits of level-0 index.
+// 0..11 -- 12 bits of byte offset within the page.
+pte_t *
+walk(pagetable_t pagetable, uint64 va, int alloc)
+{
+ 80200b08: 7139 addi sp,sp,-64
+ 80200b0a: fc06 sd ra,56(sp)
+ 80200b0c: f822 sd s0,48(sp)
+ 80200b0e: f426 sd s1,40(sp)
+ 80200b10: f04a sd s2,32(sp)
+ 80200b12: ec4e sd s3,24(sp)
+ 80200b14: e852 sd s4,16(sp)
+ 80200b16: e456 sd s5,8(sp)
+ 80200b18: e05a sd s6,0(sp)
+ 80200b1a: 0080 addi s0,sp,64
+ 80200b1c: 84aa mv s1,a0
+ 80200b1e: 89ae mv s3,a1
+ 80200b20: 8ab2 mv s5,a2
+
+ if(va >= MAXVA)
+ 80200b22: 57fd li a5,-1
+ 80200b24: 83e9 srli a5,a5,0x1a
+ 80200b26: 4a79 li s4,30
+ panic("walk");
+
+ for(int level = 2; level > 0; level--) {
+ 80200b28: 4b31 li s6,12
+ if(va >= MAXVA)
+ 80200b2a: 04b7f263 bgeu a5,a1,80200b6e <walk+0x66>
+ panic("walk");
+ 80200b2e: 00009517 auipc a0,0x9
+ 80200b32: 8da50513 addi a0,a0,-1830 # 80209408 <digits+0x88>
+ 80200b36: fffff097 auipc ra,0xfffff
+ 80200b3a: 60e080e7 jalr 1550(ra) # 80200144 <panic>
+ pte_t *pte = &pagetable[PX(level, va)];
+ if(*pte & PTE_V) {
+ pagetable = (pagetable_t)PTE2PA(*pte);
+ } else {
+ if(!alloc || (pagetable = (pde_t*)kalloc()) == NULL)
+ 80200b3e: 060a8663 beqz s5,80200baa <walk+0xa2>
+ 80200b42: 00000097 auipc ra,0x0
+ 80200b46: a18080e7 jalr -1512(ra) # 8020055a <kalloc>
+ 80200b4a: 84aa mv s1,a0
+ 80200b4c: c529 beqz a0,80200b96 <walk+0x8e>
+ return NULL;
+ memset(pagetable, 0, PGSIZE);
+ 80200b4e: 6605 lui a2,0x1
+ 80200b50: 4581 li a1,0
+ 80200b52: 00000097 auipc ra,0x0
+ 80200b56: c10080e7 jalr -1008(ra) # 80200762 <memset>
+ *pte = PA2PTE(pagetable) | PTE_V;
+ 80200b5a: 00c4d793 srli a5,s1,0xc
+ 80200b5e: 07aa slli a5,a5,0xa
+ 80200b60: 0017e793 ori a5,a5,1
+ 80200b64: 00f93023 sd a5,0(s2)
+ for(int level = 2; level > 0; level--) {
+ 80200b68: 3a5d addiw s4,s4,-9 # ffffffffffffeff7 <ebss_clear+0xffffffff7fdd8ff7>
+ 80200b6a: 036a0063 beq s4,s6,80200b8a <walk+0x82>
+ pte_t *pte = &pagetable[PX(level, va)];
+ 80200b6e: 0149d933 srl s2,s3,s4
+ 80200b72: 1ff97913 andi s2,s2,511
+ 80200b76: 090e slli s2,s2,0x3
+ 80200b78: 9926 add s2,s2,s1
+ if(*pte & PTE_V) {
+ 80200b7a: 00093483 ld s1,0(s2)
+ 80200b7e: 0014f793 andi a5,s1,1
+ 80200b82: dfd5 beqz a5,80200b3e <walk+0x36>
+ pagetable = (pagetable_t)PTE2PA(*pte);
+ 80200b84: 80a9 srli s1,s1,0xa
+ 80200b86: 04b2 slli s1,s1,0xc
+ 80200b88: b7c5 j 80200b68 <walk+0x60>
+ }
+ }
+ return &pagetable[PX(0, va)];
+ 80200b8a: 00c9d513 srli a0,s3,0xc
+ 80200b8e: 1ff57513 andi a0,a0,511
+ 80200b92: 050e slli a0,a0,0x3
+ 80200b94: 9526 add a0,a0,s1
+}
+ 80200b96: 70e2 ld ra,56(sp)
+ 80200b98: 7442 ld s0,48(sp)
+ 80200b9a: 74a2 ld s1,40(sp)
+ 80200b9c: 7902 ld s2,32(sp)
+ 80200b9e: 69e2 ld s3,24(sp)
+ 80200ba0: 6a42 ld s4,16(sp)
+ 80200ba2: 6aa2 ld s5,8(sp)
+ 80200ba4: 6b02 ld s6,0(sp)
+ 80200ba6: 6121 addi sp,sp,64
+ 80200ba8: 8082 ret
+ return NULL;
+ 80200baa: 4501 li a0,0
+ 80200bac: b7ed j 80200b96 <walk+0x8e>
+
+0000000080200bae <walkaddr>:
+walkaddr(pagetable_t pagetable, uint64 va)
+{
+ pte_t *pte;
+ uint64 pa;
+
+ if(va >= MAXVA)
+ 80200bae: 57fd li a5,-1
+ 80200bb0: 83e9 srli a5,a5,0x1a
+ 80200bb2: 00b7f463 bgeu a5,a1,80200bba <walkaddr+0xc>
+ return NULL;
+ 80200bb6: 4501 li a0,0
+ return NULL;
+ if((*pte & PTE_U) == 0)
+ return NULL;
+ pa = PTE2PA(*pte);
+ return pa;
+}
+ 80200bb8: 8082 ret
+{
+ 80200bba: 1141 addi sp,sp,-16
+ 80200bbc: e406 sd ra,8(sp)
+ 80200bbe: e022 sd s0,0(sp)
+ 80200bc0: 0800 addi s0,sp,16
+ pte = walk(pagetable, va, 0);
+ 80200bc2: 4601 li a2,0
+ 80200bc4: 00000097 auipc ra,0x0
+ 80200bc8: f44080e7 jalr -188(ra) # 80200b08 <walk>
+ if(pte == 0)
+ 80200bcc: c105 beqz a0,80200bec <walkaddr+0x3e>
+ if((*pte & PTE_V) == 0)
+ 80200bce: 611c ld a5,0(a0)
+ if((*pte & PTE_U) == 0)
+ 80200bd0: 0117f693 andi a3,a5,17
+ 80200bd4: 4745 li a4,17
+ return NULL;
+ 80200bd6: 4501 li a0,0
+ if((*pte & PTE_U) == 0)
+ 80200bd8: 00e68663 beq a3,a4,80200be4 <walkaddr+0x36>
+}
+ 80200bdc: 60a2 ld ra,8(sp)
+ 80200bde: 6402 ld s0,0(sp)
+ 80200be0: 0141 addi sp,sp,16
+ 80200be2: 8082 ret
+ pa = PTE2PA(*pte);
+ 80200be4: 83a9 srli a5,a5,0xa
+ 80200be6: 00c79513 slli a0,a5,0xc
+ return pa;
+ 80200bea: bfcd j 80200bdc <walkaddr+0x2e>
+ return NULL;
+ 80200bec: 4501 li a0,0
+ 80200bee: b7fd j 80200bdc <walkaddr+0x2e>
+
+0000000080200bf0 <kwalkaddr>:
+ return kwalkaddr(kernel_pagetable, va);
+}
+
+uint64
+kwalkaddr(pagetable_t kpt, uint64 va)
+{
+ 80200bf0: 1101 addi sp,sp,-32
+ 80200bf2: ec06 sd ra,24(sp)
+ 80200bf4: e822 sd s0,16(sp)
+ 80200bf6: e426 sd s1,8(sp)
+ 80200bf8: 1000 addi s0,sp,32
+ uint64 off = va % PGSIZE;
+ 80200bfa: 03459793 slli a5,a1,0x34
+ 80200bfe: 0347d493 srli s1,a5,0x34
+ pte_t *pte;
+ uint64 pa;
+
+ pte = walk(kpt, va, 0);
+ 80200c02: 4601 li a2,0
+ 80200c04: 00000097 auipc ra,0x0
+ 80200c08: f04080e7 jalr -252(ra) # 80200b08 <walk>
+ if(pte == 0)
+ 80200c0c: cd09 beqz a0,80200c26 <kwalkaddr+0x36>
+ panic("kvmpa");
+ if((*pte & PTE_V) == 0)
+ 80200c0e: 6108 ld a0,0(a0)
+ 80200c10: 00157793 andi a5,a0,1
+ 80200c14: c38d beqz a5,80200c36 <kwalkaddr+0x46>
+ panic("kvmpa");
+ pa = PTE2PA(*pte);
+ 80200c16: 8129 srli a0,a0,0xa
+ 80200c18: 0532 slli a0,a0,0xc
+ return pa+off;
+}
+ 80200c1a: 9526 add a0,a0,s1
+ 80200c1c: 60e2 ld ra,24(sp)
+ 80200c1e: 6442 ld s0,16(sp)
+ 80200c20: 64a2 ld s1,8(sp)
+ 80200c22: 6105 addi sp,sp,32
+ 80200c24: 8082 ret
+ panic("kvmpa");
+ 80200c26: 00008517 auipc a0,0x8
+ 80200c2a: 7ea50513 addi a0,a0,2026 # 80209410 <digits+0x90>
+ 80200c2e: fffff097 auipc ra,0xfffff
+ 80200c32: 516080e7 jalr 1302(ra) # 80200144 <panic>
+ panic("kvmpa");
+ 80200c36: 00008517 auipc a0,0x8
+ 80200c3a: 7da50513 addi a0,a0,2010 # 80209410 <digits+0x90>
+ 80200c3e: fffff097 auipc ra,0xfffff
+ 80200c42: 506080e7 jalr 1286(ra) # 80200144 <panic>
+
+0000000080200c46 <kvmpa>:
+{
+ 80200c46: 1141 addi sp,sp,-16
+ 80200c48: e406 sd ra,8(sp)
+ 80200c4a: e022 sd s0,0(sp)
+ 80200c4c: 0800 addi s0,sp,16
+ 80200c4e: 85aa mv a1,a0
+ return kwalkaddr(kernel_pagetable, va);
+ 80200c50: 00013517 auipc a0,0x13
+ 80200c54: 40853503 ld a0,1032(a0) # 80214058 <kernel_pagetable>
+ 80200c58: 00000097 auipc ra,0x0
+ 80200c5c: f98080e7 jalr -104(ra) # 80200bf0 <kwalkaddr>
+}
+ 80200c60: 60a2 ld ra,8(sp)
+ 80200c62: 6402 ld s0,0(sp)
+ 80200c64: 0141 addi sp,sp,16
+ 80200c66: 8082 ret
+
+0000000080200c68 <mappages>:
+// physical addresses starting at pa. va and size might not
+// be page-aligned. Returns 0 on success, -1 if walk() couldn't
+// allocate a needed page-table page.
+int
+mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
+{
+ 80200c68: 715d addi sp,sp,-80
+ 80200c6a: e486 sd ra,72(sp)
+ 80200c6c: e0a2 sd s0,64(sp)
+ 80200c6e: fc26 sd s1,56(sp)
+ 80200c70: f84a sd s2,48(sp)
+ 80200c72: f44e sd s3,40(sp)
+ 80200c74: f052 sd s4,32(sp)
+ 80200c76: ec56 sd s5,24(sp)
+ 80200c78: e85a sd s6,16(sp)
+ 80200c7a: e45e sd s7,8(sp)
+ 80200c7c: 0880 addi s0,sp,80
+ 80200c7e: 8aaa mv s5,a0
+ 80200c80: 8b3a mv s6,a4
+ uint64 a, last;
+ pte_t *pte;
+
+ a = PGROUNDDOWN(va);
+ 80200c82: 777d lui a4,0xfffff
+ 80200c84: 00e5f7b3 and a5,a1,a4
+ last = PGROUNDDOWN(va + size - 1);
+ 80200c88: fff60993 addi s3,a2,-1 # fff <_entry-0x801ff001>
+ 80200c8c: 99ae add s3,s3,a1
+ 80200c8e: 00e9f9b3 and s3,s3,a4
+ a = PGROUNDDOWN(va);
+ 80200c92: 893e mv s2,a5
+ 80200c94: 40f68a33 sub s4,a3,a5
+ if(*pte & PTE_V)
+ panic("remap");
+ *pte = PA2PTE(pa) | perm | PTE_V;
+ if(a == last)
+ break;
+ a += PGSIZE;
+ 80200c98: 6b85 lui s7,0x1
+ 80200c9a: 012a04b3 add s1,s4,s2
+ if((pte = walk(pagetable, a, 1)) == NULL)
+ 80200c9e: 4605 li a2,1
+ 80200ca0: 85ca mv a1,s2
+ 80200ca2: 8556 mv a0,s5
+ 80200ca4: 00000097 auipc ra,0x0
+ 80200ca8: e64080e7 jalr -412(ra) # 80200b08 <walk>
+ 80200cac: c51d beqz a0,80200cda <mappages+0x72>
+ if(*pte & PTE_V)
+ 80200cae: 611c ld a5,0(a0)
+ 80200cb0: 8b85 andi a5,a5,1
+ 80200cb2: ef81 bnez a5,80200cca <mappages+0x62>
+ *pte = PA2PTE(pa) | perm | PTE_V;
+ 80200cb4: 80b1 srli s1,s1,0xc
+ 80200cb6: 04aa slli s1,s1,0xa
+ 80200cb8: 0164e4b3 or s1,s1,s6
+ 80200cbc: 0014e493 ori s1,s1,1
+ 80200cc0: e104 sd s1,0(a0)
+ if(a == last)
+ 80200cc2: 03390863 beq s2,s3,80200cf2 <mappages+0x8a>
+ a += PGSIZE;
+ 80200cc6: 995e add s2,s2,s7
+ if((pte = walk(pagetable, a, 1)) == NULL)
+ 80200cc8: bfc9 j 80200c9a <mappages+0x32>
+ panic("remap");
+ 80200cca: 00008517 auipc a0,0x8
+ 80200cce: 74e50513 addi a0,a0,1870 # 80209418 <digits+0x98>
+ 80200cd2: fffff097 auipc ra,0xfffff
+ 80200cd6: 472080e7 jalr 1138(ra) # 80200144 <panic>
+ return -1;
+ 80200cda: 557d li a0,-1
+ pa += PGSIZE;
+ }
+ return 0;
+}
+ 80200cdc: 60a6 ld ra,72(sp)
+ 80200cde: 6406 ld s0,64(sp)
+ 80200ce0: 74e2 ld s1,56(sp)
+ 80200ce2: 7942 ld s2,48(sp)
+ 80200ce4: 79a2 ld s3,40(sp)
+ 80200ce6: 7a02 ld s4,32(sp)
+ 80200ce8: 6ae2 ld s5,24(sp)
+ 80200cea: 6b42 ld s6,16(sp)
+ 80200cec: 6ba2 ld s7,8(sp)
+ 80200cee: 6161 addi sp,sp,80
+ 80200cf0: 8082 ret
+ return 0;
+ 80200cf2: 4501 li a0,0
+ 80200cf4: b7e5 j 80200cdc <mappages+0x74>
+
+0000000080200cf6 <kvmmap>:
+{
+ 80200cf6: 1141 addi sp,sp,-16
+ 80200cf8: e406 sd ra,8(sp)
+ 80200cfa: e022 sd s0,0(sp)
+ 80200cfc: 0800 addi s0,sp,16
+ 80200cfe: 8736 mv a4,a3
+ if(mappages(kernel_pagetable, va, sz, pa, perm) != 0)
+ 80200d00: 86ae mv a3,a1
+ 80200d02: 85aa mv a1,a0
+ 80200d04: 00013517 auipc a0,0x13
+ 80200d08: 35453503 ld a0,852(a0) # 80214058 <kernel_pagetable>
+ 80200d0c: 00000097 auipc ra,0x0
+ 80200d10: f5c080e7 jalr -164(ra) # 80200c68 <mappages>
+ 80200d14: e509 bnez a0,80200d1e <kvmmap+0x28>
+}
+ 80200d16: 60a2 ld ra,8(sp)
+ 80200d18: 6402 ld s0,0(sp)
+ 80200d1a: 0141 addi sp,sp,16
+ 80200d1c: 8082 ret
+ panic("kvmmap");
+ 80200d1e: 00008517 auipc a0,0x8
+ 80200d22: 70250513 addi a0,a0,1794 # 80209420 <digits+0xa0>
+ 80200d26: fffff097 auipc ra,0xfffff
+ 80200d2a: 41e080e7 jalr 1054(ra) # 80200144 <panic>
+
+0000000080200d2e <kvminit>:
+{
+ 80200d2e: 1101 addi sp,sp,-32
+ 80200d30: ec06 sd ra,24(sp)
+ 80200d32: e822 sd s0,16(sp)
+ 80200d34: e426 sd s1,8(sp)
+ 80200d36: 1000 addi s0,sp,32
+ kernel_pagetable = (pagetable_t) kalloc();
+ 80200d38: 00000097 auipc ra,0x0
+ 80200d3c: 822080e7 jalr -2014(ra) # 8020055a <kalloc>
+ 80200d40: 00013717 auipc a4,0x13
+ 80200d44: 30a73c23 sd a0,792(a4) # 80214058 <kernel_pagetable>
+ memset(kernel_pagetable, 0, PGSIZE);
+ 80200d48: 6605 lui a2,0x1
+ 80200d4a: 4581 li a1,0
+ 80200d4c: 00000097 auipc ra,0x0
+ 80200d50: a16080e7 jalr -1514(ra) # 80200762 <memset>
+ kvmmap(UART_V, UART, PGSIZE, PTE_R | PTE_W);
+ 80200d54: 4699 li a3,6
+ 80200d56: 6605 lui a2,0x1
+ 80200d58: 100005b7 lui a1,0x10000
+ 80200d5c: 3f100513 li a0,1009
+ 80200d60: 0572 slli a0,a0,0x1c
+ 80200d62: 00000097 auipc ra,0x0
+ 80200d66: f94080e7 jalr -108(ra) # 80200cf6 <kvmmap>
+ kvmmap(VIRTIO0_V, VIRTIO0, PGSIZE, PTE_R | PTE_W);
+ 80200d6a: 4699 li a3,6
+ 80200d6c: 6605 lui a2,0x1
+ 80200d6e: 100015b7 lui a1,0x10001
+ 80200d72: 03f10537 lui a0,0x3f10
+ 80200d76: 0505 addi a0,a0,1 # 3f10001 <_entry-0x7c2effff>
+ 80200d78: 0532 slli a0,a0,0xc
+ 80200d7a: 00000097 auipc ra,0x0
+ 80200d7e: f7c080e7 jalr -132(ra) # 80200cf6 <kvmmap>
+ kvmmap(CLINT_V, CLINT, 0x10000, PTE_R | PTE_W);
+ 80200d82: 4699 li a3,6
+ 80200d84: 6641 lui a2,0x10
+ 80200d86: 020005b7 lui a1,0x2000
+ 80200d8a: 01f81537 lui a0,0x1f81
+ 80200d8e: 0536 slli a0,a0,0xd
+ 80200d90: 00000097 auipc ra,0x0
+ 80200d94: f66080e7 jalr -154(ra) # 80200cf6 <kvmmap>
+ kvmmap(PLIC_V, PLIC, 0x4000, PTE_R | PTE_W);
+ 80200d98: 4699 li a3,6
+ 80200d9a: 6611 lui a2,0x4
+ 80200d9c: 0c0005b7 lui a1,0xc000
+ 80200da0: 00fc3537 lui a0,0xfc3
+ 80200da4: 053a slli a0,a0,0xe
+ 80200da6: 00000097 auipc ra,0x0
+ 80200daa: f50080e7 jalr -176(ra) # 80200cf6 <kvmmap>
+ kvmmap(PLIC_V + 0x200000, PLIC + 0x200000, 0x4000, PTE_R | PTE_W);
+ 80200dae: 4699 li a3,6
+ 80200db0: 6611 lui a2,0x4
+ 80200db2: 0c2005b7 lui a1,0xc200
+ 80200db6: 1f861537 lui a0,0x1f861
+ 80200dba: 0526 slli a0,a0,0x9
+ 80200dbc: 00000097 auipc ra,0x0
+ 80200dc0: f3a080e7 jalr -198(ra) # 80200cf6 <kvmmap>
+ kvmmap(KERNBASE, KERNBASE, (uint64)etext - KERNBASE, PTE_R | PTE_X);
+ 80200dc4: 0000b497 auipc s1,0xb
+ 80200dc8: f344b483 ld s1,-204(s1) # 8020bcf8 <_GLOBAL_OFFSET_TABLE_+0x20>
+ 80200dcc: 46a9 li a3,10
+ 80200dce: bff00613 li a2,-1025
+ 80200dd2: 0656 slli a2,a2,0x15
+ 80200dd4: 9626 add a2,a2,s1
+ 80200dd6: 40100593 li a1,1025
+ 80200dda: 05d6 slli a1,a1,0x15
+ 80200ddc: 852e mv a0,a1
+ 80200dde: 00000097 auipc ra,0x0
+ 80200de2: f18080e7 jalr -232(ra) # 80200cf6 <kvmmap>
+ kvmmap((uint64)etext, (uint64)etext, PHYSTOP - (uint64)etext, PTE_R | PTE_W);
+ 80200de6: 4699 li a3,6
+ 80200de8: 40300613 li a2,1027
+ 80200dec: 0656 slli a2,a2,0x15
+ 80200dee: 8e05 sub a2,a2,s1
+ 80200df0: 85a6 mv a1,s1
+ 80200df2: 8526 mv a0,s1
+ 80200df4: 00000097 auipc ra,0x0
+ 80200df8: f02080e7 jalr -254(ra) # 80200cf6 <kvmmap>
+ kvmmap(TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
+ 80200dfc: 46a9 li a3,10
+ 80200dfe: 6605 lui a2,0x1
+ 80200e00: 0000b597 auipc a1,0xb
+ 80200e04: ee05b583 ld a1,-288(a1) # 8020bce0 <_GLOBAL_OFFSET_TABLE_+0x8>
+ 80200e08: 04000537 lui a0,0x4000
+ 80200e0c: 157d addi a0,a0,-1 # 3ffffff <_entry-0x7c200001>
+ 80200e0e: 0532 slli a0,a0,0xc
+ 80200e10: 00000097 auipc ra,0x0
+ 80200e14: ee6080e7 jalr -282(ra) # 80200cf6 <kvmmap>
+}
+ 80200e18: 60e2 ld ra,24(sp)
+ 80200e1a: 6442 ld s0,16(sp)
+ 80200e1c: 64a2 ld s1,8(sp)
+ 80200e1e: 6105 addi sp,sp,32
+ 80200e20: 8082 ret
+
+0000000080200e22 <vmunmap>:
+// Remove npages of mappings starting from va. va must be
+// page-aligned. The mappings must exist.
+// Optionally free the physical memory.
+void
+vmunmap(pagetable_t pagetable, uint64 va, uint64 npages, int do_free)
+{
+ 80200e22: 715d addi sp,sp,-80
+ 80200e24: e486 sd ra,72(sp)
+ 80200e26: e0a2 sd s0,64(sp)
+ 80200e28: fc26 sd s1,56(sp)
+ 80200e2a: f84a sd s2,48(sp)
+ 80200e2c: f44e sd s3,40(sp)
+ 80200e2e: f052 sd s4,32(sp)
+ 80200e30: ec56 sd s5,24(sp)
+ 80200e32: e85a sd s6,16(sp)
+ 80200e34: e45e sd s7,8(sp)
+ 80200e36: 0880 addi s0,sp,80
+ uint64 a;
+ pte_t *pte;
+
+ if((va % PGSIZE) != 0)
+ 80200e38: 03459793 slli a5,a1,0x34
+ 80200e3c: e795 bnez a5,80200e68 <vmunmap+0x46>
+ 80200e3e: 8a2a mv s4,a0
+ 80200e40: 892e mv s2,a1
+ 80200e42: 8ab6 mv s5,a3
+ panic("vmunmap: not aligned");
+
+ for(a = va; a < va + npages*PGSIZE; a += PGSIZE){
+ 80200e44: 0632 slli a2,a2,0xc
+ 80200e46: 00b609b3 add s3,a2,a1
+ if((pte = walk(pagetable, a, 0)) == 0)
+ panic("vmunmap: walk");
+ if((*pte & PTE_V) == 0)
+ panic("vmunmap: not mapped");
+ if(PTE_FLAGS(*pte) == PTE_V)
+ 80200e4a: 4b85 li s7,1
+ for(a = va; a < va + npages*PGSIZE; a += PGSIZE){
+ 80200e4c: 6b05 lui s6,0x1
+ 80200e4e: 0735e263 bltu a1,s3,80200eb2 <vmunmap+0x90>
+ uint64 pa = PTE2PA(*pte);
+ kfree((void*)pa);
+ }
+ *pte = 0;
+ }
+}
+ 80200e52: 60a6 ld ra,72(sp)
+ 80200e54: 6406 ld s0,64(sp)
+ 80200e56: 74e2 ld s1,56(sp)
+ 80200e58: 7942 ld s2,48(sp)
+ 80200e5a: 79a2 ld s3,40(sp)
+ 80200e5c: 7a02 ld s4,32(sp)
+ 80200e5e: 6ae2 ld s5,24(sp)
+ 80200e60: 6b42 ld s6,16(sp)
+ 80200e62: 6ba2 ld s7,8(sp)
+ 80200e64: 6161 addi sp,sp,80
+ 80200e66: 8082 ret
+ panic("vmunmap: not aligned");
+ 80200e68: 00008517 auipc a0,0x8
+ 80200e6c: 5c050513 addi a0,a0,1472 # 80209428 <digits+0xa8>
+ 80200e70: fffff097 auipc ra,0xfffff
+ 80200e74: 2d4080e7 jalr 724(ra) # 80200144 <panic>
+ panic("vmunmap: walk");
+ 80200e78: 00008517 auipc a0,0x8
+ 80200e7c: 5c850513 addi a0,a0,1480 # 80209440 <digits+0xc0>
+ 80200e80: fffff097 auipc ra,0xfffff
+ 80200e84: 2c4080e7 jalr 708(ra) # 80200144 <panic>
+ panic("vmunmap: not mapped");
+ 80200e88: 00008517 auipc a0,0x8
+ 80200e8c: 5c850513 addi a0,a0,1480 # 80209450 <digits+0xd0>
+ 80200e90: fffff097 auipc ra,0xfffff
+ 80200e94: 2b4080e7 jalr 692(ra) # 80200144 <panic>
+ panic("vmunmap: not a leaf");
+ 80200e98: 00008517 auipc a0,0x8
+ 80200e9c: 5d050513 addi a0,a0,1488 # 80209468 <digits+0xe8>
+ 80200ea0: fffff097 auipc ra,0xfffff
+ 80200ea4: 2a4080e7 jalr 676(ra) # 80200144 <panic>
+ *pte = 0;
+ 80200ea8: 0004b023 sd zero,0(s1)
+ for(a = va; a < va + npages*PGSIZE; a += PGSIZE){
+ 80200eac: 995a add s2,s2,s6
+ 80200eae: fb3972e3 bgeu s2,s3,80200e52 <vmunmap+0x30>
+ if((pte = walk(pagetable, a, 0)) == 0)
+ 80200eb2: 4601 li a2,0
+ 80200eb4: 85ca mv a1,s2
+ 80200eb6: 8552 mv a0,s4
+ 80200eb8: 00000097 auipc ra,0x0
+ 80200ebc: c50080e7 jalr -944(ra) # 80200b08 <walk>
+ 80200ec0: 84aa mv s1,a0
+ 80200ec2: d95d beqz a0,80200e78 <vmunmap+0x56>
+ if((*pte & PTE_V) == 0)
+ 80200ec4: 6108 ld a0,0(a0)
+ 80200ec6: 00157793 andi a5,a0,1
+ 80200eca: dfdd beqz a5,80200e88 <vmunmap+0x66>
+ if(PTE_FLAGS(*pte) == PTE_V)
+ 80200ecc: 3ff57793 andi a5,a0,1023
+ 80200ed0: fd7784e3 beq a5,s7,80200e98 <vmunmap+0x76>
+ if(do_free){
+ 80200ed4: fc0a8ae3 beqz s5,80200ea8 <vmunmap+0x86>
+ uint64 pa = PTE2PA(*pte);
+ 80200ed8: 8129 srli a0,a0,0xa
+ kfree((void*)pa);
+ 80200eda: 0532 slli a0,a0,0xc
+ 80200edc: fffff097 auipc ra,0xfffff
+ 80200ee0: 564080e7 jalr 1380(ra) # 80200440 <kfree>
+ 80200ee4: b7d1 j 80200ea8 <vmunmap+0x86>
+
+0000000080200ee6 <uvmcreate>:
+
+// create an empty user page table.
+// returns 0 if out of memory.
+pagetable_t
+uvmcreate()
+{
+ 80200ee6: 1101 addi sp,sp,-32
+ 80200ee8: ec06 sd ra,24(sp)
+ 80200eea: e822 sd s0,16(sp)
+ 80200eec: e426 sd s1,8(sp)
+ 80200eee: 1000 addi s0,sp,32
+ pagetable_t pagetable;
+ pagetable = (pagetable_t) kalloc();
+ 80200ef0: fffff097 auipc ra,0xfffff
+ 80200ef4: 66a080e7 jalr 1642(ra) # 8020055a <kalloc>
+ 80200ef8: 84aa mv s1,a0
+ if(pagetable == NULL)
+ 80200efa: c519 beqz a0,80200f08 <uvmcreate+0x22>
+ return NULL;
+ memset(pagetable, 0, PGSIZE);
+ 80200efc: 6605 lui a2,0x1
+ 80200efe: 4581 li a1,0
+ 80200f00: 00000097 auipc ra,0x0
+ 80200f04: 862080e7 jalr -1950(ra) # 80200762 <memset>
+ return pagetable;
+}
+ 80200f08: 8526 mv a0,s1
+ 80200f0a: 60e2 ld ra,24(sp)
+ 80200f0c: 6442 ld s0,16(sp)
+ 80200f0e: 64a2 ld s1,8(sp)
+ 80200f10: 6105 addi sp,sp,32
+ 80200f12: 8082 ret
+
+0000000080200f14 <uvminit>:
+// Load the user initcode into address 0 of pagetable,
+// for the very first process.
+// sz must be less than a page.
+void
+uvminit(pagetable_t pagetable, pagetable_t kpagetable, uchar *src, uint sz)
+{
+ 80200f14: 7139 addi sp,sp,-64
+ 80200f16: fc06 sd ra,56(sp)
+ 80200f18: f822 sd s0,48(sp)
+ 80200f1a: f426 sd s1,40(sp)
+ 80200f1c: f04a sd s2,32(sp)
+ 80200f1e: ec4e sd s3,24(sp)
+ 80200f20: e852 sd s4,16(sp)
+ 80200f22: e456 sd s5,8(sp)
+ 80200f24: 0080 addi s0,sp,64
+ char *mem;
+
+ if(sz >= PGSIZE)
+ 80200f26: 6785 lui a5,0x1
+ 80200f28: 06f6f363 bgeu a3,a5,80200f8e <uvminit+0x7a>
+ 80200f2c: 8aaa mv s5,a0
+ 80200f2e: 8a2e mv s4,a1
+ 80200f30: 89b2 mv s3,a2
+ 80200f32: 8936 mv s2,a3
+ panic("inituvm: more than a page");
+ mem = kalloc();
+ 80200f34: fffff097 auipc ra,0xfffff
+ 80200f38: 626080e7 jalr 1574(ra) # 8020055a <kalloc>
+ 80200f3c: 84aa mv s1,a0
+ // printf("[uvminit]kalloc: %p\n", mem);
+ memset(mem, 0, PGSIZE);
+ 80200f3e: 6605 lui a2,0x1
+ 80200f40: 4581 li a1,0
+ 80200f42: 00000097 auipc ra,0x0
+ 80200f46: 820080e7 jalr -2016(ra) # 80200762 <memset>
+ mappages(pagetable, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X|PTE_U);
+ 80200f4a: 4779 li a4,30
+ 80200f4c: 86a6 mv a3,s1
+ 80200f4e: 6605 lui a2,0x1
+ 80200f50: 4581 li a1,0
+ 80200f52: 8556 mv a0,s5
+ 80200f54: 00000097 auipc ra,0x0
+ 80200f58: d14080e7 jalr -748(ra) # 80200c68 <mappages>
+ mappages(kpagetable, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X);
+ 80200f5c: 4739 li a4,14
+ 80200f5e: 86a6 mv a3,s1
+ 80200f60: 6605 lui a2,0x1
+ 80200f62: 4581 li a1,0
+ 80200f64: 8552 mv a0,s4
+ 80200f66: 00000097 auipc ra,0x0
+ 80200f6a: d02080e7 jalr -766(ra) # 80200c68 <mappages>
+ memmove(mem, src, sz);
+ 80200f6e: 864a mv a2,s2
+ 80200f70: 85ce mv a1,s3
+ 80200f72: 8526 mv a0,s1
+ 80200f74: 00000097 auipc ra,0x0
+ 80200f78: 84a080e7 jalr -1974(ra) # 802007be <memmove>
+ // for (int i = 0; i < sz; i ++) {
+ // printf("[uvminit]mem: %p, %x\n", mem + i, mem[i]);
+ // }
+}
+ 80200f7c: 70e2 ld ra,56(sp)
+ 80200f7e: 7442 ld s0,48(sp)
+ 80200f80: 74a2 ld s1,40(sp)
+ 80200f82: 7902 ld s2,32(sp)
+ 80200f84: 69e2 ld s3,24(sp)
+ 80200f86: 6a42 ld s4,16(sp)
+ 80200f88: 6aa2 ld s5,8(sp)
+ 80200f8a: 6121 addi sp,sp,64
+ 80200f8c: 8082 ret
+ panic("inituvm: more than a page");
+ 80200f8e: 00008517 auipc a0,0x8
+ 80200f92: 4f250513 addi a0,a0,1266 # 80209480 <digits+0x100>
+ 80200f96: fffff097 auipc ra,0xfffff
+ 80200f9a: 1ae080e7 jalr 430(ra) # 80200144 <panic>
+
+0000000080200f9e <uvmdealloc>:
+// newsz. oldsz and newsz need not be page-aligned, nor does newsz
+// need to be less than oldsz. oldsz can be larger than the actual
+// process size. Returns the new process size.
+uint64
+uvmdealloc(pagetable_t pagetable, pagetable_t kpagetable, uint64 oldsz, uint64 newsz)
+{
+ 80200f9e: 7179 addi sp,sp,-48
+ 80200fa0: f406 sd ra,40(sp)
+ 80200fa2: f022 sd s0,32(sp)
+ 80200fa4: ec26 sd s1,24(sp)
+ 80200fa6: e84a sd s2,16(sp)
+ 80200fa8: e44e sd s3,8(sp)
+ 80200faa: e052 sd s4,0(sp)
+ 80200fac: 1800 addi s0,sp,48
+ if(newsz >= oldsz)
+ return oldsz;
+ 80200fae: 8932 mv s2,a2
+ if(newsz >= oldsz)
+ 80200fb0: 02c6f063 bgeu a3,a2,80200fd0 <uvmdealloc+0x32>
+ 80200fb4: 89aa mv s3,a0
+ 80200fb6: 852e mv a0,a1
+ 80200fb8: 8936 mv s2,a3
+
+ if(PGROUNDUP(newsz) < PGROUNDUP(oldsz)){
+ 80200fba: 6785 lui a5,0x1
+ 80200fbc: 17fd addi a5,a5,-1 # fff <_entry-0x801ff001>
+ 80200fbe: 00f68a33 add s4,a3,a5
+ 80200fc2: 777d lui a4,0xfffff
+ 80200fc4: 00ea7a33 and s4,s4,a4
+ 80200fc8: 963e add a2,a2,a5
+ 80200fca: 8e79 and a2,a2,a4
+ 80200fcc: 00ca6b63 bltu s4,a2,80200fe2 <uvmdealloc+0x44>
+ vmunmap(kpagetable, PGROUNDUP(newsz), npages, 0);
+ vmunmap(pagetable, PGROUNDUP(newsz), npages, 1);
+ }
+
+ return newsz;
+}
+ 80200fd0: 854a mv a0,s2
+ 80200fd2: 70a2 ld ra,40(sp)
+ 80200fd4: 7402 ld s0,32(sp)
+ 80200fd6: 64e2 ld s1,24(sp)
+ 80200fd8: 6942 ld s2,16(sp)
+ 80200fda: 69a2 ld s3,8(sp)
+ 80200fdc: 6a02 ld s4,0(sp)
+ 80200fde: 6145 addi sp,sp,48
+ 80200fe0: 8082 ret
+ int npages = (PGROUNDUP(oldsz) - PGROUNDUP(newsz)) / PGSIZE;
+ 80200fe2: 414604b3 sub s1,a2,s4
+ 80200fe6: 80b1 srli s1,s1,0xc
+ vmunmap(kpagetable, PGROUNDUP(newsz), npages, 0);
+ 80200fe8: 2481 sext.w s1,s1
+ 80200fea: 4681 li a3,0
+ 80200fec: 8626 mv a2,s1
+ 80200fee: 85d2 mv a1,s4
+ 80200ff0: 00000097 auipc ra,0x0
+ 80200ff4: e32080e7 jalr -462(ra) # 80200e22 <vmunmap>
+ vmunmap(pagetable, PGROUNDUP(newsz), npages, 1);
+ 80200ff8: 4685 li a3,1
+ 80200ffa: 8626 mv a2,s1
+ 80200ffc: 85d2 mv a1,s4
+ 80200ffe: 854e mv a0,s3
+ 80201000: 00000097 auipc ra,0x0
+ 80201004: e22080e7 jalr -478(ra) # 80200e22 <vmunmap>
+ 80201008: b7e1 j 80200fd0 <uvmdealloc+0x32>
+
+000000008020100a <uvmalloc>:
+ if(newsz < oldsz)
+ 8020100a: 0ec6e763 bltu a3,a2,802010f8 <uvmalloc+0xee>
+{
+ 8020100e: 7139 addi sp,sp,-64
+ 80201010: fc06 sd ra,56(sp)
+ 80201012: f822 sd s0,48(sp)
+ 80201014: f426 sd s1,40(sp)
+ 80201016: f04a sd s2,32(sp)
+ 80201018: ec4e sd s3,24(sp)
+ 8020101a: e852 sd s4,16(sp)
+ 8020101c: e456 sd s5,8(sp)
+ 8020101e: e05a sd s6,0(sp)
+ 80201020: 0080 addi s0,sp,64
+ 80201022: 8a2a mv s4,a0
+ 80201024: 8aae mv s5,a1
+ 80201026: 8b36 mv s6,a3
+ oldsz = PGROUNDUP(oldsz);
+ 80201028: 6785 lui a5,0x1
+ 8020102a: 17fd addi a5,a5,-1 # fff <_entry-0x801ff001>
+ 8020102c: 963e add a2,a2,a5
+ 8020102e: 77fd lui a5,0xfffff
+ 80201030: 00f679b3 and s3,a2,a5
+ for(a = oldsz; a < newsz; a += PGSIZE){
+ 80201034: 0cd9f463 bgeu s3,a3,802010fc <uvmalloc+0xf2>
+ 80201038: 894e mv s2,s3
+ mem = kalloc();
+ 8020103a: fffff097 auipc ra,0xfffff
+ 8020103e: 520080e7 jalr 1312(ra) # 8020055a <kalloc>
+ 80201042: 84aa mv s1,a0
+ if(mem == NULL){
+ 80201044: c129 beqz a0,80201086 <uvmalloc+0x7c>
+ memset(mem, 0, PGSIZE);
+ 80201046: 6605 lui a2,0x1
+ 80201048: 4581 li a1,0
+ 8020104a: fffff097 auipc ra,0xfffff
+ 8020104e: 718080e7 jalr 1816(ra) # 80200762 <memset>
+ if (mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_W|PTE_X|PTE_R|PTE_U) != 0) {
+ 80201052: 4779 li a4,30
+ 80201054: 86a6 mv a3,s1
+ 80201056: 6605 lui a2,0x1
+ 80201058: 85ca mv a1,s2
+ 8020105a: 8552 mv a0,s4
+ 8020105c: 00000097 auipc ra,0x0
+ 80201060: c0c080e7 jalr -1012(ra) # 80200c68 <mappages>
+ 80201064: e521 bnez a0,802010ac <uvmalloc+0xa2>
+ if (mappages(kpagetable, a, PGSIZE, (uint64)mem, PTE_W|PTE_X|PTE_R) != 0){
+ 80201066: 4739 li a4,14
+ 80201068: 86a6 mv a3,s1
+ 8020106a: 6605 lui a2,0x1
+ 8020106c: 85ca mv a1,s2
+ 8020106e: 8556 mv a0,s5
+ 80201070: 00000097 auipc ra,0x0
+ 80201074: bf8080e7 jalr -1032(ra) # 80200c68 <mappages>
+ 80201078: e929 bnez a0,802010ca <uvmalloc+0xc0>
+ for(a = oldsz; a < newsz; a += PGSIZE){
+ 8020107a: 6785 lui a5,0x1
+ 8020107c: 993e add s2,s2,a5
+ 8020107e: fb696ee3 bltu s2,s6,8020103a <uvmalloc+0x30>
+ return newsz;
+ 80201082: 855a mv a0,s6
+ 80201084: a811 j 80201098 <uvmalloc+0x8e>
+ uvmdealloc(pagetable, kpagetable, a, oldsz);
+ 80201086: 86ce mv a3,s3
+ 80201088: 864a mv a2,s2
+ 8020108a: 85d6 mv a1,s5
+ 8020108c: 8552 mv a0,s4
+ 8020108e: 00000097 auipc ra,0x0
+ 80201092: f10080e7 jalr -240(ra) # 80200f9e <uvmdealloc>
+ return 0;
+ 80201096: 4501 li a0,0
+}
+ 80201098: 70e2 ld ra,56(sp)
+ 8020109a: 7442 ld s0,48(sp)
+ 8020109c: 74a2 ld s1,40(sp)
+ 8020109e: 7902 ld s2,32(sp)
+ 802010a0: 69e2 ld s3,24(sp)
+ 802010a2: 6a42 ld s4,16(sp)
+ 802010a4: 6aa2 ld s5,8(sp)
+ 802010a6: 6b02 ld s6,0(sp)
+ 802010a8: 6121 addi sp,sp,64
+ 802010aa: 8082 ret
+ kfree(mem);
+ 802010ac: 8526 mv a0,s1
+ 802010ae: fffff097 auipc ra,0xfffff
+ 802010b2: 392080e7 jalr 914(ra) # 80200440 <kfree>
+ uvmdealloc(pagetable, kpagetable, a, oldsz);
+ 802010b6: 86ce mv a3,s3
+ 802010b8: 864a mv a2,s2
+ 802010ba: 85d6 mv a1,s5
+ 802010bc: 8552 mv a0,s4
+ 802010be: 00000097 auipc ra,0x0
+ 802010c2: ee0080e7 jalr -288(ra) # 80200f9e <uvmdealloc>
+ return 0;
+ 802010c6: 4501 li a0,0
+ 802010c8: bfc1 j 80201098 <uvmalloc+0x8e>
+ int npages = (a - oldsz) / PGSIZE;
+ 802010ca: 41390633 sub a2,s2,s3
+ 802010ce: 8231 srli a2,a2,0xc
+ 802010d0: 0006049b sext.w s1,a2
+ vmunmap(pagetable, oldsz, npages + 1, 1); // plus the page allocated above.
+ 802010d4: 4685 li a3,1
+ 802010d6: 2605 addiw a2,a2,1 # 1001 <_entry-0x801fefff>
+ 802010d8: 85ce mv a1,s3
+ 802010da: 8552 mv a0,s4
+ 802010dc: 00000097 auipc ra,0x0
+ 802010e0: d46080e7 jalr -698(ra) # 80200e22 <vmunmap>
+ vmunmap(kpagetable, oldsz, npages, 0);
+ 802010e4: 4681 li a3,0
+ 802010e6: 8626 mv a2,s1
+ 802010e8: 85ce mv a1,s3
+ 802010ea: 8556 mv a0,s5
+ 802010ec: 00000097 auipc ra,0x0
+ 802010f0: d36080e7 jalr -714(ra) # 80200e22 <vmunmap>
+ return 0;
+ 802010f4: 4501 li a0,0
+ 802010f6: b74d j 80201098 <uvmalloc+0x8e>
+ return oldsz;
+ 802010f8: 8532 mv a0,a2
+}
+ 802010fa: 8082 ret
+ return newsz;
+ 802010fc: 8536 mv a0,a3
+ 802010fe: bf69 j 80201098 <uvmalloc+0x8e>
+
+0000000080201100 <freewalk>:
+
+// Recursively free page-table pages.
+// All leaf mappings must already have been removed.
+void
+freewalk(pagetable_t pagetable)
+{
+ 80201100: 7179 addi sp,sp,-48
+ 80201102: f406 sd ra,40(sp)
+ 80201104: f022 sd s0,32(sp)
+ 80201106: ec26 sd s1,24(sp)
+ 80201108: e84a sd s2,16(sp)
+ 8020110a: e44e sd s3,8(sp)
+ 8020110c: e052 sd s4,0(sp)
+ 8020110e: 1800 addi s0,sp,48
+ 80201110: 8a2a mv s4,a0
+ // there are 2^9 = 512 PTEs in a page table.
+ for(int i = 0; i < 512; i++){
+ 80201112: 84aa mv s1,a0
+ 80201114: 6905 lui s2,0x1
+ 80201116: 992a add s2,s2,a0
+ pte_t pte = pagetable[i];
+ if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){
+ 80201118: 4985 li s3,1
+ 8020111a: a829 j 80201134 <freewalk+0x34>
+ // this PTE points to a lower-level page table.
+ uint64 child = PTE2PA(pte);
+ 8020111c: 83a9 srli a5,a5,0xa
+ freewalk((pagetable_t)child);
+ 8020111e: 00c79513 slli a0,a5,0xc
+ 80201122: 00000097 auipc ra,0x0
+ 80201126: fde080e7 jalr -34(ra) # 80201100 <freewalk>
+ pagetable[i] = 0;
+ 8020112a: 0004b023 sd zero,0(s1)
+ for(int i = 0; i < 512; i++){
+ 8020112e: 04a1 addi s1,s1,8
+ 80201130: 03248163 beq s1,s2,80201152 <freewalk+0x52>
+ pte_t pte = pagetable[i];
+ 80201134: 609c ld a5,0(s1)
+ if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){
+ 80201136: 00f7f713 andi a4,a5,15
+ 8020113a: ff3701e3 beq a4,s3,8020111c <freewalk+0x1c>
+ } else if(pte & PTE_V){
+ 8020113e: 8b85 andi a5,a5,1
+ 80201140: d7fd beqz a5,8020112e <freewalk+0x2e>
+ panic("freewalk: leaf");
+ 80201142: 00008517 auipc a0,0x8
+ 80201146: 35e50513 addi a0,a0,862 # 802094a0 <digits+0x120>
+ 8020114a: fffff097 auipc ra,0xfffff
+ 8020114e: ffa080e7 jalr -6(ra) # 80200144 <panic>
+ }
+ }
+ kfree((void*)pagetable);
+ 80201152: 8552 mv a0,s4
+ 80201154: fffff097 auipc ra,0xfffff
+ 80201158: 2ec080e7 jalr 748(ra) # 80200440 <kfree>
+}
+ 8020115c: 70a2 ld ra,40(sp)
+ 8020115e: 7402 ld s0,32(sp)
+ 80201160: 64e2 ld s1,24(sp)
+ 80201162: 6942 ld s2,16(sp)
+ 80201164: 69a2 ld s3,8(sp)
+ 80201166: 6a02 ld s4,0(sp)
+ 80201168: 6145 addi sp,sp,48
+ 8020116a: 8082 ret
+
+000000008020116c <uvmfree>:
+
+// Free user memory pages,
+// then free page-table pages.
+void
+uvmfree(pagetable_t pagetable, uint64 sz)
+{
+ 8020116c: 1101 addi sp,sp,-32
+ 8020116e: ec06 sd ra,24(sp)
+ 80201170: e822 sd s0,16(sp)
+ 80201172: e426 sd s1,8(sp)
+ 80201174: 1000 addi s0,sp,32
+ 80201176: 84aa mv s1,a0
+ if(sz > 0)
+ 80201178: e999 bnez a1,8020118e <uvmfree+0x22>
+ vmunmap(pagetable, 0, PGROUNDUP(sz)/PGSIZE, 1);
+ freewalk(pagetable);
+ 8020117a: 8526 mv a0,s1
+ 8020117c: 00000097 auipc ra,0x0
+ 80201180: f84080e7 jalr -124(ra) # 80201100 <freewalk>
+}
+ 80201184: 60e2 ld ra,24(sp)
+ 80201186: 6442 ld s0,16(sp)
+ 80201188: 64a2 ld s1,8(sp)
+ 8020118a: 6105 addi sp,sp,32
+ 8020118c: 8082 ret
+ vmunmap(pagetable, 0, PGROUNDUP(sz)/PGSIZE, 1);
+ 8020118e: 6785 lui a5,0x1
+ 80201190: 17fd addi a5,a5,-1 # fff <_entry-0x801ff001>
+ 80201192: 95be add a1,a1,a5
+ 80201194: 4685 li a3,1
+ 80201196: 00c5d613 srli a2,a1,0xc
+ 8020119a: 4581 li a1,0
+ 8020119c: 00000097 auipc ra,0x0
+ 802011a0: c86080e7 jalr -890(ra) # 80200e22 <vmunmap>
+ 802011a4: bfd9 j 8020117a <uvmfree+0xe>
+
+00000000802011a6 <uvmcopy>:
+ pte_t *pte;
+ uint64 pa, i = 0, ki = 0;
+ uint flags;
+ char *mem;
+
+ while (i < sz){
+ 802011a6: 10068563 beqz a3,802012b0 <uvmcopy+0x10a>
+{
+ 802011aa: 715d addi sp,sp,-80
+ 802011ac: e486 sd ra,72(sp)
+ 802011ae: e0a2 sd s0,64(sp)
+ 802011b0: fc26 sd s1,56(sp)
+ 802011b2: f84a sd s2,48(sp)
+ 802011b4: f44e sd s3,40(sp)
+ 802011b6: f052 sd s4,32(sp)
+ 802011b8: ec56 sd s5,24(sp)
+ 802011ba: e85a sd s6,16(sp)
+ 802011bc: e45e sd s7,8(sp)
+ 802011be: e062 sd s8,0(sp)
+ 802011c0: 0880 addi s0,sp,80
+ 802011c2: 8baa mv s7,a0
+ 802011c4: 8a2e mv s4,a1
+ 802011c6: 8b32 mv s6,a2
+ 802011c8: 8ab6 mv s5,a3
+ uint64 pa, i = 0, ki = 0;
+ 802011ca: 4981 li s3,0
+ 802011cc: a011 j 802011d0 <uvmcopy+0x2a>
+ memmove(mem, (char*)pa, PGSIZE);
+ if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0) {
+ kfree(mem);
+ goto err;
+ }
+ i += PGSIZE;
+ 802011ce: 89e2 mv s3,s8
+ if((pte = walk(old, i, 0)) == NULL)
+ 802011d0: 4601 li a2,0
+ 802011d2: 85ce mv a1,s3
+ 802011d4: 855e mv a0,s7
+ 802011d6: 00000097 auipc ra,0x0
+ 802011da: 932080e7 jalr -1742(ra) # 80200b08 <walk>
+ 802011de: c135 beqz a0,80201242 <uvmcopy+0x9c>
+ if((*pte & PTE_V) == 0)
+ 802011e0: 6118 ld a4,0(a0)
+ 802011e2: 00177793 andi a5,a4,1
+ 802011e6: c7b5 beqz a5,80201252 <uvmcopy+0xac>
+ pa = PTE2PA(*pte);
+ 802011e8: 00a75593 srli a1,a4,0xa
+ 802011ec: 00c59c13 slli s8,a1,0xc
+ flags = PTE_FLAGS(*pte);
+ 802011f0: 3ff77493 andi s1,a4,1023
+ if((mem = kalloc()) == NULL)
+ 802011f4: fffff097 auipc ra,0xfffff
+ 802011f8: 366080e7 jalr 870(ra) # 8020055a <kalloc>
+ 802011fc: 892a mv s2,a0
+ 802011fe: c92d beqz a0,80201270 <uvmcopy+0xca>
+ memmove(mem, (char*)pa, PGSIZE);
+ 80201200: 6605 lui a2,0x1
+ 80201202: 85e2 mv a1,s8
+ 80201204: fffff097 auipc ra,0xfffff
+ 80201208: 5ba080e7 jalr 1466(ra) # 802007be <memmove>
+ if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0) {
+ 8020120c: 2481 sext.w s1,s1
+ 8020120e: 8726 mv a4,s1
+ 80201210: 86ca mv a3,s2
+ 80201212: 6605 lui a2,0x1
+ 80201214: 85ce mv a1,s3
+ 80201216: 8552 mv a0,s4
+ 80201218: 00000097 auipc ra,0x0
+ 8020121c: a50080e7 jalr -1456(ra) # 80200c68 <mappages>
+ 80201220: e129 bnez a0,80201262 <uvmcopy+0xbc>
+ i += PGSIZE;
+ 80201222: 6c05 lui s8,0x1
+ 80201224: 9c4e add s8,s8,s3
+ if(mappages(knew, ki, PGSIZE, (uint64)mem, flags & ~PTE_U) != 0){
+ 80201226: 3ef4f713 andi a4,s1,1007
+ 8020122a: 86ca mv a3,s2
+ 8020122c: 6605 lui a2,0x1
+ 8020122e: 85ce mv a1,s3
+ 80201230: 855a mv a0,s6
+ 80201232: 00000097 auipc ra,0x0
+ 80201236: a36080e7 jalr -1482(ra) # 80200c68 <mappages>
+ 8020123a: ed05 bnez a0,80201272 <uvmcopy+0xcc>
+ while (i < sz){
+ 8020123c: f95c69e3 bltu s8,s5,802011ce <uvmcopy+0x28>
+ 80201240: a8a1 j 80201298 <uvmcopy+0xf2>
+ panic("uvmcopy: pte should exist");
+ 80201242: 00008517 auipc a0,0x8
+ 80201246: 26e50513 addi a0,a0,622 # 802094b0 <digits+0x130>
+ 8020124a: fffff097 auipc ra,0xfffff
+ 8020124e: efa080e7 jalr -262(ra) # 80200144 <panic>
+ panic("uvmcopy: page not present");
+ 80201252: 00008517 auipc a0,0x8
+ 80201256: 27e50513 addi a0,a0,638 # 802094d0 <digits+0x150>
+ 8020125a: fffff097 auipc ra,0xfffff
+ 8020125e: eea080e7 jalr -278(ra) # 80200144 <panic>
+ kfree(mem);
+ 80201262: 854a mv a0,s2
+ 80201264: fffff097 auipc ra,0xfffff
+ 80201268: 1dc080e7 jalr 476(ra) # 80200440 <kfree>
+ goto err;
+ 8020126c: 8c4e mv s8,s3
+ 8020126e: a011 j 80201272 <uvmcopy+0xcc>
+ 80201270: 8c4e mv s8,s3
+ ki += PGSIZE;
+ }
+ return 0;
+
+ err:
+ vmunmap(knew, 0, ki / PGSIZE, 0);
+ 80201272: 4681 li a3,0
+ 80201274: 00c9d613 srli a2,s3,0xc
+ 80201278: 4581 li a1,0
+ 8020127a: 855a mv a0,s6
+ 8020127c: 00000097 auipc ra,0x0
+ 80201280: ba6080e7 jalr -1114(ra) # 80200e22 <vmunmap>
+ vmunmap(new, 0, i / PGSIZE, 1);
+ 80201284: 4685 li a3,1
+ 80201286: 00cc5613 srli a2,s8,0xc
+ 8020128a: 4581 li a1,0
+ 8020128c: 8552 mv a0,s4
+ 8020128e: 00000097 auipc ra,0x0
+ 80201292: b94080e7 jalr -1132(ra) # 80200e22 <vmunmap>
+ return -1;
+ 80201296: 557d li a0,-1
+}
+ 80201298: 60a6 ld ra,72(sp)
+ 8020129a: 6406 ld s0,64(sp)
+ 8020129c: 74e2 ld s1,56(sp)
+ 8020129e: 7942 ld s2,48(sp)
+ 802012a0: 79a2 ld s3,40(sp)
+ 802012a2: 7a02 ld s4,32(sp)
+ 802012a4: 6ae2 ld s5,24(sp)
+ 802012a6: 6b42 ld s6,16(sp)
+ 802012a8: 6ba2 ld s7,8(sp)
+ 802012aa: 6c02 ld s8,0(sp)
+ 802012ac: 6161 addi sp,sp,80
+ 802012ae: 8082 ret
+ return 0;
+ 802012b0: 4501 li a0,0
+}
+ 802012b2: 8082 ret
+
+00000000802012b4 <uvmclear>:
+
+// mark a PTE invalid for user access.
+// used by exec for the user stack guard page.
+void
+uvmclear(pagetable_t pagetable, uint64 va)
+{
+ 802012b4: 1141 addi sp,sp,-16
+ 802012b6: e406 sd ra,8(sp)
+ 802012b8: e022 sd s0,0(sp)
+ 802012ba: 0800 addi s0,sp,16
+ pte_t *pte;
+
+ pte = walk(pagetable, va, 0);
+ 802012bc: 4601 li a2,0
+ 802012be: 00000097 auipc ra,0x0
+ 802012c2: 84a080e7 jalr -1974(ra) # 80200b08 <walk>
+ if(pte == NULL)
+ 802012c6: c901 beqz a0,802012d6 <uvmclear+0x22>
+ panic("uvmclear");
+ *pte &= ~PTE_U;
+ 802012c8: 611c ld a5,0(a0)
+ 802012ca: 9bbd andi a5,a5,-17
+ 802012cc: e11c sd a5,0(a0)
+}
+ 802012ce: 60a2 ld ra,8(sp)
+ 802012d0: 6402 ld s0,0(sp)
+ 802012d2: 0141 addi sp,sp,16
+ 802012d4: 8082 ret
+ panic("uvmclear");
+ 802012d6: 00008517 auipc a0,0x8
+ 802012da: 21a50513 addi a0,a0,538 # 802094f0 <digits+0x170>
+ 802012de: fffff097 auipc ra,0xfffff
+ 802012e2: e66080e7 jalr -410(ra) # 80200144 <panic>
+
+00000000802012e6 <copyout>:
+int
+copyout(pagetable_t pagetable, uint64 dstva, char *src, uint64 len)
+{
+ uint64 n, va0, pa0;
+
+ while(len > 0){
+ 802012e6: c6bd beqz a3,80201354 <copyout+0x6e>
+{
+ 802012e8: 715d addi sp,sp,-80
+ 802012ea: e486 sd ra,72(sp)
+ 802012ec: e0a2 sd s0,64(sp)
+ 802012ee: fc26 sd s1,56(sp)
+ 802012f0: f84a sd s2,48(sp)
+ 802012f2: f44e sd s3,40(sp)
+ 802012f4: f052 sd s4,32(sp)
+ 802012f6: ec56 sd s5,24(sp)
+ 802012f8: e85a sd s6,16(sp)
+ 802012fa: e45e sd s7,8(sp)
+ 802012fc: e062 sd s8,0(sp)
+ 802012fe: 0880 addi s0,sp,80
+ 80201300: 8b2a mv s6,a0
+ 80201302: 8c2e mv s8,a1
+ 80201304: 8a32 mv s4,a2
+ 80201306: 89b6 mv s3,a3
+ va0 = PGROUNDDOWN(dstva);
+ 80201308: 7bfd lui s7,0xfffff
+ pa0 = walkaddr(pagetable, va0);
+ if(pa0 == NULL)
+ return -1;
+ n = PGSIZE - (dstva - va0);
+ 8020130a: 6a85 lui s5,0x1
+ 8020130c: a015 j 80201330 <copyout+0x4a>
+ if(n > len)
+ n = len;
+ memmove((void *)(pa0 + (dstva - va0)), src, n);
+ 8020130e: 9562 add a0,a0,s8
+ 80201310: 0004861b sext.w a2,s1
+ 80201314: 85d2 mv a1,s4
+ 80201316: 41250533 sub a0,a0,s2
+ 8020131a: fffff097 auipc ra,0xfffff
+ 8020131e: 4a4080e7 jalr 1188(ra) # 802007be <memmove>
+
+ len -= n;
+ 80201322: 409989b3 sub s3,s3,s1
+ src += n;
+ 80201326: 9a26 add s4,s4,s1
+ dstva = va0 + PGSIZE;
+ 80201328: 01590c33 add s8,s2,s5
+ while(len > 0){
+ 8020132c: 02098263 beqz s3,80201350 <copyout+0x6a>
+ va0 = PGROUNDDOWN(dstva);
+ 80201330: 017c7933 and s2,s8,s7
+ pa0 = walkaddr(pagetable, va0);
+ 80201334: 85ca mv a1,s2
+ 80201336: 855a mv a0,s6
+ 80201338: 00000097 auipc ra,0x0
+ 8020133c: 876080e7 jalr -1930(ra) # 80200bae <walkaddr>
+ if(pa0 == NULL)
+ 80201340: cd01 beqz a0,80201358 <copyout+0x72>
+ n = PGSIZE - (dstva - va0);
+ 80201342: 418904b3 sub s1,s2,s8
+ 80201346: 94d6 add s1,s1,s5
+ 80201348: fc99f3e3 bgeu s3,s1,8020130e <copyout+0x28>
+ 8020134c: 84ce mv s1,s3
+ 8020134e: b7c1 j 8020130e <copyout+0x28>
+ }
+ return 0;
+ 80201350: 4501 li a0,0
+ 80201352: a021 j 8020135a <copyout+0x74>
+ 80201354: 4501 li a0,0
+}
+ 80201356: 8082 ret
+ return -1;
+ 80201358: 557d li a0,-1
+}
+ 8020135a: 60a6 ld ra,72(sp)
+ 8020135c: 6406 ld s0,64(sp)
+ 8020135e: 74e2 ld s1,56(sp)
+ 80201360: 7942 ld s2,48(sp)
+ 80201362: 79a2 ld s3,40(sp)
+ 80201364: 7a02 ld s4,32(sp)
+ 80201366: 6ae2 ld s5,24(sp)
+ 80201368: 6b42 ld s6,16(sp)
+ 8020136a: 6ba2 ld s7,8(sp)
+ 8020136c: 6c02 ld s8,0(sp)
+ 8020136e: 6161 addi sp,sp,80
+ 80201370: 8082 ret
+
+0000000080201372 <copyout2>:
+
+int
+copyout2(uint64 dstva, char *src, uint64 len)
+{
+ 80201372: 7179 addi sp,sp,-48
+ 80201374: f406 sd ra,40(sp)
+ 80201376: f022 sd s0,32(sp)
+ 80201378: ec26 sd s1,24(sp)
+ 8020137a: e84a sd s2,16(sp)
+ 8020137c: e44e sd s3,8(sp)
+ 8020137e: 1800 addi s0,sp,48
+ 80201380: 84aa mv s1,a0
+ 80201382: 89ae mv s3,a1
+ 80201384: 8932 mv s2,a2
+ uint64 sz = myproc()->sz;
+ 80201386: 00000097 auipc ra,0x0
+ 8020138a: 6b6080e7 jalr 1718(ra) # 80201a3c <myproc>
+ 8020138e: 653c ld a5,72(a0)
+ if (dstva + len > sz || dstva >= sz) {
+ 80201390: 01248733 add a4,s1,s2
+ 80201394: 02e7e463 bltu a5,a4,802013bc <copyout2+0x4a>
+ 80201398: 02f4f463 bgeu s1,a5,802013c0 <copyout2+0x4e>
+ return -1;
+ }
+ memmove((void *)dstva, src, len);
+ 8020139c: 0009061b sext.w a2,s2
+ 802013a0: 85ce mv a1,s3
+ 802013a2: 8526 mv a0,s1
+ 802013a4: fffff097 auipc ra,0xfffff
+ 802013a8: 41a080e7 jalr 1050(ra) # 802007be <memmove>
+ return 0;
+ 802013ac: 4501 li a0,0
+}
+ 802013ae: 70a2 ld ra,40(sp)
+ 802013b0: 7402 ld s0,32(sp)
+ 802013b2: 64e2 ld s1,24(sp)
+ 802013b4: 6942 ld s2,16(sp)
+ 802013b6: 69a2 ld s3,8(sp)
+ 802013b8: 6145 addi sp,sp,48
+ 802013ba: 8082 ret
+ return -1;
+ 802013bc: 557d li a0,-1
+ 802013be: bfc5 j 802013ae <copyout2+0x3c>
+ 802013c0: 557d li a0,-1
+ 802013c2: b7f5 j 802013ae <copyout2+0x3c>
+
+00000000802013c4 <copyin>:
+int
+copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
+{
+ uint64 n, va0, pa0;
+
+ while(len > 0){
+ 802013c4: caa5 beqz a3,80201434 <copyin+0x70>
+{
+ 802013c6: 715d addi sp,sp,-80
+ 802013c8: e486 sd ra,72(sp)
+ 802013ca: e0a2 sd s0,64(sp)
+ 802013cc: fc26 sd s1,56(sp)
+ 802013ce: f84a sd s2,48(sp)
+ 802013d0: f44e sd s3,40(sp)
+ 802013d2: f052 sd s4,32(sp)
+ 802013d4: ec56 sd s5,24(sp)
+ 802013d6: e85a sd s6,16(sp)
+ 802013d8: e45e sd s7,8(sp)
+ 802013da: e062 sd s8,0(sp)
+ 802013dc: 0880 addi s0,sp,80
+ 802013de: 8b2a mv s6,a0
+ 802013e0: 8a2e mv s4,a1
+ 802013e2: 8c32 mv s8,a2
+ 802013e4: 89b6 mv s3,a3
+ va0 = PGROUNDDOWN(srcva);
+ 802013e6: 7bfd lui s7,0xfffff
+ pa0 = walkaddr(pagetable, va0);
+ if(pa0 == NULL)
+ return -1;
+ n = PGSIZE - (srcva - va0);
+ 802013e8: 6a85 lui s5,0x1
+ 802013ea: a01d j 80201410 <copyin+0x4c>
+ if(n > len)
+ n = len;
+ memmove(dst, (void *)(pa0 + (srcva - va0)), n);
+ 802013ec: 018505b3 add a1,a0,s8
+ 802013f0: 0004861b sext.w a2,s1
+ 802013f4: 412585b3 sub a1,a1,s2
+ 802013f8: 8552 mv a0,s4
+ 802013fa: fffff097 auipc ra,0xfffff
+ 802013fe: 3c4080e7 jalr 964(ra) # 802007be <memmove>
+
+ len -= n;
+ 80201402: 409989b3 sub s3,s3,s1
+ dst += n;
+ 80201406: 9a26 add s4,s4,s1
+ srcva = va0 + PGSIZE;
+ 80201408: 01590c33 add s8,s2,s5
+ while(len > 0){
+ 8020140c: 02098263 beqz s3,80201430 <copyin+0x6c>
+ va0 = PGROUNDDOWN(srcva);
+ 80201410: 017c7933 and s2,s8,s7
+ pa0 = walkaddr(pagetable, va0);
+ 80201414: 85ca mv a1,s2
+ 80201416: 855a mv a0,s6
+ 80201418: fffff097 auipc ra,0xfffff
+ 8020141c: 796080e7 jalr 1942(ra) # 80200bae <walkaddr>
+ if(pa0 == NULL)
+ 80201420: cd01 beqz a0,80201438 <copyin+0x74>
+ n = PGSIZE - (srcva - va0);
+ 80201422: 418904b3 sub s1,s2,s8
+ 80201426: 94d6 add s1,s1,s5
+ 80201428: fc99f2e3 bgeu s3,s1,802013ec <copyin+0x28>
+ 8020142c: 84ce mv s1,s3
+ 8020142e: bf7d j 802013ec <copyin+0x28>
+ }
+ return 0;
+ 80201430: 4501 li a0,0
+ 80201432: a021 j 8020143a <copyin+0x76>
+ 80201434: 4501 li a0,0
+}
+ 80201436: 8082 ret
+ return -1;
+ 80201438: 557d li a0,-1
+}
+ 8020143a: 60a6 ld ra,72(sp)
+ 8020143c: 6406 ld s0,64(sp)
+ 8020143e: 74e2 ld s1,56(sp)
+ 80201440: 7942 ld s2,48(sp)
+ 80201442: 79a2 ld s3,40(sp)
+ 80201444: 7a02 ld s4,32(sp)
+ 80201446: 6ae2 ld s5,24(sp)
+ 80201448: 6b42 ld s6,16(sp)
+ 8020144a: 6ba2 ld s7,8(sp)
+ 8020144c: 6c02 ld s8,0(sp)
+ 8020144e: 6161 addi sp,sp,80
+ 80201450: 8082 ret
+
+0000000080201452 <copyin2>:
+
+int
+copyin2(char *dst, uint64 srcva, uint64 len)
+{
+ 80201452: 7179 addi sp,sp,-48
+ 80201454: f406 sd ra,40(sp)
+ 80201456: f022 sd s0,32(sp)
+ 80201458: ec26 sd s1,24(sp)
+ 8020145a: e84a sd s2,16(sp)
+ 8020145c: e44e sd s3,8(sp)
+ 8020145e: 1800 addi s0,sp,48
+ 80201460: 89aa mv s3,a0
+ 80201462: 84ae mv s1,a1
+ 80201464: 8932 mv s2,a2
+ uint64 sz = myproc()->sz;
+ 80201466: 00000097 auipc ra,0x0
+ 8020146a: 5d6080e7 jalr 1494(ra) # 80201a3c <myproc>
+ 8020146e: 653c ld a5,72(a0)
+ if (srcva + len > sz || srcva >= sz) {
+ 80201470: 01248733 add a4,s1,s2
+ 80201474: 02e7e463 bltu a5,a4,8020149c <copyin2+0x4a>
+ 80201478: 02f4f463 bgeu s1,a5,802014a0 <copyin2+0x4e>
+ return -1;
+ }
+ memmove(dst, (void *)srcva, len);
+ 8020147c: 0009061b sext.w a2,s2
+ 80201480: 85a6 mv a1,s1
+ 80201482: 854e mv a0,s3
+ 80201484: fffff097 auipc ra,0xfffff
+ 80201488: 33a080e7 jalr 826(ra) # 802007be <memmove>
+ return 0;
+ 8020148c: 4501 li a0,0
+}
+ 8020148e: 70a2 ld ra,40(sp)
+ 80201490: 7402 ld s0,32(sp)
+ 80201492: 64e2 ld s1,24(sp)
+ 80201494: 6942 ld s2,16(sp)
+ 80201496: 69a2 ld s3,8(sp)
+ 80201498: 6145 addi sp,sp,48
+ 8020149a: 8082 ret
+ return -1;
+ 8020149c: 557d li a0,-1
+ 8020149e: bfc5 j 8020148e <copyin2+0x3c>
+ 802014a0: 557d li a0,-1
+ 802014a2: b7f5 j 8020148e <copyin2+0x3c>
+
+00000000802014a4 <copyinstr>:
+copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
+{
+ uint64 n, va0, pa0;
+ int got_null = 0;
+
+ while(got_null == 0 && max > 0){
+ 802014a4: c2dd beqz a3,8020154a <copyinstr+0xa6>
+{
+ 802014a6: 715d addi sp,sp,-80
+ 802014a8: e486 sd ra,72(sp)
+ 802014aa: e0a2 sd s0,64(sp)
+ 802014ac: fc26 sd s1,56(sp)
+ 802014ae: f84a sd s2,48(sp)
+ 802014b0: f44e sd s3,40(sp)
+ 802014b2: f052 sd s4,32(sp)
+ 802014b4: ec56 sd s5,24(sp)
+ 802014b6: e85a sd s6,16(sp)
+ 802014b8: e45e sd s7,8(sp)
+ 802014ba: 0880 addi s0,sp,80
+ 802014bc: 8a2a mv s4,a0
+ 802014be: 8b2e mv s6,a1
+ 802014c0: 8bb2 mv s7,a2
+ 802014c2: 84b6 mv s1,a3
+ va0 = PGROUNDDOWN(srcva);
+ 802014c4: 7afd lui s5,0xfffff
+ pa0 = walkaddr(pagetable, va0);
+ if(pa0 == NULL)
+ return -1;
+ n = PGSIZE - (srcva - va0);
+ 802014c6: 6985 lui s3,0x1
+ 802014c8: a02d j 802014f2 <copyinstr+0x4e>
+ n = max;
+
+ char *p = (char *) (pa0 + (srcva - va0));
+ while(n > 0){
+ if(*p == '\0'){
+ *dst = '\0';
+ 802014ca: 00078023 sb zero,0(a5)
+ 802014ce: 4785 li a5,1
+ dst++;
+ }
+
+ srcva = va0 + PGSIZE;
+ }
+ if(got_null){
+ 802014d0: 37fd addiw a5,a5,-1
+ 802014d2: 0007851b sext.w a0,a5
+ return 0;
+ } else {
+ return -1;
+ }
+}
+ 802014d6: 60a6 ld ra,72(sp)
+ 802014d8: 6406 ld s0,64(sp)
+ 802014da: 74e2 ld s1,56(sp)
+ 802014dc: 7942 ld s2,48(sp)
+ 802014de: 79a2 ld s3,40(sp)
+ 802014e0: 7a02 ld s4,32(sp)
+ 802014e2: 6ae2 ld s5,24(sp)
+ 802014e4: 6b42 ld s6,16(sp)
+ 802014e6: 6ba2 ld s7,8(sp)
+ 802014e8: 6161 addi sp,sp,80
+ 802014ea: 8082 ret
+ srcva = va0 + PGSIZE;
+ 802014ec: 01390bb3 add s7,s2,s3
+ while(got_null == 0 && max > 0){
+ 802014f0: c8a9 beqz s1,80201542 <copyinstr+0x9e>
+ va0 = PGROUNDDOWN(srcva);
+ 802014f2: 015bf933 and s2,s7,s5
+ pa0 = walkaddr(pagetable, va0);
+ 802014f6: 85ca mv a1,s2
+ 802014f8: 8552 mv a0,s4
+ 802014fa: fffff097 auipc ra,0xfffff
+ 802014fe: 6b4080e7 jalr 1716(ra) # 80200bae <walkaddr>
+ if(pa0 == NULL)
+ 80201502: c131 beqz a0,80201546 <copyinstr+0xa2>
+ n = PGSIZE - (srcva - va0);
+ 80201504: 417906b3 sub a3,s2,s7
+ 80201508: 96ce add a3,a3,s3
+ 8020150a: 00d4f363 bgeu s1,a3,80201510 <copyinstr+0x6c>
+ 8020150e: 86a6 mv a3,s1
+ char *p = (char *) (pa0 + (srcva - va0));
+ 80201510: 955e add a0,a0,s7
+ 80201512: 41250533 sub a0,a0,s2
+ while(n > 0){
+ 80201516: daf9 beqz a3,802014ec <copyinstr+0x48>
+ 80201518: 87da mv a5,s6
+ if(*p == '\0'){
+ 8020151a: 41650633 sub a2,a0,s6
+ 8020151e: fff48593 addi a1,s1,-1
+ 80201522: 95da add a1,a1,s6
+ while(n > 0){
+ 80201524: 96da add a3,a3,s6
+ if(*p == '\0'){
+ 80201526: 00f60733 add a4,a2,a5
+ 8020152a: 00074703 lbu a4,0(a4) # fffffffffffff000 <ebss_clear+0xffffffff7fdd9000>
+ 8020152e: df51 beqz a4,802014ca <copyinstr+0x26>
+ *dst = *p;
+ 80201530: 00e78023 sb a4,0(a5)
+ --max;
+ 80201534: 40f584b3 sub s1,a1,a5
+ dst++;
+ 80201538: 0785 addi a5,a5,1
+ while(n > 0){
+ 8020153a: fed796e3 bne a5,a3,80201526 <copyinstr+0x82>
+ dst++;
+ 8020153e: 8b3e mv s6,a5
+ 80201540: b775 j 802014ec <copyinstr+0x48>
+ 80201542: 4781 li a5,0
+ 80201544: b771 j 802014d0 <copyinstr+0x2c>
+ return -1;
+ 80201546: 557d li a0,-1
+ 80201548: b779 j 802014d6 <copyinstr+0x32>
+ int got_null = 0;
+ 8020154a: 4781 li a5,0
+ if(got_null){
+ 8020154c: 37fd addiw a5,a5,-1
+ 8020154e: 0007851b sext.w a0,a5
+}
+ 80201552: 8082 ret
+
+0000000080201554 <copyinstr2>:
+
+int
+copyinstr2(char *dst, uint64 srcva, uint64 max)
+{
+ 80201554: 7179 addi sp,sp,-48
+ 80201556: f406 sd ra,40(sp)
+ 80201558: f022 sd s0,32(sp)
+ 8020155a: ec26 sd s1,24(sp)
+ 8020155c: e84a sd s2,16(sp)
+ 8020155e: e44e sd s3,8(sp)
+ 80201560: 1800 addi s0,sp,48
+ 80201562: 89aa mv s3,a0
+ 80201564: 84ae mv s1,a1
+ 80201566: 8932 mv s2,a2
+ int got_null = 0;
+ uint64 sz = myproc()->sz;
+ 80201568: 00000097 auipc ra,0x0
+ 8020156c: 4d4080e7 jalr 1236(ra) # 80201a3c <myproc>
+ 80201570: 6534 ld a3,72(a0)
+ while(srcva < sz && max > 0){
+ 80201572: 04d4f363 bgeu s1,a3,802015b8 <copyinstr2+0x64>
+ 80201576: 04090363 beqz s2,802015bc <copyinstr2+0x68>
+ 8020157a: 01298633 add a2,s3,s2
+ 8020157e: 8e85 sub a3,a3,s1
+ 80201580: 96ce add a3,a3,s3
+ 80201582: 87ce mv a5,s3
+ char *p = (char *)srcva;
+ if(*p == '\0'){
+ 80201584: 413485b3 sub a1,s1,s3
+ 80201588: 00b78733 add a4,a5,a1
+ 8020158c: 00074703 lbu a4,0(a4)
+ 80201590: cb11 beqz a4,802015a4 <copyinstr2+0x50>
+ *dst = '\0';
+ got_null = 1;
+ break;
+ } else {
+ *dst = *p;
+ 80201592: 00e78023 sb a4,0(a5)
+ }
+ --max;
+ srcva++;
+ dst++;
+ 80201596: 0785 addi a5,a5,1
+ while(srcva < sz && max > 0){
+ 80201598: 02d78463 beq a5,a3,802015c0 <copyinstr2+0x6c>
+ 8020159c: fec796e3 bne a5,a2,80201588 <copyinstr2+0x34>
+ }
+ if(got_null){
+ return 0;
+ } else {
+ return -1;
+ 802015a0: 557d li a0,-1
+ 802015a2: a021 j 802015aa <copyinstr2+0x56>
+ *dst = '\0';
+ 802015a4: 00078023 sb zero,0(a5)
+ return 0;
+ 802015a8: 4501 li a0,0
+ }
+}
+ 802015aa: 70a2 ld ra,40(sp)
+ 802015ac: 7402 ld s0,32(sp)
+ 802015ae: 64e2 ld s1,24(sp)
+ 802015b0: 6942 ld s2,16(sp)
+ 802015b2: 69a2 ld s3,8(sp)
+ 802015b4: 6145 addi sp,sp,48
+ 802015b6: 8082 ret
+ return -1;
+ 802015b8: 557d li a0,-1
+ 802015ba: bfc5 j 802015aa <copyinstr2+0x56>
+ 802015bc: 557d li a0,-1
+ 802015be: b7f5 j 802015aa <copyinstr2+0x56>
+ 802015c0: 557d li a0,-1
+ 802015c2: b7e5 j 802015aa <copyinstr2+0x56>
+
+00000000802015c4 <kfreewalk>:
+}
+
+// only free page table, not physical pages
+void
+kfreewalk(pagetable_t kpt)
+{
+ 802015c4: 7179 addi sp,sp,-48
+ 802015c6: f406 sd ra,40(sp)
+ 802015c8: f022 sd s0,32(sp)
+ 802015ca: ec26 sd s1,24(sp)
+ 802015cc: e84a sd s2,16(sp)
+ 802015ce: e44e sd s3,8(sp)
+ 802015d0: e052 sd s4,0(sp)
+ 802015d2: 1800 addi s0,sp,48
+ 802015d4: 8a2a mv s4,a0
+ for (int i = 0; i < 512; i++) {
+ 802015d6: 84aa mv s1,a0
+ 802015d8: 6905 lui s2,0x1
+ 802015da: 992a add s2,s2,a0
+ pte_t pte = kpt[i];
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ 802015dc: 4985 li s3,1
+ 802015de: a829 j 802015f8 <kfreewalk+0x34>
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ 802015e0: 83a9 srli a5,a5,0xa
+ 802015e2: 00c79513 slli a0,a5,0xc
+ 802015e6: 00000097 auipc ra,0x0
+ 802015ea: fde080e7 jalr -34(ra) # 802015c4 <kfreewalk>
+ kpt[i] = 0;
+ 802015ee: 0004b023 sd zero,0(s1)
+ for (int i = 0; i < 512; i++) {
+ 802015f2: 04a1 addi s1,s1,8
+ 802015f4: 01248963 beq s1,s2,80201606 <kfreewalk+0x42>
+ pte_t pte = kpt[i];
+ 802015f8: 609c ld a5,0(s1)
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ 802015fa: 00f7f713 andi a4,a5,15
+ 802015fe: ff3701e3 beq a4,s3,802015e0 <kfreewalk+0x1c>
+ } else if (pte & PTE_V) {
+ 80201602: 8b85 andi a5,a5,1
+ 80201604: d7fd beqz a5,802015f2 <kfreewalk+0x2e>
+ break;
+ }
+ }
+ kfree((void *) kpt);
+ 80201606: 8552 mv a0,s4
+ 80201608: fffff097 auipc ra,0xfffff
+ 8020160c: e38080e7 jalr -456(ra) # 80200440 <kfree>
+}
+ 80201610: 70a2 ld ra,40(sp)
+ 80201612: 7402 ld s0,32(sp)
+ 80201614: 64e2 ld s1,24(sp)
+ 80201616: 6942 ld s2,16(sp)
+ 80201618: 69a2 ld s3,8(sp)
+ 8020161a: 6a02 ld s4,0(sp)
+ 8020161c: 6145 addi sp,sp,48
+ 8020161e: 8082 ret
+
+0000000080201620 <kvmfreeusr>:
+
+void
+kvmfreeusr(pagetable_t kpt)
+{
+ 80201620: 1101 addi sp,sp,-32
+ 80201622: ec06 sd ra,24(sp)
+ 80201624: e822 sd s0,16(sp)
+ 80201626: e426 sd s1,8(sp)
+ 80201628: 1000 addi s0,sp,32
+ 8020162a: 84aa mv s1,a0
+ pte_t pte;
+ for (int i = 0; i < PX(2, MAXUVA); i++) {
+ pte = kpt[i];
+ 8020162c: 6108 ld a0,0(a0)
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ 8020162e: 00f57713 andi a4,a0,15
+ 80201632: 4785 li a5,1
+ 80201634: 00f70d63 beq a4,a5,8020164e <kvmfreeusr+0x2e>
+ pte = kpt[i];
+ 80201638: 6488 ld a0,8(s1)
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ 8020163a: 00f57713 andi a4,a0,15
+ 8020163e: 4785 li a5,1
+ 80201640: 02f70063 beq a4,a5,80201660 <kvmfreeusr+0x40>
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ kpt[i] = 0;
+ }
+ }
+}
+ 80201644: 60e2 ld ra,24(sp)
+ 80201646: 6442 ld s0,16(sp)
+ 80201648: 64a2 ld s1,8(sp)
+ 8020164a: 6105 addi sp,sp,32
+ 8020164c: 8082 ret
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ 8020164e: 8129 srli a0,a0,0xa
+ 80201650: 0532 slli a0,a0,0xc
+ 80201652: 00000097 auipc ra,0x0
+ 80201656: f72080e7 jalr -142(ra) # 802015c4 <kfreewalk>
+ kpt[i] = 0;
+ 8020165a: 0004b023 sd zero,0(s1)
+ 8020165e: bfe9 j 80201638 <kvmfreeusr+0x18>
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ 80201660: 8129 srli a0,a0,0xa
+ 80201662: 0532 slli a0,a0,0xc
+ 80201664: 00000097 auipc ra,0x0
+ 80201668: f60080e7 jalr -160(ra) # 802015c4 <kfreewalk>
+ kpt[i] = 0;
+ 8020166c: 0004b423 sd zero,8(s1)
+}
+ 80201670: bfd1 j 80201644 <kvmfreeusr+0x24>
+
+0000000080201672 <kvmfree>:
+
+void
+kvmfree(pagetable_t kpt, int stack_free)
+{
+ 80201672: 1101 addi sp,sp,-32
+ 80201674: ec06 sd ra,24(sp)
+ 80201676: e822 sd s0,16(sp)
+ 80201678: e426 sd s1,8(sp)
+ 8020167a: 1000 addi s0,sp,32
+ 8020167c: 84aa mv s1,a0
+ if (stack_free) {
+ 8020167e: e185 bnez a1,8020169e <kvmfree+0x2c>
+ pte_t pte = kpt[PX(2, VKSTACK)];
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ }
+ }
+ kvmfreeusr(kpt);
+ 80201680: 8526 mv a0,s1
+ 80201682: 00000097 auipc ra,0x0
+ 80201686: f9e080e7 jalr -98(ra) # 80201620 <kvmfreeusr>
+ kfree(kpt);
+ 8020168a: 8526 mv a0,s1
+ 8020168c: fffff097 auipc ra,0xfffff
+ 80201690: db4080e7 jalr -588(ra) # 80200440 <kfree>
+}
+ 80201694: 60e2 ld ra,24(sp)
+ 80201696: 6442 ld s0,16(sp)
+ 80201698: 64a2 ld s1,8(sp)
+ 8020169a: 6105 addi sp,sp,32
+ 8020169c: 8082 ret
+ vmunmap(kpt, VKSTACK, 1, 1);
+ 8020169e: 4685 li a3,1
+ 802016a0: 4605 li a2,1
+ 802016a2: 0fb00593 li a1,251
+ 802016a6: 05fa slli a1,a1,0x1e
+ 802016a8: fffff097 auipc ra,0xfffff
+ 802016ac: 77a080e7 jalr 1914(ra) # 80200e22 <vmunmap>
+ pte_t pte = kpt[PX(2, VKSTACK)];
+ 802016b0: 7d84b503 ld a0,2008(s1)
+ if ((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0) {
+ 802016b4: 00f57713 andi a4,a0,15
+ 802016b8: 4785 li a5,1
+ 802016ba: fcf713e3 bne a4,a5,80201680 <kvmfree+0xe>
+ kfreewalk((pagetable_t) PTE2PA(pte));
+ 802016be: 8129 srli a0,a0,0xa
+ 802016c0: 0532 slli a0,a0,0xc
+ 802016c2: 00000097 auipc ra,0x0
+ 802016c6: f02080e7 jalr -254(ra) # 802015c4 <kfreewalk>
+ 802016ca: bf5d j 80201680 <kvmfree+0xe>
+
+00000000802016cc <proc_kpagetable>:
+{
+ 802016cc: 1101 addi sp,sp,-32
+ 802016ce: ec06 sd ra,24(sp)
+ 802016d0: e822 sd s0,16(sp)
+ 802016d2: e426 sd s1,8(sp)
+ 802016d4: 1000 addi s0,sp,32
+ pagetable_t kpt = (pagetable_t) kalloc();
+ 802016d6: fffff097 auipc ra,0xfffff
+ 802016da: e84080e7 jalr -380(ra) # 8020055a <kalloc>
+ 802016de: 84aa mv s1,a0
+ if (kpt == NULL)
+ 802016e0: c91d beqz a0,80201716 <proc_kpagetable+0x4a>
+ memmove(kpt, kernel_pagetable, PGSIZE);
+ 802016e2: 6605 lui a2,0x1
+ 802016e4: 00013597 auipc a1,0x13
+ 802016e8: 9745b583 ld a1,-1676(a1) # 80214058 <kernel_pagetable>
+ 802016ec: fffff097 auipc ra,0xfffff
+ 802016f0: 0d2080e7 jalr 210(ra) # 802007be <memmove>
+ char *pstack = kalloc();
+ 802016f4: fffff097 auipc ra,0xfffff
+ 802016f8: e66080e7 jalr -410(ra) # 8020055a <kalloc>
+ 802016fc: 86aa mv a3,a0
+ if(pstack == NULL)
+ 802016fe: c115 beqz a0,80201722 <proc_kpagetable+0x56>
+ if (mappages(kpt, VKSTACK, PGSIZE, (uint64)pstack, PTE_R | PTE_W) != 0)
+ 80201700: 4719 li a4,6
+ 80201702: 6605 lui a2,0x1
+ 80201704: 0fb00593 li a1,251
+ 80201708: 05fa slli a1,a1,0x1e
+ 8020170a: 8526 mv a0,s1
+ 8020170c: fffff097 auipc ra,0xfffff
+ 80201710: 55c080e7 jalr 1372(ra) # 80200c68 <mappages>
+ 80201714: e519 bnez a0,80201722 <proc_kpagetable+0x56>
+}
+ 80201716: 8526 mv a0,s1
+ 80201718: 60e2 ld ra,24(sp)
+ 8020171a: 6442 ld s0,16(sp)
+ 8020171c: 64a2 ld s1,8(sp)
+ 8020171e: 6105 addi sp,sp,32
+ 80201720: 8082 ret
+ kvmfree(kpt, 1);
+ 80201722: 4585 li a1,1
+ 80201724: 8526 mv a0,s1
+ 80201726: 00000097 auipc ra,0x0
+ 8020172a: f4c080e7 jalr -180(ra) # 80201672 <kvmfree>
+ return NULL;
+ 8020172e: 4481 li s1,0
+ 80201730: b7dd j 80201716 <proc_kpagetable+0x4a>
+
+0000000080201732 <vmprint>:
+
+void vmprint(pagetable_t pagetable)
+{
+ 80201732: 7119 addi sp,sp,-128
+ 80201734: fc86 sd ra,120(sp)
+ 80201736: f8a2 sd s0,112(sp)
+ 80201738: f4a6 sd s1,104(sp)
+ 8020173a: f0ca sd s2,96(sp)
+ 8020173c: ecce sd s3,88(sp)
+ 8020173e: e8d2 sd s4,80(sp)
+ 80201740: e4d6 sd s5,72(sp)
+ 80201742: e0da sd s6,64(sp)
+ 80201744: fc5e sd s7,56(sp)
+ 80201746: f862 sd s8,48(sp)
+ 80201748: f466 sd s9,40(sp)
+ 8020174a: f06a sd s10,32(sp)
+ 8020174c: ec6e sd s11,24(sp)
+ 8020174e: 0100 addi s0,sp,128
+ 80201750: 8baa mv s7,a0
+ 80201752: f8a43423 sd a0,-120(s0)
+ const int capacity = 512;
+ printf("page table %p\n", pagetable);
+ 80201756: 85aa mv a1,a0
+ 80201758: 00008517 auipc a0,0x8
+ 8020175c: da850513 addi a0,a0,-600 # 80209500 <digits+0x180>
+ 80201760: fffff097 auipc ra,0xfffff
+ 80201764: a2e080e7 jalr -1490(ra) # 8020018e <printf>
+ for (pte_t *pte = (pte_t *) pagetable; pte < pagetable + capacity; pte++) {
+ 80201768: 6d85 lui s11,0x1
+ 8020176a: 9dde add s11,s11,s7
+ 8020176c: 6c85 lui s9,0x1
+
+ for (pte_t *pte2 = (pte_t *) pt2; pte2 < pt2 + capacity; pte2++) {
+ if (*pte2 & PTE_V)
+ {
+ pagetable_t pt3 = (pagetable_t) PTE2PA(*pte2);
+ printf(".. ..%d: pte %p pa %p\n", pte2 - pt2, *pte2, pt3);
+ 8020176e: 00008d17 auipc s10,0x8
+ 80201772: dbad0d13 addi s10,s10,-582 # 80209528 <digits+0x1a8>
+
+ for (pte_t *pte3 = (pte_t *) pt3; pte3 < pt3 + capacity; pte3++)
+ if (*pte3 & PTE_V)
+ printf(".. .. ..%d: pte %p pa %p\n", pte3 - pt3, *pte3, PTE2PA(*pte3));
+ 80201776: 00008a17 auipc s4,0x8
+ 8020177a: dcaa0a13 addi s4,s4,-566 # 80209540 <digits+0x1c0>
+ 8020177e: a885 j 802017ee <vmprint+0xbc>
+ for (pte_t *pte3 = (pte_t *) pt3; pte3 < pt3 + capacity; pte3++)
+ 80201780: 04a1 addi s1,s1,8
+ 80201782: 197d addi s2,s2,-1 # fff <_entry-0x801ff001>
+ 80201784: 02090263 beqz s2,802017a8 <vmprint+0x76>
+ if (*pte3 & PTE_V)
+ 80201788: 6090 ld a2,0(s1)
+ 8020178a: 00167793 andi a5,a2,1
+ 8020178e: dbed beqz a5,80201780 <vmprint+0x4e>
+ printf(".. .. ..%d: pte %p pa %p\n", pte3 - pt3, *pte3, PTE2PA(*pte3));
+ 80201790: 00a65693 srli a3,a2,0xa
+ 80201794: 413485b3 sub a1,s1,s3
+ 80201798: 06b2 slli a3,a3,0xc
+ 8020179a: 858d srai a1,a1,0x3
+ 8020179c: 8552 mv a0,s4
+ 8020179e: fffff097 auipc ra,0xfffff
+ 802017a2: 9f0080e7 jalr -1552(ra) # 8020018e <printf>
+ 802017a6: bfe9 j 80201780 <vmprint+0x4e>
+ for (pte_t *pte2 = (pte_t *) pt2; pte2 < pt2 + capacity; pte2++) {
+ 802017a8: 0aa1 addi s5,s5,8 # fffffffffffff008 <ebss_clear+0xffffffff7fdd9008>
+ 802017aa: 1b7d addi s6,s6,-1 # fff <_entry-0x801ff001>
+ 802017ac: 020b0e63 beqz s6,802017e8 <vmprint+0xb6>
+ if (*pte2 & PTE_V)
+ 802017b0: 000ab603 ld a2,0(s5)
+ 802017b4: 00167793 andi a5,a2,1
+ 802017b8: dbe5 beqz a5,802017a8 <vmprint+0x76>
+ pagetable_t pt3 = (pagetable_t) PTE2PA(*pte2);
+ 802017ba: 00a65993 srli s3,a2,0xa
+ 802017be: 09b2 slli s3,s3,0xc
+ printf(".. ..%d: pte %p pa %p\n", pte2 - pt2, *pte2, pt3);
+ 802017c0: 418a85b3 sub a1,s5,s8
+ 802017c4: 86ce mv a3,s3
+ 802017c6: 858d srai a1,a1,0x3
+ 802017c8: 856a mv a0,s10
+ 802017ca: fffff097 auipc ra,0xfffff
+ 802017ce: 9c4080e7 jalr -1596(ra) # 8020018e <printf>
+ for (pte_t *pte3 = (pte_t *) pt3; pte3 < pt3 + capacity; pte3++)
+ 802017d2: 00898713 addi a4,s3,8 # 1008 <_entry-0x801feff8>
+ 802017d6: 019987b3 add a5,s3,s9
+ 802017da: 20000913 li s2,512
+ 802017de: 00e7f363 bgeu a5,a4,802017e4 <vmprint+0xb2>
+ 802017e2: 4905 li s2,1
+ 802017e4: 84ce mv s1,s3
+ 802017e6: b74d j 80201788 <vmprint+0x56>
+ for (pte_t *pte = (pte_t *) pagetable; pte < pagetable + capacity; pte++) {
+ 802017e8: 0ba1 addi s7,s7,8 # fffffffffffff008 <ebss_clear+0xffffffff7fdd9008>
+ 802017ea: 05bb8463 beq s7,s11,80201832 <vmprint+0x100>
+ if (*pte & PTE_V)
+ 802017ee: 000bb603 ld a2,0(s7)
+ 802017f2: 00167793 andi a5,a2,1
+ 802017f6: dbed beqz a5,802017e8 <vmprint+0xb6>
+ pagetable_t pt2 = (pagetable_t) PTE2PA(*pte);
+ 802017f8: 00a65c13 srli s8,a2,0xa
+ 802017fc: 0c32 slli s8,s8,0xc
+ printf("..%d: pte %p pa %p\n", pte - pagetable, *pte, pt2);
+ 802017fe: f8843783 ld a5,-120(s0)
+ 80201802: 40fb87b3 sub a5,s7,a5
+ 80201806: 86e2 mv a3,s8
+ 80201808: 4037d593 srai a1,a5,0x3
+ 8020180c: 00008517 auipc a0,0x8
+ 80201810: d0450513 addi a0,a0,-764 # 80209510 <digits+0x190>
+ 80201814: fffff097 auipc ra,0xfffff
+ 80201818: 97a080e7 jalr -1670(ra) # 8020018e <printf>
+ for (pte_t *pte2 = (pte_t *) pt2; pte2 < pt2 + capacity; pte2++) {
+ 8020181c: 019c0733 add a4,s8,s9
+ 80201820: 008c0793 addi a5,s8,8 # 1008 <_entry-0x801feff8>
+ 80201824: 20000b13 li s6,512
+ 80201828: 00f77363 bgeu a4,a5,8020182e <vmprint+0xfc>
+ 8020182c: 4b05 li s6,1
+ 8020182e: 8ae2 mv s5,s8
+ 80201830: b741 j 802017b0 <vmprint+0x7e>
+ }
+ }
+ }
+ }
+ return;
+ 80201832: 70e6 ld ra,120(sp)
+ 80201834: 7446 ld s0,112(sp)
+ 80201836: 74a6 ld s1,104(sp)
+ 80201838: 7906 ld s2,96(sp)
+ 8020183a: 69e6 ld s3,88(sp)
+ 8020183c: 6a46 ld s4,80(sp)
+ 8020183e: 6aa6 ld s5,72(sp)
+ 80201840: 6b06 ld s6,64(sp)
+ 80201842: 7be2 ld s7,56(sp)
+ 80201844: 7c42 ld s8,48(sp)
+ 80201846: 7ca2 ld s9,40(sp)
+ 80201848: 7d02 ld s10,32(sp)
+ 8020184a: 6de2 ld s11,24(sp)
+ 8020184c: 6109 addi sp,sp,128
+ 8020184e: 8082 ret
+
+0000000080201850 <wakeup1>:
+
+// Wake up p if it is sleeping in wait(); used by exit().
+// Caller must hold p->lock.
+static void
+wakeup1(struct proc *p)
+{
+ 80201850: 1101 addi sp,sp,-32
+ 80201852: ec06 sd ra,24(sp)
+ 80201854: e822 sd s0,16(sp)
+ 80201856: e426 sd s1,8(sp)
+ 80201858: 1000 addi s0,sp,32
+ 8020185a: 84aa mv s1,a0
+ if(!holding(&p->lock))
+ 8020185c: fffff097 auipc ra,0xfffff
+ 80201860: e3c080e7 jalr -452(ra) # 80200698 <holding>
+ 80201864: c909 beqz a0,80201876 <wakeup1+0x26>
+ panic("wakeup1");
+ if(p->chan == p && p->state == SLEEPING) {
+ 80201866: 749c ld a5,40(s1)
+ 80201868: 00978f63 beq a5,s1,80201886 <wakeup1+0x36>
+ p->state = RUNNABLE;
+ }
+}
+ 8020186c: 60e2 ld ra,24(sp)
+ 8020186e: 6442 ld s0,16(sp)
+ 80201870: 64a2 ld s1,8(sp)
+ 80201872: 6105 addi sp,sp,32
+ 80201874: 8082 ret
+ panic("wakeup1");
+ 80201876: 00008517 auipc a0,0x8
+ 8020187a: cea50513 addi a0,a0,-790 # 80209560 <digits+0x1e0>
+ 8020187e: fffff097 auipc ra,0xfffff
+ 80201882: 8c6080e7 jalr -1850(ra) # 80200144 <panic>
+ if(p->chan == p && p->state == SLEEPING) {
+ 80201886: 4c98 lw a4,24(s1)
+ 80201888: 4785 li a5,1
+ 8020188a: fef711e3 bne a4,a5,8020186c <wakeup1+0x1c>
+ p->state = RUNNABLE;
+ 8020188e: 4789 li a5,2
+ 80201890: cc9c sw a5,24(s1)
+}
+ 80201892: bfe9 j 8020186c <wakeup1+0x1c>
+
+0000000080201894 <reg_info>:
+void reg_info(void) {
+ 80201894: 1141 addi sp,sp,-16
+ 80201896: e406 sd ra,8(sp)
+ 80201898: e022 sd s0,0(sp)
+ 8020189a: 0800 addi s0,sp,16
+ printf("register info: {\n");
+ 8020189c: 00008517 auipc a0,0x8
+ 802018a0: ccc50513 addi a0,a0,-820 # 80209568 <digits+0x1e8>
+ 802018a4: fffff097 auipc ra,0xfffff
+ 802018a8: 8ea080e7 jalr -1814(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 802018ac: 100025f3 csrr a1,sstatus
+ printf("sstatus: %p\n", r_sstatus());
+ 802018b0: 00008517 auipc a0,0x8
+ 802018b4: cd050513 addi a0,a0,-816 # 80209580 <digits+0x200>
+ 802018b8: fffff097 auipc ra,0xfffff
+ 802018bc: 8d6080e7 jalr -1834(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sip" : "=r" (x) );
+ 802018c0: 144025f3 csrr a1,sip
+ printf("sip: %p\n", r_sip());
+ 802018c4: 00008517 auipc a0,0x8
+ 802018c8: ccc50513 addi a0,a0,-820 # 80209590 <digits+0x210>
+ 802018cc: fffff097 auipc ra,0xfffff
+ 802018d0: 8c2080e7 jalr -1854(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sie" : "=r" (x) );
+ 802018d4: 104025f3 csrr a1,sie
+ printf("sie: %p\n", r_sie());
+ 802018d8: 00008517 auipc a0,0x8
+ 802018dc: cc850513 addi a0,a0,-824 # 802095a0 <digits+0x220>
+ 802018e0: fffff097 auipc ra,0xfffff
+ 802018e4: 8ae080e7 jalr -1874(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sepc" : "=r" (x) );
+ 802018e8: 141025f3 csrr a1,sepc
+ printf("sepc: %p\n", r_sepc());
+ 802018ec: 00008517 auipc a0,0x8
+ 802018f0: cc450513 addi a0,a0,-828 # 802095b0 <digits+0x230>
+ 802018f4: fffff097 auipc ra,0xfffff
+ 802018f8: 89a080e7 jalr -1894(ra) # 8020018e <printf>
+ asm volatile("csrr %0, stvec" : "=r" (x) );
+ 802018fc: 105025f3 csrr a1,stvec
+ printf("stvec: %p\n", r_stvec());
+ 80201900: 00008517 auipc a0,0x8
+ 80201904: cc050513 addi a0,a0,-832 # 802095c0 <digits+0x240>
+ 80201908: fffff097 auipc ra,0xfffff
+ 8020190c: 886080e7 jalr -1914(ra) # 8020018e <printf>
+ asm volatile("csrr %0, satp" : "=r" (x) );
+ 80201910: 180025f3 csrr a1,satp
+ printf("satp: %p\n", r_satp());
+ 80201914: 00008517 auipc a0,0x8
+ 80201918: cbc50513 addi a0,a0,-836 # 802095d0 <digits+0x250>
+ 8020191c: fffff097 auipc ra,0xfffff
+ 80201920: 872080e7 jalr -1934(ra) # 8020018e <printf>
+ asm volatile("csrr %0, scause" : "=r" (x) );
+ 80201924: 142025f3 csrr a1,scause
+ printf("scause: %p\n", r_scause());
+ 80201928: 00008517 auipc a0,0x8
+ 8020192c: cb850513 addi a0,a0,-840 # 802095e0 <digits+0x260>
+ 80201930: fffff097 auipc ra,0xfffff
+ 80201934: 85e080e7 jalr -1954(ra) # 8020018e <printf>
+ asm volatile("csrr %0, stval" : "=r" (x) );
+ 80201938: 143025f3 csrr a1,stval
+ printf("stval: %p\n", r_stval());
+ 8020193c: 00008517 auipc a0,0x8
+ 80201940: cb450513 addi a0,a0,-844 # 802095f0 <digits+0x270>
+ 80201944: fffff097 auipc ra,0xfffff
+ 80201948: 84a080e7 jalr -1974(ra) # 8020018e <printf>
+ asm volatile("mv %0, sp" : "=r" (x) );
+ 8020194c: 858a mv a1,sp
+ printf("sp: %p\n", r_sp());
+ 8020194e: 00008517 auipc a0,0x8
+ 80201952: cb250513 addi a0,a0,-846 # 80209600 <digits+0x280>
+ 80201956: fffff097 auipc ra,0xfffff
+ 8020195a: 838080e7 jalr -1992(ra) # 8020018e <printf>
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 8020195e: 8592 mv a1,tp
+ printf("tp: %p\n", r_tp());
+ 80201960: 00008517 auipc a0,0x8
+ 80201964: ca850513 addi a0,a0,-856 # 80209608 <digits+0x288>
+ 80201968: fffff097 auipc ra,0xfffff
+ 8020196c: 826080e7 jalr -2010(ra) # 8020018e <printf>
+ asm volatile("mv %0, ra" : "=r" (x) );
+ 80201970: 8586 mv a1,ra
+ printf("ra: %p\n", r_ra());
+ 80201972: 00008517 auipc a0,0x8
+ 80201976: c9e50513 addi a0,a0,-866 # 80209610 <digits+0x290>
+ 8020197a: fffff097 auipc ra,0xfffff
+ 8020197e: 814080e7 jalr -2028(ra) # 8020018e <printf>
+ printf("}\n");
+ 80201982: 00008517 auipc a0,0x8
+ 80201986: c9650513 addi a0,a0,-874 # 80209618 <digits+0x298>
+ 8020198a: fffff097 auipc ra,0xfffff
+ 8020198e: 804080e7 jalr -2044(ra) # 8020018e <printf>
+}
+ 80201992: 60a2 ld ra,8(sp)
+ 80201994: 6402 ld s0,0(sp)
+ 80201996: 0141 addi sp,sp,16
+ 80201998: 8082 ret
+
+000000008020199a <procinit>:
+{
+ 8020199a: 7179 addi sp,sp,-48
+ 8020199c: f406 sd ra,40(sp)
+ 8020199e: f022 sd s0,32(sp)
+ 802019a0: ec26 sd s1,24(sp)
+ 802019a2: e84a sd s2,16(sp)
+ 802019a4: e44e sd s3,8(sp)
+ 802019a6: 1800 addi s0,sp,48
+ initlock(&pid_lock, "nextpid");
+ 802019a8: 00008597 auipc a1,0x8
+ 802019ac: c7858593 addi a1,a1,-904 # 80209620 <digits+0x2a0>
+ 802019b0: 00012517 auipc a0,0x12
+ 802019b4: 6b050513 addi a0,a0,1712 # 80214060 <pid_lock>
+ 802019b8: fffff097 auipc ra,0xfffff
+ 802019bc: cca080e7 jalr -822(ra) # 80200682 <initlock>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802019c0: 00012497 auipc s1,0x12
+ 802019c4: 7c048493 addi s1,s1,1984 # 80214180 <proc>
+ initlock(&p->lock, "proc");
+ 802019c8: 00008997 auipc s3,0x8
+ 802019cc: c6098993 addi s3,s3,-928 # 80209628 <digits+0x2a8>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802019d0: 00017917 auipc s2,0x17
+ 802019d4: 12090913 addi s2,s2,288 # 80218af0 <bcache>
+ initlock(&p->lock, "proc");
+ 802019d8: 85ce mv a1,s3
+ 802019da: 8526 mv a0,s1
+ 802019dc: fffff097 auipc ra,0xfffff
+ 802019e0: ca6080e7 jalr -858(ra) # 80200682 <initlock>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802019e4: 17848493 addi s1,s1,376
+ 802019e8: ff2498e3 bne s1,s2,802019d8 <procinit+0x3e>
+ memset(cpus, 0, sizeof(cpus));
+ 802019ec: 10000613 li a2,256
+ 802019f0: 4581 li a1,0
+ 802019f2: 00012517 auipc a0,0x12
+ 802019f6: 68650513 addi a0,a0,1670 # 80214078 <cpus>
+ 802019fa: fffff097 auipc ra,0xfffff
+ 802019fe: d68080e7 jalr -664(ra) # 80200762 <memset>
+}
+ 80201a02: 70a2 ld ra,40(sp)
+ 80201a04: 7402 ld s0,32(sp)
+ 80201a06: 64e2 ld s1,24(sp)
+ 80201a08: 6942 ld s2,16(sp)
+ 80201a0a: 69a2 ld s3,8(sp)
+ 80201a0c: 6145 addi sp,sp,48
+ 80201a0e: 8082 ret
+
+0000000080201a10 <cpuid>:
+{
+ 80201a10: 1141 addi sp,sp,-16
+ 80201a12: e422 sd s0,8(sp)
+ 80201a14: 0800 addi s0,sp,16
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 80201a16: 8512 mv a0,tp
+}
+ 80201a18: 2501 sext.w a0,a0
+ 80201a1a: 6422 ld s0,8(sp)
+ 80201a1c: 0141 addi sp,sp,16
+ 80201a1e: 8082 ret
+
+0000000080201a20 <mycpu>:
+mycpu(void) {
+ 80201a20: 1141 addi sp,sp,-16
+ 80201a22: e422 sd s0,8(sp)
+ 80201a24: 0800 addi s0,sp,16
+ 80201a26: 8792 mv a5,tp
+ struct cpu *c = &cpus[id];
+ 80201a28: 2781 sext.w a5,a5
+ 80201a2a: 079e slli a5,a5,0x7
+}
+ 80201a2c: 00012517 auipc a0,0x12
+ 80201a30: 64c50513 addi a0,a0,1612 # 80214078 <cpus>
+ 80201a34: 953e add a0,a0,a5
+ 80201a36: 6422 ld s0,8(sp)
+ 80201a38: 0141 addi sp,sp,16
+ 80201a3a: 8082 ret
+
+0000000080201a3c <myproc>:
+myproc(void) {
+ 80201a3c: 1101 addi sp,sp,-32
+ 80201a3e: ec06 sd ra,24(sp)
+ 80201a40: e822 sd s0,16(sp)
+ 80201a42: e426 sd s1,8(sp)
+ 80201a44: 1000 addi s0,sp,32
+ push_off();
+ 80201a46: fffff097 auipc ra,0xfffff
+ 80201a4a: b90080e7 jalr -1136(ra) # 802005d6 <push_off>
+ 80201a4e: 8792 mv a5,tp
+ struct proc *p = c->proc;
+ 80201a50: 2781 sext.w a5,a5
+ 80201a52: 079e slli a5,a5,0x7
+ 80201a54: 00012717 auipc a4,0x12
+ 80201a58: 60c70713 addi a4,a4,1548 # 80214060 <pid_lock>
+ 80201a5c: 97ba add a5,a5,a4
+ 80201a5e: 6f84 ld s1,24(a5)
+ pop_off();
+ 80201a60: fffff097 auipc ra,0xfffff
+ 80201a64: bc2080e7 jalr -1086(ra) # 80200622 <pop_off>
+}
+ 80201a68: 8526 mv a0,s1
+ 80201a6a: 60e2 ld ra,24(sp)
+ 80201a6c: 6442 ld s0,16(sp)
+ 80201a6e: 64a2 ld s1,8(sp)
+ 80201a70: 6105 addi sp,sp,32
+ 80201a72: 8082 ret
+
+0000000080201a74 <forkret>:
+{
+ 80201a74: 1101 addi sp,sp,-32
+ 80201a76: ec06 sd ra,24(sp)
+ 80201a78: e822 sd s0,16(sp)
+ 80201a7a: e426 sd s1,8(sp)
+ 80201a7c: 1000 addi s0,sp,32
+ release(&myproc()->lock);
+ 80201a7e: 00000097 auipc ra,0x0
+ 80201a82: fbe080e7 jalr -66(ra) # 80201a3c <myproc>
+ 80201a86: fffff097 auipc ra,0xfffff
+ 80201a8a: c94080e7 jalr -876(ra) # 8020071a <release>
+ if (first) {
+ 80201a8e: 00008797 auipc a5,0x8
+ 80201a92: 5727a783 lw a5,1394(a5) # 8020a000 <first.1>
+ 80201a96: eb91 bnez a5,80201aaa <forkret+0x36>
+ usertrapret();
+ 80201a98: 00001097 auipc ra,0x1
+ 80201a9c: ec2080e7 jalr -318(ra) # 8020295a <usertrapret>
+}
+ 80201aa0: 60e2 ld ra,24(sp)
+ 80201aa2: 6442 ld s0,16(sp)
+ 80201aa4: 64a2 ld s1,8(sp)
+ 80201aa6: 6105 addi sp,sp,32
+ 80201aa8: 8082 ret
+ first = 0;
+ 80201aaa: 00008797 auipc a5,0x8
+ 80201aae: 5407ab23 sw zero,1366(a5) # 8020a000 <first.1>
+ fat32_init();
+ 80201ab2: 00004097 auipc ra,0x4
+ 80201ab6: 0f2080e7 jalr 242(ra) # 80205ba4 <fat32_init>
+ myproc()->cwd = ename("/");
+ 80201aba: 00000097 auipc ra,0x0
+ 80201abe: f82080e7 jalr -126(ra) # 80201a3c <myproc>
+ 80201ac2: 84aa mv s1,a0
+ 80201ac4: 00008517 auipc a0,0x8
+ 80201ac8: b6c50513 addi a0,a0,-1172 # 80209630 <digits+0x2b0>
+ 80201acc: 00005097 auipc ra,0x5
+ 80201ad0: 34a080e7 jalr 842(ra) # 80206e16 <ename>
+ 80201ad4: 14a4bc23 sd a0,344(s1)
+ 80201ad8: b7c1 j 80201a98 <forkret+0x24>
+
+0000000080201ada <allocpid>:
+allocpid() {
+ 80201ada: 1101 addi sp,sp,-32
+ 80201adc: ec06 sd ra,24(sp)
+ 80201ade: e822 sd s0,16(sp)
+ 80201ae0: e426 sd s1,8(sp)
+ 80201ae2: e04a sd s2,0(sp)
+ 80201ae4: 1000 addi s0,sp,32
+ acquire(&pid_lock);
+ 80201ae6: 00012917 auipc s2,0x12
+ 80201aea: 57a90913 addi s2,s2,1402 # 80214060 <pid_lock>
+ 80201aee: 854a mv a0,s2
+ 80201af0: fffff097 auipc ra,0xfffff
+ 80201af4: bd6080e7 jalr -1066(ra) # 802006c6 <acquire>
+ pid = nextpid;
+ 80201af8: 00008797 auipc a5,0x8
+ 80201afc: 50878793 addi a5,a5,1288 # 8020a000 <first.1>
+ 80201b00: 43c4 lw s1,4(a5)
+ nextpid = nextpid + 1;
+ 80201b02: 0014871b addiw a4,s1,1
+ 80201b06: c3d8 sw a4,4(a5)
+ release(&pid_lock);
+ 80201b08: 854a mv a0,s2
+ 80201b0a: fffff097 auipc ra,0xfffff
+ 80201b0e: c10080e7 jalr -1008(ra) # 8020071a <release>
+}
+ 80201b12: 8526 mv a0,s1
+ 80201b14: 60e2 ld ra,24(sp)
+ 80201b16: 6442 ld s0,16(sp)
+ 80201b18: 64a2 ld s1,8(sp)
+ 80201b1a: 6902 ld s2,0(sp)
+ 80201b1c: 6105 addi sp,sp,32
+ 80201b1e: 8082 ret
+
+0000000080201b20 <proc_pagetable>:
+{
+ 80201b20: 1101 addi sp,sp,-32
+ 80201b22: ec06 sd ra,24(sp)
+ 80201b24: e822 sd s0,16(sp)
+ 80201b26: e426 sd s1,8(sp)
+ 80201b28: e04a sd s2,0(sp)
+ 80201b2a: 1000 addi s0,sp,32
+ 80201b2c: 892a mv s2,a0
+ pagetable = uvmcreate();
+ 80201b2e: fffff097 auipc ra,0xfffff
+ 80201b32: 3b8080e7 jalr 952(ra) # 80200ee6 <uvmcreate>
+ 80201b36: 84aa mv s1,a0
+ if(pagetable == 0)
+ 80201b38: c121 beqz a0,80201b78 <proc_pagetable+0x58>
+ if(mappages(pagetable, TRAMPOLINE, PGSIZE,
+ 80201b3a: 4729 li a4,10
+ 80201b3c: 0000a697 auipc a3,0xa
+ 80201b40: 1a46b683 ld a3,420(a3) # 8020bce0 <_GLOBAL_OFFSET_TABLE_+0x8>
+ 80201b44: 6605 lui a2,0x1
+ 80201b46: 040005b7 lui a1,0x4000
+ 80201b4a: 15fd addi a1,a1,-1 # 3ffffff <_entry-0x7c200001>
+ 80201b4c: 05b2 slli a1,a1,0xc
+ 80201b4e: fffff097 auipc ra,0xfffff
+ 80201b52: 11a080e7 jalr 282(ra) # 80200c68 <mappages>
+ 80201b56: 02054863 bltz a0,80201b86 <proc_pagetable+0x66>
+ if(mappages(pagetable, TRAPFRAME, PGSIZE,
+ 80201b5a: 4719 li a4,6
+ 80201b5c: 06093683 ld a3,96(s2)
+ 80201b60: 6605 lui a2,0x1
+ 80201b62: 020005b7 lui a1,0x2000
+ 80201b66: 15fd addi a1,a1,-1 # 1ffffff <_entry-0x7e200001>
+ 80201b68: 05b6 slli a1,a1,0xd
+ 80201b6a: 8526 mv a0,s1
+ 80201b6c: fffff097 auipc ra,0xfffff
+ 80201b70: 0fc080e7 jalr 252(ra) # 80200c68 <mappages>
+ 80201b74: 02054163 bltz a0,80201b96 <proc_pagetable+0x76>
+}
+ 80201b78: 8526 mv a0,s1
+ 80201b7a: 60e2 ld ra,24(sp)
+ 80201b7c: 6442 ld s0,16(sp)
+ 80201b7e: 64a2 ld s1,8(sp)
+ 80201b80: 6902 ld s2,0(sp)
+ 80201b82: 6105 addi sp,sp,32
+ 80201b84: 8082 ret
+ uvmfree(pagetable, 0);
+ 80201b86: 4581 li a1,0
+ 80201b88: 8526 mv a0,s1
+ 80201b8a: fffff097 auipc ra,0xfffff
+ 80201b8e: 5e2080e7 jalr 1506(ra) # 8020116c <uvmfree>
+ return NULL;
+ 80201b92: 4481 li s1,0
+ 80201b94: b7d5 j 80201b78 <proc_pagetable+0x58>
+ vmunmap(pagetable, TRAMPOLINE, 1, 0);
+ 80201b96: 4681 li a3,0
+ 80201b98: 4605 li a2,1
+ 80201b9a: 040005b7 lui a1,0x4000
+ 80201b9e: 15fd addi a1,a1,-1 # 3ffffff <_entry-0x7c200001>
+ 80201ba0: 05b2 slli a1,a1,0xc
+ 80201ba2: 8526 mv a0,s1
+ 80201ba4: fffff097 auipc ra,0xfffff
+ 80201ba8: 27e080e7 jalr 638(ra) # 80200e22 <vmunmap>
+ uvmfree(pagetable, 0);
+ 80201bac: 4581 li a1,0
+ 80201bae: 8526 mv a0,s1
+ 80201bb0: fffff097 auipc ra,0xfffff
+ 80201bb4: 5bc080e7 jalr 1468(ra) # 8020116c <uvmfree>
+ return NULL;
+ 80201bb8: 4481 li s1,0
+ 80201bba: bf7d j 80201b78 <proc_pagetable+0x58>
+
+0000000080201bbc <proc_freepagetable>:
+{
+ 80201bbc: 1101 addi sp,sp,-32
+ 80201bbe: ec06 sd ra,24(sp)
+ 80201bc0: e822 sd s0,16(sp)
+ 80201bc2: e426 sd s1,8(sp)
+ 80201bc4: e04a sd s2,0(sp)
+ 80201bc6: 1000 addi s0,sp,32
+ 80201bc8: 84aa mv s1,a0
+ 80201bca: 892e mv s2,a1
+ vmunmap(pagetable, TRAMPOLINE, 1, 0);
+ 80201bcc: 4681 li a3,0
+ 80201bce: 4605 li a2,1
+ 80201bd0: 040005b7 lui a1,0x4000
+ 80201bd4: 15fd addi a1,a1,-1 # 3ffffff <_entry-0x7c200001>
+ 80201bd6: 05b2 slli a1,a1,0xc
+ 80201bd8: fffff097 auipc ra,0xfffff
+ 80201bdc: 24a080e7 jalr 586(ra) # 80200e22 <vmunmap>
+ vmunmap(pagetable, TRAPFRAME, 1, 0);
+ 80201be0: 4681 li a3,0
+ 80201be2: 4605 li a2,1
+ 80201be4: 020005b7 lui a1,0x2000
+ 80201be8: 15fd addi a1,a1,-1 # 1ffffff <_entry-0x7e200001>
+ 80201bea: 05b6 slli a1,a1,0xd
+ 80201bec: 8526 mv a0,s1
+ 80201bee: fffff097 auipc ra,0xfffff
+ 80201bf2: 234080e7 jalr 564(ra) # 80200e22 <vmunmap>
+ uvmfree(pagetable, sz);
+ 80201bf6: 85ca mv a1,s2
+ 80201bf8: 8526 mv a0,s1
+ 80201bfa: fffff097 auipc ra,0xfffff
+ 80201bfe: 572080e7 jalr 1394(ra) # 8020116c <uvmfree>
+}
+ 80201c02: 60e2 ld ra,24(sp)
+ 80201c04: 6442 ld s0,16(sp)
+ 80201c06: 64a2 ld s1,8(sp)
+ 80201c08: 6902 ld s2,0(sp)
+ 80201c0a: 6105 addi sp,sp,32
+ 80201c0c: 8082 ret
+
+0000000080201c0e <freeproc>:
+{
+ 80201c0e: 1101 addi sp,sp,-32
+ 80201c10: ec06 sd ra,24(sp)
+ 80201c12: e822 sd s0,16(sp)
+ 80201c14: e426 sd s1,8(sp)
+ 80201c16: 1000 addi s0,sp,32
+ 80201c18: 84aa mv s1,a0
+ if(p->trapframe)
+ 80201c1a: 7128 ld a0,96(a0)
+ 80201c1c: c509 beqz a0,80201c26 <freeproc+0x18>
+ kfree((void*)p->trapframe);
+ 80201c1e: fffff097 auipc ra,0xfffff
+ 80201c22: 822080e7 jalr -2014(ra) # 80200440 <kfree>
+ p->trapframe = 0;
+ 80201c26: 0604b023 sd zero,96(s1)
+ if (p->kpagetable) {
+ 80201c2a: 6ca8 ld a0,88(s1)
+ 80201c2c: c511 beqz a0,80201c38 <freeproc+0x2a>
+ kvmfree(p->kpagetable, 1);
+ 80201c2e: 4585 li a1,1
+ 80201c30: 00000097 auipc ra,0x0
+ 80201c34: a42080e7 jalr -1470(ra) # 80201672 <kvmfree>
+ p->kpagetable = 0;
+ 80201c38: 0404bc23 sd zero,88(s1)
+ if(p->pagetable)
+ 80201c3c: 68a8 ld a0,80(s1)
+ 80201c3e: c511 beqz a0,80201c4a <freeproc+0x3c>
+ proc_freepagetable(p->pagetable, p->sz);
+ 80201c40: 64ac ld a1,72(s1)
+ 80201c42: 00000097 auipc ra,0x0
+ 80201c46: f7a080e7 jalr -134(ra) # 80201bbc <proc_freepagetable>
+ p->pagetable = 0;
+ 80201c4a: 0404b823 sd zero,80(s1)
+ p->sz = 0;
+ 80201c4e: 0404b423 sd zero,72(s1)
+ p->pid = 0;
+ 80201c52: 0204ac23 sw zero,56(s1)
+ p->parent = 0;
+ 80201c56: 0204b023 sd zero,32(s1)
+ p->name[0] = 0;
+ 80201c5a: 16048023 sb zero,352(s1)
+ p->chan = 0;
+ 80201c5e: 0204b423 sd zero,40(s1)
+ p->killed = 0;
+ 80201c62: 0204a823 sw zero,48(s1)
+ p->xstate = 0;
+ 80201c66: 0204aa23 sw zero,52(s1)
+ p->state = UNUSED;
+ 80201c6a: 0004ac23 sw zero,24(s1)
+}
+ 80201c6e: 60e2 ld ra,24(sp)
+ 80201c70: 6442 ld s0,16(sp)
+ 80201c72: 64a2 ld s1,8(sp)
+ 80201c74: 6105 addi sp,sp,32
+ 80201c76: 8082 ret
+
+0000000080201c78 <allocproc>:
+{
+ 80201c78: 1101 addi sp,sp,-32
+ 80201c7a: ec06 sd ra,24(sp)
+ 80201c7c: e822 sd s0,16(sp)
+ 80201c7e: e426 sd s1,8(sp)
+ 80201c80: e04a sd s2,0(sp)
+ 80201c82: 1000 addi s0,sp,32
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 80201c84: 00012497 auipc s1,0x12
+ 80201c88: 4fc48493 addi s1,s1,1276 # 80214180 <proc>
+ 80201c8c: 00017917 auipc s2,0x17
+ 80201c90: e6490913 addi s2,s2,-412 # 80218af0 <bcache>
+ acquire(&p->lock);
+ 80201c94: 8526 mv a0,s1
+ 80201c96: fffff097 auipc ra,0xfffff
+ 80201c9a: a30080e7 jalr -1488(ra) # 802006c6 <acquire>
+ if(p->state == UNUSED) {
+ 80201c9e: 4c9c lw a5,24(s1)
+ 80201ca0: cf81 beqz a5,80201cb8 <allocproc+0x40>
+ release(&p->lock);
+ 80201ca2: 8526 mv a0,s1
+ 80201ca4: fffff097 auipc ra,0xfffff
+ 80201ca8: a76080e7 jalr -1418(ra) # 8020071a <release>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 80201cac: 17848493 addi s1,s1,376
+ 80201cb0: ff2492e3 bne s1,s2,80201c94 <allocproc+0x1c>
+ return NULL;
+ 80201cb4: 4481 li s1,0
+ 80201cb6: a085 j 80201d16 <allocproc+0x9e>
+ p->pid = allocpid();
+ 80201cb8: 00000097 auipc ra,0x0
+ 80201cbc: e22080e7 jalr -478(ra) # 80201ada <allocpid>
+ 80201cc0: dc88 sw a0,56(s1)
+ if((p->trapframe = (struct trapframe *)kalloc()) == NULL){
+ 80201cc2: fffff097 auipc ra,0xfffff
+ 80201cc6: 898080e7 jalr -1896(ra) # 8020055a <kalloc>
+ 80201cca: 892a mv s2,a0
+ 80201ccc: f0a8 sd a0,96(s1)
+ 80201cce: c939 beqz a0,80201d24 <allocproc+0xac>
+ if ((p->pagetable = proc_pagetable(p)) == NULL ||
+ 80201cd0: 8526 mv a0,s1
+ 80201cd2: 00000097 auipc ra,0x0
+ 80201cd6: e4e080e7 jalr -434(ra) # 80201b20 <proc_pagetable>
+ 80201cda: e8a8 sd a0,80(s1)
+ 80201cdc: c939 beqz a0,80201d32 <allocproc+0xba>
+ (p->kpagetable = proc_kpagetable()) == NULL) {
+ 80201cde: 00000097 auipc ra,0x0
+ 80201ce2: 9ee080e7 jalr -1554(ra) # 802016cc <proc_kpagetable>
+ 80201ce6: eca8 sd a0,88(s1)
+ if ((p->pagetable = proc_pagetable(p)) == NULL ||
+ 80201ce8: c529 beqz a0,80201d32 <allocproc+0xba>
+ p->kstack = VKSTACK;
+ 80201cea: 0fb00793 li a5,251
+ 80201cee: 07fa slli a5,a5,0x1e
+ 80201cf0: e0bc sd a5,64(s1)
+ memset(&p->context, 0, sizeof(p->context));
+ 80201cf2: 07000613 li a2,112
+ 80201cf6: 4581 li a1,0
+ 80201cf8: 06848513 addi a0,s1,104
+ 80201cfc: fffff097 auipc ra,0xfffff
+ 80201d00: a66080e7 jalr -1434(ra) # 80200762 <memset>
+ p->context.ra = (uint64)forkret;
+ 80201d04: 00000797 auipc a5,0x0
+ 80201d08: d7078793 addi a5,a5,-656 # 80201a74 <forkret>
+ 80201d0c: f4bc sd a5,104(s1)
+ p->context.sp = p->kstack + PGSIZE;
+ 80201d0e: 60bc ld a5,64(s1)
+ 80201d10: 6705 lui a4,0x1
+ 80201d12: 97ba add a5,a5,a4
+ 80201d14: f8bc sd a5,112(s1)
+}
+ 80201d16: 8526 mv a0,s1
+ 80201d18: 60e2 ld ra,24(sp)
+ 80201d1a: 6442 ld s0,16(sp)
+ 80201d1c: 64a2 ld s1,8(sp)
+ 80201d1e: 6902 ld s2,0(sp)
+ 80201d20: 6105 addi sp,sp,32
+ 80201d22: 8082 ret
+ release(&p->lock);
+ 80201d24: 8526 mv a0,s1
+ 80201d26: fffff097 auipc ra,0xfffff
+ 80201d2a: 9f4080e7 jalr -1548(ra) # 8020071a <release>
+ return NULL;
+ 80201d2e: 84ca mv s1,s2
+ 80201d30: b7dd j 80201d16 <allocproc+0x9e>
+ freeproc(p);
+ 80201d32: 8526 mv a0,s1
+ 80201d34: 00000097 auipc ra,0x0
+ 80201d38: eda080e7 jalr -294(ra) # 80201c0e <freeproc>
+ release(&p->lock);
+ 80201d3c: 8526 mv a0,s1
+ 80201d3e: fffff097 auipc ra,0xfffff
+ 80201d42: 9dc080e7 jalr -1572(ra) # 8020071a <release>
+ return NULL;
+ 80201d46: 4481 li s1,0
+ 80201d48: b7f9 j 80201d16 <allocproc+0x9e>
+
+0000000080201d4a <userinit>:
+{
+ 80201d4a: 1101 addi sp,sp,-32
+ 80201d4c: ec06 sd ra,24(sp)
+ 80201d4e: e822 sd s0,16(sp)
+ 80201d50: e426 sd s1,8(sp)
+ 80201d52: e04a sd s2,0(sp)
+ 80201d54: 1000 addi s0,sp,32
+ p = allocproc();
+ 80201d56: 00000097 auipc ra,0x0
+ 80201d5a: f22080e7 jalr -222(ra) # 80201c78 <allocproc>
+ 80201d5e: 84aa mv s1,a0
+ initproc = p;
+ 80201d60: 00012797 auipc a5,0x12
+ 80201d64: 40a7bc23 sd a0,1048(a5) # 80214178 <initproc>
+ uvminit(p->pagetable , p->kpagetable, initcode, sizeof(initcode));
+ 80201d68: 6905 lui s2,0x1
+ 80201d6a: c4090693 addi a3,s2,-960 # c40 <_entry-0x801ff3c0>
+ 80201d6e: 00008617 auipc a2,0x8
+ 80201d72: 29a60613 addi a2,a2,666 # 8020a008 <initcode>
+ 80201d76: 6d2c ld a1,88(a0)
+ 80201d78: 6928 ld a0,80(a0)
+ 80201d7a: fffff097 auipc ra,0xfffff
+ 80201d7e: 19a080e7 jalr 410(ra) # 80200f14 <uvminit>
+ p->sz = PGSIZE;
+ 80201d82: 0524b423 sd s2,72(s1)
+ p->trapframe->epc = 0x0; // user program counter
+ 80201d86: 70bc ld a5,96(s1)
+ 80201d88: 0007bc23 sd zero,24(a5)
+ p->trapframe->sp = PGSIZE; // user stack pointer
+ 80201d8c: 70bc ld a5,96(s1)
+ 80201d8e: 0327b823 sd s2,48(a5)
+ safestrcpy(p->name, "initcode", sizeof(p->name));
+ 80201d92: 4641 li a2,16
+ 80201d94: 00008597 auipc a1,0x8
+ 80201d98: 8a458593 addi a1,a1,-1884 # 80209638 <digits+0x2b8>
+ 80201d9c: 16048513 addi a0,s1,352
+ 80201da0: fffff097 auipc ra,0xfffff
+ 80201da4: b14080e7 jalr -1260(ra) # 802008b4 <safestrcpy>
+ p->state = RUNNABLE;
+ 80201da8: 4789 li a5,2
+ 80201daa: cc9c sw a5,24(s1)
+ p->tmask = 0;
+ 80201dac: 1604a823 sw zero,368(s1)
+ release(&p->lock);
+ 80201db0: 8526 mv a0,s1
+ 80201db2: fffff097 auipc ra,0xfffff
+ 80201db6: 968080e7 jalr -1688(ra) # 8020071a <release>
+}
+ 80201dba: 60e2 ld ra,24(sp)
+ 80201dbc: 6442 ld s0,16(sp)
+ 80201dbe: 64a2 ld s1,8(sp)
+ 80201dc0: 6902 ld s2,0(sp)
+ 80201dc2: 6105 addi sp,sp,32
+ 80201dc4: 8082 ret
+
+0000000080201dc6 <growproc>:
+{
+ 80201dc6: 1101 addi sp,sp,-32
+ 80201dc8: ec06 sd ra,24(sp)
+ 80201dca: e822 sd s0,16(sp)
+ 80201dcc: e426 sd s1,8(sp)
+ 80201dce: e04a sd s2,0(sp)
+ 80201dd0: 1000 addi s0,sp,32
+ 80201dd2: 84aa mv s1,a0
+ struct proc *p = myproc();
+ 80201dd4: 00000097 auipc ra,0x0
+ 80201dd8: c68080e7 jalr -920(ra) # 80201a3c <myproc>
+ 80201ddc: 892a mv s2,a0
+ sz = p->sz;
+ 80201dde: 6530 ld a2,72(a0)
+ 80201de0: 0006079b sext.w a5,a2
+ if(n > 0){
+ 80201de4: 00904f63 bgtz s1,80201e02 <growproc+0x3c>
+ } else if(n < 0){
+ 80201de8: 0204ce63 bltz s1,80201e24 <growproc+0x5e>
+ p->sz = sz;
+ 80201dec: 1782 slli a5,a5,0x20
+ 80201dee: 9381 srli a5,a5,0x20
+ 80201df0: 04f93423 sd a5,72(s2)
+ return 0;
+ 80201df4: 4501 li a0,0
+}
+ 80201df6: 60e2 ld ra,24(sp)
+ 80201df8: 6442 ld s0,16(sp)
+ 80201dfa: 64a2 ld s1,8(sp)
+ 80201dfc: 6902 ld s2,0(sp)
+ 80201dfe: 6105 addi sp,sp,32
+ 80201e00: 8082 ret
+ if((sz = uvmalloc(p->pagetable, p->kpagetable, sz, sz + n)) == 0) {
+ 80201e02: 00f486bb addw a3,s1,a5
+ 80201e06: 1682 slli a3,a3,0x20
+ 80201e08: 9281 srli a3,a3,0x20
+ 80201e0a: 1602 slli a2,a2,0x20
+ 80201e0c: 9201 srli a2,a2,0x20
+ 80201e0e: 6d2c ld a1,88(a0)
+ 80201e10: 6928 ld a0,80(a0)
+ 80201e12: fffff097 auipc ra,0xfffff
+ 80201e16: 1f8080e7 jalr 504(ra) # 8020100a <uvmalloc>
+ 80201e1a: 0005079b sext.w a5,a0
+ 80201e1e: f7f9 bnez a5,80201dec <growproc+0x26>
+ return -1;
+ 80201e20: 557d li a0,-1
+ 80201e22: bfd1 j 80201df6 <growproc+0x30>
+ sz = uvmdealloc(p->pagetable, p->kpagetable, sz, sz + n);
+ 80201e24: 00f486bb addw a3,s1,a5
+ 80201e28: 1682 slli a3,a3,0x20
+ 80201e2a: 9281 srli a3,a3,0x20
+ 80201e2c: 1602 slli a2,a2,0x20
+ 80201e2e: 9201 srli a2,a2,0x20
+ 80201e30: 6d2c ld a1,88(a0)
+ 80201e32: 6928 ld a0,80(a0)
+ 80201e34: fffff097 auipc ra,0xfffff
+ 80201e38: 16a080e7 jalr 362(ra) # 80200f9e <uvmdealloc>
+ 80201e3c: 0005079b sext.w a5,a0
+ 80201e40: b775 j 80201dec <growproc+0x26>
+
+0000000080201e42 <fork>:
+{
+ 80201e42: 7139 addi sp,sp,-64
+ 80201e44: fc06 sd ra,56(sp)
+ 80201e46: f822 sd s0,48(sp)
+ 80201e48: f426 sd s1,40(sp)
+ 80201e4a: f04a sd s2,32(sp)
+ 80201e4c: ec4e sd s3,24(sp)
+ 80201e4e: e852 sd s4,16(sp)
+ 80201e50: e456 sd s5,8(sp)
+ 80201e52: 0080 addi s0,sp,64
+ struct proc *p = myproc();
+ 80201e54: 00000097 auipc ra,0x0
+ 80201e58: be8080e7 jalr -1048(ra) # 80201a3c <myproc>
+ 80201e5c: 8aaa mv s5,a0
+ if((np = allocproc()) == NULL){
+ 80201e5e: 00000097 auipc ra,0x0
+ 80201e62: e1a080e7 jalr -486(ra) # 80201c78 <allocproc>
+ 80201e66: c965 beqz a0,80201f56 <fork+0x114>
+ 80201e68: 8a2a mv s4,a0
+ if(uvmcopy(p->pagetable, np->pagetable, np->kpagetable, p->sz) < 0){
+ 80201e6a: 048ab683 ld a3,72(s5)
+ 80201e6e: 6d30 ld a2,88(a0)
+ 80201e70: 692c ld a1,80(a0)
+ 80201e72: 050ab503 ld a0,80(s5)
+ 80201e76: fffff097 auipc ra,0xfffff
+ 80201e7a: 330080e7 jalr 816(ra) # 802011a6 <uvmcopy>
+ 80201e7e: 04054e63 bltz a0,80201eda <fork+0x98>
+ np->sz = p->sz;
+ 80201e82: 048ab783 ld a5,72(s5)
+ 80201e86: 04fa3423 sd a5,72(s4)
+ np->parent = p;
+ 80201e8a: 035a3023 sd s5,32(s4)
+ np->tmask = p->tmask;
+ 80201e8e: 170aa783 lw a5,368(s5)
+ 80201e92: 16fa2823 sw a5,368(s4)
+ *(np->trapframe) = *(p->trapframe);
+ 80201e96: 060ab683 ld a3,96(s5)
+ 80201e9a: 87b6 mv a5,a3
+ 80201e9c: 060a3703 ld a4,96(s4)
+ 80201ea0: 12068693 addi a3,a3,288
+ 80201ea4: 0007b803 ld a6,0(a5)
+ 80201ea8: 6788 ld a0,8(a5)
+ 80201eaa: 6b8c ld a1,16(a5)
+ 80201eac: 6f90 ld a2,24(a5)
+ 80201eae: 01073023 sd a6,0(a4) # 1000 <_entry-0x801ff000>
+ 80201eb2: e708 sd a0,8(a4)
+ 80201eb4: eb0c sd a1,16(a4)
+ 80201eb6: ef10 sd a2,24(a4)
+ 80201eb8: 02078793 addi a5,a5,32
+ 80201ebc: 02070713 addi a4,a4,32
+ 80201ec0: fed792e3 bne a5,a3,80201ea4 <fork+0x62>
+ np->trapframe->a0 = 0;
+ 80201ec4: 060a3783 ld a5,96(s4)
+ 80201ec8: 0607b823 sd zero,112(a5)
+ for(i = 0; i < NOFILE; i++)
+ 80201ecc: 0d8a8493 addi s1,s5,216
+ 80201ed0: 0d8a0913 addi s2,s4,216
+ 80201ed4: 158a8993 addi s3,s5,344
+ 80201ed8: a00d j 80201efa <fork+0xb8>
+ freeproc(np);
+ 80201eda: 8552 mv a0,s4
+ 80201edc: 00000097 auipc ra,0x0
+ 80201ee0: d32080e7 jalr -718(ra) # 80201c0e <freeproc>
+ release(&np->lock);
+ 80201ee4: 8552 mv a0,s4
+ 80201ee6: fffff097 auipc ra,0xfffff
+ 80201eea: 834080e7 jalr -1996(ra) # 8020071a <release>
+ return -1;
+ 80201eee: 54fd li s1,-1
+ 80201ef0: a889 j 80201f42 <fork+0x100>
+ for(i = 0; i < NOFILE; i++)
+ 80201ef2: 04a1 addi s1,s1,8
+ 80201ef4: 0921 addi s2,s2,8
+ 80201ef6: 01348b63 beq s1,s3,80201f0c <fork+0xca>
+ if(p->ofile[i])
+ 80201efa: 6088 ld a0,0(s1)
+ 80201efc: d97d beqz a0,80201ef2 <fork+0xb0>
+ np->ofile[i] = filedup(p->ofile[i]);
+ 80201efe: 00002097 auipc ra,0x2
+ 80201f02: d82080e7 jalr -638(ra) # 80203c80 <filedup>
+ 80201f06: 00a93023 sd a0,0(s2)
+ 80201f0a: b7e5 j 80201ef2 <fork+0xb0>
+ np->cwd = edup(p->cwd);
+ 80201f0c: 158ab503 ld a0,344(s5)
+ 80201f10: 00004097 auipc ra,0x4
+ 80201f14: 500080e7 jalr 1280(ra) # 80206410 <edup>
+ 80201f18: 14aa3c23 sd a0,344(s4)
+ safestrcpy(np->name, p->name, sizeof(p->name));
+ 80201f1c: 4641 li a2,16
+ 80201f1e: 160a8593 addi a1,s5,352
+ 80201f22: 160a0513 addi a0,s4,352
+ 80201f26: fffff097 auipc ra,0xfffff
+ 80201f2a: 98e080e7 jalr -1650(ra) # 802008b4 <safestrcpy>
+ pid = np->pid;
+ 80201f2e: 038a2483 lw s1,56(s4)
+ np->state = RUNNABLE;
+ 80201f32: 4789 li a5,2
+ 80201f34: 00fa2c23 sw a5,24(s4)
+ release(&np->lock);
+ 80201f38: 8552 mv a0,s4
+ 80201f3a: ffffe097 auipc ra,0xffffe
+ 80201f3e: 7e0080e7 jalr 2016(ra) # 8020071a <release>
+}
+ 80201f42: 8526 mv a0,s1
+ 80201f44: 70e2 ld ra,56(sp)
+ 80201f46: 7442 ld s0,48(sp)
+ 80201f48: 74a2 ld s1,40(sp)
+ 80201f4a: 7902 ld s2,32(sp)
+ 80201f4c: 69e2 ld s3,24(sp)
+ 80201f4e: 6a42 ld s4,16(sp)
+ 80201f50: 6aa2 ld s5,8(sp)
+ 80201f52: 6121 addi sp,sp,64
+ 80201f54: 8082 ret
+ return -1;
+ 80201f56: 54fd li s1,-1
+ 80201f58: b7ed j 80201f42 <fork+0x100>
+
+0000000080201f5a <clone>:
+{
+ 80201f5a: 7139 addi sp,sp,-64
+ 80201f5c: fc06 sd ra,56(sp)
+ 80201f5e: f822 sd s0,48(sp)
+ 80201f60: f426 sd s1,40(sp)
+ 80201f62: f04a sd s2,32(sp)
+ 80201f64: ec4e sd s3,24(sp)
+ 80201f66: e852 sd s4,16(sp)
+ 80201f68: e456 sd s5,8(sp)
+ 80201f6a: 0080 addi s0,sp,64
+ 80201f6c: 84aa mv s1,a0
+ struct proc *p = myproc();
+ 80201f6e: 00000097 auipc ra,0x0
+ 80201f72: ace080e7 jalr -1330(ra) # 80201a3c <myproc>
+ if(stack < 0 || stack > p->sz)
+ 80201f76: 1004c863 bltz s1,80202086 <clone+0x12c>
+ 80201f7a: 8aaa mv s5,a0
+ 80201f7c: 653c ld a5,72(a0)
+ 80201f7e: 1097e663 bltu a5,s1,8020208a <clone+0x130>
+ if((np = allocproc()) == NULL){
+ 80201f82: 00000097 auipc ra,0x0
+ 80201f86: cf6080e7 jalr -778(ra) # 80201c78 <allocproc>
+ 80201f8a: 89aa mv s3,a0
+ 80201f8c: 10050163 beqz a0,8020208e <clone+0x134>
+ if(uvmcopy(p->pagetable, np->pagetable, np->kpagetable, p->sz) < 0){
+ 80201f90: 048ab683 ld a3,72(s5)
+ 80201f94: 6d30 ld a2,88(a0)
+ 80201f96: 692c ld a1,80(a0)
+ 80201f98: 050ab503 ld a0,80(s5)
+ 80201f9c: fffff097 auipc ra,0xfffff
+ 80201fa0: 20a080e7 jalr 522(ra) # 802011a6 <uvmcopy>
+ 80201fa4: 06054363 bltz a0,8020200a <clone+0xb0>
+ np->sz = p->sz;
+ 80201fa8: 048ab783 ld a5,72(s5)
+ 80201fac: 04f9b423 sd a5,72(s3)
+ np->parent = p;
+ 80201fb0: 0359b023 sd s5,32(s3)
+ np->tmask = p->tmask;
+ 80201fb4: 170aa783 lw a5,368(s5)
+ 80201fb8: 16f9a823 sw a5,368(s3)
+ *(np->trapframe) = *(p->trapframe);
+ 80201fbc: 060ab683 ld a3,96(s5)
+ 80201fc0: 87b6 mv a5,a3
+ 80201fc2: 0609b703 ld a4,96(s3)
+ 80201fc6: 12068693 addi a3,a3,288
+ 80201fca: 0007b803 ld a6,0(a5)
+ 80201fce: 6788 ld a0,8(a5)
+ 80201fd0: 6b8c ld a1,16(a5)
+ 80201fd2: 6f90 ld a2,24(a5)
+ 80201fd4: 01073023 sd a6,0(a4)
+ 80201fd8: e708 sd a0,8(a4)
+ 80201fda: eb0c sd a1,16(a4)
+ 80201fdc: ef10 sd a2,24(a4)
+ 80201fde: 02078793 addi a5,a5,32
+ 80201fe2: 02070713 addi a4,a4,32
+ 80201fe6: fed792e3 bne a5,a3,80201fca <clone+0x70>
+ np->trapframe->a0 = 0;
+ 80201fea: 0609b783 ld a5,96(s3)
+ 80201fee: 0607b823 sd zero,112(a5)
+ if(stack > 0) np->trapframe->sp = stack;
+ 80201ff2: 00905563 blez s1,80201ffc <clone+0xa2>
+ 80201ff6: 0609b783 ld a5,96(s3)
+ 80201ffa: fb84 sd s1,48(a5)
+ for(i = 0; i < NOFILE; i++)
+ 80201ffc: 0d8a8493 addi s1,s5,216
+ 80202000: 0d898913 addi s2,s3,216
+ 80202004: 158a8a13 addi s4,s5,344
+ 80202008: a00d j 8020202a <clone+0xd0>
+ freeproc(np);
+ 8020200a: 854e mv a0,s3
+ 8020200c: 00000097 auipc ra,0x0
+ 80202010: c02080e7 jalr -1022(ra) # 80201c0e <freeproc>
+ release(&np->lock);
+ 80202014: 854e mv a0,s3
+ 80202016: ffffe097 auipc ra,0xffffe
+ 8020201a: 704080e7 jalr 1796(ra) # 8020071a <release>
+ return -1;
+ 8020201e: 54fd li s1,-1
+ 80202020: a889 j 80202072 <clone+0x118>
+ for(i = 0; i < NOFILE; i++)
+ 80202022: 04a1 addi s1,s1,8
+ 80202024: 0921 addi s2,s2,8
+ 80202026: 01448b63 beq s1,s4,8020203c <clone+0xe2>
+ if(p->ofile[i])
+ 8020202a: 6088 ld a0,0(s1)
+ 8020202c: d97d beqz a0,80202022 <clone+0xc8>
+ np->ofile[i] = filedup(p->ofile[i]);
+ 8020202e: 00002097 auipc ra,0x2
+ 80202032: c52080e7 jalr -942(ra) # 80203c80 <filedup>
+ 80202036: 00a93023 sd a0,0(s2)
+ 8020203a: b7e5 j 80202022 <clone+0xc8>
+ np->cwd = edup(p->cwd);
+ 8020203c: 158ab503 ld a0,344(s5)
+ 80202040: 00004097 auipc ra,0x4
+ 80202044: 3d0080e7 jalr 976(ra) # 80206410 <edup>
+ 80202048: 14a9bc23 sd a0,344(s3)
+ safestrcpy(np->name, p->name, sizeof(p->name));
+ 8020204c: 4641 li a2,16
+ 8020204e: 160a8593 addi a1,s5,352
+ 80202052: 16098513 addi a0,s3,352
+ 80202056: fffff097 auipc ra,0xfffff
+ 8020205a: 85e080e7 jalr -1954(ra) # 802008b4 <safestrcpy>
+ pid = np->pid;
+ 8020205e: 0389a483 lw s1,56(s3)
+ np->state = RUNNABLE;
+ 80202062: 4789 li a5,2
+ 80202064: 00f9ac23 sw a5,24(s3)
+ release(&np->lock);
+ 80202068: 854e mv a0,s3
+ 8020206a: ffffe097 auipc ra,0xffffe
+ 8020206e: 6b0080e7 jalr 1712(ra) # 8020071a <release>
+}
+ 80202072: 8526 mv a0,s1
+ 80202074: 70e2 ld ra,56(sp)
+ 80202076: 7442 ld s0,48(sp)
+ 80202078: 74a2 ld s1,40(sp)
+ 8020207a: 7902 ld s2,32(sp)
+ 8020207c: 69e2 ld s3,24(sp)
+ 8020207e: 6a42 ld s4,16(sp)
+ 80202080: 6aa2 ld s5,8(sp)
+ 80202082: 6121 addi sp,sp,64
+ 80202084: 8082 ret
+ return -1;
+ 80202086: 54fd li s1,-1
+ 80202088: b7ed j 80202072 <clone+0x118>
+ 8020208a: 54fd li s1,-1
+ 8020208c: b7dd j 80202072 <clone+0x118>
+ return -1;
+ 8020208e: 54fd li s1,-1
+ 80202090: b7cd j 80202072 <clone+0x118>
+
+0000000080202092 <reparent>:
+{
+ 80202092: 7179 addi sp,sp,-48
+ 80202094: f406 sd ra,40(sp)
+ 80202096: f022 sd s0,32(sp)
+ 80202098: ec26 sd s1,24(sp)
+ 8020209a: e84a sd s2,16(sp)
+ 8020209c: e44e sd s3,8(sp)
+ 8020209e: e052 sd s4,0(sp)
+ 802020a0: 1800 addi s0,sp,48
+ 802020a2: 892a mv s2,a0
+ for(pp = proc; pp < &proc[NPROC]; pp++){
+ 802020a4: 00012497 auipc s1,0x12
+ 802020a8: 0dc48493 addi s1,s1,220 # 80214180 <proc>
+ pp->parent = initproc;
+ 802020ac: 00012a17 auipc s4,0x12
+ 802020b0: fb4a0a13 addi s4,s4,-76 # 80214060 <pid_lock>
+ for(pp = proc; pp < &proc[NPROC]; pp++){
+ 802020b4: 00017997 auipc s3,0x17
+ 802020b8: a3c98993 addi s3,s3,-1476 # 80218af0 <bcache>
+ 802020bc: a029 j 802020c6 <reparent+0x34>
+ 802020be: 17848493 addi s1,s1,376
+ 802020c2: 03348363 beq s1,s3,802020e8 <reparent+0x56>
+ if(pp->parent == p){
+ 802020c6: 709c ld a5,32(s1)
+ 802020c8: ff279be3 bne a5,s2,802020be <reparent+0x2c>
+ acquire(&pp->lock);
+ 802020cc: 8526 mv a0,s1
+ 802020ce: ffffe097 auipc ra,0xffffe
+ 802020d2: 5f8080e7 jalr 1528(ra) # 802006c6 <acquire>
+ pp->parent = initproc;
+ 802020d6: 118a3783 ld a5,280(s4)
+ 802020da: f09c sd a5,32(s1)
+ release(&pp->lock);
+ 802020dc: 8526 mv a0,s1
+ 802020de: ffffe097 auipc ra,0xffffe
+ 802020e2: 63c080e7 jalr 1596(ra) # 8020071a <release>
+ 802020e6: bfe1 j 802020be <reparent+0x2c>
+}
+ 802020e8: 70a2 ld ra,40(sp)
+ 802020ea: 7402 ld s0,32(sp)
+ 802020ec: 64e2 ld s1,24(sp)
+ 802020ee: 6942 ld s2,16(sp)
+ 802020f0: 69a2 ld s3,8(sp)
+ 802020f2: 6a02 ld s4,0(sp)
+ 802020f4: 6145 addi sp,sp,48
+ 802020f6: 8082 ret
+
+00000000802020f8 <scheduler>:
+{
+ 802020f8: 715d addi sp,sp,-80
+ 802020fa: e486 sd ra,72(sp)
+ 802020fc: e0a2 sd s0,64(sp)
+ 802020fe: fc26 sd s1,56(sp)
+ 80202100: f84a sd s2,48(sp)
+ 80202102: f44e sd s3,40(sp)
+ 80202104: f052 sd s4,32(sp)
+ 80202106: ec56 sd s5,24(sp)
+ 80202108: e85a sd s6,16(sp)
+ 8020210a: e45e sd s7,8(sp)
+ 8020210c: e062 sd s8,0(sp)
+ 8020210e: 0880 addi s0,sp,80
+ 80202110: 8792 mv a5,tp
+ int id = r_tp();
+ 80202112: 2781 sext.w a5,a5
+ c->proc = 0;
+ 80202114: 00779b13 slli s6,a5,0x7
+ 80202118: 00012717 auipc a4,0x12
+ 8020211c: f4870713 addi a4,a4,-184 # 80214060 <pid_lock>
+ 80202120: 975a add a4,a4,s6
+ 80202122: 00073c23 sd zero,24(a4)
+ swtch(&c->context, &p->context);
+ 80202126: 00012717 auipc a4,0x12
+ 8020212a: f5a70713 addi a4,a4,-166 # 80214080 <cpus+0x8>
+ 8020212e: 9b3a add s6,s6,a4
+ c->proc = p;
+ 80202130: 079e slli a5,a5,0x7
+ 80202132: 00012a97 auipc s5,0x12
+ 80202136: f2ea8a93 addi s5,s5,-210 # 80214060 <pid_lock>
+ 8020213a: 9abe add s5,s5,a5
+ w_satp(MAKE_SATP(p->kpagetable));
+ 8020213c: 5a7d li s4,-1
+ 8020213e: 1a7e slli s4,s4,0x3f
+ w_satp(MAKE_SATP(kernel_pagetable));
+ 80202140: 0000ab97 auipc s7,0xa
+ 80202144: be0bbb83 ld s7,-1056(s7) # 8020bd20 <_GLOBAL_OFFSET_TABLE_+0x48>
+ 80202148: a8a5 j 802021c0 <scheduler+0xc8>
+ release(&p->lock);
+ 8020214a: 8526 mv a0,s1
+ 8020214c: ffffe097 auipc ra,0xffffe
+ 80202150: 5ce080e7 jalr 1486(ra) # 8020071a <release>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 80202154: 17848493 addi s1,s1,376
+ 80202158: 05248a63 beq s1,s2,802021ac <scheduler+0xb4>
+ acquire(&p->lock);
+ 8020215c: 8526 mv a0,s1
+ 8020215e: ffffe097 auipc ra,0xffffe
+ 80202162: 568080e7 jalr 1384(ra) # 802006c6 <acquire>
+ if(p->state == RUNNABLE) {
+ 80202166: 4c9c lw a5,24(s1)
+ 80202168: ff3791e3 bne a5,s3,8020214a <scheduler+0x52>
+ p->state = RUNNING;
+ 8020216c: 478d li a5,3
+ 8020216e: cc9c sw a5,24(s1)
+ c->proc = p;
+ 80202170: 009abc23 sd s1,24(s5)
+ w_satp(MAKE_SATP(p->kpagetable));
+ 80202174: 6cbc ld a5,88(s1)
+ 80202176: 83b1 srli a5,a5,0xc
+ 80202178: 0147e7b3 or a5,a5,s4
+ asm volatile("csrw satp, %0" : : "r" (x));
+ 8020217c: 18079073 csrw satp,a5
+ asm volatile("sfence.vma");
+ 80202180: 12000073 sfence.vma
+ swtch(&c->context, &p->context);
+ 80202184: 06848593 addi a1,s1,104
+ 80202188: 855a mv a0,s6
+ 8020218a: 00000097 auipc ra,0x0
+ 8020218e: 72a080e7 jalr 1834(ra) # 802028b4 <swtch>
+ w_satp(MAKE_SATP(kernel_pagetable));
+ 80202192: 000bb783 ld a5,0(s7)
+ 80202196: 83b1 srli a5,a5,0xc
+ 80202198: 0147e7b3 or a5,a5,s4
+ asm volatile("csrw satp, %0" : : "r" (x));
+ 8020219c: 18079073 csrw satp,a5
+ asm volatile("sfence.vma");
+ 802021a0: 12000073 sfence.vma
+ c->proc = 0;
+ 802021a4: 000abc23 sd zero,24(s5)
+ found = 1;
+ 802021a8: 4c05 li s8,1
+ 802021aa: b745 j 8020214a <scheduler+0x52>
+ if(found == 0) {
+ 802021ac: 000c1a63 bnez s8,802021c0 <scheduler+0xc8>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 802021b0: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() | SSTATUS_SIE);
+ 802021b4: 0027e793 ori a5,a5,2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 802021b8: 10079073 csrw sstatus,a5
+ asm volatile("wfi");
+ 802021bc: 10500073 wfi
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 802021c0: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() | SSTATUS_SIE);
+ 802021c4: 0027e793 ori a5,a5,2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 802021c8: 10079073 csrw sstatus,a5
+ int found = 0;
+ 802021cc: 4c01 li s8,0
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802021ce: 00012497 auipc s1,0x12
+ 802021d2: fb248493 addi s1,s1,-78 # 80214180 <proc>
+ if(p->state == RUNNABLE) {
+ 802021d6: 4989 li s3,2
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802021d8: 00017917 auipc s2,0x17
+ 802021dc: 91890913 addi s2,s2,-1768 # 80218af0 <bcache>
+ 802021e0: bfb5 j 8020215c <scheduler+0x64>
+
+00000000802021e2 <sched>:
+{
+ 802021e2: 7179 addi sp,sp,-48
+ 802021e4: f406 sd ra,40(sp)
+ 802021e6: f022 sd s0,32(sp)
+ 802021e8: ec26 sd s1,24(sp)
+ 802021ea: e84a sd s2,16(sp)
+ 802021ec: e44e sd s3,8(sp)
+ 802021ee: 1800 addi s0,sp,48
+ struct proc *p = myproc();
+ 802021f0: 00000097 auipc ra,0x0
+ 802021f4: 84c080e7 jalr -1972(ra) # 80201a3c <myproc>
+ 802021f8: 84aa mv s1,a0
+ if(!holding(&p->lock))
+ 802021fa: ffffe097 auipc ra,0xffffe
+ 802021fe: 49e080e7 jalr 1182(ra) # 80200698 <holding>
+ 80202202: c93d beqz a0,80202278 <sched+0x96>
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 80202204: 8792 mv a5,tp
+ if(mycpu()->noff != 1)
+ 80202206: 2781 sext.w a5,a5
+ 80202208: 079e slli a5,a5,0x7
+ 8020220a: 00012717 auipc a4,0x12
+ 8020220e: e5670713 addi a4,a4,-426 # 80214060 <pid_lock>
+ 80202212: 97ba add a5,a5,a4
+ 80202214: 0907a703 lw a4,144(a5)
+ 80202218: 4785 li a5,1
+ 8020221a: 06f71763 bne a4,a5,80202288 <sched+0xa6>
+ if(p->state == RUNNING)
+ 8020221e: 4c98 lw a4,24(s1)
+ 80202220: 478d li a5,3
+ 80202222: 06f70b63 beq a4,a5,80202298 <sched+0xb6>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202226: 100027f3 csrr a5,sstatus
+ return (x & SSTATUS_SIE) != 0;
+ 8020222a: 8b89 andi a5,a5,2
+ if(intr_get())
+ 8020222c: efb5 bnez a5,802022a8 <sched+0xc6>
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 8020222e: 8792 mv a5,tp
+ intena = mycpu()->intena;
+ 80202230: 00012917 auipc s2,0x12
+ 80202234: e3090913 addi s2,s2,-464 # 80214060 <pid_lock>
+ 80202238: 2781 sext.w a5,a5
+ 8020223a: 079e slli a5,a5,0x7
+ 8020223c: 97ca add a5,a5,s2
+ 8020223e: 0947a983 lw s3,148(a5)
+ 80202242: 8792 mv a5,tp
+ swtch(&p->context, &mycpu()->context);
+ 80202244: 2781 sext.w a5,a5
+ 80202246: 079e slli a5,a5,0x7
+ 80202248: 00012597 auipc a1,0x12
+ 8020224c: e3858593 addi a1,a1,-456 # 80214080 <cpus+0x8>
+ 80202250: 95be add a1,a1,a5
+ 80202252: 06848513 addi a0,s1,104
+ 80202256: 00000097 auipc ra,0x0
+ 8020225a: 65e080e7 jalr 1630(ra) # 802028b4 <swtch>
+ 8020225e: 8792 mv a5,tp
+ mycpu()->intena = intena;
+ 80202260: 2781 sext.w a5,a5
+ 80202262: 079e slli a5,a5,0x7
+ 80202264: 993e add s2,s2,a5
+ 80202266: 09392a23 sw s3,148(s2)
+}
+ 8020226a: 70a2 ld ra,40(sp)
+ 8020226c: 7402 ld s0,32(sp)
+ 8020226e: 64e2 ld s1,24(sp)
+ 80202270: 6942 ld s2,16(sp)
+ 80202272: 69a2 ld s3,8(sp)
+ 80202274: 6145 addi sp,sp,48
+ 80202276: 8082 ret
+ panic("sched p->lock");
+ 80202278: 00007517 auipc a0,0x7
+ 8020227c: 3d050513 addi a0,a0,976 # 80209648 <digits+0x2c8>
+ 80202280: ffffe097 auipc ra,0xffffe
+ 80202284: ec4080e7 jalr -316(ra) # 80200144 <panic>
+ panic("sched locks");
+ 80202288: 00007517 auipc a0,0x7
+ 8020228c: 3d050513 addi a0,a0,976 # 80209658 <digits+0x2d8>
+ 80202290: ffffe097 auipc ra,0xffffe
+ 80202294: eb4080e7 jalr -332(ra) # 80200144 <panic>
+ panic("sched running");
+ 80202298: 00007517 auipc a0,0x7
+ 8020229c: 3d050513 addi a0,a0,976 # 80209668 <digits+0x2e8>
+ 802022a0: ffffe097 auipc ra,0xffffe
+ 802022a4: ea4080e7 jalr -348(ra) # 80200144 <panic>
+ panic("sched interruptible");
+ 802022a8: 00007517 auipc a0,0x7
+ 802022ac: 3d050513 addi a0,a0,976 # 80209678 <digits+0x2f8>
+ 802022b0: ffffe097 auipc ra,0xffffe
+ 802022b4: e94080e7 jalr -364(ra) # 80200144 <panic>
+
+00000000802022b8 <exit>:
+{
+ 802022b8: 7179 addi sp,sp,-48
+ 802022ba: f406 sd ra,40(sp)
+ 802022bc: f022 sd s0,32(sp)
+ 802022be: ec26 sd s1,24(sp)
+ 802022c0: e84a sd s2,16(sp)
+ 802022c2: e44e sd s3,8(sp)
+ 802022c4: e052 sd s4,0(sp)
+ 802022c6: 1800 addi s0,sp,48
+ 802022c8: 8a2a mv s4,a0
+ struct proc *p = myproc();
+ 802022ca: fffff097 auipc ra,0xfffff
+ 802022ce: 772080e7 jalr 1906(ra) # 80201a3c <myproc>
+ 802022d2: 89aa mv s3,a0
+ if(p == initproc)
+ 802022d4: 00012797 auipc a5,0x12
+ 802022d8: ea47b783 ld a5,-348(a5) # 80214178 <initproc>
+ 802022dc: 0d850493 addi s1,a0,216
+ 802022e0: 15850913 addi s2,a0,344
+ 802022e4: 02a79363 bne a5,a0,8020230a <exit+0x52>
+ panic("init exiting");
+ 802022e8: 00007517 auipc a0,0x7
+ 802022ec: 3a850513 addi a0,a0,936 # 80209690 <digits+0x310>
+ 802022f0: ffffe097 auipc ra,0xffffe
+ 802022f4: e54080e7 jalr -428(ra) # 80200144 <panic>
+ fileclose(f);
+ 802022f8: 00002097 auipc ra,0x2
+ 802022fc: 9da080e7 jalr -1574(ra) # 80203cd2 <fileclose>
+ p->ofile[fd] = 0;
+ 80202300: 0004b023 sd zero,0(s1)
+ for(int fd = 0; fd < NOFILE; fd++){
+ 80202304: 04a1 addi s1,s1,8
+ 80202306: 01248563 beq s1,s2,80202310 <exit+0x58>
+ if(p->ofile[fd]){
+ 8020230a: 6088 ld a0,0(s1)
+ 8020230c: f575 bnez a0,802022f8 <exit+0x40>
+ 8020230e: bfdd j 80202304 <exit+0x4c>
+ eput(p->cwd);
+ 80202310: 1589b503 ld a0,344(s3)
+ 80202314: 00004097 auipc ra,0x4
+ 80202318: 3de080e7 jalr 990(ra) # 802066f2 <eput>
+ p->cwd = 0;
+ 8020231c: 1409bc23 sd zero,344(s3)
+ acquire(&initproc->lock);
+ 80202320: 00012497 auipc s1,0x12
+ 80202324: d4048493 addi s1,s1,-704 # 80214060 <pid_lock>
+ 80202328: 1184b503 ld a0,280(s1)
+ 8020232c: ffffe097 auipc ra,0xffffe
+ 80202330: 39a080e7 jalr 922(ra) # 802006c6 <acquire>
+ wakeup1(initproc);
+ 80202334: 1184b503 ld a0,280(s1)
+ 80202338: fffff097 auipc ra,0xfffff
+ 8020233c: 518080e7 jalr 1304(ra) # 80201850 <wakeup1>
+ release(&initproc->lock);
+ 80202340: 1184b503 ld a0,280(s1)
+ 80202344: ffffe097 auipc ra,0xffffe
+ 80202348: 3d6080e7 jalr 982(ra) # 8020071a <release>
+ acquire(&p->lock);
+ 8020234c: 854e mv a0,s3
+ 8020234e: ffffe097 auipc ra,0xffffe
+ 80202352: 378080e7 jalr 888(ra) # 802006c6 <acquire>
+ struct proc *original_parent = p->parent;
+ 80202356: 0209b483 ld s1,32(s3)
+ release(&p->lock);
+ 8020235a: 854e mv a0,s3
+ 8020235c: ffffe097 auipc ra,0xffffe
+ 80202360: 3be080e7 jalr 958(ra) # 8020071a <release>
+ acquire(&original_parent->lock);
+ 80202364: 8526 mv a0,s1
+ 80202366: ffffe097 auipc ra,0xffffe
+ 8020236a: 360080e7 jalr 864(ra) # 802006c6 <acquire>
+ acquire(&p->lock);
+ 8020236e: 854e mv a0,s3
+ 80202370: ffffe097 auipc ra,0xffffe
+ 80202374: 356080e7 jalr 854(ra) # 802006c6 <acquire>
+ reparent(p);
+ 80202378: 854e mv a0,s3
+ 8020237a: 00000097 auipc ra,0x0
+ 8020237e: d18080e7 jalr -744(ra) # 80202092 <reparent>
+ wakeup1(original_parent);
+ 80202382: 8526 mv a0,s1
+ 80202384: fffff097 auipc ra,0xfffff
+ 80202388: 4cc080e7 jalr 1228(ra) # 80201850 <wakeup1>
+ p->xstate = status;
+ 8020238c: 0349aa23 sw s4,52(s3)
+ p->state = ZOMBIE;
+ 80202390: 4791 li a5,4
+ 80202392: 00f9ac23 sw a5,24(s3)
+ release(&original_parent->lock);
+ 80202396: 8526 mv a0,s1
+ 80202398: ffffe097 auipc ra,0xffffe
+ 8020239c: 382080e7 jalr 898(ra) # 8020071a <release>
+ sched();
+ 802023a0: 00000097 auipc ra,0x0
+ 802023a4: e42080e7 jalr -446(ra) # 802021e2 <sched>
+ panic("zombie exit");
+ 802023a8: 00007517 auipc a0,0x7
+ 802023ac: 2f850513 addi a0,a0,760 # 802096a0 <digits+0x320>
+ 802023b0: ffffe097 auipc ra,0xffffe
+ 802023b4: d94080e7 jalr -620(ra) # 80200144 <panic>
+
+00000000802023b8 <yield>:
+{
+ 802023b8: 1101 addi sp,sp,-32
+ 802023ba: ec06 sd ra,24(sp)
+ 802023bc: e822 sd s0,16(sp)
+ 802023be: e426 sd s1,8(sp)
+ 802023c0: 1000 addi s0,sp,32
+ struct proc *p = myproc();
+ 802023c2: fffff097 auipc ra,0xfffff
+ 802023c6: 67a080e7 jalr 1658(ra) # 80201a3c <myproc>
+ 802023ca: 84aa mv s1,a0
+ acquire(&p->lock);
+ 802023cc: ffffe097 auipc ra,0xffffe
+ 802023d0: 2fa080e7 jalr 762(ra) # 802006c6 <acquire>
+ p->state = RUNNABLE;
+ 802023d4: 4789 li a5,2
+ 802023d6: cc9c sw a5,24(s1)
+ sched();
+ 802023d8: 00000097 auipc ra,0x0
+ 802023dc: e0a080e7 jalr -502(ra) # 802021e2 <sched>
+ release(&p->lock);
+ 802023e0: 8526 mv a0,s1
+ 802023e2: ffffe097 auipc ra,0xffffe
+ 802023e6: 338080e7 jalr 824(ra) # 8020071a <release>
+}
+ 802023ea: 60e2 ld ra,24(sp)
+ 802023ec: 6442 ld s0,16(sp)
+ 802023ee: 64a2 ld s1,8(sp)
+ 802023f0: 6105 addi sp,sp,32
+ 802023f2: 8082 ret
+
+00000000802023f4 <sleep>:
+{
+ 802023f4: 7179 addi sp,sp,-48
+ 802023f6: f406 sd ra,40(sp)
+ 802023f8: f022 sd s0,32(sp)
+ 802023fa: ec26 sd s1,24(sp)
+ 802023fc: e84a sd s2,16(sp)
+ 802023fe: e44e sd s3,8(sp)
+ 80202400: 1800 addi s0,sp,48
+ 80202402: 89aa mv s3,a0
+ 80202404: 892e mv s2,a1
+ struct proc *p = myproc();
+ 80202406: fffff097 auipc ra,0xfffff
+ 8020240a: 636080e7 jalr 1590(ra) # 80201a3c <myproc>
+ 8020240e: 84aa mv s1,a0
+ if(lk != &p->lock){ //DOC: sleeplock0
+ 80202410: 05250663 beq a0,s2,8020245c <sleep+0x68>
+ acquire(&p->lock); //DOC: sleeplock1
+ 80202414: ffffe097 auipc ra,0xffffe
+ 80202418: 2b2080e7 jalr 690(ra) # 802006c6 <acquire>
+ release(lk);
+ 8020241c: 854a mv a0,s2
+ 8020241e: ffffe097 auipc ra,0xffffe
+ 80202422: 2fc080e7 jalr 764(ra) # 8020071a <release>
+ p->chan = chan;
+ 80202426: 0334b423 sd s3,40(s1)
+ p->state = SLEEPING;
+ 8020242a: 4785 li a5,1
+ 8020242c: cc9c sw a5,24(s1)
+ sched();
+ 8020242e: 00000097 auipc ra,0x0
+ 80202432: db4080e7 jalr -588(ra) # 802021e2 <sched>
+ p->chan = 0;
+ 80202436: 0204b423 sd zero,40(s1)
+ release(&p->lock);
+ 8020243a: 8526 mv a0,s1
+ 8020243c: ffffe097 auipc ra,0xffffe
+ 80202440: 2de080e7 jalr 734(ra) # 8020071a <release>
+ acquire(lk);
+ 80202444: 854a mv a0,s2
+ 80202446: ffffe097 auipc ra,0xffffe
+ 8020244a: 280080e7 jalr 640(ra) # 802006c6 <acquire>
+}
+ 8020244e: 70a2 ld ra,40(sp)
+ 80202450: 7402 ld s0,32(sp)
+ 80202452: 64e2 ld s1,24(sp)
+ 80202454: 6942 ld s2,16(sp)
+ 80202456: 69a2 ld s3,8(sp)
+ 80202458: 6145 addi sp,sp,48
+ 8020245a: 8082 ret
+ p->chan = chan;
+ 8020245c: 03353423 sd s3,40(a0)
+ p->state = SLEEPING;
+ 80202460: 4785 li a5,1
+ 80202462: cd1c sw a5,24(a0)
+ sched();
+ 80202464: 00000097 auipc ra,0x0
+ 80202468: d7e080e7 jalr -642(ra) # 802021e2 <sched>
+ p->chan = 0;
+ 8020246c: 0204b423 sd zero,40(s1)
+ if(lk != &p->lock){
+ 80202470: bff9 j 8020244e <sleep+0x5a>
+
+0000000080202472 <wait>:
+{
+ 80202472: 715d addi sp,sp,-80
+ 80202474: e486 sd ra,72(sp)
+ 80202476: e0a2 sd s0,64(sp)
+ 80202478: fc26 sd s1,56(sp)
+ 8020247a: f84a sd s2,48(sp)
+ 8020247c: f44e sd s3,40(sp)
+ 8020247e: f052 sd s4,32(sp)
+ 80202480: ec56 sd s5,24(sp)
+ 80202482: e85a sd s6,16(sp)
+ 80202484: e45e sd s7,8(sp)
+ 80202486: 0880 addi s0,sp,80
+ 80202488: 8b2a mv s6,a0
+ struct proc *p = myproc();
+ 8020248a: fffff097 auipc ra,0xfffff
+ 8020248e: 5b2080e7 jalr 1458(ra) # 80201a3c <myproc>
+ 80202492: 892a mv s2,a0
+ acquire(&p->lock);
+ 80202494: ffffe097 auipc ra,0xffffe
+ 80202498: 232080e7 jalr 562(ra) # 802006c6 <acquire>
+ havekids = 0;
+ 8020249c: 4b81 li s7,0
+ if(np->state == ZOMBIE){
+ 8020249e: 4a11 li s4,4
+ havekids = 1;
+ 802024a0: 4a85 li s5,1
+ for(np = proc; np < &proc[NPROC]; np++){
+ 802024a2: 00016997 auipc s3,0x16
+ 802024a6: 64e98993 addi s3,s3,1614 # 80218af0 <bcache>
+ havekids = 0;
+ 802024aa: 875e mv a4,s7
+ for(np = proc; np < &proc[NPROC]; np++){
+ 802024ac: 00012497 auipc s1,0x12
+ 802024b0: cd448493 addi s1,s1,-812 # 80214180 <proc>
+ 802024b4: a8b9 j 80202512 <wait+0xa0>
+ pid = np->pid;
+ 802024b6: 0384a983 lw s3,56(s1)
+ if(addr != 0 && copyout2(addr, (char *)&np->xstate, sizeof(np->xstate)) < 0) {
+ 802024ba: 000b0c63 beqz s6,802024d2 <wait+0x60>
+ 802024be: 4611 li a2,4
+ 802024c0: 03448593 addi a1,s1,52
+ 802024c4: 855a mv a0,s6
+ 802024c6: fffff097 auipc ra,0xfffff
+ 802024ca: eac080e7 jalr -340(ra) # 80201372 <copyout2>
+ 802024ce: 02054263 bltz a0,802024f2 <wait+0x80>
+ freeproc(np);
+ 802024d2: 8526 mv a0,s1
+ 802024d4: fffff097 auipc ra,0xfffff
+ 802024d8: 73a080e7 jalr 1850(ra) # 80201c0e <freeproc>
+ release(&np->lock);
+ 802024dc: 8526 mv a0,s1
+ 802024de: ffffe097 auipc ra,0xffffe
+ 802024e2: 23c080e7 jalr 572(ra) # 8020071a <release>
+ release(&p->lock);
+ 802024e6: 854a mv a0,s2
+ 802024e8: ffffe097 auipc ra,0xffffe
+ 802024ec: 232080e7 jalr 562(ra) # 8020071a <release>
+ return pid;
+ 802024f0: a8a9 j 8020254a <wait+0xd8>
+ release(&np->lock);
+ 802024f2: 8526 mv a0,s1
+ 802024f4: ffffe097 auipc ra,0xffffe
+ 802024f8: 226080e7 jalr 550(ra) # 8020071a <release>
+ release(&p->lock);
+ 802024fc: 854a mv a0,s2
+ 802024fe: ffffe097 auipc ra,0xffffe
+ 80202502: 21c080e7 jalr 540(ra) # 8020071a <release>
+ return -1;
+ 80202506: 59fd li s3,-1
+ 80202508: a089 j 8020254a <wait+0xd8>
+ for(np = proc; np < &proc[NPROC]; np++){
+ 8020250a: 17848493 addi s1,s1,376
+ 8020250e: 03348463 beq s1,s3,80202536 <wait+0xc4>
+ if(np->parent == p){
+ 80202512: 709c ld a5,32(s1)
+ 80202514: ff279be3 bne a5,s2,8020250a <wait+0x98>
+ acquire(&np->lock);
+ 80202518: 8526 mv a0,s1
+ 8020251a: ffffe097 auipc ra,0xffffe
+ 8020251e: 1ac080e7 jalr 428(ra) # 802006c6 <acquire>
+ if(np->state == ZOMBIE){
+ 80202522: 4c9c lw a5,24(s1)
+ 80202524: f94789e3 beq a5,s4,802024b6 <wait+0x44>
+ release(&np->lock);
+ 80202528: 8526 mv a0,s1
+ 8020252a: ffffe097 auipc ra,0xffffe
+ 8020252e: 1f0080e7 jalr 496(ra) # 8020071a <release>
+ havekids = 1;
+ 80202532: 8756 mv a4,s5
+ 80202534: bfd9 j 8020250a <wait+0x98>
+ if(!havekids || p->killed){
+ 80202536: c701 beqz a4,8020253e <wait+0xcc>
+ 80202538: 03092783 lw a5,48(s2)
+ 8020253c: c39d beqz a5,80202562 <wait+0xf0>
+ release(&p->lock);
+ 8020253e: 854a mv a0,s2
+ 80202540: ffffe097 auipc ra,0xffffe
+ 80202544: 1da080e7 jalr 474(ra) # 8020071a <release>
+ return -1;
+ 80202548: 59fd li s3,-1
+}
+ 8020254a: 854e mv a0,s3
+ 8020254c: 60a6 ld ra,72(sp)
+ 8020254e: 6406 ld s0,64(sp)
+ 80202550: 74e2 ld s1,56(sp)
+ 80202552: 7942 ld s2,48(sp)
+ 80202554: 79a2 ld s3,40(sp)
+ 80202556: 7a02 ld s4,32(sp)
+ 80202558: 6ae2 ld s5,24(sp)
+ 8020255a: 6b42 ld s6,16(sp)
+ 8020255c: 6ba2 ld s7,8(sp)
+ 8020255e: 6161 addi sp,sp,80
+ 80202560: 8082 ret
+ sleep(p, &p->lock); //DOC: wait-sleep
+ 80202562: 85ca mv a1,s2
+ 80202564: 854a mv a0,s2
+ 80202566: 00000097 auipc ra,0x0
+ 8020256a: e8e080e7 jalr -370(ra) # 802023f4 <sleep>
+ havekids = 0;
+ 8020256e: bf35 j 802024aa <wait+0x38>
+
+0000000080202570 <wait4>:
+{
+ 80202570: 711d addi sp,sp,-96
+ 80202572: ec86 sd ra,88(sp)
+ 80202574: e8a2 sd s0,80(sp)
+ 80202576: e4a6 sd s1,72(sp)
+ 80202578: e0ca sd s2,64(sp)
+ 8020257a: fc4e sd s3,56(sp)
+ 8020257c: f852 sd s4,48(sp)
+ 8020257e: f456 sd s5,40(sp)
+ 80202580: f05a sd s6,32(sp)
+ 80202582: ec5e sd s7,24(sp)
+ 80202584: 1080 addi s0,sp,96
+ 80202586: 8a2e mv s4,a1
+ if(pid == -1) {
+ 80202588: 57fd li a5,-1
+ 8020258a: 02f51463 bne a0,a5,802025b2 <wait4+0x42>
+ return wait(addr);
+ 8020258e: 852e mv a0,a1
+ 80202590: 00000097 auipc ra,0x0
+ 80202594: ee2080e7 jalr -286(ra) # 80202472 <wait>
+ 80202598: 89aa mv s3,a0
+}
+ 8020259a: 854e mv a0,s3
+ 8020259c: 60e6 ld ra,88(sp)
+ 8020259e: 6446 ld s0,80(sp)
+ 802025a0: 64a6 ld s1,72(sp)
+ 802025a2: 6906 ld s2,64(sp)
+ 802025a4: 79e2 ld s3,56(sp)
+ 802025a6: 7a42 ld s4,48(sp)
+ 802025a8: 7aa2 ld s5,40(sp)
+ 802025aa: 7b02 ld s6,32(sp)
+ 802025ac: 6be2 ld s7,24(sp)
+ 802025ae: 6125 addi sp,sp,96
+ 802025b0: 8082 ret
+ struct proc *p = myproc();
+ 802025b2: fffff097 auipc ra,0xfffff
+ 802025b6: 48a080e7 jalr 1162(ra) # 80201a3c <myproc>
+ 802025ba: 892a mv s2,a0
+ acquire(&p->lock);
+ 802025bc: ffffe097 auipc ra,0xffffe
+ 802025c0: 10a080e7 jalr 266(ra) # 802006c6 <acquire>
+ havekids = 0;
+ 802025c4: 4b81 li s7,0
+ if(np->state == ZOMBIE){
+ 802025c6: 4a91 li s5,4
+ havekids = 1;
+ 802025c8: 4b05 li s6,1
+ for(np = proc; np < &proc[NPROC]; np++){
+ 802025ca: 00016997 auipc s3,0x16
+ 802025ce: 52698993 addi s3,s3,1318 # 80218af0 <bcache>
+ havekids = 0;
+ 802025d2: 875e mv a4,s7
+ for(np = proc; np < &proc[NPROC]; np++){
+ 802025d4: 00012497 auipc s1,0x12
+ 802025d8: bac48493 addi s1,s1,-1108 # 80214180 <proc>
+ 802025dc: a0a5 j 80202644 <wait4+0xd4>
+ pid = np->pid;
+ 802025de: 0384a983 lw s3,56(s1)
+ status = np->xstate << 8;
+ 802025e2: 58dc lw a5,52(s1)
+ 802025e4: 0087979b slliw a5,a5,0x8
+ 802025e8: faf42623 sw a5,-84(s0)
+ if(addr != 0 && copyout2(addr, (char *)&status, sizeof(status)) < 0) {
+ 802025ec: 000a0c63 beqz s4,80202604 <wait4+0x94>
+ 802025f0: 4611 li a2,4
+ 802025f2: fac40593 addi a1,s0,-84
+ 802025f6: 8552 mv a0,s4
+ 802025f8: fffff097 auipc ra,0xfffff
+ 802025fc: d7a080e7 jalr -646(ra) # 80201372 <copyout2>
+ 80202600: 02054263 bltz a0,80202624 <wait4+0xb4>
+ freeproc(np);
+ 80202604: 8526 mv a0,s1
+ 80202606: fffff097 auipc ra,0xfffff
+ 8020260a: 608080e7 jalr 1544(ra) # 80201c0e <freeproc>
+ release(&np->lock);
+ 8020260e: 8526 mv a0,s1
+ 80202610: ffffe097 auipc ra,0xffffe
+ 80202614: 10a080e7 jalr 266(ra) # 8020071a <release>
+ release(&p->lock);
+ 80202618: 854a mv a0,s2
+ 8020261a: ffffe097 auipc ra,0xffffe
+ 8020261e: 100080e7 jalr 256(ra) # 8020071a <release>
+ return pid;
+ 80202622: bfa5 j 8020259a <wait4+0x2a>
+ release(&np->lock);
+ 80202624: 8526 mv a0,s1
+ 80202626: ffffe097 auipc ra,0xffffe
+ 8020262a: 0f4080e7 jalr 244(ra) # 8020071a <release>
+ release(&p->lock);
+ 8020262e: 854a mv a0,s2
+ 80202630: ffffe097 auipc ra,0xffffe
+ 80202634: 0ea080e7 jalr 234(ra) # 8020071a <release>
+ return -1;
+ 80202638: 59fd li s3,-1
+ 8020263a: b785 j 8020259a <wait4+0x2a>
+ for(np = proc; np < &proc[NPROC]; np++){
+ 8020263c: 17848493 addi s1,s1,376
+ 80202640: 03348463 beq s1,s3,80202668 <wait4+0xf8>
+ if(np->parent == p){
+ 80202644: 709c ld a5,32(s1)
+ 80202646: ff279be3 bne a5,s2,8020263c <wait4+0xcc>
+ acquire(&np->lock);
+ 8020264a: 8526 mv a0,s1
+ 8020264c: ffffe097 auipc ra,0xffffe
+ 80202650: 07a080e7 jalr 122(ra) # 802006c6 <acquire>
+ if(np->state == ZOMBIE){
+ 80202654: 4c9c lw a5,24(s1)
+ 80202656: f95784e3 beq a5,s5,802025de <wait4+0x6e>
+ release(&np->lock);
+ 8020265a: 8526 mv a0,s1
+ 8020265c: ffffe097 auipc ra,0xffffe
+ 80202660: 0be080e7 jalr 190(ra) # 8020071a <release>
+ havekids = 1;
+ 80202664: 875a mv a4,s6
+ 80202666: bfd9 j 8020263c <wait4+0xcc>
+ if(!havekids || p->killed){
+ 80202668: c701 beqz a4,80202670 <wait4+0x100>
+ 8020266a: 03092783 lw a5,48(s2)
+ 8020266e: cb81 beqz a5,8020267e <wait4+0x10e>
+ release(&p->lock);
+ 80202670: 854a mv a0,s2
+ 80202672: ffffe097 auipc ra,0xffffe
+ 80202676: 0a8080e7 jalr 168(ra) # 8020071a <release>
+ return -1;
+ 8020267a: 59fd li s3,-1
+ 8020267c: bf39 j 8020259a <wait4+0x2a>
+ sleep(p, &p->lock); //DOC: wait-sleep
+ 8020267e: 85ca mv a1,s2
+ 80202680: 854a mv a0,s2
+ 80202682: 00000097 auipc ra,0x0
+ 80202686: d72080e7 jalr -654(ra) # 802023f4 <sleep>
+ havekids = 0;
+ 8020268a: b7a1 j 802025d2 <wait4+0x62>
+
+000000008020268c <wakeup>:
+{
+ 8020268c: 7139 addi sp,sp,-64
+ 8020268e: fc06 sd ra,56(sp)
+ 80202690: f822 sd s0,48(sp)
+ 80202692: f426 sd s1,40(sp)
+ 80202694: f04a sd s2,32(sp)
+ 80202696: ec4e sd s3,24(sp)
+ 80202698: e852 sd s4,16(sp)
+ 8020269a: e456 sd s5,8(sp)
+ 8020269c: 0080 addi s0,sp,64
+ 8020269e: 8a2a mv s4,a0
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802026a0: 00012497 auipc s1,0x12
+ 802026a4: ae048493 addi s1,s1,-1312 # 80214180 <proc>
+ if(p->state == SLEEPING && p->chan == chan) {
+ 802026a8: 4985 li s3,1
+ p->state = RUNNABLE;
+ 802026aa: 4a89 li s5,2
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802026ac: 00016917 auipc s2,0x16
+ 802026b0: 44490913 addi s2,s2,1092 # 80218af0 <bcache>
+ 802026b4: a811 j 802026c8 <wakeup+0x3c>
+ release(&p->lock);
+ 802026b6: 8526 mv a0,s1
+ 802026b8: ffffe097 auipc ra,0xffffe
+ 802026bc: 062080e7 jalr 98(ra) # 8020071a <release>
+ for(p = proc; p < &proc[NPROC]; p++) {
+ 802026c0: 17848493 addi s1,s1,376
+ 802026c4: 03248063 beq s1,s2,802026e4 <wakeup+0x58>
+ acquire(&p->lock);
+ 802026c8: 8526 mv a0,s1
+ 802026ca: ffffe097 auipc ra,0xffffe
+ 802026ce: ffc080e7 jalr -4(ra) # 802006c6 <acquire>
+ if(p->state == SLEEPING && p->chan == chan) {
+ 802026d2: 4c9c lw a5,24(s1)
+ 802026d4: ff3791e3 bne a5,s3,802026b6 <wakeup+0x2a>
+ 802026d8: 749c ld a5,40(s1)
+ 802026da: fd479ee3 bne a5,s4,802026b6 <wakeup+0x2a>
+ p->state = RUNNABLE;
+ 802026de: 0154ac23 sw s5,24(s1)
+ 802026e2: bfd1 j 802026b6 <wakeup+0x2a>
+}
+ 802026e4: 70e2 ld ra,56(sp)
+ 802026e6: 7442 ld s0,48(sp)
+ 802026e8: 74a2 ld s1,40(sp)
+ 802026ea: 7902 ld s2,32(sp)
+ 802026ec: 69e2 ld s3,24(sp)
+ 802026ee: 6a42 ld s4,16(sp)
+ 802026f0: 6aa2 ld s5,8(sp)
+ 802026f2: 6121 addi sp,sp,64
+ 802026f4: 8082 ret
+
+00000000802026f6 <kill>:
+// Kill the process with the given pid.
+// The victim won't exit until it tries to return
+// to user space (see usertrap() in trap.c).
+int
+kill(int pid)
+{
+ 802026f6: 7179 addi sp,sp,-48
+ 802026f8: f406 sd ra,40(sp)
+ 802026fa: f022 sd s0,32(sp)
+ 802026fc: ec26 sd s1,24(sp)
+ 802026fe: e84a sd s2,16(sp)
+ 80202700: e44e sd s3,8(sp)
+ 80202702: 1800 addi s0,sp,48
+ 80202704: 892a mv s2,a0
+ struct proc *p;
+
+ for(p = proc; p < &proc[NPROC]; p++){
+ 80202706: 00012497 auipc s1,0x12
+ 8020270a: a7a48493 addi s1,s1,-1414 # 80214180 <proc>
+ 8020270e: 00016997 auipc s3,0x16
+ 80202712: 3e298993 addi s3,s3,994 # 80218af0 <bcache>
+ acquire(&p->lock);
+ 80202716: 8526 mv a0,s1
+ 80202718: ffffe097 auipc ra,0xffffe
+ 8020271c: fae080e7 jalr -82(ra) # 802006c6 <acquire>
+ if(p->pid == pid){
+ 80202720: 5c9c lw a5,56(s1)
+ 80202722: 01278d63 beq a5,s2,8020273c <kill+0x46>
+ p->state = RUNNABLE;
+ }
+ release(&p->lock);
+ return 0;
+ }
+ release(&p->lock);
+ 80202726: 8526 mv a0,s1
+ 80202728: ffffe097 auipc ra,0xffffe
+ 8020272c: ff2080e7 jalr -14(ra) # 8020071a <release>
+ for(p = proc; p < &proc[NPROC]; p++){
+ 80202730: 17848493 addi s1,s1,376
+ 80202734: ff3491e3 bne s1,s3,80202716 <kill+0x20>
+ }
+ return -1;
+ 80202738: 557d li a0,-1
+ 8020273a: a821 j 80202752 <kill+0x5c>
+ p->killed = 1;
+ 8020273c: 4785 li a5,1
+ 8020273e: d89c sw a5,48(s1)
+ if(p->state == SLEEPING){
+ 80202740: 4c98 lw a4,24(s1)
+ 80202742: 00f70f63 beq a4,a5,80202760 <kill+0x6a>
+ release(&p->lock);
+ 80202746: 8526 mv a0,s1
+ 80202748: ffffe097 auipc ra,0xffffe
+ 8020274c: fd2080e7 jalr -46(ra) # 8020071a <release>
+ return 0;
+ 80202750: 4501 li a0,0
+}
+ 80202752: 70a2 ld ra,40(sp)
+ 80202754: 7402 ld s0,32(sp)
+ 80202756: 64e2 ld s1,24(sp)
+ 80202758: 6942 ld s2,16(sp)
+ 8020275a: 69a2 ld s3,8(sp)
+ 8020275c: 6145 addi sp,sp,48
+ 8020275e: 8082 ret
+ p->state = RUNNABLE;
+ 80202760: 4789 li a5,2
+ 80202762: cc9c sw a5,24(s1)
+ 80202764: b7cd j 80202746 <kill+0x50>
+
+0000000080202766 <either_copyout>:
+// Copy to either a user address, or kernel address,
+// depending on usr_dst.
+// Returns 0 on success, -1 on error.
+int
+either_copyout(int user_dst, uint64 dst, void *src, uint64 len)
+{
+ 80202766: 1101 addi sp,sp,-32
+ 80202768: ec06 sd ra,24(sp)
+ 8020276a: e822 sd s0,16(sp)
+ 8020276c: e426 sd s1,8(sp)
+ 8020276e: 1000 addi s0,sp,32
+ 80202770: 84aa mv s1,a0
+ 80202772: 852e mv a0,a1
+ 80202774: 85b2 mv a1,a2
+ 80202776: 8636 mv a2,a3
+ // struct proc *p = myproc();
+ if(user_dst){
+ 80202778: c891 beqz s1,8020278c <either_copyout+0x26>
+ // return copyout(p->pagetable, dst, src, len);
+ return copyout2(dst, src, len);
+ 8020277a: fffff097 auipc ra,0xfffff
+ 8020277e: bf8080e7 jalr -1032(ra) # 80201372 <copyout2>
+ } else {
+ memmove((char *)dst, src, len);
+ return 0;
+ }
+}
+ 80202782: 60e2 ld ra,24(sp)
+ 80202784: 6442 ld s0,16(sp)
+ 80202786: 64a2 ld s1,8(sp)
+ 80202788: 6105 addi sp,sp,32
+ 8020278a: 8082 ret
+ memmove((char *)dst, src, len);
+ 8020278c: 0006861b sext.w a2,a3
+ 80202790: ffffe097 auipc ra,0xffffe
+ 80202794: 02e080e7 jalr 46(ra) # 802007be <memmove>
+ return 0;
+ 80202798: 8526 mv a0,s1
+ 8020279a: b7e5 j 80202782 <either_copyout+0x1c>
+
+000000008020279c <either_copyin>:
+// Copy from either a user address, or kernel address,
+// depending on usr_src.
+// Returns 0 on success, -1 on error.
+int
+either_copyin(void *dst, int user_src, uint64 src, uint64 len)
+{
+ 8020279c: 1101 addi sp,sp,-32
+ 8020279e: ec06 sd ra,24(sp)
+ 802027a0: e822 sd s0,16(sp)
+ 802027a2: e426 sd s1,8(sp)
+ 802027a4: 1000 addi s0,sp,32
+ 802027a6: 84ae mv s1,a1
+ 802027a8: 85b2 mv a1,a2
+ 802027aa: 8636 mv a2,a3
+ // struct proc *p = myproc();
+ if(user_src){
+ 802027ac: c891 beqz s1,802027c0 <either_copyin+0x24>
+ // return copyin(p->pagetable, dst, src, len);
+ return copyin2(dst, src, len);
+ 802027ae: fffff097 auipc ra,0xfffff
+ 802027b2: ca4080e7 jalr -860(ra) # 80201452 <copyin2>
+ } else {
+ memmove(dst, (char*)src, len);
+ return 0;
+ }
+}
+ 802027b6: 60e2 ld ra,24(sp)
+ 802027b8: 6442 ld s0,16(sp)
+ 802027ba: 64a2 ld s1,8(sp)
+ 802027bc: 6105 addi sp,sp,32
+ 802027be: 8082 ret
+ memmove(dst, (char*)src, len);
+ 802027c0: 0006861b sext.w a2,a3
+ 802027c4: ffffe097 auipc ra,0xffffe
+ 802027c8: ffa080e7 jalr -6(ra) # 802007be <memmove>
+ return 0;
+ 802027cc: 8526 mv a0,s1
+ 802027ce: b7e5 j 802027b6 <either_copyin+0x1a>
+
+00000000802027d0 <procdump>:
+// Print a process listing to console. For debugging.
+// Runs when user types ^P on console.
+// No lock to avoid wedging a stuck machine further.
+void
+procdump(void)
+{
+ 802027d0: 715d addi sp,sp,-80
+ 802027d2: e486 sd ra,72(sp)
+ 802027d4: e0a2 sd s0,64(sp)
+ 802027d6: fc26 sd s1,56(sp)
+ 802027d8: f84a sd s2,48(sp)
+ 802027da: f44e sd s3,40(sp)
+ 802027dc: f052 sd s4,32(sp)
+ 802027de: ec56 sd s5,24(sp)
+ 802027e0: e85a sd s6,16(sp)
+ 802027e2: e45e sd s7,8(sp)
+ 802027e4: 0880 addi s0,sp,80
+ [ZOMBIE] "zombie"
+ };
+ struct proc *p;
+ char *state;
+
+ printf("\nPID\tSTATE\tNAME\tMEM\n");
+ 802027e6: 00007517 auipc a0,0x7
+ 802027ea: ed250513 addi a0,a0,-302 # 802096b8 <digits+0x338>
+ 802027ee: ffffe097 auipc ra,0xffffe
+ 802027f2: 9a0080e7 jalr -1632(ra) # 8020018e <printf>
+ for(p = proc; p < &proc[NPROC]; p++){
+ 802027f6: 00012497 auipc s1,0x12
+ 802027fa: aea48493 addi s1,s1,-1302 # 802142e0 <proc+0x160>
+ 802027fe: 00016917 auipc s2,0x16
+ 80202802: 45290913 addi s2,s2,1106 # 80218c50 <bcache+0x160>
+ if(p->state == UNUSED)
+ continue;
+ if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
+ 80202806: 4b11 li s6,4
+ state = states[p->state];
+ else
+ state = "???";
+ 80202808: 00007997 auipc s3,0x7
+ 8020280c: ea898993 addi s3,s3,-344 # 802096b0 <digits+0x330>
+ printf("%d\t%s\t%s\t%d", p->pid, state, p->name, p->sz);
+ 80202810: 00007a97 auipc s5,0x7
+ 80202814: ec0a8a93 addi s5,s5,-320 # 802096d0 <digits+0x350>
+ printf("\n");
+ 80202818: 00007a17 auipc s4,0x7
+ 8020281c: 8c0a0a13 addi s4,s4,-1856 # 802090d8 <etext+0xd8>
+ if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
+ 80202820: 00008b97 auipc s7,0x8
+ 80202824: 428b8b93 addi s7,s7,1064 # 8020ac48 <states.0>
+ 80202828: a01d j 8020284e <procdump+0x7e>
+ printf("%d\t%s\t%s\t%d", p->pid, state, p->name, p->sz);
+ 8020282a: ee86b703 ld a4,-280(a3)
+ 8020282e: ed86a583 lw a1,-296(a3)
+ 80202832: 8556 mv a0,s5
+ 80202834: ffffe097 auipc ra,0xffffe
+ 80202838: 95a080e7 jalr -1702(ra) # 8020018e <printf>
+ printf("\n");
+ 8020283c: 8552 mv a0,s4
+ 8020283e: ffffe097 auipc ra,0xffffe
+ 80202842: 950080e7 jalr -1712(ra) # 8020018e <printf>
+ for(p = proc; p < &proc[NPROC]; p++){
+ 80202846: 17848493 addi s1,s1,376
+ 8020284a: 03248263 beq s1,s2,8020286e <procdump+0x9e>
+ if(p->state == UNUSED)
+ 8020284e: 86a6 mv a3,s1
+ 80202850: eb84a783 lw a5,-328(s1)
+ 80202854: dbed beqz a5,80202846 <procdump+0x76>
+ state = "???";
+ 80202856: 864e mv a2,s3
+ if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
+ 80202858: fcfb69e3 bltu s6,a5,8020282a <procdump+0x5a>
+ 8020285c: 02079713 slli a4,a5,0x20
+ 80202860: 01d75793 srli a5,a4,0x1d
+ 80202864: 97de add a5,a5,s7
+ 80202866: 6390 ld a2,0(a5)
+ 80202868: f269 bnez a2,8020282a <procdump+0x5a>
+ state = "???";
+ 8020286a: 864e mv a2,s3
+ 8020286c: bf7d j 8020282a <procdump+0x5a>
+ }
+}
+ 8020286e: 60a6 ld ra,72(sp)
+ 80202870: 6406 ld s0,64(sp)
+ 80202872: 74e2 ld s1,56(sp)
+ 80202874: 7942 ld s2,48(sp)
+ 80202876: 79a2 ld s3,40(sp)
+ 80202878: 7a02 ld s4,32(sp)
+ 8020287a: 6ae2 ld s5,24(sp)
+ 8020287c: 6b42 ld s6,16(sp)
+ 8020287e: 6ba2 ld s7,8(sp)
+ 80202880: 6161 addi sp,sp,80
+ 80202882: 8082 ret
+
+0000000080202884 <procnum>:
+
+uint64
+procnum(void)
+{
+ 80202884: 1141 addi sp,sp,-16
+ 80202886: e422 sd s0,8(sp)
+ 80202888: 0800 addi s0,sp,16
+ int num = 0;
+ struct proc *p;
+
+ for (p = proc; p < &proc[NPROC]; p++) {
+ 8020288a: 00012797 auipc a5,0x12
+ 8020288e: 8f678793 addi a5,a5,-1802 # 80214180 <proc>
+ int num = 0;
+ 80202892: 4501 li a0,0
+ for (p = proc; p < &proc[NPROC]; p++) {
+ 80202894: 00016697 auipc a3,0x16
+ 80202898: 25c68693 addi a3,a3,604 # 80218af0 <bcache>
+ 8020289c: a029 j 802028a6 <procnum+0x22>
+ 8020289e: 17878793 addi a5,a5,376
+ 802028a2: 00d78663 beq a5,a3,802028ae <procnum+0x2a>
+ if (p->state != UNUSED) {
+ 802028a6: 4f98 lw a4,24(a5)
+ 802028a8: db7d beqz a4,8020289e <procnum+0x1a>
+ num++;
+ 802028aa: 2505 addiw a0,a0,1
+ 802028ac: bfcd j 8020289e <procnum+0x1a>
+ }
+ }
+
+ return num;
+}
+ 802028ae: 6422 ld s0,8(sp)
+ 802028b0: 0141 addi sp,sp,16
+ 802028b2: 8082 ret
+
+00000000802028b4 <swtch>:
+ 802028b4: 00153023 sd ra,0(a0)
+ 802028b8: 00253423 sd sp,8(a0)
+ 802028bc: e900 sd s0,16(a0)
+ 802028be: ed04 sd s1,24(a0)
+ 802028c0: 03253023 sd s2,32(a0)
+ 802028c4: 03353423 sd s3,40(a0)
+ 802028c8: 03453823 sd s4,48(a0)
+ 802028cc: 03553c23 sd s5,56(a0)
+ 802028d0: 05653023 sd s6,64(a0)
+ 802028d4: 05753423 sd s7,72(a0)
+ 802028d8: 05853823 sd s8,80(a0)
+ 802028dc: 05953c23 sd s9,88(a0)
+ 802028e0: 07a53023 sd s10,96(a0)
+ 802028e4: 07b53423 sd s11,104(a0)
+ 802028e8: 0005b083 ld ra,0(a1)
+ 802028ec: 0085b103 ld sp,8(a1)
+ 802028f0: 6980 ld s0,16(a1)
+ 802028f2: 6d84 ld s1,24(a1)
+ 802028f4: 0205b903 ld s2,32(a1)
+ 802028f8: 0285b983 ld s3,40(a1)
+ 802028fc: 0305ba03 ld s4,48(a1)
+ 80202900: 0385ba83 ld s5,56(a1)
+ 80202904: 0405bb03 ld s6,64(a1)
+ 80202908: 0485bb83 ld s7,72(a1)
+ 8020290c: 0505bc03 ld s8,80(a1)
+ 80202910: 0585bc83 ld s9,88(a1)
+ 80202914: 0605bd03 ld s10,96(a1)
+ 80202918: 0685bd83 ld s11,104(a1)
+ 8020291c: 8082 ret
+
+000000008020291e <trapinithart>:
+// }
+
+// set up to take exceptions and traps while in the kernel.
+void
+trapinithart(void)
+{
+ 8020291e: 1141 addi sp,sp,-16
+ 80202920: e406 sd ra,8(sp)
+ 80202922: e022 sd s0,0(sp)
+ 80202924: 0800 addi s0,sp,16
+ asm volatile("csrw stvec, %0" : : "r" (x));
+ 80202926: 00009797 auipc a5,0x9
+ 8020292a: 3ca7b783 ld a5,970(a5) # 8020bcf0 <_GLOBAL_OFFSET_TABLE_+0x18>
+ 8020292e: 10579073 csrw stvec,a5
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202932: 100027f3 csrr a5,sstatus
+ w_stvec((uint64)kernelvec);
+ w_sstatus(r_sstatus() | SSTATUS_SIE);
+ 80202936: 0027e793 ori a5,a5,2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 8020293a: 10079073 csrw sstatus,a5
+ asm volatile("csrr %0, sie" : "=r" (x) );
+ 8020293e: 104027f3 csrr a5,sie
+ // enable supervisor-mode timer interrupts.
+ w_sie(r_sie() | SIE_SEIE | SIE_SSIE | SIE_STIE);
+ 80202942: 2227e793 ori a5,a5,546
+ asm volatile("csrw sie, %0" : : "r" (x));
+ 80202946: 10479073 csrw sie,a5
+ set_next_timeout();
+ 8020294a: 00003097 auipc ra,0x3
+ 8020294e: afc080e7 jalr -1284(ra) # 80205446 <set_next_timeout>
+ #ifdef DEBUG
+ printf("trapinithart\n");
+ #endif
+}
+ 80202952: 60a2 ld ra,8(sp)
+ 80202954: 6402 ld s0,0(sp)
+ 80202956: 0141 addi sp,sp,16
+ 80202958: 8082 ret
+
+000000008020295a <usertrapret>:
+//
+// return to user space
+//
+void
+usertrapret(void)
+{
+ 8020295a: 1141 addi sp,sp,-16
+ 8020295c: e406 sd ra,8(sp)
+ 8020295e: e022 sd s0,0(sp)
+ 80202960: 0800 addi s0,sp,16
+ struct proc *p = myproc();
+ 80202962: fffff097 auipc ra,0xfffff
+ 80202966: 0da080e7 jalr 218(ra) # 80201a3c <myproc>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 8020296a: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() & ~SSTATUS_SIE);
+ 8020296e: 9bf5 andi a5,a5,-3
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 80202970: 10079073 csrw sstatus,a5
+ // kerneltrap() to usertrap(), so turn off interrupts until
+ // we're back in user space, where usertrap() is correct.
+ intr_off();
+
+ // send syscalls, interrupts, and exceptions to trampoline.S
+ w_stvec(TRAMPOLINE + (uservec - trampoline));
+ 80202974: 00009697 auipc a3,0x9
+ 80202978: 36c6b683 ld a3,876(a3) # 8020bce0 <_GLOBAL_OFFSET_TABLE_+0x8>
+ 8020297c: 00009717 auipc a4,0x9
+ 80202980: 39473703 ld a4,916(a4) # 8020bd10 <_GLOBAL_OFFSET_TABLE_+0x38>
+ 80202984: 8f15 sub a4,a4,a3
+ 80202986: 040007b7 lui a5,0x4000
+ 8020298a: 17fd addi a5,a5,-1 # 3ffffff <_entry-0x7c200001>
+ 8020298c: 07b2 slli a5,a5,0xc
+ 8020298e: 973e add a4,a4,a5
+ asm volatile("csrw stvec, %0" : : "r" (x));
+ 80202990: 10571073 csrw stvec,a4
+
+ // set up trapframe values that uservec will need when
+ // the process next re-enters the kernel.
+ p->trapframe->kernel_satp = r_satp(); // kernel page table
+ 80202994: 7138 ld a4,96(a0)
+ asm volatile("csrr %0, satp" : "=r" (x) );
+ 80202996: 18002673 csrr a2,satp
+ 8020299a: e310 sd a2,0(a4)
+ p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack
+ 8020299c: 7130 ld a2,96(a0)
+ 8020299e: 6138 ld a4,64(a0)
+ 802029a0: 6585 lui a1,0x1
+ 802029a2: 972e add a4,a4,a1
+ 802029a4: e618 sd a4,8(a2)
+ p->trapframe->kernel_trap = (uint64)usertrap;
+ 802029a6: 7138 ld a4,96(a0)
+ 802029a8: 00000617 auipc a2,0x0
+ 802029ac: 0f460613 addi a2,a2,244 # 80202a9c <usertrap>
+ 802029b0: eb10 sd a2,16(a4)
+ p->trapframe->kernel_hartid = r_tp(); // hartid for cpuid()
+ 802029b2: 7138 ld a4,96(a0)
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 802029b4: 8612 mv a2,tp
+ 802029b6: f310 sd a2,32(a4)
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 802029b8: 10002773 csrr a4,sstatus
+ // set up the registers that trampoline.S's sret will use
+ // to get to user space.
+
+ // set S Previous Privilege mode to User.
+ unsigned long x = r_sstatus();
+ x &= ~SSTATUS_SPP; // clear SPP to 0 for user mode
+ 802029bc: eff77713 andi a4,a4,-257
+ x |= SSTATUS_SPIE; // enable interrupts in user mode
+ 802029c0: 02076713 ori a4,a4,32
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 802029c4: 10071073 csrw sstatus,a4
+ w_sstatus(x);
+
+ // set S Exception Program Counter to the saved user pc.
+ w_sepc(p->trapframe->epc);
+ 802029c8: 7138 ld a4,96(a0)
+ asm volatile("csrw sepc, %0" : : "r" (x));
+ 802029ca: 6f18 ld a4,24(a4)
+ 802029cc: 14171073 csrw sepc,a4
+
+ // tell trampoline.S the user page table to switch to.
+ // printf("[usertrapret]p->pagetable: %p\n", p->pagetable);
+ uint64 satp = MAKE_SATP(p->pagetable);
+ 802029d0: 692c ld a1,80(a0)
+ 802029d2: 81b1 srli a1,a1,0xc
+
+ // jump to trampoline.S at the top of memory, which
+ // switches to the user page table, restores user registers,
+ // and switches to user mode with sret.
+ uint64 fn = TRAMPOLINE + (userret - trampoline);
+ 802029d4: 00009717 auipc a4,0x9
+ 802029d8: 31473703 ld a4,788(a4) # 8020bce8 <_GLOBAL_OFFSET_TABLE_+0x10>
+ 802029dc: 8f15 sub a4,a4,a3
+ 802029de: 97ba add a5,a5,a4
+ ((void (*)(uint64,uint64))fn)(TRAPFRAME, satp);
+ 802029e0: 577d li a4,-1
+ 802029e2: 177e slli a4,a4,0x3f
+ 802029e4: 8dd9 or a1,a1,a4
+ 802029e6: 02000537 lui a0,0x2000
+ 802029ea: 157d addi a0,a0,-1 # 1ffffff <_entry-0x7e200001>
+ 802029ec: 0536 slli a0,a0,0xd
+ 802029ee: 9782 jalr a5
+}
+ 802029f0: 60a2 ld ra,8(sp)
+ 802029f2: 6402 ld s0,0(sp)
+ 802029f4: 0141 addi sp,sp,16
+ 802029f6: 8082 ret
+
+00000000802029f8 <devintr>:
+// Check if it's an external/software interrupt,
+// and handle it.
+// returns 2 if timer interrupt,
+// 1 if other device,
+// 0 if not recognized.
+int devintr(void) {
+ 802029f8: 1101 addi sp,sp,-32
+ 802029fa: ec06 sd ra,24(sp)
+ 802029fc: e822 sd s0,16(sp)
+ 802029fe: e426 sd s1,8(sp)
+ 80202a00: 1000 addi s0,sp,32
+ asm volatile("csrr %0, scause" : "=r" (x) );
+ 80202a02: 14202773 csrr a4,scause
+ uint64 scause = r_scause();
+
+ #ifdef QEMU
+ // handle external interrupt
+ if ((0x8000000000000000L & scause) && 9 == (scause & 0xff))
+ 80202a06: 00074d63 bltz a4,80202a20 <devintr+0x28>
+ sbi_set_mie();
+ #endif
+
+ return 1;
+ }
+ else if (0x8000000000000005L == scause) {
+ 80202a0a: 57fd li a5,-1
+ 80202a0c: 17fe slli a5,a5,0x3f
+ 80202a0e: 0795 addi a5,a5,5
+ timer_tick();
+ return 2;
+ }
+ else { return 0;}
+ 80202a10: 4501 li a0,0
+ else if (0x8000000000000005L == scause) {
+ 80202a12: 06f70f63 beq a4,a5,80202a90 <devintr+0x98>
+}
+ 80202a16: 60e2 ld ra,24(sp)
+ 80202a18: 6442 ld s0,16(sp)
+ 80202a1a: 64a2 ld s1,8(sp)
+ 80202a1c: 6105 addi sp,sp,32
+ 80202a1e: 8082 ret
+ if ((0x8000000000000000L & scause) && 9 == (scause & 0xff))
+ 80202a20: 0ff77793 zext.b a5,a4
+ 80202a24: 46a5 li a3,9
+ 80202a26: fed792e3 bne a5,a3,80202a0a <devintr+0x12>
+ int irq = plic_claim();
+ 80202a2a: 00004097 auipc ra,0x4
+ 80202a2e: 480080e7 jalr 1152(ra) # 80206eaa <plic_claim>
+ 80202a32: 84aa mv s1,a0
+ if (UART_IRQ == irq) {
+ 80202a34: 47a9 li a5,10
+ 80202a36: 02f50163 beq a0,a5,80202a58 <devintr+0x60>
+ else if (DISK_IRQ == irq) {
+ 80202a3a: 4785 li a5,1
+ 80202a3c: 04f50563 beq a0,a5,80202a86 <devintr+0x8e>
+ return 1;
+ 80202a40: 4505 li a0,1
+ else if (irq) {
+ 80202a42: d8f1 beqz s1,80202a16 <devintr+0x1e>
+ printf("unexpected interrupt irq = %d\n", irq);
+ 80202a44: 85a6 mv a1,s1
+ 80202a46: 00007517 auipc a0,0x7
+ 80202a4a: cc250513 addi a0,a0,-830 # 80209708 <digits+0x388>
+ 80202a4e: ffffd097 auipc ra,0xffffd
+ 80202a52: 740080e7 jalr 1856(ra) # 8020018e <printf>
+ 80202a56: a821 j 80202a6e <devintr+0x76>
+ return SBI_CALL_0(SBI_CONSOLE_GETCHAR);
+ 80202a58: 4501 li a0,0
+ 80202a5a: 4581 li a1,0
+ 80202a5c: 4601 li a2,0
+ 80202a5e: 4681 li a3,0
+ 80202a60: 4889 li a7,2
+ 80202a62: 00000073 ecall
+ 80202a66: 2501 sext.w a0,a0
+ if (-1 != c) {
+ 80202a68: 57fd li a5,-1
+ 80202a6a: 00f51963 bne a0,a5,80202a7c <devintr+0x84>
+ if (irq) { plic_complete(irq);}
+ 80202a6e: 8526 mv a0,s1
+ 80202a70: 00004097 auipc ra,0x4
+ 80202a74: 464080e7 jalr 1124(ra) # 80206ed4 <plic_complete>
+ return 1;
+ 80202a78: 4505 li a0,1
+ 80202a7a: bf71 j 80202a16 <devintr+0x1e>
+ consoleintr(c);
+ 80202a7c: 00004097 auipc ra,0x4
+ 80202a80: 66c080e7 jalr 1644(ra) # 802070e8 <consoleintr>
+ 80202a84: b7ed j 80202a6e <devintr+0x76>
+ disk_intr();
+ 80202a86: 00003097 auipc ra,0x3
+ 80202a8a: a80080e7 jalr -1408(ra) # 80205506 <disk_intr>
+ 80202a8e: b7c5 j 80202a6e <devintr+0x76>
+ timer_tick();
+ 80202a90: 00003097 auipc ra,0x3
+ 80202a94: 9dc080e7 jalr -1572(ra) # 8020546c <timer_tick>
+ return 2;
+ 80202a98: 4509 li a0,2
+ 80202a9a: bfb5 j 80202a16 <devintr+0x1e>
+
+0000000080202a9c <usertrap>:
+{
+ 80202a9c: 1101 addi sp,sp,-32
+ 80202a9e: ec06 sd ra,24(sp)
+ 80202aa0: e822 sd s0,16(sp)
+ 80202aa2: e426 sd s1,8(sp)
+ 80202aa4: e04a sd s2,0(sp)
+ 80202aa6: 1000 addi s0,sp,32
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202aa8: 100027f3 csrr a5,sstatus
+ if((r_sstatus() & SSTATUS_SPP) != 0)
+ 80202aac: 1007f793 andi a5,a5,256
+ 80202ab0: e3ad bnez a5,80202b12 <usertrap+0x76>
+ asm volatile("csrw stvec, %0" : : "r" (x));
+ 80202ab2: 00009797 auipc a5,0x9
+ 80202ab6: 23e7b783 ld a5,574(a5) # 8020bcf0 <_GLOBAL_OFFSET_TABLE_+0x18>
+ 80202aba: 10579073 csrw stvec,a5
+ struct proc *p = myproc();
+ 80202abe: fffff097 auipc ra,0xfffff
+ 80202ac2: f7e080e7 jalr -130(ra) # 80201a3c <myproc>
+ 80202ac6: 84aa mv s1,a0
+ p->trapframe->epc = r_sepc();
+ 80202ac8: 713c ld a5,96(a0)
+ asm volatile("csrr %0, sepc" : "=r" (x) );
+ 80202aca: 14102773 csrr a4,sepc
+ 80202ace: ef98 sd a4,24(a5)
+ asm volatile("csrr %0, scause" : "=r" (x) );
+ 80202ad0: 14202773 csrr a4,scause
+ if(r_scause() == 8){
+ 80202ad4: 47a1 li a5,8
+ 80202ad6: 04f71c63 bne a4,a5,80202b2e <usertrap+0x92>
+ if(p->killed)
+ 80202ada: 591c lw a5,48(a0)
+ 80202adc: e3b9 bnez a5,80202b22 <usertrap+0x86>
+ p->trapframe->epc += 4;
+ 80202ade: 70b8 ld a4,96(s1)
+ 80202ae0: 6f1c ld a5,24(a4)
+ 80202ae2: 0791 addi a5,a5,4
+ 80202ae4: ef1c sd a5,24(a4)
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202ae6: 100027f3 csrr a5,sstatus
+ w_sstatus(r_sstatus() | SSTATUS_SIE);
+ 80202aea: 0027e793 ori a5,a5,2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 80202aee: 10079073 csrw sstatus,a5
+ syscall();
+ 80202af2: 00000097 auipc ra,0x0
+ 80202af6: 644080e7 jalr 1604(ra) # 80203136 <syscall>
+ if(p->killed)
+ 80202afa: 589c lw a5,48(s1)
+ 80202afc: ebd1 bnez a5,80202b90 <usertrap+0xf4>
+ usertrapret();
+ 80202afe: 00000097 auipc ra,0x0
+ 80202b02: e5c080e7 jalr -420(ra) # 8020295a <usertrapret>
+}
+ 80202b06: 60e2 ld ra,24(sp)
+ 80202b08: 6442 ld s0,16(sp)
+ 80202b0a: 64a2 ld s1,8(sp)
+ 80202b0c: 6902 ld s2,0(sp)
+ 80202b0e: 6105 addi sp,sp,32
+ 80202b10: 8082 ret
+ panic("usertrap: not from user mode");
+ 80202b12: 00007517 auipc a0,0x7
+ 80202b16: c1650513 addi a0,a0,-1002 # 80209728 <digits+0x3a8>
+ 80202b1a: ffffd097 auipc ra,0xffffd
+ 80202b1e: 62a080e7 jalr 1578(ra) # 80200144 <panic>
+ exit(-1);
+ 80202b22: 557d li a0,-1
+ 80202b24: fffff097 auipc ra,0xfffff
+ 80202b28: 794080e7 jalr 1940(ra) # 802022b8 <exit>
+ 80202b2c: bf4d j 80202ade <usertrap+0x42>
+ else if((which_dev = devintr()) != 0){
+ 80202b2e: 00000097 auipc ra,0x0
+ 80202b32: eca080e7 jalr -310(ra) # 802029f8 <devintr>
+ 80202b36: 892a mv s2,a0
+ 80202b38: c501 beqz a0,80202b40 <usertrap+0xa4>
+ if(p->killed)
+ 80202b3a: 589c lw a5,48(s1)
+ 80202b3c: c3b1 beqz a5,80202b80 <usertrap+0xe4>
+ 80202b3e: a825 j 80202b76 <usertrap+0xda>
+ asm volatile("csrr %0, scause" : "=r" (x) );
+ 80202b40: 142025f3 csrr a1,scause
+ printf("\nusertrap(): unexpected scause %p pid=%d %s\n", r_scause(), p->pid, p->name);
+ 80202b44: 16048693 addi a3,s1,352
+ 80202b48: 5c90 lw a2,56(s1)
+ 80202b4a: 00007517 auipc a0,0x7
+ 80202b4e: bfe50513 addi a0,a0,-1026 # 80209748 <digits+0x3c8>
+ 80202b52: ffffd097 auipc ra,0xffffd
+ 80202b56: 63c080e7 jalr 1596(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sepc" : "=r" (x) );
+ 80202b5a: 141025f3 csrr a1,sepc
+ asm volatile("csrr %0, stval" : "=r" (x) );
+ 80202b5e: 14302673 csrr a2,stval
+ printf(" sepc=%p stval=%p\n", r_sepc(), r_stval());
+ 80202b62: 00007517 auipc a0,0x7
+ 80202b66: c1650513 addi a0,a0,-1002 # 80209778 <digits+0x3f8>
+ 80202b6a: ffffd097 auipc ra,0xffffd
+ 80202b6e: 624080e7 jalr 1572(ra) # 8020018e <printf>
+ p->killed = 1;
+ 80202b72: 4785 li a5,1
+ 80202b74: d89c sw a5,48(s1)
+ exit(-1);
+ 80202b76: 557d li a0,-1
+ 80202b78: fffff097 auipc ra,0xfffff
+ 80202b7c: 740080e7 jalr 1856(ra) # 802022b8 <exit>
+ if(which_dev == 2)
+ 80202b80: 4789 li a5,2
+ 80202b82: f6f91ee3 bne s2,a5,80202afe <usertrap+0x62>
+ yield();
+ 80202b86: 00000097 auipc ra,0x0
+ 80202b8a: 832080e7 jalr -1998(ra) # 802023b8 <yield>
+ 80202b8e: bf85 j 80202afe <usertrap+0x62>
+ int which_dev = 0;
+ 80202b90: 4901 li s2,0
+ 80202b92: b7d5 j 80202b76 <usertrap+0xda>
+
+0000000080202b94 <kerneltrap>:
+kerneltrap() {
+ 80202b94: 7179 addi sp,sp,-48
+ 80202b96: f406 sd ra,40(sp)
+ 80202b98: f022 sd s0,32(sp)
+ 80202b9a: ec26 sd s1,24(sp)
+ 80202b9c: e84a sd s2,16(sp)
+ 80202b9e: e44e sd s3,8(sp)
+ 80202ba0: 1800 addi s0,sp,48
+ asm volatile("csrr %0, sepc" : "=r" (x) );
+ 80202ba2: 14102973 csrr s2,sepc
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202ba6: 100024f3 csrr s1,sstatus
+ asm volatile("csrr %0, scause" : "=r" (x) );
+ 80202baa: 142029f3 csrr s3,scause
+ if((sstatus & SSTATUS_SPP) == 0)
+ 80202bae: 1004f793 andi a5,s1,256
+ 80202bb2: cb85 beqz a5,80202be2 <kerneltrap+0x4e>
+ asm volatile("csrr %0, sstatus" : "=r" (x) );
+ 80202bb4: 100027f3 csrr a5,sstatus
+ return (x & SSTATUS_SIE) != 0;
+ 80202bb8: 8b89 andi a5,a5,2
+ if(intr_get() != 0)
+ 80202bba: ef85 bnez a5,80202bf2 <kerneltrap+0x5e>
+ if((which_dev = devintr()) == 0){
+ 80202bbc: 00000097 auipc ra,0x0
+ 80202bc0: e3c080e7 jalr -452(ra) # 802029f8 <devintr>
+ 80202bc4: cd1d beqz a0,80202c02 <kerneltrap+0x6e>
+ if(which_dev == 2 && myproc() != 0 && myproc()->state == RUNNING) {
+ 80202bc6: 4789 li a5,2
+ 80202bc8: 08f50b63 beq a0,a5,80202c5e <kerneltrap+0xca>
+ asm volatile("csrw sepc, %0" : : "r" (x));
+ 80202bcc: 14191073 csrw sepc,s2
+ asm volatile("csrw sstatus, %0" : : "r" (x));
+ 80202bd0: 10049073 csrw sstatus,s1
+}
+ 80202bd4: 70a2 ld ra,40(sp)
+ 80202bd6: 7402 ld s0,32(sp)
+ 80202bd8: 64e2 ld s1,24(sp)
+ 80202bda: 6942 ld s2,16(sp)
+ 80202bdc: 69a2 ld s3,8(sp)
+ 80202bde: 6145 addi sp,sp,48
+ 80202be0: 8082 ret
+ panic("kerneltrap: not from supervisor mode");
+ 80202be2: 00007517 auipc a0,0x7
+ 80202be6: bb650513 addi a0,a0,-1098 # 80209798 <digits+0x418>
+ 80202bea: ffffd097 auipc ra,0xffffd
+ 80202bee: 55a080e7 jalr 1370(ra) # 80200144 <panic>
+ panic("kerneltrap: interrupts enabled");
+ 80202bf2: 00007517 auipc a0,0x7
+ 80202bf6: bce50513 addi a0,a0,-1074 # 802097c0 <digits+0x440>
+ 80202bfa: ffffd097 auipc ra,0xffffd
+ 80202bfe: 54a080e7 jalr 1354(ra) # 80200144 <panic>
+ printf("\nscause %p\n", scause);
+ 80202c02: 85ce mv a1,s3
+ 80202c04: 00007517 auipc a0,0x7
+ 80202c08: bdc50513 addi a0,a0,-1060 # 802097e0 <digits+0x460>
+ 80202c0c: ffffd097 auipc ra,0xffffd
+ 80202c10: 582080e7 jalr 1410(ra) # 8020018e <printf>
+ asm volatile("csrr %0, sepc" : "=r" (x) );
+ 80202c14: 141025f3 csrr a1,sepc
+ asm volatile("csrr %0, stval" : "=r" (x) );
+ 80202c18: 14302673 csrr a2,stval
+ asm volatile("mv %0, tp" : "=r" (x) );
+ 80202c1c: 8692 mv a3,tp
+ printf("sepc=%p stval=%p hart=%d\n", r_sepc(), r_stval(), r_tp());
+ 80202c1e: 00007517 auipc a0,0x7
+ 80202c22: bd250513 addi a0,a0,-1070 # 802097f0 <digits+0x470>
+ 80202c26: ffffd097 auipc ra,0xffffd
+ 80202c2a: 568080e7 jalr 1384(ra) # 8020018e <printf>
+ struct proc *p = myproc();
+ 80202c2e: fffff097 auipc ra,0xfffff
+ 80202c32: e0e080e7 jalr -498(ra) # 80201a3c <myproc>
+ if (p != 0) {
+ 80202c36: cd01 beqz a0,80202c4e <kerneltrap+0xba>
+ printf("pid: %d, name: %s\n", p->pid, p->name);
+ 80202c38: 16050613 addi a2,a0,352
+ 80202c3c: 5d0c lw a1,56(a0)
+ 80202c3e: 00007517 auipc a0,0x7
+ 80202c42: bd250513 addi a0,a0,-1070 # 80209810 <digits+0x490>
+ 80202c46: ffffd097 auipc ra,0xffffd
+ 80202c4a: 548080e7 jalr 1352(ra) # 8020018e <printf>
+ panic("kerneltrap");
+ 80202c4e: 00007517 auipc a0,0x7
+ 80202c52: bda50513 addi a0,a0,-1062 # 80209828 <digits+0x4a8>
+ 80202c56: ffffd097 auipc ra,0xffffd
+ 80202c5a: 4ee080e7 jalr 1262(ra) # 80200144 <panic>
+ if(which_dev == 2 && myproc() != 0 && myproc()->state == RUNNING) {
+ 80202c5e: fffff097 auipc ra,0xfffff
+ 80202c62: dde080e7 jalr -546(ra) # 80201a3c <myproc>
+ 80202c66: d13d beqz a0,80202bcc <kerneltrap+0x38>
+ 80202c68: fffff097 auipc ra,0xfffff
+ 80202c6c: dd4080e7 jalr -556(ra) # 80201a3c <myproc>
+ 80202c70: 4d18 lw a4,24(a0)
+ 80202c72: 478d li a5,3
+ 80202c74: f4f71ce3 bne a4,a5,80202bcc <kerneltrap+0x38>
+ yield();
+ 80202c78: fffff097 auipc ra,0xfffff
+ 80202c7c: 740080e7 jalr 1856(ra) # 802023b8 <yield>
+ 80202c80: b7b1 j 80202bcc <kerneltrap+0x38>
+
+0000000080202c82 <trapframedump>:
+
+void trapframedump(struct trapframe *tf)
+{
+ 80202c82: 1101 addi sp,sp,-32
+ 80202c84: ec06 sd ra,24(sp)
+ 80202c86: e822 sd s0,16(sp)
+ 80202c88: e426 sd s1,8(sp)
+ 80202c8a: 1000 addi s0,sp,32
+ 80202c8c: 84aa mv s1,a0
+ printf("a0: %p\t", tf->a0);
+ 80202c8e: 792c ld a1,112(a0)
+ 80202c90: 00007517 auipc a0,0x7
+ 80202c94: ba850513 addi a0,a0,-1112 # 80209838 <digits+0x4b8>
+ 80202c98: ffffd097 auipc ra,0xffffd
+ 80202c9c: 4f6080e7 jalr 1270(ra) # 8020018e <printf>
+ printf("a1: %p\t", tf->a1);
+ 80202ca0: 7cac ld a1,120(s1)
+ 80202ca2: 00007517 auipc a0,0x7
+ 80202ca6: b9e50513 addi a0,a0,-1122 # 80209840 <digits+0x4c0>
+ 80202caa: ffffd097 auipc ra,0xffffd
+ 80202cae: 4e4080e7 jalr 1252(ra) # 8020018e <printf>
+ printf("a2: %p\t", tf->a2);
+ 80202cb2: 60cc ld a1,128(s1)
+ 80202cb4: 00007517 auipc a0,0x7
+ 80202cb8: b9450513 addi a0,a0,-1132 # 80209848 <digits+0x4c8>
+ 80202cbc: ffffd097 auipc ra,0xffffd
+ 80202cc0: 4d2080e7 jalr 1234(ra) # 8020018e <printf>
+ printf("a3: %p\n", tf->a3);
+ 80202cc4: 64cc ld a1,136(s1)
+ 80202cc6: 00007517 auipc a0,0x7
+ 80202cca: b8a50513 addi a0,a0,-1142 # 80209850 <digits+0x4d0>
+ 80202cce: ffffd097 auipc ra,0xffffd
+ 80202cd2: 4c0080e7 jalr 1216(ra) # 8020018e <printf>
+ printf("a4: %p\t", tf->a4);
+ 80202cd6: 68cc ld a1,144(s1)
+ 80202cd8: 00007517 auipc a0,0x7
+ 80202cdc: b8050513 addi a0,a0,-1152 # 80209858 <digits+0x4d8>
+ 80202ce0: ffffd097 auipc ra,0xffffd
+ 80202ce4: 4ae080e7 jalr 1198(ra) # 8020018e <printf>
+ printf("a5: %p\t", tf->a5);
+ 80202ce8: 6ccc ld a1,152(s1)
+ 80202cea: 00007517 auipc a0,0x7
+ 80202cee: b7650513 addi a0,a0,-1162 # 80209860 <digits+0x4e0>
+ 80202cf2: ffffd097 auipc ra,0xffffd
+ 80202cf6: 49c080e7 jalr 1180(ra) # 8020018e <printf>
+ printf("a6: %p\t", tf->a6);
+ 80202cfa: 70cc ld a1,160(s1)
+ 80202cfc: 00007517 auipc a0,0x7
+ 80202d00: b6c50513 addi a0,a0,-1172 # 80209868 <digits+0x4e8>
+ 80202d04: ffffd097 auipc ra,0xffffd
+ 80202d08: 48a080e7 jalr 1162(ra) # 8020018e <printf>
+ printf("a7: %p\n", tf->a7);
+ 80202d0c: 74cc ld a1,168(s1)
+ 80202d0e: 00007517 auipc a0,0x7
+ 80202d12: b6250513 addi a0,a0,-1182 # 80209870 <digits+0x4f0>
+ 80202d16: ffffd097 auipc ra,0xffffd
+ 80202d1a: 478080e7 jalr 1144(ra) # 8020018e <printf>
+ printf("t0: %p\t", tf->t0);
+ 80202d1e: 64ac ld a1,72(s1)
+ 80202d20: 00007517 auipc a0,0x7
+ 80202d24: b5850513 addi a0,a0,-1192 # 80209878 <digits+0x4f8>
+ 80202d28: ffffd097 auipc ra,0xffffd
+ 80202d2c: 466080e7 jalr 1126(ra) # 8020018e <printf>
+ printf("t1: %p\t", tf->t1);
+ 80202d30: 68ac ld a1,80(s1)
+ 80202d32: 00007517 auipc a0,0x7
+ 80202d36: b4e50513 addi a0,a0,-1202 # 80209880 <digits+0x500>
+ 80202d3a: ffffd097 auipc ra,0xffffd
+ 80202d3e: 454080e7 jalr 1108(ra) # 8020018e <printf>
+ printf("t2: %p\t", tf->t2);
+ 80202d42: 6cac ld a1,88(s1)
+ 80202d44: 00007517 auipc a0,0x7
+ 80202d48: b4450513 addi a0,a0,-1212 # 80209888 <digits+0x508>
+ 80202d4c: ffffd097 auipc ra,0xffffd
+ 80202d50: 442080e7 jalr 1090(ra) # 8020018e <printf>
+ printf("t3: %p\n", tf->t3);
+ 80202d54: 1004b583 ld a1,256(s1)
+ 80202d58: 00007517 auipc a0,0x7
+ 80202d5c: b3850513 addi a0,a0,-1224 # 80209890 <digits+0x510>
+ 80202d60: ffffd097 auipc ra,0xffffd
+ 80202d64: 42e080e7 jalr 1070(ra) # 8020018e <printf>
+ printf("t4: %p\t", tf->t4);
+ 80202d68: 1084b583 ld a1,264(s1)
+ 80202d6c: 00007517 auipc a0,0x7
+ 80202d70: b2c50513 addi a0,a0,-1236 # 80209898 <digits+0x518>
+ 80202d74: ffffd097 auipc ra,0xffffd
+ 80202d78: 41a080e7 jalr 1050(ra) # 8020018e <printf>
+ printf("t5: %p\t", tf->t5);
+ 80202d7c: 1104b583 ld a1,272(s1)
+ 80202d80: 00007517 auipc a0,0x7
+ 80202d84: b2050513 addi a0,a0,-1248 # 802098a0 <digits+0x520>
+ 80202d88: ffffd097 auipc ra,0xffffd
+ 80202d8c: 406080e7 jalr 1030(ra) # 8020018e <printf>
+ printf("t6: %p\t", tf->t6);
+ 80202d90: 1184b583 ld a1,280(s1)
+ 80202d94: 00007517 auipc a0,0x7
+ 80202d98: b1450513 addi a0,a0,-1260 # 802098a8 <digits+0x528>
+ 80202d9c: ffffd097 auipc ra,0xffffd
+ 80202da0: 3f2080e7 jalr 1010(ra) # 8020018e <printf>
+ printf("s0: %p\n", tf->s0);
+ 80202da4: 70ac ld a1,96(s1)
+ 80202da6: 00007517 auipc a0,0x7
+ 80202daa: b0a50513 addi a0,a0,-1270 # 802098b0 <digits+0x530>
+ 80202dae: ffffd097 auipc ra,0xffffd
+ 80202db2: 3e0080e7 jalr 992(ra) # 8020018e <printf>
+ printf("s1: %p\t", tf->s1);
+ 80202db6: 74ac ld a1,104(s1)
+ 80202db8: 00007517 auipc a0,0x7
+ 80202dbc: b0050513 addi a0,a0,-1280 # 802098b8 <digits+0x538>
+ 80202dc0: ffffd097 auipc ra,0xffffd
+ 80202dc4: 3ce080e7 jalr 974(ra) # 8020018e <printf>
+ printf("s2: %p\t", tf->s2);
+ 80202dc8: 78cc ld a1,176(s1)
+ 80202dca: 00007517 auipc a0,0x7
+ 80202dce: af650513 addi a0,a0,-1290 # 802098c0 <digits+0x540>
+ 80202dd2: ffffd097 auipc ra,0xffffd
+ 80202dd6: 3bc080e7 jalr 956(ra) # 8020018e <printf>
+ printf("s3: %p\t", tf->s3);
+ 80202dda: 7ccc ld a1,184(s1)
+ 80202ddc: 00007517 auipc a0,0x7
+ 80202de0: aec50513 addi a0,a0,-1300 # 802098c8 <digits+0x548>
+ 80202de4: ffffd097 auipc ra,0xffffd
+ 80202de8: 3aa080e7 jalr 938(ra) # 8020018e <printf>
+ printf("s4: %p\n", tf->s4);
+ 80202dec: 60ec ld a1,192(s1)
+ 80202dee: 00007517 auipc a0,0x7
+ 80202df2: ae250513 addi a0,a0,-1310 # 802098d0 <digits+0x550>
+ 80202df6: ffffd097 auipc ra,0xffffd
+ 80202dfa: 398080e7 jalr 920(ra) # 8020018e <printf>
+ printf("s5: %p\t", tf->s5);
+ 80202dfe: 64ec ld a1,200(s1)
+ 80202e00: 00007517 auipc a0,0x7
+ 80202e04: ad850513 addi a0,a0,-1320 # 802098d8 <digits+0x558>
+ 80202e08: ffffd097 auipc ra,0xffffd
+ 80202e0c: 386080e7 jalr 902(ra) # 8020018e <printf>
+ printf("s6: %p\t", tf->s6);
+ 80202e10: 68ec ld a1,208(s1)
+ 80202e12: 00007517 auipc a0,0x7
+ 80202e16: ace50513 addi a0,a0,-1330 # 802098e0 <digits+0x560>
+ 80202e1a: ffffd097 auipc ra,0xffffd
+ 80202e1e: 374080e7 jalr 884(ra) # 8020018e <printf>
+ printf("s7: %p\t", tf->s7);
+ 80202e22: 6cec ld a1,216(s1)
+ 80202e24: 00007517 auipc a0,0x7
+ 80202e28: ac450513 addi a0,a0,-1340 # 802098e8 <digits+0x568>
+ 80202e2c: ffffd097 auipc ra,0xffffd
+ 80202e30: 362080e7 jalr 866(ra) # 8020018e <printf>
+ printf("s8: %p\n", tf->s8);
+ 80202e34: 70ec ld a1,224(s1)
+ 80202e36: 00007517 auipc a0,0x7
+ 80202e3a: aba50513 addi a0,a0,-1350 # 802098f0 <digits+0x570>
+ 80202e3e: ffffd097 auipc ra,0xffffd
+ 80202e42: 350080e7 jalr 848(ra) # 8020018e <printf>
+ printf("s9: %p\t", tf->s9);
+ 80202e46: 74ec ld a1,232(s1)
+ 80202e48: 00007517 auipc a0,0x7
+ 80202e4c: ab050513 addi a0,a0,-1360 # 802098f8 <digits+0x578>
+ 80202e50: ffffd097 auipc ra,0xffffd
+ 80202e54: 33e080e7 jalr 830(ra) # 8020018e <printf>
+ printf("s10: %p\t", tf->s10);
+ 80202e58: 78ec ld a1,240(s1)
+ 80202e5a: 00007517 auipc a0,0x7
+ 80202e5e: aa650513 addi a0,a0,-1370 # 80209900 <digits+0x580>
+ 80202e62: ffffd097 auipc ra,0xffffd
+ 80202e66: 32c080e7 jalr 812(ra) # 8020018e <printf>
+ printf("s11: %p\t", tf->s11);
+ 80202e6a: 7cec ld a1,248(s1)
+ 80202e6c: 00007517 auipc a0,0x7
+ 80202e70: aa450513 addi a0,a0,-1372 # 80209910 <digits+0x590>
+ 80202e74: ffffd097 auipc ra,0xffffd
+ 80202e78: 31a080e7 jalr 794(ra) # 8020018e <printf>
+ printf("ra: %p\n", tf->ra);
+ 80202e7c: 748c ld a1,40(s1)
+ 80202e7e: 00006517 auipc a0,0x6
+ 80202e82: 79250513 addi a0,a0,1938 # 80209610 <digits+0x290>
+ 80202e86: ffffd097 auipc ra,0xffffd
+ 80202e8a: 308080e7 jalr 776(ra) # 8020018e <printf>
+ printf("sp: %p\t", tf->sp);
+ 80202e8e: 788c ld a1,48(s1)
+ 80202e90: 00007517 auipc a0,0x7
+ 80202e94: a9050513 addi a0,a0,-1392 # 80209920 <digits+0x5a0>
+ 80202e98: ffffd097 auipc ra,0xffffd
+ 80202e9c: 2f6080e7 jalr 758(ra) # 8020018e <printf>
+ printf("gp: %p\t", tf->gp);
+ 80202ea0: 7c8c ld a1,56(s1)
+ 80202ea2: 00007517 auipc a0,0x7
+ 80202ea6: a8650513 addi a0,a0,-1402 # 80209928 <digits+0x5a8>
+ 80202eaa: ffffd097 auipc ra,0xffffd
+ 80202eae: 2e4080e7 jalr 740(ra) # 8020018e <printf>
+ printf("tp: %p\t", tf->tp);
+ 80202eb2: 60ac ld a1,64(s1)
+ 80202eb4: 00007517 auipc a0,0x7
+ 80202eb8: a7c50513 addi a0,a0,-1412 # 80209930 <digits+0x5b0>
+ 80202ebc: ffffd097 auipc ra,0xffffd
+ 80202ec0: 2d2080e7 jalr 722(ra) # 8020018e <printf>
+ printf("epc: %p\n", tf->epc);
+ 80202ec4: 6c8c ld a1,24(s1)
+ 80202ec6: 00007517 auipc a0,0x7
+ 80202eca: a7250513 addi a0,a0,-1422 # 80209938 <digits+0x5b8>
+ 80202ece: ffffd097 auipc ra,0xffffd
+ 80202ed2: 2c0080e7 jalr 704(ra) # 8020018e <printf>
+}
+ 80202ed6: 60e2 ld ra,24(sp)
+ 80202ed8: 6442 ld s0,16(sp)
+ 80202eda: 64a2 ld s1,8(sp)
+ 80202edc: 6105 addi sp,sp,32
+ 80202ede: 8082 ret
+
+0000000080202ee0 <argraw>:
+ return strlen(buf);
+}
+
+static uint64
+argraw(int n)
+{
+ 80202ee0: 1101 addi sp,sp,-32
+ 80202ee2: ec06 sd ra,24(sp)
+ 80202ee4: e822 sd s0,16(sp)
+ 80202ee6: e426 sd s1,8(sp)
+ 80202ee8: 1000 addi s0,sp,32
+ 80202eea: 84aa mv s1,a0
+ struct proc *p = myproc();
+ 80202eec: fffff097 auipc ra,0xfffff
+ 80202ef0: b50080e7 jalr -1200(ra) # 80201a3c <myproc>
+ switch (n) {
+ 80202ef4: 4795 li a5,5
+ 80202ef6: 0497e163 bltu a5,s1,80202f38 <argraw+0x58>
+ 80202efa: 048a slli s1,s1,0x2
+ 80202efc: 00007717 auipc a4,0x7
+ 80202f00: bf470713 addi a4,a4,-1036 # 80209af0 <digits+0x770>
+ 80202f04: 94ba add s1,s1,a4
+ 80202f06: 409c lw a5,0(s1)
+ 80202f08: 97ba add a5,a5,a4
+ 80202f0a: 8782 jr a5
+ case 0:
+ return p->trapframe->a0;
+ 80202f0c: 713c ld a5,96(a0)
+ 80202f0e: 7ba8 ld a0,112(a5)
+ case 5:
+ return p->trapframe->a5;
+ }
+ panic("argraw");
+ return -1;
+}
+ 80202f10: 60e2 ld ra,24(sp)
+ 80202f12: 6442 ld s0,16(sp)
+ 80202f14: 64a2 ld s1,8(sp)
+ 80202f16: 6105 addi sp,sp,32
+ 80202f18: 8082 ret
+ return p->trapframe->a1;
+ 80202f1a: 713c ld a5,96(a0)
+ 80202f1c: 7fa8 ld a0,120(a5)
+ 80202f1e: bfcd j 80202f10 <argraw+0x30>
+ return p->trapframe->a2;
+ 80202f20: 713c ld a5,96(a0)
+ 80202f22: 63c8 ld a0,128(a5)
+ 80202f24: b7f5 j 80202f10 <argraw+0x30>
+ return p->trapframe->a3;
+ 80202f26: 713c ld a5,96(a0)
+ 80202f28: 67c8 ld a0,136(a5)
+ 80202f2a: b7dd j 80202f10 <argraw+0x30>
+ return p->trapframe->a4;
+ 80202f2c: 713c ld a5,96(a0)
+ 80202f2e: 6bc8 ld a0,144(a5)
+ 80202f30: b7c5 j 80202f10 <argraw+0x30>
+ return p->trapframe->a5;
+ 80202f32: 713c ld a5,96(a0)
+ 80202f34: 6fc8 ld a0,152(a5)
+ 80202f36: bfe9 j 80202f10 <argraw+0x30>
+ panic("argraw");
+ 80202f38: 00007517 auipc a0,0x7
+ 80202f3c: a1050513 addi a0,a0,-1520 # 80209948 <digits+0x5c8>
+ 80202f40: ffffd097 auipc ra,0xffffd
+ 80202f44: 204080e7 jalr 516(ra) # 80200144 <panic>
+
+0000000080202f48 <sys_uname>:
+ return 0;
+}
+
+uint64
+sys_uname(void)
+{
+ 80202f48: 7125 addi sp,sp,-416
+ 80202f4a: ef06 sd ra,408(sp)
+ 80202f4c: eb22 sd s0,400(sp)
+ 80202f4e: 1300 addi s0,sp,416
+ *ip = argraw(n);
+ 80202f50: 4501 li a0,0
+ 80202f52: 00000097 auipc ra,0x0
+ 80202f56: f8e080e7 jalr -114(ra) # 80202ee0 <argraw>
+ char version[65];
+ char machine[65];
+ char domainname[65];
+ };
+
+ struct utsname uname = {"xv6", "xv6", "0", "0", "xv6", "localhost"};
+ 80202f5a: 00007797 auipc a5,0x7
+ 80202f5e: bae78793 addi a5,a5,-1106 # 80209b08 <digits+0x788>
+ 80202f62: e6840713 addi a4,s0,-408
+ 80202f66: 00007697 auipc a3,0x7
+ 80202f6a: d2268693 addi a3,a3,-734 # 80209c88 <digits+0x908>
+ 80202f6e: 0007b883 ld a7,0(a5)
+ 80202f72: 0087b803 ld a6,8(a5)
+ 80202f76: 6b8c ld a1,16(a5)
+ 80202f78: 6f90 ld a2,24(a5)
+ 80202f7a: 01173023 sd a7,0(a4)
+ 80202f7e: 01073423 sd a6,8(a4)
+ 80202f82: eb0c sd a1,16(a4)
+ 80202f84: ef10 sd a2,24(a4)
+ 80202f86: 02078793 addi a5,a5,32
+ 80202f8a: 02070713 addi a4,a4,32
+ 80202f8e: fed790e3 bne a5,a3,80202f6e <sys_uname+0x26>
+ 80202f92: 4394 lw a3,0(a5)
+ 80202f94: c314 sw a3,0(a4)
+ 80202f96: 0047d783 lhu a5,4(a5)
+ 80202f9a: 00f71223 sh a5,4(a4)
+
+ if(copyout2(addr, (char *) & uname, sizeof(uname)) < 0)
+ 80202f9e: 18600613 li a2,390
+ 80202fa2: e6840593 addi a1,s0,-408
+ 80202fa6: ffffe097 auipc ra,0xffffe
+ 80202faa: 3cc080e7 jalr 972(ra) # 80201372 <copyout2>
+ return -1;
+
+ return 0;
+ 80202fae: 957d srai a0,a0,0x3f
+ 80202fb0: 60fa ld ra,408(sp)
+ 80202fb2: 645a ld s0,400(sp)
+ 80202fb4: 611d addi sp,sp,416
+ 80202fb6: 8082 ret
+
+0000000080202fb8 <sys_sysinfo>:
+{
+ 80202fb8: 7179 addi sp,sp,-48
+ 80202fba: f406 sd ra,40(sp)
+ 80202fbc: f022 sd s0,32(sp)
+ 80202fbe: ec26 sd s1,24(sp)
+ 80202fc0: 1800 addi s0,sp,48
+ *ip = argraw(n);
+ 80202fc2: 4501 li a0,0
+ 80202fc4: 00000097 auipc ra,0x0
+ 80202fc8: f1c080e7 jalr -228(ra) # 80202ee0 <argraw>
+ 80202fcc: 84aa mv s1,a0
+ info.freemem = freemem_amount();
+ 80202fce: ffffd097 auipc ra,0xffffd
+ 80202fd2: 5f2080e7 jalr 1522(ra) # 802005c0 <freemem_amount>
+ 80202fd6: fca43823 sd a0,-48(s0)
+ info.nproc = procnum();
+ 80202fda: 00000097 auipc ra,0x0
+ 80202fde: 8aa080e7 jalr -1878(ra) # 80202884 <procnum>
+ 80202fe2: fca43c23 sd a0,-40(s0)
+ if (copyout2(addr, (char *)&info, sizeof(info)) < 0) {
+ 80202fe6: 4641 li a2,16
+ 80202fe8: fd040593 addi a1,s0,-48
+ 80202fec: 8526 mv a0,s1
+ 80202fee: ffffe097 auipc ra,0xffffe
+ 80202ff2: 384080e7 jalr 900(ra) # 80201372 <copyout2>
+}
+ 80202ff6: 957d srai a0,a0,0x3f
+ 80202ff8: 70a2 ld ra,40(sp)
+ 80202ffa: 7402 ld s0,32(sp)
+ 80202ffc: 64e2 ld s1,24(sp)
+ 80202ffe: 6145 addi sp,sp,48
+ 80203000: 8082 ret
+
+0000000080203002 <fetchaddr>:
+{
+ 80203002: 1101 addi sp,sp,-32
+ 80203004: ec06 sd ra,24(sp)
+ 80203006: e822 sd s0,16(sp)
+ 80203008: e426 sd s1,8(sp)
+ 8020300a: e04a sd s2,0(sp)
+ 8020300c: 1000 addi s0,sp,32
+ 8020300e: 84aa mv s1,a0
+ 80203010: 892e mv s2,a1
+ struct proc *p = myproc();
+ 80203012: fffff097 auipc ra,0xfffff
+ 80203016: a2a080e7 jalr -1494(ra) # 80201a3c <myproc>
+ if(addr >= p->sz || addr+sizeof(uint64) > p->sz)
+ 8020301a: 653c ld a5,72(a0)
+ 8020301c: 02f4f763 bgeu s1,a5,8020304a <fetchaddr+0x48>
+ 80203020: 00848713 addi a4,s1,8
+ 80203024: 02e7e563 bltu a5,a4,8020304e <fetchaddr+0x4c>
+ if(copyin2((char *)ip, addr, sizeof(*ip)) != 0)
+ 80203028: 4621 li a2,8
+ 8020302a: 85a6 mv a1,s1
+ 8020302c: 854a mv a0,s2
+ 8020302e: ffffe097 auipc ra,0xffffe
+ 80203032: 424080e7 jalr 1060(ra) # 80201452 <copyin2>
+ 80203036: 00a03533 snez a0,a0
+ 8020303a: 40a00533 neg a0,a0
+}
+ 8020303e: 60e2 ld ra,24(sp)
+ 80203040: 6442 ld s0,16(sp)
+ 80203042: 64a2 ld s1,8(sp)
+ 80203044: 6902 ld s2,0(sp)
+ 80203046: 6105 addi sp,sp,32
+ 80203048: 8082 ret
+ return -1;
+ 8020304a: 557d li a0,-1
+ 8020304c: bfcd j 8020303e <fetchaddr+0x3c>
+ 8020304e: 557d li a0,-1
+ 80203050: b7fd j 8020303e <fetchaddr+0x3c>
+
+0000000080203052 <fetchstr>:
+{
+ 80203052: 1101 addi sp,sp,-32
+ 80203054: ec06 sd ra,24(sp)
+ 80203056: e822 sd s0,16(sp)
+ 80203058: e426 sd s1,8(sp)
+ 8020305a: 1000 addi s0,sp,32
+ 8020305c: 84ae mv s1,a1
+ int err = copyinstr2(buf, addr, max);
+ 8020305e: 85aa mv a1,a0
+ 80203060: 8526 mv a0,s1
+ 80203062: ffffe097 auipc ra,0xffffe
+ 80203066: 4f2080e7 jalr 1266(ra) # 80201554 <copyinstr2>
+ if(err < 0)
+ 8020306a: 00054763 bltz a0,80203078 <fetchstr+0x26>
+ return strlen(buf);
+ 8020306e: 8526 mv a0,s1
+ 80203070: ffffe097 auipc ra,0xffffe
+ 80203074: 876080e7 jalr -1930(ra) # 802008e6 <strlen>
+}
+ 80203078: 60e2 ld ra,24(sp)
+ 8020307a: 6442 ld s0,16(sp)
+ 8020307c: 64a2 ld s1,8(sp)
+ 8020307e: 6105 addi sp,sp,32
+ 80203080: 8082 ret
+
+0000000080203082 <argint>:
+{
+ 80203082: 1101 addi sp,sp,-32
+ 80203084: ec06 sd ra,24(sp)
+ 80203086: e822 sd s0,16(sp)
+ 80203088: e426 sd s1,8(sp)
+ 8020308a: 1000 addi s0,sp,32
+ 8020308c: 84ae mv s1,a1
+ *ip = argraw(n);
+ 8020308e: 00000097 auipc ra,0x0
+ 80203092: e52080e7 jalr -430(ra) # 80202ee0 <argraw>
+ 80203096: c088 sw a0,0(s1)
+}
+ 80203098: 4501 li a0,0
+ 8020309a: 60e2 ld ra,24(sp)
+ 8020309c: 6442 ld s0,16(sp)
+ 8020309e: 64a2 ld s1,8(sp)
+ 802030a0: 6105 addi sp,sp,32
+ 802030a2: 8082 ret
+
+00000000802030a4 <sys_test_proc>:
+sys_test_proc(void) {
+ 802030a4: 1101 addi sp,sp,-32
+ 802030a6: ec06 sd ra,24(sp)
+ 802030a8: e822 sd s0,16(sp)
+ 802030aa: 1000 addi s0,sp,32
+ argint(0, &n);
+ 802030ac: fec40593 addi a1,s0,-20
+ 802030b0: 4501 li a0,0
+ 802030b2: 00000097 auipc ra,0x0
+ 802030b6: fd0080e7 jalr -48(ra) # 80203082 <argint>
+ printf("hello world from proc %d, hart %d, arg %d\n", myproc()->pid, r_tp(), n);
+ 802030ba: fffff097 auipc ra,0xfffff
+ 802030be: 982080e7 jalr -1662(ra) # 80201a3c <myproc>
+ 802030c2: 8612 mv a2,tp
+ 802030c4: fec42683 lw a3,-20(s0)
+ 802030c8: 5d0c lw a1,56(a0)
+ 802030ca: 00007517 auipc a0,0x7
+ 802030ce: 88650513 addi a0,a0,-1914 # 80209950 <digits+0x5d0>
+ 802030d2: ffffd097 auipc ra,0xffffd
+ 802030d6: 0bc080e7 jalr 188(ra) # 8020018e <printf>
+}
+ 802030da: 4501 li a0,0
+ 802030dc: 60e2 ld ra,24(sp)
+ 802030de: 6442 ld s0,16(sp)
+ 802030e0: 6105 addi sp,sp,32
+ 802030e2: 8082 ret
+
+00000000802030e4 <argaddr>:
+{
+ 802030e4: 1101 addi sp,sp,-32
+ 802030e6: ec06 sd ra,24(sp)
+ 802030e8: e822 sd s0,16(sp)
+ 802030ea: e426 sd s1,8(sp)
+ 802030ec: 1000 addi s0,sp,32
+ 802030ee: 84ae mv s1,a1
+ *ip = argraw(n);
+ 802030f0: 00000097 auipc ra,0x0
+ 802030f4: df0080e7 jalr -528(ra) # 80202ee0 <argraw>
+ 802030f8: e088 sd a0,0(s1)
+}
+ 802030fa: 4501 li a0,0
+ 802030fc: 60e2 ld ra,24(sp)
+ 802030fe: 6442 ld s0,16(sp)
+ 80203100: 64a2 ld s1,8(sp)
+ 80203102: 6105 addi sp,sp,32
+ 80203104: 8082 ret
+
+0000000080203106 <argstr>:
+{
+ 80203106: 1101 addi sp,sp,-32
+ 80203108: ec06 sd ra,24(sp)
+ 8020310a: e822 sd s0,16(sp)
+ 8020310c: e426 sd s1,8(sp)
+ 8020310e: e04a sd s2,0(sp)
+ 80203110: 1000 addi s0,sp,32
+ 80203112: 84ae mv s1,a1
+ 80203114: 8932 mv s2,a2
+ *ip = argraw(n);
+ 80203116: 00000097 auipc ra,0x0
+ 8020311a: dca080e7 jalr -566(ra) # 80202ee0 <argraw>
+ return fetchstr(addr, buf, max);
+ 8020311e: 864a mv a2,s2
+ 80203120: 85a6 mv a1,s1
+ 80203122: 00000097 auipc ra,0x0
+ 80203126: f30080e7 jalr -208(ra) # 80203052 <fetchstr>
+}
+ 8020312a: 60e2 ld ra,24(sp)
+ 8020312c: 6442 ld s0,16(sp)
+ 8020312e: 64a2 ld s1,8(sp)
+ 80203130: 6902 ld s2,0(sp)
+ 80203132: 6105 addi sp,sp,32
+ 80203134: 8082 ret
+
+0000000080203136 <syscall>:
+{
+ 80203136: 7179 addi sp,sp,-48
+ 80203138: f406 sd ra,40(sp)
+ 8020313a: f022 sd s0,32(sp)
+ 8020313c: ec26 sd s1,24(sp)
+ 8020313e: e84a sd s2,16(sp)
+ 80203140: e44e sd s3,8(sp)
+ 80203142: 1800 addi s0,sp,48
+ struct proc *p = myproc();
+ 80203144: fffff097 auipc ra,0xfffff
+ 80203148: 8f8080e7 jalr -1800(ra) # 80201a3c <myproc>
+ 8020314c: 84aa mv s1,a0
+ num = p->trapframe->a7;
+ 8020314e: 06053903 ld s2,96(a0)
+ 80203152: 0a893783 ld a5,168(s2)
+ 80203156: 0007899b sext.w s3,a5
+ if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
+ 8020315a: 37fd addiw a5,a5,-1
+ 8020315c: 10300713 li a4,259
+ 80203160: 04f76763 bltu a4,a5,802031ae <syscall+0x78>
+ 80203164: 00399713 slli a4,s3,0x3
+ 80203168: 00008797 auipc a5,0x8
+ 8020316c: b0878793 addi a5,a5,-1272 # 8020ac70 <syscalls>
+ 80203170: 97ba add a5,a5,a4
+ 80203172: 639c ld a5,0(a5)
+ 80203174: cf8d beqz a5,802031ae <syscall+0x78>
+ p->trapframe->a0 = syscalls[num]();
+ 80203176: 9782 jalr a5
+ 80203178: 06a93823 sd a0,112(s2)
+ if ((p->tmask & (1 << num)) != 0) {
+ 8020317c: 1704a783 lw a5,368(s1)
+ 80203180: 4137d7bb sraw a5,a5,s3
+ 80203184: 8b85 andi a5,a5,1
+ 80203186: c3b9 beqz a5,802031cc <syscall+0x96>
+ printf("pid %d: %s -> %d\n", p->pid, sysnames[num], p->trapframe->a0);
+ 80203188: 70b8 ld a4,96(s1)
+ 8020318a: 098e slli s3,s3,0x3
+ 8020318c: 00008797 auipc a5,0x8
+ 80203190: 30c78793 addi a5,a5,780 # 8020b498 <sysnames>
+ 80203194: 97ce add a5,a5,s3
+ 80203196: 7b34 ld a3,112(a4)
+ 80203198: 6390 ld a2,0(a5)
+ 8020319a: 5c8c lw a1,56(s1)
+ 8020319c: 00006517 auipc a0,0x6
+ 802031a0: 7e450513 addi a0,a0,2020 # 80209980 <digits+0x600>
+ 802031a4: ffffd097 auipc ra,0xffffd
+ 802031a8: fea080e7 jalr -22(ra) # 8020018e <printf>
+ 802031ac: a005 j 802031cc <syscall+0x96>
+ printf("pid %d %s: unknown sys call %d\n",
+ 802031ae: 86ce mv a3,s3
+ 802031b0: 16048613 addi a2,s1,352
+ 802031b4: 5c8c lw a1,56(s1)
+ 802031b6: 00006517 auipc a0,0x6
+ 802031ba: 7e250513 addi a0,a0,2018 # 80209998 <digits+0x618>
+ 802031be: ffffd097 auipc ra,0xffffd
+ 802031c2: fd0080e7 jalr -48(ra) # 8020018e <printf>
+ p->trapframe->a0 = -1;
+ 802031c6: 70bc ld a5,96(s1)
+ 802031c8: 577d li a4,-1
+ 802031ca: fbb8 sd a4,112(a5)
+}
+ 802031cc: 70a2 ld ra,40(sp)
+ 802031ce: 7402 ld s0,32(sp)
+ 802031d0: 64e2 ld s1,24(sp)
+ 802031d2: 6942 ld s2,16(sp)
+ 802031d4: 69a2 ld s3,8(sp)
+ 802031d6: 6145 addi sp,sp,48
+ 802031d8: 8082 ret
+
+00000000802031da <sys_exec>:
+
+extern int exec(char *path, char **argv);
+
+uint64
+sys_exec(void)
+{
+ 802031da: d9010113 addi sp,sp,-624
+ 802031de: 26113423 sd ra,616(sp)
+ 802031e2: 26813023 sd s0,608(sp)
+ 802031e6: 24913c23 sd s1,600(sp)
+ 802031ea: 25213823 sd s2,592(sp)
+ 802031ee: 25313423 sd s3,584(sp)
+ 802031f2: 25413023 sd s4,576(sp)
+ 802031f6: 23513c23 sd s5,568(sp)
+ 802031fa: 23613823 sd s6,560(sp)
+ 802031fe: 23713423 sd s7,552(sp)
+ 80203202: 1c80 addi s0,sp,624
+ char path[FAT32_MAX_PATH], *argv[MAXARG];
+ int i;
+ uint64 uargv, uarg;
+
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || argaddr(1, &uargv) < 0){
+ 80203204: 10400613 li a2,260
+ 80203208: ea840593 addi a1,s0,-344
+ 8020320c: 4501 li a0,0
+ 8020320e: 00000097 auipc ra,0x0
+ 80203212: ef8080e7 jalr -264(ra) # 80203106 <argstr>
+ return -1;
+ 80203216: 597d li s2,-1
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || argaddr(1, &uargv) < 0){
+ 80203218: 0c054c63 bltz a0,802032f0 <sys_exec+0x116>
+ 8020321c: da040593 addi a1,s0,-608
+ 80203220: 4505 li a0,1
+ 80203222: 00000097 auipc ra,0x0
+ 80203226: ec2080e7 jalr -318(ra) # 802030e4 <argaddr>
+ 8020322a: 0c054363 bltz a0,802032f0 <sys_exec+0x116>
+ }
+ memset(argv, 0, sizeof(argv));
+ 8020322e: da840a13 addi s4,s0,-600
+ 80203232: 10000613 li a2,256
+ 80203236: 4581 li a1,0
+ 80203238: 8552 mv a0,s4
+ 8020323a: ffffd097 auipc ra,0xffffd
+ 8020323e: 528080e7 jalr 1320(ra) # 80200762 <memset>
+ for(i=0;; i++){
+ if(i >= NELEM(argv)){
+ 80203242: 84d2 mv s1,s4
+ memset(argv, 0, sizeof(argv));
+ 80203244: 89d2 mv s3,s4
+ 80203246: 4901 li s2,0
+ goto bad;
+ }
+ if(fetchaddr(uargv+sizeof(uint64)*i, (uint64*)&uarg) < 0){
+ 80203248: d9840a93 addi s5,s0,-616
+ if(i >= NELEM(argv)){
+ 8020324c: 02000b13 li s6,32
+ 80203250: 00090b9b sext.w s7,s2
+ if(fetchaddr(uargv+sizeof(uint64)*i, (uint64*)&uarg) < 0){
+ 80203254: 00391513 slli a0,s2,0x3
+ 80203258: 85d6 mv a1,s5
+ 8020325a: da043783 ld a5,-608(s0)
+ 8020325e: 953e add a0,a0,a5
+ 80203260: 00000097 auipc ra,0x0
+ 80203264: da2080e7 jalr -606(ra) # 80203002 <fetchaddr>
+ 80203268: 02054a63 bltz a0,8020329c <sys_exec+0xc2>
+ goto bad;
+ }
+ if(uarg == 0){
+ 8020326c: d9843783 ld a5,-616(s0)
+ 80203270: c3b9 beqz a5,802032b6 <sys_exec+0xdc>
+ argv[i] = 0;
+ break;
+ }
+ argv[i] = kalloc();
+ 80203272: ffffd097 auipc ra,0xffffd
+ 80203276: 2e8080e7 jalr 744(ra) # 8020055a <kalloc>
+ 8020327a: 85aa mv a1,a0
+ 8020327c: 00a9b023 sd a0,0(s3)
+ if(argv[i] == 0)
+ 80203280: cd11 beqz a0,8020329c <sys_exec+0xc2>
+ goto bad;
+ if(fetchstr(uarg, argv[i], PGSIZE) < 0)
+ 80203282: 6605 lui a2,0x1
+ 80203284: d9843503 ld a0,-616(s0)
+ 80203288: 00000097 auipc ra,0x0
+ 8020328c: dca080e7 jalr -566(ra) # 80203052 <fetchstr>
+ 80203290: 00054663 bltz a0,8020329c <sys_exec+0xc2>
+ if(i >= NELEM(argv)){
+ 80203294: 0905 addi s2,s2,1
+ 80203296: 09a1 addi s3,s3,8
+ 80203298: fb691ce3 bne s2,s6,80203250 <sys_exec+0x76>
+ kfree(argv[i]);
+
+ return ret;
+
+ bad:
+ for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
+ 8020329c: 100a0a13 addi s4,s4,256
+ 802032a0: 6088 ld a0,0(s1)
+ 802032a2: c531 beqz a0,802032ee <sys_exec+0x114>
+ kfree(argv[i]);
+ 802032a4: ffffd097 auipc ra,0xffffd
+ 802032a8: 19c080e7 jalr 412(ra) # 80200440 <kfree>
+ for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
+ 802032ac: 04a1 addi s1,s1,8
+ 802032ae: ff4499e3 bne s1,s4,802032a0 <sys_exec+0xc6>
+ return -1;
+ 802032b2: 597d li s2,-1
+ 802032b4: a835 j 802032f0 <sys_exec+0x116>
+ argv[i] = 0;
+ 802032b6: 0b8e slli s7,s7,0x3
+ 802032b8: fb0b8793 addi a5,s7,-80
+ 802032bc: 00878bb3 add s7,a5,s0
+ 802032c0: de0bbc23 sd zero,-520(s7)
+ int ret = exec(path, argv);
+ 802032c4: da840593 addi a1,s0,-600
+ 802032c8: ea840513 addi a0,s0,-344
+ 802032cc: 00001097 auipc ra,0x1
+ 802032d0: 0ac080e7 jalr 172(ra) # 80204378 <exec>
+ 802032d4: 892a mv s2,a0
+ for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
+ 802032d6: 100a0a13 addi s4,s4,256
+ 802032da: 6088 ld a0,0(s1)
+ 802032dc: c911 beqz a0,802032f0 <sys_exec+0x116>
+ kfree(argv[i]);
+ 802032de: ffffd097 auipc ra,0xffffd
+ 802032e2: 162080e7 jalr 354(ra) # 80200440 <kfree>
+ for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
+ 802032e6: 04a1 addi s1,s1,8
+ 802032e8: ff4499e3 bne s1,s4,802032da <sys_exec+0x100>
+ 802032ec: a011 j 802032f0 <sys_exec+0x116>
+ return -1;
+ 802032ee: 597d li s2,-1
+}
+ 802032f0: 854a mv a0,s2
+ 802032f2: 26813083 ld ra,616(sp)
+ 802032f6: 26013403 ld s0,608(sp)
+ 802032fa: 25813483 ld s1,600(sp)
+ 802032fe: 25013903 ld s2,592(sp)
+ 80203302: 24813983 ld s3,584(sp)
+ 80203306: 24013a03 ld s4,576(sp)
+ 8020330a: 23813a83 ld s5,568(sp)
+ 8020330e: 23013b03 ld s6,560(sp)
+ 80203312: 22813b83 ld s7,552(sp)
+ 80203316: 27010113 addi sp,sp,624
+ 8020331a: 8082 ret
+
+000000008020331c <sys_exit>:
+
+uint64
+sys_exit(void)
+{
+ 8020331c: 1101 addi sp,sp,-32
+ 8020331e: ec06 sd ra,24(sp)
+ 80203320: e822 sd s0,16(sp)
+ 80203322: 1000 addi s0,sp,32
+ int n;
+ if(argint(0, &n) < 0)
+ 80203324: fec40593 addi a1,s0,-20
+ 80203328: 4501 li a0,0
+ 8020332a: 00000097 auipc ra,0x0
+ 8020332e: d58080e7 jalr -680(ra) # 80203082 <argint>
+ return -1;
+ 80203332: 57fd li a5,-1
+ if(argint(0, &n) < 0)
+ 80203334: 00054963 bltz a0,80203346 <sys_exit+0x2a>
+ exit(n);
+ 80203338: fec42503 lw a0,-20(s0)
+ 8020333c: fffff097 auipc ra,0xfffff
+ 80203340: f7c080e7 jalr -132(ra) # 802022b8 <exit>
+ return 0; // not reached
+ 80203344: 4781 li a5,0
+}
+ 80203346: 853e mv a0,a5
+ 80203348: 60e2 ld ra,24(sp)
+ 8020334a: 6442 ld s0,16(sp)
+ 8020334c: 6105 addi sp,sp,32
+ 8020334e: 8082 ret
+
+0000000080203350 <sys_getpid>:
+
+
+
+uint64
+sys_getpid(void)
+{
+ 80203350: 1141 addi sp,sp,-16
+ 80203352: e406 sd ra,8(sp)
+ 80203354: e022 sd s0,0(sp)
+ 80203356: 0800 addi s0,sp,16
+ return myproc()->pid;
+ 80203358: ffffe097 auipc ra,0xffffe
+ 8020335c: 6e4080e7 jalr 1764(ra) # 80201a3c <myproc>
+}
+ 80203360: 5d08 lw a0,56(a0)
+ 80203362: 60a2 ld ra,8(sp)
+ 80203364: 6402 ld s0,0(sp)
+ 80203366: 0141 addi sp,sp,16
+ 80203368: 8082 ret
+
+000000008020336a <sys_getppid>:
+
+uint64
+sys_getppid(void)
+{
+ 8020336a: 1141 addi sp,sp,-16
+ 8020336c: e406 sd ra,8(sp)
+ 8020336e: e022 sd s0,0(sp)
+ 80203370: 0800 addi s0,sp,16
+ return myproc()->parent->pid;
+ 80203372: ffffe097 auipc ra,0xffffe
+ 80203376: 6ca080e7 jalr 1738(ra) # 80201a3c <myproc>
+ 8020337a: 711c ld a5,32(a0)
+}
+ 8020337c: 5f88 lw a0,56(a5)
+ 8020337e: 60a2 ld ra,8(sp)
+ 80203380: 6402 ld s0,0(sp)
+ 80203382: 0141 addi sp,sp,16
+ 80203384: 8082 ret
+
+0000000080203386 <sys_fork>:
+
+
+uint64
+sys_fork(void)
+{
+ 80203386: 1141 addi sp,sp,-16
+ 80203388: e406 sd ra,8(sp)
+ 8020338a: e022 sd s0,0(sp)
+ 8020338c: 0800 addi s0,sp,16
+ return fork();
+ 8020338e: fffff097 auipc ra,0xfffff
+ 80203392: ab4080e7 jalr -1356(ra) # 80201e42 <fork>
+}
+ 80203396: 60a2 ld ra,8(sp)
+ 80203398: 6402 ld s0,0(sp)
+ 8020339a: 0141 addi sp,sp,16
+ 8020339c: 8082 ret
+
+000000008020339e <sys_clone>:
+
+uint64
+sys_clone(void)
+{
+ 8020339e: 1101 addi sp,sp,-32
+ 802033a0: ec06 sd ra,24(sp)
+ 802033a2: e822 sd s0,16(sp)
+ 802033a4: 1000 addi s0,sp,32
+ int stack;
+ if(argint(1, &stack) < 0)
+ 802033a6: fec40593 addi a1,s0,-20
+ 802033aa: 4505 li a0,1
+ 802033ac: 00000097 auipc ra,0x0
+ 802033b0: cd6080e7 jalr -810(ra) # 80203082 <argint>
+ 802033b4: 87aa mv a5,a0
+ return -1;
+ 802033b6: 557d li a0,-1
+ if(argint(1, &stack) < 0)
+ 802033b8: 0007c863 bltz a5,802033c8 <sys_clone+0x2a>
+ return clone(stack);
+ 802033bc: fec42503 lw a0,-20(s0)
+ 802033c0: fffff097 auipc ra,0xfffff
+ 802033c4: b9a080e7 jalr -1126(ra) # 80201f5a <clone>
+}
+ 802033c8: 60e2 ld ra,24(sp)
+ 802033ca: 6442 ld s0,16(sp)
+ 802033cc: 6105 addi sp,sp,32
+ 802033ce: 8082 ret
+
+00000000802033d0 <sys_wait>:
+
+uint64
+sys_wait(void)
+{
+ 802033d0: 1101 addi sp,sp,-32
+ 802033d2: ec06 sd ra,24(sp)
+ 802033d4: e822 sd s0,16(sp)
+ 802033d6: 1000 addi s0,sp,32
+ uint64 p;
+ if(argaddr(0, &p) < 0)
+ 802033d8: fe840593 addi a1,s0,-24
+ 802033dc: 4501 li a0,0
+ 802033de: 00000097 auipc ra,0x0
+ 802033e2: d06080e7 jalr -762(ra) # 802030e4 <argaddr>
+ 802033e6: 87aa mv a5,a0
+ return -1;
+ 802033e8: 557d li a0,-1
+ if(argaddr(0, &p) < 0)
+ 802033ea: 0007c863 bltz a5,802033fa <sys_wait+0x2a>
+ return wait(p);
+ 802033ee: fe843503 ld a0,-24(s0)
+ 802033f2: fffff097 auipc ra,0xfffff
+ 802033f6: 080080e7 jalr 128(ra) # 80202472 <wait>
+}
+ 802033fa: 60e2 ld ra,24(sp)
+ 802033fc: 6442 ld s0,16(sp)
+ 802033fe: 6105 addi sp,sp,32
+ 80203400: 8082 ret
+
+0000000080203402 <sys_wait4>:
+
+uint64
+sys_wait4(void)
+{
+ 80203402: 1101 addi sp,sp,-32
+ 80203404: ec06 sd ra,24(sp)
+ 80203406: e822 sd s0,16(sp)
+ 80203408: 1000 addi s0,sp,32
+ uint64 status;
+ int pid, options;
+ if(argint(0, &pid) < 0 || argaddr(1, &status) < 0 || argint(2, &options) < 0)
+ 8020340a: fe440593 addi a1,s0,-28
+ 8020340e: 4501 li a0,0
+ 80203410: 00000097 auipc ra,0x0
+ 80203414: c72080e7 jalr -910(ra) # 80203082 <argint>
+ return -1;
+ 80203418: 57fd li a5,-1
+ if(argint(0, &pid) < 0 || argaddr(1, &status) < 0 || argint(2, &options) < 0)
+ 8020341a: 04054163 bltz a0,8020345c <sys_wait4+0x5a>
+ 8020341e: fe840593 addi a1,s0,-24
+ 80203422: 4505 li a0,1
+ 80203424: 00000097 auipc ra,0x0
+ 80203428: cc0080e7 jalr -832(ra) # 802030e4 <argaddr>
+ return -1;
+ 8020342c: 57fd li a5,-1
+ if(argint(0, &pid) < 0 || argaddr(1, &status) < 0 || argint(2, &options) < 0)
+ 8020342e: 02054763 bltz a0,8020345c <sys_wait4+0x5a>
+ 80203432: fe040593 addi a1,s0,-32
+ 80203436: 4509 li a0,2
+ 80203438: 00000097 auipc ra,0x0
+ 8020343c: c4a080e7 jalr -950(ra) # 80203082 <argint>
+ return -1;
+ 80203440: 57fd li a5,-1
+ if(argint(0, &pid) < 0 || argaddr(1, &status) < 0 || argint(2, &options) < 0)
+ 80203442: 00054d63 bltz a0,8020345c <sys_wait4+0x5a>
+
+ return wait4(pid, status, options);
+ 80203446: fe042603 lw a2,-32(s0)
+ 8020344a: fe843583 ld a1,-24(s0)
+ 8020344e: fe442503 lw a0,-28(s0)
+ 80203452: fffff097 auipc ra,0xfffff
+ 80203456: 11e080e7 jalr 286(ra) # 80202570 <wait4>
+ 8020345a: 87aa mv a5,a0
+}
+ 8020345c: 853e mv a0,a5
+ 8020345e: 60e2 ld ra,24(sp)
+ 80203460: 6442 ld s0,16(sp)
+ 80203462: 6105 addi sp,sp,32
+ 80203464: 8082 ret
+
+0000000080203466 <sys_sbrk>:
+
+uint64
+sys_sbrk(void)
+{
+ 80203466: 7179 addi sp,sp,-48
+ 80203468: f406 sd ra,40(sp)
+ 8020346a: f022 sd s0,32(sp)
+ 8020346c: ec26 sd s1,24(sp)
+ 8020346e: 1800 addi s0,sp,48
+ int addr;
+ int n;
+
+ if(argint(0, &n) < 0)
+ 80203470: fdc40593 addi a1,s0,-36
+ 80203474: 4501 li a0,0
+ 80203476: 00000097 auipc ra,0x0
+ 8020347a: c0c080e7 jalr -1012(ra) # 80203082 <argint>
+ 8020347e: 87aa mv a5,a0
+ return -1;
+ 80203480: 557d li a0,-1
+ if(argint(0, &n) < 0)
+ 80203482: 0207c063 bltz a5,802034a2 <sys_sbrk+0x3c>
+ addr = myproc()->sz;
+ 80203486: ffffe097 auipc ra,0xffffe
+ 8020348a: 5b6080e7 jalr 1462(ra) # 80201a3c <myproc>
+ 8020348e: 4524 lw s1,72(a0)
+ if(growproc(n) < 0)
+ 80203490: fdc42503 lw a0,-36(s0)
+ 80203494: fffff097 auipc ra,0xfffff
+ 80203498: 932080e7 jalr -1742(ra) # 80201dc6 <growproc>
+ 8020349c: 00054863 bltz a0,802034ac <sys_sbrk+0x46>
+ return -1;
+ return addr;
+ 802034a0: 8526 mv a0,s1
+}
+ 802034a2: 70a2 ld ra,40(sp)
+ 802034a4: 7402 ld s0,32(sp)
+ 802034a6: 64e2 ld s1,24(sp)
+ 802034a8: 6145 addi sp,sp,48
+ 802034aa: 8082 ret
+ return -1;
+ 802034ac: 557d li a0,-1
+ 802034ae: bfd5 j 802034a2 <sys_sbrk+0x3c>
+
+00000000802034b0 <sys_sleep>:
+
+uint64
+sys_sleep(void)
+{
+ 802034b0: 7139 addi sp,sp,-64
+ 802034b2: fc06 sd ra,56(sp)
+ 802034b4: f822 sd s0,48(sp)
+ 802034b6: f426 sd s1,40(sp)
+ 802034b8: f04a sd s2,32(sp)
+ 802034ba: ec4e sd s3,24(sp)
+ 802034bc: 0080 addi s0,sp,64
+ int n;
+ uint ticks0;
+
+ if(argint(0, &n) < 0)
+ 802034be: fcc40593 addi a1,s0,-52
+ 802034c2: 4501 li a0,0
+ 802034c4: 00000097 auipc ra,0x0
+ 802034c8: bbe080e7 jalr -1090(ra) # 80203082 <argint>
+ return -1;
+ 802034cc: 57fd li a5,-1
+ if(argint(0, &n) < 0)
+ 802034ce: 06054763 bltz a0,8020353c <sys_sleep+0x8c>
+ acquire(&tickslock);
+ 802034d2: 00009517 auipc a0,0x9
+ 802034d6: 83653503 ld a0,-1994(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802034da: ffffd097 auipc ra,0xffffd
+ 802034de: 1ec080e7 jalr 492(ra) # 802006c6 <acquire>
+ ticks0 = ticks;
+ 802034e2: 00009797 auipc a5,0x9
+ 802034e6: 8367b783 ld a5,-1994(a5) # 8020bd18 <_GLOBAL_OFFSET_TABLE_+0x40>
+ 802034ea: 0007a903 lw s2,0(a5)
+ while(ticks - ticks0 < n){
+ 802034ee: fcc42783 lw a5,-52(s0)
+ 802034f2: cf85 beqz a5,8020352a <sys_sleep+0x7a>
+ if(myproc()->killed){
+ release(&tickslock);
+ return -1;
+ }
+ sleep(&ticks, &tickslock);
+ 802034f4: 00009997 auipc s3,0x9
+ 802034f8: 8149b983 ld s3,-2028(s3) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802034fc: 00009497 auipc s1,0x9
+ 80203500: 81c4b483 ld s1,-2020(s1) # 8020bd18 <_GLOBAL_OFFSET_TABLE_+0x40>
+ if(myproc()->killed){
+ 80203504: ffffe097 auipc ra,0xffffe
+ 80203508: 538080e7 jalr 1336(ra) # 80201a3c <myproc>
+ 8020350c: 591c lw a5,48(a0)
+ 8020350e: ef9d bnez a5,8020354c <sys_sleep+0x9c>
+ sleep(&ticks, &tickslock);
+ 80203510: 85ce mv a1,s3
+ 80203512: 8526 mv a0,s1
+ 80203514: fffff097 auipc ra,0xfffff
+ 80203518: ee0080e7 jalr -288(ra) # 802023f4 <sleep>
+ while(ticks - ticks0 < n){
+ 8020351c: 409c lw a5,0(s1)
+ 8020351e: 412787bb subw a5,a5,s2
+ 80203522: fcc42703 lw a4,-52(s0)
+ 80203526: fce7efe3 bltu a5,a4,80203504 <sys_sleep+0x54>
+ }
+ release(&tickslock);
+ 8020352a: 00008517 auipc a0,0x8
+ 8020352e: 7de53503 ld a0,2014(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 80203532: ffffd097 auipc ra,0xffffd
+ 80203536: 1e8080e7 jalr 488(ra) # 8020071a <release>
+ return 0;
+ 8020353a: 4781 li a5,0
+}
+ 8020353c: 853e mv a0,a5
+ 8020353e: 70e2 ld ra,56(sp)
+ 80203540: 7442 ld s0,48(sp)
+ 80203542: 74a2 ld s1,40(sp)
+ 80203544: 7902 ld s2,32(sp)
+ 80203546: 69e2 ld s3,24(sp)
+ 80203548: 6121 addi sp,sp,64
+ 8020354a: 8082 ret
+ release(&tickslock);
+ 8020354c: 00008517 auipc a0,0x8
+ 80203550: 7bc53503 ld a0,1980(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 80203554: ffffd097 auipc ra,0xffffd
+ 80203558: 1c6080e7 jalr 454(ra) # 8020071a <release>
+ return -1;
+ 8020355c: 57fd li a5,-1
+ 8020355e: bff9 j 8020353c <sys_sleep+0x8c>
+
+0000000080203560 <sys_nanosleep>:
+
+
+uint64
+sys_nanosleep(void)
+{
+ 80203560: 715d addi sp,sp,-80
+ 80203562: e486 sd ra,72(sp)
+ 80203564: e0a2 sd s0,64(sp)
+ 80203566: fc26 sd s1,56(sp)
+ 80203568: f84a sd s2,48(sp)
+ 8020356a: f44e sd s3,40(sp)
+ 8020356c: f052 sd s4,32(sp)
+ 8020356e: 0880 addi s0,sp,80
+ uint64 addr1, addr2;
+ uint64 time0, time;
+ uint64 tv_sec, tv_nsec;
+
+ if(argaddr(0, &addr1) < 0 || argaddr(1, &addr2) < 0)
+ 80203570: fc840593 addi a1,s0,-56
+ 80203574: 4501 li a0,0
+ 80203576: 00000097 auipc ra,0x0
+ 8020357a: b6e080e7 jalr -1170(ra) # 802030e4 <argaddr>
+ return -1;
+ 8020357e: 57fd li a5,-1
+ if(argaddr(0, &addr1) < 0 || argaddr(1, &addr2) < 0)
+ 80203580: 0a054d63 bltz a0,8020363a <sys_nanosleep+0xda>
+ 80203584: fc040593 addi a1,s0,-64
+ 80203588: 4505 li a0,1
+ 8020358a: 00000097 auipc ra,0x0
+ 8020358e: b5a080e7 jalr -1190(ra) # 802030e4 <argaddr>
+ return -1;
+ 80203592: 57fd li a5,-1
+ if(argaddr(0, &addr1) < 0 || argaddr(1, &addr2) < 0)
+ 80203594: 0a054363 bltz a0,8020363a <sys_nanosleep+0xda>
+ if(fetchaddr(addr1, &tv_sec) < 0 || fetchaddr(addr2, &tv_nsec) < 0)
+ 80203598: fb840593 addi a1,s0,-72
+ 8020359c: fc843503 ld a0,-56(s0)
+ 802035a0: 00000097 auipc ra,0x0
+ 802035a4: a62080e7 jalr -1438(ra) # 80203002 <fetchaddr>
+ return -1;
+ 802035a8: 57fd li a5,-1
+ if(fetchaddr(addr1, &tv_sec) < 0 || fetchaddr(addr2, &tv_nsec) < 0)
+ 802035aa: 08054863 bltz a0,8020363a <sys_nanosleep+0xda>
+ 802035ae: fb040593 addi a1,s0,-80
+ 802035b2: fc043503 ld a0,-64(s0)
+ 802035b6: 00000097 auipc ra,0x0
+ 802035ba: a4c080e7 jalr -1460(ra) # 80203002 <fetchaddr>
+ return -1;
+ 802035be: 57fd li a5,-1
+ if(fetchaddr(addr1, &tv_sec) < 0 || fetchaddr(addr2, &tv_nsec) < 0)
+ 802035c0: 06054d63 bltz a0,8020363a <sys_nanosleep+0xda>
+ asm volatile("rdtime %0" : "=r" (x) );
+ 802035c4: c0102973 rdtime s2
+
+ time = r_time();
+ time0 = time;
+ acquire(&tickslock);
+ 802035c8: 00008517 auipc a0,0x8
+ 802035cc: 74053503 ld a0,1856(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802035d0: ffffd097 auipc ra,0xffffd
+ 802035d4: 0f6080e7 jalr 246(ra) # 802006c6 <acquire>
+ while(time - time0 < tv_sec * 12500000) {
+ 802035d8: fb843783 ld a5,-72(s0)
+ 802035dc: 00bec737 lui a4,0xbec
+ 802035e0: c2070713 addi a4,a4,-992 # bebc20 <_entry-0x7f6143e0>
+ 802035e4: 02e787b3 mul a5,a5,a4
+ 802035e8: c3a1 beqz a5,80203628 <sys_nanosleep+0xc8>
+ if(myproc()->killed) {
+ release(&tickslock);
+ return -1;
+ }
+ sleep(&ticks, &tickslock);
+ 802035ea: 00008a17 auipc s4,0x8
+ 802035ee: 71ea3a03 ld s4,1822(s4) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802035f2: 00008997 auipc s3,0x8
+ 802035f6: 7269b983 ld s3,1830(s3) # 8020bd18 <_GLOBAL_OFFSET_TABLE_+0x40>
+ while(time - time0 < tv_sec * 12500000) {
+ 802035fa: 84ba mv s1,a4
+ if(myproc()->killed) {
+ 802035fc: ffffe097 auipc ra,0xffffe
+ 80203600: 440080e7 jalr 1088(ra) # 80201a3c <myproc>
+ 80203604: 591c lw a5,48(a0)
+ 80203606: e3b9 bnez a5,8020364c <sys_nanosleep+0xec>
+ sleep(&ticks, &tickslock);
+ 80203608: 85d2 mv a1,s4
+ 8020360a: 854e mv a0,s3
+ 8020360c: fffff097 auipc ra,0xfffff
+ 80203610: de8080e7 jalr -536(ra) # 802023f4 <sleep>
+ 80203614: c0102773 rdtime a4
+ while(time - time0 < tv_sec * 12500000) {
+ 80203618: 41270733 sub a4,a4,s2
+ 8020361c: fb843783 ld a5,-72(s0)
+ 80203620: 029787b3 mul a5,a5,s1
+ 80203624: fcf76ce3 bltu a4,a5,802035fc <sys_nanosleep+0x9c>
+ time = r_time();
+ }
+ release(&tickslock);
+ 80203628: 00008517 auipc a0,0x8
+ 8020362c: 6e053503 ld a0,1760(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 80203630: ffffd097 auipc ra,0xffffd
+ 80203634: 0ea080e7 jalr 234(ra) # 8020071a <release>
+ return 0;
+ 80203638: 4781 li a5,0
+}
+ 8020363a: 853e mv a0,a5
+ 8020363c: 60a6 ld ra,72(sp)
+ 8020363e: 6406 ld s0,64(sp)
+ 80203640: 74e2 ld s1,56(sp)
+ 80203642: 7942 ld s2,48(sp)
+ 80203644: 79a2 ld s3,40(sp)
+ 80203646: 7a02 ld s4,32(sp)
+ 80203648: 6161 addi sp,sp,80
+ 8020364a: 8082 ret
+ release(&tickslock);
+ 8020364c: 00008517 auipc a0,0x8
+ 80203650: 6bc53503 ld a0,1724(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 80203654: ffffd097 auipc ra,0xffffd
+ 80203658: 0c6080e7 jalr 198(ra) # 8020071a <release>
+ return -1;
+ 8020365c: 57fd li a5,-1
+ 8020365e: bff1 j 8020363a <sys_nanosleep+0xda>
+
+0000000080203660 <sys_kill>:
+
+uint64
+sys_kill(void)
+{
+ 80203660: 1101 addi sp,sp,-32
+ 80203662: ec06 sd ra,24(sp)
+ 80203664: e822 sd s0,16(sp)
+ 80203666: 1000 addi s0,sp,32
+ int pid;
+
+ if(argint(0, &pid) < 0)
+ 80203668: fec40593 addi a1,s0,-20
+ 8020366c: 4501 li a0,0
+ 8020366e: 00000097 auipc ra,0x0
+ 80203672: a14080e7 jalr -1516(ra) # 80203082 <argint>
+ 80203676: 87aa mv a5,a0
+ return -1;
+ 80203678: 557d li a0,-1
+ if(argint(0, &pid) < 0)
+ 8020367a: 0007c863 bltz a5,8020368a <sys_kill+0x2a>
+ return kill(pid);
+ 8020367e: fec42503 lw a0,-20(s0)
+ 80203682: fffff097 auipc ra,0xfffff
+ 80203686: 074080e7 jalr 116(ra) # 802026f6 <kill>
+}
+ 8020368a: 60e2 ld ra,24(sp)
+ 8020368c: 6442 ld s0,16(sp)
+ 8020368e: 6105 addi sp,sp,32
+ 80203690: 8082 ret
+
+0000000080203692 <sys_uptime>:
+
+// return how many clock tick interrupts have occurred
+// since start.
+uint64
+sys_uptime(void)
+{
+ 80203692: 1101 addi sp,sp,-32
+ 80203694: ec06 sd ra,24(sp)
+ 80203696: e822 sd s0,16(sp)
+ 80203698: e426 sd s1,8(sp)
+ 8020369a: 1000 addi s0,sp,32
+ uint xticks;
+
+ acquire(&tickslock);
+ 8020369c: 00008517 auipc a0,0x8
+ 802036a0: 66c53503 ld a0,1644(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802036a4: ffffd097 auipc ra,0xffffd
+ 802036a8: 022080e7 jalr 34(ra) # 802006c6 <acquire>
+ xticks = ticks;
+ 802036ac: 00008797 auipc a5,0x8
+ 802036b0: 66c7b783 ld a5,1644(a5) # 8020bd18 <_GLOBAL_OFFSET_TABLE_+0x40>
+ 802036b4: 4384 lw s1,0(a5)
+ release(&tickslock);
+ 802036b6: 00008517 auipc a0,0x8
+ 802036ba: 65253503 ld a0,1618(a0) # 8020bd08 <_GLOBAL_OFFSET_TABLE_+0x30>
+ 802036be: ffffd097 auipc ra,0xffffd
+ 802036c2: 05c080e7 jalr 92(ra) # 8020071a <release>
+ return xticks;
+}
+ 802036c6: 02049513 slli a0,s1,0x20
+ 802036ca: 9101 srli a0,a0,0x20
+ 802036cc: 60e2 ld ra,24(sp)
+ 802036ce: 6442 ld s0,16(sp)
+ 802036d0: 64a2 ld s1,8(sp)
+ 802036d2: 6105 addi sp,sp,32
+ 802036d4: 8082 ret
+
+00000000802036d6 <sys_times>:
+
+uint64
+sys_times(void)
+{
+ 802036d6: 1141 addi sp,sp,-16
+ 802036d8: e406 sd ra,8(sp)
+ 802036da: e022 sd s0,0(sp)
+ 802036dc: 0800 addi s0,sp,16
+ return sys_uptime();
+ 802036de: 00000097 auipc ra,0x0
+ 802036e2: fb4080e7 jalr -76(ra) # 80203692 <sys_uptime>
+}
+ 802036e6: 60a2 ld ra,8(sp)
+ 802036e8: 6402 ld s0,0(sp)
+ 802036ea: 0141 addi sp,sp,16
+ 802036ec: 8082 ret
+
+00000000802036ee <sys_trace>:
+
+
+uint64
+sys_trace(void)
+{
+ 802036ee: 1101 addi sp,sp,-32
+ 802036f0: ec06 sd ra,24(sp)
+ 802036f2: e822 sd s0,16(sp)
+ 802036f4: 1000 addi s0,sp,32
+ int mask;
+ if(argint(0, &mask) < 0) {
+ 802036f6: fec40593 addi a1,s0,-20
+ 802036fa: 4501 li a0,0
+ 802036fc: 00000097 auipc ra,0x0
+ 80203700: 986080e7 jalr -1658(ra) # 80203082 <argint>
+ return -1;
+ 80203704: 57fd li a5,-1
+ if(argint(0, &mask) < 0) {
+ 80203706: 00054b63 bltz a0,8020371c <sys_trace+0x2e>
+ }
+ myproc()->tmask = mask;
+ 8020370a: ffffe097 auipc ra,0xffffe
+ 8020370e: 332080e7 jalr 818(ra) # 80201a3c <myproc>
+ 80203712: fec42783 lw a5,-20(s0)
+ 80203716: 16f52823 sw a5,368(a0)
+ return 0;
+ 8020371a: 4781 li a5,0
+}
+ 8020371c: 853e mv a0,a5
+ 8020371e: 60e2 ld ra,24(sp)
+ 80203720: 6442 ld s0,16(sp)
+ 80203722: 6105 addi sp,sp,32
+ 80203724: 8082 ret
+
+0000000080203726 <sys_shutdown>:
+
+uint64
+sys_shutdown(void) {
+ 80203726: 1141 addi sp,sp,-16
+ 80203728: e422 sd s0,8(sp)
+ 8020372a: 0800 addi s0,sp,16
+ SBI_CALL_0(SBI_SHUTDOWN);
+ 8020372c: 4501 li a0,0
+ 8020372e: 4581 li a1,0
+ 80203730: 4601 li a2,0
+ 80203732: 4681 li a3,0
+ 80203734: 48a1 li a7,8
+ 80203736: 00000073 ecall
+ sbi_shutdown();
+ return 0;
+}
+ 8020373a: 4501 li a0,0
+ 8020373c: 6422 ld s0,8(sp)
+ 8020373e: 0141 addi sp,sp,16
+ 80203740: 8082 ret
+
+0000000080203742 <sys_yield>:
+
+uint64
+sys_yield(void) {
+ 80203742: 1141 addi sp,sp,-16
+ 80203744: e406 sd ra,8(sp)
+ 80203746: e022 sd s0,0(sp)
+ 80203748: 0800 addi s0,sp,16
+ yield();
+ 8020374a: fffff097 auipc ra,0xfffff
+ 8020374e: c6e080e7 jalr -914(ra) # 802023b8 <yield>
+ return 0;
+}
+ 80203752: 4501 li a0,0
+ 80203754: 60a2 ld ra,8(sp)
+ 80203756: 6402 ld s0,0(sp)
+ 80203758: 0141 addi sp,sp,16
+ 8020375a: 8082 ret
+
+000000008020375c <sys_gettimeofday>:
+
+
+uint64
+sys_gettimeofday(void)
+{
+ 8020375c: 7179 addi sp,sp,-48
+ 8020375e: f406 sd ra,40(sp)
+ 80203760: f022 sd s0,32(sp)
+ 80203762: 1800 addi s0,sp,48
+ long tv_sec; /* 秒 */
+ long tv_nsec; /* 纳秒, 范围在0~999999999 */
+ };
+ struct timespec tm;
+
+ if(argaddr(0, &addr) < 0)
+ 80203764: fe840593 addi a1,s0,-24
+ 80203768: 4501 li a0,0
+ 8020376a: 00000097 auipc ra,0x0
+ 8020376e: 97a080e7 jalr -1670(ra) # 802030e4 <argaddr>
+ 80203772: 87aa mv a5,a0
+ return -1;
+ 80203774: 557d li a0,-1
+ if(argaddr(0, &addr) < 0)
+ 80203776: 0207ca63 bltz a5,802037aa <sys_gettimeofday+0x4e>
+ 8020377a: c01027f3 rdtime a5
+
+ uint64 time = r_time();
+
+ tm.tv_sec = time / 12500000;
+ 8020377e: 00bec737 lui a4,0xbec
+ 80203782: c2070713 addi a4,a4,-992 # bebc20 <_entry-0x7f6143e0>
+ 80203786: 02e7d6b3 divu a3,a5,a4
+ 8020378a: fcd43c23 sd a3,-40(s0)
+ tm.tv_nsec = time % 12500000;
+ 8020378e: 02e7f7b3 remu a5,a5,a4
+ 80203792: fef43023 sd a5,-32(s0)
+ if(copyout2(addr, (char*)&tm, sizeof(tm)) < 0)
+ 80203796: 4641 li a2,16
+ 80203798: fd840593 addi a1,s0,-40
+ 8020379c: fe843503 ld a0,-24(s0)
+ 802037a0: ffffe097 auipc ra,0xffffe
+ 802037a4: bd2080e7 jalr -1070(ra) # 80201372 <copyout2>
+ 802037a8: 957d srai a0,a0,0x3f
+ return -1;
+
+ return 0;
+ 802037aa: 70a2 ld ra,40(sp)
+ 802037ac: 7402 ld s0,32(sp)
+ 802037ae: 6145 addi sp,sp,48
+ 802037b0: 8082 ret
+
+00000000802037b2 <binit>:
+ struct buf head;
+} bcache;
+
+void
+binit(void)
+{
+ 802037b2: 7139 addi sp,sp,-64
+ 802037b4: fc06 sd ra,56(sp)
+ 802037b6: f822 sd s0,48(sp)
+ 802037b8: f426 sd s1,40(sp)
+ 802037ba: f04a sd s2,32(sp)
+ 802037bc: ec4e sd s3,24(sp)
+ 802037be: e852 sd s4,16(sp)
+ 802037c0: e456 sd s5,8(sp)
+ 802037c2: 0080 addi s0,sp,64
+ struct buf *b;
+
+ initlock(&bcache.lock, "bcache");
+ 802037c4: 00006597 auipc a1,0x6
+ 802037c8: 4cc58593 addi a1,a1,1228 # 80209c90 <digits+0x910>
+ 802037cc: 00015517 auipc a0,0x15
+ 802037d0: 32450513 addi a0,a0,804 # 80218af0 <bcache>
+ 802037d4: ffffd097 auipc ra,0xffffd
+ 802037d8: eae080e7 jalr -338(ra) # 80200682 <initlock>
+
+ // Create linked list of buffers
+ bcache.head.prev = &bcache.head;
+ 802037dc: 00019797 auipc a5,0x19
+ 802037e0: 31478793 addi a5,a5,788 # 8021caf0 <bcache+0x4000>
+ 802037e4: 0001a717 auipc a4,0x1a
+ 802037e8: 97470713 addi a4,a4,-1676 # 8021d158 <bcache+0x4668>
+ 802037ec: 6ae7b823 sd a4,1712(a5)
+ bcache.head.next = &bcache.head;
+ 802037f0: 6ae7bc23 sd a4,1720(a5)
+ for(b = bcache.buf; b < bcache.buf+NBUF; b++){
+ 802037f4: 00015497 auipc s1,0x15
+ 802037f8: 31448493 addi s1,s1,788 # 80218b08 <bcache+0x18>
+ b->refcnt = 0;
+ b->sectorno = ~0;
+ 802037fc: 5a7d li s4,-1
+ b->dev = ~0;
+ b->next = bcache.head.next;
+ 802037fe: 893e mv s2,a5
+ b->prev = &bcache.head;
+ 80203800: 89ba mv s3,a4
+ initsleeplock(&b->lock, "buffer");
+ 80203802: 00006a97 auipc s5,0x6
+ 80203806: 496a8a93 addi s5,s5,1174 # 80209c98 <digits+0x918>
+ b->refcnt = 0;
+ 8020380a: 0404a023 sw zero,64(s1)
+ b->sectorno = ~0;
+ 8020380e: 0144a623 sw s4,12(s1)
+ b->dev = ~0;
+ 80203812: 0144a423 sw s4,8(s1)
+ b->next = bcache.head.next;
+ 80203816: 6b893783 ld a5,1720(s2)
+ 8020381a: e8bc sd a5,80(s1)
+ b->prev = &bcache.head;
+ 8020381c: 0534b423 sd s3,72(s1)
+ initsleeplock(&b->lock, "buffer");
+ 80203820: 85d6 mv a1,s5
+ 80203822: 01048513 addi a0,s1,16
+ 80203826: 00000097 auipc ra,0x0
+ 8020382a: 26e080e7 jalr 622(ra) # 80203a94 <initsleeplock>
+ bcache.head.next->prev = b;
+ 8020382e: 6b893783 ld a5,1720(s2)
+ 80203832: e7a4 sd s1,72(a5)
+ bcache.head.next = b;
+ 80203834: 6a993c23 sd s1,1720(s2)
+ for(b = bcache.buf; b < bcache.buf+NBUF; b++){
+ 80203838: 25848493 addi s1,s1,600
+ 8020383c: fd3497e3 bne s1,s3,8020380a <binit+0x58>
+ }
+ #ifdef DEBUG
+ printf("binit\n");
+ #endif
+}
+ 80203840: 70e2 ld ra,56(sp)
+ 80203842: 7442 ld s0,48(sp)
+ 80203844: 74a2 ld s1,40(sp)
+ 80203846: 7902 ld s2,32(sp)
+ 80203848: 69e2 ld s3,24(sp)
+ 8020384a: 6a42 ld s4,16(sp)
+ 8020384c: 6aa2 ld s5,8(sp)
+ 8020384e: 6121 addi sp,sp,64
+ 80203850: 8082 ret
+
+0000000080203852 <bread>:
+ panic("bget: no buffers");
+}
+
+// Return a locked buf with the contents of the indicated block.
+struct buf*
+bread(uint dev, uint sectorno) {
+ 80203852: 7179 addi sp,sp,-48
+ 80203854: f406 sd ra,40(sp)
+ 80203856: f022 sd s0,32(sp)
+ 80203858: ec26 sd s1,24(sp)
+ 8020385a: e84a sd s2,16(sp)
+ 8020385c: e44e sd s3,8(sp)
+ 8020385e: 1800 addi s0,sp,48
+ 80203860: 892a mv s2,a0
+ 80203862: 89ae mv s3,a1
+ acquire(&bcache.lock);
+ 80203864: 00015517 auipc a0,0x15
+ 80203868: 28c50513 addi a0,a0,652 # 80218af0 <bcache>
+ 8020386c: ffffd097 auipc ra,0xffffd
+ 80203870: e5a080e7 jalr -422(ra) # 802006c6 <acquire>
+ for(b = bcache.head.next; b != &bcache.head; b = b->next){
+ 80203874: 0001a497 auipc s1,0x1a
+ 80203878: 9344b483 ld s1,-1740(s1) # 8021d1a8 <bcache+0x46b8>
+ 8020387c: 0001a797 auipc a5,0x1a
+ 80203880: 8dc78793 addi a5,a5,-1828 # 8021d158 <bcache+0x4668>
+ 80203884: 02f48f63 beq s1,a5,802038c2 <bread+0x70>
+ 80203888: 873e mv a4,a5
+ 8020388a: a021 j 80203892 <bread+0x40>
+ 8020388c: 68a4 ld s1,80(s1)
+ 8020388e: 02e48a63 beq s1,a4,802038c2 <bread+0x70>
+ if(b->dev == dev && b->sectorno == sectorno){
+ 80203892: 449c lw a5,8(s1)
+ 80203894: ff279ce3 bne a5,s2,8020388c <bread+0x3a>
+ 80203898: 44dc lw a5,12(s1)
+ 8020389a: ff3799e3 bne a5,s3,8020388c <bread+0x3a>
+ b->refcnt++;
+ 8020389e: 40bc lw a5,64(s1)
+ 802038a0: 2785 addiw a5,a5,1
+ 802038a2: c0bc sw a5,64(s1)
+ release(&bcache.lock);
+ 802038a4: 00015517 auipc a0,0x15
+ 802038a8: 24c50513 addi a0,a0,588 # 80218af0 <bcache>
+ 802038ac: ffffd097 auipc ra,0xffffd
+ 802038b0: e6e080e7 jalr -402(ra) # 8020071a <release>
+ acquiresleep(&b->lock);
+ 802038b4: 01048513 addi a0,s1,16
+ 802038b8: 00000097 auipc ra,0x0
+ 802038bc: 216080e7 jalr 534(ra) # 80203ace <acquiresleep>
+ return b;
+ 802038c0: a8b9 j 8020391e <bread+0xcc>
+ for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
+ 802038c2: 0001a497 auipc s1,0x1a
+ 802038c6: 8de4b483 ld s1,-1826(s1) # 8021d1a0 <bcache+0x46b0>
+ 802038ca: 0001a797 auipc a5,0x1a
+ 802038ce: 88e78793 addi a5,a5,-1906 # 8021d158 <bcache+0x4668>
+ 802038d2: 00f48863 beq s1,a5,802038e2 <bread+0x90>
+ 802038d6: 873e mv a4,a5
+ if(b->refcnt == 0) {
+ 802038d8: 40bc lw a5,64(s1)
+ 802038da: cf81 beqz a5,802038f2 <bread+0xa0>
+ for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
+ 802038dc: 64a4 ld s1,72(s1)
+ 802038de: fee49de3 bne s1,a4,802038d8 <bread+0x86>
+ panic("bget: no buffers");
+ 802038e2: 00006517 auipc a0,0x6
+ 802038e6: 3be50513 addi a0,a0,958 # 80209ca0 <digits+0x920>
+ 802038ea: ffffd097 auipc ra,0xffffd
+ 802038ee: 85a080e7 jalr -1958(ra) # 80200144 <panic>
+ b->dev = dev;
+ 802038f2: 0124a423 sw s2,8(s1)
+ b->sectorno = sectorno;
+ 802038f6: 0134a623 sw s3,12(s1)
+ b->valid = 0;
+ 802038fa: 0004a023 sw zero,0(s1)
+ b->refcnt = 1;
+ 802038fe: 4785 li a5,1
+ 80203900: c0bc sw a5,64(s1)
+ release(&bcache.lock);
+ 80203902: 00015517 auipc a0,0x15
+ 80203906: 1ee50513 addi a0,a0,494 # 80218af0 <bcache>
+ 8020390a: ffffd097 auipc ra,0xffffd
+ 8020390e: e10080e7 jalr -496(ra) # 8020071a <release>
+ acquiresleep(&b->lock);
+ 80203912: 01048513 addi a0,s1,16
+ 80203916: 00000097 auipc ra,0x0
+ 8020391a: 1b8080e7 jalr 440(ra) # 80203ace <acquiresleep>
+ struct buf *b;
+
+ b = bget(dev, sectorno);
+ if (!b->valid) {
+ 8020391e: 409c lw a5,0(s1)
+ 80203920: cb89 beqz a5,80203932 <bread+0xe0>
+ disk_read(b);
+ b->valid = 1;
+ }
+
+ return b;
+}
+ 80203922: 8526 mv a0,s1
+ 80203924: 70a2 ld ra,40(sp)
+ 80203926: 7402 ld s0,32(sp)
+ 80203928: 64e2 ld s1,24(sp)
+ 8020392a: 6942 ld s2,16(sp)
+ 8020392c: 69a2 ld s3,8(sp)
+ 8020392e: 6145 addi sp,sp,48
+ 80203930: 8082 ret
+ disk_read(b);
+ 80203932: 8526 mv a0,s1
+ 80203934: 00002097 auipc ra,0x2
+ 80203938: b9e080e7 jalr -1122(ra) # 802054d2 <disk_read>
+ b->valid = 1;
+ 8020393c: 4785 li a5,1
+ 8020393e: c09c sw a5,0(s1)
+ return b;
+ 80203940: b7cd j 80203922 <bread+0xd0>
+
+0000000080203942 <bwrite>:
+
+// Write b's contents to disk. Must be locked.
+void
+bwrite(struct buf *b) {
+ 80203942: 1101 addi sp,sp,-32
+ 80203944: ec06 sd ra,24(sp)
+ 80203946: e822 sd s0,16(sp)
+ 80203948: e426 sd s1,8(sp)
+ 8020394a: 1000 addi s0,sp,32
+ 8020394c: 84aa mv s1,a0
+ if(!holdingsleep(&b->lock))
+ 8020394e: 0541 addi a0,a0,16
+ 80203950: 00000097 auipc ra,0x0
+ 80203954: 218080e7 jalr 536(ra) # 80203b68 <holdingsleep>
+ 80203958: c919 beqz a0,8020396e <bwrite+0x2c>
+ panic("bwrite");
+ disk_write(b);
+ 8020395a: 8526 mv a0,s1
+ 8020395c: 00002097 auipc ra,0x2
+ 80203960: b90080e7 jalr -1136(ra) # 802054ec <disk_write>
+}
+ 80203964: 60e2 ld ra,24(sp)
+ 80203966: 6442 ld s0,16(sp)
+ 80203968: 64a2 ld s1,8(sp)
+ 8020396a: 6105 addi sp,sp,32
+ 8020396c: 8082 ret
+ panic("bwrite");
+ 8020396e: 00006517 auipc a0,0x6
+ 80203972: 34a50513 addi a0,a0,842 # 80209cb8 <digits+0x938>
+ 80203976: ffffc097 auipc ra,0xffffc
+ 8020397a: 7ce080e7 jalr 1998(ra) # 80200144 <panic>
+
+000000008020397e <brelse>:
+
+// Release a locked buffer.
+// Move to the head of the most-recently-used list.
+void
+brelse(struct buf *b)
+{
+ 8020397e: 1101 addi sp,sp,-32
+ 80203980: ec06 sd ra,24(sp)
+ 80203982: e822 sd s0,16(sp)
+ 80203984: e426 sd s1,8(sp)
+ 80203986: e04a sd s2,0(sp)
+ 80203988: 1000 addi s0,sp,32
+ 8020398a: 84aa mv s1,a0
+ if(!holdingsleep(&b->lock))
+ 8020398c: 01050913 addi s2,a0,16
+ 80203990: 854a mv a0,s2
+ 80203992: 00000097 auipc ra,0x0
+ 80203996: 1d6080e7 jalr 470(ra) # 80203b68 <holdingsleep>
+ 8020399a: c92d beqz a0,80203a0c <brelse+0x8e>
+ panic("brelse");
+
+ releasesleep(&b->lock);
+ 8020399c: 854a mv a0,s2
+ 8020399e: 00000097 auipc ra,0x0
+ 802039a2: 186080e7 jalr 390(ra) # 80203b24 <releasesleep>
+
+ acquire(&bcache.lock);
+ 802039a6: 00015517 auipc a0,0x15
+ 802039aa: 14a50513 addi a0,a0,330 # 80218af0 <bcache>
+ 802039ae: ffffd097 auipc ra,0xffffd
+ 802039b2: d18080e7 jalr -744(ra) # 802006c6 <acquire>
+ b->refcnt--;
+ 802039b6: 40bc lw a5,64(s1)
+ 802039b8: 37fd addiw a5,a5,-1
+ 802039ba: 0007871b sext.w a4,a5
+ 802039be: c0bc sw a5,64(s1)
+ if (b->refcnt == 0) {
+ 802039c0: eb05 bnez a4,802039f0 <brelse+0x72>
+ // no one is waiting for it.
+ b->next->prev = b->prev;
+ 802039c2: 68bc ld a5,80(s1)
+ 802039c4: 64b8 ld a4,72(s1)
+ 802039c6: e7b8 sd a4,72(a5)
+ b->prev->next = b->next;
+ 802039c8: 64bc ld a5,72(s1)
+ 802039ca: 68b8 ld a4,80(s1)
+ 802039cc: ebb8 sd a4,80(a5)
+ b->next = bcache.head.next;
+ 802039ce: 00019797 auipc a5,0x19
+ 802039d2: 12278793 addi a5,a5,290 # 8021caf0 <bcache+0x4000>
+ 802039d6: 6b87b703 ld a4,1720(a5)
+ 802039da: e8b8 sd a4,80(s1)
+ b->prev = &bcache.head;
+ 802039dc: 00019717 auipc a4,0x19
+ 802039e0: 77c70713 addi a4,a4,1916 # 8021d158 <bcache+0x4668>
+ 802039e4: e4b8 sd a4,72(s1)
+ bcache.head.next->prev = b;
+ 802039e6: 6b87b703 ld a4,1720(a5)
+ 802039ea: e724 sd s1,72(a4)
+ bcache.head.next = b;
+ 802039ec: 6a97bc23 sd s1,1720(a5)
+ }
+
+ release(&bcache.lock);
+ 802039f0: 00015517 auipc a0,0x15
+ 802039f4: 10050513 addi a0,a0,256 # 80218af0 <bcache>
+ 802039f8: ffffd097 auipc ra,0xffffd
+ 802039fc: d22080e7 jalr -734(ra) # 8020071a <release>
+}
+ 80203a00: 60e2 ld ra,24(sp)
+ 80203a02: 6442 ld s0,16(sp)
+ 80203a04: 64a2 ld s1,8(sp)
+ 80203a06: 6902 ld s2,0(sp)
+ 80203a08: 6105 addi sp,sp,32
+ 80203a0a: 8082 ret
+ panic("brelse");
+ 80203a0c: 00006517 auipc a0,0x6
+ 80203a10: 2b450513 addi a0,a0,692 # 80209cc0 <digits+0x940>
+ 80203a14: ffffc097 auipc ra,0xffffc
+ 80203a18: 730080e7 jalr 1840(ra) # 80200144 <panic>
+
+0000000080203a1c <bpin>:
+
+void
+bpin(struct buf *b) {
+ 80203a1c: 1101 addi sp,sp,-32
+ 80203a1e: ec06 sd ra,24(sp)
+ 80203a20: e822 sd s0,16(sp)
+ 80203a22: e426 sd s1,8(sp)
+ 80203a24: 1000 addi s0,sp,32
+ 80203a26: 84aa mv s1,a0
+ acquire(&bcache.lock);
+ 80203a28: 00015517 auipc a0,0x15
+ 80203a2c: 0c850513 addi a0,a0,200 # 80218af0 <bcache>
+ 80203a30: ffffd097 auipc ra,0xffffd
+ 80203a34: c96080e7 jalr -874(ra) # 802006c6 <acquire>
+ b->refcnt++;
+ 80203a38: 40bc lw a5,64(s1)
+ 80203a3a: 2785 addiw a5,a5,1
+ 80203a3c: c0bc sw a5,64(s1)
+ release(&bcache.lock);
+ 80203a3e: 00015517 auipc a0,0x15
+ 80203a42: 0b250513 addi a0,a0,178 # 80218af0 <bcache>
+ 80203a46: ffffd097 auipc ra,0xffffd
+ 80203a4a: cd4080e7 jalr -812(ra) # 8020071a <release>
+}
+ 80203a4e: 60e2 ld ra,24(sp)
+ 80203a50: 6442 ld s0,16(sp)
+ 80203a52: 64a2 ld s1,8(sp)
+ 80203a54: 6105 addi sp,sp,32
+ 80203a56: 8082 ret
+
+0000000080203a58 <bunpin>:
+
+void
+bunpin(struct buf *b) {
+ 80203a58: 1101 addi sp,sp,-32
+ 80203a5a: ec06 sd ra,24(sp)
+ 80203a5c: e822 sd s0,16(sp)
+ 80203a5e: e426 sd s1,8(sp)
+ 80203a60: 1000 addi s0,sp,32
+ 80203a62: 84aa mv s1,a0
+ acquire(&bcache.lock);
+ 80203a64: 00015517 auipc a0,0x15
+ 80203a68: 08c50513 addi a0,a0,140 # 80218af0 <bcache>
+ 80203a6c: ffffd097 auipc ra,0xffffd
+ 80203a70: c5a080e7 jalr -934(ra) # 802006c6 <acquire>
+ b->refcnt--;
+ 80203a74: 40bc lw a5,64(s1)
+ 80203a76: 37fd addiw a5,a5,-1
+ 80203a78: c0bc sw a5,64(s1)
+ release(&bcache.lock);
+ 80203a7a: 00015517 auipc a0,0x15
+ 80203a7e: 07650513 addi a0,a0,118 # 80218af0 <bcache>
+ 80203a82: ffffd097 auipc ra,0xffffd
+ 80203a86: c98080e7 jalr -872(ra) # 8020071a <release>
+}
+ 80203a8a: 60e2 ld ra,24(sp)
+ 80203a8c: 6442 ld s0,16(sp)
+ 80203a8e: 64a2 ld s1,8(sp)
+ 80203a90: 6105 addi sp,sp,32
+ 80203a92: 8082 ret
+
+0000000080203a94 <initsleeplock>:
+#include "include/proc.h"
+#include "include/sleeplock.h"
+
+void
+initsleeplock(struct sleeplock *lk, char *name)
+{
+ 80203a94: 1101 addi sp,sp,-32
+ 80203a96: ec06 sd ra,24(sp)
+ 80203a98: e822 sd s0,16(sp)
+ 80203a9a: e426 sd s1,8(sp)
+ 80203a9c: e04a sd s2,0(sp)
+ 80203a9e: 1000 addi s0,sp,32
+ 80203aa0: 84aa mv s1,a0
+ 80203aa2: 892e mv s2,a1
+ initlock(&lk->lk, "sleep lock");
+ 80203aa4: 00006597 auipc a1,0x6
+ 80203aa8: 22458593 addi a1,a1,548 # 80209cc8 <digits+0x948>
+ 80203aac: 0521 addi a0,a0,8
+ 80203aae: ffffd097 auipc ra,0xffffd
+ 80203ab2: bd4080e7 jalr -1068(ra) # 80200682 <initlock>
+ lk->name = name;
+ 80203ab6: 0324b023 sd s2,32(s1)
+ lk->locked = 0;
+ 80203aba: 0004a023 sw zero,0(s1)
+ lk->pid = 0;
+ 80203abe: 0204a423 sw zero,40(s1)
+}
+ 80203ac2: 60e2 ld ra,24(sp)
+ 80203ac4: 6442 ld s0,16(sp)
+ 80203ac6: 64a2 ld s1,8(sp)
+ 80203ac8: 6902 ld s2,0(sp)
+ 80203aca: 6105 addi sp,sp,32
+ 80203acc: 8082 ret
+
+0000000080203ace <acquiresleep>:
+
+void
+acquiresleep(struct sleeplock *lk)
+{
+ 80203ace: 1101 addi sp,sp,-32
+ 80203ad0: ec06 sd ra,24(sp)
+ 80203ad2: e822 sd s0,16(sp)
+ 80203ad4: e426 sd s1,8(sp)
+ 80203ad6: e04a sd s2,0(sp)
+ 80203ad8: 1000 addi s0,sp,32
+ 80203ada: 84aa mv s1,a0
+ acquire(&lk->lk);
+ 80203adc: 00850913 addi s2,a0,8
+ 80203ae0: 854a mv a0,s2
+ 80203ae2: ffffd097 auipc ra,0xffffd
+ 80203ae6: be4080e7 jalr -1052(ra) # 802006c6 <acquire>
+ while (lk->locked) {
+ 80203aea: 409c lw a5,0(s1)
+ 80203aec: cb89 beqz a5,80203afe <acquiresleep+0x30>
+ sleep(lk, &lk->lk);
+ 80203aee: 85ca mv a1,s2
+ 80203af0: 8526 mv a0,s1
+ 80203af2: fffff097 auipc ra,0xfffff
+ 80203af6: 902080e7 jalr -1790(ra) # 802023f4 <sleep>
+ while (lk->locked) {
+ 80203afa: 409c lw a5,0(s1)
+ 80203afc: fbed bnez a5,80203aee <acquiresleep+0x20>
+ }
+ lk->locked = 1;
+ 80203afe: 4785 li a5,1
+ 80203b00: c09c sw a5,0(s1)
+ lk->pid = myproc()->pid;
+ 80203b02: ffffe097 auipc ra,0xffffe
+ 80203b06: f3a080e7 jalr -198(ra) # 80201a3c <myproc>
+ 80203b0a: 5d1c lw a5,56(a0)
+ 80203b0c: d49c sw a5,40(s1)
+ release(&lk->lk);
+ 80203b0e: 854a mv a0,s2
+ 80203b10: ffffd097 auipc ra,0xffffd
+ 80203b14: c0a080e7 jalr -1014(ra) # 8020071a <release>
+}
+ 80203b18: 60e2 ld ra,24(sp)
+ 80203b1a: 6442 ld s0,16(sp)
+ 80203b1c: 64a2 ld s1,8(sp)
+ 80203b1e: 6902 ld s2,0(sp)
+ 80203b20: 6105 addi sp,sp,32
+ 80203b22: 8082 ret
+
+0000000080203b24 <releasesleep>:
+
+void
+releasesleep(struct sleeplock *lk)
+{
+ 80203b24: 1101 addi sp,sp,-32
+ 80203b26: ec06 sd ra,24(sp)
+ 80203b28: e822 sd s0,16(sp)
+ 80203b2a: e426 sd s1,8(sp)
+ 80203b2c: e04a sd s2,0(sp)
+ 80203b2e: 1000 addi s0,sp,32
+ 80203b30: 84aa mv s1,a0
+ acquire(&lk->lk);
+ 80203b32: 00850913 addi s2,a0,8
+ 80203b36: 854a mv a0,s2
+ 80203b38: ffffd097 auipc ra,0xffffd
+ 80203b3c: b8e080e7 jalr -1138(ra) # 802006c6 <acquire>
+ lk->locked = 0;
+ 80203b40: 0004a023 sw zero,0(s1)
+ lk->pid = 0;
+ 80203b44: 0204a423 sw zero,40(s1)
+ wakeup(lk);
+ 80203b48: 8526 mv a0,s1
+ 80203b4a: fffff097 auipc ra,0xfffff
+ 80203b4e: b42080e7 jalr -1214(ra) # 8020268c <wakeup>
+ release(&lk->lk);
+ 80203b52: 854a mv a0,s2
+ 80203b54: ffffd097 auipc ra,0xffffd
+ 80203b58: bc6080e7 jalr -1082(ra) # 8020071a <release>
+}
+ 80203b5c: 60e2 ld ra,24(sp)
+ 80203b5e: 6442 ld s0,16(sp)
+ 80203b60: 64a2 ld s1,8(sp)
+ 80203b62: 6902 ld s2,0(sp)
+ 80203b64: 6105 addi sp,sp,32
+ 80203b66: 8082 ret
+
+0000000080203b68 <holdingsleep>:
+
+int
+holdingsleep(struct sleeplock *lk)
+{
+ 80203b68: 7179 addi sp,sp,-48
+ 80203b6a: f406 sd ra,40(sp)
+ 80203b6c: f022 sd s0,32(sp)
+ 80203b6e: ec26 sd s1,24(sp)
+ 80203b70: e84a sd s2,16(sp)
+ 80203b72: e44e sd s3,8(sp)
+ 80203b74: 1800 addi s0,sp,48
+ 80203b76: 84aa mv s1,a0
+ int r;
+
+ acquire(&lk->lk);
+ 80203b78: 00850913 addi s2,a0,8
+ 80203b7c: 854a mv a0,s2
+ 80203b7e: ffffd097 auipc ra,0xffffd
+ 80203b82: b48080e7 jalr -1208(ra) # 802006c6 <acquire>
+ r = lk->locked && (lk->pid == myproc()->pid);
+ 80203b86: 409c lw a5,0(s1)
+ 80203b88: ef99 bnez a5,80203ba6 <holdingsleep+0x3e>
+ 80203b8a: 4481 li s1,0
+ release(&lk->lk);
+ 80203b8c: 854a mv a0,s2
+ 80203b8e: ffffd097 auipc ra,0xffffd
+ 80203b92: b8c080e7 jalr -1140(ra) # 8020071a <release>
+ return r;
+}
+ 80203b96: 8526 mv a0,s1
+ 80203b98: 70a2 ld ra,40(sp)
+ 80203b9a: 7402 ld s0,32(sp)
+ 80203b9c: 64e2 ld s1,24(sp)
+ 80203b9e: 6942 ld s2,16(sp)
+ 80203ba0: 69a2 ld s3,8(sp)
+ 80203ba2: 6145 addi sp,sp,48
+ 80203ba4: 8082 ret
+ r = lk->locked && (lk->pid == myproc()->pid);
+ 80203ba6: 0284a983 lw s3,40(s1)
+ 80203baa: ffffe097 auipc ra,0xffffe
+ 80203bae: e92080e7 jalr -366(ra) # 80201a3c <myproc>
+ 80203bb2: 5d04 lw s1,56(a0)
+ 80203bb4: 413484b3 sub s1,s1,s3
+ 80203bb8: 0014b493 seqz s1,s1
+ 80203bbc: bfc1 j 80203b8c <holdingsleep+0x24>
+
+0000000080203bbe <fileinit>:
+ struct file file[NFILE];
+} ftable;
+
+void
+fileinit(void)
+{
+ 80203bbe: 1101 addi sp,sp,-32
+ 80203bc0: ec06 sd ra,24(sp)
+ 80203bc2: e822 sd s0,16(sp)
+ 80203bc4: e426 sd s1,8(sp)
+ 80203bc6: e04a sd s2,0(sp)
+ 80203bc8: 1000 addi s0,sp,32
+ initlock(&ftable.lock, "ftable");
+ 80203bca: 00006597 auipc a1,0x6
+ 80203bce: 10e58593 addi a1,a1,270 # 80209cd8 <digits+0x958>
+ 80203bd2: 0001a517 auipc a0,0x1a
+ 80203bd6: 87e50513 addi a0,a0,-1922 # 8021d450 <ftable>
+ 80203bda: ffffd097 auipc ra,0xffffd
+ 80203bde: aa8080e7 jalr -1368(ra) # 80200682 <initlock>
+ struct file *f;
+ for(f = ftable.file; f < ftable.file + NFILE; f++){
+ 80203be2: 0001a497 auipc s1,0x1a
+ 80203be6: 88648493 addi s1,s1,-1914 # 8021d468 <ftable+0x18>
+ 80203bea: 0001b917 auipc s2,0x1b
+ 80203bee: 81e90913 addi s2,s2,-2018 # 8021e408 <tickslock>
+ memset(f, 0, sizeof(struct file));
+ 80203bf2: 02800613 li a2,40
+ 80203bf6: 4581 li a1,0
+ 80203bf8: 8526 mv a0,s1
+ 80203bfa: ffffd097 auipc ra,0xffffd
+ 80203bfe: b68080e7 jalr -1176(ra) # 80200762 <memset>
+ for(f = ftable.file; f < ftable.file + NFILE; f++){
+ 80203c02: 02848493 addi s1,s1,40
+ 80203c06: ff2496e3 bne s1,s2,80203bf2 <fileinit+0x34>
+ }
+ #ifdef DEBUG
+ printf("fileinit\n");
+ #endif
+}
+ 80203c0a: 60e2 ld ra,24(sp)
+ 80203c0c: 6442 ld s0,16(sp)
+ 80203c0e: 64a2 ld s1,8(sp)
+ 80203c10: 6902 ld s2,0(sp)
+ 80203c12: 6105 addi sp,sp,32
+ 80203c14: 8082 ret
+
+0000000080203c16 <filealloc>:
+
+// Allocate a file structure.
+struct file*
+filealloc(void)
+{
+ 80203c16: 1101 addi sp,sp,-32
+ 80203c18: ec06 sd ra,24(sp)
+ 80203c1a: e822 sd s0,16(sp)
+ 80203c1c: e426 sd s1,8(sp)
+ 80203c1e: 1000 addi s0,sp,32
+ struct file *f;
+
+ acquire(&ftable.lock);
+ 80203c20: 0001a517 auipc a0,0x1a
+ 80203c24: 83050513 addi a0,a0,-2000 # 8021d450 <ftable>
+ 80203c28: ffffd097 auipc ra,0xffffd
+ 80203c2c: a9e080e7 jalr -1378(ra) # 802006c6 <acquire>
+ for(f = ftable.file; f < ftable.file + NFILE; f++){
+ 80203c30: 0001a497 auipc s1,0x1a
+ 80203c34: 83848493 addi s1,s1,-1992 # 8021d468 <ftable+0x18>
+ 80203c38: 0001a717 auipc a4,0x1a
+ 80203c3c: 7d070713 addi a4,a4,2000 # 8021e408 <tickslock>
+ if(f->ref == 0){
+ 80203c40: 40dc lw a5,4(s1)
+ 80203c42: cf99 beqz a5,80203c60 <filealloc+0x4a>
+ for(f = ftable.file; f < ftable.file + NFILE; f++){
+ 80203c44: 02848493 addi s1,s1,40
+ 80203c48: fee49ce3 bne s1,a4,80203c40 <filealloc+0x2a>
+ f->ref = 1;
+ release(&ftable.lock);
+ return f;
+ }
+ }
+ release(&ftable.lock);
+ 80203c4c: 0001a517 auipc a0,0x1a
+ 80203c50: 80450513 addi a0,a0,-2044 # 8021d450 <ftable>
+ 80203c54: ffffd097 auipc ra,0xffffd
+ 80203c58: ac6080e7 jalr -1338(ra) # 8020071a <release>
+ return NULL;
+ 80203c5c: 4481 li s1,0
+ 80203c5e: a819 j 80203c74 <filealloc+0x5e>
+ f->ref = 1;
+ 80203c60: 4785 li a5,1
+ 80203c62: c0dc sw a5,4(s1)
+ release(&ftable.lock);
+ 80203c64: 00019517 auipc a0,0x19
+ 80203c68: 7ec50513 addi a0,a0,2028 # 8021d450 <ftable>
+ 80203c6c: ffffd097 auipc ra,0xffffd
+ 80203c70: aae080e7 jalr -1362(ra) # 8020071a <release>
+}
+ 80203c74: 8526 mv a0,s1
+ 80203c76: 60e2 ld ra,24(sp)
+ 80203c78: 6442 ld s0,16(sp)
+ 80203c7a: 64a2 ld s1,8(sp)
+ 80203c7c: 6105 addi sp,sp,32
+ 80203c7e: 8082 ret
+
+0000000080203c80 <filedup>:
+
+// Increment ref count for file f.
+struct file*
+filedup(struct file *f)
+{
+ 80203c80: 1101 addi sp,sp,-32
+ 80203c82: ec06 sd ra,24(sp)
+ 80203c84: e822 sd s0,16(sp)
+ 80203c86: e426 sd s1,8(sp)
+ 80203c88: 1000 addi s0,sp,32
+ 80203c8a: 84aa mv s1,a0
+ acquire(&ftable.lock);
+ 80203c8c: 00019517 auipc a0,0x19
+ 80203c90: 7c450513 addi a0,a0,1988 # 8021d450 <ftable>
+ 80203c94: ffffd097 auipc ra,0xffffd
+ 80203c98: a32080e7 jalr -1486(ra) # 802006c6 <acquire>
+ if(f->ref < 1)
+ 80203c9c: 40dc lw a5,4(s1)
+ 80203c9e: 02f05263 blez a5,80203cc2 <filedup+0x42>
+ panic("filedup");
+ f->ref++;
+ 80203ca2: 2785 addiw a5,a5,1
+ 80203ca4: c0dc sw a5,4(s1)
+ release(&ftable.lock);
+ 80203ca6: 00019517 auipc a0,0x19
+ 80203caa: 7aa50513 addi a0,a0,1962 # 8021d450 <ftable>
+ 80203cae: ffffd097 auipc ra,0xffffd
+ 80203cb2: a6c080e7 jalr -1428(ra) # 8020071a <release>
+ return f;
+}
+ 80203cb6: 8526 mv a0,s1
+ 80203cb8: 60e2 ld ra,24(sp)
+ 80203cba: 6442 ld s0,16(sp)
+ 80203cbc: 64a2 ld s1,8(sp)
+ 80203cbe: 6105 addi sp,sp,32
+ 80203cc0: 8082 ret
+ panic("filedup");
+ 80203cc2: 00006517 auipc a0,0x6
+ 80203cc6: 01e50513 addi a0,a0,30 # 80209ce0 <digits+0x960>
+ 80203cca: ffffc097 auipc ra,0xffffc
+ 80203cce: 47a080e7 jalr 1146(ra) # 80200144 <panic>
+
+0000000080203cd2 <fileclose>:
+
+// Close file f. (Decrement ref count, close when reaches 0.)
+void
+fileclose(struct file *f)
+{
+ 80203cd2: 7139 addi sp,sp,-64
+ 80203cd4: fc06 sd ra,56(sp)
+ 80203cd6: f822 sd s0,48(sp)
+ 80203cd8: f426 sd s1,40(sp)
+ 80203cda: f04a sd s2,32(sp)
+ 80203cdc: ec4e sd s3,24(sp)
+ 80203cde: e852 sd s4,16(sp)
+ 80203ce0: e456 sd s5,8(sp)
+ 80203ce2: 0080 addi s0,sp,64
+ 80203ce4: 84aa mv s1,a0
+ struct file ff;
+
+ acquire(&ftable.lock);
+ 80203ce6: 00019517 auipc a0,0x19
+ 80203cea: 76a50513 addi a0,a0,1898 # 8021d450 <ftable>
+ 80203cee: ffffd097 auipc ra,0xffffd
+ 80203cf2: 9d8080e7 jalr -1576(ra) # 802006c6 <acquire>
+ if(f->ref < 1)
+ 80203cf6: 40dc lw a5,4(s1)
+ 80203cf8: 04f05863 blez a5,80203d48 <fileclose+0x76>
+ panic("fileclose");
+ if(--f->ref > 0){
+ 80203cfc: 37fd addiw a5,a5,-1
+ 80203cfe: 0007871b sext.w a4,a5
+ 80203d02: c0dc sw a5,4(s1)
+ 80203d04: 04e04a63 bgtz a4,80203d58 <fileclose+0x86>
+ release(&ftable.lock);
+ return;
+ }
+ ff = *f;
+ 80203d08: 0004a903 lw s2,0(s1)
+ 80203d0c: 0094ca03 lbu s4,9(s1)
+ 80203d10: 0104b983 ld s3,16(s1)
+ 80203d14: 0184ba83 ld s5,24(s1)
+ f->ref = 0;
+ 80203d18: 0004a223 sw zero,4(s1)
+ f->type = FD_NONE;
+ 80203d1c: 0004a023 sw zero,0(s1)
+ release(&ftable.lock);
+ 80203d20: 00019517 auipc a0,0x19
+ 80203d24: 73050513 addi a0,a0,1840 # 8021d450 <ftable>
+ 80203d28: ffffd097 auipc ra,0xffffd
+ 80203d2c: 9f2080e7 jalr -1550(ra) # 8020071a <release>
+
+ if(ff.type == FD_PIPE){
+ 80203d30: 4785 li a5,1
+ 80203d32: 04f90463 beq s2,a5,80203d7a <fileclose+0xa8>
+ pipeclose(ff.pipe, ff.writable);
+ } else if(ff.type == FD_ENTRY){
+ 80203d36: 4789 li a5,2
+ 80203d38: 02f91863 bne s2,a5,80203d68 <fileclose+0x96>
+ eput(ff.ep);
+ 80203d3c: 8556 mv a0,s5
+ 80203d3e: 00003097 auipc ra,0x3
+ 80203d42: 9b4080e7 jalr -1612(ra) # 802066f2 <eput>
+ 80203d46: a00d j 80203d68 <fileclose+0x96>
+ panic("fileclose");
+ 80203d48: 00006517 auipc a0,0x6
+ 80203d4c: fa050513 addi a0,a0,-96 # 80209ce8 <digits+0x968>
+ 80203d50: ffffc097 auipc ra,0xffffc
+ 80203d54: 3f4080e7 jalr 1012(ra) # 80200144 <panic>
+ release(&ftable.lock);
+ 80203d58: 00019517 auipc a0,0x19
+ 80203d5c: 6f850513 addi a0,a0,1784 # 8021d450 <ftable>
+ 80203d60: ffffd097 auipc ra,0xffffd
+ 80203d64: 9ba080e7 jalr -1606(ra) # 8020071a <release>
+ } else if (ff.type == FD_DEVICE) {
+
+ }
+}
+ 80203d68: 70e2 ld ra,56(sp)
+ 80203d6a: 7442 ld s0,48(sp)
+ 80203d6c: 74a2 ld s1,40(sp)
+ 80203d6e: 7902 ld s2,32(sp)
+ 80203d70: 69e2 ld s3,24(sp)
+ 80203d72: 6a42 ld s4,16(sp)
+ 80203d74: 6aa2 ld s5,8(sp)
+ 80203d76: 6121 addi sp,sp,64
+ 80203d78: 8082 ret
+ pipeclose(ff.pipe, ff.writable);
+ 80203d7a: 85d2 mv a1,s4
+ 80203d7c: 854e mv a0,s3
+ 80203d7e: 00000097 auipc ra,0x0
+ 80203d82: 3a0080e7 jalr 928(ra) # 8020411e <pipeclose>
+ 80203d86: b7cd j 80203d68 <fileclose+0x96>
+
+0000000080203d88 <filestat>:
+filestat(struct file *f, uint64 addr)
+{
+ // struct proc *p = myproc();
+ struct stat st;
+
+ if(f->type == FD_ENTRY){
+ 80203d88: 4118 lw a4,0(a0)
+ 80203d8a: 4789 li a5,2
+ 80203d8c: 04f71e63 bne a4,a5,80203de8 <filestat+0x60>
+{
+ 80203d90: 7159 addi sp,sp,-112
+ 80203d92: f486 sd ra,104(sp)
+ 80203d94: f0a2 sd s0,96(sp)
+ 80203d96: eca6 sd s1,88(sp)
+ 80203d98: e8ca sd s2,80(sp)
+ 80203d9a: e4ce sd s3,72(sp)
+ 80203d9c: 1880 addi s0,sp,112
+ 80203d9e: 84aa mv s1,a0
+ 80203da0: 892e mv s2,a1
+ elock(f->ep);
+ 80203da2: 6d08 ld a0,24(a0)
+ 80203da4: 00003097 auipc ra,0x3
+ 80203da8: 8ca080e7 jalr -1846(ra) # 8020666e <elock>
+ estat(f->ep, &st);
+ 80203dac: f9840993 addi s3,s0,-104
+ 80203db0: 85ce mv a1,s3
+ 80203db2: 6c88 ld a0,24(s1)
+ 80203db4: 00003097 auipc ra,0x3
+ 80203db8: a76080e7 jalr -1418(ra) # 8020682a <estat>
+ eunlock(f->ep);
+ 80203dbc: 6c88 ld a0,24(s1)
+ 80203dbe: 00003097 auipc ra,0x3
+ 80203dc2: 8e6080e7 jalr -1818(ra) # 802066a4 <eunlock>
+ // if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
+ if(copyout2(addr, (char *)&st, sizeof(st)) < 0)
+ 80203dc6: 03800613 li a2,56
+ 80203dca: 85ce mv a1,s3
+ 80203dcc: 854a mv a0,s2
+ 80203dce: ffffd097 auipc ra,0xffffd
+ 80203dd2: 5a4080e7 jalr 1444(ra) # 80201372 <copyout2>
+ 80203dd6: 41f5551b sraiw a0,a0,0x1f
+ return -1;
+ return 0;
+ }
+ return -1;
+}
+ 80203dda: 70a6 ld ra,104(sp)
+ 80203ddc: 7406 ld s0,96(sp)
+ 80203dde: 64e6 ld s1,88(sp)
+ 80203de0: 6946 ld s2,80(sp)
+ 80203de2: 69a6 ld s3,72(sp)
+ 80203de4: 6165 addi sp,sp,112
+ 80203de6: 8082 ret
+ return -1;
+ 80203de8: 557d li a0,-1
+}
+ 80203dea: 8082 ret
+
+0000000080203dec <fileread>:
+
+// Read from file f.
+// addr is a user virtual address.
+int
+fileread(struct file *f, uint64 addr, int n)
+{
+ 80203dec: 7179 addi sp,sp,-48
+ 80203dee: f406 sd ra,40(sp)
+ 80203df0: f022 sd s0,32(sp)
+ 80203df2: ec26 sd s1,24(sp)
+ 80203df4: e84a sd s2,16(sp)
+ 80203df6: e44e sd s3,8(sp)
+ 80203df8: 1800 addi s0,sp,48
+ int r = 0;
+
+ if(f->readable == 0)
+ 80203dfa: 00854783 lbu a5,8(a0)
+ 80203dfe: c3d5 beqz a5,80203ea2 <fileread+0xb6>
+ 80203e00: 84aa mv s1,a0
+ 80203e02: 89ae mv s3,a1
+ 80203e04: 8932 mv s2,a2
+ return -1;
+
+ switch (f->type) {
+ 80203e06: 411c lw a5,0(a0)
+ 80203e08: 4709 li a4,2
+ 80203e0a: 06e78263 beq a5,a4,80203e6e <fileread+0x82>
+ 80203e0e: 470d li a4,3
+ 80203e10: 02e78b63 beq a5,a4,80203e46 <fileread+0x5a>
+ 80203e14: 4705 li a4,1
+ 80203e16: 00e78a63 beq a5,a4,80203e2a <fileread+0x3e>
+ if((r = eread(f->ep, 1, addr, f->off, n)) > 0)
+ f->off += r;
+ eunlock(f->ep);
+ break;
+ default:
+ panic("fileread");
+ 80203e1a: 00006517 auipc a0,0x6
+ 80203e1e: ede50513 addi a0,a0,-290 # 80209cf8 <digits+0x978>
+ 80203e22: ffffc097 auipc ra,0xffffc
+ 80203e26: 322080e7 jalr 802(ra) # 80200144 <panic>
+ r = piperead(f->pipe, addr, n);
+ 80203e2a: 6908 ld a0,16(a0)
+ 80203e2c: 00000097 auipc ra,0x0
+ 80203e30: 466080e7 jalr 1126(ra) # 80204292 <piperead>
+ 80203e34: 892a mv s2,a0
+ }
+
+ return r;
+}
+ 80203e36: 854a mv a0,s2
+ 80203e38: 70a2 ld ra,40(sp)
+ 80203e3a: 7402 ld s0,32(sp)
+ 80203e3c: 64e2 ld s1,24(sp)
+ 80203e3e: 6942 ld s2,16(sp)
+ 80203e40: 69a2 ld s3,8(sp)
+ 80203e42: 6145 addi sp,sp,48
+ 80203e44: 8082 ret
+ if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
+ 80203e46: 02451783 lh a5,36(a0)
+ 80203e4a: 03079693 slli a3,a5,0x30
+ 80203e4e: 92c1 srli a3,a3,0x30
+ 80203e50: 4725 li a4,9
+ 80203e52: 04d76a63 bltu a4,a3,80203ea6 <fileread+0xba>
+ 80203e56: 0792 slli a5,a5,0x4
+ 80203e58: 00019717 auipc a4,0x19
+ 80203e5c: 55870713 addi a4,a4,1368 # 8021d3b0 <devsw>
+ 80203e60: 97ba add a5,a5,a4
+ 80203e62: 639c ld a5,0(a5)
+ 80203e64: c3b9 beqz a5,80203eaa <fileread+0xbe>
+ r = devsw[f->major].read(1, addr, n);
+ 80203e66: 4505 li a0,1
+ 80203e68: 9782 jalr a5
+ 80203e6a: 892a mv s2,a0
+ break;
+ 80203e6c: b7e9 j 80203e36 <fileread+0x4a>
+ elock(f->ep);
+ 80203e6e: 6d08 ld a0,24(a0)
+ 80203e70: 00002097 auipc ra,0x2
+ 80203e74: 7fe080e7 jalr 2046(ra) # 8020666e <elock>
+ if((r = eread(f->ep, 1, addr, f->off, n)) > 0)
+ 80203e78: 874a mv a4,s2
+ 80203e7a: 5094 lw a3,32(s1)
+ 80203e7c: 864e mv a2,s3
+ 80203e7e: 4585 li a1,1
+ 80203e80: 6c88 ld a0,24(s1)
+ 80203e82: 00002097 auipc ra,0x2
+ 80203e86: ee8080e7 jalr -280(ra) # 80205d6a <eread>
+ 80203e8a: 892a mv s2,a0
+ 80203e8c: 00a05563 blez a0,80203e96 <fileread+0xaa>
+ f->off += r;
+ 80203e90: 509c lw a5,32(s1)
+ 80203e92: 9fa9 addw a5,a5,a0
+ 80203e94: d09c sw a5,32(s1)
+ eunlock(f->ep);
+ 80203e96: 6c88 ld a0,24(s1)
+ 80203e98: 00003097 auipc ra,0x3
+ 80203e9c: 80c080e7 jalr -2036(ra) # 802066a4 <eunlock>
+ break;
+ 80203ea0: bf59 j 80203e36 <fileread+0x4a>
+ return -1;
+ 80203ea2: 597d li s2,-1
+ 80203ea4: bf49 j 80203e36 <fileread+0x4a>
+ return -1;
+ 80203ea6: 597d li s2,-1
+ 80203ea8: b779 j 80203e36 <fileread+0x4a>
+ 80203eaa: 597d li s2,-1
+ 80203eac: b769 j 80203e36 <fileread+0x4a>
+
+0000000080203eae <filewrite>:
+
+// Write to file f.
+// addr is a user virtual address.
+int
+filewrite(struct file *f, uint64 addr, int n)
+{
+ 80203eae: 7179 addi sp,sp,-48
+ 80203eb0: f406 sd ra,40(sp)
+ 80203eb2: f022 sd s0,32(sp)
+ 80203eb4: ec26 sd s1,24(sp)
+ 80203eb6: e84a sd s2,16(sp)
+ 80203eb8: e44e sd s3,8(sp)
+ 80203eba: e052 sd s4,0(sp)
+ 80203ebc: 1800 addi s0,sp,48
+ int ret = 0;
+
+ if(f->writable == 0)
+ 80203ebe: 00954783 lbu a5,9(a0)
+ 80203ec2: cbc5 beqz a5,80203f72 <filewrite+0xc4>
+ 80203ec4: 84aa mv s1,a0
+ 80203ec6: 892e mv s2,a1
+ 80203ec8: 89b2 mv s3,a2
+ return -1;
+
+ if(f->type == FD_PIPE){
+ 80203eca: 411c lw a5,0(a0)
+ 80203ecc: 4705 li a4,1
+ 80203ece: 04e78963 beq a5,a4,80203f20 <filewrite+0x72>
+ ret = pipewrite(f->pipe, addr, n);
+ } else if(f->type == FD_DEVICE){
+ 80203ed2: 470d li a4,3
+ 80203ed4: 04e78d63 beq a5,a4,80203f2e <filewrite+0x80>
+ if(f->major < 0 || f->major >= NDEV || !devsw[f->major].write)
+ return -1;
+ ret = devsw[f->major].write(1, addr, n);
+ } else if(f->type == FD_ENTRY){
+ 80203ed8: 4709 li a4,2
+ 80203eda: 08e79463 bne a5,a4,80203f62 <filewrite+0xb4>
+ elock(f->ep);
+ 80203ede: 6d08 ld a0,24(a0)
+ 80203ee0: 00002097 auipc ra,0x2
+ 80203ee4: 78e080e7 jalr 1934(ra) # 8020666e <elock>
+ if (ewrite(f->ep, 1, addr, f->off, n) == n) {
+ 80203ee8: 00098a1b sext.w s4,s3
+ 80203eec: 8752 mv a4,s4
+ 80203eee: 5094 lw a3,32(s1)
+ 80203ef0: 864a mv a2,s2
+ 80203ef2: 4585 li a1,1
+ 80203ef4: 6c88 ld a0,24(s1)
+ 80203ef6: 00002097 auipc ra,0x2
+ 80203efa: f6c080e7 jalr -148(ra) # 80205e62 <ewrite>
+ ret = n;
+ f->off += n;
+ } else {
+ ret = -1;
+ 80203efe: 597d li s2,-1
+ if (ewrite(f->ep, 1, addr, f->off, n) == n) {
+ 80203f00: 05350b63 beq a0,s3,80203f56 <filewrite+0xa8>
+ }
+ eunlock(f->ep);
+ 80203f04: 6c88 ld a0,24(s1)
+ 80203f06: 00002097 auipc ra,0x2
+ 80203f0a: 79e080e7 jalr 1950(ra) # 802066a4 <eunlock>
+ } else {
+ panic("filewrite");
+ }
+
+ return ret;
+}
+ 80203f0e: 854a mv a0,s2
+ 80203f10: 70a2 ld ra,40(sp)
+ 80203f12: 7402 ld s0,32(sp)
+ 80203f14: 64e2 ld s1,24(sp)
+ 80203f16: 6942 ld s2,16(sp)
+ 80203f18: 69a2 ld s3,8(sp)
+ 80203f1a: 6a02 ld s4,0(sp)
+ 80203f1c: 6145 addi sp,sp,48
+ 80203f1e: 8082 ret
+ ret = pipewrite(f->pipe, addr, n);
+ 80203f20: 6908 ld a0,16(a0)
+ 80203f22: 00000097 auipc ra,0x0
+ 80203f26: 26c080e7 jalr 620(ra) # 8020418e <pipewrite>
+ 80203f2a: 892a mv s2,a0
+ 80203f2c: b7cd j 80203f0e <filewrite+0x60>
+ if(f->major < 0 || f->major >= NDEV || !devsw[f->major].write)
+ 80203f2e: 02451783 lh a5,36(a0)
+ 80203f32: 03079693 slli a3,a5,0x30
+ 80203f36: 92c1 srli a3,a3,0x30
+ 80203f38: 4725 li a4,9
+ 80203f3a: 02d76e63 bltu a4,a3,80203f76 <filewrite+0xc8>
+ 80203f3e: 0792 slli a5,a5,0x4
+ 80203f40: 00019717 auipc a4,0x19
+ 80203f44: 47070713 addi a4,a4,1136 # 8021d3b0 <devsw>
+ 80203f48: 97ba add a5,a5,a4
+ 80203f4a: 679c ld a5,8(a5)
+ 80203f4c: c79d beqz a5,80203f7a <filewrite+0xcc>
+ ret = devsw[f->major].write(1, addr, n);
+ 80203f4e: 4505 li a0,1
+ 80203f50: 9782 jalr a5
+ 80203f52: 892a mv s2,a0
+ 80203f54: bf6d j 80203f0e <filewrite+0x60>
+ f->off += n;
+ 80203f56: 509c lw a5,32(s1)
+ 80203f58: 014787bb addw a5,a5,s4
+ 80203f5c: d09c sw a5,32(s1)
+ ret = n;
+ 80203f5e: 894e mv s2,s3
+ 80203f60: b755 j 80203f04 <filewrite+0x56>
+ panic("filewrite");
+ 80203f62: 00006517 auipc a0,0x6
+ 80203f66: da650513 addi a0,a0,-602 # 80209d08 <digits+0x988>
+ 80203f6a: ffffc097 auipc ra,0xffffc
+ 80203f6e: 1da080e7 jalr 474(ra) # 80200144 <panic>
+ return -1;
+ 80203f72: 597d li s2,-1
+ 80203f74: bf69 j 80203f0e <filewrite+0x60>
+ return -1;
+ 80203f76: 597d li s2,-1
+ 80203f78: bf59 j 80203f0e <filewrite+0x60>
+ 80203f7a: 597d li s2,-1
+ 80203f7c: bf49 j 80203f0e <filewrite+0x60>
+
+0000000080203f7e <dirnext>:
+int
+dirnext(struct file *f, uint64 addr)
+{
+ // struct proc *p = myproc();
+
+ if(f->readable == 0 || !(f->ep->attribute & ATTR_DIRECTORY))
+ 80203f7e: 00854783 lbu a5,8(a0)
+ 80203f82: cfdd beqz a5,80204040 <dirnext+0xc2>
+{
+ 80203f84: 7141 addi sp,sp,-496
+ 80203f86: f786 sd ra,488(sp)
+ 80203f88: f3a2 sd s0,480(sp)
+ 80203f8a: efa6 sd s1,472(sp)
+ 80203f8c: ebca sd s2,464(sp)
+ 80203f8e: e7ce sd s3,456(sp)
+ 80203f90: e3d2 sd s4,448(sp)
+ 80203f92: ff56 sd s5,440(sp)
+ 80203f94: 1b80 addi s0,sp,496
+ 80203f96: 84aa mv s1,a0
+ 80203f98: 8aae mv s5,a1
+ if(f->readable == 0 || !(f->ep->attribute & ATTR_DIRECTORY))
+ 80203f9a: 6d18 ld a4,24(a0)
+ 80203f9c: 10074783 lbu a5,256(a4)
+ 80203fa0: 8bc1 andi a5,a5,16
+ return -1;
+ 80203fa2: 557d li a0,-1
+ if(f->readable == 0 || !(f->ep->attribute & ATTR_DIRECTORY))
+ 80203fa4: eb91 bnez a5,80203fb8 <dirnext+0x3a>
+ // if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
+ if(copyout2(addr, (char *)&st, sizeof(st)) < 0)
+ return -1;
+
+ return 1;
+ 80203fa6: 70be ld ra,488(sp)
+ 80203fa8: 741e ld s0,480(sp)
+ 80203faa: 64fe ld s1,472(sp)
+ 80203fac: 695e ld s2,464(sp)
+ 80203fae: 69be ld s3,456(sp)
+ 80203fb0: 6a1e ld s4,448(sp)
+ 80203fb2: 7afa ld s5,440(sp)
+ 80203fb4: 617d addi sp,sp,496
+ 80203fb6: 8082 ret
+ int count = 0;
+ 80203fb8: e0042e23 sw zero,-484(s0)
+ elock(f->ep);
+ 80203fbc: 853a mv a0,a4
+ 80203fbe: 00002097 auipc ra,0x2
+ 80203fc2: 6b0080e7 jalr 1712(ra) # 8020666e <elock>
+ while ((ret = enext(f->ep, &de, f->off, &count)) == 0) { // skip empty entry
+ 80203fc6: e1c40a13 addi s4,s0,-484
+ 80203fca: e5840993 addi s3,s0,-424
+ 80203fce: a801 j 80203fde <dirnext+0x60>
+ f->off += count * 32;
+ 80203fd0: e1c42783 lw a5,-484(s0)
+ 80203fd4: 0057979b slliw a5,a5,0x5
+ 80203fd8: 5098 lw a4,32(s1)
+ 80203fda: 9fb9 addw a5,a5,a4
+ 80203fdc: d09c sw a5,32(s1)
+ while ((ret = enext(f->ep, &de, f->off, &count)) == 0) { // skip empty entry
+ 80203fde: 86d2 mv a3,s4
+ 80203fe0: 5090 lw a2,32(s1)
+ 80203fe2: 85ce mv a1,s3
+ 80203fe4: 6c88 ld a0,24(s1)
+ 80203fe6: 00003097 auipc ra,0x3
+ 80203fea: 88c080e7 jalr -1908(ra) # 80206872 <enext>
+ 80203fee: 892a mv s2,a0
+ 80203ff0: d165 beqz a0,80203fd0 <dirnext+0x52>
+ eunlock(f->ep);
+ 80203ff2: 6c88 ld a0,24(s1)
+ 80203ff4: 00002097 auipc ra,0x2
+ 80203ff8: 6b0080e7 jalr 1712(ra) # 802066a4 <eunlock>
+ if (ret == -1)
+ 80203ffc: 57fd li a5,-1
+ return 0;
+ 80203ffe: 4501 li a0,0
+ if (ret == -1)
+ 80204000: faf903e3 beq s2,a5,80203fa6 <dirnext+0x28>
+ f->off += count * 32;
+ 80204004: e1c42783 lw a5,-484(s0)
+ 80204008: 0057979b slliw a5,a5,0x5
+ 8020400c: 5098 lw a4,32(s1)
+ 8020400e: 9fb9 addw a5,a5,a4
+ 80204010: d09c sw a5,32(s1)
+ estat(&de, &st);
+ 80204012: e2040493 addi s1,s0,-480
+ 80204016: 85a6 mv a1,s1
+ 80204018: e5840513 addi a0,s0,-424
+ 8020401c: 00003097 auipc ra,0x3
+ 80204020: 80e080e7 jalr -2034(ra) # 8020682a <estat>
+ if(copyout2(addr, (char *)&st, sizeof(st)) < 0)
+ 80204024: 03800613 li a2,56
+ 80204028: 85a6 mv a1,s1
+ 8020402a: 8556 mv a0,s5
+ 8020402c: ffffd097 auipc ra,0xffffd
+ 80204030: 346080e7 jalr 838(ra) # 80201372 <copyout2>
+ return -1;
+ 80204034: fff54513 not a0,a0
+ 80204038: 957d srai a0,a0,0x3f
+ 8020403a: 8909 andi a0,a0,2
+ 8020403c: 157d addi a0,a0,-1
+ 8020403e: b7a5 j 80203fa6 <dirnext+0x28>
+ return -1;
+ 80204040: 557d li a0,-1
+ 80204042: 8082 ret
+
+0000000080204044 <pipealloc>:
+#include "include/kalloc.h"
+#include "include/vm.h"
+
+int
+pipealloc(struct file **f0, struct file **f1)
+{
+ 80204044: 7179 addi sp,sp,-48
+ 80204046: f406 sd ra,40(sp)
+ 80204048: f022 sd s0,32(sp)
+ 8020404a: ec26 sd s1,24(sp)
+ 8020404c: e84a sd s2,16(sp)
+ 8020404e: e44e sd s3,8(sp)
+ 80204050: e052 sd s4,0(sp)
+ 80204052: 1800 addi s0,sp,48
+ 80204054: 84aa mv s1,a0
+ 80204056: 8a2e mv s4,a1
+ struct pipe *pi;
+
+ pi = 0;
+ *f0 = *f1 = 0;
+ 80204058: 0005b023 sd zero,0(a1)
+ 8020405c: 00053023 sd zero,0(a0)
+ if((*f0 = filealloc()) == NULL || (*f1 = filealloc()) == NULL)
+ 80204060: 00000097 auipc ra,0x0
+ 80204064: bb6080e7 jalr -1098(ra) # 80203c16 <filealloc>
+ 80204068: e088 sd a0,0(s1)
+ 8020406a: c551 beqz a0,802040f6 <pipealloc+0xb2>
+ 8020406c: 00000097 auipc ra,0x0
+ 80204070: baa080e7 jalr -1110(ra) # 80203c16 <filealloc>
+ 80204074: 00aa3023 sd a0,0(s4)
+ 80204078: c92d beqz a0,802040ea <pipealloc+0xa6>
+ goto bad;
+ if((pi = (struct pipe*)kalloc()) == NULL)
+ 8020407a: ffffc097 auipc ra,0xffffc
+ 8020407e: 4e0080e7 jalr 1248(ra) # 8020055a <kalloc>
+ 80204082: 892a mv s2,a0
+ 80204084: c125 beqz a0,802040e4 <pipealloc+0xa0>
+ goto bad;
+ pi->readopen = 1;
+ 80204086: 4985 li s3,1
+ 80204088: 23352023 sw s3,544(a0)
+ pi->writeopen = 1;
+ 8020408c: 23352223 sw s3,548(a0)
+ pi->nwrite = 0;
+ 80204090: 20052e23 sw zero,540(a0)
+ pi->nread = 0;
+ 80204094: 20052c23 sw zero,536(a0)
+ initlock(&pi->lock, "pipe");
+ 80204098: 00006597 auipc a1,0x6
+ 8020409c: 9b858593 addi a1,a1,-1608 # 80209a50 <digits+0x6d0>
+ 802040a0: ffffc097 auipc ra,0xffffc
+ 802040a4: 5e2080e7 jalr 1506(ra) # 80200682 <initlock>
+ (*f0)->type = FD_PIPE;
+ 802040a8: 609c ld a5,0(s1)
+ 802040aa: 0137a023 sw s3,0(a5)
+ (*f0)->readable = 1;
+ 802040ae: 609c ld a5,0(s1)
+ 802040b0: 01378423 sb s3,8(a5)
+ (*f0)->writable = 0;
+ 802040b4: 609c ld a5,0(s1)
+ 802040b6: 000784a3 sb zero,9(a5)
+ (*f0)->pipe = pi;
+ 802040ba: 609c ld a5,0(s1)
+ 802040bc: 0127b823 sd s2,16(a5)
+ (*f1)->type = FD_PIPE;
+ 802040c0: 000a3783 ld a5,0(s4)
+ 802040c4: 0137a023 sw s3,0(a5)
+ (*f1)->readable = 0;
+ 802040c8: 000a3783 ld a5,0(s4)
+ 802040cc: 00078423 sb zero,8(a5)
+ (*f1)->writable = 1;
+ 802040d0: 000a3783 ld a5,0(s4)
+ 802040d4: 013784a3 sb s3,9(a5)
+ (*f1)->pipe = pi;
+ 802040d8: 000a3783 ld a5,0(s4)
+ 802040dc: 0127b823 sd s2,16(a5)
+ return 0;
+ 802040e0: 4501 li a0,0
+ 802040e2: a025 j 8020410a <pipealloc+0xc6>
+
+ bad:
+ if(pi)
+ kfree((char*)pi);
+ if(*f0)
+ 802040e4: 6088 ld a0,0(s1)
+ 802040e6: e501 bnez a0,802040ee <pipealloc+0xaa>
+ 802040e8: a039 j 802040f6 <pipealloc+0xb2>
+ 802040ea: 6088 ld a0,0(s1)
+ 802040ec: c51d beqz a0,8020411a <pipealloc+0xd6>
+ fileclose(*f0);
+ 802040ee: 00000097 auipc ra,0x0
+ 802040f2: be4080e7 jalr -1052(ra) # 80203cd2 <fileclose>
+ if(*f1)
+ 802040f6: 000a3783 ld a5,0(s4)
+ fileclose(*f1);
+ return -1;
+ 802040fa: 557d li a0,-1
+ if(*f1)
+ 802040fc: c799 beqz a5,8020410a <pipealloc+0xc6>
+ fileclose(*f1);
+ 802040fe: 853e mv a0,a5
+ 80204100: 00000097 auipc ra,0x0
+ 80204104: bd2080e7 jalr -1070(ra) # 80203cd2 <fileclose>
+ return -1;
+ 80204108: 557d li a0,-1
+}
+ 8020410a: 70a2 ld ra,40(sp)
+ 8020410c: 7402 ld s0,32(sp)
+ 8020410e: 64e2 ld s1,24(sp)
+ 80204110: 6942 ld s2,16(sp)
+ 80204112: 69a2 ld s3,8(sp)
+ 80204114: 6a02 ld s4,0(sp)
+ 80204116: 6145 addi sp,sp,48
+ 80204118: 8082 ret
+ return -1;
+ 8020411a: 557d li a0,-1
+ 8020411c: b7fd j 8020410a <pipealloc+0xc6>
+
+000000008020411e <pipeclose>:
+
+void
+pipeclose(struct pipe *pi, int writable)
+{
+ 8020411e: 1101 addi sp,sp,-32
+ 80204120: ec06 sd ra,24(sp)
+ 80204122: e822 sd s0,16(sp)
+ 80204124: e426 sd s1,8(sp)
+ 80204126: e04a sd s2,0(sp)
+ 80204128: 1000 addi s0,sp,32
+ 8020412a: 84aa mv s1,a0
+ 8020412c: 892e mv s2,a1
+ acquire(&pi->lock);
+ 8020412e: ffffc097 auipc ra,0xffffc
+ 80204132: 598080e7 jalr 1432(ra) # 802006c6 <acquire>
+ if(writable){
+ 80204136: 02090d63 beqz s2,80204170 <pipeclose+0x52>
+ pi->writeopen = 0;
+ 8020413a: 2204a223 sw zero,548(s1)
+ wakeup(&pi->nread);
+ 8020413e: 21848513 addi a0,s1,536
+ 80204142: ffffe097 auipc ra,0xffffe
+ 80204146: 54a080e7 jalr 1354(ra) # 8020268c <wakeup>
+ } else {
+ pi->readopen = 0;
+ wakeup(&pi->nwrite);
+ }
+ if(pi->readopen == 0 && pi->writeopen == 0){
+ 8020414a: 2204b783 ld a5,544(s1)
+ 8020414e: eb95 bnez a5,80204182 <pipeclose+0x64>
+ release(&pi->lock);
+ 80204150: 8526 mv a0,s1
+ 80204152: ffffc097 auipc ra,0xffffc
+ 80204156: 5c8080e7 jalr 1480(ra) # 8020071a <release>
+ kfree((char*)pi);
+ 8020415a: 8526 mv a0,s1
+ 8020415c: ffffc097 auipc ra,0xffffc
+ 80204160: 2e4080e7 jalr 740(ra) # 80200440 <kfree>
+ } else
+ release(&pi->lock);
+}
+ 80204164: 60e2 ld ra,24(sp)
+ 80204166: 6442 ld s0,16(sp)
+ 80204168: 64a2 ld s1,8(sp)
+ 8020416a: 6902 ld s2,0(sp)
+ 8020416c: 6105 addi sp,sp,32
+ 8020416e: 8082 ret
+ pi->readopen = 0;
+ 80204170: 2204a023 sw zero,544(s1)
+ wakeup(&pi->nwrite);
+ 80204174: 21c48513 addi a0,s1,540
+ 80204178: ffffe097 auipc ra,0xffffe
+ 8020417c: 514080e7 jalr 1300(ra) # 8020268c <wakeup>
+ 80204180: b7e9 j 8020414a <pipeclose+0x2c>
+ release(&pi->lock);
+ 80204182: 8526 mv a0,s1
+ 80204184: ffffc097 auipc ra,0xffffc
+ 80204188: 596080e7 jalr 1430(ra) # 8020071a <release>
+}
+ 8020418c: bfe1 j 80204164 <pipeclose+0x46>
+
+000000008020418e <pipewrite>:
+
+int
+pipewrite(struct pipe *pi, uint64 addr, int n)
+{
+ 8020418e: 7159 addi sp,sp,-112
+ 80204190: f486 sd ra,104(sp)
+ 80204192: f0a2 sd s0,96(sp)
+ 80204194: eca6 sd s1,88(sp)
+ 80204196: e8ca sd s2,80(sp)
+ 80204198: e4ce sd s3,72(sp)
+ 8020419a: e0d2 sd s4,64(sp)
+ 8020419c: fc56 sd s5,56(sp)
+ 8020419e: f85a sd s6,48(sp)
+ 802041a0: f45e sd s7,40(sp)
+ 802041a2: f062 sd s8,32(sp)
+ 802041a4: ec66 sd s9,24(sp)
+ 802041a6: 1880 addi s0,sp,112
+ 802041a8: 84aa mv s1,a0
+ 802041aa: 8b2e mv s6,a1
+ 802041ac: 8ab2 mv s5,a2
+ int i;
+ char ch;
+ struct proc *pr = myproc();
+ 802041ae: ffffe097 auipc ra,0xffffe
+ 802041b2: 88e080e7 jalr -1906(ra) # 80201a3c <myproc>
+ 802041b6: 892a mv s2,a0
+
+ acquire(&pi->lock);
+ 802041b8: 8526 mv a0,s1
+ 802041ba: ffffc097 auipc ra,0xffffc
+ 802041be: 50c080e7 jalr 1292(ra) # 802006c6 <acquire>
+ for(i = 0; i < n; i++){
+ 802041c2: 09505763 blez s5,80204250 <pipewrite+0xc2>
+ 802041c6: 4b81 li s7,0
+ while(pi->nwrite == pi->nread + PIPESIZE){ //DOC: pipewrite-full
+ if(pi->readopen == 0 || pr->killed){
+ release(&pi->lock);
+ return -1;
+ }
+ wakeup(&pi->nread);
+ 802041c8: 21848a13 addi s4,s1,536
+ sleep(&pi->nwrite, &pi->lock);
+ 802041cc: 21c48993 addi s3,s1,540
+ }
+ // if(copyin(pr->pagetable, &ch, addr + i, 1) == -1)
+ if(copyin2(&ch, addr + i, 1) == -1)
+ 802041d0: f9f40c93 addi s9,s0,-97
+ 802041d4: 5c7d li s8,-1
+ while(pi->nwrite == pi->nread + PIPESIZE){ //DOC: pipewrite-full
+ 802041d6: 2184a783 lw a5,536(s1)
+ 802041da: 21c4a703 lw a4,540(s1)
+ 802041de: 2007879b addiw a5,a5,512
+ 802041e2: 02f71b63 bne a4,a5,80204218 <pipewrite+0x8a>
+ if(pi->readopen == 0 || pr->killed){
+ 802041e6: 2204a783 lw a5,544(s1)
+ 802041ea: c3c1 beqz a5,8020426a <pipewrite+0xdc>
+ 802041ec: 03092783 lw a5,48(s2)
+ 802041f0: efad bnez a5,8020426a <pipewrite+0xdc>
+ wakeup(&pi->nread);
+ 802041f2: 8552 mv a0,s4
+ 802041f4: ffffe097 auipc ra,0xffffe
+ 802041f8: 498080e7 jalr 1176(ra) # 8020268c <wakeup>
+ sleep(&pi->nwrite, &pi->lock);
+ 802041fc: 85a6 mv a1,s1
+ 802041fe: 854e mv a0,s3
+ 80204200: ffffe097 auipc ra,0xffffe
+ 80204204: 1f4080e7 jalr 500(ra) # 802023f4 <sleep>
+ while(pi->nwrite == pi->nread + PIPESIZE){ //DOC: pipewrite-full
+ 80204208: 2184a783 lw a5,536(s1)
+ 8020420c: 21c4a703 lw a4,540(s1)
+ 80204210: 2007879b addiw a5,a5,512
+ 80204214: fcf709e3 beq a4,a5,802041e6 <pipewrite+0x58>
+ if(copyin2(&ch, addr + i, 1) == -1)
+ 80204218: 4605 li a2,1
+ 8020421a: 85da mv a1,s6
+ 8020421c: 8566 mv a0,s9
+ 8020421e: ffffd097 auipc ra,0xffffd
+ 80204222: 234080e7 jalr 564(ra) # 80201452 <copyin2>
+ 80204226: 03850663 beq a0,s8,80204252 <pipewrite+0xc4>
+ break;
+ pi->data[pi->nwrite++ % PIPESIZE] = ch;
+ 8020422a: 21c4a783 lw a5,540(s1)
+ 8020422e: 0017871b addiw a4,a5,1
+ 80204232: 20e4ae23 sw a4,540(s1)
+ 80204236: 1ff7f793 andi a5,a5,511
+ 8020423a: 97a6 add a5,a5,s1
+ 8020423c: f9f44703 lbu a4,-97(s0)
+ 80204240: 00e78c23 sb a4,24(a5)
+ for(i = 0; i < n; i++){
+ 80204244: 2b85 addiw s7,s7,1
+ 80204246: 0b05 addi s6,s6,1
+ 80204248: f97a97e3 bne s5,s7,802041d6 <pipewrite+0x48>
+ 8020424c: 8bd6 mv s7,s5
+ 8020424e: a011 j 80204252 <pipewrite+0xc4>
+ 80204250: 4b81 li s7,0
+ }
+ wakeup(&pi->nread);
+ 80204252: 21848513 addi a0,s1,536
+ 80204256: ffffe097 auipc ra,0xffffe
+ 8020425a: 436080e7 jalr 1078(ra) # 8020268c <wakeup>
+ release(&pi->lock);
+ 8020425e: 8526 mv a0,s1
+ 80204260: ffffc097 auipc ra,0xffffc
+ 80204264: 4ba080e7 jalr 1210(ra) # 8020071a <release>
+ return i;
+ 80204268: a039 j 80204276 <pipewrite+0xe8>
+ release(&pi->lock);
+ 8020426a: 8526 mv a0,s1
+ 8020426c: ffffc097 auipc ra,0xffffc
+ 80204270: 4ae080e7 jalr 1198(ra) # 8020071a <release>
+ return -1;
+ 80204274: 5bfd li s7,-1
+}
+ 80204276: 855e mv a0,s7
+ 80204278: 70a6 ld ra,104(sp)
+ 8020427a: 7406 ld s0,96(sp)
+ 8020427c: 64e6 ld s1,88(sp)
+ 8020427e: 6946 ld s2,80(sp)
+ 80204280: 69a6 ld s3,72(sp)
+ 80204282: 6a06 ld s4,64(sp)
+ 80204284: 7ae2 ld s5,56(sp)
+ 80204286: 7b42 ld s6,48(sp)
+ 80204288: 7ba2 ld s7,40(sp)
+ 8020428a: 7c02 ld s8,32(sp)
+ 8020428c: 6ce2 ld s9,24(sp)
+ 8020428e: 6165 addi sp,sp,112
+ 80204290: 8082 ret
+
+0000000080204292 <piperead>:
+
+int
+piperead(struct pipe *pi, uint64 addr, int n)
+{
+ 80204292: 715d addi sp,sp,-80
+ 80204294: e486 sd ra,72(sp)
+ 80204296: e0a2 sd s0,64(sp)
+ 80204298: fc26 sd s1,56(sp)
+ 8020429a: f84a sd s2,48(sp)
+ 8020429c: f44e sd s3,40(sp)
+ 8020429e: f052 sd s4,32(sp)
+ 802042a0: ec56 sd s5,24(sp)
+ 802042a2: e85a sd s6,16(sp)
+ 802042a4: 0880 addi s0,sp,80
+ 802042a6: 84aa mv s1,a0
+ 802042a8: 892e mv s2,a1
+ 802042aa: 8a32 mv s4,a2
+ int i;
+ struct proc *pr = myproc();
+ 802042ac: ffffd097 auipc ra,0xffffd
+ 802042b0: 790080e7 jalr 1936(ra) # 80201a3c <myproc>
+ 802042b4: 89aa mv s3,a0
+ char ch;
+
+ acquire(&pi->lock);
+ 802042b6: 8526 mv a0,s1
+ 802042b8: ffffc097 auipc ra,0xffffc
+ 802042bc: 40e080e7 jalr 1038(ra) # 802006c6 <acquire>
+ while(pi->nread == pi->nwrite && pi->writeopen){ //DOC: pipe-empty
+ 802042c0: 2184a703 lw a4,536(s1)
+ 802042c4: 21c4a783 lw a5,540(s1)
+ if(pr->killed){
+ release(&pi->lock);
+ return -1;
+ }
+ sleep(&pi->nread, &pi->lock); //DOC: piperead-sleep
+ 802042c8: 21848a93 addi s5,s1,536
+ while(pi->nread == pi->nwrite && pi->writeopen){ //DOC: pipe-empty
+ 802042cc: 02f71463 bne a4,a5,802042f4 <piperead+0x62>
+ 802042d0: 2244a783 lw a5,548(s1)
+ 802042d4: c385 beqz a5,802042f4 <piperead+0x62>
+ if(pr->killed){
+ 802042d6: 0309a783 lw a5,48(s3)
+ 802042da: ebc1 bnez a5,8020436a <piperead+0xd8>
+ sleep(&pi->nread, &pi->lock); //DOC: piperead-sleep
+ 802042dc: 85a6 mv a1,s1
+ 802042de: 8556 mv a0,s5
+ 802042e0: ffffe097 auipc ra,0xffffe
+ 802042e4: 114080e7 jalr 276(ra) # 802023f4 <sleep>
+ while(pi->nread == pi->nwrite && pi->writeopen){ //DOC: pipe-empty
+ 802042e8: 2184a703 lw a4,536(s1)
+ 802042ec: 21c4a783 lw a5,540(s1)
+ 802042f0: fef700e3 beq a4,a5,802042d0 <piperead+0x3e>
+ }
+ for(i = 0; i < n; i++){ //DOC: piperead-copy
+ 802042f4: 4981 li s3,0
+ if(pi->nread == pi->nwrite)
+ break;
+ ch = pi->data[pi->nread++ % PIPESIZE];
+ // if(copyout(pr->pagetable, addr + i, &ch, 1) == -1)
+ if(copyout2(addr + i, &ch, 1) == -1)
+ 802042f6: fbf40b13 addi s6,s0,-65
+ 802042fa: 5afd li s5,-1
+ for(i = 0; i < n; i++){ //DOC: piperead-copy
+ 802042fc: 05405163 blez s4,8020433e <piperead+0xac>
+ if(pi->nread == pi->nwrite)
+ 80204300: 2184a783 lw a5,536(s1)
+ 80204304: 21c4a703 lw a4,540(s1)
+ 80204308: 02f70b63 beq a4,a5,8020433e <piperead+0xac>
+ ch = pi->data[pi->nread++ % PIPESIZE];
+ 8020430c: 0017871b addiw a4,a5,1
+ 80204310: 20e4ac23 sw a4,536(s1)
+ 80204314: 1ff7f793 andi a5,a5,511
+ 80204318: 97a6 add a5,a5,s1
+ 8020431a: 0187c783 lbu a5,24(a5)
+ 8020431e: faf40fa3 sb a5,-65(s0)
+ if(copyout2(addr + i, &ch, 1) == -1)
+ 80204322: 4605 li a2,1
+ 80204324: 85da mv a1,s6
+ 80204326: 854a mv a0,s2
+ 80204328: ffffd097 auipc ra,0xffffd
+ 8020432c: 04a080e7 jalr 74(ra) # 80201372 <copyout2>
+ 80204330: 01550763 beq a0,s5,8020433e <piperead+0xac>
+ for(i = 0; i < n; i++){ //DOC: piperead-copy
+ 80204334: 2985 addiw s3,s3,1
+ 80204336: 0905 addi s2,s2,1
+ 80204338: fd3a14e3 bne s4,s3,80204300 <piperead+0x6e>
+ 8020433c: 89d2 mv s3,s4
+ break;
+ }
+ wakeup(&pi->nwrite); //DOC: piperead-wakeup
+ 8020433e: 21c48513 addi a0,s1,540
+ 80204342: ffffe097 auipc ra,0xffffe
+ 80204346: 34a080e7 jalr 842(ra) # 8020268c <wakeup>
+ release(&pi->lock);
+ 8020434a: 8526 mv a0,s1
+ 8020434c: ffffc097 auipc ra,0xffffc
+ 80204350: 3ce080e7 jalr 974(ra) # 8020071a <release>
+ return i;
+}
+ 80204354: 854e mv a0,s3
+ 80204356: 60a6 ld ra,72(sp)
+ 80204358: 6406 ld s0,64(sp)
+ 8020435a: 74e2 ld s1,56(sp)
+ 8020435c: 7942 ld s2,48(sp)
+ 8020435e: 79a2 ld s3,40(sp)
+ 80204360: 7a02 ld s4,32(sp)
+ 80204362: 6ae2 ld s5,24(sp)
+ 80204364: 6b42 ld s6,16(sp)
+ 80204366: 6161 addi sp,sp,80
+ 80204368: 8082 ret
+ release(&pi->lock);
+ 8020436a: 8526 mv a0,s1
+ 8020436c: ffffc097 auipc ra,0xffffc
+ 80204370: 3ae080e7 jalr 942(ra) # 8020071a <release>
+ return -1;
+ 80204374: 59fd li s3,-1
+ 80204376: bff9 j 80204354 <piperead+0xc2>
+
+0000000080204378 <exec>:
+ return 0;
+}
+
+
+int exec(char *path, char **argv)
+{
+ 80204378: dd010113 addi sp,sp,-560
+ 8020437c: 22113423 sd ra,552(sp)
+ 80204380: 22813023 sd s0,544(sp)
+ 80204384: 20913c23 sd s1,536(sp)
+ 80204388: 21213823 sd s2,528(sp)
+ 8020438c: 21313423 sd s3,520(sp)
+ 80204390: 21413023 sd s4,512(sp)
+ 80204394: ffd6 sd s5,504(sp)
+ 80204396: fbda sd s6,496(sp)
+ 80204398: f7de sd s7,488(sp)
+ 8020439a: f3e2 sd s8,480(sp)
+ 8020439c: efe6 sd s9,472(sp)
+ 8020439e: ebea sd s10,464(sp)
+ 802043a0: e7ee sd s11,456(sp)
+ 802043a2: 1c00 addi s0,sp,560
+ 802043a4: 892a mv s2,a0
+ 802043a6: dca43c23 sd a0,-552(s0)
+ 802043aa: deb43423 sd a1,-536(s0)
+ struct elfhdr elf;
+ struct dirent *ep;
+ struct proghdr ph;
+ pagetable_t pagetable = 0, oldpagetable;
+ pagetable_t kpagetable = 0, oldkpagetable;
+ struct proc *p = myproc();
+ 802043ae: ffffd097 auipc ra,0xffffd
+ 802043b2: 68e080e7 jalr 1678(ra) # 80201a3c <myproc>
+ 802043b6: 84aa mv s1,a0
+
+ // Make a copy of p->kpt without old user space,
+ // but with the same kstack we are using now, which can't be changed
+ if ((kpagetable = (pagetable_t)kalloc()) == NULL) {
+ 802043b8: ffffc097 auipc ra,0xffffc
+ 802043bc: 1a2080e7 jalr 418(ra) # 8020055a <kalloc>
+ 802043c0: 2a050863 beqz a0,80204670 <exec+0x2f8>
+ 802043c4: 8b2a mv s6,a0
+ return -1;
+ }
+ memmove(kpagetable, p->kpagetable, PGSIZE);
+ 802043c6: 6605 lui a2,0x1
+ 802043c8: 6cac ld a1,88(s1)
+ 802043ca: ffffc097 auipc ra,0xffffc
+ 802043ce: 3f4080e7 jalr 1012(ra) # 802007be <memmove>
+ for (int i = 0; i < PX(2, MAXUVA); i++) {
+ kpagetable[i] = 0;
+ 802043d2: 000b3023 sd zero,0(s6)
+ 802043d6: 000b3423 sd zero,8(s6)
+ }
+
+ if((ep = ename(path)) == NULL) {
+ 802043da: 854a mv a0,s2
+ 802043dc: 00003097 auipc ra,0x3
+ 802043e0: a3a080e7 jalr -1478(ra) # 80206e16 <ename>
+ 802043e4: 8a2a mv s4,a0
+ 802043e6: 3a050e63 beqz a0,802047a2 <exec+0x42a>
+ #ifdef DEBUG
+ printf("[exec] %s not found\n", path);
+ #endif
+ goto bad;
+ }
+ elock(ep);
+ 802043ea: 00002097 auipc ra,0x2
+ 802043ee: 284080e7 jalr 644(ra) # 8020666e <elock>
+
+ // Check ELF header
+ if(eread(ep, 0, (uint64) &elf, 0, sizeof(elf)) != sizeof(elf))
+ 802043f2: 04000713 li a4,64
+ 802043f6: 4681 li a3,0
+ 802043f8: e4840613 addi a2,s0,-440
+ 802043fc: 4581 li a1,0
+ 802043fe: 8552 mv a0,s4
+ 80204400: 00002097 auipc ra,0x2
+ 80204404: 96a080e7 jalr -1686(ra) # 80205d6a <eread>
+ 80204408: 04000793 li a5,64
+ 8020440c: 00f51a63 bne a0,a5,80204420 <exec+0xa8>
+ goto bad;
+ if(elf.magic != ELF_MAGIC)
+ 80204410: e4842703 lw a4,-440(s0)
+ 80204414: 464c47b7 lui a5,0x464c4
+ 80204418: 57f78793 addi a5,a5,1407 # 464c457f <_entry-0x39d3ba81>
+ 8020441c: 00f70963 beq a4,a5,8020442e <exec+0xb6>
+ printf("[exec] reach bad\n");
+ #endif
+ if(pagetable)
+ proc_freepagetable(pagetable, sz);
+ if(kpagetable)
+ kvmfree(kpagetable, 0);
+ 80204420: 4581 li a1,0
+ 80204422: 855a mv a0,s6
+ 80204424: ffffd097 auipc ra,0xffffd
+ 80204428: 24e080e7 jalr 590(ra) # 80201672 <kvmfree>
+ if(ep){
+ 8020442c: a4bd j 8020469a <exec+0x322>
+ if((pagetable = proc_pagetable(p)) == NULL)
+ 8020442e: 8526 mv a0,s1
+ 80204430: ffffd097 auipc ra,0xffffd
+ 80204434: 6f0080e7 jalr 1776(ra) # 80201b20 <proc_pagetable>
+ 80204438: e0a43423 sd a0,-504(s0)
+ 8020443c: d175 beqz a0,80204420 <exec+0xa8>
+ for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
+ 8020443e: e6842783 lw a5,-408(s0)
+ 80204442: e8045703 lhu a4,-384(s0)
+ 80204446: cb3d beqz a4,802044bc <exec+0x144>
+ uint64 argc, sz = 0, sp, ustack[MAXARG+1], stackbase;
+ 80204448: 4481 li s1,0
+ for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
+ 8020444a: e0043023 sd zero,-512(s0)
+ if(eread(ep, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
+ 8020444e: e1040713 addi a4,s0,-496
+ 80204452: dee43023 sd a4,-544(s0)
+ if(ph.vaddr % PGSIZE != 0)
+ 80204456: 6a85 lui s5,0x1
+ 80204458: fffa8713 addi a4,s5,-1 # fff <_entry-0x801ff001>
+ 8020445c: dce43823 sd a4,-560(s0)
+ for(i = 0; i < sz; i += PGSIZE){
+ 80204460: 6d85 lui s11,0x1
+ 80204462: 7d7d lui s10,0xfffff
+ 80204464: a4c9 j 80204726 <exec+0x3ae>
+ panic("loadseg: address should exist");
+ 80204466: 00006517 auipc a0,0x6
+ 8020446a: 8b250513 addi a0,a0,-1870 # 80209d18 <digits+0x998>
+ 8020446e: ffffc097 auipc ra,0xffffc
+ 80204472: cd6080e7 jalr -810(ra) # 80200144 <panic>
+ if(eread(ep, 0, (uint64)pa, offset+i, n) != n)
+ 80204476: 874a mv a4,s2
+ 80204478: 009c86bb addw a3,s9,s1
+ 8020447c: 4581 li a1,0
+ 8020447e: 8552 mv a0,s4
+ 80204480: 00002097 auipc ra,0x2
+ 80204484: 8ea080e7 jalr -1814(ra) # 80205d6a <eread>
+ 80204488: 2501 sext.w a0,a0
+ 8020448a: 1ea91763 bne s2,a0,80204678 <exec+0x300>
+ for(i = 0; i < sz; i += PGSIZE){
+ 8020448e: 009d84bb addw s1,s11,s1
+ 80204492: 013d09bb addw s3,s10,s3
+ 80204496: 2774f863 bgeu s1,s7,80204706 <exec+0x38e>
+ pa = walkaddr(pagetable, va + i);
+ 8020449a: 02049593 slli a1,s1,0x20
+ 8020449e: 9181 srli a1,a1,0x20
+ 802044a0: 95e2 add a1,a1,s8
+ 802044a2: e0843503 ld a0,-504(s0)
+ 802044a6: ffffc097 auipc ra,0xffffc
+ 802044aa: 708080e7 jalr 1800(ra) # 80200bae <walkaddr>
+ 802044ae: 862a mv a2,a0
+ if(pa == NULL)
+ 802044b0: d95d beqz a0,80204466 <exec+0xee>
+ n = PGSIZE;
+ 802044b2: 8956 mv s2,s5
+ if(sz - i < PGSIZE)
+ 802044b4: fd59f1e3 bgeu s3,s5,80204476 <exec+0xfe>
+ n = sz - i;
+ 802044b8: 894e mv s2,s3
+ 802044ba: bf75 j 80204476 <exec+0xfe>
+ uint64 argc, sz = 0, sp, ustack[MAXARG+1], stackbase;
+ 802044bc: 4481 li s1,0
+ eunlock(ep);
+ 802044be: 8552 mv a0,s4
+ 802044c0: 00002097 auipc ra,0x2
+ 802044c4: 1e4080e7 jalr 484(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 802044c8: 8552 mv a0,s4
+ 802044ca: 00002097 auipc ra,0x2
+ 802044ce: 228080e7 jalr 552(ra) # 802066f2 <eput>
+ p = myproc();
+ 802044d2: ffffd097 auipc ra,0xffffd
+ 802044d6: 56a080e7 jalr 1386(ra) # 80201a3c <myproc>
+ 802044da: 8aaa mv s5,a0
+ uint64 oldsz = p->sz;
+ 802044dc: 04853d03 ld s10,72(a0)
+ sz = PGROUNDUP(sz);
+ 802044e0: 6785 lui a5,0x1
+ 802044e2: 17fd addi a5,a5,-1 # fff <_entry-0x801ff001>
+ 802044e4: 97a6 add a5,a5,s1
+ 802044e6: 777d lui a4,0xfffff
+ 802044e8: 8ff9 and a5,a5,a4
+ 802044ea: def43823 sd a5,-528(s0)
+ if((sz1 = uvmalloc(pagetable, kpagetable, sz, sz + 2*PGSIZE)) == 0)
+ 802044ee: 6689 lui a3,0x2
+ 802044f0: 96be add a3,a3,a5
+ 802044f2: 863e mv a2,a5
+ 802044f4: 85da mv a1,s6
+ 802044f6: e0843483 ld s1,-504(s0)
+ 802044fa: 8526 mv a0,s1
+ 802044fc: ffffd097 auipc ra,0xffffd
+ 80204500: b0e080e7 jalr -1266(ra) # 8020100a <uvmalloc>
+ 80204504: 8caa mv s9,a0
+ ep = 0;
+ 80204506: 4a01 li s4,0
+ if((sz1 = uvmalloc(pagetable, kpagetable, sz, sz + 2*PGSIZE)) == 0)
+ 80204508: 16050863 beqz a0,80204678 <exec+0x300>
+ uvmclear(pagetable, sz-2*PGSIZE);
+ 8020450c: 75f9 lui a1,0xffffe
+ 8020450e: 95aa add a1,a1,a0
+ 80204510: 8526 mv a0,s1
+ 80204512: ffffd097 auipc ra,0xffffd
+ 80204516: da2080e7 jalr -606(ra) # 802012b4 <uvmclear>
+ stackbase = sp - PGSIZE;
+ 8020451a: 7bfd lui s7,0xfffff
+ 8020451c: 9be6 add s7,s7,s9
+ for(argc = 0; argv[argc]; argc++) {
+ 8020451e: de843783 ld a5,-536(s0)
+ 80204522: 6388 ld a0,0(a5)
+ 80204524: c92d beqz a0,80204596 <exec+0x21e>
+ 80204526: e8840993 addi s3,s0,-376
+ 8020452a: f8840c13 addi s8,s0,-120
+ sp = sz;
+ 8020452e: 8966 mv s2,s9
+ for(argc = 0; argv[argc]; argc++) {
+ 80204530: 4481 li s1,0
+ sp -= strlen(argv[argc]) + 1;
+ 80204532: ffffc097 auipc ra,0xffffc
+ 80204536: 3b4080e7 jalr 948(ra) # 802008e6 <strlen>
+ 8020453a: 0015079b addiw a5,a0,1
+ 8020453e: 40f907b3 sub a5,s2,a5
+ sp -= sp % 16; // riscv sp must be 16-byte aligned
+ 80204542: ff07f913 andi s2,a5,-16
+ if(sp < stackbase)
+ 80204546: 1b796463 bltu s2,s7,802046ee <exec+0x376>
+ if(copyout(pagetable, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
+ 8020454a: de843d83 ld s11,-536(s0)
+ 8020454e: 000dba03 ld s4,0(s11) # 1000 <_entry-0x801ff000>
+ 80204552: 8552 mv a0,s4
+ 80204554: ffffc097 auipc ra,0xffffc
+ 80204558: 392080e7 jalr 914(ra) # 802008e6 <strlen>
+ 8020455c: 0015069b addiw a3,a0,1
+ 80204560: 8652 mv a2,s4
+ 80204562: 85ca mv a1,s2
+ 80204564: e0843503 ld a0,-504(s0)
+ 80204568: ffffd097 auipc ra,0xffffd
+ 8020456c: d7e080e7 jalr -642(ra) # 802012e6 <copyout>
+ 80204570: 18054363 bltz a0,802046f6 <exec+0x37e>
+ ustack[argc] = sp;
+ 80204574: 0129b023 sd s2,0(s3)
+ for(argc = 0; argv[argc]; argc++) {
+ 80204578: 0485 addi s1,s1,1
+ 8020457a: 008d8793 addi a5,s11,8
+ 8020457e: def43423 sd a5,-536(s0)
+ 80204582: 008db503 ld a0,8(s11)
+ 80204586: c911 beqz a0,8020459a <exec+0x222>
+ if(argc >= MAXARG)
+ 80204588: 09a1 addi s3,s3,8
+ 8020458a: fb3c14e3 bne s8,s3,80204532 <exec+0x1ba>
+ sz = sz1;
+ 8020458e: df943823 sd s9,-528(s0)
+ ep = 0;
+ 80204592: 4a01 li s4,0
+ 80204594: a0d5 j 80204678 <exec+0x300>
+ sp = sz;
+ 80204596: 8966 mv s2,s9
+ for(argc = 0; argv[argc]; argc++) {
+ 80204598: 4481 li s1,0
+ ustack[argc] = 0;
+ 8020459a: 00349793 slli a5,s1,0x3
+ 8020459e: f9078793 addi a5,a5,-112
+ 802045a2: 97a2 add a5,a5,s0
+ 802045a4: ee07bc23 sd zero,-264(a5)
+ sp -= (argc+1) * sizeof(uint64);
+ 802045a8: 00148693 addi a3,s1,1
+ 802045ac: 068e slli a3,a3,0x3
+ 802045ae: 40d90933 sub s2,s2,a3
+ sp -= sp % 16;
+ 802045b2: ff097913 andi s2,s2,-16
+ if(sp < stackbase)
+ 802045b6: 01797663 bgeu s2,s7,802045c2 <exec+0x24a>
+ sz = sz1;
+ 802045ba: df943823 sd s9,-528(s0)
+ ep = 0;
+ 802045be: 4a01 li s4,0
+ 802045c0: a865 j 80204678 <exec+0x300>
+ if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
+ 802045c2: e8840613 addi a2,s0,-376
+ 802045c6: 85ca mv a1,s2
+ 802045c8: e0843503 ld a0,-504(s0)
+ 802045cc: ffffd097 auipc ra,0xffffd
+ 802045d0: d1a080e7 jalr -742(ra) # 802012e6 <copyout>
+ 802045d4: 12054563 bltz a0,802046fe <exec+0x386>
+ p->trapframe->a1 = sp;
+ 802045d8: 060ab783 ld a5,96(s5)
+ 802045dc: 0727bc23 sd s2,120(a5)
+ for(last=s=path; *s; s++)
+ 802045e0: dd843783 ld a5,-552(s0)
+ 802045e4: 0007c703 lbu a4,0(a5)
+ 802045e8: cf11 beqz a4,80204604 <exec+0x28c>
+ 802045ea: 0785 addi a5,a5,1
+ if(*s == '/')
+ 802045ec: 02f00693 li a3,47
+ 802045f0: a039 j 802045fe <exec+0x286>
+ last = s+1;
+ 802045f2: dcf43c23 sd a5,-552(s0)
+ for(last=s=path; *s; s++)
+ 802045f6: 0785 addi a5,a5,1
+ 802045f8: fff7c703 lbu a4,-1(a5)
+ 802045fc: c701 beqz a4,80204604 <exec+0x28c>
+ if(*s == '/')
+ 802045fe: fed71ce3 bne a4,a3,802045f6 <exec+0x27e>
+ 80204602: bfc5 j 802045f2 <exec+0x27a>
+ safestrcpy(p->name, last, sizeof(p->name));
+ 80204604: 4641 li a2,16
+ 80204606: dd843583 ld a1,-552(s0)
+ 8020460a: 160a8513 addi a0,s5,352
+ 8020460e: ffffc097 auipc ra,0xffffc
+ 80204612: 2a6080e7 jalr 678(ra) # 802008b4 <safestrcpy>
+ oldpagetable = p->pagetable;
+ 80204616: 050ab503 ld a0,80(s5)
+ oldkpagetable = p->kpagetable;
+ 8020461a: 058ab983 ld s3,88(s5)
+ p->pagetable = pagetable;
+ 8020461e: e0843783 ld a5,-504(s0)
+ 80204622: 04fab823 sd a5,80(s5)
+ p->kpagetable = kpagetable;
+ 80204626: 056abc23 sd s6,88(s5)
+ p->sz = sz;
+ 8020462a: 059ab423 sd s9,72(s5)
+ p->trapframe->epc = elf.entry; // initial program counter = main
+ 8020462e: 060ab783 ld a5,96(s5)
+ 80204632: e6043703 ld a4,-416(s0)
+ 80204636: ef98 sd a4,24(a5)
+ p->trapframe->sp = sp; // initial stack pointer
+ 80204638: 060ab783 ld a5,96(s5)
+ 8020463c: 0327b823 sd s2,48(a5)
+ proc_freepagetable(oldpagetable, oldsz);
+ 80204640: 85ea mv a1,s10
+ 80204642: ffffd097 auipc ra,0xffffd
+ 80204646: 57a080e7 jalr 1402(ra) # 80201bbc <proc_freepagetable>
+ w_satp(MAKE_SATP(p->kpagetable));
+ 8020464a: 058ab783 ld a5,88(s5)
+ 8020464e: 83b1 srli a5,a5,0xc
+ 80204650: 577d li a4,-1
+ 80204652: 177e slli a4,a4,0x3f
+ 80204654: 8fd9 or a5,a5,a4
+ asm volatile("csrw satp, %0" : : "r" (x));
+ 80204656: 18079073 csrw satp,a5
+ asm volatile("sfence.vma");
+ 8020465a: 12000073 sfence.vma
+ kvmfree(oldkpagetable, 0);
+ 8020465e: 4581 li a1,0
+ 80204660: 854e mv a0,s3
+ 80204662: ffffd097 auipc ra,0xffffd
+ 80204666: 010080e7 jalr 16(ra) # 80201672 <kvmfree>
+ return argc; // this ends up in a0, the first argument to main(argc, argv)
+ 8020466a: 0004851b sext.w a0,s1
+ 8020466e: a089 j 802046b0 <exec+0x338>
+ return -1;
+ 80204670: 557d li a0,-1
+ 80204672: a83d j 802046b0 <exec+0x338>
+ 80204674: de943823 sd s1,-528(s0)
+ proc_freepagetable(pagetable, sz);
+ 80204678: df043583 ld a1,-528(s0)
+ 8020467c: e0843503 ld a0,-504(s0)
+ 80204680: ffffd097 auipc ra,0xffffd
+ 80204684: 53c080e7 jalr 1340(ra) # 80201bbc <proc_freepagetable>
+ kvmfree(kpagetable, 0);
+ 80204688: 4581 li a1,0
+ 8020468a: 855a mv a0,s6
+ 8020468c: ffffd097 auipc ra,0xffffd
+ 80204690: fe6080e7 jalr -26(ra) # 80201672 <kvmfree>
+ eunlock(ep);
+ eput(ep);
+ }
+ return -1;
+ 80204694: 557d li a0,-1
+ if(ep){
+ 80204696: 000a0d63 beqz s4,802046b0 <exec+0x338>
+ eunlock(ep);
+ 8020469a: 8552 mv a0,s4
+ 8020469c: 00002097 auipc ra,0x2
+ 802046a0: 008080e7 jalr 8(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 802046a4: 8552 mv a0,s4
+ 802046a6: 00002097 auipc ra,0x2
+ 802046aa: 04c080e7 jalr 76(ra) # 802066f2 <eput>
+ return -1;
+ 802046ae: 557d li a0,-1
+}
+ 802046b0: 22813083 ld ra,552(sp)
+ 802046b4: 22013403 ld s0,544(sp)
+ 802046b8: 21813483 ld s1,536(sp)
+ 802046bc: 21013903 ld s2,528(sp)
+ 802046c0: 20813983 ld s3,520(sp)
+ 802046c4: 20013a03 ld s4,512(sp)
+ 802046c8: 7afe ld s5,504(sp)
+ 802046ca: 7b5e ld s6,496(sp)
+ 802046cc: 7bbe ld s7,488(sp)
+ 802046ce: 7c1e ld s8,480(sp)
+ 802046d0: 6cfe ld s9,472(sp)
+ 802046d2: 6d5e ld s10,464(sp)
+ 802046d4: 6dbe ld s11,456(sp)
+ 802046d6: 23010113 addi sp,sp,560
+ 802046da: 8082 ret
+ 802046dc: de943823 sd s1,-528(s0)
+ 802046e0: bf61 j 80204678 <exec+0x300>
+ 802046e2: de943823 sd s1,-528(s0)
+ 802046e6: bf49 j 80204678 <exec+0x300>
+ 802046e8: de943823 sd s1,-528(s0)
+ 802046ec: b771 j 80204678 <exec+0x300>
+ sz = sz1;
+ 802046ee: df943823 sd s9,-528(s0)
+ ep = 0;
+ 802046f2: 4a01 li s4,0
+ 802046f4: b751 j 80204678 <exec+0x300>
+ sz = sz1;
+ 802046f6: df943823 sd s9,-528(s0)
+ ep = 0;
+ 802046fa: 4a01 li s4,0
+ 802046fc: bfb5 j 80204678 <exec+0x300>
+ sz = sz1;
+ 802046fe: df943823 sd s9,-528(s0)
+ ep = 0;
+ 80204702: 4a01 li s4,0
+ 80204704: bf95 j 80204678 <exec+0x300>
+ if((sz1 = uvmalloc(pagetable, kpagetable, sz, ph.vaddr + ph.memsz)) == 0)
+ 80204706: df043483 ld s1,-528(s0)
+ for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
+ 8020470a: e0043783 ld a5,-512(s0)
+ 8020470e: 0017869b addiw a3,a5,1
+ 80204712: e0d43023 sd a3,-512(s0)
+ 80204716: df843783 ld a5,-520(s0)
+ 8020471a: 0387879b addiw a5,a5,56
+ 8020471e: e8045703 lhu a4,-384(s0)
+ 80204722: d8e6dee3 bge a3,a4,802044be <exec+0x146>
+ if(eread(ep, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
+ 80204726: 2781 sext.w a5,a5
+ 80204728: def43c23 sd a5,-520(s0)
+ 8020472c: 03800713 li a4,56
+ 80204730: 86be mv a3,a5
+ 80204732: de043603 ld a2,-544(s0)
+ 80204736: 4581 li a1,0
+ 80204738: 8552 mv a0,s4
+ 8020473a: 00001097 auipc ra,0x1
+ 8020473e: 630080e7 jalr 1584(ra) # 80205d6a <eread>
+ 80204742: 03800793 li a5,56
+ 80204746: f2f517e3 bne a0,a5,80204674 <exec+0x2fc>
+ if(ph.type != ELF_PROG_LOAD)
+ 8020474a: e1042783 lw a5,-496(s0)
+ 8020474e: 4705 li a4,1
+ 80204750: fae79de3 bne a5,a4,8020470a <exec+0x392>
+ if(ph.memsz < ph.filesz)
+ 80204754: e3843683 ld a3,-456(s0)
+ 80204758: e3043783 ld a5,-464(s0)
+ 8020475c: f8f6e0e3 bltu a3,a5,802046dc <exec+0x364>
+ if(ph.vaddr + ph.memsz < ph.vaddr)
+ 80204760: e2043783 ld a5,-480(s0)
+ 80204764: 96be add a3,a3,a5
+ 80204766: f6f6eee3 bltu a3,a5,802046e2 <exec+0x36a>
+ if((sz1 = uvmalloc(pagetable, kpagetable, sz, ph.vaddr + ph.memsz)) == 0)
+ 8020476a: 8626 mv a2,s1
+ 8020476c: 85da mv a1,s6
+ 8020476e: e0843503 ld a0,-504(s0)
+ 80204772: ffffd097 auipc ra,0xffffd
+ 80204776: 898080e7 jalr -1896(ra) # 8020100a <uvmalloc>
+ 8020477a: dea43823 sd a0,-528(s0)
+ 8020477e: d52d beqz a0,802046e8 <exec+0x370>
+ if(ph.vaddr % PGSIZE != 0)
+ 80204780: e2043c03 ld s8,-480(s0)
+ 80204784: dd043783 ld a5,-560(s0)
+ 80204788: 00fc77b3 and a5,s8,a5
+ 8020478c: ee0796e3 bnez a5,80204678 <exec+0x300>
+ if(loadseg(pagetable, ph.vaddr, ep, ph.off, ph.filesz) < 0)
+ 80204790: e1842c83 lw s9,-488(s0)
+ 80204794: e3042b83 lw s7,-464(s0)
+ for(i = 0; i < sz; i += PGSIZE){
+ 80204798: f60b87e3 beqz s7,80204706 <exec+0x38e>
+ 8020479c: 89de mv s3,s7
+ 8020479e: 4481 li s1,0
+ 802047a0: b9ed j 8020449a <exec+0x122>
+ kvmfree(kpagetable, 0);
+ 802047a2: 4581 li a1,0
+ 802047a4: 855a mv a0,s6
+ 802047a6: ffffd097 auipc ra,0xffffd
+ 802047aa: ecc080e7 jalr -308(ra) # 80201672 <kvmfree>
+ return -1;
+ 802047ae: 557d li a0,-1
+ 802047b0: b701 j 802046b0 <exec+0x338>
+
+00000000802047b2 <argfd>:
+
+// Fetch the nth word-sized system call argument as a file descriptor
+// and return both the descriptor and the corresponding struct file.
+static int
+argfd(int n, int *pfd, struct file **pf)
+{
+ 802047b2: 7179 addi sp,sp,-48
+ 802047b4: f406 sd ra,40(sp)
+ 802047b6: f022 sd s0,32(sp)
+ 802047b8: ec26 sd s1,24(sp)
+ 802047ba: e84a sd s2,16(sp)
+ 802047bc: 1800 addi s0,sp,48
+ 802047be: 892e mv s2,a1
+ 802047c0: 84b2 mv s1,a2
+ int fd;
+ struct file *f;
+
+ if(argint(n, &fd) < 0)
+ 802047c2: fdc40593 addi a1,s0,-36
+ 802047c6: fffff097 auipc ra,0xfffff
+ 802047ca: 8bc080e7 jalr -1860(ra) # 80203082 <argint>
+ 802047ce: 04054063 bltz a0,8020480e <argfd+0x5c>
+ return -1;
+ if(fd < 0 || fd >= NOFILE || (f=myproc()->ofile[fd]) == NULL)
+ 802047d2: fdc42703 lw a4,-36(s0)
+ 802047d6: 47bd li a5,15
+ 802047d8: 02e7ed63 bltu a5,a4,80204812 <argfd+0x60>
+ 802047dc: ffffd097 auipc ra,0xffffd
+ 802047e0: 260080e7 jalr 608(ra) # 80201a3c <myproc>
+ 802047e4: fdc42703 lw a4,-36(s0)
+ 802047e8: 01a70793 addi a5,a4,26 # fffffffffffff01a <ebss_clear+0xffffffff7fdd901a>
+ 802047ec: 078e slli a5,a5,0x3
+ 802047ee: 953e add a0,a0,a5
+ 802047f0: 651c ld a5,8(a0)
+ 802047f2: c395 beqz a5,80204816 <argfd+0x64>
+ return -1;
+ if(pfd)
+ 802047f4: 00090463 beqz s2,802047fc <argfd+0x4a>
+ *pfd = fd;
+ 802047f8: 00e92023 sw a4,0(s2)
+ if(pf)
+ *pf = f;
+ return 0;
+ 802047fc: 4501 li a0,0
+ if(pf)
+ 802047fe: c091 beqz s1,80204802 <argfd+0x50>
+ *pf = f;
+ 80204800: e09c sd a5,0(s1)
+}
+ 80204802: 70a2 ld ra,40(sp)
+ 80204804: 7402 ld s0,32(sp)
+ 80204806: 64e2 ld s1,24(sp)
+ 80204808: 6942 ld s2,16(sp)
+ 8020480a: 6145 addi sp,sp,48
+ 8020480c: 8082 ret
+ return -1;
+ 8020480e: 557d li a0,-1
+ 80204810: bfcd j 80204802 <argfd+0x50>
+ return -1;
+ 80204812: 557d li a0,-1
+ 80204814: b7fd j 80204802 <argfd+0x50>
+ 80204816: 557d li a0,-1
+ 80204818: b7ed j 80204802 <argfd+0x50>
+
+000000008020481a <fdalloc>:
+
+// Allocate a file descriptor for the given file.
+// Takes over file reference from caller on success.
+static int
+fdalloc(struct file *f)
+{
+ 8020481a: 1101 addi sp,sp,-32
+ 8020481c: ec06 sd ra,24(sp)
+ 8020481e: e822 sd s0,16(sp)
+ 80204820: e426 sd s1,8(sp)
+ 80204822: 1000 addi s0,sp,32
+ 80204824: 84aa mv s1,a0
+ int fd;
+ struct proc *p = myproc();
+ 80204826: ffffd097 auipc ra,0xffffd
+ 8020482a: 216080e7 jalr 534(ra) # 80201a3c <myproc>
+ 8020482e: 862a mv a2,a0
+
+ for(fd = 0; fd < NOFILE; fd++){
+ 80204830: 0d850793 addi a5,a0,216
+ 80204834: 4501 li a0,0
+ 80204836: 46c1 li a3,16
+ if(p->ofile[fd] == 0){
+ 80204838: 6398 ld a4,0(a5)
+ 8020483a: cb19 beqz a4,80204850 <fdalloc+0x36>
+ for(fd = 0; fd < NOFILE; fd++){
+ 8020483c: 2505 addiw a0,a0,1
+ 8020483e: 07a1 addi a5,a5,8
+ 80204840: fed51ce3 bne a0,a3,80204838 <fdalloc+0x1e>
+ p->ofile[fd] = f;
+ return fd;
+ }
+ }
+ return -1;
+ 80204844: 557d li a0,-1
+}
+ 80204846: 60e2 ld ra,24(sp)
+ 80204848: 6442 ld s0,16(sp)
+ 8020484a: 64a2 ld s1,8(sp)
+ 8020484c: 6105 addi sp,sp,32
+ 8020484e: 8082 ret
+ p->ofile[fd] = f;
+ 80204850: 01a50793 addi a5,a0,26
+ 80204854: 078e slli a5,a5,0x3
+ 80204856: 963e add a2,a2,a5
+ 80204858: e604 sd s1,8(a2)
+ return fd;
+ 8020485a: b7f5 j 80204846 <fdalloc+0x2c>
+
+000000008020485c <create>:
+ return filestat(f, st);
+}
+
+static struct dirent*
+create(char *path, short type, int mode)
+{
+ 8020485c: 7169 addi sp,sp,-304
+ 8020485e: f606 sd ra,296(sp)
+ 80204860: f222 sd s0,288(sp)
+ 80204862: ee26 sd s1,280(sp)
+ 80204864: ea4a sd s2,272(sp)
+ 80204866: e64e sd s3,264(sp)
+ 80204868: 1a00 addi s0,sp,304
+ 8020486a: 892e mv s2,a1
+ struct dirent *ep, *dp;
+ char name[FAT32_MAX_FILENAME + 1];
+
+ if((dp = enameparent(path, name)) == NULL)
+ 8020486c: ed040593 addi a1,s0,-304
+ 80204870: 00002097 auipc ra,0x2
+ 80204874: 5c4080e7 jalr 1476(ra) # 80206e34 <enameparent>
+ 80204878: 84aa mv s1,a0
+ 8020487a: c945 beqz a0,8020492a <create+0xce>
+ mode = ATTR_READ_ONLY;
+ } else {
+ mode = 0;
+ }
+
+ elock(dp);
+ 8020487c: 00002097 auipc ra,0x2
+ 80204880: df2080e7 jalr -526(ra) # 8020666e <elock>
+ if (type == T_DIR) {
+ 80204884: fff90613 addi a2,s2,-1
+ 80204888: 00163613 seqz a2,a2
+ if ((ep = ealloc(dp, name, mode)) == NULL) {
+ 8020488c: 0046161b slliw a2,a2,0x4
+ 80204890: ed040593 addi a1,s0,-304
+ 80204894: 8526 mv a0,s1
+ 80204896: 00002097 auipc ra,0x2
+ 8020489a: 2c4080e7 jalr 708(ra) # 80206b5a <ealloc>
+ 8020489e: 89aa mv s3,a0
+ 802048a0: c529 beqz a0,802048ea <create+0x8e>
+ eunlock(dp);
+ eput(dp);
+ return NULL;
+ }
+
+ if ((type == T_DIR && !(ep->attribute & ATTR_DIRECTORY)) ||
+ 802048a2: 0009079b sext.w a5,s2
+ 802048a6: 4705 li a4,1
+ 802048a8: 04e78c63 beq a5,a4,80204900 <create+0xa4>
+ 802048ac: 2901 sext.w s2,s2
+ 802048ae: 4789 li a5,2
+ 802048b0: 00f91663 bne s2,a5,802048bc <create+0x60>
+ (type == T_FILE && (ep->attribute & ATTR_DIRECTORY))) {
+ 802048b4: 10054783 lbu a5,256(a0)
+ 802048b8: 8bc1 andi a5,a5,16
+ 802048ba: e7b9 bnez a5,80204908 <create+0xac>
+ eput(ep);
+ eput(dp);
+ return NULL;
+ }
+
+ eunlock(dp);
+ 802048bc: 8526 mv a0,s1
+ 802048be: 00002097 auipc ra,0x2
+ 802048c2: de6080e7 jalr -538(ra) # 802066a4 <eunlock>
+ eput(dp);
+ 802048c6: 8526 mv a0,s1
+ 802048c8: 00002097 auipc ra,0x2
+ 802048cc: e2a080e7 jalr -470(ra) # 802066f2 <eput>
+
+ elock(ep);
+ 802048d0: 854e mv a0,s3
+ 802048d2: 00002097 auipc ra,0x2
+ 802048d6: d9c080e7 jalr -612(ra) # 8020666e <elock>
+ return ep;
+}
+ 802048da: 854e mv a0,s3
+ 802048dc: 70b2 ld ra,296(sp)
+ 802048de: 7412 ld s0,288(sp)
+ 802048e0: 64f2 ld s1,280(sp)
+ 802048e2: 6952 ld s2,272(sp)
+ 802048e4: 69b2 ld s3,264(sp)
+ 802048e6: 6155 addi sp,sp,304
+ 802048e8: 8082 ret
+ eunlock(dp);
+ 802048ea: 8526 mv a0,s1
+ 802048ec: 00002097 auipc ra,0x2
+ 802048f0: db8080e7 jalr -584(ra) # 802066a4 <eunlock>
+ eput(dp);
+ 802048f4: 8526 mv a0,s1
+ 802048f6: 00002097 auipc ra,0x2
+ 802048fa: dfc080e7 jalr -516(ra) # 802066f2 <eput>
+ return NULL;
+ 802048fe: bff1 j 802048da <create+0x7e>
+ if ((type == T_DIR && !(ep->attribute & ATTR_DIRECTORY)) ||
+ 80204900: 10054783 lbu a5,256(a0)
+ 80204904: 8bc1 andi a5,a5,16
+ 80204906: fbdd bnez a5,802048bc <create+0x60>
+ eunlock(dp);
+ 80204908: 8526 mv a0,s1
+ 8020490a: 00002097 auipc ra,0x2
+ 8020490e: d9a080e7 jalr -614(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 80204912: 854e mv a0,s3
+ 80204914: 00002097 auipc ra,0x2
+ 80204918: dde080e7 jalr -546(ra) # 802066f2 <eput>
+ eput(dp);
+ 8020491c: 8526 mv a0,s1
+ 8020491e: 00002097 auipc ra,0x2
+ 80204922: dd4080e7 jalr -556(ra) # 802066f2 <eput>
+ return NULL;
+ 80204926: 4981 li s3,0
+ 80204928: bf4d j 802048da <create+0x7e>
+ return NULL;
+ 8020492a: 89aa mv s3,a0
+ 8020492c: b77d j 802048da <create+0x7e>
+
+000000008020492e <sys_dup>:
+{
+ 8020492e: 7179 addi sp,sp,-48
+ 80204930: f406 sd ra,40(sp)
+ 80204932: f022 sd s0,32(sp)
+ 80204934: ec26 sd s1,24(sp)
+ 80204936: e84a sd s2,16(sp)
+ 80204938: 1800 addi s0,sp,48
+ if(argfd(0, 0, &f) < 0)
+ 8020493a: fd840613 addi a2,s0,-40
+ 8020493e: 4581 li a1,0
+ 80204940: 4501 li a0,0
+ 80204942: 00000097 auipc ra,0x0
+ 80204946: e70080e7 jalr -400(ra) # 802047b2 <argfd>
+ return -1;
+ 8020494a: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0)
+ 8020494c: 02054363 bltz a0,80204972 <sys_dup+0x44>
+ if((fd=fdalloc(f)) < 0)
+ 80204950: fd843903 ld s2,-40(s0)
+ 80204954: 854a mv a0,s2
+ 80204956: 00000097 auipc ra,0x0
+ 8020495a: ec4080e7 jalr -316(ra) # 8020481a <fdalloc>
+ 8020495e: 84aa mv s1,a0
+ return -1;
+ 80204960: 57fd li a5,-1
+ if((fd=fdalloc(f)) < 0)
+ 80204962: 00054863 bltz a0,80204972 <sys_dup+0x44>
+ filedup(f);
+ 80204966: 854a mv a0,s2
+ 80204968: fffff097 auipc ra,0xfffff
+ 8020496c: 318080e7 jalr 792(ra) # 80203c80 <filedup>
+ return fd;
+ 80204970: 87a6 mv a5,s1
+}
+ 80204972: 853e mv a0,a5
+ 80204974: 70a2 ld ra,40(sp)
+ 80204976: 7402 ld s0,32(sp)
+ 80204978: 64e2 ld s1,24(sp)
+ 8020497a: 6942 ld s2,16(sp)
+ 8020497c: 6145 addi sp,sp,48
+ 8020497e: 8082 ret
+
+0000000080204980 <sys_read>:
+{
+ 80204980: 7179 addi sp,sp,-48
+ 80204982: f406 sd ra,40(sp)
+ 80204984: f022 sd s0,32(sp)
+ 80204986: 1800 addi s0,sp,48
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 80204988: fe840613 addi a2,s0,-24
+ 8020498c: 4581 li a1,0
+ 8020498e: 4501 li a0,0
+ 80204990: 00000097 auipc ra,0x0
+ 80204994: e22080e7 jalr -478(ra) # 802047b2 <argfd>
+ return -1;
+ 80204998: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 8020499a: 04054163 bltz a0,802049dc <sys_read+0x5c>
+ 8020499e: fe440593 addi a1,s0,-28
+ 802049a2: 4509 li a0,2
+ 802049a4: ffffe097 auipc ra,0xffffe
+ 802049a8: 6de080e7 jalr 1758(ra) # 80203082 <argint>
+ return -1;
+ 802049ac: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 802049ae: 02054763 bltz a0,802049dc <sys_read+0x5c>
+ 802049b2: fd840593 addi a1,s0,-40
+ 802049b6: 4505 li a0,1
+ 802049b8: ffffe097 auipc ra,0xffffe
+ 802049bc: 72c080e7 jalr 1836(ra) # 802030e4 <argaddr>
+ return -1;
+ 802049c0: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 802049c2: 00054d63 bltz a0,802049dc <sys_read+0x5c>
+ return fileread(f, p, n);
+ 802049c6: fe442603 lw a2,-28(s0)
+ 802049ca: fd843583 ld a1,-40(s0)
+ 802049ce: fe843503 ld a0,-24(s0)
+ 802049d2: fffff097 auipc ra,0xfffff
+ 802049d6: 41a080e7 jalr 1050(ra) # 80203dec <fileread>
+ 802049da: 87aa mv a5,a0
+}
+ 802049dc: 853e mv a0,a5
+ 802049de: 70a2 ld ra,40(sp)
+ 802049e0: 7402 ld s0,32(sp)
+ 802049e2: 6145 addi sp,sp,48
+ 802049e4: 8082 ret
+
+00000000802049e6 <sys_write>:
+{
+ 802049e6: 7179 addi sp,sp,-48
+ 802049e8: f406 sd ra,40(sp)
+ 802049ea: f022 sd s0,32(sp)
+ 802049ec: 1800 addi s0,sp,48
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 802049ee: fe840613 addi a2,s0,-24
+ 802049f2: 4581 li a1,0
+ 802049f4: 4501 li a0,0
+ 802049f6: 00000097 auipc ra,0x0
+ 802049fa: dbc080e7 jalr -580(ra) # 802047b2 <argfd>
+ return -1;
+ 802049fe: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 80204a00: 04054163 bltz a0,80204a42 <sys_write+0x5c>
+ 80204a04: fe440593 addi a1,s0,-28
+ 80204a08: 4509 li a0,2
+ 80204a0a: ffffe097 auipc ra,0xffffe
+ 80204a0e: 678080e7 jalr 1656(ra) # 80203082 <argint>
+ return -1;
+ 80204a12: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 80204a14: 02054763 bltz a0,80204a42 <sys_write+0x5c>
+ 80204a18: fd840593 addi a1,s0,-40
+ 80204a1c: 4505 li a0,1
+ 80204a1e: ffffe097 auipc ra,0xffffe
+ 80204a22: 6c6080e7 jalr 1734(ra) # 802030e4 <argaddr>
+ return -1;
+ 80204a26: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argaddr(1, &p) < 0)
+ 80204a28: 00054d63 bltz a0,80204a42 <sys_write+0x5c>
+ return filewrite(f, p, n);
+ 80204a2c: fe442603 lw a2,-28(s0)
+ 80204a30: fd843583 ld a1,-40(s0)
+ 80204a34: fe843503 ld a0,-24(s0)
+ 80204a38: fffff097 auipc ra,0xfffff
+ 80204a3c: 476080e7 jalr 1142(ra) # 80203eae <filewrite>
+ 80204a40: 87aa mv a5,a0
+}
+ 80204a42: 853e mv a0,a5
+ 80204a44: 70a2 ld ra,40(sp)
+ 80204a46: 7402 ld s0,32(sp)
+ 80204a48: 6145 addi sp,sp,48
+ 80204a4a: 8082 ret
+
+0000000080204a4c <sys_close>:
+{
+ 80204a4c: 1101 addi sp,sp,-32
+ 80204a4e: ec06 sd ra,24(sp)
+ 80204a50: e822 sd s0,16(sp)
+ 80204a52: 1000 addi s0,sp,32
+ if(argfd(0, &fd, &f) < 0)
+ 80204a54: fe040613 addi a2,s0,-32
+ 80204a58: fec40593 addi a1,s0,-20
+ 80204a5c: 4501 li a0,0
+ 80204a5e: 00000097 auipc ra,0x0
+ 80204a62: d54080e7 jalr -684(ra) # 802047b2 <argfd>
+ return -1;
+ 80204a66: 57fd li a5,-1
+ if(argfd(0, &fd, &f) < 0)
+ 80204a68: 02054463 bltz a0,80204a90 <sys_close+0x44>
+ myproc()->ofile[fd] = 0;
+ 80204a6c: ffffd097 auipc ra,0xffffd
+ 80204a70: fd0080e7 jalr -48(ra) # 80201a3c <myproc>
+ 80204a74: fec42783 lw a5,-20(s0)
+ 80204a78: 07e9 addi a5,a5,26
+ 80204a7a: 078e slli a5,a5,0x3
+ 80204a7c: 953e add a0,a0,a5
+ 80204a7e: 00053423 sd zero,8(a0)
+ fileclose(f);
+ 80204a82: fe043503 ld a0,-32(s0)
+ 80204a86: fffff097 auipc ra,0xfffff
+ 80204a8a: 24c080e7 jalr 588(ra) # 80203cd2 <fileclose>
+ return 0;
+ 80204a8e: 4781 li a5,0
+}
+ 80204a90: 853e mv a0,a5
+ 80204a92: 60e2 ld ra,24(sp)
+ 80204a94: 6442 ld s0,16(sp)
+ 80204a96: 6105 addi sp,sp,32
+ 80204a98: 8082 ret
+
+0000000080204a9a <sys_fstat>:
+{
+ 80204a9a: 1101 addi sp,sp,-32
+ 80204a9c: ec06 sd ra,24(sp)
+ 80204a9e: e822 sd s0,16(sp)
+ 80204aa0: 1000 addi s0,sp,32
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &st) < 0)
+ 80204aa2: fe840613 addi a2,s0,-24
+ 80204aa6: 4581 li a1,0
+ 80204aa8: 4501 li a0,0
+ 80204aaa: 00000097 auipc ra,0x0
+ 80204aae: d08080e7 jalr -760(ra) # 802047b2 <argfd>
+ return -1;
+ 80204ab2: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &st) < 0)
+ 80204ab4: 02054563 bltz a0,80204ade <sys_fstat+0x44>
+ 80204ab8: fe040593 addi a1,s0,-32
+ 80204abc: 4505 li a0,1
+ 80204abe: ffffe097 auipc ra,0xffffe
+ 80204ac2: 626080e7 jalr 1574(ra) # 802030e4 <argaddr>
+ return -1;
+ 80204ac6: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &st) < 0)
+ 80204ac8: 00054b63 bltz a0,80204ade <sys_fstat+0x44>
+ return filestat(f, st);
+ 80204acc: fe043583 ld a1,-32(s0)
+ 80204ad0: fe843503 ld a0,-24(s0)
+ 80204ad4: fffff097 auipc ra,0xfffff
+ 80204ad8: 2b4080e7 jalr 692(ra) # 80203d88 <filestat>
+ 80204adc: 87aa mv a5,a0
+}
+ 80204ade: 853e mv a0,a5
+ 80204ae0: 60e2 ld ra,24(sp)
+ 80204ae2: 6442 ld s0,16(sp)
+ 80204ae4: 6105 addi sp,sp,32
+ 80204ae6: 8082 ret
+
+0000000080204ae8 <sys_open>:
+
+uint64
+sys_open(void)
+{
+ 80204ae8: 7129 addi sp,sp,-320
+ 80204aea: fe06 sd ra,312(sp)
+ 80204aec: fa22 sd s0,304(sp)
+ 80204aee: f626 sd s1,296(sp)
+ 80204af0: f24a sd s2,288(sp)
+ 80204af2: ee4e sd s3,280(sp)
+ 80204af4: 0280 addi s0,sp,320
+ char path[FAT32_MAX_PATH];
+ int fd, omode;
+ struct file *f;
+ struct dirent *ep;
+
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || argint(1, &omode) < 0)
+ 80204af6: 10400613 li a2,260
+ 80204afa: ec840593 addi a1,s0,-312
+ 80204afe: 4501 li a0,0
+ 80204b00: ffffe097 auipc ra,0xffffe
+ 80204b04: 606080e7 jalr 1542(ra) # 80203106 <argstr>
+ 80204b08: 87aa mv a5,a0
+ return -1;
+ 80204b0a: 557d li a0,-1
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || argint(1, &omode) < 0)
+ 80204b0c: 0807ce63 bltz a5,80204ba8 <sys_open+0xc0>
+ 80204b10: ec440593 addi a1,s0,-316
+ 80204b14: 4505 li a0,1
+ 80204b16: ffffe097 auipc ra,0xffffe
+ 80204b1a: 56c080e7 jalr 1388(ra) # 80203082 <argint>
+ 80204b1e: 0e054163 bltz a0,80204c00 <sys_open+0x118>
+
+ if(omode & O_CREATE){
+ 80204b22: ec442603 lw a2,-316(s0)
+ 80204b26: 20067793 andi a5,a2,512
+ 80204b2a: c7d1 beqz a5,80204bb6 <sys_open+0xce>
+ ep = create(path, T_FILE, omode);
+ 80204b2c: 4589 li a1,2
+ 80204b2e: ec840513 addi a0,s0,-312
+ 80204b32: 00000097 auipc ra,0x0
+ 80204b36: d2a080e7 jalr -726(ra) # 8020485c <create>
+ 80204b3a: 892a mv s2,a0
+ if(ep == NULL){
+ 80204b3c: c561 beqz a0,80204c04 <sys_open+0x11c>
+ eput(ep);
+ return -1;
+ }
+ }
+
+ if((f = filealloc()) == NULL || (fd = fdalloc(f)) < 0){
+ 80204b3e: fffff097 auipc ra,0xfffff
+ 80204b42: 0d8080e7 jalr 216(ra) # 80203c16 <filealloc>
+ 80204b46: 89aa mv s3,a0
+ 80204b48: c579 beqz a0,80204c16 <sys_open+0x12e>
+ 80204b4a: 00000097 auipc ra,0x0
+ 80204b4e: cd0080e7 jalr -816(ra) # 8020481a <fdalloc>
+ 80204b52: 84aa mv s1,a0
+ 80204b54: 0a054c63 bltz a0,80204c0c <sys_open+0x124>
+ eunlock(ep);
+ eput(ep);
+ return -1;
+ }
+
+ if(!(ep->attribute & ATTR_DIRECTORY) && (omode & O_TRUNC)){
+ 80204b58: 10094783 lbu a5,256(s2)
+ 80204b5c: 8bc1 andi a5,a5,16
+ 80204b5e: e791 bnez a5,80204b6a <sys_open+0x82>
+ 80204b60: ec442783 lw a5,-316(s0)
+ 80204b64: 4007f793 andi a5,a5,1024
+ 80204b68: e7d1 bnez a5,80204bf4 <sys_open+0x10c>
+ etrunc(ep);
+ }
+
+ f->type = FD_ENTRY;
+ 80204b6a: 4789 li a5,2
+ 80204b6c: 00f9a023 sw a5,0(s3)
+ f->off = (omode & O_APPEND) ? ep->file_size : 0;
+ 80204b70: ec442783 lw a5,-316(s0)
+ 80204b74: 0047f693 andi a3,a5,4
+ 80204b78: 4701 li a4,0
+ 80204b7a: c299 beqz a3,80204b80 <sys_open+0x98>
+ 80204b7c: 10892703 lw a4,264(s2)
+ 80204b80: 02e9a023 sw a4,32(s3)
+ f->ep = ep;
+ 80204b84: 0129bc23 sd s2,24(s3)
+ f->readable = !(omode & O_WRONLY);
+ 80204b88: 0017c713 xori a4,a5,1
+ 80204b8c: 8b05 andi a4,a4,1
+ 80204b8e: 00e98423 sb a4,8(s3)
+ f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
+ 80204b92: 8b8d andi a5,a5,3
+ 80204b94: 00f037b3 snez a5,a5
+ 80204b98: 00f984a3 sb a5,9(s3)
+
+ eunlock(ep);
+ 80204b9c: 854a mv a0,s2
+ 80204b9e: 00002097 auipc ra,0x2
+ 80204ba2: b06080e7 jalr -1274(ra) # 802066a4 <eunlock>
+
+ return fd;
+ 80204ba6: 8526 mv a0,s1
+}
+ 80204ba8: 70f2 ld ra,312(sp)
+ 80204baa: 7452 ld s0,304(sp)
+ 80204bac: 74b2 ld s1,296(sp)
+ 80204bae: 7912 ld s2,288(sp)
+ 80204bb0: 69f2 ld s3,280(sp)
+ 80204bb2: 6131 addi sp,sp,320
+ 80204bb4: 8082 ret
+ if((ep = ename(path)) == NULL){
+ 80204bb6: ec840513 addi a0,s0,-312
+ 80204bba: 00002097 auipc ra,0x2
+ 80204bbe: 25c080e7 jalr 604(ra) # 80206e16 <ename>
+ 80204bc2: 892a mv s2,a0
+ 80204bc4: c131 beqz a0,80204c08 <sys_open+0x120>
+ elock(ep);
+ 80204bc6: 00002097 auipc ra,0x2
+ 80204bca: aa8080e7 jalr -1368(ra) # 8020666e <elock>
+ if((ep->attribute & ATTR_DIRECTORY) && omode != O_RDONLY){
+ 80204bce: 10094783 lbu a5,256(s2)
+ 80204bd2: 8bc1 andi a5,a5,16
+ 80204bd4: d7ad beqz a5,80204b3e <sys_open+0x56>
+ 80204bd6: ec442783 lw a5,-316(s0)
+ 80204bda: d3b5 beqz a5,80204b3e <sys_open+0x56>
+ eunlock(ep);
+ 80204bdc: 854a mv a0,s2
+ 80204bde: 00002097 auipc ra,0x2
+ 80204be2: ac6080e7 jalr -1338(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 80204be6: 854a mv a0,s2
+ 80204be8: 00002097 auipc ra,0x2
+ 80204bec: b0a080e7 jalr -1270(ra) # 802066f2 <eput>
+ return -1;
+ 80204bf0: 557d li a0,-1
+ 80204bf2: bf5d j 80204ba8 <sys_open+0xc0>
+ etrunc(ep);
+ 80204bf4: 854a mv a0,s2
+ 80204bf6: 00002097 auipc ra,0x2
+ 80204bfa: a0e080e7 jalr -1522(ra) # 80206604 <etrunc>
+ 80204bfe: b7b5 j 80204b6a <sys_open+0x82>
+ return -1;
+ 80204c00: 557d li a0,-1
+ 80204c02: b75d j 80204ba8 <sys_open+0xc0>
+ return -1;
+ 80204c04: 557d li a0,-1
+ 80204c06: b74d j 80204ba8 <sys_open+0xc0>
+ return -1;
+ 80204c08: 557d li a0,-1
+ 80204c0a: bf79 j 80204ba8 <sys_open+0xc0>
+ fileclose(f);
+ 80204c0c: 854e mv a0,s3
+ 80204c0e: fffff097 auipc ra,0xfffff
+ 80204c12: 0c4080e7 jalr 196(ra) # 80203cd2 <fileclose>
+ eunlock(ep);
+ 80204c16: 854a mv a0,s2
+ 80204c18: 00002097 auipc ra,0x2
+ 80204c1c: a8c080e7 jalr -1396(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 80204c20: 854a mv a0,s2
+ 80204c22: 00002097 auipc ra,0x2
+ 80204c26: ad0080e7 jalr -1328(ra) # 802066f2 <eput>
+ return -1;
+ 80204c2a: 557d li a0,-1
+ 80204c2c: bfb5 j 80204ba8 <sys_open+0xc0>
+
+0000000080204c2e <sys_mkdir>:
+
+uint64
+sys_mkdir(void)
+{
+ 80204c2e: 7169 addi sp,sp,-304
+ 80204c30: f606 sd ra,296(sp)
+ 80204c32: f222 sd s0,288(sp)
+ 80204c34: ee26 sd s1,280(sp)
+ 80204c36: 1a00 addi s0,sp,304
+ char path[FAT32_MAX_PATH];
+ struct dirent *ep;
+
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || (ep = create(path, T_DIR, 0)) == 0){
+ 80204c38: 10400613 li a2,260
+ 80204c3c: ed840593 addi a1,s0,-296
+ 80204c40: 4501 li a0,0
+ 80204c42: ffffe097 auipc ra,0xffffe
+ 80204c46: 4c4080e7 jalr 1220(ra) # 80203106 <argstr>
+ return -1;
+ 80204c4a: 57fd li a5,-1
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || (ep = create(path, T_DIR, 0)) == 0){
+ 80204c4c: 02054663 bltz a0,80204c78 <sys_mkdir+0x4a>
+ 80204c50: 4601 li a2,0
+ 80204c52: 4585 li a1,1
+ 80204c54: ed840513 addi a0,s0,-296
+ 80204c58: 00000097 auipc ra,0x0
+ 80204c5c: c04080e7 jalr -1020(ra) # 8020485c <create>
+ 80204c60: 84aa mv s1,a0
+ 80204c62: c10d beqz a0,80204c84 <sys_mkdir+0x56>
+ }
+ eunlock(ep);
+ 80204c64: 00002097 auipc ra,0x2
+ 80204c68: a40080e7 jalr -1472(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 80204c6c: 8526 mv a0,s1
+ 80204c6e: 00002097 auipc ra,0x2
+ 80204c72: a84080e7 jalr -1404(ra) # 802066f2 <eput>
+ return 0;
+ 80204c76: 4781 li a5,0
+}
+ 80204c78: 853e mv a0,a5
+ 80204c7a: 70b2 ld ra,296(sp)
+ 80204c7c: 7412 ld s0,288(sp)
+ 80204c7e: 64f2 ld s1,280(sp)
+ 80204c80: 6155 addi sp,sp,304
+ 80204c82: 8082 ret
+ return -1;
+ 80204c84: 57fd li a5,-1
+ 80204c86: bfcd j 80204c78 <sys_mkdir+0x4a>
+
+0000000080204c88 <sys_chdir>:
+
+uint64
+sys_chdir(void)
+{
+ 80204c88: 7169 addi sp,sp,-304
+ 80204c8a: f606 sd ra,296(sp)
+ 80204c8c: f222 sd s0,288(sp)
+ 80204c8e: ee26 sd s1,280(sp)
+ 80204c90: ea4a sd s2,272(sp)
+ 80204c92: 1a00 addi s0,sp,304
+ char path[FAT32_MAX_PATH];
+ struct dirent *ep;
+ struct proc *p = myproc();
+ 80204c94: ffffd097 auipc ra,0xffffd
+ 80204c98: da8080e7 jalr -600(ra) # 80201a3c <myproc>
+ 80204c9c: 892a mv s2,a0
+
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || (ep = ename(path)) == NULL){
+ 80204c9e: 10400613 li a2,260
+ 80204ca2: ed840593 addi a1,s0,-296
+ 80204ca6: 4501 li a0,0
+ 80204ca8: ffffe097 auipc ra,0xffffe
+ 80204cac: 45e080e7 jalr 1118(ra) # 80203106 <argstr>
+ return -1;
+ 80204cb0: 57fd li a5,-1
+ if(argstr(0, path, FAT32_MAX_PATH) < 0 || (ep = ename(path)) == NULL){
+ 80204cb2: 04054063 bltz a0,80204cf2 <sys_chdir+0x6a>
+ 80204cb6: ed840513 addi a0,s0,-296
+ 80204cba: 00002097 auipc ra,0x2
+ 80204cbe: 15c080e7 jalr 348(ra) # 80206e16 <ename>
+ 80204cc2: 84aa mv s1,a0
+ 80204cc4: c931 beqz a0,80204d18 <sys_chdir+0x90>
+ }
+ elock(ep);
+ 80204cc6: 00002097 auipc ra,0x2
+ 80204cca: 9a8080e7 jalr -1624(ra) # 8020666e <elock>
+ if(!(ep->attribute & ATTR_DIRECTORY)){
+ 80204cce: 1004c783 lbu a5,256(s1)
+ 80204cd2: 8bc1 andi a5,a5,16
+ 80204cd4: c795 beqz a5,80204d00 <sys_chdir+0x78>
+ eunlock(ep);
+ eput(ep);
+ return -1;
+ }
+ eunlock(ep);
+ 80204cd6: 8526 mv a0,s1
+ 80204cd8: 00002097 auipc ra,0x2
+ 80204cdc: 9cc080e7 jalr -1588(ra) # 802066a4 <eunlock>
+ eput(p->cwd);
+ 80204ce0: 15893503 ld a0,344(s2)
+ 80204ce4: 00002097 auipc ra,0x2
+ 80204ce8: a0e080e7 jalr -1522(ra) # 802066f2 <eput>
+ p->cwd = ep;
+ 80204cec: 14993c23 sd s1,344(s2)
+ return 0;
+ 80204cf0: 4781 li a5,0
+}
+ 80204cf2: 853e mv a0,a5
+ 80204cf4: 70b2 ld ra,296(sp)
+ 80204cf6: 7412 ld s0,288(sp)
+ 80204cf8: 64f2 ld s1,280(sp)
+ 80204cfa: 6952 ld s2,272(sp)
+ 80204cfc: 6155 addi sp,sp,304
+ 80204cfe: 8082 ret
+ eunlock(ep);
+ 80204d00: 8526 mv a0,s1
+ 80204d02: 00002097 auipc ra,0x2
+ 80204d06: 9a2080e7 jalr -1630(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 80204d0a: 8526 mv a0,s1
+ 80204d0c: 00002097 auipc ra,0x2
+ 80204d10: 9e6080e7 jalr -1562(ra) # 802066f2 <eput>
+ return -1;
+ 80204d14: 57fd li a5,-1
+ 80204d16: bff1 j 80204cf2 <sys_chdir+0x6a>
+ return -1;
+ 80204d18: 57fd li a5,-1
+ 80204d1a: bfe1 j 80204cf2 <sys_chdir+0x6a>
+
+0000000080204d1c <sys_pipe>:
+
+uint64
+sys_pipe(void)
+{
+ 80204d1c: 7139 addi sp,sp,-64
+ 80204d1e: fc06 sd ra,56(sp)
+ 80204d20: f822 sd s0,48(sp)
+ 80204d22: f426 sd s1,40(sp)
+ 80204d24: 0080 addi s0,sp,64
+ uint64 fdarray; // user pointer to array of two integers
+ struct file *rf, *wf;
+ int fd0, fd1;
+ struct proc *p = myproc();
+ 80204d26: ffffd097 auipc ra,0xffffd
+ 80204d2a: d16080e7 jalr -746(ra) # 80201a3c <myproc>
+ 80204d2e: 84aa mv s1,a0
+
+ if(argaddr(0, &fdarray) < 0)
+ 80204d30: fd840593 addi a1,s0,-40
+ 80204d34: 4501 li a0,0
+ 80204d36: ffffe097 auipc ra,0xffffe
+ 80204d3a: 3ae080e7 jalr 942(ra) # 802030e4 <argaddr>
+ return -1;
+ 80204d3e: 57fd li a5,-1
+ if(argaddr(0, &fdarray) < 0)
+ 80204d40: 0c054e63 bltz a0,80204e1c <sys_pipe+0x100>
+ if(pipealloc(&rf, &wf) < 0)
+ 80204d44: fc840593 addi a1,s0,-56
+ 80204d48: fd040513 addi a0,s0,-48
+ 80204d4c: fffff097 auipc ra,0xfffff
+ 80204d50: 2f8080e7 jalr 760(ra) # 80204044 <pipealloc>
+ return -1;
+ 80204d54: 57fd li a5,-1
+ if(pipealloc(&rf, &wf) < 0)
+ 80204d56: 0c054363 bltz a0,80204e1c <sys_pipe+0x100>
+ fd0 = -1;
+ 80204d5a: fcf42223 sw a5,-60(s0)
+ if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
+ 80204d5e: fd043503 ld a0,-48(s0)
+ 80204d62: 00000097 auipc ra,0x0
+ 80204d66: ab8080e7 jalr -1352(ra) # 8020481a <fdalloc>
+ 80204d6a: fca42223 sw a0,-60(s0)
+ 80204d6e: 08054a63 bltz a0,80204e02 <sys_pipe+0xe6>
+ 80204d72: fc843503 ld a0,-56(s0)
+ 80204d76: 00000097 auipc ra,0x0
+ 80204d7a: aa4080e7 jalr -1372(ra) # 8020481a <fdalloc>
+ 80204d7e: fca42023 sw a0,-64(s0)
+ 80204d82: 06054763 bltz a0,80204df0 <sys_pipe+0xd4>
+ fileclose(wf);
+ return -1;
+ }
+ // if(copyout(p->pagetable, fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
+ // copyout(p->pagetable, fdarray+sizeof(fd0), (char *)&fd1, sizeof(fd1)) < 0){
+ if(copyout2(fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
+ 80204d86: 4611 li a2,4
+ 80204d88: fc440593 addi a1,s0,-60
+ 80204d8c: fd843503 ld a0,-40(s0)
+ 80204d90: ffffc097 auipc ra,0xffffc
+ 80204d94: 5e2080e7 jalr 1506(ra) # 80201372 <copyout2>
+ 80204d98: 00054f63 bltz a0,80204db6 <sys_pipe+0x9a>
+ copyout2(fdarray+sizeof(fd0), (char *)&fd1, sizeof(fd1)) < 0){
+ 80204d9c: 4611 li a2,4
+ 80204d9e: fc040593 addi a1,s0,-64
+ 80204da2: fd843503 ld a0,-40(s0)
+ 80204da6: 0511 addi a0,a0,4
+ 80204da8: ffffc097 auipc ra,0xffffc
+ 80204dac: 5ca080e7 jalr 1482(ra) # 80201372 <copyout2>
+ p->ofile[fd1] = 0;
+ fileclose(rf);
+ fileclose(wf);
+ return -1;
+ }
+ return 0;
+ 80204db0: 4781 li a5,0
+ if(copyout2(fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
+ 80204db2: 06055563 bgez a0,80204e1c <sys_pipe+0x100>
+ p->ofile[fd0] = 0;
+ 80204db6: fc442783 lw a5,-60(s0)
+ 80204dba: 07e9 addi a5,a5,26
+ 80204dbc: 078e slli a5,a5,0x3
+ 80204dbe: 97a6 add a5,a5,s1
+ 80204dc0: 0007b423 sd zero,8(a5)
+ p->ofile[fd1] = 0;
+ 80204dc4: fc042783 lw a5,-64(s0)
+ 80204dc8: 07e9 addi a5,a5,26
+ 80204dca: 078e slli a5,a5,0x3
+ 80204dcc: 00f48533 add a0,s1,a5
+ 80204dd0: 00053423 sd zero,8(a0)
+ fileclose(rf);
+ 80204dd4: fd043503 ld a0,-48(s0)
+ 80204dd8: fffff097 auipc ra,0xfffff
+ 80204ddc: efa080e7 jalr -262(ra) # 80203cd2 <fileclose>
+ fileclose(wf);
+ 80204de0: fc843503 ld a0,-56(s0)
+ 80204de4: fffff097 auipc ra,0xfffff
+ 80204de8: eee080e7 jalr -274(ra) # 80203cd2 <fileclose>
+ return -1;
+ 80204dec: 57fd li a5,-1
+ 80204dee: a03d j 80204e1c <sys_pipe+0x100>
+ if(fd0 >= 0)
+ 80204df0: fc442783 lw a5,-60(s0)
+ 80204df4: 0007c763 bltz a5,80204e02 <sys_pipe+0xe6>
+ p->ofile[fd0] = 0;
+ 80204df8: 07e9 addi a5,a5,26
+ 80204dfa: 078e slli a5,a5,0x3
+ 80204dfc: 97a6 add a5,a5,s1
+ 80204dfe: 0007b423 sd zero,8(a5)
+ fileclose(rf);
+ 80204e02: fd043503 ld a0,-48(s0)
+ 80204e06: fffff097 auipc ra,0xfffff
+ 80204e0a: ecc080e7 jalr -308(ra) # 80203cd2 <fileclose>
+ fileclose(wf);
+ 80204e0e: fc843503 ld a0,-56(s0)
+ 80204e12: fffff097 auipc ra,0xfffff
+ 80204e16: ec0080e7 jalr -320(ra) # 80203cd2 <fileclose>
+ return -1;
+ 80204e1a: 57fd li a5,-1
+}
+ 80204e1c: 853e mv a0,a5
+ 80204e1e: 70e2 ld ra,56(sp)
+ 80204e20: 7442 ld s0,48(sp)
+ 80204e22: 74a2 ld s1,40(sp)
+ 80204e24: 6121 addi sp,sp,64
+ 80204e26: 8082 ret
+
+0000000080204e28 <sys_dev>:
+
+// To open console device.
+uint64
+sys_dev(void)
+{
+ 80204e28: 7179 addi sp,sp,-48
+ 80204e2a: f406 sd ra,40(sp)
+ 80204e2c: f022 sd s0,32(sp)
+ 80204e2e: ec26 sd s1,24(sp)
+ 80204e30: 1800 addi s0,sp,48
+ int fd, omode;
+ int major, minor;
+ struct file *f;
+
+ if(argint(0, &omode) < 0 || argint(1, &major) < 0 || argint(2, &minor) < 0){
+ 80204e32: fdc40593 addi a1,s0,-36
+ 80204e36: 4501 li a0,0
+ 80204e38: ffffe097 auipc ra,0xffffe
+ 80204e3c: 24a080e7 jalr 586(ra) # 80203082 <argint>
+ 80204e40: 08054a63 bltz a0,80204ed4 <sys_dev+0xac>
+ 80204e44: fd840593 addi a1,s0,-40
+ 80204e48: 4505 li a0,1
+ 80204e4a: ffffe097 auipc ra,0xffffe
+ 80204e4e: 238080e7 jalr 568(ra) # 80203082 <argint>
+ 80204e52: 08054763 bltz a0,80204ee0 <sys_dev+0xb8>
+ 80204e56: fd440593 addi a1,s0,-44
+ 80204e5a: 4509 li a0,2
+ 80204e5c: ffffe097 auipc ra,0xffffe
+ 80204e60: 226080e7 jalr 550(ra) # 80203082 <argint>
+ 80204e64: 08054063 bltz a0,80204ee4 <sys_dev+0xbc>
+ return -1;
+ }
+
+ if(omode & O_CREATE){
+ 80204e68: fdc42783 lw a5,-36(s0)
+ 80204e6c: 2007f793 andi a5,a5,512
+ 80204e70: ebb1 bnez a5,80204ec4 <sys_dev+0x9c>
+ panic("dev file on FAT");
+ }
+
+ if(major < 0 || major >= NDEV)
+ 80204e72: fd842703 lw a4,-40(s0)
+ 80204e76: 47a5 li a5,9
+ return -1;
+ 80204e78: 557d li a0,-1
+ if(major < 0 || major >= NDEV)
+ 80204e7a: 04e7ee63 bltu a5,a4,80204ed6 <sys_dev+0xae>
+
+ if((f = filealloc()) == NULL || (fd = fdalloc(f)) < 0){
+ 80204e7e: fffff097 auipc ra,0xfffff
+ 80204e82: d98080e7 jalr -616(ra) # 80203c16 <filealloc>
+ 80204e86: 84aa mv s1,a0
+ 80204e88: c125 beqz a0,80204ee8 <sys_dev+0xc0>
+ 80204e8a: 00000097 auipc ra,0x0
+ 80204e8e: 990080e7 jalr -1648(ra) # 8020481a <fdalloc>
+ 80204e92: 04054d63 bltz a0,80204eec <sys_dev+0xc4>
+ if(f)
+ fileclose(f);
+ return -1;
+ }
+
+ f->type = FD_DEVICE;
+ 80204e96: 478d li a5,3
+ 80204e98: c09c sw a5,0(s1)
+ f->off = 0;
+ 80204e9a: 0204a023 sw zero,32(s1)
+ f->ep = 0;
+ 80204e9e: 0004bc23 sd zero,24(s1)
+ f->major = major;
+ 80204ea2: fd842783 lw a5,-40(s0)
+ 80204ea6: 02f49223 sh a5,36(s1)
+ f->readable = !(omode & O_WRONLY);
+ 80204eaa: fdc42783 lw a5,-36(s0)
+ 80204eae: 0017c713 xori a4,a5,1
+ 80204eb2: 8b05 andi a4,a4,1
+ 80204eb4: 00e48423 sb a4,8(s1)
+ f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
+ 80204eb8: 8b8d andi a5,a5,3
+ 80204eba: 00f037b3 snez a5,a5
+ 80204ebe: 00f484a3 sb a5,9(s1)
+
+ return fd;
+ 80204ec2: a811 j 80204ed6 <sys_dev+0xae>
+ panic("dev file on FAT");
+ 80204ec4: 00005517 auipc a0,0x5
+ 80204ec8: e7450513 addi a0,a0,-396 # 80209d38 <digits+0x9b8>
+ 80204ecc: ffffb097 auipc ra,0xffffb
+ 80204ed0: 278080e7 jalr 632(ra) # 80200144 <panic>
+ return -1;
+ 80204ed4: 557d li a0,-1
+}
+ 80204ed6: 70a2 ld ra,40(sp)
+ 80204ed8: 7402 ld s0,32(sp)
+ 80204eda: 64e2 ld s1,24(sp)
+ 80204edc: 6145 addi sp,sp,48
+ 80204ede: 8082 ret
+ return -1;
+ 80204ee0: 557d li a0,-1
+ 80204ee2: bfd5 j 80204ed6 <sys_dev+0xae>
+ 80204ee4: 557d li a0,-1
+ 80204ee6: bfc5 j 80204ed6 <sys_dev+0xae>
+ return -1;
+ 80204ee8: 557d li a0,-1
+ 80204eea: b7f5 j 80204ed6 <sys_dev+0xae>
+ fileclose(f);
+ 80204eec: 8526 mv a0,s1
+ 80204eee: fffff097 auipc ra,0xfffff
+ 80204ef2: de4080e7 jalr -540(ra) # 80203cd2 <fileclose>
+ return -1;
+ 80204ef6: 557d li a0,-1
+ 80204ef8: bff9 j 80204ed6 <sys_dev+0xae>
+
+0000000080204efa <sys_readdir>:
+
+// To support ls command
+uint64
+sys_readdir(void)
+{
+ 80204efa: 1101 addi sp,sp,-32
+ 80204efc: ec06 sd ra,24(sp)
+ 80204efe: e822 sd s0,16(sp)
+ 80204f00: 1000 addi s0,sp,32
+ struct file *f;
+ uint64 p;
+
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &p) < 0)
+ 80204f02: fe840613 addi a2,s0,-24
+ 80204f06: 4581 li a1,0
+ 80204f08: 4501 li a0,0
+ 80204f0a: 00000097 auipc ra,0x0
+ 80204f0e: 8a8080e7 jalr -1880(ra) # 802047b2 <argfd>
+ return -1;
+ 80204f12: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &p) < 0)
+ 80204f14: 02054563 bltz a0,80204f3e <sys_readdir+0x44>
+ 80204f18: fe040593 addi a1,s0,-32
+ 80204f1c: 4505 li a0,1
+ 80204f1e: ffffe097 auipc ra,0xffffe
+ 80204f22: 1c6080e7 jalr 454(ra) # 802030e4 <argaddr>
+ return -1;
+ 80204f26: 57fd li a5,-1
+ if(argfd(0, 0, &f) < 0 || argaddr(1, &p) < 0)
+ 80204f28: 00054b63 bltz a0,80204f3e <sys_readdir+0x44>
+ return dirnext(f, p);
+ 80204f2c: fe043583 ld a1,-32(s0)
+ 80204f30: fe843503 ld a0,-24(s0)
+ 80204f34: fffff097 auipc ra,0xfffff
+ 80204f38: 04a080e7 jalr 74(ra) # 80203f7e <dirnext>
+ 80204f3c: 87aa mv a5,a0
+}
+ 80204f3e: 853e mv a0,a5
+ 80204f40: 60e2 ld ra,24(sp)
+ 80204f42: 6442 ld s0,16(sp)
+ 80204f44: 6105 addi sp,sp,32
+ 80204f46: 8082 ret
+
+0000000080204f48 <sys_getcwd>:
+
+// get absolute cwd string
+uint64
+sys_getcwd(void)
+{
+ 80204f48: 714d addi sp,sp,-336
+ 80204f4a: e686 sd ra,328(sp)
+ 80204f4c: e2a2 sd s0,320(sp)
+ 80204f4e: fe26 sd s1,312(sp)
+ 80204f50: fa4a sd s2,304(sp)
+ 80204f52: f64e sd s3,296(sp)
+ 80204f54: f252 sd s4,288(sp)
+ 80204f56: ee56 sd s5,280(sp)
+ 80204f58: 0a80 addi s0,sp,336
+ uint64 addr;
+ int size;
+ if (argaddr(0, &addr) < 0 || argint(1, &size))
+ 80204f5a: fb840593 addi a1,s0,-72
+ 80204f5e: 4501 li a0,0
+ 80204f60: ffffe097 auipc ra,0xffffe
+ 80204f64: 184080e7 jalr 388(ra) # 802030e4 <argaddr>
+ return NULL;
+ 80204f68: 4781 li a5,0
+ if (argaddr(0, &addr) < 0 || argint(1, &size))
+ 80204f6a: 00054b63 bltz a0,80204f80 <sys_getcwd+0x38>
+ 80204f6e: fb440593 addi a1,s0,-76
+ 80204f72: 4505 li a0,1
+ 80204f74: ffffe097 auipc ra,0xffffe
+ 80204f78: 10e080e7 jalr 270(ra) # 80203082 <argint>
+ return NULL;
+ 80204f7c: 4781 li a5,0
+ if (argaddr(0, &addr) < 0 || argint(1, &size))
+ 80204f7e: c919 beqz a0,80204f94 <sys_getcwd+0x4c>
+ if (copyout2(addr, s, strlen(s) + 1) < 0)
+ return NULL;
+
+ return addr;
+
+}
+ 80204f80: 853e mv a0,a5
+ 80204f82: 60b6 ld ra,328(sp)
+ 80204f84: 6416 ld s0,320(sp)
+ 80204f86: 74f2 ld s1,312(sp)
+ 80204f88: 7952 ld s2,304(sp)
+ 80204f8a: 79b2 ld s3,296(sp)
+ 80204f8c: 7a12 ld s4,288(sp)
+ 80204f8e: 6af2 ld s5,280(sp)
+ 80204f90: 6171 addi sp,sp,336
+ 80204f92: 8082 ret
+ struct dirent *de = myproc()->cwd;
+ 80204f94: ffffd097 auipc ra,0xffffd
+ 80204f98: aa8080e7 jalr -1368(ra) # 80201a3c <myproc>
+ 80204f9c: 15853483 ld s1,344(a0)
+ if (de->parent == NULL) {
+ 80204fa0: 1204b783 ld a5,288(s1)
+ 80204fa4: c3c9 beqz a5,80205026 <sys_getcwd+0xde>
+ *s = '\0';
+ 80204fa6: fa0409a3 sb zero,-77(s0)
+ s = path + FAT32_MAX_PATH - 1;
+ 80204faa: fb340993 addi s3,s0,-77
+ if (s <= path) // can't reach root "/"
+ 80204fae: eb040a13 addi s4,s0,-336
+ *--s = '/';
+ 80204fb2: 02f00a93 li s5,47
+ len = strlen(de->filename);
+ 80204fb6: 8526 mv a0,s1
+ 80204fb8: ffffc097 auipc ra,0xffffc
+ 80204fbc: 92e080e7 jalr -1746(ra) # 802008e6 <strlen>
+ 80204fc0: 862a mv a2,a0
+ s -= len;
+ 80204fc2: 40a98933 sub s2,s3,a0
+ if (s <= path) // can't reach root "/"
+ 80204fc6: 072a7563 bgeu s4,s2,80205030 <sys_getcwd+0xe8>
+ strncpy(s, de->filename, len);
+ 80204fca: 85a6 mv a1,s1
+ 80204fcc: 854a mv a0,s2
+ 80204fce: ffffc097 auipc ra,0xffffc
+ 80204fd2: 8a8080e7 jalr -1880(ra) # 80200876 <strncpy>
+ *--s = '/';
+ 80204fd6: fff90993 addi s3,s2,-1
+ 80204fda: ff590fa3 sb s5,-1(s2)
+ de = de->parent;
+ 80204fde: 1204b483 ld s1,288(s1)
+ while (de->parent) {
+ 80204fe2: 1204b783 ld a5,288(s1)
+ 80204fe6: fbe1 bnez a5,80204fb6 <sys_getcwd+0x6e>
+ if(strlen(s) + 1 > size) {
+ 80204fe8: 854e mv a0,s3
+ 80204fea: ffffc097 auipc ra,0xffffc
+ 80204fee: 8fc080e7 jalr -1796(ra) # 802008e6 <strlen>
+ 80204ff2: fb442703 lw a4,-76(s0)
+ return NULL;
+ 80204ff6: 4781 li a5,0
+ if(strlen(s) + 1 > size) {
+ 80204ff8: f8e554e3 bge a0,a4,80204f80 <sys_getcwd+0x38>
+ if (copyout2(addr, s, strlen(s) + 1) < 0)
+ 80204ffc: fb843483 ld s1,-72(s0)
+ 80205000: 854e mv a0,s3
+ 80205002: ffffc097 auipc ra,0xffffc
+ 80205006: 8e4080e7 jalr -1820(ra) # 802008e6 <strlen>
+ 8020500a: 0015061b addiw a2,a0,1
+ 8020500e: 85ce mv a1,s3
+ 80205010: 8526 mv a0,s1
+ 80205012: ffffc097 auipc ra,0xffffc
+ 80205016: 360080e7 jalr 864(ra) # 80201372 <copyout2>
+ return NULL;
+ 8020501a: 4781 li a5,0
+ if (copyout2(addr, s, strlen(s) + 1) < 0)
+ 8020501c: f60542e3 bltz a0,80204f80 <sys_getcwd+0x38>
+ return addr;
+ 80205020: fb843783 ld a5,-72(s0)
+ 80205024: bfb1 j 80204f80 <sys_getcwd+0x38>
+ s = "/";
+ 80205026: 00004997 auipc s3,0x4
+ 8020502a: 60a98993 addi s3,s3,1546 # 80209630 <digits+0x2b0>
+ 8020502e: bf6d j 80204fe8 <sys_getcwd+0xa0>
+ return -1;
+ 80205030: 57fd li a5,-1
+ 80205032: b7b9 j 80204f80 <sys_getcwd+0x38>
+
+0000000080205034 <sys_remove>:
+ return ret == -1;
+}
+
+uint64
+sys_remove(void)
+{
+ 80205034: d6010113 addi sp,sp,-672
+ 80205038: 28113c23 sd ra,664(sp)
+ 8020503c: 28813823 sd s0,656(sp)
+ 80205040: 28913423 sd s1,648(sp)
+ 80205044: 1500 addi s0,sp,672
+ char path[FAT32_MAX_PATH];
+ struct dirent *ep;
+ int len;
+ if((len = argstr(0, path, FAT32_MAX_PATH)) <= 0)
+ 80205046: 10400613 li a2,260
+ 8020504a: ed840593 addi a1,s0,-296
+ 8020504e: 4501 li a0,0
+ 80205050: ffffe097 auipc ra,0xffffe
+ 80205054: 0b6080e7 jalr 182(ra) # 80203106 <argstr>
+ 80205058: 0ea05a63 blez a0,8020514c <sys_remove+0x118>
+ return -1;
+
+ char *s = path + len - 1;
+ 8020505c: 157d addi a0,a0,-1
+ 8020505e: ed840713 addi a4,s0,-296
+ 80205062: 00a707b3 add a5,a4,a0
+ while (s >= path && *s == '/') {
+ 80205066: 02f00693 li a3,47
+ 8020506a: 863a mv a2,a4
+ 8020506c: 00e7e963 bltu a5,a4,8020507e <sys_remove+0x4a>
+ 80205070: 0007c703 lbu a4,0(a5)
+ 80205074: 08d71a63 bne a4,a3,80205108 <sys_remove+0xd4>
+ s--;
+ 80205078: 17fd addi a5,a5,-1
+ while (s >= path && *s == '/') {
+ 8020507a: fec7fbe3 bgeu a5,a2,80205070 <sys_remove+0x3c>
+ }
+ if (s >= path && *s == '.' && (s == path || *--s == '/')) {
+ return -1;
+ }
+
+ if((ep = ename(path)) == NULL){
+ 8020507e: ed840513 addi a0,s0,-296
+ 80205082: 00002097 auipc ra,0x2
+ 80205086: d94080e7 jalr -620(ra) # 80206e16 <ename>
+ 8020508a: 84aa mv s1,a0
+ 8020508c: c561 beqz a0,80205154 <sys_remove+0x120>
+ return -1;
+ }
+ elock(ep);
+ 8020508e: 00001097 auipc ra,0x1
+ 80205092: 5e0080e7 jalr 1504(ra) # 8020666e <elock>
+ if((ep->attribute & ATTR_DIRECTORY) && !isdirempty(ep)){
+ 80205096: 1004c783 lbu a5,256(s1)
+ 8020509a: 8bc1 andi a5,a5,16
+ 8020509c: c38d beqz a5,802050be <sys_remove+0x8a>
+ ep.valid = 0;
+ 8020509e: e8041323 sh zero,-378(s0)
+ ret = enext(dp, &ep, 2 * 32, &count); // skip the "." and ".."
+ 802050a2: d6c40693 addi a3,s0,-660
+ 802050a6: 04000613 li a2,64
+ 802050aa: d7040593 addi a1,s0,-656
+ 802050ae: 8526 mv a0,s1
+ 802050b0: 00001097 auipc ra,0x1
+ 802050b4: 7c2080e7 jalr 1986(ra) # 80206872 <enext>
+ if((ep->attribute & ATTR_DIRECTORY) && !isdirempty(ep)){
+ 802050b8: 57fd li a5,-1
+ 802050ba: 06f51d63 bne a0,a5,80205134 <sys_remove+0x100>
+ eunlock(ep);
+ eput(ep);
+ return -1;
+ }
+ elock(ep->parent); // Will this lead to deadlock?
+ 802050be: 1204b503 ld a0,288(s1)
+ 802050c2: 00001097 auipc ra,0x1
+ 802050c6: 5ac080e7 jalr 1452(ra) # 8020666e <elock>
+ eremove(ep);
+ 802050ca: 8526 mv a0,s1
+ 802050cc: 00001097 auipc ra,0x1
+ 802050d0: 46e080e7 jalr 1134(ra) # 8020653a <eremove>
+ eunlock(ep->parent);
+ 802050d4: 1204b503 ld a0,288(s1)
+ 802050d8: 00001097 auipc ra,0x1
+ 802050dc: 5cc080e7 jalr 1484(ra) # 802066a4 <eunlock>
+ eunlock(ep);
+ 802050e0: 8526 mv a0,s1
+ 802050e2: 00001097 auipc ra,0x1
+ 802050e6: 5c2080e7 jalr 1474(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 802050ea: 8526 mv a0,s1
+ 802050ec: 00001097 auipc ra,0x1
+ 802050f0: 606080e7 jalr 1542(ra) # 802066f2 <eput>
+
+ return 0;
+ 802050f4: 4501 li a0,0
+}
+ 802050f6: 29813083 ld ra,664(sp)
+ 802050fa: 29013403 ld s0,656(sp)
+ 802050fe: 28813483 ld s1,648(sp)
+ 80205102: 2a010113 addi sp,sp,672
+ 80205106: 8082 ret
+ if (s >= path && *s == '.' && (s == path || *--s == '/')) {
+ 80205108: ed840713 addi a4,s0,-296
+ 8020510c: f6e7e9e3 bltu a5,a4,8020507e <sys_remove+0x4a>
+ 80205110: 0007c683 lbu a3,0(a5)
+ 80205114: 02e00713 li a4,46
+ 80205118: f6e693e3 bne a3,a4,8020507e <sys_remove+0x4a>
+ 8020511c: ed840713 addi a4,s0,-296
+ 80205120: 02e78863 beq a5,a4,80205150 <sys_remove+0x11c>
+ 80205124: fff7c703 lbu a4,-1(a5)
+ 80205128: 02f00793 li a5,47
+ 8020512c: f4f719e3 bne a4,a5,8020507e <sys_remove+0x4a>
+ return -1;
+ 80205130: 557d li a0,-1
+ 80205132: b7d1 j 802050f6 <sys_remove+0xc2>
+ eunlock(ep);
+ 80205134: 8526 mv a0,s1
+ 80205136: 00001097 auipc ra,0x1
+ 8020513a: 56e080e7 jalr 1390(ra) # 802066a4 <eunlock>
+ eput(ep);
+ 8020513e: 8526 mv a0,s1
+ 80205140: 00001097 auipc ra,0x1
+ 80205144: 5b2080e7 jalr 1458(ra) # 802066f2 <eput>
+ return -1;
+ 80205148: 557d li a0,-1
+ 8020514a: b775 j 802050f6 <sys_remove+0xc2>
+ return -1;
+ 8020514c: 557d li a0,-1
+ 8020514e: b765 j 802050f6 <sys_remove+0xc2>
+ return -1;
+ 80205150: 557d li a0,-1
+ 80205152: b755 j 802050f6 <sys_remove+0xc2>
+ return -1;
+ 80205154: 557d li a0,-1
+ 80205156: b745 j 802050f6 <sys_remove+0xc2>
+
+0000000080205158 <sys_rename>:
+
+// Must hold too many locks at a time! It's possible to raise a deadlock.
+// Because this op takes some steps, we can't promise
+uint64
+sys_rename(void)
+{
+ 80205158: c4010113 addi sp,sp,-960
+ 8020515c: 3a113c23 sd ra,952(sp)
+ 80205160: 3a813823 sd s0,944(sp)
+ 80205164: 3a913423 sd s1,936(sp)
+ 80205168: 3b213023 sd s2,928(sp)
+ 8020516c: 39313c23 sd s3,920(sp)
+ 80205170: 39413823 sd s4,912(sp)
+ 80205174: 0780 addi s0,sp,960
+ char old[FAT32_MAX_PATH], new[FAT32_MAX_PATH];
+ if (argstr(0, old, FAT32_MAX_PATH) < 0 || argstr(1, new, FAT32_MAX_PATH) < 0) {
+ 80205176: 10400613 li a2,260
+ 8020517a: ec840593 addi a1,s0,-312
+ 8020517e: 4501 li a0,0
+ 80205180: ffffe097 auipc ra,0xffffe
+ 80205184: f86080e7 jalr -122(ra) # 80203106 <argstr>
+ return -1;
+ 80205188: 57fd li a5,-1
+ if (argstr(0, old, FAT32_MAX_PATH) < 0 || argstr(1, new, FAT32_MAX_PATH) < 0) {
+ 8020518a: 0c054d63 bltz a0,80205264 <sys_rename+0x10c>
+ 8020518e: 10400613 li a2,260
+ 80205192: dc040593 addi a1,s0,-576
+ 80205196: 4505 li a0,1
+ 80205198: ffffe097 auipc ra,0xffffe
+ 8020519c: f6e080e7 jalr -146(ra) # 80203106 <argstr>
+ return -1;
+ 802051a0: 57fd li a5,-1
+ if (argstr(0, old, FAT32_MAX_PATH) < 0 || argstr(1, new, FAT32_MAX_PATH) < 0) {
+ 802051a2: 0c054163 bltz a0,80205264 <sys_rename+0x10c>
+ }
+
+ struct dirent *src = NULL, *dst = NULL, *pdst = NULL;
+ int srclock = 0;
+ char *name;
+ if ((src = ename(old)) == NULL || (pdst = enameparent(new, old)) == NULL
+ 802051a6: ec840513 addi a0,s0,-312
+ 802051aa: 00002097 auipc ra,0x2
+ 802051ae: c6c080e7 jalr -916(ra) # 80206e16 <ename>
+ 802051b2: 84aa mv s1,a0
+ 802051b4: 1c050963 beqz a0,80205386 <sys_rename+0x22e>
+ 802051b8: ec840593 addi a1,s0,-312
+ 802051bc: dc040513 addi a0,s0,-576
+ 802051c0: 00002097 auipc ra,0x2
+ 802051c4: c74080e7 jalr -908(ra) # 80206e34 <enameparent>
+ 802051c8: 892a mv s2,a0
+ 802051ca: cd35 beqz a0,80205246 <sys_rename+0xee>
+ || (name = formatname(old)) == NULL) {
+ 802051cc: ec840513 addi a0,s0,-312
+ 802051d0: 00001097 auipc ra,0x1
+ 802051d4: dbe080e7 jalr -578(ra) # 80205f8e <formatname>
+ 802051d8: 89aa mv s3,a0
+ 802051da: c535 beqz a0,80205246 <sys_rename+0xee>
+ goto fail; // src doesn't exist || dst parent doesn't exist || illegal new name
+ }
+ for (struct dirent *ep = pdst; ep != NULL; ep = ep->parent) {
+ if (ep == src) { // In what universe can we move a directory into its child?
+ 802051dc: 07248563 beq s1,s2,80205246 <sys_rename+0xee>
+ for (struct dirent *ep = pdst; ep != NULL; ep = ep->parent) {
+ 802051e0: 87ca mv a5,s2
+ 802051e2: 1207b783 ld a5,288(a5)
+ 802051e6: c781 beqz a5,802051ee <sys_rename+0x96>
+ if (ep == src) { // In what universe can we move a directory into its child?
+ 802051e8: fef49de3 bne s1,a5,802051e2 <sys_rename+0x8a>
+ 802051ec: a8a9 j 80205246 <sys_rename+0xee>
+ goto fail;
+ }
+ }
+
+ uint off;
+ elock(src); // must hold child's lock before acquiring parent's, because we do so in other similar cases
+ 802051ee: 8526 mv a0,s1
+ 802051f0: 00001097 auipc ra,0x1
+ 802051f4: 47e080e7 jalr 1150(ra) # 8020666e <elock>
+ srclock = 1;
+ elock(pdst);
+ 802051f8: 854a mv a0,s2
+ 802051fa: 00001097 auipc ra,0x1
+ 802051fe: 474080e7 jalr 1140(ra) # 8020666e <elock>
+ dst = dirlookup(pdst, name, &off);
+ 80205202: dbc40613 addi a2,s0,-580
+ 80205206: 85ce mv a1,s3
+ 80205208: 854a mv a0,s2
+ 8020520a: 00001097 auipc ra,0x1
+ 8020520e: 7f2080e7 jalr 2034(ra) # 802069fc <dirlookup>
+ 80205212: 8a2a mv s4,a0
+ if (dst != NULL) {
+ 80205214: cd45 beqz a0,802052cc <sys_rename+0x174>
+ eunlock(pdst);
+ 80205216: 854a mv a0,s2
+ 80205218: 00001097 auipc ra,0x1
+ 8020521c: 48c080e7 jalr 1164(ra) # 802066a4 <eunlock>
+ if (src == dst) {
+ 80205220: 01448963 beq s1,s4,80205232 <sys_rename+0xda>
+ goto fail;
+ } else if (src->attribute & dst->attribute & ATTR_DIRECTORY) {
+ 80205224: 1004c783 lbu a5,256(s1)
+ 80205228: 100a4703 lbu a4,256(s4)
+ 8020522c: 8ff9 and a5,a5,a4
+ 8020522e: 8bc1 andi a5,a5,16
+ 80205230: ebb1 bnez a5,80205284 <sys_rename+0x12c>
+
+ return 0;
+
+fail:
+ if (srclock)
+ eunlock(src);
+ 80205232: 8526 mv a0,s1
+ 80205234: 00001097 auipc ra,0x1
+ 80205238: 470080e7 jalr 1136(ra) # 802066a4 <eunlock>
+ if (dst)
+ eput(dst);
+ 8020523c: 8552 mv a0,s4
+ 8020523e: 00001097 auipc ra,0x1
+ 80205242: 4b4080e7 jalr 1204(ra) # 802066f2 <eput>
+ if (pdst)
+ 80205246: 00090763 beqz s2,80205254 <sys_rename+0xfc>
+ eput(pdst);
+ 8020524a: 854a mv a0,s2
+ 8020524c: 00001097 auipc ra,0x1
+ 80205250: 4a6080e7 jalr 1190(ra) # 802066f2 <eput>
+ if (src)
+ eput(src);
+ return -1;
+ 80205254: 57fd li a5,-1
+ if (src)
+ 80205256: c499 beqz s1,80205264 <sys_rename+0x10c>
+ eput(src);
+ 80205258: 8526 mv a0,s1
+ 8020525a: 00001097 auipc ra,0x1
+ 8020525e: 498080e7 jalr 1176(ra) # 802066f2 <eput>
+ return -1;
+ 80205262: 57fd li a5,-1
+}
+ 80205264: 853e mv a0,a5
+ 80205266: 3b813083 ld ra,952(sp)
+ 8020526a: 3b013403 ld s0,944(sp)
+ 8020526e: 3a813483 ld s1,936(sp)
+ 80205272: 3a013903 ld s2,928(sp)
+ 80205276: 39813983 ld s3,920(sp)
+ 8020527a: 39013a03 ld s4,912(sp)
+ 8020527e: 3c010113 addi sp,sp,960
+ 80205282: 8082 ret
+ elock(dst);
+ 80205284: 8552 mv a0,s4
+ 80205286: 00001097 auipc ra,0x1
+ 8020528a: 3e8080e7 jalr 1000(ra) # 8020666e <elock>
+ ep.valid = 0;
+ 8020528e: d6041323 sh zero,-666(s0)
+ ret = enext(dp, &ep, 2 * 32, &count); // skip the "." and ".."
+ 80205292: c4c40693 addi a3,s0,-948
+ 80205296: 04000613 li a2,64
+ 8020529a: c5040593 addi a1,s0,-944
+ 8020529e: 8552 mv a0,s4
+ 802052a0: 00001097 auipc ra,0x1
+ 802052a4: 5d2080e7 jalr 1490(ra) # 80206872 <enext>
+ if (!isdirempty(dst)) { // it's ok to overwrite an empty dir
+ 802052a8: 57fd li a5,-1
+ 802052aa: 0cf51863 bne a0,a5,8020537a <sys_rename+0x222>
+ elock(pdst);
+ 802052ae: 854a mv a0,s2
+ 802052b0: 00001097 auipc ra,0x1
+ 802052b4: 3be080e7 jalr 958(ra) # 8020666e <elock>
+ eremove(dst);
+ 802052b8: 8552 mv a0,s4
+ 802052ba: 00001097 auipc ra,0x1
+ 802052be: 280080e7 jalr 640(ra) # 8020653a <eremove>
+ eunlock(dst);
+ 802052c2: 8552 mv a0,s4
+ 802052c4: 00001097 auipc ra,0x1
+ 802052c8: 3e0080e7 jalr 992(ra) # 802066a4 <eunlock>
+ memmove(src->filename, name, FAT32_MAX_FILENAME);
+ 802052cc: 0ff00613 li a2,255
+ 802052d0: 85ce mv a1,s3
+ 802052d2: 8526 mv a0,s1
+ 802052d4: ffffb097 auipc ra,0xffffb
+ 802052d8: 4ea080e7 jalr 1258(ra) # 802007be <memmove>
+ emake(pdst, src, off);
+ 802052dc: dbc42603 lw a2,-580(s0)
+ 802052e0: 85a6 mv a1,s1
+ 802052e2: 854a mv a0,s2
+ 802052e4: 00001097 auipc ra,0x1
+ 802052e8: d62080e7 jalr -670(ra) # 80206046 <emake>
+ if (src->parent != pdst) {
+ 802052ec: 1204b783 ld a5,288(s1)
+ 802052f0: 01278d63 beq a5,s2,8020530a <sys_rename+0x1b2>
+ eunlock(pdst);
+ 802052f4: 854a mv a0,s2
+ 802052f6: 00001097 auipc ra,0x1
+ 802052fa: 3ae080e7 jalr 942(ra) # 802066a4 <eunlock>
+ elock(src->parent);
+ 802052fe: 1204b503 ld a0,288(s1)
+ 80205302: 00001097 auipc ra,0x1
+ 80205306: 36c080e7 jalr 876(ra) # 8020666e <elock>
+ eremove(src);
+ 8020530a: 8526 mv a0,s1
+ 8020530c: 00001097 auipc ra,0x1
+ 80205310: 22e080e7 jalr 558(ra) # 8020653a <eremove>
+ eunlock(src->parent);
+ 80205314: 1204b503 ld a0,288(s1)
+ 80205318: 00001097 auipc ra,0x1
+ 8020531c: 38c080e7 jalr 908(ra) # 802066a4 <eunlock>
+ struct dirent *psrc = src->parent; // src must not be root, or it won't pass the for-loop test
+ 80205320: 1204b983 ld s3,288(s1)
+ src->parent = edup(pdst);
+ 80205324: 854a mv a0,s2
+ 80205326: 00001097 auipc ra,0x1
+ 8020532a: 0ea080e7 jalr 234(ra) # 80206410 <edup>
+ 8020532e: 12a4b023 sd a0,288(s1)
+ src->off = off;
+ 80205332: dbc42783 lw a5,-580(s0)
+ 80205336: 10f4ae23 sw a5,284(s1)
+ src->valid = 1;
+ 8020533a: 4785 li a5,1
+ 8020533c: 10f49b23 sh a5,278(s1)
+ eunlock(src);
+ 80205340: 8526 mv a0,s1
+ 80205342: 00001097 auipc ra,0x1
+ 80205346: 362080e7 jalr 866(ra) # 802066a4 <eunlock>
+ eput(psrc);
+ 8020534a: 854e mv a0,s3
+ 8020534c: 00001097 auipc ra,0x1
+ 80205350: 3a6080e7 jalr 934(ra) # 802066f2 <eput>
+ if (dst) {
+ 80205354: 000a0763 beqz s4,80205362 <sys_rename+0x20a>
+ eput(dst);
+ 80205358: 8552 mv a0,s4
+ 8020535a: 00001097 auipc ra,0x1
+ 8020535e: 398080e7 jalr 920(ra) # 802066f2 <eput>
+ eput(pdst);
+ 80205362: 854a mv a0,s2
+ 80205364: 00001097 auipc ra,0x1
+ 80205368: 38e080e7 jalr 910(ra) # 802066f2 <eput>
+ eput(src);
+ 8020536c: 8526 mv a0,s1
+ 8020536e: 00001097 auipc ra,0x1
+ 80205372: 384080e7 jalr 900(ra) # 802066f2 <eput>
+ return 0;
+ 80205376: 4781 li a5,0
+ 80205378: b5f5 j 80205264 <sys_rename+0x10c>
+ eunlock(dst);
+ 8020537a: 8552 mv a0,s4
+ 8020537c: 00001097 auipc ra,0x1
+ 80205380: 328080e7 jalr 808(ra) # 802066a4 <eunlock>
+ goto fail;
+ 80205384: b57d j 80205232 <sys_rename+0xda>
+ struct dirent *src = NULL, *dst = NULL, *pdst = NULL;
+ 80205386: 892a mv s2,a0
+ if (dst)
+ 80205388: bd7d j 80205246 <sys_rename+0xee>
+ 8020538a: 0000 unimp
+ 8020538c: 0000 unimp
+ ...
+
+0000000080205390 <kernelvec>:
+ 80205390: 7111 addi sp,sp,-256
+ 80205392: e006 sd ra,0(sp)
+ 80205394: e40a sd sp,8(sp)
+ 80205396: e80e sd gp,16(sp)
+ 80205398: ec12 sd tp,24(sp)
+ 8020539a: f016 sd t0,32(sp)
+ 8020539c: f41a sd t1,40(sp)
+ 8020539e: f81e sd t2,48(sp)
+ 802053a0: fc22 sd s0,56(sp)
+ 802053a2: e0a6 sd s1,64(sp)
+ 802053a4: e4aa sd a0,72(sp)
+ 802053a6: e8ae sd a1,80(sp)
+ 802053a8: ecb2 sd a2,88(sp)
+ 802053aa: f0b6 sd a3,96(sp)
+ 802053ac: f4ba sd a4,104(sp)
+ 802053ae: f8be sd a5,112(sp)
+ 802053b0: fcc2 sd a6,120(sp)
+ 802053b2: e146 sd a7,128(sp)
+ 802053b4: e54a sd s2,136(sp)
+ 802053b6: e94e sd s3,144(sp)
+ 802053b8: ed52 sd s4,152(sp)
+ 802053ba: f156 sd s5,160(sp)
+ 802053bc: f55a sd s6,168(sp)
+ 802053be: f95e sd s7,176(sp)
+ 802053c0: fd62 sd s8,184(sp)
+ 802053c2: e1e6 sd s9,192(sp)
+ 802053c4: e5ea sd s10,200(sp)
+ 802053c6: e9ee sd s11,208(sp)
+ 802053c8: edf2 sd t3,216(sp)
+ 802053ca: f1f6 sd t4,224(sp)
+ 802053cc: f5fa sd t5,232(sp)
+ 802053ce: f9fe sd t6,240(sp)
+ 802053d0: fc4fd0ef jal ra,80202b94 <kerneltrap>
+ 802053d4: 6082 ld ra,0(sp)
+ 802053d6: 6122 ld sp,8(sp)
+ 802053d8: 61c2 ld gp,16(sp)
+ 802053da: 7282 ld t0,32(sp)
+ 802053dc: 7322 ld t1,40(sp)
+ 802053de: 73c2 ld t2,48(sp)
+ 802053e0: 7462 ld s0,56(sp)
+ 802053e2: 6486 ld s1,64(sp)
+ 802053e4: 6526 ld a0,72(sp)
+ 802053e6: 65c6 ld a1,80(sp)
+ 802053e8: 6666 ld a2,88(sp)
+ 802053ea: 7686 ld a3,96(sp)
+ 802053ec: 7726 ld a4,104(sp)
+ 802053ee: 77c6 ld a5,112(sp)
+ 802053f0: 7866 ld a6,120(sp)
+ 802053f2: 688a ld a7,128(sp)
+ 802053f4: 692a ld s2,136(sp)
+ 802053f6: 69ca ld s3,144(sp)
+ 802053f8: 6a6a ld s4,152(sp)
+ 802053fa: 7a8a ld s5,160(sp)
+ 802053fc: 7b2a ld s6,168(sp)
+ 802053fe: 7bca ld s7,176(sp)
+ 80205400: 7c6a ld s8,184(sp)
+ 80205402: 6c8e ld s9,192(sp)
+ 80205404: 6d2e ld s10,200(sp)
+ 80205406: 6dce ld s11,208(sp)
+ 80205408: 6e6e ld t3,216(sp)
+ 8020540a: 7e8e ld t4,224(sp)
+ 8020540c: 7f2e ld t5,232(sp)
+ 8020540e: 7fce ld t6,240(sp)
+ 80205410: 6111 addi sp,sp,256
+ 80205412: 10200073 sret
+ ...
+
+000000008020541e <timerinit>:
+#include "include/proc.h"
+
+struct spinlock tickslock;
+uint ticks;
+
+void timerinit() {
+ 8020541e: 1141 addi sp,sp,-16
+ 80205420: e406 sd ra,8(sp)
+ 80205422: e022 sd s0,0(sp)
+ 80205424: 0800 addi s0,sp,16
+ initlock(&tickslock, "time");
+ 80205426: 00005597 auipc a1,0x5
+ 8020542a: 92258593 addi a1,a1,-1758 # 80209d48 <digits+0x9c8>
+ 8020542e: 00019517 auipc a0,0x19
+ 80205432: fda50513 addi a0,a0,-38 # 8021e408 <tickslock>
+ 80205436: ffffb097 auipc ra,0xffffb
+ 8020543a: 24c080e7 jalr 588(ra) # 80200682 <initlock>
+ #ifdef DEBUG
+ printf("timerinit\n");
+ #endif
+}
+ 8020543e: 60a2 ld ra,8(sp)
+ 80205440: 6402 ld s0,0(sp)
+ 80205442: 0141 addi sp,sp,16
+ 80205444: 8082 ret
+
+0000000080205446 <set_next_timeout>:
+
+void
+set_next_timeout() {
+ 80205446: 1141 addi sp,sp,-16
+ 80205448: e422 sd s0,8(sp)
+ 8020544a: 0800 addi s0,sp,16
+ asm volatile("rdtime %0" : "=r" (x) );
+ 8020544c: c0102573 rdtime a0
+ // if comment the `printf` line below
+ // the timer will not work.
+
+ // this bug seems to disappear automatically
+ // printf("");
+ sbi_set_timer(r_time() + INTERVAL);
+ 80205450: 001dc7b7 lui a5,0x1dc
+ 80205454: 13078793 addi a5,a5,304 # 1dc130 <_entry-0x80023ed0>
+ 80205458: 953e add a0,a0,a5
+ SBI_CALL_1(SBI_SET_TIMER, stime_value);
+ 8020545a: 4581 li a1,0
+ 8020545c: 4601 li a2,0
+ 8020545e: 4681 li a3,0
+ 80205460: 4881 li a7,0
+ 80205462: 00000073 ecall
+}
+ 80205466: 6422 ld s0,8(sp)
+ 80205468: 0141 addi sp,sp,16
+ 8020546a: 8082 ret
+
+000000008020546c <timer_tick>:
+
+void timer_tick() {
+ 8020546c: 1101 addi sp,sp,-32
+ 8020546e: ec06 sd ra,24(sp)
+ 80205470: e822 sd s0,16(sp)
+ 80205472: e426 sd s1,8(sp)
+ 80205474: 1000 addi s0,sp,32
+ acquire(&tickslock);
+ 80205476: 00019497 auipc s1,0x19
+ 8020547a: f9248493 addi s1,s1,-110 # 8021e408 <tickslock>
+ 8020547e: 8526 mv a0,s1
+ 80205480: ffffb097 auipc ra,0xffffb
+ 80205484: 246080e7 jalr 582(ra) # 802006c6 <acquire>
+ ticks++;
+ 80205488: 4c9c lw a5,24(s1)
+ 8020548a: 2785 addiw a5,a5,1
+ 8020548c: cc9c sw a5,24(s1)
+ wakeup(&ticks);
+ 8020548e: 00019517 auipc a0,0x19
+ 80205492: f9250513 addi a0,a0,-110 # 8021e420 <ticks>
+ 80205496: ffffd097 auipc ra,0xffffd
+ 8020549a: 1f6080e7 jalr 502(ra) # 8020268c <wakeup>
+ release(&tickslock);
+ 8020549e: 8526 mv a0,s1
+ 802054a0: ffffb097 auipc ra,0xffffb
+ 802054a4: 27a080e7 jalr 634(ra) # 8020071a <release>
+ set_next_timeout();
+ 802054a8: 00000097 auipc ra,0x0
+ 802054ac: f9e080e7 jalr -98(ra) # 80205446 <set_next_timeout>
+}
+ 802054b0: 60e2 ld ra,24(sp)
+ 802054b2: 6442 ld s0,16(sp)
+ 802054b4: 64a2 ld s1,8(sp)
+ 802054b6: 6105 addi sp,sp,32
+ 802054b8: 8082 ret
+
+00000000802054ba <disk_init>:
+#else
+#include "include/virtio.h"
+#endif
+
+void disk_init(void)
+{
+ 802054ba: 1141 addi sp,sp,-16
+ 802054bc: e406 sd ra,8(sp)
+ 802054be: e022 sd s0,0(sp)
+ 802054c0: 0800 addi s0,sp,16
+ #ifdef QEMU
+ virtio_disk_init();
+ 802054c2: 00002097 auipc ra,0x2
+ 802054c6: e8e080e7 jalr -370(ra) # 80207350 <virtio_disk_init>
+ #else
+ sdcard_init();
+ #endif
+}
+ 802054ca: 60a2 ld ra,8(sp)
+ 802054cc: 6402 ld s0,0(sp)
+ 802054ce: 0141 addi sp,sp,16
+ 802054d0: 8082 ret
+
+00000000802054d2 <disk_read>:
+
+void disk_read(struct buf *b)
+{
+ 802054d2: 1141 addi sp,sp,-16
+ 802054d4: e406 sd ra,8(sp)
+ 802054d6: e022 sd s0,0(sp)
+ 802054d8: 0800 addi s0,sp,16
+ #ifdef QEMU
+ virtio_disk_rw(b, 0);
+ 802054da: 4581 li a1,0
+ 802054dc: 00002097 auipc ra,0x2
+ 802054e0: ffa080e7 jalr -6(ra) # 802074d6 <virtio_disk_rw>
+ #else
+ sdcard_read_sector(b->data, b->sectorno);
+ #endif
+}
+ 802054e4: 60a2 ld ra,8(sp)
+ 802054e6: 6402 ld s0,0(sp)
+ 802054e8: 0141 addi sp,sp,16
+ 802054ea: 8082 ret
+
+00000000802054ec <disk_write>:
+
+void disk_write(struct buf *b)
+{
+ 802054ec: 1141 addi sp,sp,-16
+ 802054ee: e406 sd ra,8(sp)
+ 802054f0: e022 sd s0,0(sp)
+ 802054f2: 0800 addi s0,sp,16
+ #ifdef QEMU
+ virtio_disk_rw(b, 1);
+ 802054f4: 4585 li a1,1
+ 802054f6: 00002097 auipc ra,0x2
+ 802054fa: fe0080e7 jalr -32(ra) # 802074d6 <virtio_disk_rw>
+ #else
+ sdcard_write_sector(b->data, b->sectorno);
+ #endif
+}
+ 802054fe: 60a2 ld ra,8(sp)
+ 80205500: 6402 ld s0,0(sp)
+ 80205502: 0141 addi sp,sp,16
+ 80205504: 8082 ret
+
+0000000080205506 <disk_intr>:
+
+void disk_intr(void)
+{
+ 80205506: 1141 addi sp,sp,-16
+ 80205508: e406 sd ra,8(sp)
+ 8020550a: e022 sd s0,0(sp)
+ 8020550c: 0800 addi s0,sp,16
+ #ifdef QEMU
+ virtio_disk_intr();
+ 8020550e: 00002097 auipc ra,0x2
+ 80205512: 254080e7 jalr 596(ra) # 80207762 <virtio_disk_intr>
+ #else
+ dmac_intr(DMAC_CHANNEL0);
+ #endif
+}
+ 80205516: 60a2 ld ra,8(sp)
+ 80205518: 6402 ld s0,0(sp)
+ 8020551a: 0141 addi sp,sp,16
+ 8020551c: 8082 ret
+
+000000008020551e <read_fat>:
+/**
+ * Read the FAT table content corresponded to the given cluster number.
+ * @param cluster the number of cluster which you want to read its content in FAT table
+ */
+static uint32 read_fat(uint32 cluster)
+{
+ 8020551e: 1101 addi sp,sp,-32
+ 80205520: ec06 sd ra,24(sp)
+ 80205522: e822 sd s0,16(sp)
+ 80205524: e426 sd s1,8(sp)
+ 80205526: e04a sd s2,0(sp)
+ 80205528: 1000 addi s0,sp,32
+ if (cluster >= FAT32_EOC) {
+ 8020552a: 100007b7 lui a5,0x10000
+ 8020552e: 17dd addi a5,a5,-9 # ffffff7 <_entry-0x70200009>
+ return cluster;
+ 80205530: 84aa mv s1,a0
+ if (cluster >= FAT32_EOC) {
+ 80205532: 00a7ea63 bltu a5,a0,80205546 <read_fat+0x28>
+ }
+ if (cluster > fat.data_clus_cnt + 1) { // because cluster number starts at 2, not 0
+ 80205536: 00019797 auipc a5,0x19
+ 8020553a: efa7a783 lw a5,-262(a5) # 8021e430 <fat+0x8>
+ 8020553e: 2785 addiw a5,a5,1
+ return 0;
+ 80205540: 4481 li s1,0
+ if (cluster > fat.data_clus_cnt + 1) { // because cluster number starts at 2, not 0
+ 80205542: 00a7f963 bgeu a5,a0,80205554 <read_fat+0x36>
+ // here should be a cache layer for FAT table, but not implemented yet.
+ struct buf *b = bread(0, fat_sec);
+ uint32 next_clus = *(uint32 *)(b->data + fat_offset_of_clus(cluster));
+ brelse(b);
+ return next_clus;
+}
+ 80205546: 8526 mv a0,s1
+ 80205548: 60e2 ld ra,24(sp)
+ 8020554a: 6442 ld s0,16(sp)
+ 8020554c: 64a2 ld s1,8(sp)
+ 8020554e: 6902 ld s2,0(sp)
+ 80205550: 6105 addi sp,sp,32
+ 80205552: 8082 ret
+ return fat.bpb.rsvd_sec_cnt + (cluster << 2) / fat.bpb.byts_per_sec + fat.bpb.fat_sz * (fat_num - 1);
+ 80205554: 0025149b slliw s1,a0,0x2
+ 80205558: 00019917 auipc s2,0x19
+ 8020555c: ed090913 addi s2,s2,-304 # 8021e428 <fat>
+ 80205560: 01095783 lhu a5,16(s2)
+ 80205564: 02f4d7bb divuw a5,s1,a5
+ 80205568: 01495583 lhu a1,20(s2)
+ struct buf *b = bread(0, fat_sec);
+ 8020556c: 9dbd addw a1,a1,a5
+ 8020556e: 4501 li a0,0
+ 80205570: ffffe097 auipc ra,0xffffe
+ 80205574: 2e2080e7 jalr 738(ra) # 80203852 <bread>
+ return (cluster << 2) % fat.bpb.byts_per_sec;
+ 80205578: 01095783 lhu a5,16(s2)
+ 8020557c: 02f4f4bb remuw s1,s1,a5
+ uint32 next_clus = *(uint32 *)(b->data + fat_offset_of_clus(cluster));
+ 80205580: 1482 slli s1,s1,0x20
+ 80205582: 9081 srli s1,s1,0x20
+ 80205584: 009507b3 add a5,a0,s1
+ 80205588: 4fa4 lw s1,88(a5)
+ brelse(b);
+ 8020558a: ffffe097 auipc ra,0xffffe
+ 8020558e: 3f4080e7 jalr 1012(ra) # 8020397e <brelse>
+ return next_clus;
+ 80205592: bf55 j 80205546 <read_fat+0x28>
+
+0000000080205594 <alloc_clus>:
+ brelse(b);
+ }
+}
+
+static uint32 alloc_clus(uint8 dev)
+{
+ 80205594: 711d addi sp,sp,-96
+ 80205596: ec86 sd ra,88(sp)
+ 80205598: e8a2 sd s0,80(sp)
+ 8020559a: e4a6 sd s1,72(sp)
+ 8020559c: e0ca sd s2,64(sp)
+ 8020559e: fc4e sd s3,56(sp)
+ 802055a0: f852 sd s4,48(sp)
+ 802055a2: f456 sd s5,40(sp)
+ 802055a4: f05a sd s6,32(sp)
+ 802055a6: ec5e sd s7,24(sp)
+ 802055a8: e862 sd s8,16(sp)
+ 802055aa: e466 sd s9,8(sp)
+ 802055ac: 1080 addi s0,sp,96
+ // should we keep a free cluster list? instead of searching fat every time.
+ struct buf *b;
+ uint32 sec = fat.bpb.rsvd_sec_cnt;
+ 802055ae: 00019797 auipc a5,0x19
+ 802055b2: e7a78793 addi a5,a5,-390 # 8021e428 <fat>
+ 802055b6: 0147db83 lhu s7,20(a5)
+ uint32 const ent_per_sec = fat.bpb.byts_per_sec / sizeof(uint32);
+ 802055ba: 0107d903 lhu s2,16(a5)
+ for (uint32 i = 0; i < fat.bpb.fat_sz; i++, sec++) {
+ 802055be: 539c lw a5,32(a5)
+ 802055c0: 10078363 beqz a5,802056c6 <alloc_clus+0x132>
+ 802055c4: 0029591b srliw s2,s2,0x2
+ 802055c8: 0009099b sext.w s3,s2
+ 802055cc: 4b01 li s6,0
+ b = bread(dev, sec);
+ 802055ce: 00050a9b sext.w s5,a0
+ for (uint32 j = 0; j < ent_per_sec; j++) {
+ 802055d2: 4c01 li s8,0
+ for (uint32 i = 0; i < fat.bpb.fat_sz; i++, sec++) {
+ 802055d4: 00019c97 auipc s9,0x19
+ 802055d8: e54c8c93 addi s9,s9,-428 # 8021e428 <fat>
+ 802055dc: a0c9 j 8020569e <alloc_clus+0x10a>
+ if (((uint32 *)(b->data))[j] == 0) {
+ ((uint32 *)(b->data))[j] = FAT32_EOC + 7;
+ 802055de: 100007b7 lui a5,0x10000
+ 802055e2: 17fd addi a5,a5,-1 # fffffff <_entry-0x70200001>
+ 802055e4: c29c sw a5,0(a3)
+ bwrite(b);
+ 802055e6: 8552 mv a0,s4
+ 802055e8: ffffe097 auipc ra,0xffffe
+ 802055ec: 35a080e7 jalr 858(ra) # 80203942 <bwrite>
+ brelse(b);
+ 802055f0: 8552 mv a0,s4
+ 802055f2: ffffe097 auipc ra,0xffffe
+ 802055f6: 38c080e7 jalr 908(ra) # 8020397e <brelse>
+ uint32 clus = i * ent_per_sec + j;
+ 802055fa: 0369093b mulw s2,s2,s6
+ 802055fe: 0099093b addw s2,s2,s1
+ 80205602: 00090a9b sext.w s5,s2
+ return ((cluster - 2) * fat.bpb.sec_per_clus) + fat.first_data_sec;
+ 80205606: 00019717 auipc a4,0x19
+ 8020560a: e2270713 addi a4,a4,-478 # 8021e428 <fat>
+ 8020560e: 01274783 lbu a5,18(a4)
+ 80205612: ffe9099b addiw s3,s2,-2
+ 80205616: 02f989bb mulw s3,s3,a5
+ 8020561a: 4318 lw a4,0(a4)
+ 8020561c: 00e989bb addw s3,s3,a4
+ for (int i = 0; i < fat.bpb.sec_per_clus; i++) {
+ 80205620: c7b1 beqz a5,8020566c <alloc_clus+0xd8>
+ 80205622: 4901 li s2,0
+ 80205624: 00019a17 auipc s4,0x19
+ 80205628: e04a0a13 addi s4,s4,-508 # 8021e428 <fat>
+ b = bread(0, sec++);
+ 8020562c: 013905bb addw a1,s2,s3
+ 80205630: 4501 li a0,0
+ 80205632: ffffe097 auipc ra,0xffffe
+ 80205636: 220080e7 jalr 544(ra) # 80203852 <bread>
+ 8020563a: 84aa mv s1,a0
+ memset(b->data, 0, BSIZE);
+ 8020563c: 20000613 li a2,512
+ 80205640: 4581 li a1,0
+ 80205642: 05850513 addi a0,a0,88
+ 80205646: ffffb097 auipc ra,0xffffb
+ 8020564a: 11c080e7 jalr 284(ra) # 80200762 <memset>
+ bwrite(b);
+ 8020564e: 8526 mv a0,s1
+ 80205650: ffffe097 auipc ra,0xffffe
+ 80205654: 2f2080e7 jalr 754(ra) # 80203942 <bwrite>
+ brelse(b);
+ 80205658: 8526 mv a0,s1
+ 8020565a: ffffe097 auipc ra,0xffffe
+ 8020565e: 324080e7 jalr 804(ra) # 8020397e <brelse>
+ for (int i = 0; i < fat.bpb.sec_per_clus; i++) {
+ 80205662: 2905 addiw s2,s2,1
+ 80205664: 012a4783 lbu a5,18(s4)
+ 80205668: fcf942e3 blt s2,a5,8020562c <alloc_clus+0x98>
+ }
+ }
+ brelse(b);
+ }
+ panic("no clusters");
+}
+ 8020566c: 8556 mv a0,s5
+ 8020566e: 60e6 ld ra,88(sp)
+ 80205670: 6446 ld s0,80(sp)
+ 80205672: 64a6 ld s1,72(sp)
+ 80205674: 6906 ld s2,64(sp)
+ 80205676: 79e2 ld s3,56(sp)
+ 80205678: 7a42 ld s4,48(sp)
+ 8020567a: 7aa2 ld s5,40(sp)
+ 8020567c: 7b02 ld s6,32(sp)
+ 8020567e: 6be2 ld s7,24(sp)
+ 80205680: 6c42 ld s8,16(sp)
+ 80205682: 6ca2 ld s9,8(sp)
+ 80205684: 6125 addi sp,sp,96
+ 80205686: 8082 ret
+ brelse(b);
+ 80205688: 8552 mv a0,s4
+ 8020568a: ffffe097 auipc ra,0xffffe
+ 8020568e: 2f4080e7 jalr 756(ra) # 8020397e <brelse>
+ for (uint32 i = 0; i < fat.bpb.fat_sz; i++, sec++) {
+ 80205692: 2b05 addiw s6,s6,1
+ 80205694: 2b85 addiw s7,s7,1 # fffffffffffff001 <ebss_clear+0xffffffff7fdd9001>
+ 80205696: 020ca783 lw a5,32(s9)
+ 8020569a: 02fb7663 bgeu s6,a5,802056c6 <alloc_clus+0x132>
+ b = bread(dev, sec);
+ 8020569e: 85de mv a1,s7
+ 802056a0: 8556 mv a0,s5
+ 802056a2: ffffe097 auipc ra,0xffffe
+ 802056a6: 1b0080e7 jalr 432(ra) # 80203852 <bread>
+ 802056aa: 8a2a mv s4,a0
+ for (uint32 j = 0; j < ent_per_sec; j++) {
+ 802056ac: fc098ee3 beqz s3,80205688 <alloc_clus+0xf4>
+ 802056b0: 05850793 addi a5,a0,88
+ 802056b4: 84e2 mv s1,s8
+ if (((uint32 *)(b->data))[j] == 0) {
+ 802056b6: 86be mv a3,a5
+ 802056b8: 4398 lw a4,0(a5)
+ 802056ba: d315 beqz a4,802055de <alloc_clus+0x4a>
+ for (uint32 j = 0; j < ent_per_sec; j++) {
+ 802056bc: 2485 addiw s1,s1,1
+ 802056be: 0791 addi a5,a5,4
+ 802056c0: fe999be3 bne s3,s1,802056b6 <alloc_clus+0x122>
+ 802056c4: b7d1 j 80205688 <alloc_clus+0xf4>
+ panic("no clusters");
+ 802056c6: 00004517 auipc a0,0x4
+ 802056ca: 68a50513 addi a0,a0,1674 # 80209d50 <digits+0x9d0>
+ 802056ce: ffffb097 auipc ra,0xffffb
+ 802056d2: a76080e7 jalr -1418(ra) # 80200144 <panic>
+
+00000000802056d6 <write_fat>:
+ if (cluster > fat.data_clus_cnt + 1) {
+ 802056d6: 00019797 auipc a5,0x19
+ 802056da: d5a7a783 lw a5,-678(a5) # 8021e430 <fat+0x8>
+ 802056de: 2785 addiw a5,a5,1
+ 802056e0: 06a7e963 bltu a5,a0,80205752 <write_fat+0x7c>
+{
+ 802056e4: 7179 addi sp,sp,-48
+ 802056e6: f406 sd ra,40(sp)
+ 802056e8: f022 sd s0,32(sp)
+ 802056ea: ec26 sd s1,24(sp)
+ 802056ec: e84a sd s2,16(sp)
+ 802056ee: e44e sd s3,8(sp)
+ 802056f0: e052 sd s4,0(sp)
+ 802056f2: 1800 addi s0,sp,48
+ 802056f4: 89ae mv s3,a1
+ return fat.bpb.rsvd_sec_cnt + (cluster << 2) / fat.bpb.byts_per_sec + fat.bpb.fat_sz * (fat_num - 1);
+ 802056f6: 0025149b slliw s1,a0,0x2
+ 802056fa: 00019a17 auipc s4,0x19
+ 802056fe: d2ea0a13 addi s4,s4,-722 # 8021e428 <fat>
+ 80205702: 010a5783 lhu a5,16(s4)
+ 80205706: 02f4d7bb divuw a5,s1,a5
+ 8020570a: 014a5583 lhu a1,20(s4)
+ struct buf *b = bread(0, fat_sec);
+ 8020570e: 9dbd addw a1,a1,a5
+ 80205710: 4501 li a0,0
+ 80205712: ffffe097 auipc ra,0xffffe
+ 80205716: 140080e7 jalr 320(ra) # 80203852 <bread>
+ 8020571a: 892a mv s2,a0
+ return (cluster << 2) % fat.bpb.byts_per_sec;
+ 8020571c: 010a5783 lhu a5,16(s4)
+ 80205720: 02f4f4bb remuw s1,s1,a5
+ *(uint32 *)(b->data + off) = content;
+ 80205724: 1482 slli s1,s1,0x20
+ 80205726: 9081 srli s1,s1,0x20
+ 80205728: 94aa add s1,s1,a0
+ 8020572a: 0534ac23 sw s3,88(s1)
+ bwrite(b);
+ 8020572e: ffffe097 auipc ra,0xffffe
+ 80205732: 214080e7 jalr 532(ra) # 80203942 <bwrite>
+ brelse(b);
+ 80205736: 854a mv a0,s2
+ 80205738: ffffe097 auipc ra,0xffffe
+ 8020573c: 246080e7 jalr 582(ra) # 8020397e <brelse>
+ return 0;
+ 80205740: 4501 li a0,0
+}
+ 80205742: 70a2 ld ra,40(sp)
+ 80205744: 7402 ld s0,32(sp)
+ 80205746: 64e2 ld s1,24(sp)
+ 80205748: 6942 ld s2,16(sp)
+ 8020574a: 69a2 ld s3,8(sp)
+ 8020574c: 6a02 ld s4,0(sp)
+ 8020574e: 6145 addi sp,sp,48
+ 80205750: 8082 ret
+ return -1;
+ 80205752: 557d li a0,-1
+}
+ 80205754: 8082 ret
+
+0000000080205756 <reloc_clus>:
+ * @param off the offset from the beginning of the relative file
+ * @param alloc whether alloc new cluster when meeting end of FAT chains
+ * @return the offset from the new cur_clus
+ */
+static int reloc_clus(struct dirent *entry, uint off, int alloc)
+{
+ 80205756: 715d addi sp,sp,-80
+ 80205758: e486 sd ra,72(sp)
+ 8020575a: e0a2 sd s0,64(sp)
+ 8020575c: fc26 sd s1,56(sp)
+ 8020575e: f84a sd s2,48(sp)
+ 80205760: f44e sd s3,40(sp)
+ 80205762: f052 sd s4,32(sp)
+ 80205764: ec56 sd s5,24(sp)
+ 80205766: e85a sd s6,16(sp)
+ 80205768: e45e sd s7,8(sp)
+ 8020576a: 0880 addi s0,sp,80
+ 8020576c: 84aa mv s1,a0
+ 8020576e: 8a2e mv s4,a1
+ int clus_num = off / fat.byts_per_clus;
+ 80205770: 00019b97 auipc s7,0x19
+ 80205774: cc4bab83 lw s7,-828(s7) # 8021e434 <fat+0xc>
+ 80205778: 0375d9bb divuw s3,a1,s7
+ while (clus_num > entry->clus_cnt) {
+ 8020577c: 11052703 lw a4,272(a0)
+ 80205780: 07377563 bgeu a4,s3,802057ea <reloc_clus+0x94>
+ 80205784: 8b32 mv s6,a2
+ int clus = read_fat(entry->cur_clus);
+ if (clus >= FAT32_EOC) {
+ 80205786: 10000ab7 lui s5,0x10000
+ 8020578a: 1add addi s5,s5,-9 # ffffff7 <_entry-0x70200009>
+ 8020578c: a81d j 802057c2 <reloc_clus+0x6c>
+ if (alloc) {
+ clus = alloc_clus(entry->dev);
+ 8020578e: 1144c503 lbu a0,276(s1)
+ 80205792: 00000097 auipc ra,0x0
+ 80205796: e02080e7 jalr -510(ra) # 80205594 <alloc_clus>
+ 8020579a: 0005091b sext.w s2,a0
+ write_fat(entry->cur_clus, clus);
+ 8020579e: 85ca mv a1,s2
+ 802057a0: 10c4a503 lw a0,268(s1)
+ 802057a4: 00000097 auipc ra,0x0
+ 802057a8: f32080e7 jalr -206(ra) # 802056d6 <write_fat>
+ entry->cur_clus = entry->first_clus;
+ entry->clus_cnt = 0;
+ return -1;
+ }
+ }
+ entry->cur_clus = clus;
+ 802057ac: 1124a623 sw s2,268(s1)
+ entry->clus_cnt++;
+ 802057b0: 1104a783 lw a5,272(s1)
+ 802057b4: 2785 addiw a5,a5,1
+ 802057b6: 0007871b sext.w a4,a5
+ 802057ba: 10f4a823 sw a5,272(s1)
+ while (clus_num > entry->clus_cnt) {
+ 802057be: 03377663 bgeu a4,s3,802057ea <reloc_clus+0x94>
+ int clus = read_fat(entry->cur_clus);
+ 802057c2: 10c4a503 lw a0,268(s1)
+ 802057c6: 00000097 auipc ra,0x0
+ 802057ca: d58080e7 jalr -680(ra) # 8020551e <read_fat>
+ 802057ce: 0005091b sext.w s2,a0
+ if (clus >= FAT32_EOC) {
+ 802057d2: fd2adde3 bge s5,s2,802057ac <reloc_clus+0x56>
+ if (alloc) {
+ 802057d6: fa0b1ce3 bnez s6,8020578e <reloc_clus+0x38>
+ entry->cur_clus = entry->first_clus;
+ 802057da: 1044a783 lw a5,260(s1)
+ 802057de: 10f4a623 sw a5,268(s1)
+ entry->clus_cnt = 0;
+ 802057e2: 1004a823 sw zero,272(s1)
+ return -1;
+ 802057e6: 557d li a0,-1
+ 802057e8: a881 j 80205838 <reloc_clus+0xe2>
+ }
+ if (clus_num < entry->clus_cnt) {
+ 802057ea: 04e9f163 bgeu s3,a4,8020582c <reloc_clus+0xd6>
+ entry->cur_clus = entry->first_clus;
+ 802057ee: 1044a783 lw a5,260(s1)
+ 802057f2: 10f4a623 sw a5,268(s1)
+ entry->clus_cnt = 0;
+ 802057f6: 1004a823 sw zero,272(s1)
+ while (entry->clus_cnt < clus_num) {
+ 802057fa: 037a6963 bltu s4,s7,8020582c <reloc_clus+0xd6>
+ entry->cur_clus = read_fat(entry->cur_clus);
+ if (entry->cur_clus >= FAT32_EOC) {
+ 802057fe: 10000937 lui s2,0x10000
+ 80205802: 195d addi s2,s2,-9 # ffffff7 <_entry-0x70200009>
+ entry->cur_clus = read_fat(entry->cur_clus);
+ 80205804: 10c4a503 lw a0,268(s1)
+ 80205808: 00000097 auipc ra,0x0
+ 8020580c: d16080e7 jalr -746(ra) # 8020551e <read_fat>
+ 80205810: 2501 sext.w a0,a0
+ 80205812: 10a4a623 sw a0,268(s1)
+ if (entry->cur_clus >= FAT32_EOC) {
+ 80205816: 02a96c63 bltu s2,a0,8020584e <reloc_clus+0xf8>
+ panic("reloc_clus");
+ }
+ entry->clus_cnt++;
+ 8020581a: 1104a783 lw a5,272(s1)
+ 8020581e: 2785 addiw a5,a5,1
+ 80205820: 0007871b sext.w a4,a5
+ 80205824: 10f4a823 sw a5,272(s1)
+ while (entry->clus_cnt < clus_num) {
+ 80205828: fd376ee3 bltu a4,s3,80205804 <reloc_clus+0xae>
+ }
+ }
+ return off % fat.byts_per_clus;
+ 8020582c: 00019797 auipc a5,0x19
+ 80205830: c087a783 lw a5,-1016(a5) # 8021e434 <fat+0xc>
+ 80205834: 02fa753b remuw a0,s4,a5
+}
+ 80205838: 60a6 ld ra,72(sp)
+ 8020583a: 6406 ld s0,64(sp)
+ 8020583c: 74e2 ld s1,56(sp)
+ 8020583e: 7942 ld s2,48(sp)
+ 80205840: 79a2 ld s3,40(sp)
+ 80205842: 7a02 ld s4,32(sp)
+ 80205844: 6ae2 ld s5,24(sp)
+ 80205846: 6b42 ld s6,16(sp)
+ 80205848: 6ba2 ld s7,8(sp)
+ 8020584a: 6161 addi sp,sp,80
+ 8020584c: 8082 ret
+ panic("reloc_clus");
+ 8020584e: 00004517 auipc a0,0x4
+ 80205852: 51250513 addi a0,a0,1298 # 80209d60 <digits+0x9e0>
+ 80205856: ffffb097 auipc ra,0xffffb
+ 8020585a: 8ee080e7 jalr -1810(ra) # 80200144 <panic>
+
+000000008020585e <rw_clus>:
+{
+ 8020585e: 7119 addi sp,sp,-128
+ 80205860: fc86 sd ra,120(sp)
+ 80205862: f8a2 sd s0,112(sp)
+ 80205864: f4a6 sd s1,104(sp)
+ 80205866: f0ca sd s2,96(sp)
+ 80205868: ecce sd s3,88(sp)
+ 8020586a: e8d2 sd s4,80(sp)
+ 8020586c: e4d6 sd s5,72(sp)
+ 8020586e: e0da sd s6,64(sp)
+ 80205870: fc5e sd s7,56(sp)
+ 80205872: f862 sd s8,48(sp)
+ 80205874: f466 sd s9,40(sp)
+ 80205876: f06a sd s10,32(sp)
+ 80205878: ec6e sd s11,24(sp)
+ 8020587a: 0100 addi s0,sp,128
+ 8020587c: f8c43423 sd a2,-120(s0)
+ 80205880: 8b36 mv s6,a3
+ 80205882: 8c3e mv s8,a5
+ if (off + n > fat.byts_per_clus)
+ 80205884: 00f706bb addw a3,a4,a5
+ 80205888: 00019797 auipc a5,0x19
+ 8020588c: bac7a783 lw a5,-1108(a5) # 8021e434 <fat+0xc>
+ 80205890: 02d7ef63 bltu a5,a3,802058ce <rw_clus+0x70>
+ 80205894: 8cae mv s9,a1
+ uint sec = first_sec_of_clus(cluster) + off / fat.bpb.byts_per_sec;
+ 80205896: 00019797 auipc a5,0x19
+ 8020589a: b9278793 addi a5,a5,-1134 # 8021e428 <fat>
+ 8020589e: 0107d683 lhu a3,16(a5)
+ return ((cluster - 2) * fat.bpb.sec_per_clus) + fat.first_data_sec;
+ 802058a2: ffe5099b addiw s3,a0,-2
+ 802058a6: 0127c603 lbu a2,18(a5)
+ 802058aa: 02c989bb mulw s3,s3,a2
+ 802058ae: 439c lw a5,0(a5)
+ 802058b0: 00f989bb addw s3,s3,a5
+ uint sec = first_sec_of_clus(cluster) + off / fat.bpb.byts_per_sec;
+ 802058b4: 02d757bb divuw a5,a4,a3
+ 802058b8: 00f989bb addw s3,s3,a5
+ off = off % fat.bpb.byts_per_sec;
+ 802058bc: 02d77abb remuw s5,a4,a3
+ for (tot = 0; tot < n; tot += m, off += m, data += m, sec++) {
+ 802058c0: 0e0c0363 beqz s8,802059a6 <rw_clus+0x148>
+ 802058c4: 4a01 li s4,0
+ m = BSIZE - off % BSIZE;
+ 802058c6: 20000d93 li s11,512
+ if (bad == -1) {
+ 802058ca: 5d7d li s10,-1
+ 802058cc: a095 j 80205930 <rw_clus+0xd2>
+ panic("offset out of range");
+ 802058ce: 00004517 auipc a0,0x4
+ 802058d2: 4a250513 addi a0,a0,1186 # 80209d70 <digits+0x9f0>
+ 802058d6: ffffb097 auipc ra,0xffffb
+ 802058da: 86e080e7 jalr -1938(ra) # 80200144 <panic>
+ bwrite(bp);
+ 802058de: 854a mv a0,s2
+ 802058e0: ffffe097 auipc ra,0xffffe
+ 802058e4: 062080e7 jalr 98(ra) # 80203942 <bwrite>
+ brelse(bp);
+ 802058e8: 854a mv a0,s2
+ 802058ea: ffffe097 auipc ra,0xffffe
+ 802058ee: 094080e7 jalr 148(ra) # 8020397e <brelse>
+ if (bad == -1) {
+ 802058f2: a02d j 8020591c <rw_clus+0xbe>
+ bad = either_copyout(user, data, bp->data + (off % BSIZE), m);
+ 802058f4: 05890613 addi a2,s2,88
+ 802058f8: 1682 slli a3,a3,0x20
+ 802058fa: 9281 srli a3,a3,0x20
+ 802058fc: 963a add a2,a2,a4
+ 802058fe: 85da mv a1,s6
+ 80205900: f8843503 ld a0,-120(s0)
+ 80205904: ffffd097 auipc ra,0xffffd
+ 80205908: e62080e7 jalr -414(ra) # 80202766 <either_copyout>
+ 8020590c: 8baa mv s7,a0
+ brelse(bp);
+ 8020590e: 854a mv a0,s2
+ 80205910: ffffe097 auipc ra,0xffffe
+ 80205914: 06e080e7 jalr 110(ra) # 8020397e <brelse>
+ if (bad == -1) {
+ 80205918: 07ab8763 beq s7,s10,80205986 <rw_clus+0x128>
+ for (tot = 0; tot < n; tot += m, off += m, data += m, sec++) {
+ 8020591c: 01448a3b addw s4,s1,s4
+ 80205920: 01548abb addw s5,s1,s5
+ 80205924: 1482 slli s1,s1,0x20
+ 80205926: 9081 srli s1,s1,0x20
+ 80205928: 9b26 add s6,s6,s1
+ 8020592a: 2985 addiw s3,s3,1
+ 8020592c: 058a7d63 bgeu s4,s8,80205986 <rw_clus+0x128>
+ bp = bread(0, sec);
+ 80205930: 85ce mv a1,s3
+ 80205932: 4501 li a0,0
+ 80205934: ffffe097 auipc ra,0xffffe
+ 80205938: f1e080e7 jalr -226(ra) # 80203852 <bread>
+ 8020593c: 892a mv s2,a0
+ m = BSIZE - off % BSIZE;
+ 8020593e: 1ffaf713 andi a4,s5,511
+ if (n - tot < m) {
+ 80205942: 414c07bb subw a5,s8,s4
+ m = BSIZE - off % BSIZE;
+ 80205946: 40ed863b subw a2,s11,a4
+ 8020594a: 86be mv a3,a5
+ 8020594c: 2781 sext.w a5,a5
+ 8020594e: 0006059b sext.w a1,a2
+ 80205952: 00f5f363 bgeu a1,a5,80205958 <rw_clus+0xfa>
+ 80205956: 86b2 mv a3,a2
+ 80205958: 0006849b sext.w s1,a3
+ if (write) {
+ 8020595c: f80c8ce3 beqz s9,802058f4 <rw_clus+0x96>
+ if ((bad = either_copyin(bp->data + (off % BSIZE), user, data, m)) != -1) {
+ 80205960: 05890513 addi a0,s2,88
+ 80205964: 1682 slli a3,a3,0x20
+ 80205966: 9281 srli a3,a3,0x20
+ 80205968: 865a mv a2,s6
+ 8020596a: f8843583 ld a1,-120(s0)
+ 8020596e: 953a add a0,a0,a4
+ 80205970: ffffd097 auipc ra,0xffffd
+ 80205974: e2c080e7 jalr -468(ra) # 8020279c <either_copyin>
+ 80205978: f7a513e3 bne a0,s10,802058de <rw_clus+0x80>
+ brelse(bp);
+ 8020597c: 854a mv a0,s2
+ 8020597e: ffffe097 auipc ra,0xffffe
+ 80205982: 000080e7 jalr ra # 8020397e <brelse>
+}
+ 80205986: 8552 mv a0,s4
+ 80205988: 70e6 ld ra,120(sp)
+ 8020598a: 7446 ld s0,112(sp)
+ 8020598c: 74a6 ld s1,104(sp)
+ 8020598e: 7906 ld s2,96(sp)
+ 80205990: 69e6 ld s3,88(sp)
+ 80205992: 6a46 ld s4,80(sp)
+ 80205994: 6aa6 ld s5,72(sp)
+ 80205996: 6b06 ld s6,64(sp)
+ 80205998: 7be2 ld s7,56(sp)
+ 8020599a: 7c42 ld s8,48(sp)
+ 8020599c: 7ca2 ld s9,40(sp)
+ 8020599e: 7d02 ld s10,32(sp)
+ 802059a0: 6de2 ld s11,24(sp)
+ 802059a2: 6109 addi sp,sp,128
+ 802059a4: 8082 ret
+ for (tot = 0; tot < n; tot += m, off += m, data += m, sec++) {
+ 802059a6: 8a62 mv s4,s8
+ 802059a8: bff9 j 80205986 <rw_clus+0x128>
+
+00000000802059aa <eget>:
+// by their whole path. But when parsing a path, we open all the directories through it,
+// which forms a linked list from the final file to the root. Thus, we use the "parent" pointer
+// to recognize whether an entry with the "name" as given is really the file we want in the right path.
+// Should never get root by eget, it's easy to understand.
+static struct dirent *eget(struct dirent *parent, char *name)
+{
+ 802059aa: 7139 addi sp,sp,-64
+ 802059ac: fc06 sd ra,56(sp)
+ 802059ae: f822 sd s0,48(sp)
+ 802059b0: f426 sd s1,40(sp)
+ 802059b2: f04a sd s2,32(sp)
+ 802059b4: ec4e sd s3,24(sp)
+ 802059b6: e852 sd s4,16(sp)
+ 802059b8: e456 sd s5,8(sp)
+ 802059ba: 0080 addi s0,sp,64
+ 802059bc: 8a2a mv s4,a0
+ 802059be: 8aae mv s5,a1
+ struct dirent *ep;
+ acquire(&ecache.lock);
+ 802059c0: 00019517 auipc a0,0x19
+ 802059c4: bf850513 addi a0,a0,-1032 # 8021e5b8 <ecache>
+ 802059c8: ffffb097 auipc ra,0xffffb
+ 802059cc: cfe080e7 jalr -770(ra) # 802006c6 <acquire>
+ if (name) {
+ 802059d0: 060a8b63 beqz s5,80205a46 <eget+0x9c>
+ for (ep = root.next; ep != &root; ep = ep->next) { // LRU algo
+ 802059d4: 00019497 auipc s1,0x19
+ 802059d8: ba44b483 ld s1,-1116(s1) # 8021e578 <root+0x128>
+ 802059dc: 00019797 auipc a5,0x19
+ 802059e0: a7478793 addi a5,a5,-1420 # 8021e450 <root>
+ 802059e4: 06f48163 beq s1,a5,80205a46 <eget+0x9c>
+ if (ep->valid == 1 && ep->parent == parent
+ 802059e8: 4905 li s2,1
+ for (ep = root.next; ep != &root; ep = ep->next) { // LRU algo
+ 802059ea: 89be mv s3,a5
+ 802059ec: a029 j 802059f6 <eget+0x4c>
+ 802059ee: 1284b483 ld s1,296(s1)
+ 802059f2: 05348a63 beq s1,s3,80205a46 <eget+0x9c>
+ if (ep->valid == 1 && ep->parent == parent
+ 802059f6: 11649783 lh a5,278(s1)
+ 802059fa: ff279ae3 bne a5,s2,802059ee <eget+0x44>
+ 802059fe: 1204b783 ld a5,288(s1)
+ 80205a02: ff4796e3 bne a5,s4,802059ee <eget+0x44>
+ && strncmp(ep->filename, name, FAT32_MAX_FILENAME) == 0) {
+ 80205a06: 0ff00613 li a2,255
+ 80205a0a: 85d6 mv a1,s5
+ 80205a0c: 8526 mv a0,s1
+ 80205a0e: ffffb097 auipc ra,0xffffb
+ 80205a12: e2c080e7 jalr -468(ra) # 8020083a <strncmp>
+ 80205a16: fd61 bnez a0,802059ee <eget+0x44>
+ if (ep->ref++ == 0) {
+ 80205a18: 1184a783 lw a5,280(s1)
+ 80205a1c: 0017871b addiw a4,a5,1
+ 80205a20: 10e4ac23 sw a4,280(s1)
+ 80205a24: eb81 bnez a5,80205a34 <eget+0x8a>
+ ep->parent->ref++;
+ 80205a26: 1204b703 ld a4,288(s1)
+ 80205a2a: 11872783 lw a5,280(a4)
+ 80205a2e: 2785 addiw a5,a5,1
+ 80205a30: 10f72c23 sw a5,280(a4)
+ }
+ release(&ecache.lock);
+ 80205a34: 00019517 auipc a0,0x19
+ 80205a38: b8450513 addi a0,a0,-1148 # 8021e5b8 <ecache>
+ 80205a3c: ffffb097 auipc ra,0xffffb
+ 80205a40: cde080e7 jalr -802(ra) # 8020071a <release>
+ // edup(ep->parent);
+ return ep;
+ 80205a44: a085 j 80205aa4 <eget+0xfa>
+ }
+ }
+ }
+ for (ep = root.prev; ep != &root; ep = ep->prev) { // LRU algo
+ 80205a46: 00019497 auipc s1,0x19
+ 80205a4a: b3a4b483 ld s1,-1222(s1) # 8021e580 <root+0x130>
+ 80205a4e: 00019797 auipc a5,0x19
+ 80205a52: a0278793 addi a5,a5,-1534 # 8021e450 <root>
+ 80205a56: 00f48a63 beq s1,a5,80205a6a <eget+0xc0>
+ 80205a5a: 873e mv a4,a5
+ if (ep->ref == 0) {
+ 80205a5c: 1184a783 lw a5,280(s1)
+ 80205a60: cf89 beqz a5,80205a7a <eget+0xd0>
+ for (ep = root.prev; ep != &root; ep = ep->prev) { // LRU algo
+ 80205a62: 1304b483 ld s1,304(s1)
+ 80205a66: fee49be3 bne s1,a4,80205a5c <eget+0xb2>
+ ep->dirty = 0;
+ release(&ecache.lock);
+ return ep;
+ }
+ }
+ panic("eget: insufficient ecache");
+ 80205a6a: 00004517 auipc a0,0x4
+ 80205a6e: 31e50513 addi a0,a0,798 # 80209d88 <digits+0xa08>
+ 80205a72: ffffa097 auipc ra,0xffffa
+ 80205a76: 6d2080e7 jalr 1746(ra) # 80200144 <panic>
+ ep->ref = 1;
+ 80205a7a: 4785 li a5,1
+ 80205a7c: 10f4ac23 sw a5,280(s1)
+ ep->dev = parent->dev;
+ 80205a80: 114a4783 lbu a5,276(s4)
+ 80205a84: 10f48a23 sb a5,276(s1)
+ ep->off = 0;
+ 80205a88: 1004ae23 sw zero,284(s1)
+ ep->valid = 0;
+ 80205a8c: 10049b23 sh zero,278(s1)
+ ep->dirty = 0;
+ 80205a90: 10048aa3 sb zero,277(s1)
+ release(&ecache.lock);
+ 80205a94: 00019517 auipc a0,0x19
+ 80205a98: b2450513 addi a0,a0,-1244 # 8021e5b8 <ecache>
+ 80205a9c: ffffb097 auipc ra,0xffffb
+ 80205aa0: c7e080e7 jalr -898(ra) # 8020071a <release>
+ return 0;
+}
+ 80205aa4: 8526 mv a0,s1
+ 80205aa6: 70e2 ld ra,56(sp)
+ 80205aa8: 7442 ld s0,48(sp)
+ 80205aaa: 74a2 ld s1,40(sp)
+ 80205aac: 7902 ld s2,32(sp)
+ 80205aae: 69e2 ld s3,24(sp)
+ 80205ab0: 6a42 ld s4,16(sp)
+ 80205ab2: 6aa2 ld s5,8(sp)
+ 80205ab4: 6121 addi sp,sp,64
+ 80205ab6: 8082 ret
+
+0000000080205ab8 <read_entry_name>:
+ * @param buffer pointer to the array that stores the name
+ * @param raw_entry pointer to the entry in a sector buffer
+ * @param islong if non-zero, read as l-n-e, otherwise s-n-e.
+ */
+static void read_entry_name(char *buffer, union dentry *d)
+{
+ 80205ab8: 7139 addi sp,sp,-64
+ 80205aba: fc06 sd ra,56(sp)
+ 80205abc: f822 sd s0,48(sp)
+ 80205abe: f426 sd s1,40(sp)
+ 80205ac0: f04a sd s2,32(sp)
+ 80205ac2: ec4e sd s3,24(sp)
+ 80205ac4: 0080 addi s0,sp,64
+ 80205ac6: 84aa mv s1,a0
+ 80205ac8: 892e mv s2,a1
+ if (d->lne.attr == ATTR_LONG_NAME) { // long entry branch
+ 80205aca: 00b5c703 lbu a4,11(a1)
+ 80205ace: 47bd li a5,15
+ 80205ad0: 08f70563 beq a4,a5,80205b5a <read_entry_name+0xa2>
+ snstr(buffer, d->lne.name2, NELEM(d->lne.name2));
+ buffer += NELEM(d->lne.name2);
+ snstr(buffer, d->lne.name3, NELEM(d->lne.name3));
+ } else {
+ // assert: only "." and ".." will enter this branch
+ memset(buffer, 0, CHAR_SHORT_NAME + 2); // plus '.' and '\0'
+ 80205ad4: 4635 li a2,13
+ 80205ad6: 4581 li a1,0
+ 80205ad8: ffffb097 auipc ra,0xffffb
+ 80205adc: c8a080e7 jalr -886(ra) # 80200762 <memset>
+ int i;
+ for (i = 0; d->sne.name[i] != ' ' && i < 8; i++) {
+ 80205ae0: 00094703 lbu a4,0(s2)
+ 80205ae4: 02000793 li a5,32
+ 80205ae8: 0af70c63 beq a4,a5,80205ba0 <read_entry_name+0xe8>
+ 80205aec: 4785 li a5,1
+ 80205aee: 02000613 li a2,32
+ 80205af2: 45a5 li a1,9
+ buffer[i] = d->sne.name[i];
+ 80205af4: 00f486b3 add a3,s1,a5
+ 80205af8: fee68fa3 sb a4,-1(a3) # 1fff <_entry-0x801fe001>
+ for (i = 0; d->sne.name[i] != ' ' && i < 8; i++) {
+ 80205afc: 0007869b sext.w a3,a5
+ 80205b00: 00f90733 add a4,s2,a5
+ 80205b04: 00074703 lbu a4,0(a4)
+ 80205b08: 00c70563 beq a4,a2,80205b12 <read_entry_name+0x5a>
+ 80205b0c: 0785 addi a5,a5,1
+ 80205b0e: feb793e3 bne a5,a1,80205af4 <read_entry_name+0x3c>
+ }
+ if (d->sne.name[8] != ' ') {
+ 80205b12: 00894703 lbu a4,8(s2)
+ 80205b16: 02000793 li a5,32
+ 80205b1a: 00f70963 beq a4,a5,80205b2c <read_entry_name+0x74>
+ buffer[i++] = '.';
+ 80205b1e: 00d487b3 add a5,s1,a3
+ 80205b22: 02e00713 li a4,46
+ 80205b26: 00e78023 sb a4,0(a5)
+ 80205b2a: 2685 addiw a3,a3,1
+ }
+ for (int j = 8; j < CHAR_SHORT_NAME; j++, i++) {
+ 80205b2c: 00890793 addi a5,s2,8
+ 80205b30: 94b6 add s1,s1,a3
+ 80205b32: 092d addi s2,s2,11
+ if (d->sne.name[j] == ' ') { break; }
+ 80205b34: 02000693 li a3,32
+ 80205b38: 0007c703 lbu a4,0(a5)
+ 80205b3c: 00d70863 beq a4,a3,80205b4c <read_entry_name+0x94>
+ buffer[i] = d->sne.name[j];
+ 80205b40: 00e48023 sb a4,0(s1)
+ for (int j = 8; j < CHAR_SHORT_NAME; j++, i++) {
+ 80205b44: 0785 addi a5,a5,1
+ 80205b46: 0485 addi s1,s1,1
+ 80205b48: ff2798e3 bne a5,s2,80205b38 <read_entry_name+0x80>
+ }
+ }
+}
+ 80205b4c: 70e2 ld ra,56(sp)
+ 80205b4e: 7442 ld s0,48(sp)
+ 80205b50: 74a2 ld s1,40(sp)
+ 80205b52: 7902 ld s2,32(sp)
+ 80205b54: 69e2 ld s3,24(sp)
+ 80205b56: 6121 addi sp,sp,64
+ 80205b58: 8082 ret
+ memmove(temp, d->lne.name1, sizeof(temp));
+ 80205b5a: 4629 li a2,10
+ 80205b5c: 0585 addi a1,a1,1
+ 80205b5e: fc040993 addi s3,s0,-64
+ 80205b62: 854e mv a0,s3
+ 80205b64: ffffb097 auipc ra,0xffffb
+ 80205b68: c5a080e7 jalr -934(ra) # 802007be <memmove>
+ snstr(buffer, temp, NELEM(d->lne.name1));
+ 80205b6c: 4615 li a2,5
+ 80205b6e: 85ce mv a1,s3
+ 80205b70: 8526 mv a0,s1
+ 80205b72: ffffb097 auipc ra,0xffffb
+ 80205b76: dd0080e7 jalr -560(ra) # 80200942 <snstr>
+ snstr(buffer, d->lne.name2, NELEM(d->lne.name2));
+ 80205b7a: 4619 li a2,6
+ 80205b7c: 00e90593 addi a1,s2,14
+ 80205b80: 00548513 addi a0,s1,5
+ 80205b84: ffffb097 auipc ra,0xffffb
+ 80205b88: dbe080e7 jalr -578(ra) # 80200942 <snstr>
+ snstr(buffer, d->lne.name3, NELEM(d->lne.name3));
+ 80205b8c: 4609 li a2,2
+ 80205b8e: 01c90593 addi a1,s2,28
+ 80205b92: 00b48513 addi a0,s1,11
+ 80205b96: ffffb097 auipc ra,0xffffb
+ 80205b9a: dac080e7 jalr -596(ra) # 80200942 <snstr>
+ 80205b9e: b77d j 80205b4c <read_entry_name+0x94>
+ for (i = 0; d->sne.name[i] != ' ' && i < 8; i++) {
+ 80205ba0: 4681 li a3,0
+ 80205ba2: bf85 j 80205b12 <read_entry_name+0x5a>
+
+0000000080205ba4 <fat32_init>:
+{
+ 80205ba4: 7139 addi sp,sp,-64
+ 80205ba6: fc06 sd ra,56(sp)
+ 80205ba8: f822 sd s0,48(sp)
+ 80205baa: f426 sd s1,40(sp)
+ 80205bac: f04a sd s2,32(sp)
+ 80205bae: ec4e sd s3,24(sp)
+ 80205bb0: e852 sd s4,16(sp)
+ 80205bb2: e456 sd s5,8(sp)
+ 80205bb4: 0080 addi s0,sp,64
+ struct buf *b = bread(0, 0);
+ 80205bb6: 4581 li a1,0
+ 80205bb8: 4501 li a0,0
+ 80205bba: ffffe097 auipc ra,0xffffe
+ 80205bbe: c98080e7 jalr -872(ra) # 80203852 <bread>
+ 80205bc2: 892a mv s2,a0
+ if (strncmp((char const*)(b->data + 82), "FAT32", 5))
+ 80205bc4: 4615 li a2,5
+ 80205bc6: 00004597 auipc a1,0x4
+ 80205bca: 1e258593 addi a1,a1,482 # 80209da8 <digits+0xa28>
+ 80205bce: 0aa50513 addi a0,a0,170
+ 80205bd2: ffffb097 auipc ra,0xffffb
+ 80205bd6: c68080e7 jalr -920(ra) # 8020083a <strncmp>
+ 80205bda: 16051863 bnez a0,80205d4a <fat32_init+0x1a6>
+ memmove(&fat.bpb.byts_per_sec, b->data + 11, 2); // avoid misaligned load on k210
+ 80205bde: 00019497 auipc s1,0x19
+ 80205be2: 84a48493 addi s1,s1,-1974 # 8021e428 <fat>
+ 80205be6: 4609 li a2,2
+ 80205be8: 06390593 addi a1,s2,99
+ 80205bec: 00019517 auipc a0,0x19
+ 80205bf0: 84c50513 addi a0,a0,-1972 # 8021e438 <fat+0x10>
+ 80205bf4: ffffb097 auipc ra,0xffffb
+ 80205bf8: bca080e7 jalr -1078(ra) # 802007be <memmove>
+ fat.bpb.sec_per_clus = *(b->data + 13);
+ 80205bfc: 06594683 lbu a3,101(s2)
+ 80205c00: 00d48923 sb a3,18(s1)
+ fat.bpb.rsvd_sec_cnt = *(uint16 *)(b->data + 14);
+ 80205c04: 06695603 lhu a2,102(s2)
+ 80205c08: 00c49a23 sh a2,20(s1)
+ fat.bpb.fat_cnt = *(b->data + 16);
+ 80205c0c: 06894703 lbu a4,104(s2)
+ 80205c10: 00e48b23 sb a4,22(s1)
+ fat.bpb.hidd_sec = *(uint32 *)(b->data + 28);
+ 80205c14: 07492783 lw a5,116(s2)
+ 80205c18: cc9c sw a5,24(s1)
+ fat.bpb.tot_sec = *(uint32 *)(b->data + 32);
+ 80205c1a: 07892783 lw a5,120(s2)
+ 80205c1e: ccdc sw a5,28(s1)
+ fat.bpb.fat_sz = *(uint32 *)(b->data + 36);
+ 80205c20: 07c92583 lw a1,124(s2)
+ 80205c24: d08c sw a1,32(s1)
+ fat.bpb.root_clus = *(uint32 *)(b->data + 44);
+ 80205c26: 08492503 lw a0,132(s2)
+ 80205c2a: d0c8 sw a0,36(s1)
+ fat.first_data_sec = fat.bpb.rsvd_sec_cnt + fat.bpb.fat_cnt * fat.bpb.fat_sz;
+ 80205c2c: 02b7073b mulw a4,a4,a1
+ 80205c30: 9f31 addw a4,a4,a2
+ 80205c32: c098 sw a4,0(s1)
+ fat.data_sec_cnt = fat.bpb.tot_sec - fat.first_data_sec;
+ 80205c34: 9f99 subw a5,a5,a4
+ 80205c36: c0dc sw a5,4(s1)
+ fat.data_clus_cnt = fat.data_sec_cnt / fat.bpb.sec_per_clus;
+ 80205c38: 02d7d7bb divuw a5,a5,a3
+ 80205c3c: c49c sw a5,8(s1)
+ fat.byts_per_clus = fat.bpb.sec_per_clus * fat.bpb.byts_per_sec;
+ 80205c3e: 0104d783 lhu a5,16(s1)
+ 80205c42: 02d787bb mulw a5,a5,a3
+ 80205c46: c4dc sw a5,12(s1)
+ brelse(b);
+ 80205c48: 854a mv a0,s2
+ 80205c4a: ffffe097 auipc ra,0xffffe
+ 80205c4e: d34080e7 jalr -716(ra) # 8020397e <brelse>
+ if (BSIZE != fat.bpb.byts_per_sec)
+ 80205c52: 0104d703 lhu a4,16(s1)
+ 80205c56: 20000793 li a5,512
+ 80205c5a: 10f71063 bne a4,a5,80205d5a <fat32_init+0x1b6>
+ initlock(&ecache.lock, "ecache");
+ 80205c5e: 00004597 auipc a1,0x4
+ 80205c62: 18258593 addi a1,a1,386 # 80209de0 <digits+0xa60>
+ 80205c66: 00019517 auipc a0,0x19
+ 80205c6a: 95250513 addi a0,a0,-1710 # 8021e5b8 <ecache>
+ 80205c6e: ffffb097 auipc ra,0xffffb
+ 80205c72: a14080e7 jalr -1516(ra) # 80200682 <initlock>
+ memset(&root, 0, sizeof(root));
+ 80205c76: 00018497 auipc s1,0x18
+ 80205c7a: 7b248493 addi s1,s1,1970 # 8021e428 <fat>
+ 80205c7e: 00018917 auipc s2,0x18
+ 80205c82: 7d290913 addi s2,s2,2002 # 8021e450 <root>
+ 80205c86: 16800613 li a2,360
+ 80205c8a: 4581 li a1,0
+ 80205c8c: 854a mv a0,s2
+ 80205c8e: ffffb097 auipc ra,0xffffb
+ 80205c92: ad4080e7 jalr -1324(ra) # 80200762 <memset>
+ initsleeplock(&root.lock, "entry");
+ 80205c96: 00004597 auipc a1,0x4
+ 80205c9a: 15258593 addi a1,a1,338 # 80209de8 <digits+0xa68>
+ 80205c9e: 00019517 auipc a0,0x19
+ 80205ca2: 8ea50513 addi a0,a0,-1814 # 8021e588 <root+0x138>
+ 80205ca6: ffffe097 auipc ra,0xffffe
+ 80205caa: dee080e7 jalr -530(ra) # 80203a94 <initsleeplock>
+ root.attribute = (ATTR_DIRECTORY | ATTR_SYSTEM);
+ 80205cae: 47d1 li a5,20
+ 80205cb0: 12f48423 sb a5,296(s1)
+ root.first_clus = root.cur_clus = fat.bpb.root_clus;
+ 80205cb4: 50dc lw a5,36(s1)
+ 80205cb6: 12f4aa23 sw a5,308(s1)
+ 80205cba: 12f4a623 sw a5,300(s1)
+ root.valid = 1;
+ 80205cbe: 4785 li a5,1
+ 80205cc0: 12f49f23 sh a5,318(s1)
+ root.prev = &root;
+ 80205cc4: 1524bc23 sd s2,344(s1)
+ root.next = &root;
+ 80205cc8: 1524b823 sd s2,336(s1)
+ for(struct dirent *de = ecache.entries; de < ecache.entries + ENTRY_CACHE_NUM; de++) {
+ 80205ccc: 00019497 auipc s1,0x19
+ 80205cd0: 90448493 addi s1,s1,-1788 # 8021e5d0 <ecache+0x18>
+ de->next = root.next;
+ 80205cd4: 00018917 auipc s2,0x18
+ 80205cd8: 75490913 addi s2,s2,1876 # 8021e428 <fat>
+ de->prev = &root;
+ 80205cdc: 00018a97 auipc s5,0x18
+ 80205ce0: 774a8a93 addi s5,s5,1908 # 8021e450 <root>
+ initsleeplock(&de->lock, "entry");
+ 80205ce4: 00004a17 auipc s4,0x4
+ 80205ce8: 104a0a13 addi s4,s4,260 # 80209de8 <digits+0xa68>
+ for(struct dirent *de = ecache.entries; de < ecache.entries + ENTRY_CACHE_NUM; de++) {
+ 80205cec: 0001d997 auipc s3,0x1d
+ 80205cf0: f3498993 addi s3,s3,-204 # 80222c20 <cons>
+ de->dev = 0;
+ 80205cf4: 10048a23 sb zero,276(s1)
+ de->valid = 0;
+ 80205cf8: 10049b23 sh zero,278(s1)
+ de->ref = 0;
+ 80205cfc: 1004ac23 sw zero,280(s1)
+ de->dirty = 0;
+ 80205d00: 10048aa3 sb zero,277(s1)
+ de->parent = 0;
+ 80205d04: 1204b023 sd zero,288(s1)
+ de->next = root.next;
+ 80205d08: 15093783 ld a5,336(s2)
+ 80205d0c: 12f4b423 sd a5,296(s1)
+ de->prev = &root;
+ 80205d10: 1354b823 sd s5,304(s1)
+ initsleeplock(&de->lock, "entry");
+ 80205d14: 85d2 mv a1,s4
+ 80205d16: 13848513 addi a0,s1,312
+ 80205d1a: ffffe097 auipc ra,0xffffe
+ 80205d1e: d7a080e7 jalr -646(ra) # 80203a94 <initsleeplock>
+ root.next->prev = de;
+ 80205d22: 15093783 ld a5,336(s2)
+ 80205d26: 1297b823 sd s1,304(a5)
+ root.next = de;
+ 80205d2a: 14993823 sd s1,336(s2)
+ for(struct dirent *de = ecache.entries; de < ecache.entries + ENTRY_CACHE_NUM; de++) {
+ 80205d2e: 16848493 addi s1,s1,360
+ 80205d32: fd3491e3 bne s1,s3,80205cf4 <fat32_init+0x150>
+}
+ 80205d36: 4501 li a0,0
+ 80205d38: 70e2 ld ra,56(sp)
+ 80205d3a: 7442 ld s0,48(sp)
+ 80205d3c: 74a2 ld s1,40(sp)
+ 80205d3e: 7902 ld s2,32(sp)
+ 80205d40: 69e2 ld s3,24(sp)
+ 80205d42: 6a42 ld s4,16(sp)
+ 80205d44: 6aa2 ld s5,8(sp)
+ 80205d46: 6121 addi sp,sp,64
+ 80205d48: 8082 ret
+ panic("not FAT32 volume");
+ 80205d4a: 00004517 auipc a0,0x4
+ 80205d4e: 06650513 addi a0,a0,102 # 80209db0 <digits+0xa30>
+ 80205d52: ffffa097 auipc ra,0xffffa
+ 80205d56: 3f2080e7 jalr 1010(ra) # 80200144 <panic>
+ panic("byts_per_sec != BSIZE");
+ 80205d5a: 00004517 auipc a0,0x4
+ 80205d5e: 06e50513 addi a0,a0,110 # 80209dc8 <digits+0xa48>
+ 80205d62: ffffa097 auipc ra,0xffffa
+ 80205d66: 3e2080e7 jalr 994(ra) # 80200144 <panic>
+
+0000000080205d6a <eread>:
+ if (off > entry->file_size || off + n < off || (entry->attribute & ATTR_DIRECTORY)) {
+ 80205d6a: 10852783 lw a5,264(a0)
+ 80205d6e: 0ed7e863 bltu a5,a3,80205e5e <eread+0xf4>
+{
+ 80205d72: 711d addi sp,sp,-96
+ 80205d74: ec86 sd ra,88(sp)
+ 80205d76: e8a2 sd s0,80(sp)
+ 80205d78: e4a6 sd s1,72(sp)
+ 80205d7a: e0ca sd s2,64(sp)
+ 80205d7c: fc4e sd s3,56(sp)
+ 80205d7e: f852 sd s4,48(sp)
+ 80205d80: f456 sd s5,40(sp)
+ 80205d82: f05a sd s6,32(sp)
+ 80205d84: ec5e sd s7,24(sp)
+ 80205d86: e862 sd s8,16(sp)
+ 80205d88: e466 sd s9,8(sp)
+ 80205d8a: e06a sd s10,0(sp)
+ 80205d8c: 1080 addi s0,sp,96
+ 80205d8e: 8a2a mv s4,a0
+ 80205d90: 8bae mv s7,a1
+ 80205d92: 8ab2 mv s5,a2
+ 80205d94: 8936 mv s2,a3
+ 80205d96: 8b3a mv s6,a4
+ if (off > entry->file_size || off + n < off || (entry->attribute & ATTR_DIRECTORY)) {
+ 80205d98: 9eb9 addw a3,a3,a4
+ return 0;
+ 80205d9a: 4501 li a0,0
+ if (off > entry->file_size || off + n < off || (entry->attribute & ATTR_DIRECTORY)) {
+ 80205d9c: 0b26e163 bltu a3,s2,80205e3e <eread+0xd4>
+ 80205da0: 100a4703 lbu a4,256(s4)
+ 80205da4: 8b41 andi a4,a4,16
+ 80205da6: ef41 bnez a4,80205e3e <eread+0xd4>
+ if (off + n > entry->file_size) {
+ 80205da8: 00d7f463 bgeu a5,a3,80205db0 <eread+0x46>
+ n = entry->file_size - off;
+ 80205dac: 41278b3b subw s6,a5,s2
+ for (tot = 0; entry->cur_clus < FAT32_EOC && tot < n; tot += m, off += m, dst += m) {
+ 80205db0: 10ca2703 lw a4,268(s4)
+ 80205db4: 100007b7 lui a5,0x10000
+ 80205db8: 17dd addi a5,a5,-9 # ffffff7 <_entry-0x70200009>
+ 80205dba: 06e7ef63 bltu a5,a4,80205e38 <eread+0xce>
+ 80205dbe: 080b0e63 beqz s6,80205e5a <eread+0xf0>
+ 80205dc2: 4981 li s3,0
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205dc4: 00018c97 auipc s9,0x18
+ 80205dc8: 664c8c93 addi s9,s9,1636 # 8021e428 <fat>
+ for (tot = 0; entry->cur_clus < FAT32_EOC && tot < n; tot += m, off += m, dst += m) {
+ 80205dcc: 8c3e mv s8,a5
+ 80205dce: a82d j 80205e08 <eread+0x9e>
+ 80205dd0: 00048d1b sext.w s10,s1
+ if (rw_clus(entry->cur_clus, 0, user_dst, dst, off % fat.byts_per_clus, m) != m) {
+ 80205dd4: 87ea mv a5,s10
+ 80205dd6: 86d6 mv a3,s5
+ 80205dd8: 865e mv a2,s7
+ 80205dda: 4581 li a1,0
+ 80205ddc: 10ca2503 lw a0,268(s4)
+ 80205de0: 00000097 auipc ra,0x0
+ 80205de4: a7e080e7 jalr -1410(ra) # 8020585e <rw_clus>
+ 80205de8: 2501 sext.w a0,a0
+ 80205dea: 04ad1863 bne s10,a0,80205e3a <eread+0xd0>
+ for (tot = 0; entry->cur_clus < FAT32_EOC && tot < n; tot += m, off += m, dst += m) {
+ 80205dee: 013489bb addw s3,s1,s3
+ 80205df2: 0124893b addw s2,s1,s2
+ 80205df6: 1482 slli s1,s1,0x20
+ 80205df8: 9081 srli s1,s1,0x20
+ 80205dfa: 9aa6 add s5,s5,s1
+ 80205dfc: 10ca2783 lw a5,268(s4)
+ 80205e00: 02fc6d63 bltu s8,a5,80205e3a <eread+0xd0>
+ 80205e04: 0369fb63 bgeu s3,s6,80205e3a <eread+0xd0>
+ reloc_clus(entry, off, 0);
+ 80205e08: 4601 li a2,0
+ 80205e0a: 85ca mv a1,s2
+ 80205e0c: 8552 mv a0,s4
+ 80205e0e: 00000097 auipc ra,0x0
+ 80205e12: 948080e7 jalr -1720(ra) # 80205756 <reloc_clus>
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205e16: 00cca683 lw a3,12(s9)
+ 80205e1a: 02d9763b remuw a2,s2,a3
+ 80205e1e: 0006071b sext.w a4,a2
+ if (n - tot < m) {
+ 80205e22: 413b07bb subw a5,s6,s3
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205e26: 9e91 subw a3,a3,a2
+ 80205e28: 84be mv s1,a5
+ 80205e2a: 2781 sext.w a5,a5
+ 80205e2c: 0006861b sext.w a2,a3
+ 80205e30: faf670e3 bgeu a2,a5,80205dd0 <eread+0x66>
+ 80205e34: 84b6 mv s1,a3
+ 80205e36: bf69 j 80205dd0 <eread+0x66>
+ for (tot = 0; entry->cur_clus < FAT32_EOC && tot < n; tot += m, off += m, dst += m) {
+ 80205e38: 4981 li s3,0
+ return tot;
+ 80205e3a: 0009851b sext.w a0,s3
+}
+ 80205e3e: 60e6 ld ra,88(sp)
+ 80205e40: 6446 ld s0,80(sp)
+ 80205e42: 64a6 ld s1,72(sp)
+ 80205e44: 6906 ld s2,64(sp)
+ 80205e46: 79e2 ld s3,56(sp)
+ 80205e48: 7a42 ld s4,48(sp)
+ 80205e4a: 7aa2 ld s5,40(sp)
+ 80205e4c: 7b02 ld s6,32(sp)
+ 80205e4e: 6be2 ld s7,24(sp)
+ 80205e50: 6c42 ld s8,16(sp)
+ 80205e52: 6ca2 ld s9,8(sp)
+ 80205e54: 6d02 ld s10,0(sp)
+ 80205e56: 6125 addi sp,sp,96
+ 80205e58: 8082 ret
+ for (tot = 0; entry->cur_clus < FAT32_EOC && tot < n; tot += m, off += m, dst += m) {
+ 80205e5a: 89da mv s3,s6
+ 80205e5c: bff9 j 80205e3a <eread+0xd0>
+ return 0;
+ 80205e5e: 4501 li a0,0
+}
+ 80205e60: 8082 ret
+
+0000000080205e62 <ewrite>:
+ if (off > entry->file_size || off + n < off || (uint64)off + n > 0xffffffff
+ 80205e62: 10852783 lw a5,264(a0)
+ 80205e66: 0ed7e463 bltu a5,a3,80205f4e <ewrite+0xec>
+{
+ 80205e6a: 711d addi sp,sp,-96
+ 80205e6c: ec86 sd ra,88(sp)
+ 80205e6e: e8a2 sd s0,80(sp)
+ 80205e70: e4a6 sd s1,72(sp)
+ 80205e72: e0ca sd s2,64(sp)
+ 80205e74: fc4e sd s3,56(sp)
+ 80205e76: f852 sd s4,48(sp)
+ 80205e78: f456 sd s5,40(sp)
+ 80205e7a: f05a sd s6,32(sp)
+ 80205e7c: ec5e sd s7,24(sp)
+ 80205e7e: e862 sd s8,16(sp)
+ 80205e80: e466 sd s9,8(sp)
+ 80205e82: 1080 addi s0,sp,96
+ 80205e84: 8aaa mv s5,a0
+ 80205e86: 8bae mv s7,a1
+ 80205e88: 8a32 mv s4,a2
+ 80205e8a: 8936 mv s2,a3
+ 80205e8c: 8b3a mv s6,a4
+ if (off > entry->file_size || off + n < off || (uint64)off + n > 0xffffffff
+ 80205e8e: 00e687bb addw a5,a3,a4
+ 80205e92: 0cd7e063 bltu a5,a3,80205f52 <ewrite+0xf0>
+ 80205e96: 02069793 slli a5,a3,0x20
+ 80205e9a: 9381 srli a5,a5,0x20
+ 80205e9c: 1702 slli a4,a4,0x20
+ 80205e9e: 9301 srli a4,a4,0x20
+ 80205ea0: 97ba add a5,a5,a4
+ 80205ea2: 577d li a4,-1
+ 80205ea4: 9301 srli a4,a4,0x20
+ 80205ea6: 0af76863 bltu a4,a5,80205f56 <ewrite+0xf4>
+ || (entry->attribute & ATTR_READ_ONLY)) {
+ 80205eaa: 10054783 lbu a5,256(a0)
+ 80205eae: 8b85 andi a5,a5,1
+ 80205eb0: e7cd bnez a5,80205f5a <ewrite+0xf8>
+ if (entry->first_clus == 0) { // so file_size if 0 too, which requests off == 0
+ 80205eb2: 10452783 lw a5,260(a0)
+ 80205eb6: cb89 beqz a5,80205ec8 <ewrite+0x66>
+ for (tot = 0; tot < n; tot += m, off += m, src += m) {
+ 80205eb8: 080b0963 beqz s6,80205f4a <ewrite+0xe8>
+ 80205ebc: 4981 li s3,0
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205ebe: 00018c17 auipc s8,0x18
+ 80205ec2: 56ac0c13 addi s8,s8,1386 # 8021e428 <fat>
+ 80205ec6: a891 j 80205f1a <ewrite+0xb8>
+ entry->cur_clus = entry->first_clus = alloc_clus(entry->dev);
+ 80205ec8: 11454503 lbu a0,276(a0)
+ 80205ecc: fffff097 auipc ra,0xfffff
+ 80205ed0: 6c8080e7 jalr 1736(ra) # 80205594 <alloc_clus>
+ 80205ed4: 2501 sext.w a0,a0
+ 80205ed6: 10aaa223 sw a0,260(s5)
+ 80205eda: 10aaa623 sw a0,268(s5)
+ entry->clus_cnt = 0;
+ 80205ede: 100aa823 sw zero,272(s5)
+ entry->dirty = 1;
+ 80205ee2: 4785 li a5,1
+ 80205ee4: 10fa8aa3 sb a5,277(s5)
+ 80205ee8: bfc1 j 80205eb8 <ewrite+0x56>
+ 80205eea: 00048c9b sext.w s9,s1
+ if (rw_clus(entry->cur_clus, 1, user_src, src, off % fat.byts_per_clus, m) != m) {
+ 80205eee: 87e6 mv a5,s9
+ 80205ef0: 86d2 mv a3,s4
+ 80205ef2: 865e mv a2,s7
+ 80205ef4: 4585 li a1,1
+ 80205ef6: 10caa503 lw a0,268(s5)
+ 80205efa: 00000097 auipc ra,0x0
+ 80205efe: 964080e7 jalr -1692(ra) # 8020585e <rw_clus>
+ 80205f02: 2501 sext.w a0,a0
+ 80205f04: 04ac9d63 bne s9,a0,80205f5e <ewrite+0xfc>
+ for (tot = 0; tot < n; tot += m, off += m, src += m) {
+ 80205f08: 013489bb addw s3,s1,s3
+ 80205f0c: 0124893b addw s2,s1,s2
+ 80205f10: 1482 slli s1,s1,0x20
+ 80205f12: 9081 srli s1,s1,0x20
+ 80205f14: 9a26 add s4,s4,s1
+ 80205f16: 0569f463 bgeu s3,s6,80205f5e <ewrite+0xfc>
+ reloc_clus(entry, off, 1);
+ 80205f1a: 4605 li a2,1
+ 80205f1c: 85ca mv a1,s2
+ 80205f1e: 8556 mv a0,s5
+ 80205f20: 00000097 auipc ra,0x0
+ 80205f24: 836080e7 jalr -1994(ra) # 80205756 <reloc_clus>
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205f28: 00cc2683 lw a3,12(s8)
+ 80205f2c: 02d9763b remuw a2,s2,a3
+ 80205f30: 0006071b sext.w a4,a2
+ if (n - tot < m) {
+ 80205f34: 413b07bb subw a5,s6,s3
+ m = fat.byts_per_clus - off % fat.byts_per_clus;
+ 80205f38: 9e91 subw a3,a3,a2
+ 80205f3a: 84be mv s1,a5
+ 80205f3c: 2781 sext.w a5,a5
+ 80205f3e: 0006861b sext.w a2,a3
+ 80205f42: faf674e3 bgeu a2,a5,80205eea <ewrite+0x88>
+ 80205f46: 84b6 mv s1,a3
+ 80205f48: b74d j 80205eea <ewrite+0x88>
+ for (tot = 0; tot < n; tot += m, off += m, src += m) {
+ 80205f4a: 89da mv s3,s6
+ 80205f4c: a015 j 80205f70 <ewrite+0x10e>
+ return -1;
+ 80205f4e: 557d li a0,-1
+}
+ 80205f50: 8082 ret
+ return -1;
+ 80205f52: 557d li a0,-1
+ 80205f54: a005 j 80205f74 <ewrite+0x112>
+ 80205f56: 557d li a0,-1
+ 80205f58: a831 j 80205f74 <ewrite+0x112>
+ 80205f5a: 557d li a0,-1
+ 80205f5c: a821 j 80205f74 <ewrite+0x112>
+ if(off > entry->file_size) {
+ 80205f5e: 108aa783 lw a5,264(s5)
+ 80205f62: 0127f763 bgeu a5,s2,80205f70 <ewrite+0x10e>
+ entry->file_size = off;
+ 80205f66: 112aa423 sw s2,264(s5)
+ entry->dirty = 1;
+ 80205f6a: 4785 li a5,1
+ 80205f6c: 10fa8aa3 sb a5,277(s5)
+ return tot;
+ 80205f70: 0009851b sext.w a0,s3
+}
+ 80205f74: 60e6 ld ra,88(sp)
+ 80205f76: 6446 ld s0,80(sp)
+ 80205f78: 64a6 ld s1,72(sp)
+ 80205f7a: 6906 ld s2,64(sp)
+ 80205f7c: 79e2 ld s3,56(sp)
+ 80205f7e: 7a42 ld s4,48(sp)
+ 80205f80: 7aa2 ld s5,40(sp)
+ 80205f82: 7b02 ld s6,32(sp)
+ 80205f84: 6be2 ld s7,24(sp)
+ 80205f86: 6c42 ld s8,16(sp)
+ 80205f88: 6ca2 ld s9,8(sp)
+ 80205f8a: 6125 addi sp,sp,96
+ 80205f8c: 8082 ret
+
+0000000080205f8e <formatname>:
+{
+ 80205f8e: 7179 addi sp,sp,-48
+ 80205f90: f406 sd ra,40(sp)
+ 80205f92: f022 sd s0,32(sp)
+ 80205f94: ec26 sd s1,24(sp)
+ 80205f96: e84a sd s2,16(sp)
+ 80205f98: e44e sd s3,8(sp)
+ 80205f9a: e052 sd s4,0(sp)
+ 80205f9c: 1800 addi s0,sp,48
+ 80205f9e: 84aa mv s1,a0
+ while (*name == ' ' || *name == '.') { name++; }
+ 80205fa0: 02000793 li a5,32
+ 80205fa4: 02e00713 li a4,46
+ 80205fa8: a011 j 80205fac <formatname+0x1e>
+ 80205faa: 0485 addi s1,s1,1
+ 80205fac: 0004c583 lbu a1,0(s1)
+ 80205fb0: fef58de3 beq a1,a5,80205faa <formatname+0x1c>
+ 80205fb4: fee58be3 beq a1,a4,80205faa <formatname+0x1c>
+ for (p = name; *p; p++) {
+ 80205fb8: c1b9 beqz a1,80205ffe <formatname+0x70>
+ 80205fba: 8926 mv s2,s1
+ if (c < 0x20 || strchr(illegal, c)) {
+ 80205fbc: 49fd li s3,31
+ 80205fbe: 00006a17 auipc s4,0x6
+ 80205fc2: d02a0a13 addi s4,s4,-766 # 8020bcc0 <illegal.1>
+ 80205fc6: 02b9fe63 bgeu s3,a1,80206002 <formatname+0x74>
+ 80205fca: 8552 mv a0,s4
+ 80205fcc: ffffb097 auipc ra,0xffffb
+ 80205fd0: 9f4080e7 jalr -1548(ra) # 802009c0 <strchr>
+ 80205fd4: e121 bnez a0,80206014 <formatname+0x86>
+ for (p = name; *p; p++) {
+ 80205fd6: 0905 addi s2,s2,1
+ 80205fd8: 00094583 lbu a1,0(s2)
+ 80205fdc: f5ed bnez a1,80205fc6 <formatname+0x38>
+ if (*p != ' ') {
+ 80205fde: 02000693 li a3,32
+ 80205fe2: 874a mv a4,s2
+ while (p-- > name) {
+ 80205fe4: 0124fb63 bgeu s1,s2,80205ffa <formatname+0x6c>
+ if (*p != ' ') {
+ 80205fe8: 197d addi s2,s2,-1
+ 80205fea: 00094783 lbu a5,0(s2)
+ 80205fee: fed78ae3 beq a5,a3,80205fe2 <formatname+0x54>
+ p[1] = '\0';
+ 80205ff2: 00070023 sb zero,0(a4)
+ break;
+ 80205ff6: 8526 mv a0,s1
+ 80205ff8: a031 j 80206004 <formatname+0x76>
+ 80205ffa: 8526 mv a0,s1
+ 80205ffc: a021 j 80206004 <formatname+0x76>
+ for (p = name; *p; p++) {
+ 80205ffe: 8526 mv a0,s1
+ 80206000: a011 j 80206004 <formatname+0x76>
+ return 0;
+ 80206002: 4501 li a0,0
+}
+ 80206004: 70a2 ld ra,40(sp)
+ 80206006: 7402 ld s0,32(sp)
+ 80206008: 64e2 ld s1,24(sp)
+ 8020600a: 6942 ld s2,16(sp)
+ 8020600c: 69a2 ld s3,8(sp)
+ 8020600e: 6a02 ld s4,0(sp)
+ 80206010: 6145 addi sp,sp,48
+ 80206012: 8082 ret
+ return 0;
+ 80206014: 4501 li a0,0
+ 80206016: b7fd j 80206004 <formatname+0x76>
+
+0000000080206018 <cal_checksum>:
+{
+ 80206018: 1141 addi sp,sp,-16
+ 8020601a: e422 sd s0,8(sp)
+ 8020601c: 0800 addi s0,sp,16
+ 8020601e: 87aa mv a5,a0
+ for (int i = CHAR_SHORT_NAME; i != 0; i--) {
+ 80206020: 00b50613 addi a2,a0,11
+ uint8 sum = 0;
+ 80206024: 4501 li a0,0
+ sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + *shortname++;
+ 80206026: 0075171b slliw a4,a0,0x7
+ 8020602a: 0785 addi a5,a5,1
+ 8020602c: 0015551b srliw a0,a0,0x1
+ 80206030: fff7c683 lbu a3,-1(a5)
+ 80206034: 9d35 addw a0,a0,a3
+ 80206036: 953a add a0,a0,a4
+ 80206038: 0ff57513 zext.b a0,a0
+ for (int i = CHAR_SHORT_NAME; i != 0; i--) {
+ 8020603c: fef615e3 bne a2,a5,80206026 <cal_checksum+0xe>
+}
+ 80206040: 6422 ld s0,8(sp)
+ 80206042: 0141 addi sp,sp,16
+ 80206044: 8082 ret
+
+0000000080206046 <emake>:
+{
+ 80206046: 7131 addi sp,sp,-192
+ 80206048: fd06 sd ra,184(sp)
+ 8020604a: f922 sd s0,176(sp)
+ 8020604c: f526 sd s1,168(sp)
+ 8020604e: f14a sd s2,160(sp)
+ 80206050: ed4e sd s3,152(sp)
+ 80206052: e952 sd s4,144(sp)
+ 80206054: e556 sd s5,136(sp)
+ 80206056: e15a sd s6,128(sp)
+ 80206058: fcde sd s7,120(sp)
+ 8020605a: f8e2 sd s8,112(sp)
+ 8020605c: f4e6 sd s9,104(sp)
+ 8020605e: f0ea sd s10,96(sp)
+ 80206060: ecee sd s11,88(sp)
+ 80206062: 0180 addi s0,sp,192
+ if (!(dp->attribute & ATTR_DIRECTORY))
+ 80206064: 10054783 lbu a5,256(a0)
+ 80206068: 8bc1 andi a5,a5,16
+ 8020606a: c3d5 beqz a5,8020610e <emake+0xc8>
+ 8020606c: 8b2a mv s6,a0
+ 8020606e: 8d2e mv s10,a1
+ 80206070: 8cb2 mv s9,a2
+ if (off % sizeof(union dentry))
+ 80206072: 01f67793 andi a5,a2,31
+ 80206076: e7c5 bnez a5,8020611e <emake+0xd8>
+ memset(&de, 0, sizeof(de));
+ 80206078: 02000613 li a2,32
+ 8020607c: 4581 li a1,0
+ 8020607e: f7040513 addi a0,s0,-144
+ 80206082: ffffa097 auipc ra,0xffffa
+ 80206086: 6e0080e7 jalr 1760(ra) # 80200762 <memset>
+ if (off <= 32) {
+ 8020608a: 02000793 li a5,32
+ 8020608e: 0b97ec63 bltu a5,s9,80206146 <emake+0x100>
+ if (off == 0) {
+ 80206092: 080c9e63 bnez s9,8020612e <emake+0xe8>
+ strncpy(de.sne.name, ". ", sizeof(de.sne.name));
+ 80206096: 462d li a2,11
+ 80206098: 00004597 auipc a1,0x4
+ 8020609c: d8058593 addi a1,a1,-640 # 80209e18 <digits+0xa98>
+ 802060a0: f7040513 addi a0,s0,-144
+ 802060a4: ffffa097 auipc ra,0xffffa
+ 802060a8: 7d2080e7 jalr 2002(ra) # 80200876 <strncpy>
+ de.sne.attr = ATTR_DIRECTORY;
+ 802060ac: 47c1 li a5,16
+ 802060ae: f6f40da3 sb a5,-133(s0)
+ de.sne.fst_clus_hi = (uint16)(ep->first_clus >> 16); // first clus high 16 bits
+ 802060b2: 104d2783 lw a5,260(s10) # fffffffffffff104 <ebss_clear+0xffffffff7fdd9104>
+ 802060b6: 0107d71b srliw a4,a5,0x10
+ 802060ba: f8e41223 sh a4,-124(s0)
+ de.sne.fst_clus_lo = (uint16)(ep->first_clus & 0xffff); // low 16 bits
+ 802060be: f8f41523 sh a5,-118(s0)
+ de.sne.file_size = 0; // filesize is updated in eupdate()
+ 802060c2: f8042623 sw zero,-116(s0)
+ off = reloc_clus(dp, off, 1);
+ 802060c6: 4605 li a2,1
+ 802060c8: 85e6 mv a1,s9
+ 802060ca: 855a mv a0,s6
+ 802060cc: fffff097 auipc ra,0xfffff
+ 802060d0: 68a080e7 jalr 1674(ra) # 80205756 <reloc_clus>
+ rw_clus(dp->cur_clus, 1, 0, (uint64)&de, off, sizeof(de));
+ 802060d4: 02000793 li a5,32
+ 802060d8: 0005071b sext.w a4,a0
+ 802060dc: f7040693 addi a3,s0,-144
+ 802060e0: 4601 li a2,0
+ 802060e2: 4585 li a1,1
+ 802060e4: 10cb2503 lw a0,268(s6)
+ 802060e8: fffff097 auipc ra,0xfffff
+ 802060ec: 776080e7 jalr 1910(ra) # 8020585e <rw_clus>
+}
+ 802060f0: 70ea ld ra,184(sp)
+ 802060f2: 744a ld s0,176(sp)
+ 802060f4: 74aa ld s1,168(sp)
+ 802060f6: 790a ld s2,160(sp)
+ 802060f8: 69ea ld s3,152(sp)
+ 802060fa: 6a4a ld s4,144(sp)
+ 802060fc: 6aaa ld s5,136(sp)
+ 802060fe: 6b0a ld s6,128(sp)
+ 80206100: 7be6 ld s7,120(sp)
+ 80206102: 7c46 ld s8,112(sp)
+ 80206104: 7ca6 ld s9,104(sp)
+ 80206106: 7d06 ld s10,96(sp)
+ 80206108: 6de6 ld s11,88(sp)
+ 8020610a: 6129 addi sp,sp,192
+ 8020610c: 8082 ret
+ panic("emake: not dir");
+ 8020610e: 00004517 auipc a0,0x4
+ 80206112: ce250513 addi a0,a0,-798 # 80209df0 <digits+0xa70>
+ 80206116: ffffa097 auipc ra,0xffffa
+ 8020611a: 02e080e7 jalr 46(ra) # 80200144 <panic>
+ panic("emake: not aligned");
+ 8020611e: 00004517 auipc a0,0x4
+ 80206122: ce250513 addi a0,a0,-798 # 80209e00 <digits+0xa80>
+ 80206126: ffffa097 auipc ra,0xffffa
+ 8020612a: 01e080e7 jalr 30(ra) # 80200144 <panic>
+ strncpy(de.sne.name, ".. ", sizeof(de.sne.name));
+ 8020612e: 462d li a2,11
+ 80206130: 00004597 auipc a1,0x4
+ 80206134: cf858593 addi a1,a1,-776 # 80209e28 <digits+0xaa8>
+ 80206138: f7040513 addi a0,s0,-144
+ 8020613c: ffffa097 auipc ra,0xffffa
+ 80206140: 73a080e7 jalr 1850(ra) # 80200876 <strncpy>
+ 80206144: b7a5 j 802060ac <emake+0x66>
+ int entcnt = (strlen(ep->filename) + CHAR_LONG_NAME - 1) / CHAR_LONG_NAME; // count of l-n-entries, rounds up
+ 80206146: 896a mv s2,s10
+ 80206148: 856a mv a0,s10
+ 8020614a: ffffa097 auipc ra,0xffffa
+ 8020614e: 79c080e7 jalr 1948(ra) # 802008e6 <strlen>
+ 80206152: f4a43423 sd a0,-184(s0)
+ 80206156: 00c5071b addiw a4,a0,12
+ 8020615a: 47b5 li a5,13
+ 8020615c: 02f747bb divw a5,a4,a5
+ 80206160: f4f42c23 sw a5,-168(s0)
+ 80206164: 00078d9b sext.w s11,a5
+ memset(shortname, 0, sizeof(shortname));
+ 80206168: 4631 li a2,12
+ 8020616a: 4581 li a1,0
+ 8020616c: f6040513 addi a0,s0,-160
+ 80206170: ffffa097 auipc ra,0xffffa
+ 80206174: 5f2080e7 jalr 1522(ra) # 80200762 <memset>
+ for (int j = strlen(name) - 1; j >= 0; j--) {
+ 80206178: 856a mv a0,s10
+ 8020617a: ffffa097 auipc ra,0xffffa
+ 8020617e: 76c080e7 jalr 1900(ra) # 802008e6 <strlen>
+ 80206182: fff5079b addiw a5,a0,-1
+ 80206186: 0207cf63 bltz a5,802061c4 <emake+0x17e>
+ 8020618a: 97ea add a5,a5,s10
+ 8020618c: ffed0693 addi a3,s10,-2
+ 80206190: 96aa add a3,a3,a0
+ 80206192: fff5071b addiw a4,a0,-1
+ 80206196: 1702 slli a4,a4,0x20
+ 80206198: 9301 srli a4,a4,0x20
+ 8020619a: 8e99 sub a3,a3,a4
+ if (name[j] == '.') {
+ 8020619c: 02e00613 li a2,46
+ 802061a0: 89be mv s3,a5
+ 802061a2: 0007c703 lbu a4,0(a5)
+ 802061a6: 00c70663 beq a4,a2,802061b2 <emake+0x16c>
+ for (int j = strlen(name) - 1; j >= 0; j--) {
+ 802061aa: 17fd addi a5,a5,-1
+ 802061ac: fed79ae3 bne a5,a3,802061a0 <emake+0x15a>
+ char c, *p = name;
+ 802061b0: 89ea mv s3,s10
+ shortname[i++] = c;
+ 802061b2: 4481 li s1,0
+ if (i == 8 && p) {
+ 802061b4: 4aa1 li s5,8
+ while (i < CHAR_SHORT_NAME && (c = *name++)) {
+ 802061b6: 4ba9 li s7,10
+ if (c >= 'a' && c <= 'z') {
+ 802061b8: 4c65 li s8,25
+ memset(shortname + i, ' ', 8 - i);
+ 802061ba: f6040793 addi a5,s0,-160
+ 802061be: f4f43823 sd a5,-176(s0)
+ 802061c2: a8d9 j 80206298 <emake+0x252>
+ char c, *p = name;
+ 802061c4: 89ea mv s3,s10
+ 802061c6: b7f5 j 802061b2 <emake+0x16c>
+ if (i == 8 && p) {
+ 802061c8: 22098b63 beqz s3,802063fe <emake+0x3b8>
+ if (p + 1 < name) { break; } // no '.'
+ 802061cc: 0985 addi s3,s3,1
+ 802061ce: 0949fc63 bgeu s3,s4,80206266 <emake+0x220>
+ 802061d2: f6040793 addi a5,s0,-160
+ 802061d6: 97a6 add a5,a5,s1
+ shortname[i++] = ' ';
+ 802061d8: 02000693 li a3,32
+ while (i < CHAR_SHORT_NAME) {
+ 802061dc: 4729 li a4,10
+ shortname[i++] = ' ';
+ 802061de: 2485 addiw s1,s1,1
+ 802061e0: 00d78023 sb a3,0(a5)
+ while (i < CHAR_SHORT_NAME) {
+ 802061e4: 0785 addi a5,a5,1
+ 802061e6: fe975ce3 bge a4,s1,802061de <emake+0x198>
+ de.lne.checksum = cal_checksum((uchar *)shortname);
+ 802061ea: f6040513 addi a0,s0,-160
+ 802061ee: 00000097 auipc ra,0x0
+ 802061f2: e2a080e7 jalr -470(ra) # 80206018 <cal_checksum>
+ 802061f6: f6a40ea3 sb a0,-131(s0)
+ de.lne.attr = ATTR_LONG_NAME;
+ 802061fa: 47bd li a5,15
+ 802061fc: f6f40da3 sb a5,-133(s0)
+ for (int i = entcnt; i > 0; i--) {
+ 80206200: f4843783 ld a5,-184(s0)
+ 80206204: 14f05c63 blez a5,8020635c <emake+0x316>
+ 80206208: f5842783 lw a5,-168(s0)
+ 8020620c: 37fd addiw a5,a5,-1
+ 8020620e: f4f42223 sw a5,-188(s0)
+ 80206212: 00179b9b slliw s7,a5,0x1
+ 80206216: 00fb8bbb addw s7,s7,a5
+ 8020621a: 002b9b9b slliw s7,s7,0x2
+ 8020621e: 00fb8bbb addw s7,s7,a5
+ 80206222: 9bea add s7,s7,s10
+ 80206224: 8aee mv s5,s11
+ 80206226: 8c66 mv s8,s9
+ int end = 0;
+ 80206228: 4981 li s3,0
+ uint8 *w = (uint8 *)de.lne.name1;
+ 8020622a: f7140793 addi a5,s0,-143
+ 8020622e: f4f43823 sd a5,-176(s0)
+ 80206232: 0ff00913 li s2,255
+ case 5: w = (uint8 *)de.lne.name2; break;
+ 80206236: f7e40793 addi a5,s0,-130
+ 8020623a: f4f43c23 sd a5,-168(s0)
+ switch (j) {
+ 8020623e: 44ad li s1,11
+ 80206240: f8c40a13 addi s4,s0,-116
+ 80206244: a0c5 j 80206324 <emake+0x2de>
+ if (name > p) { // last '.'
+ 80206246: 0549f663 bgeu s3,s4,80206292 <emake+0x24c>
+ memset(shortname + i, ' ', 8 - i);
+ 8020624a: 47a1 li a5,8
+ 8020624c: 4097863b subw a2,a5,s1
+ 80206250: 02000593 li a1,32
+ 80206254: f5043783 ld a5,-176(s0)
+ 80206258: 00978533 add a0,a5,s1
+ 8020625c: ffffa097 auipc ra,0xffffa
+ 80206260: 506080e7 jalr 1286(ra) # 80200762 <memset>
+ while (i < CHAR_SHORT_NAME && (c = *name++)) {
+ 80206264: 89d2 mv s3,s4
+ shortname[i++] = c;
+ 80206266: 8a4e mv s4,s3
+ 80206268: 84d6 mv s1,s5
+ 8020626a: 4981 li s3,0
+ 8020626c: a02d j 80206296 <emake+0x250>
+ if (strchr(illegal, c) != NULL) {
+ 8020626e: 85ca mv a1,s2
+ 80206270: 00006517 auipc a0,0x6
+ 80206274: a6050513 addi a0,a0,-1440 # 8020bcd0 <illegal.0>
+ 80206278: ffffa097 auipc ra,0xffffa
+ 8020627c: 748080e7 jalr 1864(ra) # 802009c0 <strchr>
+ 80206280: c119 beqz a0,80206286 <emake+0x240>
+ c = '_';
+ 80206282: 05f00913 li s2,95
+ shortname[i++] = c;
+ 80206286: f9048793 addi a5,s1,-112
+ 8020628a: 97a2 add a5,a5,s0
+ 8020628c: fd278823 sb s2,-48(a5)
+ 80206290: 2485 addiw s1,s1,1
+ while (i < CHAR_SHORT_NAME && (c = *name++)) {
+ 80206292: f49bcce3 blt s7,s1,802061ea <emake+0x1a4>
+ shortname[i++] = c;
+ 80206296: 8952 mv s2,s4
+ while (i < CHAR_SHORT_NAME && (c = *name++)) {
+ 80206298: 00190a13 addi s4,s2,1
+ 8020629c: 00094903 lbu s2,0(s2)
+ 802062a0: 02090663 beqz s2,802062cc <emake+0x286>
+ if (i == 8 && p) {
+ 802062a4: f35482e3 beq s1,s5,802061c8 <emake+0x182>
+ if (c == ' ') { continue; }
+ 802062a8: 02000793 li a5,32
+ 802062ac: fef903e3 beq s2,a5,80206292 <emake+0x24c>
+ if (c == '.') {
+ 802062b0: 02e00793 li a5,46
+ 802062b4: f8f909e3 beq s2,a5,80206246 <emake+0x200>
+ if (c >= 'a' && c <= 'z') {
+ 802062b8: f9f9079b addiw a5,s2,-97
+ 802062bc: 0ff7f793 zext.b a5,a5
+ 802062c0: fafc67e3 bltu s8,a5,8020626e <emake+0x228>
+ c += 'A' - 'a';
+ 802062c4: 3901 addiw s2,s2,-32
+ 802062c6: 0ff97913 zext.b s2,s2
+ 802062ca: bf75 j 80206286 <emake+0x240>
+ while (i < CHAR_SHORT_NAME) {
+ 802062cc: 47a9 li a5,10
+ 802062ce: f097d2e3 bge a5,s1,802061d2 <emake+0x18c>
+ 802062d2: bf21 j 802061ea <emake+0x1a4>
+ de.lne.order |= LAST_LONG_ENTRY;
+ 802062d4: 0407e793 ori a5,a5,64
+ 802062d8: f6f40823 sb a5,-144(s0)
+ 802062dc: a891 j 80206330 <emake+0x2ea>
+ if ((*w++ = *p++) == 0) {
+ 802062de: 00084603 lbu a2,0(a6)
+ end = 1;
+ 802062e2: 00163513 seqz a0,a2
+ *w++ = 0;
+ 802062e6: 00278893 addi a7,a5,2
+ if ((*w++ = *p++) == 0) {
+ 802062ea: 0805 addi a6,a6,1
+ *w++ = 0;
+ 802062ec: 85ce mv a1,s3
+ 802062ee: a8d5 j 802063e2 <emake+0x39c>
+ uint off2 = reloc_clus(dp, off, 1);
+ 802062f0: 4605 li a2,1
+ 802062f2: 85e2 mv a1,s8
+ 802062f4: 855a mv a0,s6
+ 802062f6: fffff097 auipc ra,0xfffff
+ 802062fa: 460080e7 jalr 1120(ra) # 80205756 <reloc_clus>
+ rw_clus(dp->cur_clus, 1, 0, (uint64)&de, off2, sizeof(de));
+ 802062fe: 02000793 li a5,32
+ 80206302: 0005071b sext.w a4,a0
+ 80206306: f7040693 addi a3,s0,-144
+ 8020630a: 864e mv a2,s3
+ 8020630c: 4585 li a1,1
+ 8020630e: 10cb2503 lw a0,268(s6)
+ 80206312: fffff097 auipc ra,0xfffff
+ 80206316: 54c080e7 jalr 1356(ra) # 8020585e <rw_clus>
+ off += sizeof(de);
+ 8020631a: 020c0c1b addiw s8,s8,32
+ for (int i = entcnt; i > 0; i--) {
+ 8020631e: 1bcd addi s7,s7,-13
+ 80206320: 03505163 blez s5,80206342 <emake+0x2fc>
+ if ((de.lne.order = i) == entcnt) {
+ 80206324: 0ffaf793 zext.b a5,s5
+ 80206328: fafd86e3 beq s11,a5,802062d4 <emake+0x28e>
+ 8020632c: f6f40823 sb a5,-144(s0)
+ char *p = ep->filename + (i - 1) * CHAR_LONG_NAME;
+ 80206330: 3afd addiw s5,s5,-1
+ 80206332: 885e mv a6,s7
+ 80206334: 4709 li a4,2
+ int end = 0;
+ 80206336: 854e mv a0,s3
+ uint8 *w = (uint8 *)de.lne.name1;
+ 80206338: f5043783 ld a5,-176(s0)
+ switch (j) {
+ 8020633c: 4315 li t1,5
+ for (int j = 1; j <= CHAR_LONG_NAME; j++) {
+ 8020633e: 4e35 li t3,13
+ 80206340: a851 j 802063d4 <emake+0x38e>
+ 80206342: 020c8c9b addiw s9,s9,32
+ off += sizeof(de);
+ 80206346: 4781 li a5,0
+ 80206348: f4843703 ld a4,-184(s0)
+ 8020634c: 00e05663 blez a4,80206358 <emake+0x312>
+ 80206350: f4442783 lw a5,-188(s0)
+ 80206354: 0057979b slliw a5,a5,0x5
+ 80206358: 01978cbb addw s9,a5,s9
+ memset(&de, 0, sizeof(de));
+ 8020635c: 02000613 li a2,32
+ 80206360: 4581 li a1,0
+ 80206362: f7040493 addi s1,s0,-144
+ 80206366: 8526 mv a0,s1
+ 80206368: ffffa097 auipc ra,0xffffa
+ 8020636c: 3fa080e7 jalr 1018(ra) # 80200762 <memset>
+ strncpy(de.sne.name, shortname, sizeof(de.sne.name));
+ 80206370: 462d li a2,11
+ 80206372: f6040593 addi a1,s0,-160
+ 80206376: 8526 mv a0,s1
+ 80206378: ffffa097 auipc ra,0xffffa
+ 8020637c: 4fe080e7 jalr 1278(ra) # 80200876 <strncpy>
+ de.sne.attr = ep->attribute;
+ 80206380: 100d4783 lbu a5,256(s10)
+ 80206384: f6f40da3 sb a5,-133(s0)
+ de.sne.fst_clus_hi = (uint16)(ep->first_clus >> 16); // first clus high 16 bits
+ 80206388: 104d2783 lw a5,260(s10)
+ 8020638c: 0107d71b srliw a4,a5,0x10
+ 80206390: f8e41223 sh a4,-124(s0)
+ de.sne.fst_clus_lo = (uint16)(ep->first_clus & 0xffff); // low 16 bits
+ 80206394: f8f41523 sh a5,-118(s0)
+ de.sne.file_size = ep->file_size; // filesize is updated in eupdate()
+ 80206398: 108d2783 lw a5,264(s10)
+ 8020639c: f8f42623 sw a5,-116(s0)
+ off = reloc_clus(dp, off, 1);
+ 802063a0: 4605 li a2,1
+ 802063a2: 85e6 mv a1,s9
+ 802063a4: 855a mv a0,s6
+ 802063a6: fffff097 auipc ra,0xfffff
+ 802063aa: 3b0080e7 jalr 944(ra) # 80205756 <reloc_clus>
+ rw_clus(dp->cur_clus, 1, 0, (uint64)&de, off, sizeof(de));
+ 802063ae: 02000793 li a5,32
+ 802063b2: 0005071b sext.w a4,a0
+ 802063b6: 86a6 mv a3,s1
+ 802063b8: 4601 li a2,0
+ 802063ba: 4585 li a1,1
+ 802063bc: 10cb2503 lw a0,268(s6)
+ 802063c0: fffff097 auipc ra,0xfffff
+ 802063c4: 49e080e7 jalr 1182(ra) # 8020585e <rw_clus>
+}
+ 802063c8: b325 j 802060f0 <emake+0xaa>
+ case 5: w = (uint8 *)de.lne.name2; break;
+ 802063ca: f5843783 ld a5,-168(s0)
+ 802063ce: a011 j 802063d2 <emake+0x38c>
+ switch (j) {
+ 802063d0: 87d2 mv a5,s4
+ for (int j = 1; j <= CHAR_LONG_NAME; j++) {
+ 802063d2: 2705 addiw a4,a4,1
+ 802063d4: fff7069b addiw a3,a4,-1
+ if (end) {
+ 802063d8: d119 beqz a0,802062de <emake+0x298>
+ *w++ = 0xff;
+ 802063da: 00278893 addi a7,a5,2
+ 802063de: 864a mv a2,s2
+ 802063e0: 85ca mv a1,s2
+ *w++ = 0xff; // on k210, unaligned reading is illegal
+ 802063e2: 00c78023 sb a2,0(a5)
+ *w++ = 0xff;
+ 802063e6: 00b780a3 sb a1,1(a5)
+ switch (j) {
+ 802063ea: fe6680e3 beq a3,t1,802063ca <emake+0x384>
+ 802063ee: fe9681e3 beq a3,s1,802063d0 <emake+0x38a>
+ for (int j = 1; j <= CHAR_LONG_NAME; j++) {
+ 802063f2: 0007079b sext.w a5,a4
+ 802063f6: eefe4de3 blt t3,a5,802062f0 <emake+0x2aa>
+ 802063fa: 87c6 mv a5,a7
+ 802063fc: bfd9 j 802063d2 <emake+0x38c>
+ if (c == ' ') { continue; }
+ 802063fe: 02000793 li a5,32
+ 80206402: e8f90ae3 beq s2,a5,80206296 <emake+0x250>
+ if (c == '.') {
+ 80206406: 02e00793 li a5,46
+ 8020640a: eaf917e3 bne s2,a5,802062b8 <emake+0x272>
+ 8020640e: bd35 j 8020624a <emake+0x204>
+
+0000000080206410 <edup>:
+{
+ 80206410: 1101 addi sp,sp,-32
+ 80206412: ec06 sd ra,24(sp)
+ 80206414: e822 sd s0,16(sp)
+ 80206416: e426 sd s1,8(sp)
+ 80206418: 1000 addi s0,sp,32
+ 8020641a: 84aa mv s1,a0
+ if (entry != 0) {
+ 8020641c: c515 beqz a0,80206448 <edup+0x38>
+ acquire(&ecache.lock);
+ 8020641e: 00018517 auipc a0,0x18
+ 80206422: 19a50513 addi a0,a0,410 # 8021e5b8 <ecache>
+ 80206426: ffffa097 auipc ra,0xffffa
+ 8020642a: 2a0080e7 jalr 672(ra) # 802006c6 <acquire>
+ entry->ref++;
+ 8020642e: 1184a783 lw a5,280(s1)
+ 80206432: 2785 addiw a5,a5,1
+ 80206434: 10f4ac23 sw a5,280(s1)
+ release(&ecache.lock);
+ 80206438: 00018517 auipc a0,0x18
+ 8020643c: 18050513 addi a0,a0,384 # 8021e5b8 <ecache>
+ 80206440: ffffa097 auipc ra,0xffffa
+ 80206444: 2da080e7 jalr 730(ra) # 8020071a <release>
+}
+ 80206448: 8526 mv a0,s1
+ 8020644a: 60e2 ld ra,24(sp)
+ 8020644c: 6442 ld s0,16(sp)
+ 8020644e: 64a2 ld s1,8(sp)
+ 80206450: 6105 addi sp,sp,32
+ 80206452: 8082 ret
+
+0000000080206454 <eupdate>:
+ if (!entry->dirty || entry->valid != 1) { return; }
+ 80206454: 11554783 lbu a5,277(a0)
+ 80206458: c3e5 beqz a5,80206538 <eupdate+0xe4>
+{
+ 8020645a: 711d addi sp,sp,-96
+ 8020645c: ec86 sd ra,88(sp)
+ 8020645e: e8a2 sd s0,80(sp)
+ 80206460: e4a6 sd s1,72(sp)
+ 80206462: e0ca sd s2,64(sp)
+ 80206464: fc4e sd s3,56(sp)
+ 80206466: 1080 addi s0,sp,96
+ 80206468: 84aa mv s1,a0
+ if (!entry->dirty || entry->valid != 1) { return; }
+ 8020646a: 11651703 lh a4,278(a0)
+ 8020646e: 4785 li a5,1
+ 80206470: 00f70963 beq a4,a5,80206482 <eupdate+0x2e>
+}
+ 80206474: 60e6 ld ra,88(sp)
+ 80206476: 6446 ld s0,80(sp)
+ 80206478: 64a6 ld s1,72(sp)
+ 8020647a: 6906 ld s2,64(sp)
+ 8020647c: 79e2 ld s3,56(sp)
+ 8020647e: 6125 addi sp,sp,96
+ 80206480: 8082 ret
+ uint entcnt = 0;
+ 80206482: fc042623 sw zero,-52(s0)
+ uint32 off = reloc_clus(entry->parent, entry->off, 0);
+ 80206486: 4601 li a2,0
+ 80206488: 11c52583 lw a1,284(a0)
+ 8020648c: 12053503 ld a0,288(a0)
+ 80206490: fffff097 auipc ra,0xfffff
+ 80206494: 2c6080e7 jalr 710(ra) # 80205756 <reloc_clus>
+ rw_clus(entry->parent->cur_clus, 0, 0, (uint64) &entcnt, off, 1);
+ 80206498: 1204b803 ld a6,288(s1)
+ 8020649c: 4785 li a5,1
+ 8020649e: 0005071b sext.w a4,a0
+ 802064a2: fcc40693 addi a3,s0,-52
+ 802064a6: 4601 li a2,0
+ 802064a8: 4581 li a1,0
+ 802064aa: 10c82503 lw a0,268(a6)
+ 802064ae: fffff097 auipc ra,0xfffff
+ 802064b2: 3b0080e7 jalr 944(ra) # 8020585e <rw_clus>
+ entcnt &= ~LAST_LONG_ENTRY;
+ 802064b6: fcc42583 lw a1,-52(s0)
+ 802064ba: fbf5f593 andi a1,a1,-65
+ 802064be: fcb42623 sw a1,-52(s0)
+ off = reloc_clus(entry->parent, entry->off + (entcnt << 5), 0);
+ 802064c2: 0055959b slliw a1,a1,0x5
+ 802064c6: 11c4a783 lw a5,284(s1)
+ 802064ca: 4601 li a2,0
+ 802064cc: 9dbd addw a1,a1,a5
+ 802064ce: 1204b503 ld a0,288(s1)
+ 802064d2: fffff097 auipc ra,0xfffff
+ 802064d6: 284080e7 jalr 644(ra) # 80205756 <reloc_clus>
+ 802064da: 0005099b sext.w s3,a0
+ rw_clus(entry->parent->cur_clus, 0, 0, (uint64)&de, off, sizeof(de));
+ 802064de: 1204b503 ld a0,288(s1)
+ 802064e2: 02000793 li a5,32
+ 802064e6: 874e mv a4,s3
+ 802064e8: fa840913 addi s2,s0,-88
+ 802064ec: 86ca mv a3,s2
+ 802064ee: 4601 li a2,0
+ 802064f0: 4581 li a1,0
+ 802064f2: 10c52503 lw a0,268(a0)
+ 802064f6: fffff097 auipc ra,0xfffff
+ 802064fa: 368080e7 jalr 872(ra) # 8020585e <rw_clus>
+ de.sne.fst_clus_hi = (uint16)(entry->first_clus >> 16);
+ 802064fe: 1044a783 lw a5,260(s1)
+ 80206502: 0107d71b srliw a4,a5,0x10
+ 80206506: fae41e23 sh a4,-68(s0)
+ de.sne.fst_clus_lo = (uint16)(entry->first_clus & 0xffff);
+ 8020650a: fcf41123 sh a5,-62(s0)
+ de.sne.file_size = entry->file_size;
+ 8020650e: 1084a783 lw a5,264(s1)
+ 80206512: fcf42223 sw a5,-60(s0)
+ rw_clus(entry->parent->cur_clus, 1, 0, (uint64)&de, off, sizeof(de));
+ 80206516: 1204b503 ld a0,288(s1)
+ 8020651a: 02000793 li a5,32
+ 8020651e: 874e mv a4,s3
+ 80206520: 86ca mv a3,s2
+ 80206522: 4601 li a2,0
+ 80206524: 4585 li a1,1
+ 80206526: 10c52503 lw a0,268(a0)
+ 8020652a: fffff097 auipc ra,0xfffff
+ 8020652e: 334080e7 jalr 820(ra) # 8020585e <rw_clus>
+ entry->dirty = 0;
+ 80206532: 10048aa3 sb zero,277(s1)
+ 80206536: bf3d j 80206474 <eupdate+0x20>
+ 80206538: 8082 ret
+
+000000008020653a <eremove>:
+ if (entry->valid != 1) { return; }
+ 8020653a: 11651703 lh a4,278(a0)
+ 8020653e: 4785 li a5,1
+ 80206540: 00f70363 beq a4,a5,80206546 <eremove+0xc>
+ 80206544: 8082 ret
+{
+ 80206546: 715d addi sp,sp,-80
+ 80206548: e486 sd ra,72(sp)
+ 8020654a: e0a2 sd s0,64(sp)
+ 8020654c: fc26 sd s1,56(sp)
+ 8020654e: f84a sd s2,48(sp)
+ 80206550: f44e sd s3,40(sp)
+ 80206552: f052 sd s4,32(sp)
+ 80206554: ec56 sd s5,24(sp)
+ 80206556: 0880 addi s0,sp,80
+ 80206558: 89aa mv s3,a0
+ uint entcnt = 0;
+ 8020655a: fa042e23 sw zero,-68(s0)
+ uint32 off = entry->off;
+ 8020655e: 11c52a03 lw s4,284(a0)
+ uint32 off2 = reloc_clus(entry->parent, off, 0);
+ 80206562: 4601 li a2,0
+ 80206564: 85d2 mv a1,s4
+ 80206566: 12053503 ld a0,288(a0)
+ 8020656a: fffff097 auipc ra,0xfffff
+ 8020656e: 1ec080e7 jalr 492(ra) # 80205756 <reloc_clus>
+ 80206572: 0005049b sext.w s1,a0
+ rw_clus(entry->parent->cur_clus, 0, 0, (uint64) &entcnt, off2, 1);
+ 80206576: 1209b503 ld a0,288(s3)
+ 8020657a: 4785 li a5,1
+ 8020657c: 8726 mv a4,s1
+ 8020657e: fbc40693 addi a3,s0,-68
+ 80206582: 4601 li a2,0
+ 80206584: 4581 li a1,0
+ 80206586: 10c52503 lw a0,268(a0)
+ 8020658a: fffff097 auipc ra,0xfffff
+ 8020658e: 2d4080e7 jalr 724(ra) # 8020585e <rw_clus>
+ entcnt &= ~LAST_LONG_ENTRY;
+ 80206592: fbc42783 lw a5,-68(s0)
+ 80206596: fbf7f793 andi a5,a5,-65
+ 8020659a: faf42e23 sw a5,-68(s0)
+ uint8 flag = EMPTY_ENTRY;
+ 8020659e: 5795 li a5,-27
+ 802065a0: faf40da3 sb a5,-69(s0)
+ for (int i = 0; i <= entcnt; i++) {
+ 802065a4: 4901 li s2,0
+ rw_clus(entry->parent->cur_clus, 1, 0, (uint64) &flag, off2, 1);
+ 802065a6: fbb40a93 addi s5,s0,-69
+ 802065aa: 1209b503 ld a0,288(s3)
+ 802065ae: 4785 li a5,1
+ 802065b0: 8726 mv a4,s1
+ 802065b2: 86d6 mv a3,s5
+ 802065b4: 4601 li a2,0
+ 802065b6: 4585 li a1,1
+ 802065b8: 10c52503 lw a0,268(a0)
+ 802065bc: fffff097 auipc ra,0xfffff
+ 802065c0: 2a2080e7 jalr 674(ra) # 8020585e <rw_clus>
+ off += 32;
+ 802065c4: 020a0a1b addiw s4,s4,32
+ off2 = reloc_clus(entry->parent, off, 0);
+ 802065c8: 4601 li a2,0
+ 802065ca: 85d2 mv a1,s4
+ 802065cc: 1209b503 ld a0,288(s3)
+ 802065d0: fffff097 auipc ra,0xfffff
+ 802065d4: 186080e7 jalr 390(ra) # 80205756 <reloc_clus>
+ 802065d8: 0005049b sext.w s1,a0
+ for (int i = 0; i <= entcnt; i++) {
+ 802065dc: 0019079b addiw a5,s2,1
+ 802065e0: 0007891b sext.w s2,a5
+ 802065e4: fbc42703 lw a4,-68(s0)
+ 802065e8: fd2771e3 bgeu a4,s2,802065aa <eremove+0x70>
+ entry->valid = -1;
+ 802065ec: 57fd li a5,-1
+ 802065ee: 10f99b23 sh a5,278(s3)
+}
+ 802065f2: 60a6 ld ra,72(sp)
+ 802065f4: 6406 ld s0,64(sp)
+ 802065f6: 74e2 ld s1,56(sp)
+ 802065f8: 7942 ld s2,48(sp)
+ 802065fa: 79a2 ld s3,40(sp)
+ 802065fc: 7a02 ld s4,32(sp)
+ 802065fe: 6ae2 ld s5,24(sp)
+ 80206600: 6161 addi sp,sp,80
+ 80206602: 8082 ret
+
+0000000080206604 <etrunc>:
+{
+ 80206604: 7179 addi sp,sp,-48
+ 80206606: f406 sd ra,40(sp)
+ 80206608: f022 sd s0,32(sp)
+ 8020660a: ec26 sd s1,24(sp)
+ 8020660c: e84a sd s2,16(sp)
+ 8020660e: e44e sd s3,8(sp)
+ 80206610: e052 sd s4,0(sp)
+ 80206612: 1800 addi s0,sp,48
+ 80206614: 8a2a mv s4,a0
+ for (uint32 clus = entry->first_clus; clus >= 2 && clus < FAT32_EOC; ) {
+ 80206616: 10452483 lw s1,260(a0)
+ 8020661a: ffe4871b addiw a4,s1,-2
+ 8020661e: 100007b7 lui a5,0x10000
+ 80206622: 17d5 addi a5,a5,-11 # ffffff5 <_entry-0x7020000b>
+ 80206624: 02e7e663 bltu a5,a4,80206650 <etrunc+0x4c>
+ 80206628: 89be mv s3,a5
+ uint32 next = read_fat(clus);
+ 8020662a: 0004891b sext.w s2,s1
+ 8020662e: 8526 mv a0,s1
+ 80206630: fffff097 auipc ra,0xfffff
+ 80206634: eee080e7 jalr -274(ra) # 8020551e <read_fat>
+ 80206638: 0005049b sext.w s1,a0
+ write_fat(cluster, 0);
+ 8020663c: 4581 li a1,0
+ 8020663e: 854a mv a0,s2
+ 80206640: fffff097 auipc ra,0xfffff
+ 80206644: 096080e7 jalr 150(ra) # 802056d6 <write_fat>
+ for (uint32 clus = entry->first_clus; clus >= 2 && clus < FAT32_EOC; ) {
+ 80206648: ffe4879b addiw a5,s1,-2
+ 8020664c: fcf9ffe3 bgeu s3,a5,8020662a <etrunc+0x26>
+ entry->file_size = 0;
+ 80206650: 100a2423 sw zero,264(s4)
+ entry->first_clus = 0;
+ 80206654: 100a2223 sw zero,260(s4)
+ entry->dirty = 1;
+ 80206658: 4785 li a5,1
+ 8020665a: 10fa0aa3 sb a5,277(s4)
+}
+ 8020665e: 70a2 ld ra,40(sp)
+ 80206660: 7402 ld s0,32(sp)
+ 80206662: 64e2 ld s1,24(sp)
+ 80206664: 6942 ld s2,16(sp)
+ 80206666: 69a2 ld s3,8(sp)
+ 80206668: 6a02 ld s4,0(sp)
+ 8020666a: 6145 addi sp,sp,48
+ 8020666c: 8082 ret
+
+000000008020666e <elock>:
+{
+ 8020666e: 1141 addi sp,sp,-16
+ 80206670: e406 sd ra,8(sp)
+ 80206672: e022 sd s0,0(sp)
+ 80206674: 0800 addi s0,sp,16
+ if (entry == 0 || entry->ref < 1)
+ 80206676: cd19 beqz a0,80206694 <elock+0x26>
+ 80206678: 11852783 lw a5,280(a0)
+ 8020667c: 00f05c63 blez a5,80206694 <elock+0x26>
+ acquiresleep(&entry->lock);
+ 80206680: 13850513 addi a0,a0,312
+ 80206684: ffffd097 auipc ra,0xffffd
+ 80206688: 44a080e7 jalr 1098(ra) # 80203ace <acquiresleep>
+}
+ 8020668c: 60a2 ld ra,8(sp)
+ 8020668e: 6402 ld s0,0(sp)
+ 80206690: 0141 addi sp,sp,16
+ 80206692: 8082 ret
+ panic("elock");
+ 80206694: 00003517 auipc a0,0x3
+ 80206698: 7a450513 addi a0,a0,1956 # 80209e38 <digits+0xab8>
+ 8020669c: ffffa097 auipc ra,0xffffa
+ 802066a0: aa8080e7 jalr -1368(ra) # 80200144 <panic>
+
+00000000802066a4 <eunlock>:
+{
+ 802066a4: 1101 addi sp,sp,-32
+ 802066a6: ec06 sd ra,24(sp)
+ 802066a8: e822 sd s0,16(sp)
+ 802066aa: e426 sd s1,8(sp)
+ 802066ac: e04a sd s2,0(sp)
+ 802066ae: 1000 addi s0,sp,32
+ if (entry == 0 || !holdingsleep(&entry->lock) || entry->ref < 1)
+ 802066b0: c90d beqz a0,802066e2 <eunlock+0x3e>
+ 802066b2: 84aa mv s1,a0
+ 802066b4: 13850913 addi s2,a0,312
+ 802066b8: 854a mv a0,s2
+ 802066ba: ffffd097 auipc ra,0xffffd
+ 802066be: 4ae080e7 jalr 1198(ra) # 80203b68 <holdingsleep>
+ 802066c2: c105 beqz a0,802066e2 <eunlock+0x3e>
+ 802066c4: 1184a783 lw a5,280(s1)
+ 802066c8: 00f05d63 blez a5,802066e2 <eunlock+0x3e>
+ releasesleep(&entry->lock);
+ 802066cc: 854a mv a0,s2
+ 802066ce: ffffd097 auipc ra,0xffffd
+ 802066d2: 456080e7 jalr 1110(ra) # 80203b24 <releasesleep>
+}
+ 802066d6: 60e2 ld ra,24(sp)
+ 802066d8: 6442 ld s0,16(sp)
+ 802066da: 64a2 ld s1,8(sp)
+ 802066dc: 6902 ld s2,0(sp)
+ 802066de: 6105 addi sp,sp,32
+ 802066e0: 8082 ret
+ panic("eunlock");
+ 802066e2: 00003517 auipc a0,0x3
+ 802066e6: 75e50513 addi a0,a0,1886 # 80209e40 <digits+0xac0>
+ 802066ea: ffffa097 auipc ra,0xffffa
+ 802066ee: a5a080e7 jalr -1446(ra) # 80200144 <panic>
+
+00000000802066f2 <eput>:
+{
+ 802066f2: 1101 addi sp,sp,-32
+ 802066f4: ec06 sd ra,24(sp)
+ 802066f6: e822 sd s0,16(sp)
+ 802066f8: e426 sd s1,8(sp)
+ 802066fa: e04a sd s2,0(sp)
+ 802066fc: 1000 addi s0,sp,32
+ 802066fe: 84aa mv s1,a0
+ acquire(&ecache.lock);
+ 80206700: 00018517 auipc a0,0x18
+ 80206704: eb850513 addi a0,a0,-328 # 8021e5b8 <ecache>
+ 80206708: ffffa097 auipc ra,0xffffa
+ 8020670c: fbe080e7 jalr -66(ra) # 802006c6 <acquire>
+ if (entry != &root && entry->valid != 0 && entry->ref == 1) {
+ 80206710: 00018797 auipc a5,0x18
+ 80206714: d4078793 addi a5,a5,-704 # 8021e450 <root>
+ 80206718: 00f48a63 beq s1,a5,8020672c <eput+0x3a>
+ 8020671c: 11649783 lh a5,278(s1)
+ 80206720: c791 beqz a5,8020672c <eput+0x3a>
+ 80206722: 1184a703 lw a4,280(s1)
+ 80206726: 4785 li a5,1
+ 80206728: 02f70563 beq a4,a5,80206752 <eput+0x60>
+ entry->ref--;
+ 8020672c: 1184a783 lw a5,280(s1)
+ 80206730: 37fd addiw a5,a5,-1
+ 80206732: 10f4ac23 sw a5,280(s1)
+ release(&ecache.lock);
+ 80206736: 00018517 auipc a0,0x18
+ 8020673a: e8250513 addi a0,a0,-382 # 8021e5b8 <ecache>
+ 8020673e: ffffa097 auipc ra,0xffffa
+ 80206742: fdc080e7 jalr -36(ra) # 8020071a <release>
+}
+ 80206746: 60e2 ld ra,24(sp)
+ 80206748: 6442 ld s0,16(sp)
+ 8020674a: 64a2 ld s1,8(sp)
+ 8020674c: 6902 ld s2,0(sp)
+ 8020674e: 6105 addi sp,sp,32
+ 80206750: 8082 ret
+ acquiresleep(&entry->lock);
+ 80206752: 13848913 addi s2,s1,312
+ 80206756: 854a mv a0,s2
+ 80206758: ffffd097 auipc ra,0xffffd
+ 8020675c: 376080e7 jalr 886(ra) # 80203ace <acquiresleep>
+ entry->next->prev = entry->prev;
+ 80206760: 1284b703 ld a4,296(s1)
+ 80206764: 1304b783 ld a5,304(s1)
+ 80206768: 12f73823 sd a5,304(a4)
+ entry->prev->next = entry->next;
+ 8020676c: 1284b703 ld a4,296(s1)
+ 80206770: 12e7b423 sd a4,296(a5)
+ entry->next = root.next;
+ 80206774: 00018797 auipc a5,0x18
+ 80206778: cb478793 addi a5,a5,-844 # 8021e428 <fat>
+ 8020677c: 1507b703 ld a4,336(a5)
+ 80206780: 12e4b423 sd a4,296(s1)
+ entry->prev = &root;
+ 80206784: 00018697 auipc a3,0x18
+ 80206788: ccc68693 addi a3,a3,-820 # 8021e450 <root>
+ 8020678c: 12d4b823 sd a3,304(s1)
+ root.next->prev = entry;
+ 80206790: 12973823 sd s1,304(a4)
+ root.next = entry;
+ 80206794: 1497b823 sd s1,336(a5)
+ release(&ecache.lock);
+ 80206798: 00018517 auipc a0,0x18
+ 8020679c: e2050513 addi a0,a0,-480 # 8021e5b8 <ecache>
+ 802067a0: ffffa097 auipc ra,0xffffa
+ 802067a4: f7a080e7 jalr -134(ra) # 8020071a <release>
+ if (entry->valid == -1) { // this means some one has called eremove()
+ 802067a8: 11649703 lh a4,278(s1)
+ 802067ac: 57fd li a5,-1
+ 802067ae: 06f70863 beq a4,a5,8020681e <eput+0x12c>
+ elock(entry->parent);
+ 802067b2: 1204b503 ld a0,288(s1)
+ 802067b6: 00000097 auipc ra,0x0
+ 802067ba: eb8080e7 jalr -328(ra) # 8020666e <elock>
+ eupdate(entry);
+ 802067be: 8526 mv a0,s1
+ 802067c0: 00000097 auipc ra,0x0
+ 802067c4: c94080e7 jalr -876(ra) # 80206454 <eupdate>
+ eunlock(entry->parent);
+ 802067c8: 1204b503 ld a0,288(s1)
+ 802067cc: 00000097 auipc ra,0x0
+ 802067d0: ed8080e7 jalr -296(ra) # 802066a4 <eunlock>
+ releasesleep(&entry->lock);
+ 802067d4: 854a mv a0,s2
+ 802067d6: ffffd097 auipc ra,0xffffd
+ 802067da: 34e080e7 jalr 846(ra) # 80203b24 <releasesleep>
+ struct dirent *eparent = entry->parent;
+ 802067de: 1204b903 ld s2,288(s1)
+ acquire(&ecache.lock);
+ 802067e2: 00018517 auipc a0,0x18
+ 802067e6: dd650513 addi a0,a0,-554 # 8021e5b8 <ecache>
+ 802067ea: ffffa097 auipc ra,0xffffa
+ 802067ee: edc080e7 jalr -292(ra) # 802006c6 <acquire>
+ entry->ref--;
+ 802067f2: 1184a783 lw a5,280(s1)
+ 802067f6: 37fd addiw a5,a5,-1
+ 802067f8: 10f4ac23 sw a5,280(s1)
+ release(&ecache.lock);
+ 802067fc: 00018517 auipc a0,0x18
+ 80206800: dbc50513 addi a0,a0,-580 # 8021e5b8 <ecache>
+ 80206804: ffffa097 auipc ra,0xffffa
+ 80206808: f16080e7 jalr -234(ra) # 8020071a <release>
+ if (entry->ref == 0) {
+ 8020680c: 1184a783 lw a5,280(s1)
+ 80206810: fb9d bnez a5,80206746 <eput+0x54>
+ eput(eparent);
+ 80206812: 854a mv a0,s2
+ 80206814: 00000097 auipc ra,0x0
+ 80206818: ede080e7 jalr -290(ra) # 802066f2 <eput>
+ 8020681c: b72d j 80206746 <eput+0x54>
+ etrunc(entry);
+ 8020681e: 8526 mv a0,s1
+ 80206820: 00000097 auipc ra,0x0
+ 80206824: de4080e7 jalr -540(ra) # 80206604 <etrunc>
+ 80206828: b775 j 802067d4 <eput+0xe2>
+
+000000008020682a <estat>:
+{
+ 8020682a: 1101 addi sp,sp,-32
+ 8020682c: ec06 sd ra,24(sp)
+ 8020682e: e822 sd s0,16(sp)
+ 80206830: e426 sd s1,8(sp)
+ 80206832: e04a sd s2,0(sp)
+ 80206834: 1000 addi s0,sp,32
+ 80206836: 892a mv s2,a0
+ 80206838: 84ae mv s1,a1
+ strncpy(st->name, de->filename, STAT_MAX_NAME);
+ 8020683a: 02000613 li a2,32
+ 8020683e: 85aa mv a1,a0
+ 80206840: 8526 mv a0,s1
+ 80206842: ffffa097 auipc ra,0xffffa
+ 80206846: 034080e7 jalr 52(ra) # 80200876 <strncpy>
+ st->type = (de->attribute & ATTR_DIRECTORY) ? T_DIR : T_FILE;
+ 8020684a: 10094783 lbu a5,256(s2)
+ 8020684e: 8bc1 andi a5,a5,16
+ 80206850: 0017b793 seqz a5,a5
+ 80206854: 0785 addi a5,a5,1
+ 80206856: 02f49423 sh a5,40(s1)
+ st->dev = de->dev;
+ 8020685a: 11494783 lbu a5,276(s2)
+ 8020685e: d0dc sw a5,36(s1)
+ st->size = de->file_size;
+ 80206860: 10896783 lwu a5,264(s2)
+ 80206864: f89c sd a5,48(s1)
+}
+ 80206866: 60e2 ld ra,24(sp)
+ 80206868: 6442 ld s0,16(sp)
+ 8020686a: 64a2 ld s1,8(sp)
+ 8020686c: 6902 ld s2,0(sp)
+ 8020686e: 6105 addi sp,sp,32
+ 80206870: 8082 ret
+
+0000000080206872 <enext>:
+ * @return -1 meet the end of dir
+ * 0 find empty slots
+ * 1 find a file with all its entries
+ */
+int enext(struct dirent *dp, struct dirent *ep, uint off, int *count)
+{
+ 80206872: 7119 addi sp,sp,-128
+ 80206874: fc86 sd ra,120(sp)
+ 80206876: f8a2 sd s0,112(sp)
+ 80206878: f4a6 sd s1,104(sp)
+ 8020687a: f0ca sd s2,96(sp)
+ 8020687c: ecce sd s3,88(sp)
+ 8020687e: e8d2 sd s4,80(sp)
+ 80206880: e4d6 sd s5,72(sp)
+ 80206882: e0da sd s6,64(sp)
+ 80206884: fc5e sd s7,56(sp)
+ 80206886: f862 sd s8,48(sp)
+ 80206888: f466 sd s9,40(sp)
+ 8020688a: 0100 addi s0,sp,128
+ if (!(dp->attribute & ATTR_DIRECTORY))
+ 8020688c: 10054783 lbu a5,256(a0)
+ 80206890: 8bc1 andi a5,a5,16
+ 80206892: cf95 beqz a5,802068ce <enext+0x5c>
+ 80206894: 892a mv s2,a0
+ 80206896: 89ae mv s3,a1
+ 80206898: 84b2 mv s1,a2
+ 8020689a: 8ab6 mv s5,a3
+ panic("enext not dir");
+ if (ep->valid)
+ 8020689c: 11659783 lh a5,278(a1)
+ 802068a0: ef9d bnez a5,802068de <enext+0x6c>
+ panic("enext ep valid");
+ if (off % 32)
+ 802068a2: 01f67793 andi a5,a2,31
+ 802068a6: e7a1 bnez a5,802068ee <enext+0x7c>
+ panic("enext not align");
+ if (dp->valid != 1) { return -1; }
+ 802068a8: 11651703 lh a4,278(a0)
+ 802068ac: 4785 li a5,1
+ 802068ae: 557d li a0,-1
+ 802068b0: 04f70763 beq a4,a5,802068fe <enext+0x8c>
+ read_entry_info(ep, &de);
+ return 1;
+ }
+ }
+ return -1;
+}
+ 802068b4: 70e6 ld ra,120(sp)
+ 802068b6: 7446 ld s0,112(sp)
+ 802068b8: 74a6 ld s1,104(sp)
+ 802068ba: 7906 ld s2,96(sp)
+ 802068bc: 69e6 ld s3,88(sp)
+ 802068be: 6a46 ld s4,80(sp)
+ 802068c0: 6aa6 ld s5,72(sp)
+ 802068c2: 6b06 ld s6,64(sp)
+ 802068c4: 7be2 ld s7,56(sp)
+ 802068c6: 7c42 ld s8,48(sp)
+ 802068c8: 7ca2 ld s9,40(sp)
+ 802068ca: 6109 addi sp,sp,128
+ 802068cc: 8082 ret
+ panic("enext not dir");
+ 802068ce: 00003517 auipc a0,0x3
+ 802068d2: 57a50513 addi a0,a0,1402 # 80209e48 <digits+0xac8>
+ 802068d6: ffffa097 auipc ra,0xffffa
+ 802068da: 86e080e7 jalr -1938(ra) # 80200144 <panic>
+ panic("enext ep valid");
+ 802068de: 00003517 auipc a0,0x3
+ 802068e2: 57a50513 addi a0,a0,1402 # 80209e58 <digits+0xad8>
+ 802068e6: ffffa097 auipc ra,0xffffa
+ 802068ea: 85e080e7 jalr -1954(ra) # 80200144 <panic>
+ panic("enext not align");
+ 802068ee: 00003517 auipc a0,0x3
+ 802068f2: 57a50513 addi a0,a0,1402 # 80209e68 <digits+0xae8>
+ 802068f6: ffffa097 auipc ra,0xffffa
+ 802068fa: 84e080e7 jalr -1970(ra) # 80200144 <panic>
+ memset(ep->filename, 0, FAT32_MAX_FILENAME + 1);
+ 802068fe: 10000613 li a2,256
+ 80206902: 4581 li a1,0
+ 80206904: 854e mv a0,s3
+ 80206906: ffffa097 auipc ra,0xffffa
+ 8020690a: e5c080e7 jalr -420(ra) # 80200762 <memset>
+ int cnt = 0;
+ 8020690e: 4b01 li s6,0
+ for (int off2; (off2 = reloc_clus(dp, off, 0)) != -1; off += 32) {
+ 80206910: 5bfd li s7,-1
+ if (rw_clus(dp->cur_clus, 0, 0, (uint64)&de, off2, 32) != 32 || de.lne.order == END_OF_ENTRY) {
+ 80206912: f8040a13 addi s4,s0,-128
+ if (de.lne.order == EMPTY_ENTRY) {
+ 80206916: 0e500c13 li s8,229
+ if (de.lne.attr == ATTR_LONG_NAME) {
+ 8020691a: 4cbd li s9,15
+ for (int off2; (off2 = reloc_clus(dp, off, 0)) != -1; off += 32) {
+ 8020691c: a03d j 8020694a <enext+0xd8>
+ cnt++;
+ 8020691e: 2b05 addiw s6,s6,1
+ continue;
+ 80206920: a01d j 80206946 <enext+0xd4>
+ *count = cnt;
+ 80206922: 016aa023 sw s6,0(s5)
+ return 0;
+ 80206926: 4501 li a0,0
+ 80206928: b771 j 802068b4 <enext+0x42>
+ read_entry_name(ep->filename + (lcnt - 1) * CHAR_LONG_NAME, &de);
+ 8020692a: fff7079b addiw a5,a4,-1
+ 8020692e: 0017951b slliw a0,a5,0x1
+ 80206932: 9d3d addw a0,a0,a5
+ 80206934: 0025151b slliw a0,a0,0x2
+ 80206938: 9d3d addw a0,a0,a5
+ 8020693a: 85d2 mv a1,s4
+ 8020693c: 954e add a0,a0,s3
+ 8020693e: fffff097 auipc ra,0xfffff
+ 80206942: 17a080e7 jalr 378(ra) # 80205ab8 <read_entry_name>
+ for (int off2; (off2 = reloc_clus(dp, off, 0)) != -1; off += 32) {
+ 80206946: 0204849b addiw s1,s1,32
+ 8020694a: 4601 li a2,0
+ 8020694c: 85a6 mv a1,s1
+ 8020694e: 854a mv a0,s2
+ 80206950: fffff097 auipc ra,0xfffff
+ 80206954: e06080e7 jalr -506(ra) # 80205756 <reloc_clus>
+ 80206958: f5750ee3 beq a0,s7,802068b4 <enext+0x42>
+ if (rw_clus(dp->cur_clus, 0, 0, (uint64)&de, off2, 32) != 32 || de.lne.order == END_OF_ENTRY) {
+ 8020695c: 02000793 li a5,32
+ 80206960: 0005071b sext.w a4,a0
+ 80206964: 86d2 mv a3,s4
+ 80206966: 4601 li a2,0
+ 80206968: 4581 li a1,0
+ 8020696a: 10c92503 lw a0,268(s2)
+ 8020696e: fffff097 auipc ra,0xfffff
+ 80206972: ef0080e7 jalr -272(ra) # 8020585e <rw_clus>
+ 80206976: 2501 sext.w a0,a0
+ 80206978: 02000793 li a5,32
+ 8020697c: 06f51c63 bne a0,a5,802069f4 <enext+0x182>
+ 80206980: f8044783 lbu a5,-128(s0)
+ 80206984: cbb5 beqz a5,802069f8 <enext+0x186>
+ if (de.lne.order == EMPTY_ENTRY) {
+ 80206986: f9878ce3 beq a5,s8,8020691e <enext+0xac>
+ } else if (cnt) {
+ 8020698a: f80b1ce3 bnez s6,80206922 <enext+0xb0>
+ if (de.lne.attr == ATTR_LONG_NAME) {
+ 8020698e: f8b44703 lbu a4,-117(s0)
+ 80206992: 01971d63 bne a4,s9,802069ac <enext+0x13a>
+ int lcnt = de.lne.order & ~LAST_LONG_ENTRY;
+ 80206996: 0bf7f713 andi a4,a5,191
+ if (de.lne.order & LAST_LONG_ENTRY) {
+ 8020699a: 0407f793 andi a5,a5,64
+ 8020699e: d7d1 beqz a5,8020692a <enext+0xb8>
+ *count = lcnt + 1; // plus the s-n-e;
+ 802069a0: 0017079b addiw a5,a4,1
+ 802069a4: 00faa023 sw a5,0(s5)
+ count = 0;
+ 802069a8: 4a81 li s5,0
+ 802069aa: b741 j 8020692a <enext+0xb8>
+ if (count) {
+ 802069ac: 000a8c63 beqz s5,802069c4 <enext+0x152>
+ *count = 1;
+ 802069b0: 4785 li a5,1
+ 802069b2: 00faa023 sw a5,0(s5)
+ read_entry_name(ep->filename, &de);
+ 802069b6: f8040593 addi a1,s0,-128
+ 802069ba: 854e mv a0,s3
+ 802069bc: fffff097 auipc ra,0xfffff
+ 802069c0: 0fc080e7 jalr 252(ra) # 80205ab8 <read_entry_name>
+ entry->attribute = d->sne.attr;
+ 802069c4: f8b44783 lbu a5,-117(s0)
+ 802069c8: 10f98023 sb a5,256(s3)
+ entry->first_clus = ((uint32)d->sne.fst_clus_hi << 16) | d->sne.fst_clus_lo;
+ 802069cc: f9445783 lhu a5,-108(s0)
+ 802069d0: 0107979b slliw a5,a5,0x10
+ 802069d4: f9a45703 lhu a4,-102(s0)
+ 802069d8: 8fd9 or a5,a5,a4
+ 802069da: 2781 sext.w a5,a5
+ 802069dc: 10f9a223 sw a5,260(s3)
+ entry->file_size = d->sne.file_size;
+ 802069e0: f9c42703 lw a4,-100(s0)
+ 802069e4: 10e9a423 sw a4,264(s3)
+ entry->cur_clus = entry->first_clus;
+ 802069e8: 10f9a623 sw a5,268(s3)
+ entry->clus_cnt = 0;
+ 802069ec: 1009a823 sw zero,272(s3)
+ return 1;
+ 802069f0: 4505 li a0,1
+}
+ 802069f2: b5c9 j 802068b4 <enext+0x42>
+ return -1;
+ 802069f4: 557d li a0,-1
+ 802069f6: bd7d j 802068b4 <enext+0x42>
+ 802069f8: 557d li a0,-1
+ 802069fa: bd6d j 802068b4 <enext+0x42>
+
+00000000802069fc <dirlookup>:
+ * @param dp entry of a directory file
+ * @param filename target filename
+ * @param poff offset of proper empty entry slots from the beginning of the dir
+ */
+struct dirent *dirlookup(struct dirent *dp, char *filename, uint *poff)
+{
+ 802069fc: 711d addi sp,sp,-96
+ 802069fe: ec86 sd ra,88(sp)
+ 80206a00: e8a2 sd s0,80(sp)
+ 80206a02: e4a6 sd s1,72(sp)
+ 80206a04: e0ca sd s2,64(sp)
+ 80206a06: fc4e sd s3,56(sp)
+ 80206a08: f852 sd s4,48(sp)
+ 80206a0a: f456 sd s5,40(sp)
+ 80206a0c: f05a sd s6,32(sp)
+ 80206a0e: ec5e sd s7,24(sp)
+ 80206a10: 1080 addi s0,sp,96
+ if (!(dp->attribute & ATTR_DIRECTORY))
+ 80206a12: 10054783 lbu a5,256(a0)
+ 80206a16: 8bc1 andi a5,a5,16
+ 80206a18: cbb1 beqz a5,80206a6c <dirlookup+0x70>
+ 80206a1a: 84aa mv s1,a0
+ 80206a1c: 89ae mv s3,a1
+ 80206a1e: 8ab2 mv s5,a2
+ panic("dirlookup not DIR");
+ if (strncmp(filename, ".", FAT32_MAX_FILENAME) == 0) {
+ 80206a20: 0ff00613 li a2,255
+ 80206a24: 00003597 auipc a1,0x3
+ 80206a28: 46c58593 addi a1,a1,1132 # 80209e90 <digits+0xb10>
+ 80206a2c: 854e mv a0,s3
+ 80206a2e: ffffa097 auipc ra,0xffffa
+ 80206a32: e0c080e7 jalr -500(ra) # 8020083a <strncmp>
+ 80206a36: c139 beqz a0,80206a7c <dirlookup+0x80>
+ return edup(dp);
+ } else if (strncmp(filename, "..", FAT32_MAX_FILENAME) == 0) {
+ 80206a38: 0ff00613 li a2,255
+ 80206a3c: 00003597 auipc a1,0x3
+ 80206a40: 45c58593 addi a1,a1,1116 # 80209e98 <digits+0xb18>
+ 80206a44: 854e mv a0,s3
+ 80206a46: ffffa097 auipc ra,0xffffa
+ 80206a4a: df4080e7 jalr -524(ra) # 8020083a <strncmp>
+ 80206a4e: e125 bnez a0,80206aae <dirlookup+0xb2>
+ if (dp == &root) {
+ 80206a50: 00018797 auipc a5,0x18
+ 80206a54: a0078793 addi a5,a5,-1536 # 8021e450 <root>
+ 80206a58: 04f48463 beq s1,a5,80206aa0 <dirlookup+0xa4>
+ return edup(&root);
+ }
+ return edup(dp->parent);
+ 80206a5c: 1204b503 ld a0,288(s1)
+ 80206a60: 00000097 auipc ra,0x0
+ 80206a64: 9b0080e7 jalr -1616(ra) # 80206410 <edup>
+ 80206a68: 892a mv s2,a0
+ 80206a6a: a839 j 80206a88 <dirlookup+0x8c>
+ panic("dirlookup not DIR");
+ 80206a6c: 00003517 auipc a0,0x3
+ 80206a70: 40c50513 addi a0,a0,1036 # 80209e78 <digits+0xaf8>
+ 80206a74: ffff9097 auipc ra,0xffff9
+ 80206a78: 6d0080e7 jalr 1744(ra) # 80200144 <panic>
+ return edup(dp);
+ 80206a7c: 8526 mv a0,s1
+ 80206a7e: 00000097 auipc ra,0x0
+ 80206a82: 992080e7 jalr -1646(ra) # 80206410 <edup>
+ 80206a86: 892a mv s2,a0
+ if (poff) {
+ *poff = off;
+ }
+ eput(ep);
+ return NULL;
+}
+ 80206a88: 854a mv a0,s2
+ 80206a8a: 60e6 ld ra,88(sp)
+ 80206a8c: 6446 ld s0,80(sp)
+ 80206a8e: 64a6 ld s1,72(sp)
+ 80206a90: 6906 ld s2,64(sp)
+ 80206a92: 79e2 ld s3,56(sp)
+ 80206a94: 7a42 ld s4,48(sp)
+ 80206a96: 7aa2 ld s5,40(sp)
+ 80206a98: 7b02 ld s6,32(sp)
+ 80206a9a: 6be2 ld s7,24(sp)
+ 80206a9c: 6125 addi sp,sp,96
+ 80206a9e: 8082 ret
+ return edup(&root);
+ 80206aa0: 853e mv a0,a5
+ 80206aa2: 00000097 auipc ra,0x0
+ 80206aa6: 96e080e7 jalr -1682(ra) # 80206410 <edup>
+ 80206aaa: 892a mv s2,a0
+ 80206aac: bff1 j 80206a88 <dirlookup+0x8c>
+ if (dp->valid != 1) {
+ 80206aae: 11649703 lh a4,278(s1)
+ 80206ab2: 4785 li a5,1
+ return NULL;
+ 80206ab4: 4901 li s2,0
+ if (dp->valid != 1) {
+ 80206ab6: fcf719e3 bne a4,a5,80206a88 <dirlookup+0x8c>
+ struct dirent *ep = eget(dp, filename);
+ 80206aba: 85ce mv a1,s3
+ 80206abc: 8526 mv a0,s1
+ 80206abe: fffff097 auipc ra,0xfffff
+ 80206ac2: eec080e7 jalr -276(ra) # 802059aa <eget>
+ 80206ac6: 892a mv s2,a0
+ if (ep->valid == 1) { return ep; } // ecache hits
+ 80206ac8: 11651703 lh a4,278(a0)
+ 80206acc: 4785 li a5,1
+ 80206ace: faf70de3 beq a4,a5,80206a88 <dirlookup+0x8c>
+ int len = strlen(filename);
+ 80206ad2: 854e mv a0,s3
+ 80206ad4: ffffa097 auipc ra,0xffffa
+ 80206ad8: e12080e7 jalr -494(ra) # 802008e6 <strlen>
+ int count = 0;
+ 80206adc: fa042623 sw zero,-84(s0)
+ reloc_clus(dp, 0, 0);
+ 80206ae0: 4601 li a2,0
+ 80206ae2: 4581 li a1,0
+ 80206ae4: 8526 mv a0,s1
+ 80206ae6: fffff097 auipc ra,0xfffff
+ 80206aea: c70080e7 jalr -912(ra) # 80205756 <reloc_clus>
+ uint off = 0;
+ 80206aee: 4a01 li s4,0
+ while ((type = enext(dp, ep, off, &count) != -1)) {
+ 80206af0: fac40b93 addi s7,s0,-84
+ 80206af4: 5b7d li s6,-1
+ 80206af6: 86de mv a3,s7
+ 80206af8: 8652 mv a2,s4
+ 80206afa: 85ca mv a1,s2
+ 80206afc: 8526 mv a0,s1
+ 80206afe: 00000097 auipc ra,0x0
+ 80206b02: d74080e7 jalr -652(ra) # 80206872 <enext>
+ 80206b06: 03650f63 beq a0,s6,80206b44 <dirlookup+0x148>
+ } else if (strncmp(filename, ep->filename, FAT32_MAX_FILENAME) == 0) {
+ 80206b0a: 0ff00613 li a2,255
+ 80206b0e: 85ca mv a1,s2
+ 80206b10: 854e mv a0,s3
+ 80206b12: ffffa097 auipc ra,0xffffa
+ 80206b16: d28080e7 jalr -728(ra) # 8020083a <strncmp>
+ 80206b1a: c901 beqz a0,80206b2a <dirlookup+0x12e>
+ off += count << 5;
+ 80206b1c: fac42783 lw a5,-84(s0)
+ 80206b20: 0057979b slliw a5,a5,0x5
+ 80206b24: 01478a3b addw s4,a5,s4
+ 80206b28: b7f9 j 80206af6 <dirlookup+0xfa>
+ ep->parent = edup(dp);
+ 80206b2a: 8526 mv a0,s1
+ 80206b2c: 00000097 auipc ra,0x0
+ 80206b30: 8e4080e7 jalr -1820(ra) # 80206410 <edup>
+ 80206b34: 12a93023 sd a0,288(s2)
+ ep->off = off;
+ 80206b38: 11492e23 sw s4,284(s2)
+ ep->valid = 1;
+ 80206b3c: 4785 li a5,1
+ 80206b3e: 10f91b23 sh a5,278(s2)
+ return ep;
+ 80206b42: b799 j 80206a88 <dirlookup+0x8c>
+ if (poff) {
+ 80206b44: 000a8463 beqz s5,80206b4c <dirlookup+0x150>
+ *poff = off;
+ 80206b48: 014aa023 sw s4,0(s5)
+ eput(ep);
+ 80206b4c: 854a mv a0,s2
+ 80206b4e: 00000097 auipc ra,0x0
+ 80206b52: ba4080e7 jalr -1116(ra) # 802066f2 <eput>
+ return NULL;
+ 80206b56: 4901 li s2,0
+ 80206b58: bf05 j 80206a88 <dirlookup+0x8c>
+
+0000000080206b5a <ealloc>:
+{
+ 80206b5a: 715d addi sp,sp,-80
+ 80206b5c: e486 sd ra,72(sp)
+ 80206b5e: e0a2 sd s0,64(sp)
+ 80206b60: fc26 sd s1,56(sp)
+ 80206b62: f84a sd s2,48(sp)
+ 80206b64: f44e sd s3,40(sp)
+ 80206b66: f052 sd s4,32(sp)
+ 80206b68: ec56 sd s5,24(sp)
+ 80206b6a: 0880 addi s0,sp,80
+ 80206b6c: 892a mv s2,a0
+ if (!(dp->attribute & ATTR_DIRECTORY)) {
+ 80206b6e: 10054783 lbu a5,256(a0)
+ 80206b72: 8bc1 andi a5,a5,16
+ 80206b74: c7b1 beqz a5,80206bc0 <ealloc+0x66>
+ 80206b76: 852e mv a0,a1
+ 80206b78: 8a32 mv s4,a2
+ if (dp->valid != 1 || !(name = formatname(name))) { // detect illegal character
+ 80206b7a: 11691703 lh a4,278(s2)
+ 80206b7e: 4785 li a5,1
+ return NULL;
+ 80206b80: 4481 li s1,0
+ if (dp->valid != 1 || !(name = formatname(name))) { // detect illegal character
+ 80206b82: 02f71563 bne a4,a5,80206bac <ealloc+0x52>
+ 80206b86: fffff097 auipc ra,0xfffff
+ 80206b8a: 408080e7 jalr 1032(ra) # 80205f8e <formatname>
+ 80206b8e: 89aa mv s3,a0
+ 80206b90: 10050663 beqz a0,80206c9c <ealloc+0x142>
+ uint off = 0;
+ 80206b94: fa042e23 sw zero,-68(s0)
+ if ((ep = dirlookup(dp, name, &off)) != 0) { // entry exists
+ 80206b98: fbc40613 addi a2,s0,-68
+ 80206b9c: 85aa mv a1,a0
+ 80206b9e: 854a mv a0,s2
+ 80206ba0: 00000097 auipc ra,0x0
+ 80206ba4: e5c080e7 jalr -420(ra) # 802069fc <dirlookup>
+ 80206ba8: 84aa mv s1,a0
+ 80206baa: c11d beqz a0,80206bd0 <ealloc+0x76>
+}
+ 80206bac: 8526 mv a0,s1
+ 80206bae: 60a6 ld ra,72(sp)
+ 80206bb0: 6406 ld s0,64(sp)
+ 80206bb2: 74e2 ld s1,56(sp)
+ 80206bb4: 7942 ld s2,48(sp)
+ 80206bb6: 79a2 ld s3,40(sp)
+ 80206bb8: 7a02 ld s4,32(sp)
+ 80206bba: 6ae2 ld s5,24(sp)
+ 80206bbc: 6161 addi sp,sp,80
+ 80206bbe: 8082 ret
+ panic("ealloc not dir");
+ 80206bc0: 00003517 auipc a0,0x3
+ 80206bc4: 2e050513 addi a0,a0,736 # 80209ea0 <digits+0xb20>
+ 80206bc8: ffff9097 auipc ra,0xffff9
+ 80206bcc: 57c080e7 jalr 1404(ra) # 80200144 <panic>
+ ep = eget(dp, name);
+ 80206bd0: 85ce mv a1,s3
+ 80206bd2: 854a mv a0,s2
+ 80206bd4: fffff097 auipc ra,0xfffff
+ 80206bd8: dd6080e7 jalr -554(ra) # 802059aa <eget>
+ 80206bdc: 84aa mv s1,a0
+ elock(ep);
+ 80206bde: 00000097 auipc ra,0x0
+ 80206be2: a90080e7 jalr -1392(ra) # 8020666e <elock>
+ ep->attribute = attr;
+ 80206be6: 11448023 sb s4,256(s1)
+ ep->file_size = 0;
+ 80206bea: 1004a423 sw zero,264(s1)
+ ep->first_clus = 0;
+ 80206bee: 1004a223 sw zero,260(s1)
+ ep->parent = edup(dp);
+ 80206bf2: 854a mv a0,s2
+ 80206bf4: 00000097 auipc ra,0x0
+ 80206bf8: 81c080e7 jalr -2020(ra) # 80206410 <edup>
+ 80206bfc: 12a4b023 sd a0,288(s1)
+ ep->off = off;
+ 80206c00: fbc42a83 lw s5,-68(s0)
+ 80206c04: 1154ae23 sw s5,284(s1)
+ ep->clus_cnt = 0;
+ 80206c08: 1004a823 sw zero,272(s1)
+ ep->cur_clus = 0;
+ 80206c0c: 1004a623 sw zero,268(s1)
+ ep->dirty = 0;
+ 80206c10: 10048aa3 sb zero,277(s1)
+ strncpy(ep->filename, name, FAT32_MAX_FILENAME);
+ 80206c14: 0ff00613 li a2,255
+ 80206c18: 85ce mv a1,s3
+ 80206c1a: 8526 mv a0,s1
+ 80206c1c: ffffa097 auipc ra,0xffffa
+ 80206c20: c5a080e7 jalr -934(ra) # 80200876 <strncpy>
+ ep->filename[FAT32_MAX_FILENAME] = '\0';
+ 80206c24: 0e048fa3 sb zero,255(s1)
+ if (attr == ATTR_DIRECTORY) { // generate "." and ".." for ep
+ 80206c28: 47c1 li a5,16
+ 80206c2a: 02fa0863 beq s4,a5,80206c5a <ealloc+0x100>
+ ep->attribute |= ATTR_ARCHIVE;
+ 80206c2e: 1004c783 lbu a5,256(s1)
+ 80206c32: 0207e793 ori a5,a5,32
+ 80206c36: 10f48023 sb a5,256(s1)
+ emake(dp, ep, off);
+ 80206c3a: 8656 mv a2,s5
+ 80206c3c: 85a6 mv a1,s1
+ 80206c3e: 854a mv a0,s2
+ 80206c40: fffff097 auipc ra,0xfffff
+ 80206c44: 406080e7 jalr 1030(ra) # 80206046 <emake>
+ ep->valid = 1;
+ 80206c48: 4785 li a5,1
+ 80206c4a: 10f49b23 sh a5,278(s1)
+ eunlock(ep);
+ 80206c4e: 8526 mv a0,s1
+ 80206c50: 00000097 auipc ra,0x0
+ 80206c54: a54080e7 jalr -1452(ra) # 802066a4 <eunlock>
+ return ep;
+ 80206c58: bf91 j 80206bac <ealloc+0x52>
+ ep->attribute |= ATTR_DIRECTORY;
+ 80206c5a: 1004c783 lbu a5,256(s1)
+ 80206c5e: 0107e793 ori a5,a5,16
+ 80206c62: 10f48023 sb a5,256(s1)
+ ep->cur_clus = ep->first_clus = alloc_clus(dp->dev);
+ 80206c66: 11494503 lbu a0,276(s2)
+ 80206c6a: fffff097 auipc ra,0xfffff
+ 80206c6e: 92a080e7 jalr -1750(ra) # 80205594 <alloc_clus>
+ 80206c72: 2501 sext.w a0,a0
+ 80206c74: 10a4a223 sw a0,260(s1)
+ 80206c78: 10a4a623 sw a0,268(s1)
+ emake(ep, ep, 0);
+ 80206c7c: 4601 li a2,0
+ 80206c7e: 85a6 mv a1,s1
+ 80206c80: 8526 mv a0,s1
+ 80206c82: fffff097 auipc ra,0xfffff
+ 80206c86: 3c4080e7 jalr 964(ra) # 80206046 <emake>
+ emake(ep, dp, 32);
+ 80206c8a: 02000613 li a2,32
+ 80206c8e: 85ca mv a1,s2
+ 80206c90: 8526 mv a0,s1
+ 80206c92: fffff097 auipc ra,0xfffff
+ 80206c96: 3b4080e7 jalr 948(ra) # 80206046 <emake>
+ 80206c9a: b745 j 80206c3a <ealloc+0xe0>
+ return NULL;
+ 80206c9c: 84aa mv s1,a0
+ 80206c9e: b739 j 80206bac <ealloc+0x52>
+
+0000000080206ca0 <lookup_path>:
+ return path;
+}
+
+// FAT32 version of namex in xv6's original file system.
+static struct dirent *lookup_path(char *path, int parent, char *name)
+{
+ 80206ca0: 715d addi sp,sp,-80
+ 80206ca2: e486 sd ra,72(sp)
+ 80206ca4: e0a2 sd s0,64(sp)
+ 80206ca6: fc26 sd s1,56(sp)
+ 80206ca8: f84a sd s2,48(sp)
+ 80206caa: f44e sd s3,40(sp)
+ 80206cac: f052 sd s4,32(sp)
+ 80206cae: ec56 sd s5,24(sp)
+ 80206cb0: e85a sd s6,16(sp)
+ 80206cb2: e45e sd s7,8(sp)
+ 80206cb4: e062 sd s8,0(sp)
+ 80206cb6: 0880 addi s0,sp,80
+ 80206cb8: 892a mv s2,a0
+ 80206cba: 8b2e mv s6,a1
+ 80206cbc: 8ab2 mv s5,a2
+ struct dirent *entry, *next;
+ if (*path == '/') {
+ 80206cbe: 00054783 lbu a5,0(a0)
+ 80206cc2: 02f00713 li a4,47
+ 80206cc6: 02e78663 beq a5,a4,80206cf2 <lookup_path+0x52>
+ entry = edup(&root);
+ } else if (*path != '\0') {
+ entry = edup(myproc()->cwd);
+ } else {
+ return NULL;
+ 80206cca: 4a01 li s4,0
+ } else if (*path != '\0') {
+ 80206ccc: cba1 beqz a5,80206d1c <lookup_path+0x7c>
+ entry = edup(myproc()->cwd);
+ 80206cce: ffffb097 auipc ra,0xffffb
+ 80206cd2: d6e080e7 jalr -658(ra) # 80201a3c <myproc>
+ 80206cd6: 15853503 ld a0,344(a0)
+ 80206cda: fffff097 auipc ra,0xfffff
+ 80206cde: 736080e7 jalr 1846(ra) # 80206410 <edup>
+ 80206ce2: 8a2a mv s4,a0
+ while (*path == '/') {
+ 80206ce4: 02f00993 li s3,47
+ 80206ce8: 0ff00b93 li s7,255
+ 80206cec: 0ff00c13 li s8,255
+ 80206cf0: a0e5 j 80206dd8 <lookup_path+0x138>
+ entry = edup(&root);
+ 80206cf2: 00017517 auipc a0,0x17
+ 80206cf6: 75e50513 addi a0,a0,1886 # 8021e450 <root>
+ 80206cfa: fffff097 auipc ra,0xfffff
+ 80206cfe: 716080e7 jalr 1814(ra) # 80206410 <edup>
+ 80206d02: 8a2a mv s4,a0
+ 80206d04: b7c5 j 80206ce4 <lookup_path+0x44>
+ }
+ while ((path = skipelem(path, name)) != 0) {
+ elock(entry);
+ if (!(entry->attribute & ATTR_DIRECTORY)) {
+ eunlock(entry);
+ 80206d06: 8552 mv a0,s4
+ 80206d08: 00000097 auipc ra,0x0
+ 80206d0c: 99c080e7 jalr -1636(ra) # 802066a4 <eunlock>
+ eput(entry);
+ 80206d10: 8552 mv a0,s4
+ 80206d12: 00000097 auipc ra,0x0
+ 80206d16: 9e0080e7 jalr -1568(ra) # 802066f2 <eput>
+ return NULL;
+ 80206d1a: 4a01 li s4,0
+ if (parent) {
+ eput(entry);
+ return NULL;
+ }
+ return entry;
+}
+ 80206d1c: 8552 mv a0,s4
+ 80206d1e: 60a6 ld ra,72(sp)
+ 80206d20: 6406 ld s0,64(sp)
+ 80206d22: 74e2 ld s1,56(sp)
+ 80206d24: 7942 ld s2,48(sp)
+ 80206d26: 79a2 ld s3,40(sp)
+ 80206d28: 7a02 ld s4,32(sp)
+ 80206d2a: 6ae2 ld s5,24(sp)
+ 80206d2c: 6b42 ld s6,16(sp)
+ 80206d2e: 6ba2 ld s7,8(sp)
+ 80206d30: 6c02 ld s8,0(sp)
+ 80206d32: 6161 addi sp,sp,80
+ 80206d34: 8082 ret
+ eunlock(entry);
+ 80206d36: 8552 mv a0,s4
+ 80206d38: 00000097 auipc ra,0x0
+ 80206d3c: 96c080e7 jalr -1684(ra) # 802066a4 <eunlock>
+ return entry;
+ 80206d40: bff1 j 80206d1c <lookup_path+0x7c>
+ eunlock(entry);
+ 80206d42: 8552 mv a0,s4
+ 80206d44: 00000097 auipc ra,0x0
+ 80206d48: 960080e7 jalr -1696(ra) # 802066a4 <eunlock>
+ eput(entry);
+ 80206d4c: 8552 mv a0,s4
+ 80206d4e: 00000097 auipc ra,0x0
+ 80206d52: 9a4080e7 jalr -1628(ra) # 802066f2 <eput>
+ return NULL;
+ 80206d56: 8a4a mv s4,s2
+ 80206d58: b7d1 j 80206d1c <lookup_path+0x7c>
+ int len = path - s;
+ 80206d5a: 412487b3 sub a5,s1,s2
+ 80206d5e: 863e mv a2,a5
+ 80206d60: 2781 sext.w a5,a5
+ 80206d62: 00fbd363 bge s7,a5,80206d68 <lookup_path+0xc8>
+ 80206d66: 8662 mv a2,s8
+ 80206d68: 0006079b sext.w a5,a2
+ name[len] = 0;
+ 80206d6c: 97d6 add a5,a5,s5
+ 80206d6e: 00078023 sb zero,0(a5)
+ memmove(name, s, len);
+ 80206d72: 2601 sext.w a2,a2
+ 80206d74: 85ca mv a1,s2
+ 80206d76: 8556 mv a0,s5
+ 80206d78: ffffa097 auipc ra,0xffffa
+ 80206d7c: a46080e7 jalr -1466(ra) # 802007be <memmove>
+ while (*path == '/') {
+ 80206d80: 0004c783 lbu a5,0(s1)
+ 80206d84: 01379763 bne a5,s3,80206d92 <lookup_path+0xf2>
+ path++;
+ 80206d88: 0485 addi s1,s1,1
+ while (*path == '/') {
+ 80206d8a: 0004c783 lbu a5,0(s1)
+ 80206d8e: ff378de3 beq a5,s3,80206d88 <lookup_path+0xe8>
+ elock(entry);
+ 80206d92: 8552 mv a0,s4
+ 80206d94: 00000097 auipc ra,0x0
+ 80206d98: 8da080e7 jalr -1830(ra) # 8020666e <elock>
+ if (!(entry->attribute & ATTR_DIRECTORY)) {
+ 80206d9c: 100a4783 lbu a5,256(s4)
+ 80206da0: 8bc1 andi a5,a5,16
+ 80206da2: d3b5 beqz a5,80206d06 <lookup_path+0x66>
+ if (parent && *path == '\0') {
+ 80206da4: 000b0563 beqz s6,80206dae <lookup_path+0x10e>
+ 80206da8: 0004c783 lbu a5,0(s1)
+ 80206dac: d7c9 beqz a5,80206d36 <lookup_path+0x96>
+ if ((next = dirlookup(entry, name, 0)) == 0) {
+ 80206dae: 4601 li a2,0
+ 80206db0: 85d6 mv a1,s5
+ 80206db2: 8552 mv a0,s4
+ 80206db4: 00000097 auipc ra,0x0
+ 80206db8: c48080e7 jalr -952(ra) # 802069fc <dirlookup>
+ 80206dbc: 892a mv s2,a0
+ 80206dbe: d151 beqz a0,80206d42 <lookup_path+0xa2>
+ eunlock(entry);
+ 80206dc0: 8552 mv a0,s4
+ 80206dc2: 00000097 auipc ra,0x0
+ 80206dc6: 8e2080e7 jalr -1822(ra) # 802066a4 <eunlock>
+ eput(entry);
+ 80206dca: 8552 mv a0,s4
+ 80206dcc: 00000097 auipc ra,0x0
+ 80206dd0: 926080e7 jalr -1754(ra) # 802066f2 <eput>
+ entry = next;
+ 80206dd4: 8a4a mv s4,s2
+ eput(entry);
+ 80206dd6: 8926 mv s2,s1
+ while (*path == '/') {
+ 80206dd8: 00094783 lbu a5,0(s2)
+ 80206ddc: 03379363 bne a5,s3,80206e02 <lookup_path+0x162>
+ path++;
+ 80206de0: 0905 addi s2,s2,1
+ while (*path == '/') {
+ 80206de2: 00094783 lbu a5,0(s2)
+ 80206de6: ff378de3 beq a5,s3,80206de0 <lookup_path+0x140>
+ if (*path == 0) { return NULL; }
+ 80206dea: cf89 beqz a5,80206e04 <lookup_path+0x164>
+ path++;
+ 80206dec: 84ca mv s1,s2
+ while (*path != '/' && *path != 0) {
+ 80206dee: f73786e3 beq a5,s3,80206d5a <lookup_path+0xba>
+ eput(entry);
+ 80206df2: 84ca mv s1,s2
+ while (*path != '/' && *path != 0) {
+ 80206df4: d3bd beqz a5,80206d5a <lookup_path+0xba>
+ path++;
+ 80206df6: 0485 addi s1,s1,1
+ while (*path != '/' && *path != 0) {
+ 80206df8: 0004c783 lbu a5,0(s1)
+ 80206dfc: ff379ce3 bne a5,s3,80206df4 <lookup_path+0x154>
+ 80206e00: bfa9 j 80206d5a <lookup_path+0xba>
+ if (*path == 0) { return NULL; }
+ 80206e02: fbe5 bnez a5,80206df2 <lookup_path+0x152>
+ if (parent) {
+ 80206e04: f00b0ce3 beqz s6,80206d1c <lookup_path+0x7c>
+ eput(entry);
+ 80206e08: 8552 mv a0,s4
+ 80206e0a: 00000097 auipc ra,0x0
+ 80206e0e: 8e8080e7 jalr -1816(ra) # 802066f2 <eput>
+ return NULL;
+ 80206e12: 4a01 li s4,0
+ 80206e14: b721 j 80206d1c <lookup_path+0x7c>
+
+0000000080206e16 <ename>:
+
+struct dirent *ename(char *path)
+{
+ 80206e16: 716d addi sp,sp,-272
+ 80206e18: e606 sd ra,264(sp)
+ 80206e1a: e222 sd s0,256(sp)
+ 80206e1c: 0a00 addi s0,sp,272
+ char name[FAT32_MAX_FILENAME + 1];
+ return lookup_path(path, 0, name);
+ 80206e1e: ef040613 addi a2,s0,-272
+ 80206e22: 4581 li a1,0
+ 80206e24: 00000097 auipc ra,0x0
+ 80206e28: e7c080e7 jalr -388(ra) # 80206ca0 <lookup_path>
+}
+ 80206e2c: 60b2 ld ra,264(sp)
+ 80206e2e: 6412 ld s0,256(sp)
+ 80206e30: 6151 addi sp,sp,272
+ 80206e32: 8082 ret
+
+0000000080206e34 <enameparent>:
+
+struct dirent *enameparent(char *path, char *name)
+{
+ 80206e34: 1141 addi sp,sp,-16
+ 80206e36: e406 sd ra,8(sp)
+ 80206e38: e022 sd s0,0(sp)
+ 80206e3a: 0800 addi s0,sp,16
+ 80206e3c: 862e mv a2,a1
+ return lookup_path(path, 1, name);
+ 80206e3e: 4585 li a1,1
+ 80206e40: 00000097 auipc ra,0x0
+ 80206e44: e60080e7 jalr -416(ra) # 80206ca0 <lookup_path>
+}
+ 80206e48: 60a2 ld ra,8(sp)
+ 80206e4a: 6402 ld s0,0(sp)
+ 80206e4c: 0141 addi sp,sp,16
+ 80206e4e: 8082 ret
+
+0000000080206e50 <plicinit>:
+
+//
+// the riscv Platform Level Interrupt Controller (PLIC).
+//
+
+void plicinit(void) {
+ 80206e50: 1141 addi sp,sp,-16
+ 80206e52: e422 sd s0,8(sp)
+ 80206e54: 0800 addi s0,sp,16
+ writed(1, PLIC_V + DISK_IRQ * sizeof(uint32));
+ 80206e56: 00fc37b7 lui a5,0xfc3
+ 80206e5a: 07ba slli a5,a5,0xe
+ 80206e5c: 4705 li a4,1
+ 80206e5e: c3d8 sw a4,4(a5)
+ writed(1, PLIC_V + UART_IRQ * sizeof(uint32));
+ 80206e60: d798 sw a4,40(a5)
+
+ #ifdef DEBUG
+ printf("plicinit\n");
+ #endif
+}
+ 80206e62: 6422 ld s0,8(sp)
+ 80206e64: 0141 addi sp,sp,16
+ 80206e66: 8082 ret
+
+0000000080206e68 <plicinithart>:
+
+void
+plicinithart(void)
+{
+ 80206e68: 1141 addi sp,sp,-16
+ 80206e6a: e406 sd ra,8(sp)
+ 80206e6c: e022 sd s0,0(sp)
+ 80206e6e: 0800 addi s0,sp,16
+ int hart = cpuid();
+ 80206e70: ffffb097 auipc ra,0xffffb
+ 80206e74: ba0080e7 jalr -1120(ra) # 80201a10 <cpuid>
+ #ifdef QEMU
+ // set uart's enable bit for this hart's S-mode.
+ *(uint32*)PLIC_SENABLE(hart)= (1 << UART_IRQ) | (1 << DISK_IRQ);
+ 80206e78: 0085171b slliw a4,a0,0x8
+ 80206e7c: 01f867b7 lui a5,0x1f86
+ 80206e80: 0785 addi a5,a5,1 # 1f86001 <_entry-0x7e279fff>
+ 80206e82: 07b6 slli a5,a5,0xd
+ 80206e84: 97ba add a5,a5,a4
+ 80206e86: 40200713 li a4,1026
+ 80206e8a: 08e7a023 sw a4,128(a5)
+ // set this hart's S-mode priority threshold to 0.
+ *(uint32*)PLIC_SPRIORITY(hart) = 0;
+ 80206e8e: 00d5151b slliw a0,a0,0xd
+ 80206e92: 03f0c7b7 lui a5,0x3f0c
+ 80206e96: 20178793 addi a5,a5,513 # 3f0c201 <_entry-0x7c2f3dff>
+ 80206e9a: 07b2 slli a5,a5,0xc
+ 80206e9c: 97aa add a5,a5,a0
+ 80206e9e: 0007a023 sw zero,0(a5)
+ *(hart0_m_int_enable_hi) = readd(hart0_m_int_enable_hi) | (1 << (UART_IRQ % 32));
+ #endif
+ #ifdef DEBUG
+ printf("plicinithart\n");
+ #endif
+}
+ 80206ea2: 60a2 ld ra,8(sp)
+ 80206ea4: 6402 ld s0,0(sp)
+ 80206ea6: 0141 addi sp,sp,16
+ 80206ea8: 8082 ret
+
+0000000080206eaa <plic_claim>:
+
+// ask the PLIC what interrupt we should serve.
+int
+plic_claim(void)
+{
+ 80206eaa: 1141 addi sp,sp,-16
+ 80206eac: e406 sd ra,8(sp)
+ 80206eae: e022 sd s0,0(sp)
+ 80206eb0: 0800 addi s0,sp,16
+ int hart = cpuid();
+ 80206eb2: ffffb097 auipc ra,0xffffb
+ 80206eb6: b5e080e7 jalr -1186(ra) # 80201a10 <cpuid>
+ int irq;
+ #ifndef QEMU
+ irq = *(uint32*)PLIC_MCLAIM(hart);
+ #else
+ irq = *(uint32*)PLIC_SCLAIM(hart);
+ 80206eba: 00d5151b slliw a0,a0,0xd
+ 80206ebe: 03f0c7b7 lui a5,0x3f0c
+ 80206ec2: 20178793 addi a5,a5,513 # 3f0c201 <_entry-0x7c2f3dff>
+ 80206ec6: 07b2 slli a5,a5,0xc
+ 80206ec8: 97aa add a5,a5,a0
+ #endif
+ return irq;
+}
+ 80206eca: 43c8 lw a0,4(a5)
+ 80206ecc: 60a2 ld ra,8(sp)
+ 80206ece: 6402 ld s0,0(sp)
+ 80206ed0: 0141 addi sp,sp,16
+ 80206ed2: 8082 ret
+
+0000000080206ed4 <plic_complete>:
+
+// tell the PLIC we've served this IRQ.
+void
+plic_complete(int irq)
+{
+ 80206ed4: 1101 addi sp,sp,-32
+ 80206ed6: ec06 sd ra,24(sp)
+ 80206ed8: e822 sd s0,16(sp)
+ 80206eda: e426 sd s1,8(sp)
+ 80206edc: 1000 addi s0,sp,32
+ 80206ede: 84aa mv s1,a0
+ int hart = cpuid();
+ 80206ee0: ffffb097 auipc ra,0xffffb
+ 80206ee4: b30080e7 jalr -1232(ra) # 80201a10 <cpuid>
+ #ifndef QEMU
+ *(uint32*)PLIC_MCLAIM(hart) = irq;
+ #else
+ *(uint32*)PLIC_SCLAIM(hart) = irq;
+ 80206ee8: 00d5151b slliw a0,a0,0xd
+ 80206eec: 03f0c7b7 lui a5,0x3f0c
+ 80206ef0: 20178793 addi a5,a5,513 # 3f0c201 <_entry-0x7c2f3dff>
+ 80206ef4: 07b2 slli a5,a5,0xc
+ 80206ef6: 97aa add a5,a5,a0
+ 80206ef8: c3c4 sw s1,4(a5)
+ #endif
+}
+ 80206efa: 60e2 ld ra,24(sp)
+ 80206efc: 6442 ld s0,16(sp)
+ 80206efe: 64a2 ld s1,8(sp)
+ 80206f00: 6105 addi sp,sp,32
+ 80206f02: 8082 ret
+
+0000000080206f04 <consolewrite>:
+//
+// user write()s to the console go here.
+//
+int
+consolewrite(int user_src, uint64 src, int n)
+{
+ 80206f04: 715d addi sp,sp,-80
+ 80206f06: e486 sd ra,72(sp)
+ 80206f08: e0a2 sd s0,64(sp)
+ 80206f0a: fc26 sd s1,56(sp)
+ 80206f0c: f84a sd s2,48(sp)
+ 80206f0e: f44e sd s3,40(sp)
+ 80206f10: f052 sd s4,32(sp)
+ 80206f12: ec56 sd s5,24(sp)
+ 80206f14: e85a sd s6,16(sp)
+ 80206f16: 0880 addi s0,sp,80
+ 80206f18: 8a2a mv s4,a0
+ 80206f1a: 84ae mv s1,a1
+ 80206f1c: 89b2 mv s3,a2
+ int i;
+
+ acquire(&cons.lock);
+ 80206f1e: 0001c517 auipc a0,0x1c
+ 80206f22: d0250513 addi a0,a0,-766 # 80222c20 <cons>
+ 80206f26: ffff9097 auipc ra,0xffff9
+ 80206f2a: 7a0080e7 jalr 1952(ra) # 802006c6 <acquire>
+ for(i = 0; i < n; i++){
+ 80206f2e: 07305063 blez s3,80206f8e <consolewrite+0x8a>
+ 80206f32: 4901 li s2,0
+ char c;
+ if(either_copyin(&c, user_src, src+i, 1) == -1)
+ 80206f34: fbf40b13 addi s6,s0,-65
+ 80206f38: 5afd li s5,-1
+ 80206f3a: 4685 li a3,1
+ 80206f3c: 8626 mv a2,s1
+ 80206f3e: 85d2 mv a1,s4
+ 80206f40: 855a mv a0,s6
+ 80206f42: ffffc097 auipc ra,0xffffc
+ 80206f46: 85a080e7 jalr -1958(ra) # 8020279c <either_copyin>
+ 80206f4a: 01550f63 beq a0,s5,80206f68 <consolewrite+0x64>
+ SBI_CALL_1(SBI_CONSOLE_PUTCHAR, ch);
+ 80206f4e: fbf44503 lbu a0,-65(s0)
+ 80206f52: 4581 li a1,0
+ 80206f54: 4601 li a2,0
+ 80206f56: 4681 li a3,0
+ 80206f58: 4885 li a7,1
+ 80206f5a: 00000073 ecall
+ for(i = 0; i < n; i++){
+ 80206f5e: 2905 addiw s2,s2,1
+ 80206f60: 0485 addi s1,s1,1
+ 80206f62: fd299ce3 bne s3,s2,80206f3a <consolewrite+0x36>
+ 80206f66: 894e mv s2,s3
+ break;
+ sbi_console_putchar(c);
+ }
+ release(&cons.lock);
+ 80206f68: 0001c517 auipc a0,0x1c
+ 80206f6c: cb850513 addi a0,a0,-840 # 80222c20 <cons>
+ 80206f70: ffff9097 auipc ra,0xffff9
+ 80206f74: 7aa080e7 jalr 1962(ra) # 8020071a <release>
+
+ return i;
+}
+ 80206f78: 854a mv a0,s2
+ 80206f7a: 60a6 ld ra,72(sp)
+ 80206f7c: 6406 ld s0,64(sp)
+ 80206f7e: 74e2 ld s1,56(sp)
+ 80206f80: 7942 ld s2,48(sp)
+ 80206f82: 79a2 ld s3,40(sp)
+ 80206f84: 7a02 ld s4,32(sp)
+ 80206f86: 6ae2 ld s5,24(sp)
+ 80206f88: 6b42 ld s6,16(sp)
+ 80206f8a: 6161 addi sp,sp,80
+ 80206f8c: 8082 ret
+ for(i = 0; i < n; i++){
+ 80206f8e: 4901 li s2,0
+ 80206f90: bfe1 j 80206f68 <consolewrite+0x64>
+
+0000000080206f92 <consoleread>:
+// user_dist indicates whether dst is a user
+// or kernel address.
+//
+int
+consoleread(int user_dst, uint64 dst, int n)
+{
+ 80206f92: 7119 addi sp,sp,-128
+ 80206f94: fc86 sd ra,120(sp)
+ 80206f96: f8a2 sd s0,112(sp)
+ 80206f98: f4a6 sd s1,104(sp)
+ 80206f9a: f0ca sd s2,96(sp)
+ 80206f9c: ecce sd s3,88(sp)
+ 80206f9e: e8d2 sd s4,80(sp)
+ 80206fa0: e4d6 sd s5,72(sp)
+ 80206fa2: e0da sd s6,64(sp)
+ 80206fa4: fc5e sd s7,56(sp)
+ 80206fa6: f862 sd s8,48(sp)
+ 80206fa8: f466 sd s9,40(sp)
+ 80206faa: f06a sd s10,32(sp)
+ 80206fac: ec6e sd s11,24(sp)
+ 80206fae: 0100 addi s0,sp,128
+ 80206fb0: 8aaa mv s5,a0
+ 80206fb2: 8a2e mv s4,a1
+ 80206fb4: 89b2 mv s3,a2
+ uint target;
+ int c;
+ char cbuf;
+
+ target = n;
+ 80206fb6: 00060b1b sext.w s6,a2
+ acquire(&cons.lock);
+ 80206fba: 0001c517 auipc a0,0x1c
+ 80206fbe: c6650513 addi a0,a0,-922 # 80222c20 <cons>
+ 80206fc2: ffff9097 auipc ra,0xffff9
+ 80206fc6: 704080e7 jalr 1796(ra) # 802006c6 <acquire>
+ while(n > 0){
+ // wait until interrupt handler has put some
+ // input into cons.buffer.
+ while(cons.r == cons.w){
+ 80206fca: 0001c497 auipc s1,0x1c
+ 80206fce: c5648493 addi s1,s1,-938 # 80222c20 <cons>
+ if(myproc()->killed){
+ release(&cons.lock);
+ return -1;
+ }
+ sleep(&cons.r, &cons.lock);
+ 80206fd2: 0001c917 auipc s2,0x1c
+ 80206fd6: ce690913 addi s2,s2,-794 # 80222cb8 <cons+0x98>
+ }
+
+ c = cons.buf[cons.r++ % INPUT_BUF];
+
+ if(c == C('D')){ // end-of-file
+ 80206fda: 4c11 li s8,4
+ break;
+ }
+
+ // copy the input byte to the user-space buffer.
+ cbuf = c;
+ if(either_copyout(user_dst, dst, &cbuf, 1) == -1)
+ 80206fdc: f8f40d13 addi s10,s0,-113
+ 80206fe0: 5cfd li s9,-1
+ break;
+
+ dst++;
+ --n;
+
+ if(c == '\n'){
+ 80206fe2: 4da9 li s11,10
+ while(n > 0){
+ 80206fe4: 07305763 blez s3,80207052 <consoleread+0xc0>
+ while(cons.r == cons.w){
+ 80206fe8: 0984a783 lw a5,152(s1)
+ 80206fec: 09c4a703 lw a4,156(s1)
+ 80206ff0: 02f71463 bne a4,a5,80207018 <consoleread+0x86>
+ if(myproc()->killed){
+ 80206ff4: ffffb097 auipc ra,0xffffb
+ 80206ff8: a48080e7 jalr -1464(ra) # 80201a3c <myproc>
+ 80206ffc: 591c lw a5,48(a0)
+ 80206ffe: e7ad bnez a5,80207068 <consoleread+0xd6>
+ sleep(&cons.r, &cons.lock);
+ 80207000: 85a6 mv a1,s1
+ 80207002: 854a mv a0,s2
+ 80207004: ffffb097 auipc ra,0xffffb
+ 80207008: 3f0080e7 jalr 1008(ra) # 802023f4 <sleep>
+ while(cons.r == cons.w){
+ 8020700c: 0984a783 lw a5,152(s1)
+ 80207010: 09c4a703 lw a4,156(s1)
+ 80207014: fef700e3 beq a4,a5,80206ff4 <consoleread+0x62>
+ c = cons.buf[cons.r++ % INPUT_BUF];
+ 80207018: 0017871b addiw a4,a5,1
+ 8020701c: 08e4ac23 sw a4,152(s1)
+ 80207020: 07f7f713 andi a4,a5,127
+ 80207024: 9726 add a4,a4,s1
+ 80207026: 01874703 lbu a4,24(a4)
+ 8020702a: 00070b9b sext.w s7,a4
+ if(c == C('D')){ // end-of-file
+ 8020702e: 078b8563 beq s7,s8,80207098 <consoleread+0x106>
+ cbuf = c;
+ 80207032: f8e407a3 sb a4,-113(s0)
+ if(either_copyout(user_dst, dst, &cbuf, 1) == -1)
+ 80207036: 4685 li a3,1
+ 80207038: 866a mv a2,s10
+ 8020703a: 85d2 mv a1,s4
+ 8020703c: 8556 mv a0,s5
+ 8020703e: ffffb097 auipc ra,0xffffb
+ 80207042: 728080e7 jalr 1832(ra) # 80202766 <either_copyout>
+ 80207046: 01950663 beq a0,s9,80207052 <consoleread+0xc0>
+ dst++;
+ 8020704a: 0a05 addi s4,s4,1
+ --n;
+ 8020704c: 39fd addiw s3,s3,-1
+ if(c == '\n'){
+ 8020704e: f9bb9be3 bne s7,s11,80206fe4 <consoleread+0x52>
+ // a whole line has arrived, return to
+ // the user-level read().
+ break;
+ }
+ }
+ release(&cons.lock);
+ 80207052: 0001c517 auipc a0,0x1c
+ 80207056: bce50513 addi a0,a0,-1074 # 80222c20 <cons>
+ 8020705a: ffff9097 auipc ra,0xffff9
+ 8020705e: 6c0080e7 jalr 1728(ra) # 8020071a <release>
+
+ return target - n;
+ 80207062: 413b053b subw a0,s6,s3
+ 80207066: a811 j 8020707a <consoleread+0xe8>
+ release(&cons.lock);
+ 80207068: 0001c517 auipc a0,0x1c
+ 8020706c: bb850513 addi a0,a0,-1096 # 80222c20 <cons>
+ 80207070: ffff9097 auipc ra,0xffff9
+ 80207074: 6aa080e7 jalr 1706(ra) # 8020071a <release>
+ return -1;
+ 80207078: 557d li a0,-1
+}
+ 8020707a: 70e6 ld ra,120(sp)
+ 8020707c: 7446 ld s0,112(sp)
+ 8020707e: 74a6 ld s1,104(sp)
+ 80207080: 7906 ld s2,96(sp)
+ 80207082: 69e6 ld s3,88(sp)
+ 80207084: 6a46 ld s4,80(sp)
+ 80207086: 6aa6 ld s5,72(sp)
+ 80207088: 6b06 ld s6,64(sp)
+ 8020708a: 7be2 ld s7,56(sp)
+ 8020708c: 7c42 ld s8,48(sp)
+ 8020708e: 7ca2 ld s9,40(sp)
+ 80207090: 7d02 ld s10,32(sp)
+ 80207092: 6de2 ld s11,24(sp)
+ 80207094: 6109 addi sp,sp,128
+ 80207096: 8082 ret
+ if(n < target){
+ 80207098: 0009871b sext.w a4,s3
+ 8020709c: fb677be3 bgeu a4,s6,80207052 <consoleread+0xc0>
+ cons.r--;
+ 802070a0: 0001c717 auipc a4,0x1c
+ 802070a4: c0f72c23 sw a5,-1000(a4) # 80222cb8 <cons+0x98>
+ 802070a8: b76d j 80207052 <consoleread+0xc0>
+
+00000000802070aa <consputc>:
+void consputc(int c) {
+ 802070aa: 1141 addi sp,sp,-16
+ 802070ac: e422 sd s0,8(sp)
+ 802070ae: 0800 addi s0,sp,16
+ if(c == BACKSPACE){
+ 802070b0: 10000793 li a5,256
+ 802070b4: 00f50b63 beq a0,a5,802070ca <consputc+0x20>
+ 802070b8: 4581 li a1,0
+ 802070ba: 4601 li a2,0
+ 802070bc: 4681 li a3,0
+ 802070be: 4885 li a7,1
+ 802070c0: 00000073 ecall
+}
+ 802070c4: 6422 ld s0,8(sp)
+ 802070c6: 0141 addi sp,sp,16
+ 802070c8: 8082 ret
+ 802070ca: 4521 li a0,8
+ 802070cc: 4581 li a1,0
+ 802070ce: 4601 li a2,0
+ 802070d0: 4681 li a3,0
+ 802070d2: 4885 li a7,1
+ 802070d4: 00000073 ecall
+ 802070d8: 02000513 li a0,32
+ 802070dc: 00000073 ecall
+ 802070e0: 4521 li a0,8
+ 802070e2: 00000073 ecall
+}
+ 802070e6: bff9 j 802070c4 <consputc+0x1a>
+
+00000000802070e8 <consoleintr>:
+// do erase/kill processing, append to cons.buf,
+// wake up consoleread() if a whole line has arrived.
+//
+void
+consoleintr(int c)
+{
+ 802070e8: 1101 addi sp,sp,-32
+ 802070ea: ec06 sd ra,24(sp)
+ 802070ec: e822 sd s0,16(sp)
+ 802070ee: e426 sd s1,8(sp)
+ 802070f0: e04a sd s2,0(sp)
+ 802070f2: 1000 addi s0,sp,32
+ 802070f4: 84aa mv s1,a0
+ acquire(&cons.lock);
+ 802070f6: 0001c517 auipc a0,0x1c
+ 802070fa: b2a50513 addi a0,a0,-1238 # 80222c20 <cons>
+ 802070fe: ffff9097 auipc ra,0xffff9
+ 80207102: 5c8080e7 jalr 1480(ra) # 802006c6 <acquire>
+
+ switch(c){
+ 80207106: 47d5 li a5,21
+ 80207108: 0af48663 beq s1,a5,802071b4 <consoleintr+0xcc>
+ 8020710c: 0297ca63 blt a5,s1,80207140 <consoleintr+0x58>
+ 80207110: 47a1 li a5,8
+ 80207112: 0ef48763 beq s1,a5,80207200 <consoleintr+0x118>
+ 80207116: 47c1 li a5,16
+ 80207118: 10f49a63 bne s1,a5,8020722c <consoleintr+0x144>
+ case C('P'): // Print process list.
+ procdump();
+ 8020711c: ffffb097 auipc ra,0xffffb
+ 80207120: 6b4080e7 jalr 1716(ra) # 802027d0 <procdump>
+ }
+ }
+ break;
+ }
+
+ release(&cons.lock);
+ 80207124: 0001c517 auipc a0,0x1c
+ 80207128: afc50513 addi a0,a0,-1284 # 80222c20 <cons>
+ 8020712c: ffff9097 auipc ra,0xffff9
+ 80207130: 5ee080e7 jalr 1518(ra) # 8020071a <release>
+}
+ 80207134: 60e2 ld ra,24(sp)
+ 80207136: 6442 ld s0,16(sp)
+ 80207138: 64a2 ld s1,8(sp)
+ 8020713a: 6902 ld s2,0(sp)
+ 8020713c: 6105 addi sp,sp,32
+ 8020713e: 8082 ret
+ switch(c){
+ 80207140: 07f00793 li a5,127
+ 80207144: 0af48e63 beq s1,a5,80207200 <consoleintr+0x118>
+ if(c != 0 && cons.e-cons.r < INPUT_BUF){
+ 80207148: 0001c717 auipc a4,0x1c
+ 8020714c: ad870713 addi a4,a4,-1320 # 80222c20 <cons>
+ 80207150: 0a072783 lw a5,160(a4)
+ 80207154: 09872703 lw a4,152(a4)
+ 80207158: 9f99 subw a5,a5,a4
+ 8020715a: 07f00713 li a4,127
+ 8020715e: fcf763e3 bltu a4,a5,80207124 <consoleintr+0x3c>
+ c = (c == '\r') ? '\n' : c;
+ 80207162: 47b5 li a5,13
+ 80207164: 0cf48763 beq s1,a5,80207232 <consoleintr+0x14a>
+ consputc(c);
+ 80207168: 8526 mv a0,s1
+ 8020716a: 00000097 auipc ra,0x0
+ 8020716e: f40080e7 jalr -192(ra) # 802070aa <consputc>
+ cons.buf[cons.e++ % INPUT_BUF] = c;
+ 80207172: 0001c797 auipc a5,0x1c
+ 80207176: aae78793 addi a5,a5,-1362 # 80222c20 <cons>
+ 8020717a: 0a07a703 lw a4,160(a5)
+ 8020717e: 0017069b addiw a3,a4,1
+ 80207182: 0006861b sext.w a2,a3
+ 80207186: 0ad7a023 sw a3,160(a5)
+ 8020718a: 07f77713 andi a4,a4,127
+ 8020718e: 97ba add a5,a5,a4
+ 80207190: 00978c23 sb s1,24(a5)
+ if(c == '\n' || c == C('D') || cons.e == cons.r+INPUT_BUF){
+ 80207194: 47a9 li a5,10
+ 80207196: 0cf48563 beq s1,a5,80207260 <consoleintr+0x178>
+ 8020719a: 4791 li a5,4
+ 8020719c: 0cf48263 beq s1,a5,80207260 <consoleintr+0x178>
+ 802071a0: 0001c797 auipc a5,0x1c
+ 802071a4: b187a783 lw a5,-1256(a5) # 80222cb8 <cons+0x98>
+ 802071a8: 0807879b addiw a5,a5,128
+ 802071ac: f6f61ce3 bne a2,a5,80207124 <consoleintr+0x3c>
+ cons.buf[cons.e++ % INPUT_BUF] = c;
+ 802071b0: 863e mv a2,a5
+ 802071b2: a07d j 80207260 <consoleintr+0x178>
+ while(cons.e != cons.w &&
+ 802071b4: 0001c717 auipc a4,0x1c
+ 802071b8: a6c70713 addi a4,a4,-1428 # 80222c20 <cons>
+ 802071bc: 0a072783 lw a5,160(a4)
+ 802071c0: 09c72703 lw a4,156(a4)
+ cons.buf[(cons.e-1) % INPUT_BUF] != '\n'){
+ 802071c4: 0001c497 auipc s1,0x1c
+ 802071c8: a5c48493 addi s1,s1,-1444 # 80222c20 <cons>
+ while(cons.e != cons.w &&
+ 802071cc: 4929 li s2,10
+ 802071ce: f4f70be3 beq a4,a5,80207124 <consoleintr+0x3c>
+ cons.buf[(cons.e-1) % INPUT_BUF] != '\n'){
+ 802071d2: 37fd addiw a5,a5,-1
+ 802071d4: 07f7f713 andi a4,a5,127
+ 802071d8: 9726 add a4,a4,s1
+ while(cons.e != cons.w &&
+ 802071da: 01874703 lbu a4,24(a4)
+ 802071de: f52703e3 beq a4,s2,80207124 <consoleintr+0x3c>
+ cons.e--;
+ 802071e2: 0af4a023 sw a5,160(s1)
+ consputc(BACKSPACE);
+ 802071e6: 10000513 li a0,256
+ 802071ea: 00000097 auipc ra,0x0
+ 802071ee: ec0080e7 jalr -320(ra) # 802070aa <consputc>
+ while(cons.e != cons.w &&
+ 802071f2: 0a04a783 lw a5,160(s1)
+ 802071f6: 09c4a703 lw a4,156(s1)
+ 802071fa: fcf71ce3 bne a4,a5,802071d2 <consoleintr+0xea>
+ 802071fe: b71d j 80207124 <consoleintr+0x3c>
+ if(cons.e != cons.w){
+ 80207200: 0001c717 auipc a4,0x1c
+ 80207204: a2070713 addi a4,a4,-1504 # 80222c20 <cons>
+ 80207208: 0a072783 lw a5,160(a4)
+ 8020720c: 09c72703 lw a4,156(a4)
+ 80207210: f0f70ae3 beq a4,a5,80207124 <consoleintr+0x3c>
+ cons.e--;
+ 80207214: 37fd addiw a5,a5,-1
+ 80207216: 0001c717 auipc a4,0x1c
+ 8020721a: aaf72523 sw a5,-1366(a4) # 80222cc0 <cons+0xa0>
+ consputc(BACKSPACE);
+ 8020721e: 10000513 li a0,256
+ 80207222: 00000097 auipc ra,0x0
+ 80207226: e88080e7 jalr -376(ra) # 802070aa <consputc>
+ 8020722a: bded j 80207124 <consoleintr+0x3c>
+ if(c != 0 && cons.e-cons.r < INPUT_BUF){
+ 8020722c: ee048ce3 beqz s1,80207124 <consoleintr+0x3c>
+ 80207230: bf21 j 80207148 <consoleintr+0x60>
+ consputc(c);
+ 80207232: 4529 li a0,10
+ 80207234: 00000097 auipc ra,0x0
+ 80207238: e76080e7 jalr -394(ra) # 802070aa <consputc>
+ cons.buf[cons.e++ % INPUT_BUF] = c;
+ 8020723c: 0001c797 auipc a5,0x1c
+ 80207240: 9e478793 addi a5,a5,-1564 # 80222c20 <cons>
+ 80207244: 0a07a703 lw a4,160(a5)
+ 80207248: 0017069b addiw a3,a4,1
+ 8020724c: 0006861b sext.w a2,a3
+ 80207250: 0ad7a023 sw a3,160(a5)
+ 80207254: 07f77713 andi a4,a4,127
+ 80207258: 97ba add a5,a5,a4
+ 8020725a: 4729 li a4,10
+ 8020725c: 00e78c23 sb a4,24(a5)
+ cons.w = cons.e;
+ 80207260: 0001c797 auipc a5,0x1c
+ 80207264: a4c7ae23 sw a2,-1444(a5) # 80222cbc <cons+0x9c>
+ wakeup(&cons.r);
+ 80207268: 0001c517 auipc a0,0x1c
+ 8020726c: a5050513 addi a0,a0,-1456 # 80222cb8 <cons+0x98>
+ 80207270: ffffb097 auipc ra,0xffffb
+ 80207274: 41c080e7 jalr 1052(ra) # 8020268c <wakeup>
+ 80207278: b575 j 80207124 <consoleintr+0x3c>
+
+000000008020727a <consoleinit>:
+
+void
+consoleinit(void)
+{
+ 8020727a: 1101 addi sp,sp,-32
+ 8020727c: ec06 sd ra,24(sp)
+ 8020727e: e822 sd s0,16(sp)
+ 80207280: e426 sd s1,8(sp)
+ 80207282: 1000 addi s0,sp,32
+ initlock(&cons.lock, "cons");
+ 80207284: 0001c497 auipc s1,0x1c
+ 80207288: 99c48493 addi s1,s1,-1636 # 80222c20 <cons>
+ 8020728c: 00003597 auipc a1,0x3
+ 80207290: c2458593 addi a1,a1,-988 # 80209eb0 <digits+0xb30>
+ 80207294: 8526 mv a0,s1
+ 80207296: ffff9097 auipc ra,0xffff9
+ 8020729a: 3ec080e7 jalr 1004(ra) # 80200682 <initlock>
+
+ cons.e = cons.w = cons.r = 0;
+ 8020729e: 0804ac23 sw zero,152(s1)
+ 802072a2: 0804ae23 sw zero,156(s1)
+ 802072a6: 0a04a023 sw zero,160(s1)
+
+ // connect read and write system calls
+ // to consoleread and consolewrite.
+ devsw[CONSOLE].read = consoleread;
+ 802072aa: 00005797 auipc a5,0x5
+ 802072ae: a867b783 ld a5,-1402(a5) # 8020bd30 <_GLOBAL_OFFSET_TABLE_+0x58>
+ 802072b2: 00000717 auipc a4,0x0
+ 802072b6: ce070713 addi a4,a4,-800 # 80206f92 <consoleread>
+ 802072ba: eb98 sd a4,16(a5)
+ devsw[CONSOLE].write = consolewrite;
+ 802072bc: 00000717 auipc a4,0x0
+ 802072c0: c4870713 addi a4,a4,-952 # 80206f04 <consolewrite>
+ 802072c4: ef98 sd a4,24(a5)
+}
+ 802072c6: 60e2 ld ra,24(sp)
+ 802072c8: 6442 ld s0,16(sp)
+ 802072ca: 64a2 ld s1,8(sp)
+ 802072cc: 6105 addi sp,sp,32
+ 802072ce: 8082 ret
+
+00000000802072d0 <free_desc>:
+}
+
+// mark a descriptor as free.
+static void
+free_desc(int i)
+{
+ 802072d0: 1141 addi sp,sp,-16
+ 802072d2: e406 sd ra,8(sp)
+ 802072d4: e022 sd s0,0(sp)
+ 802072d6: 0800 addi s0,sp,16
+ if(i >= NUM)
+ 802072d8: 479d li a5,7
+ 802072da: 04a7cb63 blt a5,a0,80207330 <free_desc+0x60>
+ panic("virtio_disk_intr 1");
+ if(disk.free[i])
+ 802072de: 0001c717 auipc a4,0x1c
+ 802072e2: d2270713 addi a4,a4,-734 # 80223000 <disk>
+ 802072e6: 972a add a4,a4,a0
+ 802072e8: 6789 lui a5,0x2
+ 802072ea: 97ba add a5,a5,a4
+ 802072ec: 0187c783 lbu a5,24(a5) # 2018 <_entry-0x801fdfe8>
+ 802072f0: eba1 bnez a5,80207340 <free_desc+0x70>
+ panic("virtio_disk_intr 2");
+ disk.desc[i].addr = 0;
+ 802072f2: 00451713 slli a4,a0,0x4
+ 802072f6: 0001e797 auipc a5,0x1e
+ 802072fa: d0a7b783 ld a5,-758(a5) # 80225000 <disk+0x2000>
+ 802072fe: 97ba add a5,a5,a4
+ 80207300: 0007b023 sd zero,0(a5)
+ disk.free[i] = 1;
+ 80207304: 0001c717 auipc a4,0x1c
+ 80207308: cfc70713 addi a4,a4,-772 # 80223000 <disk>
+ 8020730c: 972a add a4,a4,a0
+ 8020730e: 6789 lui a5,0x2
+ 80207310: 97ba add a5,a5,a4
+ 80207312: 4705 li a4,1
+ 80207314: 00e78c23 sb a4,24(a5) # 2018 <_entry-0x801fdfe8>
+ wakeup(&disk.free[0]);
+ 80207318: 0001e517 auipc a0,0x1e
+ 8020731c: d0050513 addi a0,a0,-768 # 80225018 <disk+0x2018>
+ 80207320: ffffb097 auipc ra,0xffffb
+ 80207324: 36c080e7 jalr 876(ra) # 8020268c <wakeup>
+}
+ 80207328: 60a2 ld ra,8(sp)
+ 8020732a: 6402 ld s0,0(sp)
+ 8020732c: 0141 addi sp,sp,16
+ 8020732e: 8082 ret
+ panic("virtio_disk_intr 1");
+ 80207330: 00003517 auipc a0,0x3
+ 80207334: b8850513 addi a0,a0,-1144 # 80209eb8 <digits+0xb38>
+ 80207338: ffff9097 auipc ra,0xffff9
+ 8020733c: e0c080e7 jalr -500(ra) # 80200144 <panic>
+ panic("virtio_disk_intr 2");
+ 80207340: 00003517 auipc a0,0x3
+ 80207344: b9050513 addi a0,a0,-1136 # 80209ed0 <digits+0xb50>
+ 80207348: ffff9097 auipc ra,0xffff9
+ 8020734c: dfc080e7 jalr -516(ra) # 80200144 <panic>
+
+0000000080207350 <virtio_disk_init>:
+{
+ 80207350: 1141 addi sp,sp,-16
+ 80207352: e406 sd ra,8(sp)
+ 80207354: e022 sd s0,0(sp)
+ 80207356: 0800 addi s0,sp,16
+ initlock(&disk.vdisk_lock, "virtio_disk");
+ 80207358: 00003597 auipc a1,0x3
+ 8020735c: b9058593 addi a1,a1,-1136 # 80209ee8 <digits+0xb68>
+ 80207360: 0001e517 auipc a0,0x1e
+ 80207364: d4850513 addi a0,a0,-696 # 802250a8 <disk+0x20a8>
+ 80207368: ffff9097 auipc ra,0xffff9
+ 8020736c: 31a080e7 jalr 794(ra) # 80200682 <initlock>
+ if(*R(VIRTIO_MMIO_MAGIC_VALUE) != 0x74726976 ||
+ 80207370: 03f107b7 lui a5,0x3f10
+ 80207374: 0785 addi a5,a5,1 # 3f10001 <_entry-0x7c2effff>
+ 80207376: 07b2 slli a5,a5,0xc
+ 80207378: 4398 lw a4,0(a5)
+ 8020737a: 2701 sext.w a4,a4
+ 8020737c: 747277b7 lui a5,0x74727
+ 80207380: 97678793 addi a5,a5,-1674 # 74726976 <_entry-0xbad968a>
+ 80207384: 12f71163 bne a4,a5,802074a6 <virtio_disk_init+0x156>
+ *R(VIRTIO_MMIO_VERSION) != 1 ||
+ 80207388: 00003797 auipc a5,0x3
+ 8020738c: be87b783 ld a5,-1048(a5) # 80209f70 <digits+0xbf0>
+ 80207390: 439c lw a5,0(a5)
+ 80207392: 2781 sext.w a5,a5
+ if(*R(VIRTIO_MMIO_MAGIC_VALUE) != 0x74726976 ||
+ 80207394: 4705 li a4,1
+ 80207396: 10e79863 bne a5,a4,802074a6 <virtio_disk_init+0x156>
+ *R(VIRTIO_MMIO_DEVICE_ID) != 2 ||
+ 8020739a: 00003797 auipc a5,0x3
+ 8020739e: bde7b783 ld a5,-1058(a5) # 80209f78 <digits+0xbf8>
+ 802073a2: 439c lw a5,0(a5)
+ 802073a4: 2781 sext.w a5,a5
+ *R(VIRTIO_MMIO_VERSION) != 1 ||
+ 802073a6: 4709 li a4,2
+ 802073a8: 0ee79f63 bne a5,a4,802074a6 <virtio_disk_init+0x156>
+ *R(VIRTIO_MMIO_VENDOR_ID) != 0x554d4551){
+ 802073ac: 00003797 auipc a5,0x3
+ 802073b0: bd47b783 ld a5,-1068(a5) # 80209f80 <digits+0xc00>
+ 802073b4: 4398 lw a4,0(a5)
+ 802073b6: 2701 sext.w a4,a4
+ *R(VIRTIO_MMIO_DEVICE_ID) != 2 ||
+ 802073b8: 554d47b7 lui a5,0x554d4
+ 802073bc: 55178793 addi a5,a5,1361 # 554d4551 <_entry-0x2ad2baaf>
+ 802073c0: 0ef71363 bne a4,a5,802074a6 <virtio_disk_init+0x156>
+ *R(VIRTIO_MMIO_STATUS) = status;
+ 802073c4: 00003797 auipc a5,0x3
+ 802073c8: bc47b783 ld a5,-1084(a5) # 80209f88 <digits+0xc08>
+ 802073cc: 4705 li a4,1
+ 802073ce: c398 sw a4,0(a5)
+ *R(VIRTIO_MMIO_STATUS) = status;
+ 802073d0: 470d li a4,3
+ 802073d2: c398 sw a4,0(a5)
+ uint64 features = *R(VIRTIO_MMIO_DEVICE_FEATURES);
+ 802073d4: 00003717 auipc a4,0x3
+ 802073d8: bbc73703 ld a4,-1092(a4) # 80209f90 <digits+0xc10>
+ 802073dc: 4318 lw a4,0(a4)
+ *R(VIRTIO_MMIO_DRIVER_FEATURES) = features;
+ 802073de: c7ffe6b7 lui a3,0xc7ffe
+ 802073e2: 75f68693 addi a3,a3,1887 # ffffffffc7ffe75f <ebss_clear+0xffffffff47dd875f>
+ 802073e6: 8f75 and a4,a4,a3
+ 802073e8: 00003697 auipc a3,0x3
+ 802073ec: bb06b683 ld a3,-1104(a3) # 80209f98 <digits+0xc18>
+ 802073f0: c298 sw a4,0(a3)
+ *R(VIRTIO_MMIO_STATUS) = status;
+ 802073f2: 472d li a4,11
+ 802073f4: c398 sw a4,0(a5)
+ *R(VIRTIO_MMIO_STATUS) = status;
+ 802073f6: 473d li a4,15
+ 802073f8: c398 sw a4,0(a5)
+ *R(VIRTIO_MMIO_GUEST_PAGE_SIZE) = PGSIZE;
+ 802073fa: 00003797 auipc a5,0x3
+ 802073fe: ba67b783 ld a5,-1114(a5) # 80209fa0 <digits+0xc20>
+ 80207402: 6705 lui a4,0x1
+ 80207404: c398 sw a4,0(a5)
+ *R(VIRTIO_MMIO_QUEUE_SEL) = 0;
+ 80207406: 00003797 auipc a5,0x3
+ 8020740a: ba27b783 ld a5,-1118(a5) # 80209fa8 <digits+0xc28>
+ 8020740e: 0007a023 sw zero,0(a5)
+ uint32 max = *R(VIRTIO_MMIO_QUEUE_NUM_MAX);
+ 80207412: 00003797 auipc a5,0x3
+ 80207416: b9e7b783 ld a5,-1122(a5) # 80209fb0 <digits+0xc30>
+ 8020741a: 439c lw a5,0(a5)
+ 8020741c: 2781 sext.w a5,a5
+ if(max == 0)
+ 8020741e: cfc1 beqz a5,802074b6 <virtio_disk_init+0x166>
+ if(max < NUM)
+ 80207420: 471d li a4,7
+ 80207422: 0af77263 bgeu a4,a5,802074c6 <virtio_disk_init+0x176>
+ *R(VIRTIO_MMIO_QUEUE_NUM) = NUM;
+ 80207426: 00003797 auipc a5,0x3
+ 8020742a: b927b783 ld a5,-1134(a5) # 80209fb8 <digits+0xc38>
+ 8020742e: 4721 li a4,8
+ 80207430: c398 sw a4,0(a5)
+ memset(disk.pages, 0, sizeof(disk.pages));
+ 80207432: 6609 lui a2,0x2
+ 80207434: 4581 li a1,0
+ 80207436: 0001c517 auipc a0,0x1c
+ 8020743a: bca50513 addi a0,a0,-1078 # 80223000 <disk>
+ 8020743e: ffff9097 auipc ra,0xffff9
+ 80207442: 324080e7 jalr 804(ra) # 80200762 <memset>
+ *R(VIRTIO_MMIO_QUEUE_PFN) = ((uint64)disk.pages) >> PGSHIFT;
+ 80207446: 0001c717 auipc a4,0x1c
+ 8020744a: bba70713 addi a4,a4,-1094 # 80223000 <disk>
+ 8020744e: 00c75793 srli a5,a4,0xc
+ 80207452: 2781 sext.w a5,a5
+ 80207454: 00003697 auipc a3,0x3
+ 80207458: b6c6b683 ld a3,-1172(a3) # 80209fc0 <digits+0xc40>
+ 8020745c: c29c sw a5,0(a3)
+ disk.desc = (struct VRingDesc *) disk.pages;
+ 8020745e: 0001e797 auipc a5,0x1e
+ 80207462: ba278793 addi a5,a5,-1118 # 80225000 <disk+0x2000>
+ 80207466: e398 sd a4,0(a5)
+ disk.avail = (uint16*)(((char*)disk.desc) + NUM*sizeof(struct VRingDesc));
+ 80207468: 0001c717 auipc a4,0x1c
+ 8020746c: c1870713 addi a4,a4,-1000 # 80223080 <disk+0x80>
+ 80207470: e798 sd a4,8(a5)
+ disk.used = (struct UsedArea *) (disk.pages + PGSIZE);
+ 80207472: 0001d717 auipc a4,0x1d
+ 80207476: b8e70713 addi a4,a4,-1138 # 80224000 <disk+0x1000>
+ 8020747a: eb98 sd a4,16(a5)
+ disk.free[i] = 1;
+ 8020747c: 4705 li a4,1
+ 8020747e: 00e78c23 sb a4,24(a5)
+ 80207482: 00e78ca3 sb a4,25(a5)
+ 80207486: 00e78d23 sb a4,26(a5)
+ 8020748a: 00e78da3 sb a4,27(a5)
+ 8020748e: 00e78e23 sb a4,28(a5)
+ 80207492: 00e78ea3 sb a4,29(a5)
+ 80207496: 00e78f23 sb a4,30(a5)
+ 8020749a: 00e78fa3 sb a4,31(a5)
+}
+ 8020749e: 60a2 ld ra,8(sp)
+ 802074a0: 6402 ld s0,0(sp)
+ 802074a2: 0141 addi sp,sp,16
+ 802074a4: 8082 ret
+ panic("could not find virtio disk");
+ 802074a6: 00003517 auipc a0,0x3
+ 802074aa: a5250513 addi a0,a0,-1454 # 80209ef8 <digits+0xb78>
+ 802074ae: ffff9097 auipc ra,0xffff9
+ 802074b2: c96080e7 jalr -874(ra) # 80200144 <panic>
+ panic("virtio disk has no queue 0");
+ 802074b6: 00003517 auipc a0,0x3
+ 802074ba: a6250513 addi a0,a0,-1438 # 80209f18 <digits+0xb98>
+ 802074be: ffff9097 auipc ra,0xffff9
+ 802074c2: c86080e7 jalr -890(ra) # 80200144 <panic>
+ panic("virtio disk max queue too short");
+ 802074c6: 00003517 auipc a0,0x3
+ 802074ca: a7250513 addi a0,a0,-1422 # 80209f38 <digits+0xbb8>
+ 802074ce: ffff9097 auipc ra,0xffff9
+ 802074d2: c76080e7 jalr -906(ra) # 80200144 <panic>
+
+00000000802074d6 <virtio_disk_rw>:
+ return 0;
+}
+
+void
+virtio_disk_rw(struct buf *b, int write)
+{
+ 802074d6: 7175 addi sp,sp,-144
+ 802074d8: e506 sd ra,136(sp)
+ 802074da: e122 sd s0,128(sp)
+ 802074dc: fca6 sd s1,120(sp)
+ 802074de: f8ca sd s2,112(sp)
+ 802074e0: f4ce sd s3,104(sp)
+ 802074e2: f0d2 sd s4,96(sp)
+ 802074e4: ecd6 sd s5,88(sp)
+ 802074e6: e8da sd s6,80(sp)
+ 802074e8: e4de sd s7,72(sp)
+ 802074ea: e0e2 sd s8,64(sp)
+ 802074ec: fc66 sd s9,56(sp)
+ 802074ee: f86a sd s10,48(sp)
+ 802074f0: f46e sd s11,40(sp)
+ 802074f2: 0900 addi s0,sp,144
+ 802074f4: 8aaa mv s5,a0
+ 802074f6: 8cae mv s9,a1
+ uint64 sector = b->sectorno;
+ 802074f8: 00c56d03 lwu s10,12(a0)
+
+ acquire(&disk.vdisk_lock);
+ 802074fc: 0001e517 auipc a0,0x1e
+ 80207500: bac50513 addi a0,a0,-1108 # 802250a8 <disk+0x20a8>
+ 80207504: ffff9097 auipc ra,0xffff9
+ 80207508: 1c2080e7 jalr 450(ra) # 802006c6 <acquire>
+ for(int i = 0; i < 3; i++){
+ 8020750c: 4981 li s3,0
+ for(int i = 0; i < NUM; i++){
+ 8020750e: 44a1 li s1,8
+ disk.free[i] = 0;
+ 80207510: 0001cc17 auipc s8,0x1c
+ 80207514: af0c0c13 addi s8,s8,-1296 # 80223000 <disk>
+ 80207518: 6b89 lui s7,0x2
+ for(int i = 0; i < 3; i++){
+ 8020751a: 4b0d li s6,3
+ 8020751c: a0ad j 80207586 <virtio_disk_rw+0xb0>
+ disk.free[i] = 0;
+ 8020751e: 00fc0733 add a4,s8,a5
+ 80207522: 975e add a4,a4,s7
+ 80207524: 00070c23 sb zero,24(a4)
+ idx[i] = alloc_desc();
+ 80207528: c19c sw a5,0(a1)
+ if(idx[i] < 0){
+ 8020752a: 0207c563 bltz a5,80207554 <virtio_disk_rw+0x7e>
+ for(int i = 0; i < 3; i++){
+ 8020752e: 2905 addiw s2,s2,1
+ 80207530: 0611 addi a2,a2,4 # 2004 <_entry-0x801fdffc>
+ 80207532: 19690e63 beq s2,s6,802076ce <virtio_disk_rw+0x1f8>
+ idx[i] = alloc_desc();
+ 80207536: 85b2 mv a1,a2
+ for(int i = 0; i < NUM; i++){
+ 80207538: 0001e717 auipc a4,0x1e
+ 8020753c: ae070713 addi a4,a4,-1312 # 80225018 <disk+0x2018>
+ 80207540: 87ce mv a5,s3
+ if(disk.free[i]){
+ 80207542: 00074683 lbu a3,0(a4)
+ 80207546: fee1 bnez a3,8020751e <virtio_disk_rw+0x48>
+ for(int i = 0; i < NUM; i++){
+ 80207548: 2785 addiw a5,a5,1
+ 8020754a: 0705 addi a4,a4,1
+ 8020754c: fe979be3 bne a5,s1,80207542 <virtio_disk_rw+0x6c>
+ idx[i] = alloc_desc();
+ 80207550: 57fd li a5,-1
+ 80207552: c19c sw a5,0(a1)
+ for(int j = 0; j < i; j++)
+ 80207554: 01205d63 blez s2,8020756e <virtio_disk_rw+0x98>
+ 80207558: 8dce mv s11,s3
+ free_desc(idx[j]);
+ 8020755a: 000a2503 lw a0,0(s4)
+ 8020755e: 00000097 auipc ra,0x0
+ 80207562: d72080e7 jalr -654(ra) # 802072d0 <free_desc>
+ for(int j = 0; j < i; j++)
+ 80207566: 2d85 addiw s11,s11,1
+ 80207568: 0a11 addi s4,s4,4
+ 8020756a: ff2d98e3 bne s11,s2,8020755a <virtio_disk_rw+0x84>
+ int idx[3];
+ while(1){
+ if(alloc3_desc(idx) == 0) {
+ break;
+ }
+ sleep(&disk.free[0], &disk.vdisk_lock);
+ 8020756e: 0001e597 auipc a1,0x1e
+ 80207572: b3a58593 addi a1,a1,-1222 # 802250a8 <disk+0x20a8>
+ 80207576: 0001e517 auipc a0,0x1e
+ 8020757a: aa250513 addi a0,a0,-1374 # 80225018 <disk+0x2018>
+ 8020757e: ffffb097 auipc ra,0xffffb
+ 80207582: e76080e7 jalr -394(ra) # 802023f4 <sleep>
+ for(int i = 0; i < 3; i++){
+ 80207586: f8040a13 addi s4,s0,-128
+{
+ 8020758a: 8652 mv a2,s4
+ for(int i = 0; i < 3; i++){
+ 8020758c: 894e mv s2,s3
+ 8020758e: b765 j 80207536 <virtio_disk_rw+0x60>
+ disk.desc[idx[0]].next = idx[1];
+
+ disk.desc[idx[1]].addr = (uint64) b->data;
+ disk.desc[idx[1]].len = BSIZE;
+ if(write)
+ disk.desc[idx[1]].flags = 0; // device reads b->data
+ 80207590: 0001e717 auipc a4,0x1e
+ 80207594: a7073703 ld a4,-1424(a4) # 80225000 <disk+0x2000>
+ 80207598: 973e add a4,a4,a5
+ 8020759a: 00071623 sh zero,12(a4)
+ else
+ disk.desc[idx[1]].flags = VRING_DESC_F_WRITE; // device writes b->data
+ disk.desc[idx[1]].flags |= VRING_DESC_F_NEXT;
+ 8020759e: 0001c517 auipc a0,0x1c
+ 802075a2: a6250513 addi a0,a0,-1438 # 80223000 <disk>
+ 802075a6: 0001e717 auipc a4,0x1e
+ 802075aa: a5a70713 addi a4,a4,-1446 # 80225000 <disk+0x2000>
+ 802075ae: 6314 ld a3,0(a4)
+ 802075b0: 96be add a3,a3,a5
+ 802075b2: 00c6d603 lhu a2,12(a3)
+ 802075b6: 00166613 ori a2,a2,1
+ 802075ba: 00c69623 sh a2,12(a3)
+ disk.desc[idx[1]].next = idx[2];
+ 802075be: f8842683 lw a3,-120(s0)
+ 802075c2: 6310 ld a2,0(a4)
+ 802075c4: 97b2 add a5,a5,a2
+ 802075c6: 00d79723 sh a3,14(a5)
+
+ disk.info[idx[0]].status = 0;
+ 802075ca: 20048613 addi a2,s1,512
+ 802075ce: 0612 slli a2,a2,0x4
+ 802075d0: 962a add a2,a2,a0
+ 802075d2: 02060823 sb zero,48(a2)
+ disk.desc[idx[2]].addr = (uint64) &disk.info[idx[0]].status;
+ 802075d6: 00469793 slli a5,a3,0x4
+ 802075da: 630c ld a1,0(a4)
+ 802075dc: 95be add a1,a1,a5
+ 802075de: 6689 lui a3,0x2
+ 802075e0: 03068693 addi a3,a3,48 # 2030 <_entry-0x801fdfd0>
+ 802075e4: 96ca add a3,a3,s2
+ 802075e6: 96aa add a3,a3,a0
+ 802075e8: e194 sd a3,0(a1)
+ disk.desc[idx[2]].len = 1;
+ 802075ea: 6314 ld a3,0(a4)
+ 802075ec: 96be add a3,a3,a5
+ 802075ee: 4585 li a1,1
+ 802075f0: c68c sw a1,8(a3)
+ disk.desc[idx[2]].flags = VRING_DESC_F_WRITE; // device writes the status
+ 802075f2: 6314 ld a3,0(a4)
+ 802075f4: 96be add a3,a3,a5
+ 802075f6: 4509 li a0,2
+ 802075f8: 00a69623 sh a0,12(a3)
+ disk.desc[idx[2]].next = 0;
+ 802075fc: 6314 ld a3,0(a4)
+ 802075fe: 97b6 add a5,a5,a3
+ 80207600: 00079723 sh zero,14(a5)
+
+ // record struct buf for virtio_disk_intr().
+ b->disk = 1;
+ 80207604: 00baa223 sw a1,4(s5)
+ disk.info[idx[0]].b = b;
+ 80207608: 03563423 sd s5,40(a2)
+
+ // avail[0] is flags
+ // avail[1] tells the device how far to look in avail[2...].
+ // avail[2...] are desc[] indices the device should process.
+ // we only tell device the first index in our chain of descriptors.
+ disk.avail[2 + (disk.avail[1] % NUM)] = idx[0];
+ 8020760c: 6714 ld a3,8(a4)
+ 8020760e: 0026d783 lhu a5,2(a3)
+ 80207612: 8b9d andi a5,a5,7
+ 80207614: 0789 addi a5,a5,2
+ 80207616: 0786 slli a5,a5,0x1
+ 80207618: 96be add a3,a3,a5
+ 8020761a: 00969023 sh s1,0(a3)
+ __sync_synchronize();
+ 8020761e: 0ff0000f fence
+ disk.avail[1] = disk.avail[1] + 1;
+ 80207622: 6718 ld a4,8(a4)
+ 80207624: 00275783 lhu a5,2(a4)
+ 80207628: 2785 addiw a5,a5,1
+ 8020762a: 00f71123 sh a5,2(a4)
+
+ *R(VIRTIO_MMIO_QUEUE_NOTIFY) = 0; // value is queue number
+ 8020762e: 00003797 auipc a5,0x3
+ 80207632: 99a7b783 ld a5,-1638(a5) # 80209fc8 <digits+0xc48>
+ 80207636: 0007a023 sw zero,0(a5)
+
+ // Wait for virtio_disk_intr() to say request has finished.
+ while(b->disk == 1) {
+ 8020763a: 004aa783 lw a5,4(s5)
+ 8020763e: 02b79163 bne a5,a1,80207660 <virtio_disk_rw+0x18a>
+ sleep(b, &disk.vdisk_lock);
+ 80207642: 0001e917 auipc s2,0x1e
+ 80207646: a6690913 addi s2,s2,-1434 # 802250a8 <disk+0x20a8>
+ while(b->disk == 1) {
+ 8020764a: 4485 li s1,1
+ sleep(b, &disk.vdisk_lock);
+ 8020764c: 85ca mv a1,s2
+ 8020764e: 8556 mv a0,s5
+ 80207650: ffffb097 auipc ra,0xffffb
+ 80207654: da4080e7 jalr -604(ra) # 802023f4 <sleep>
+ while(b->disk == 1) {
+ 80207658: 004aa783 lw a5,4(s5)
+ 8020765c: fe9788e3 beq a5,s1,8020764c <virtio_disk_rw+0x176>
+ }
+
+ disk.info[idx[0]].b = 0;
+ 80207660: f8042483 lw s1,-128(s0)
+ 80207664: 20048713 addi a4,s1,512
+ 80207668: 0712 slli a4,a4,0x4
+ 8020766a: 0001c797 auipc a5,0x1c
+ 8020766e: 99678793 addi a5,a5,-1642 # 80223000 <disk>
+ 80207672: 97ba add a5,a5,a4
+ 80207674: 0207b423 sd zero,40(a5)
+ if(disk.desc[i].flags & VRING_DESC_F_NEXT)
+ 80207678: 0001e917 auipc s2,0x1e
+ 8020767c: 98890913 addi s2,s2,-1656 # 80225000 <disk+0x2000>
+ 80207680: a019 j 80207686 <virtio_disk_rw+0x1b0>
+ i = disk.desc[i].next;
+ 80207682: 00e7d483 lhu s1,14(a5)
+ free_desc(i);
+ 80207686: 8526 mv a0,s1
+ 80207688: 00000097 auipc ra,0x0
+ 8020768c: c48080e7 jalr -952(ra) # 802072d0 <free_desc>
+ if(disk.desc[i].flags & VRING_DESC_F_NEXT)
+ 80207690: 0492 slli s1,s1,0x4
+ 80207692: 00093783 ld a5,0(s2)
+ 80207696: 97a6 add a5,a5,s1
+ 80207698: 00c7d703 lhu a4,12(a5)
+ 8020769c: 8b05 andi a4,a4,1
+ 8020769e: f375 bnez a4,80207682 <virtio_disk_rw+0x1ac>
+ free_chain(idx[0]);
+
+ release(&disk.vdisk_lock);
+ 802076a0: 0001e517 auipc a0,0x1e
+ 802076a4: a0850513 addi a0,a0,-1528 # 802250a8 <disk+0x20a8>
+ 802076a8: ffff9097 auipc ra,0xffff9
+ 802076ac: 072080e7 jalr 114(ra) # 8020071a <release>
+}
+ 802076b0: 60aa ld ra,136(sp)
+ 802076b2: 640a ld s0,128(sp)
+ 802076b4: 74e6 ld s1,120(sp)
+ 802076b6: 7946 ld s2,112(sp)
+ 802076b8: 79a6 ld s3,104(sp)
+ 802076ba: 7a06 ld s4,96(sp)
+ 802076bc: 6ae6 ld s5,88(sp)
+ 802076be: 6b46 ld s6,80(sp)
+ 802076c0: 6ba6 ld s7,72(sp)
+ 802076c2: 6c06 ld s8,64(sp)
+ 802076c4: 7ce2 ld s9,56(sp)
+ 802076c6: 7d42 ld s10,48(sp)
+ 802076c8: 7da2 ld s11,40(sp)
+ 802076ca: 6149 addi sp,sp,144
+ 802076cc: 8082 ret
+ if(write)
+ 802076ce: 019037b3 snez a5,s9
+ 802076d2: f6f42823 sw a5,-144(s0)
+ buf0.reserved = 0;
+ 802076d6: f6042a23 sw zero,-140(s0)
+ buf0.sector = sector;
+ 802076da: f7a43c23 sd s10,-136(s0)
+ disk.desc[idx[0]].addr = (uint64) kwalkaddr(myproc()->kpagetable, (uint64) &buf0);
+ 802076de: ffffa097 auipc ra,0xffffa
+ 802076e2: 35e080e7 jalr 862(ra) # 80201a3c <myproc>
+ 802076e6: f8042483 lw s1,-128(s0)
+ 802076ea: 00449913 slli s2,s1,0x4
+ 802076ee: 0001e997 auipc s3,0x1e
+ 802076f2: 91298993 addi s3,s3,-1774 # 80225000 <disk+0x2000>
+ 802076f6: 0009ba03 ld s4,0(s3)
+ 802076fa: 9a4a add s4,s4,s2
+ 802076fc: f7040593 addi a1,s0,-144
+ 80207700: 6d28 ld a0,88(a0)
+ 80207702: ffff9097 auipc ra,0xffff9
+ 80207706: 4ee080e7 jalr 1262(ra) # 80200bf0 <kwalkaddr>
+ 8020770a: 00aa3023 sd a0,0(s4)
+ disk.desc[idx[0]].len = sizeof(buf0);
+ 8020770e: 0009b783 ld a5,0(s3)
+ 80207712: 97ca add a5,a5,s2
+ 80207714: 4741 li a4,16
+ 80207716: c798 sw a4,8(a5)
+ disk.desc[idx[0]].flags = VRING_DESC_F_NEXT;
+ 80207718: 0009b783 ld a5,0(s3)
+ 8020771c: 97ca add a5,a5,s2
+ 8020771e: 4705 li a4,1
+ 80207720: 00e79623 sh a4,12(a5)
+ disk.desc[idx[0]].next = idx[1];
+ 80207724: f8442783 lw a5,-124(s0)
+ 80207728: 0009b703 ld a4,0(s3)
+ 8020772c: 974a add a4,a4,s2
+ 8020772e: 00f71723 sh a5,14(a4)
+ disk.desc[idx[1]].addr = (uint64) b->data;
+ 80207732: 0792 slli a5,a5,0x4
+ 80207734: 0009b703 ld a4,0(s3)
+ 80207738: 973e add a4,a4,a5
+ 8020773a: 058a8693 addi a3,s5,88
+ 8020773e: e314 sd a3,0(a4)
+ disk.desc[idx[1]].len = BSIZE;
+ 80207740: 0009b703 ld a4,0(s3)
+ 80207744: 973e add a4,a4,a5
+ 80207746: 20000693 li a3,512
+ 8020774a: c714 sw a3,8(a4)
+ if(write)
+ 8020774c: e40c92e3 bnez s9,80207590 <virtio_disk_rw+0xba>
+ disk.desc[idx[1]].flags = VRING_DESC_F_WRITE; // device writes b->data
+ 80207750: 0001e717 auipc a4,0x1e
+ 80207754: 8b073703 ld a4,-1872(a4) # 80225000 <disk+0x2000>
+ 80207758: 973e add a4,a4,a5
+ 8020775a: 4689 li a3,2
+ 8020775c: 00d71623 sh a3,12(a4)
+ 80207760: bd3d j 8020759e <virtio_disk_rw+0xc8>
+
+0000000080207762 <virtio_disk_intr>:
+
+void
+virtio_disk_intr()
+{
+ 80207762: 1101 addi sp,sp,-32
+ 80207764: ec06 sd ra,24(sp)
+ 80207766: e822 sd s0,16(sp)
+ 80207768: e426 sd s1,8(sp)
+ 8020776a: e04a sd s2,0(sp)
+ 8020776c: 1000 addi s0,sp,32
+ acquire(&disk.vdisk_lock);
+ 8020776e: 0001e517 auipc a0,0x1e
+ 80207772: 93a50513 addi a0,a0,-1734 # 802250a8 <disk+0x20a8>
+ 80207776: ffff9097 auipc ra,0xffff9
+ 8020777a: f50080e7 jalr -176(ra) # 802006c6 <acquire>
+
+ while((disk.used_idx % NUM) != (disk.used->id % NUM)){
+ 8020777e: 0001e717 auipc a4,0x1e
+ 80207782: 88270713 addi a4,a4,-1918 # 80225000 <disk+0x2000>
+ 80207786: 02075783 lhu a5,32(a4)
+ 8020778a: 6b18 ld a4,16(a4)
+ 8020778c: 00275683 lhu a3,2(a4)
+ 80207790: 8ebd xor a3,a3,a5
+ 80207792: 8a9d andi a3,a3,7
+ 80207794: cab9 beqz a3,802077ea <virtio_disk_intr+0x88>
+ int id = disk.used->elems[disk.used_idx].id;
+
+ if(disk.info[id].status != 0)
+ 80207796: 0001c917 auipc s2,0x1c
+ 8020779a: 86a90913 addi s2,s2,-1942 # 80223000 <disk>
+ panic("virtio_disk_intr status");
+
+ disk.info[id].b->disk = 0; // disk is done with buf
+ wakeup(disk.info[id].b);
+
+ disk.used_idx = (disk.used_idx + 1) % NUM;
+ 8020779e: 0001e497 auipc s1,0x1e
+ 802077a2: 86248493 addi s1,s1,-1950 # 80225000 <disk+0x2000>
+ int id = disk.used->elems[disk.used_idx].id;
+ 802077a6: 078e slli a5,a5,0x3
+ 802077a8: 973e add a4,a4,a5
+ 802077aa: 435c lw a5,4(a4)
+ if(disk.info[id].status != 0)
+ 802077ac: 20078713 addi a4,a5,512
+ 802077b0: 0712 slli a4,a4,0x4
+ 802077b2: 974a add a4,a4,s2
+ 802077b4: 03074703 lbu a4,48(a4)
+ 802077b8: e335 bnez a4,8020781c <virtio_disk_intr+0xba>
+ disk.info[id].b->disk = 0; // disk is done with buf
+ 802077ba: 20078793 addi a5,a5,512
+ 802077be: 0792 slli a5,a5,0x4
+ 802077c0: 97ca add a5,a5,s2
+ 802077c2: 7798 ld a4,40(a5)
+ 802077c4: 00072223 sw zero,4(a4)
+ wakeup(disk.info[id].b);
+ 802077c8: 7788 ld a0,40(a5)
+ 802077ca: ffffb097 auipc ra,0xffffb
+ 802077ce: ec2080e7 jalr -318(ra) # 8020268c <wakeup>
+ disk.used_idx = (disk.used_idx + 1) % NUM;
+ 802077d2: 0204d783 lhu a5,32(s1)
+ 802077d6: 2785 addiw a5,a5,1
+ 802077d8: 8b9d andi a5,a5,7
+ 802077da: 02f49023 sh a5,32(s1)
+ while((disk.used_idx % NUM) != (disk.used->id % NUM)){
+ 802077de: 6898 ld a4,16(s1)
+ 802077e0: 00275683 lhu a3,2(a4)
+ 802077e4: 8a9d andi a3,a3,7
+ 802077e6: fcf690e3 bne a3,a5,802077a6 <virtio_disk_intr+0x44>
+ }
+ *R(VIRTIO_MMIO_INTERRUPT_ACK) = *R(VIRTIO_MMIO_INTERRUPT_STATUS) & 0x3;
+ 802077ea: 00002797 auipc a5,0x2
+ 802077ee: 7e67b783 ld a5,2022(a5) # 80209fd0 <digits+0xc50>
+ 802077f2: 439c lw a5,0(a5)
+ 802077f4: 8b8d andi a5,a5,3
+ 802077f6: 00002717 auipc a4,0x2
+ 802077fa: 7e273703 ld a4,2018(a4) # 80209fd8 <digits+0xc58>
+ 802077fe: c31c sw a5,0(a4)
+
+ release(&disk.vdisk_lock);
+ 80207800: 0001e517 auipc a0,0x1e
+ 80207804: 8a850513 addi a0,a0,-1880 # 802250a8 <disk+0x20a8>
+ 80207808: ffff9097 auipc ra,0xffff9
+ 8020780c: f12080e7 jalr -238(ra) # 8020071a <release>
+}
+ 80207810: 60e2 ld ra,24(sp)
+ 80207812: 6442 ld s0,16(sp)
+ 80207814: 64a2 ld s1,8(sp)
+ 80207816: 6902 ld s2,0(sp)
+ 80207818: 6105 addi sp,sp,32
+ 8020781a: 8082 ret
+ panic("virtio_disk_intr status");
+ 8020781c: 00002517 auipc a0,0x2
+ 80207820: 73c50513 addi a0,a0,1852 # 80209f58 <digits+0xbd8>
+ 80207824: ffff9097 auipc ra,0xffff9
+ 80207828: 920080e7 jalr -1760(ra) # 80200144 <panic>
+ ...
+
+0000000080208000 <_trampoline>:
+ 80208000: 14051573 csrrw a0,sscratch,a0
+ 80208004: 02153423 sd ra,40(a0)
+ 80208008: 02253823 sd sp,48(a0)
+ 8020800c: 02353c23 sd gp,56(a0)
+ 80208010: 04453023 sd tp,64(a0)
+ 80208014: 04553423 sd t0,72(a0)
+ 80208018: 04653823 sd t1,80(a0)
+ 8020801c: 04753c23 sd t2,88(a0)
+ 80208020: f120 sd s0,96(a0)
+ 80208022: f524 sd s1,104(a0)
+ 80208024: fd2c sd a1,120(a0)
+ 80208026: e150 sd a2,128(a0)
+ 80208028: e554 sd a3,136(a0)
+ 8020802a: e958 sd a4,144(a0)
+ 8020802c: ed5c sd a5,152(a0)
+ 8020802e: 0b053023 sd a6,160(a0)
+ 80208032: 0b153423 sd a7,168(a0)
+ 80208036: 0b253823 sd s2,176(a0)
+ 8020803a: 0b353c23 sd s3,184(a0)
+ 8020803e: 0d453023 sd s4,192(a0)
+ 80208042: 0d553423 sd s5,200(a0)
+ 80208046: 0d653823 sd s6,208(a0)
+ 8020804a: 0d753c23 sd s7,216(a0)
+ 8020804e: 0f853023 sd s8,224(a0)
+ 80208052: 0f953423 sd s9,232(a0)
+ 80208056: 0fa53823 sd s10,240(a0)
+ 8020805a: 0fb53c23 sd s11,248(a0)
+ 8020805e: 11c53023 sd t3,256(a0)
+ 80208062: 11d53423 sd t4,264(a0)
+ 80208066: 11e53823 sd t5,272(a0)
+ 8020806a: 11f53c23 sd t6,280(a0)
+ 8020806e: 140022f3 csrr t0,sscratch
+ 80208072: 06553823 sd t0,112(a0)
+ 80208076: 00853103 ld sp,8(a0)
+ 8020807a: 02053203 ld tp,32(a0)
+ 8020807e: 01053283 ld t0,16(a0)
+ 80208082: 00053303 ld t1,0(a0)
+ 80208086: 18031073 csrw satp,t1
+ 8020808a: 12000073 sfence.vma
+ 8020808e: 8282 jr t0
+
+0000000080208090 <userret>:
+ 80208090: 18059073 csrw satp,a1
+ 80208094: 12000073 sfence.vma
+ 80208098: 07053283 ld t0,112(a0)
+ 8020809c: 14029073 csrw sscratch,t0
+ 802080a0: 02853083 ld ra,40(a0)
+ 802080a4: 03053103 ld sp,48(a0)
+ 802080a8: 03853183 ld gp,56(a0)
+ 802080ac: 04053203 ld tp,64(a0)
+ 802080b0: 04853283 ld t0,72(a0)
+ 802080b4: 05053303 ld t1,80(a0)
+ 802080b8: 05853383 ld t2,88(a0)
+ 802080bc: 7120 ld s0,96(a0)
+ 802080be: 7524 ld s1,104(a0)
+ 802080c0: 7d2c ld a1,120(a0)
+ 802080c2: 6150 ld a2,128(a0)
+ 802080c4: 6554 ld a3,136(a0)
+ 802080c6: 6958 ld a4,144(a0)
+ 802080c8: 6d5c ld a5,152(a0)
+ 802080ca: 0a053803 ld a6,160(a0)
+ 802080ce: 0a853883 ld a7,168(a0)
+ 802080d2: 0b053903 ld s2,176(a0)
+ 802080d6: 0b853983 ld s3,184(a0)
+ 802080da: 0c053a03 ld s4,192(a0)
+ 802080de: 0c853a83 ld s5,200(a0)
+ 802080e2: 0d053b03 ld s6,208(a0)
+ 802080e6: 0d853b83 ld s7,216(a0)
+ 802080ea: 0e053c03 ld s8,224(a0)
+ 802080ee: 0e853c83 ld s9,232(a0)
+ 802080f2: 0f053d03 ld s10,240(a0)
+ 802080f6: 0f853d83 ld s11,248(a0)
+ 802080fa: 10053e03 ld t3,256(a0)
+ 802080fe: 10853e83 ld t4,264(a0)
+ 80208102: 11053f03 ld t5,272(a0)
+ 80208106: 11853f83 ld t6,280(a0)
+ 8020810a: 14051573 csrrw a0,sscratch,a0
+ 8020810e: 10200073 sret
+ ...
diff --git a/target/kernel.sym b/target/kernel.sym
new file mode 100644
index 0000000000000000000000000000000000000000..deade5b43d12a81c77ad8d98134215b058b638f7
--- /dev/null
+++ b/target/kernel.sym
@@ -0,0 +1,306 @@
+0000000080200000 .text
+0000000080209000 .rodata
+000000008020a000 .data
+000000008020bcd8 .got
+000000008020bd38 .got.plt
+000000008020c000 .bss
+0000000000000000 .riscv.attributes
+0000000000000000 .comment
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_loclists
+0000000000000000 .debug_aranges
+0000000000000000 .debug_rnglists
+0000000000000000 .debug_line
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_frame
+0000000000000000 entry_qemu.o
+0000000080200014 loop
+0000000000000000 printf.c
+0000000080200016 printint
+0000000080209380 digits
+0000000080214008 pr
+0000000000000000 kalloc.c
+0000000000000000 intr.c
+0000000000000000 spinlock.c
+0000000000000000 string.c
+0000000000000000 main.c
+0000000080214050 started
+0000000000000000 vm.c
+0000000000000000 proc.c
+0000000080201850 wakeup1
+0000000080201c0e freeproc
+0000000080201c78 allocproc
+000000008020a000 first.1
+000000008020ac48 states.0
+0000000000000000 swtch.o
+0000000000000000 trap.c
+0000000000000000 syscall.c
+0000000080202ee0 argraw
+000000008020ac70 syscalls
+000000008020b498 sysnames
+0000000000000000 sysproc.c
+0000000000000000 bio.c
+0000000000000000 sleeplock.c
+0000000000000000 file.c
+0000000000000000 pipe.c
+0000000000000000 exec.c
+0000000000000000 sysfile.c
+00000000802047b2 argfd
+000000008020481a fdalloc
+000000008020485c create
+0000000000000000 kernelvec.o
+0000000000000000 timer.c
+0000000000000000 disk.c
+0000000000000000 fat32.c
+000000008020551e read_fat
+0000000080205594 alloc_clus
+00000000802056d6 write_fat
+0000000080205756 reloc_clus
+000000008020585e rw_clus
+00000000802059aa eget
+000000008021e5b8 ecache
+0000000080205ab8 read_entry_name
+0000000080206ca0 lookup_path
+000000008020bcc0 illegal.1
+000000008020bcd0 illegal.0
+000000008021e428 fat
+000000008021e450 root
+0000000000000000 plic.c
+0000000000000000 console.c
+0000000000000000 virtio_disk.c
+00000000802072d0 free_desc
+0000000080223000 disk
+000000008020bcd8 _GLOBAL_OFFSET_TABLE_
+0000000080205034 sys_remove
+0000000080206410 edup
+0000000080200c68 mappages
+00000000802014a4 copyinstr
+0000000080206f92 consoleread
+00000000802008b4 safestrcpy
+0000000080204a4c sys_close
+00000000802023b8 yield
+0000000080214028 kmem
+0000000080202766 either_copyout
+000000008020541e timerinit
+0000000080214180 proc
+00000000802016cc proc_kpagetable
+0000000080203dec fileread
+000000008020018e printf
+0000000080203466 sys_sbrk
+0000000080203742 sys_yield
+0000000080208000 trampoline
+0000000080214000 panicked
+0000000080206046 emake
+0000000080206eaa plic_claim
+0000000080204e28 sys_dev
+0000000080206e50 plicinit
+0000000080206ed4 plic_complete
+00000000802021e2 sched
+00000000802007be memmove
+0000000080203136 syscall
+0000000080201a10 cpuid
+0000000080203386 sys_fork
+0000000080218af0 bcache
+0000000080204c2e sys_mkdir
+0000000080206604 etrunc
+0000000080206e68 plicinithart
+0000000080202092 reparent
+0000000080205ba4 fat32_init
+0000000080206e34 enameparent
+0000000080203106 argstr
+0000000080200f9e uvmdealloc
+000000008020339e sys_clone
+000000008020a000 sdata
+0000000080203c80 filedup
+00000000802037b2 binit
+00000000802012b4 uvmclear
+000000008020653a eremove
+0000000080204980 sys_read
+0000000080200822 memcpy
+0000000080200cf6 kvmmap
+0000000080200440 kfree
+0000000080201a20 mycpu
+00000000802029f8 devintr
+0000000080205d6a eread
+000000008020a004 nextpid
+0000000080203bbe fileinit
+0000000080208090 userret
+0000000080200682 initlock
+0000000080205f8e formatname
+00000000802012e6 copyout
+00000000802023f4 sleep
+00000000802000b8 printstring
+0000000080205390 kernelvec
+000000008020bcd7 edata
+0000000080200988 wcsncmp
+0000000080203660 sys_kill
+000000008020411e pipeclose
+0000000080204a9a sys_fstat
+0000000080206f04 consolewrite
+0000000080209000 rodata_start
+0000000080206e16 ename
+00000000802004c2 freerange
+000000008020666e elock
+0000000080200ae4 kvminithart
+000000008020100a uvmalloc
+0000000080200f14 uvminit
+00000000802011a6 uvmcopy
+0000000080214178 initproc
+0000000080201bbc proc_freepagetable
+0000000080201894 reg_info
+0000000080201b20 proc_pagetable
+00000000802034b0 sys_sleep
+0000000080201672 kvmfree
+00000000802054ba disk_init
+0000000080203f7e dirnext
+0000000080203c16 filealloc
+000000008020268c wakeup
+0000000080207350 virtio_disk_init
+0000000080201a3c myproc
+0000000080200000 BASE_ADDRESS
+0000000080202570 wait4
+0000000080204efa sys_readdir
+0000000080200b08 walk
+0000000080204ae8 sys_open
+00000000802000e4 backtrace
+00000000802070e8 consoleintr
+00000000802070aa consputc
+00000000802026f6 kill
+0000000080201ada allocpid
+00000000802013c4 copyin
+0000000080200910 wnstr
+000000008020116c uvmfree
+0000000080201372 copyout2
+0000000080203eae filewrite
+0000000080200942 snstr
+0000000080203082 argint
+0000000080209000 srodata
+0000000080200e22 vmunmap
+00000000802036d6 sys_times
+00000000802036ee sys_trace
+0000000080204378 exec
+0000000080209000 etext
+00000000802049e6 sys_write
+000000008020071a release
+0000000080203052 fetchstr
+0000000080202472 wait
+00000000802066f2 eput
+0000000080214000 boot_stack_top
+000000008020295a usertrapret
+00000000802020f8 scheduler
+0000000080206018 cal_checksum
+0000000080208000 _trampoline
+0000000080226000 kernel_end
+00000000802069fc dirlookup
+0000000080203402 sys_wait4
+0000000080203cd2 fileclose
+0000000080206b5a ealloc
+0000000080200bf0 kwalkaddr
+00000000802005c0 freemem_amount
+0000000080202a9c usertrap
+000000008020083a strncmp
+000000008021e408 tickslock
+000000008020418e pipewrite
+0000000080205506 disk_intr
+0000000080200876 strncpy
+000000008021d450 ftable
+0000000080207762 virtio_disk_intr
+0000000080209fe0 erodata
+000000008020492e sys_dup
+0000000080201452 copyin2
+0000000080200144 panic
+000000008020c000 bss_start
+0000000080201a74 forkret
+000000008020050e kinit
+0000000080200784 memcmp
+000000008020279c either_copyin
+0000000080201e42 fork
+0000000080214078 cpus
+0000000080203b24 releasesleep
+0000000080200000 _entry
+0000000080200698 holding
+00000000802006c6 acquire
+0000000080202f48 sys_uname
+0000000080214000 sbss_clear
+0000000080203560 sys_nanosleep
+000000008020a008 initcode
+000000008020291e trapinithart
+0000000080200762 memset
+00000000802030a4 sys_test_proc
+00000000802009e4 main
+0000000080203ace acquiresleep
+0000000080208000 uservec
+0000000080200d2e kvminit
+00000000802015c4 kfreewalk
+0000000080203a58 bunpin
+00000000802030e4 argaddr
+0000000080200000 text_start
+0000000080203726 sys_shutdown
+0000000080203692 sys_uptime
+000000008020a000 data_start
+0000000080204f48 sys_getcwd
+000000008020036e printfinit
+0000000080201732 vmprint
+0000000080200ee6 uvmcreate
+0000000080205e62 ewrite
+0000000080201dc6 growproc
+0000000080203b68 holdingsleep
+0000000080201554 copyinstr2
+0000000080201d4a userinit
+0000000080203852 bread
+0000000080204292 piperead
+00000000802003a0 print_logo
+000000008021e420 ticks
+000000008020727a consoleinit
+0000000080200bae walkaddr
+0000000080202c82 trapframedump
+00000000802027d0 procdump
+000000008020397e brelse
+0000000080202fb8 sys_sysinfo
+0000000080205446 set_next_timeout
+00000000802031da sys_exec
+0000000080200c46 kvmpa
+000000008020682a estat
+00000000802028b4 swtch
+0000000080226000 ebss_clear
+00000000802005d6 push_off
+0000000080205158 sys_rename
+0000000080200622 pop_off
+0000000080203942 bwrite
+000000008020546c timer_tick
+00000000802054ec disk_write
+00000000802022b8 exit
+0000000080201100 freewalk
+00000000802033d0 sys_wait
+000000008020331c sys_exit
+0000000080203a94 initsleeplock
+00000000802066a4 eunlock
+000000008020375c sys_gettimeofday
+0000000080214058 kernel_pagetable
+00000000802074d6 virtio_disk_rw
+00000000802008e6 strlen
+00000000802054d2 disk_read
+0000000080204d1c sys_pipe
+0000000080201f5a clone
+000000008020c000 boot_stack
+0000000080202884 procnum
+00000000802009c0 strchr
+0000000080206872 enext
+0000000080201620 kvmfreeusr
+0000000080222c20 cons
+000000008020055a kalloc
+0000000080203002 fetchaddr
+000000008021d3b0 devsw
+0000000080203350 sys_getpid
+0000000080204044 pipealloc
+000000008020336a sys_getppid
+0000000080200000 kernel_start
+0000000080204c88 sys_chdir
+0000000080206454 eupdate
+0000000080202b94 kerneltrap
+0000000080203a1c bpin
+000000008020199a procinit
+0000000080203d88 filestat
+0000000080214060 pid_lock
diff --git a/xv6-user/_cat b/xv6-user/_cat
new file mode 100644
index 0000000000000000000000000000000000000000..b494aa5b214b30b33239cc1370360b7fa8074b29
Binary files /dev/null and b/xv6-user/_cat differ
diff --git a/xv6-user/_echo b/xv6-user/_echo
new file mode 100644
index 0000000000000000000000000000000000000000..8a8434dee18c56242cb261d108a6bb0112e68a4f
Binary files /dev/null and b/xv6-user/_echo differ
diff --git a/xv6-user/_find b/xv6-user/_find
new file mode 100644
index 0000000000000000000000000000000000000000..83c4d1627e7da5ceb9919e7133276838c3049834
Binary files /dev/null and b/xv6-user/_find differ
diff --git a/xv6-user/_grep b/xv6-user/_grep
new file mode 100644
index 0000000000000000000000000000000000000000..b79afa5b64462a6c2d7171d93c88fe0d89b7fe71
Binary files /dev/null and b/xv6-user/_grep differ
diff --git a/xv6-user/_init b/xv6-user/_init
new file mode 100644
index 0000000000000000000000000000000000000000..23f0f61a9dc28ef7d21279d4a3deeab2b92128ae
Binary files /dev/null and b/xv6-user/_init differ
diff --git a/xv6-user/_kill b/xv6-user/_kill
new file mode 100644
index 0000000000000000000000000000000000000000..3fa3e7733564fbd01b28d677843187297afcd9c0
Binary files /dev/null and b/xv6-user/_kill differ
diff --git a/xv6-user/_ls b/xv6-user/_ls
new file mode 100644
index 0000000000000000000000000000000000000000..2f884dbb5fa278a8c87787addc53943e8e2e239e
Binary files /dev/null and b/xv6-user/_ls differ
diff --git a/xv6-user/_mkdir b/xv6-user/_mkdir
new file mode 100644
index 0000000000000000000000000000000000000000..d2cc842b3733c165a9503f697fa0b58d88dd20db
Binary files /dev/null and b/xv6-user/_mkdir differ
diff --git a/xv6-user/_mv b/xv6-user/_mv
new file mode 100644
index 0000000000000000000000000000000000000000..fc1f22cd88acbadb95fc7055bcb965cd14f32a5c
Binary files /dev/null and b/xv6-user/_mv differ
diff --git a/xv6-user/_rm b/xv6-user/_rm
new file mode 100644
index 0000000000000000000000000000000000000000..4c4f5ad57b5a558318fa786dbbe301b4a5be2800
Binary files /dev/null and b/xv6-user/_rm differ
diff --git a/xv6-user/_sh b/xv6-user/_sh
new file mode 100644
index 0000000000000000000000000000000000000000..44df6ae97d2fa7a33fe57d10ff9ea13de34fd816
Binary files /dev/null and b/xv6-user/_sh differ
diff --git a/xv6-user/_sleep b/xv6-user/_sleep
new file mode 100644
index 0000000000000000000000000000000000000000..f06e20bd3755f9872409ab072fbdfcdaf0e2392c
Binary files /dev/null and b/xv6-user/_sleep differ
diff --git a/xv6-user/_strace b/xv6-user/_strace
new file mode 100644
index 0000000000000000000000000000000000000000..0820d0c885a4317d5ad2a25c2eb6dbb8fb738cf2
Binary files /dev/null and b/xv6-user/_strace differ
diff --git a/xv6-user/_sysinfo b/xv6-user/_sysinfo
new file mode 100644
index 0000000000000000000000000000000000000000..f91e34884e4f3aec81238ef8ddee17c0a20acf13
Binary files /dev/null and b/xv6-user/_sysinfo differ
diff --git a/xv6-user/_test b/xv6-user/_test
new file mode 100644
index 0000000000000000000000000000000000000000..0b0438aa5b222c724a625e9d439710bec74c374a
Binary files /dev/null and b/xv6-user/_test differ
diff --git a/xv6-user/_usertests b/xv6-user/_usertests
new file mode 100644
index 0000000000000000000000000000000000000000..58b4b5e5ee68ddf239b44a80b0dbc85dfc4dec80
Binary files /dev/null and b/xv6-user/_usertests differ
diff --git a/xv6-user/_wc b/xv6-user/_wc
new file mode 100644
index 0000000000000000000000000000000000000000..655e497b596511d1b726d4add3226c71f699f05d
Binary files /dev/null and b/xv6-user/_wc differ
diff --git a/xv6-user/_xargs b/xv6-user/_xargs
new file mode 100644
index 0000000000000000000000000000000000000000..62eaee2727c815ff604a1f44f489cdc9c5cb99de
Binary files /dev/null and b/xv6-user/_xargs differ
diff --git a/xv6-user/cat.asm b/xv6-user/cat.asm
new file mode 100644
index 0000000000000000000000000000000000000000..c6cd26c889f378e3bc4a54552a9fef9c8d7a8a4d
--- /dev/null
+++ b/xv6-user/cat.asm
@@ -0,0 +1,1530 @@
+
+xv6-user/_cat: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <cat>:
+
+char buf[512];
+
+void
+cat(int fd)
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: 1800 addi s0,sp,48
+ e: 89aa mv s3,a0
+ int n;
+
+ while((n = read(fd, buf, sizeof(buf))) > 0) {
+ 10: 00001917 auipc s2,0x1
+ 14: 9f090913 addi s2,s2,-1552 # a00 <buf>
+ 18: 20000613 li a2,512
+ 1c: 85ca mv a1,s2
+ 1e: 854e mv a0,s3
+ 20: 00000097 auipc ra,0x0
+ 24: 3d2080e7 jalr 978(ra) # 3f2 <read>
+ 28: 84aa mv s1,a0
+ 2a: 02a05963 blez a0,5c <cat+0x5c>
+ if (write(1, buf, n) != n) {
+ 2e: 8626 mv a2,s1
+ 30: 85ca mv a1,s2
+ 32: 4505 li a0,1
+ 34: 00000097 auipc ra,0x0
+ 38: 3c8080e7 jalr 968(ra) # 3fc <write>
+ 3c: fc950ee3 beq a0,s1,18 <cat+0x18>
+ fprintf(2, "cat: write error\n");
+ 40: 00001597 auipc a1,0x1
+ 44: 90058593 addi a1,a1,-1792 # 940 <malloc+0xee>
+ 48: 4509 li a0,2
+ 4a: 00000097 auipc ra,0x0
+ 4e: 722080e7 jalr 1826(ra) # 76c <fprintf>
+ exit(1);
+ 52: 4505 li a0,1
+ 54: 00000097 auipc ra,0x0
+ 58: 382080e7 jalr 898(ra) # 3d6 <exit>
+ }
+ }
+ if(n < 0){
+ 5c: 00054963 bltz a0,6e <cat+0x6e>
+ fprintf(2, "cat: read error\n");
+ exit(1);
+ }
+}
+ 60: 70a2 ld ra,40(sp)
+ 62: 7402 ld s0,32(sp)
+ 64: 64e2 ld s1,24(sp)
+ 66: 6942 ld s2,16(sp)
+ 68: 69a2 ld s3,8(sp)
+ 6a: 6145 addi sp,sp,48
+ 6c: 8082 ret
+ fprintf(2, "cat: read error\n");
+ 6e: 00001597 auipc a1,0x1
+ 72: 8ea58593 addi a1,a1,-1814 # 958 <malloc+0x106>
+ 76: 4509 li a0,2
+ 78: 00000097 auipc ra,0x0
+ 7c: 6f4080e7 jalr 1780(ra) # 76c <fprintf>
+ exit(1);
+ 80: 4505 li a0,1
+ 82: 00000097 auipc ra,0x0
+ 86: 354080e7 jalr 852(ra) # 3d6 <exit>
+
+000000000000008a <main>:
+
+int
+main(int argc, char *argv[])
+{
+ 8a: 7179 addi sp,sp,-48
+ 8c: f406 sd ra,40(sp)
+ 8e: f022 sd s0,32(sp)
+ 90: ec26 sd s1,24(sp)
+ 92: e84a sd s2,16(sp)
+ 94: e44e sd s3,8(sp)
+ 96: e052 sd s4,0(sp)
+ 98: 1800 addi s0,sp,48
+ int fd, i;
+
+ if(argc <= 1){
+ 9a: 4785 li a5,1
+ 9c: 04a7d763 bge a5,a0,ea <main+0x60>
+ a0: 00858913 addi s2,a1,8
+ a4: ffe5099b addiw s3,a0,-2
+ a8: 02099793 slli a5,s3,0x20
+ ac: 01d7d993 srli s3,a5,0x1d
+ b0: 05c1 addi a1,a1,16
+ b2: 99ae add s3,s3,a1
+ cat(0);
+ exit(0);
+ }
+
+ for(i = 1; i < argc; i++){
+ if((fd = open(argv[i], 0)) < 0){
+ b4: 4581 li a1,0
+ b6: 00093503 ld a0,0(s2)
+ ba: 00000097 auipc ra,0x0
+ be: 368080e7 jalr 872(ra) # 422 <open>
+ c2: 84aa mv s1,a0
+ c4: 02054d63 bltz a0,fe <main+0x74>
+ fprintf(2, "cat: cannot open %s\n", argv[i]);
+ exit(1);
+ }
+ cat(fd);
+ c8: 00000097 auipc ra,0x0
+ cc: f38080e7 jalr -200(ra) # 0 <cat>
+ close(fd);
+ d0: 8526 mv a0,s1
+ d2: 00000097 auipc ra,0x0
+ d6: 334080e7 jalr 820(ra) # 406 <close>
+ for(i = 1; i < argc; i++){
+ da: 0921 addi s2,s2,8
+ dc: fd391ce3 bne s2,s3,b4 <main+0x2a>
+ }
+ exit(0);
+ e0: 4501 li a0,0
+ e2: 00000097 auipc ra,0x0
+ e6: 2f4080e7 jalr 756(ra) # 3d6 <exit>
+ cat(0);
+ ea: 4501 li a0,0
+ ec: 00000097 auipc ra,0x0
+ f0: f14080e7 jalr -236(ra) # 0 <cat>
+ exit(0);
+ f4: 4501 li a0,0
+ f6: 00000097 auipc ra,0x0
+ fa: 2e0080e7 jalr 736(ra) # 3d6 <exit>
+ fprintf(2, "cat: cannot open %s\n", argv[i]);
+ fe: 00093603 ld a2,0(s2)
+ 102: 00001597 auipc a1,0x1
+ 106: 86e58593 addi a1,a1,-1938 # 970 <malloc+0x11e>
+ 10a: 4509 li a0,2
+ 10c: 00000097 auipc ra,0x0
+ 110: 660080e7 jalr 1632(ra) # 76c <fprintf>
+ exit(1);
+ 114: 4505 li a0,1
+ 116: 00000097 auipc ra,0x0
+ 11a: 2c0080e7 jalr 704(ra) # 3d6 <exit>
+
+000000000000011e <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 11e: 1141 addi sp,sp,-16
+ 120: e422 sd s0,8(sp)
+ 122: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 124: 87aa mv a5,a0
+ 126: 0585 addi a1,a1,1
+ 128: 0785 addi a5,a5,1
+ 12a: fff5c703 lbu a4,-1(a1)
+ 12e: fee78fa3 sb a4,-1(a5)
+ 132: fb75 bnez a4,126 <strcpy+0x8>
+ ;
+ return os;
+}
+ 134: 6422 ld s0,8(sp)
+ 136: 0141 addi sp,sp,16
+ 138: 8082 ret
+
+000000000000013a <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 13a: 1141 addi sp,sp,-16
+ 13c: e422 sd s0,8(sp)
+ 13e: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 140: 00054783 lbu a5,0(a0)
+ 144: c385 beqz a5,164 <strcat+0x2a>
+ 146: 87aa mv a5,a0
+ s++;
+ 148: 0785 addi a5,a5,1
+ while(*s)
+ 14a: 0007c703 lbu a4,0(a5)
+ 14e: ff6d bnez a4,148 <strcat+0xe>
+ while((*s++ = *t++))
+ 150: 0585 addi a1,a1,1
+ 152: 0785 addi a5,a5,1
+ 154: fff5c703 lbu a4,-1(a1)
+ 158: fee78fa3 sb a4,-1(a5)
+ 15c: fb75 bnez a4,150 <strcat+0x16>
+ ;
+ return os;
+}
+ 15e: 6422 ld s0,8(sp)
+ 160: 0141 addi sp,sp,16
+ 162: 8082 ret
+ while(*s)
+ 164: 87aa mv a5,a0
+ 166: b7ed j 150 <strcat+0x16>
+
+0000000000000168 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 168: 1141 addi sp,sp,-16
+ 16a: e422 sd s0,8(sp)
+ 16c: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 16e: 00054783 lbu a5,0(a0)
+ 172: cb91 beqz a5,186 <strcmp+0x1e>
+ 174: 0005c703 lbu a4,0(a1)
+ 178: 00f71763 bne a4,a5,186 <strcmp+0x1e>
+ p++, q++;
+ 17c: 0505 addi a0,a0,1
+ 17e: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 180: 00054783 lbu a5,0(a0)
+ 184: fbe5 bnez a5,174 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 186: 0005c503 lbu a0,0(a1)
+}
+ 18a: 40a7853b subw a0,a5,a0
+ 18e: 6422 ld s0,8(sp)
+ 190: 0141 addi sp,sp,16
+ 192: 8082 ret
+
+0000000000000194 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 194: 1141 addi sp,sp,-16
+ 196: e422 sd s0,8(sp)
+ 198: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 19a: 00054783 lbu a5,0(a0)
+ 19e: cf91 beqz a5,1ba <strlen+0x26>
+ 1a0: 0505 addi a0,a0,1
+ 1a2: 87aa mv a5,a0
+ 1a4: 4685 li a3,1
+ 1a6: 9e89 subw a3,a3,a0
+ 1a8: 00f6853b addw a0,a3,a5
+ 1ac: 0785 addi a5,a5,1
+ 1ae: fff7c703 lbu a4,-1(a5)
+ 1b2: fb7d bnez a4,1a8 <strlen+0x14>
+ ;
+ return n;
+}
+ 1b4: 6422 ld s0,8(sp)
+ 1b6: 0141 addi sp,sp,16
+ 1b8: 8082 ret
+ for(n = 0; s[n]; n++)
+ 1ba: 4501 li a0,0
+ 1bc: bfe5 j 1b4 <strlen+0x20>
+
+00000000000001be <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 1be: 1141 addi sp,sp,-16
+ 1c0: e422 sd s0,8(sp)
+ 1c2: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 1c4: ca19 beqz a2,1da <memset+0x1c>
+ 1c6: 87aa mv a5,a0
+ 1c8: 1602 slli a2,a2,0x20
+ 1ca: 9201 srli a2,a2,0x20
+ 1cc: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 1d0: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 1d4: 0785 addi a5,a5,1
+ 1d6: fee79de3 bne a5,a4,1d0 <memset+0x12>
+ }
+ return dst;
+}
+ 1da: 6422 ld s0,8(sp)
+ 1dc: 0141 addi sp,sp,16
+ 1de: 8082 ret
+
+00000000000001e0 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 1e0: 1141 addi sp,sp,-16
+ 1e2: e422 sd s0,8(sp)
+ 1e4: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 1e6: 00054783 lbu a5,0(a0)
+ 1ea: cb99 beqz a5,200 <strchr+0x20>
+ if(*s == c)
+ 1ec: 00f58763 beq a1,a5,1fa <strchr+0x1a>
+ for(; *s; s++)
+ 1f0: 0505 addi a0,a0,1
+ 1f2: 00054783 lbu a5,0(a0)
+ 1f6: fbfd bnez a5,1ec <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 1f8: 4501 li a0,0
+}
+ 1fa: 6422 ld s0,8(sp)
+ 1fc: 0141 addi sp,sp,16
+ 1fe: 8082 ret
+ return 0;
+ 200: 4501 li a0,0
+ 202: bfe5 j 1fa <strchr+0x1a>
+
+0000000000000204 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 204: 711d addi sp,sp,-96
+ 206: ec86 sd ra,88(sp)
+ 208: e8a2 sd s0,80(sp)
+ 20a: e4a6 sd s1,72(sp)
+ 20c: e0ca sd s2,64(sp)
+ 20e: fc4e sd s3,56(sp)
+ 210: f852 sd s4,48(sp)
+ 212: f456 sd s5,40(sp)
+ 214: f05a sd s6,32(sp)
+ 216: ec5e sd s7,24(sp)
+ 218: e862 sd s8,16(sp)
+ 21a: 1080 addi s0,sp,96
+ 21c: 8baa mv s7,a0
+ 21e: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 220: 892a mv s2,a0
+ 222: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 224: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 228: 4b29 li s6,10
+ 22a: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 22c: 89a6 mv s3,s1
+ 22e: 2485 addiw s1,s1,1
+ 230: 0344d763 bge s1,s4,25e <gets+0x5a>
+ cc = read(0, &c, 1);
+ 234: 4605 li a2,1
+ 236: 85d6 mv a1,s5
+ 238: 4501 li a0,0
+ 23a: 00000097 auipc ra,0x0
+ 23e: 1b8080e7 jalr 440(ra) # 3f2 <read>
+ if(cc < 1)
+ 242: 00a05e63 blez a0,25e <gets+0x5a>
+ buf[i++] = c;
+ 246: faf44783 lbu a5,-81(s0)
+ 24a: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 24e: 01678763 beq a5,s6,25c <gets+0x58>
+ 252: 0905 addi s2,s2,1
+ 254: fd879ce3 bne a5,s8,22c <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 258: 89a6 mv s3,s1
+ 25a: a011 j 25e <gets+0x5a>
+ 25c: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 25e: 99de add s3,s3,s7
+ 260: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 264: 855e mv a0,s7
+ 266: 60e6 ld ra,88(sp)
+ 268: 6446 ld s0,80(sp)
+ 26a: 64a6 ld s1,72(sp)
+ 26c: 6906 ld s2,64(sp)
+ 26e: 79e2 ld s3,56(sp)
+ 270: 7a42 ld s4,48(sp)
+ 272: 7aa2 ld s5,40(sp)
+ 274: 7b02 ld s6,32(sp)
+ 276: 6be2 ld s7,24(sp)
+ 278: 6c42 ld s8,16(sp)
+ 27a: 6125 addi sp,sp,96
+ 27c: 8082 ret
+
+000000000000027e <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 27e: 1101 addi sp,sp,-32
+ 280: ec06 sd ra,24(sp)
+ 282: e822 sd s0,16(sp)
+ 284: e426 sd s1,8(sp)
+ 286: e04a sd s2,0(sp)
+ 288: 1000 addi s0,sp,32
+ 28a: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 28c: 4581 li a1,0
+ 28e: 00000097 auipc ra,0x0
+ 292: 194080e7 jalr 404(ra) # 422 <open>
+ if(fd < 0)
+ 296: 02054563 bltz a0,2c0 <stat+0x42>
+ 29a: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 29c: 85ca mv a1,s2
+ 29e: 00000097 auipc ra,0x0
+ 2a2: 18e080e7 jalr 398(ra) # 42c <fstat>
+ 2a6: 892a mv s2,a0
+ close(fd);
+ 2a8: 8526 mv a0,s1
+ 2aa: 00000097 auipc ra,0x0
+ 2ae: 15c080e7 jalr 348(ra) # 406 <close>
+ return r;
+}
+ 2b2: 854a mv a0,s2
+ 2b4: 60e2 ld ra,24(sp)
+ 2b6: 6442 ld s0,16(sp)
+ 2b8: 64a2 ld s1,8(sp)
+ 2ba: 6902 ld s2,0(sp)
+ 2bc: 6105 addi sp,sp,32
+ 2be: 8082 ret
+ return -1;
+ 2c0: 597d li s2,-1
+ 2c2: bfc5 j 2b2 <stat+0x34>
+
+00000000000002c4 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 2c4: 1141 addi sp,sp,-16
+ 2c6: e422 sd s0,8(sp)
+ 2c8: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 2ca: 00054703 lbu a4,0(a0)
+ 2ce: 02d00793 li a5,45
+ int neg = 1;
+ 2d2: 4585 li a1,1
+ if (*s == '-') {
+ 2d4: 04f70363 beq a4,a5,31a <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 2d8: 00054703 lbu a4,0(a0)
+ 2dc: fd07079b addiw a5,a4,-48
+ 2e0: 0ff7f793 zext.b a5,a5
+ 2e4: 46a5 li a3,9
+ 2e6: 02f6ed63 bltu a3,a5,320 <atoi+0x5c>
+ n = 0;
+ 2ea: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 2ec: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 2ee: 0505 addi a0,a0,1
+ 2f0: 0026979b slliw a5,a3,0x2
+ 2f4: 9fb5 addw a5,a5,a3
+ 2f6: 0017979b slliw a5,a5,0x1
+ 2fa: 9fb9 addw a5,a5,a4
+ 2fc: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 300: 00054703 lbu a4,0(a0)
+ 304: fd07079b addiw a5,a4,-48
+ 308: 0ff7f793 zext.b a5,a5
+ 30c: fef671e3 bgeu a2,a5,2ee <atoi+0x2a>
+ return n * neg;
+}
+ 310: 02d5853b mulw a0,a1,a3
+ 314: 6422 ld s0,8(sp)
+ 316: 0141 addi sp,sp,16
+ 318: 8082 ret
+ s++;
+ 31a: 0505 addi a0,a0,1
+ neg = -1;
+ 31c: 55fd li a1,-1
+ 31e: bf6d j 2d8 <atoi+0x14>
+ n = 0;
+ 320: 4681 li a3,0
+ 322: b7fd j 310 <atoi+0x4c>
+
+0000000000000324 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 324: 1141 addi sp,sp,-16
+ 326: e422 sd s0,8(sp)
+ 328: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 32a: 02b57463 bgeu a0,a1,352 <memmove+0x2e>
+ while(n-- > 0)
+ 32e: 00c05f63 blez a2,34c <memmove+0x28>
+ 332: 1602 slli a2,a2,0x20
+ 334: 9201 srli a2,a2,0x20
+ 336: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 33a: 872a mv a4,a0
+ *dst++ = *src++;
+ 33c: 0585 addi a1,a1,1
+ 33e: 0705 addi a4,a4,1
+ 340: fff5c683 lbu a3,-1(a1)
+ 344: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 348: fee79ae3 bne a5,a4,33c <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 34c: 6422 ld s0,8(sp)
+ 34e: 0141 addi sp,sp,16
+ 350: 8082 ret
+ dst += n;
+ 352: 00c50733 add a4,a0,a2
+ src += n;
+ 356: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 358: fec05ae3 blez a2,34c <memmove+0x28>
+ 35c: fff6079b addiw a5,a2,-1
+ 360: 1782 slli a5,a5,0x20
+ 362: 9381 srli a5,a5,0x20
+ 364: fff7c793 not a5,a5
+ 368: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 36a: 15fd addi a1,a1,-1
+ 36c: 177d addi a4,a4,-1
+ 36e: 0005c683 lbu a3,0(a1)
+ 372: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 376: fee79ae3 bne a5,a4,36a <memmove+0x46>
+ 37a: bfc9 j 34c <memmove+0x28>
+
+000000000000037c <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 37c: 1141 addi sp,sp,-16
+ 37e: e422 sd s0,8(sp)
+ 380: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 382: ca05 beqz a2,3b2 <memcmp+0x36>
+ 384: fff6069b addiw a3,a2,-1
+ 388: 1682 slli a3,a3,0x20
+ 38a: 9281 srli a3,a3,0x20
+ 38c: 0685 addi a3,a3,1
+ 38e: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 390: 00054783 lbu a5,0(a0)
+ 394: 0005c703 lbu a4,0(a1)
+ 398: 00e79863 bne a5,a4,3a8 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 39c: 0505 addi a0,a0,1
+ p2++;
+ 39e: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 3a0: fed518e3 bne a0,a3,390 <memcmp+0x14>
+ }
+ return 0;
+ 3a4: 4501 li a0,0
+ 3a6: a019 j 3ac <memcmp+0x30>
+ return *p1 - *p2;
+ 3a8: 40e7853b subw a0,a5,a4
+}
+ 3ac: 6422 ld s0,8(sp)
+ 3ae: 0141 addi sp,sp,16
+ 3b0: 8082 ret
+ return 0;
+ 3b2: 4501 li a0,0
+ 3b4: bfe5 j 3ac <memcmp+0x30>
+
+00000000000003b6 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 3b6: 1141 addi sp,sp,-16
+ 3b8: e406 sd ra,8(sp)
+ 3ba: e022 sd s0,0(sp)
+ 3bc: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 3be: 00000097 auipc ra,0x0
+ 3c2: f66080e7 jalr -154(ra) # 324 <memmove>
+}
+ 3c6: 60a2 ld ra,8(sp)
+ 3c8: 6402 ld s0,0(sp)
+ 3ca: 0141 addi sp,sp,16
+ 3cc: 8082 ret
+
+00000000000003ce <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 3ce: 4885 li a7,1
+ ecall
+ 3d0: 00000073 ecall
+ ret
+ 3d4: 8082 ret
+
+00000000000003d6 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 3d6: 05d00893 li a7,93
+ ecall
+ 3da: 00000073 ecall
+ ret
+ 3de: 8082 ret
+
+00000000000003e0 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 3e0: 488d li a7,3
+ ecall
+ 3e2: 00000073 ecall
+ ret
+ 3e6: 8082 ret
+
+00000000000003e8 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 3e8: 03b00893 li a7,59
+ ecall
+ 3ec: 00000073 ecall
+ ret
+ 3f0: 8082 ret
+
+00000000000003f2 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 3f2: 03f00893 li a7,63
+ ecall
+ 3f6: 00000073 ecall
+ ret
+ 3fa: 8082 ret
+
+00000000000003fc <write>:
+.global write
+write:
+ li a7, SYS_write
+ 3fc: 04000893 li a7,64
+ ecall
+ 400: 00000073 ecall
+ ret
+ 404: 8082 ret
+
+0000000000000406 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 406: 03900893 li a7,57
+ ecall
+ 40a: 00000073 ecall
+ ret
+ 40e: 8082 ret
+
+0000000000000410 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 410: 4899 li a7,6
+ ecall
+ 412: 00000073 ecall
+ ret
+ 416: 8082 ret
+
+0000000000000418 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 418: 0dd00893 li a7,221
+ ecall
+ 41c: 00000073 ecall
+ ret
+ 420: 8082 ret
+
+0000000000000422 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 422: 03800893 li a7,56
+ ecall
+ 426: 00000073 ecall
+ ret
+ 42a: 8082 ret
+
+000000000000042c <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 42c: 05000893 li a7,80
+ ecall
+ 430: 00000073 ecall
+ ret
+ 434: 8082 ret
+
+0000000000000436 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 436: 02200893 li a7,34
+ ecall
+ 43a: 00000073 ecall
+ ret
+ 43e: 8082 ret
+
+0000000000000440 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 440: 03100893 li a7,49
+ ecall
+ 444: 00000073 ecall
+ ret
+ 448: 8082 ret
+
+000000000000044a <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 44a: 48dd li a7,23
+ ecall
+ 44c: 00000073 ecall
+ ret
+ 450: 8082 ret
+
+0000000000000452 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 452: 0ac00893 li a7,172
+ ecall
+ 456: 00000073 ecall
+ ret
+ 45a: 8082 ret
+
+000000000000045c <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 45c: 48b1 li a7,12
+ ecall
+ 45e: 00000073 ecall
+ ret
+ 462: 8082 ret
+
+0000000000000464 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 464: 48b5 li a7,13
+ ecall
+ 466: 00000073 ecall
+ ret
+ 46a: 8082 ret
+
+000000000000046c <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 46c: 48b9 li a7,14
+ ecall
+ 46e: 00000073 ecall
+ ret
+ 472: 8082 ret
+
+0000000000000474 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 474: 48d9 li a7,22
+ ecall
+ 476: 00000073 ecall
+ ret
+ 47a: 8082 ret
+
+000000000000047c <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 47c: 03200893 li a7,50
+ ecall
+ 480: 00000073 ecall
+ ret
+ 484: 8082 ret
+
+0000000000000486 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 486: 48ed li a7,27
+ ecall
+ 488: 00000073 ecall
+ ret
+ 48c: 8082 ret
+
+000000000000048e <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 48e: 48c5 li a7,17
+ ecall
+ 490: 00000073 ecall
+ ret
+ 494: 8082 ret
+
+0000000000000496 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 496: 07500893 li a7,117
+ ecall
+ 49a: 00000073 ecall
+ ret
+ 49e: 8082 ret
+
+00000000000004a0 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 4a0: 48c9 li a7,18
+ ecall
+ 4a2: 00000073 ecall
+ ret
+ 4a6: 8082 ret
+
+00000000000004a8 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 4a8: 48cd li a7,19
+ ecall
+ 4aa: 00000073 ecall
+ ret
+ 4ae: 8082 ret
+
+00000000000004b0 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 4b0: 48e9 li a7,26
+ ecall
+ 4b2: 00000073 ecall
+ ret
+ 4b6: 8082 ret
+
+00000000000004b8 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 4b8: 0d200893 li a7,210
+ ecall
+ 4bc: 00000073 ecall
+ ret
+ 4c0: 8082 ret
+
+00000000000004c2 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 4c2: 1101 addi sp,sp,-32
+ 4c4: ec06 sd ra,24(sp)
+ 4c6: e822 sd s0,16(sp)
+ 4c8: 1000 addi s0,sp,32
+ 4ca: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 4ce: 4605 li a2,1
+ 4d0: fef40593 addi a1,s0,-17
+ 4d4: 00000097 auipc ra,0x0
+ 4d8: f28080e7 jalr -216(ra) # 3fc <write>
+}
+ 4dc: 60e2 ld ra,24(sp)
+ 4de: 6442 ld s0,16(sp)
+ 4e0: 6105 addi sp,sp,32
+ 4e2: 8082 ret
+
+00000000000004e4 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 4e4: 7139 addi sp,sp,-64
+ 4e6: fc06 sd ra,56(sp)
+ 4e8: f822 sd s0,48(sp)
+ 4ea: f426 sd s1,40(sp)
+ 4ec: f04a sd s2,32(sp)
+ 4ee: ec4e sd s3,24(sp)
+ 4f0: 0080 addi s0,sp,64
+ 4f2: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 4f4: c299 beqz a3,4fa <printint+0x16>
+ 4f6: 0805c863 bltz a1,586 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 4fa: 2581 sext.w a1,a1
+ neg = 0;
+ 4fc: 4881 li a7,0
+ }
+
+ i = 0;
+ 4fe: fc040993 addi s3,s0,-64
+ neg = 0;
+ 502: 86ce mv a3,s3
+ i = 0;
+ 504: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 506: 2601 sext.w a2,a2
+ 508: 00000517 auipc a0,0x0
+ 50c: 4e050513 addi a0,a0,1248 # 9e8 <digits>
+ 510: 883a mv a6,a4
+ 512: 2705 addiw a4,a4,1
+ 514: 02c5f7bb remuw a5,a1,a2
+ 518: 1782 slli a5,a5,0x20
+ 51a: 9381 srli a5,a5,0x20
+ 51c: 97aa add a5,a5,a0
+ 51e: 0007c783 lbu a5,0(a5)
+ 522: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 526: 0005879b sext.w a5,a1
+ 52a: 02c5d5bb divuw a1,a1,a2
+ 52e: 0685 addi a3,a3,1
+ 530: fec7f0e3 bgeu a5,a2,510 <printint+0x2c>
+ if(neg)
+ 534: 00088c63 beqz a7,54c <printint+0x68>
+ buf[i++] = '-';
+ 538: fd070793 addi a5,a4,-48
+ 53c: 00878733 add a4,a5,s0
+ 540: 02d00793 li a5,45
+ 544: fef70823 sb a5,-16(a4)
+ 548: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 54c: 02e05663 blez a4,578 <printint+0x94>
+ 550: fc040913 addi s2,s0,-64
+ 554: 993a add s2,s2,a4
+ 556: 19fd addi s3,s3,-1
+ 558: 99ba add s3,s3,a4
+ 55a: 377d addiw a4,a4,-1
+ 55c: 1702 slli a4,a4,0x20
+ 55e: 9301 srli a4,a4,0x20
+ 560: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 564: fff94583 lbu a1,-1(s2)
+ 568: 8526 mv a0,s1
+ 56a: 00000097 auipc ra,0x0
+ 56e: f58080e7 jalr -168(ra) # 4c2 <putc>
+ while(--i >= 0)
+ 572: 197d addi s2,s2,-1
+ 574: ff3918e3 bne s2,s3,564 <printint+0x80>
+}
+ 578: 70e2 ld ra,56(sp)
+ 57a: 7442 ld s0,48(sp)
+ 57c: 74a2 ld s1,40(sp)
+ 57e: 7902 ld s2,32(sp)
+ 580: 69e2 ld s3,24(sp)
+ 582: 6121 addi sp,sp,64
+ 584: 8082 ret
+ x = -xx;
+ 586: 40b005bb negw a1,a1
+ neg = 1;
+ 58a: 4885 li a7,1
+ x = -xx;
+ 58c: bf8d j 4fe <printint+0x1a>
+
+000000000000058e <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 58e: 7119 addi sp,sp,-128
+ 590: fc86 sd ra,120(sp)
+ 592: f8a2 sd s0,112(sp)
+ 594: f4a6 sd s1,104(sp)
+ 596: f0ca sd s2,96(sp)
+ 598: ecce sd s3,88(sp)
+ 59a: e8d2 sd s4,80(sp)
+ 59c: e4d6 sd s5,72(sp)
+ 59e: e0da sd s6,64(sp)
+ 5a0: fc5e sd s7,56(sp)
+ 5a2: f862 sd s8,48(sp)
+ 5a4: f466 sd s9,40(sp)
+ 5a6: f06a sd s10,32(sp)
+ 5a8: ec6e sd s11,24(sp)
+ 5aa: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 5ac: 0005c903 lbu s2,0(a1)
+ 5b0: 18090f63 beqz s2,74e <vprintf+0x1c0>
+ 5b4: 8aaa mv s5,a0
+ 5b6: 8b32 mv s6,a2
+ 5b8: 00158493 addi s1,a1,1
+ state = 0;
+ 5bc: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 5be: 02500a13 li s4,37
+ 5c2: 4c55 li s8,21
+ 5c4: 00000c97 auipc s9,0x0
+ 5c8: 3ccc8c93 addi s9,s9,972 # 990 <malloc+0x13e>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 5cc: 02800d93 li s11,40
+ putc(fd, 'x');
+ 5d0: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5d2: 00000b97 auipc s7,0x0
+ 5d6: 416b8b93 addi s7,s7,1046 # 9e8 <digits>
+ 5da: a839 j 5f8 <vprintf+0x6a>
+ putc(fd, c);
+ 5dc: 85ca mv a1,s2
+ 5de: 8556 mv a0,s5
+ 5e0: 00000097 auipc ra,0x0
+ 5e4: ee2080e7 jalr -286(ra) # 4c2 <putc>
+ 5e8: a019 j 5ee <vprintf+0x60>
+ } else if(state == '%'){
+ 5ea: 01498d63 beq s3,s4,604 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 5ee: 0485 addi s1,s1,1
+ 5f0: fff4c903 lbu s2,-1(s1)
+ 5f4: 14090d63 beqz s2,74e <vprintf+0x1c0>
+ if(state == 0){
+ 5f8: fe0999e3 bnez s3,5ea <vprintf+0x5c>
+ if(c == '%'){
+ 5fc: ff4910e3 bne s2,s4,5dc <vprintf+0x4e>
+ state = '%';
+ 600: 89d2 mv s3,s4
+ 602: b7f5 j 5ee <vprintf+0x60>
+ if(c == 'd'){
+ 604: 11490c63 beq s2,s4,71c <vprintf+0x18e>
+ 608: f9d9079b addiw a5,s2,-99
+ 60c: 0ff7f793 zext.b a5,a5
+ 610: 10fc6e63 bltu s8,a5,72c <vprintf+0x19e>
+ 614: f9d9079b addiw a5,s2,-99
+ 618: 0ff7f713 zext.b a4,a5
+ 61c: 10ec6863 bltu s8,a4,72c <vprintf+0x19e>
+ 620: 00271793 slli a5,a4,0x2
+ 624: 97e6 add a5,a5,s9
+ 626: 439c lw a5,0(a5)
+ 628: 97e6 add a5,a5,s9
+ 62a: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 62c: 008b0913 addi s2,s6,8
+ 630: 4685 li a3,1
+ 632: 4629 li a2,10
+ 634: 000b2583 lw a1,0(s6)
+ 638: 8556 mv a0,s5
+ 63a: 00000097 auipc ra,0x0
+ 63e: eaa080e7 jalr -342(ra) # 4e4 <printint>
+ 642: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 644: 4981 li s3,0
+ 646: b765 j 5ee <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 648: 008b0913 addi s2,s6,8
+ 64c: 4681 li a3,0
+ 64e: 4629 li a2,10
+ 650: 000b2583 lw a1,0(s6)
+ 654: 8556 mv a0,s5
+ 656: 00000097 auipc ra,0x0
+ 65a: e8e080e7 jalr -370(ra) # 4e4 <printint>
+ 65e: 8b4a mv s6,s2
+ state = 0;
+ 660: 4981 li s3,0
+ 662: b771 j 5ee <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 664: 008b0913 addi s2,s6,8
+ 668: 4681 li a3,0
+ 66a: 866a mv a2,s10
+ 66c: 000b2583 lw a1,0(s6)
+ 670: 8556 mv a0,s5
+ 672: 00000097 auipc ra,0x0
+ 676: e72080e7 jalr -398(ra) # 4e4 <printint>
+ 67a: 8b4a mv s6,s2
+ state = 0;
+ 67c: 4981 li s3,0
+ 67e: bf85 j 5ee <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 680: 008b0793 addi a5,s6,8
+ 684: f8f43423 sd a5,-120(s0)
+ 688: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 68c: 03000593 li a1,48
+ 690: 8556 mv a0,s5
+ 692: 00000097 auipc ra,0x0
+ 696: e30080e7 jalr -464(ra) # 4c2 <putc>
+ putc(fd, 'x');
+ 69a: 07800593 li a1,120
+ 69e: 8556 mv a0,s5
+ 6a0: 00000097 auipc ra,0x0
+ 6a4: e22080e7 jalr -478(ra) # 4c2 <putc>
+ 6a8: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 6aa: 03c9d793 srli a5,s3,0x3c
+ 6ae: 97de add a5,a5,s7
+ 6b0: 0007c583 lbu a1,0(a5)
+ 6b4: 8556 mv a0,s5
+ 6b6: 00000097 auipc ra,0x0
+ 6ba: e0c080e7 jalr -500(ra) # 4c2 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 6be: 0992 slli s3,s3,0x4
+ 6c0: 397d addiw s2,s2,-1
+ 6c2: fe0914e3 bnez s2,6aa <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 6c6: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 6ca: 4981 li s3,0
+ 6cc: b70d j 5ee <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6ce: 008b0913 addi s2,s6,8
+ 6d2: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 6d6: 02098163 beqz s3,6f8 <vprintf+0x16a>
+ while(*s != 0){
+ 6da: 0009c583 lbu a1,0(s3)
+ 6de: c5ad beqz a1,748 <vprintf+0x1ba>
+ putc(fd, *s);
+ 6e0: 8556 mv a0,s5
+ 6e2: 00000097 auipc ra,0x0
+ 6e6: de0080e7 jalr -544(ra) # 4c2 <putc>
+ s++;
+ 6ea: 0985 addi s3,s3,1
+ while(*s != 0){
+ 6ec: 0009c583 lbu a1,0(s3)
+ 6f0: f9e5 bnez a1,6e0 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 6f2: 8b4a mv s6,s2
+ state = 0;
+ 6f4: 4981 li s3,0
+ 6f6: bde5 j 5ee <vprintf+0x60>
+ s = "(null)";
+ 6f8: 00000997 auipc s3,0x0
+ 6fc: 29098993 addi s3,s3,656 # 988 <malloc+0x136>
+ while(*s != 0){
+ 700: 85ee mv a1,s11
+ 702: bff9 j 6e0 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 704: 008b0913 addi s2,s6,8
+ 708: 000b4583 lbu a1,0(s6)
+ 70c: 8556 mv a0,s5
+ 70e: 00000097 auipc ra,0x0
+ 712: db4080e7 jalr -588(ra) # 4c2 <putc>
+ 716: 8b4a mv s6,s2
+ state = 0;
+ 718: 4981 li s3,0
+ 71a: bdd1 j 5ee <vprintf+0x60>
+ putc(fd, c);
+ 71c: 85d2 mv a1,s4
+ 71e: 8556 mv a0,s5
+ 720: 00000097 auipc ra,0x0
+ 724: da2080e7 jalr -606(ra) # 4c2 <putc>
+ state = 0;
+ 728: 4981 li s3,0
+ 72a: b5d1 j 5ee <vprintf+0x60>
+ putc(fd, '%');
+ 72c: 85d2 mv a1,s4
+ 72e: 8556 mv a0,s5
+ 730: 00000097 auipc ra,0x0
+ 734: d92080e7 jalr -622(ra) # 4c2 <putc>
+ putc(fd, c);
+ 738: 85ca mv a1,s2
+ 73a: 8556 mv a0,s5
+ 73c: 00000097 auipc ra,0x0
+ 740: d86080e7 jalr -634(ra) # 4c2 <putc>
+ state = 0;
+ 744: 4981 li s3,0
+ 746: b565 j 5ee <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 748: 8b4a mv s6,s2
+ state = 0;
+ 74a: 4981 li s3,0
+ 74c: b54d j 5ee <vprintf+0x60>
+ }
+ }
+}
+ 74e: 70e6 ld ra,120(sp)
+ 750: 7446 ld s0,112(sp)
+ 752: 74a6 ld s1,104(sp)
+ 754: 7906 ld s2,96(sp)
+ 756: 69e6 ld s3,88(sp)
+ 758: 6a46 ld s4,80(sp)
+ 75a: 6aa6 ld s5,72(sp)
+ 75c: 6b06 ld s6,64(sp)
+ 75e: 7be2 ld s7,56(sp)
+ 760: 7c42 ld s8,48(sp)
+ 762: 7ca2 ld s9,40(sp)
+ 764: 7d02 ld s10,32(sp)
+ 766: 6de2 ld s11,24(sp)
+ 768: 6109 addi sp,sp,128
+ 76a: 8082 ret
+
+000000000000076c <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 76c: 715d addi sp,sp,-80
+ 76e: ec06 sd ra,24(sp)
+ 770: e822 sd s0,16(sp)
+ 772: 1000 addi s0,sp,32
+ 774: e010 sd a2,0(s0)
+ 776: e414 sd a3,8(s0)
+ 778: e818 sd a4,16(s0)
+ 77a: ec1c sd a5,24(s0)
+ 77c: 03043023 sd a6,32(s0)
+ 780: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 784: 8622 mv a2,s0
+ 786: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 78a: 00000097 auipc ra,0x0
+ 78e: e04080e7 jalr -508(ra) # 58e <vprintf>
+}
+ 792: 60e2 ld ra,24(sp)
+ 794: 6442 ld s0,16(sp)
+ 796: 6161 addi sp,sp,80
+ 798: 8082 ret
+
+000000000000079a <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 79a: 711d addi sp,sp,-96
+ 79c: ec06 sd ra,24(sp)
+ 79e: e822 sd s0,16(sp)
+ 7a0: 1000 addi s0,sp,32
+ 7a2: e40c sd a1,8(s0)
+ 7a4: e810 sd a2,16(s0)
+ 7a6: ec14 sd a3,24(s0)
+ 7a8: f018 sd a4,32(s0)
+ 7aa: f41c sd a5,40(s0)
+ 7ac: 03043823 sd a6,48(s0)
+ 7b0: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 7b4: 00840613 addi a2,s0,8
+ 7b8: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 7bc: 85aa mv a1,a0
+ 7be: 4505 li a0,1
+ 7c0: 00000097 auipc ra,0x0
+ 7c4: dce080e7 jalr -562(ra) # 58e <vprintf>
+}
+ 7c8: 60e2 ld ra,24(sp)
+ 7ca: 6442 ld s0,16(sp)
+ 7cc: 6125 addi sp,sp,96
+ 7ce: 8082 ret
+
+00000000000007d0 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 7d0: 1141 addi sp,sp,-16
+ 7d2: e422 sd s0,8(sp)
+ 7d4: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 7d6: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 7da: 00000797 auipc a5,0x0
+ 7de: 4267b783 ld a5,1062(a5) # c00 <freep>
+ 7e2: a02d j 80c <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 7e4: 4618 lw a4,8(a2)
+ 7e6: 9f2d addw a4,a4,a1
+ 7e8: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 7ec: 6398 ld a4,0(a5)
+ 7ee: 6310 ld a2,0(a4)
+ 7f0: a83d j 82e <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 7f2: ff852703 lw a4,-8(a0)
+ 7f6: 9f31 addw a4,a4,a2
+ 7f8: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 7fa: ff053683 ld a3,-16(a0)
+ 7fe: a091 j 842 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 800: 6398 ld a4,0(a5)
+ 802: 00e7e463 bltu a5,a4,80a <free+0x3a>
+ 806: 00e6ea63 bltu a3,a4,81a <free+0x4a>
+{
+ 80a: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 80c: fed7fae3 bgeu a5,a3,800 <free+0x30>
+ 810: 6398 ld a4,0(a5)
+ 812: 00e6e463 bltu a3,a4,81a <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 816: fee7eae3 bltu a5,a4,80a <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 81a: ff852583 lw a1,-8(a0)
+ 81e: 6390 ld a2,0(a5)
+ 820: 02059813 slli a6,a1,0x20
+ 824: 01c85713 srli a4,a6,0x1c
+ 828: 9736 add a4,a4,a3
+ 82a: fae60de3 beq a2,a4,7e4 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 82e: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 832: 4790 lw a2,8(a5)
+ 834: 02061593 slli a1,a2,0x20
+ 838: 01c5d713 srli a4,a1,0x1c
+ 83c: 973e add a4,a4,a5
+ 83e: fae68ae3 beq a3,a4,7f2 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 842: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 844: 00000717 auipc a4,0x0
+ 848: 3af73e23 sd a5,956(a4) # c00 <freep>
+}
+ 84c: 6422 ld s0,8(sp)
+ 84e: 0141 addi sp,sp,16
+ 850: 8082 ret
+
+0000000000000852 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 852: 7139 addi sp,sp,-64
+ 854: fc06 sd ra,56(sp)
+ 856: f822 sd s0,48(sp)
+ 858: f426 sd s1,40(sp)
+ 85a: f04a sd s2,32(sp)
+ 85c: ec4e sd s3,24(sp)
+ 85e: e852 sd s4,16(sp)
+ 860: e456 sd s5,8(sp)
+ 862: e05a sd s6,0(sp)
+ 864: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 866: 02051493 slli s1,a0,0x20
+ 86a: 9081 srli s1,s1,0x20
+ 86c: 04bd addi s1,s1,15
+ 86e: 8091 srli s1,s1,0x4
+ 870: 00148a1b addiw s4,s1,1
+ 874: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 876: 00000517 auipc a0,0x0
+ 87a: 38a53503 ld a0,906(a0) # c00 <freep>
+ 87e: c515 beqz a0,8aa <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 880: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 882: 4798 lw a4,8(a5)
+ 884: 04977163 bgeu a4,s1,8c6 <malloc+0x74>
+ 888: 89d2 mv s3,s4
+ 88a: 000a071b sext.w a4,s4
+ 88e: 6685 lui a3,0x1
+ 890: 00d77363 bgeu a4,a3,896 <malloc+0x44>
+ 894: 6985 lui s3,0x1
+ 896: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 89a: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 89e: 00000917 auipc s2,0x0
+ 8a2: 36290913 addi s2,s2,866 # c00 <freep>
+ if(p == (char*)-1)
+ 8a6: 5afd li s5,-1
+ 8a8: a8a5 j 920 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 8aa: 00000797 auipc a5,0x0
+ 8ae: 35678793 addi a5,a5,854 # c00 <freep>
+ 8b2: 00000717 auipc a4,0x0
+ 8b6: 35670713 addi a4,a4,854 # c08 <base>
+ 8ba: e398 sd a4,0(a5)
+ 8bc: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 8be: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 8c2: 87ba mv a5,a4
+ 8c4: b7d1 j 888 <malloc+0x36>
+ if(p->s.size == nunits)
+ 8c6: 02e48c63 beq s1,a4,8fe <malloc+0xac>
+ p->s.size -= nunits;
+ 8ca: 4147073b subw a4,a4,s4
+ 8ce: c798 sw a4,8(a5)
+ p += p->s.size;
+ 8d0: 02071693 slli a3,a4,0x20
+ 8d4: 01c6d713 srli a4,a3,0x1c
+ 8d8: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 8da: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 8de: 00000717 auipc a4,0x0
+ 8e2: 32a73123 sd a0,802(a4) # c00 <freep>
+ return (void*)(p + 1);
+ 8e6: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 8ea: 70e2 ld ra,56(sp)
+ 8ec: 7442 ld s0,48(sp)
+ 8ee: 74a2 ld s1,40(sp)
+ 8f0: 7902 ld s2,32(sp)
+ 8f2: 69e2 ld s3,24(sp)
+ 8f4: 6a42 ld s4,16(sp)
+ 8f6: 6aa2 ld s5,8(sp)
+ 8f8: 6b02 ld s6,0(sp)
+ 8fa: 6121 addi sp,sp,64
+ 8fc: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 8fe: 6398 ld a4,0(a5)
+ 900: e118 sd a4,0(a0)
+ 902: bff1 j 8de <malloc+0x8c>
+ hp->s.size = nu;
+ 904: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 908: 0541 addi a0,a0,16
+ 90a: 00000097 auipc ra,0x0
+ 90e: ec6080e7 jalr -314(ra) # 7d0 <free>
+ return freep;
+ 912: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 916: d971 beqz a0,8ea <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 918: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 91a: 4798 lw a4,8(a5)
+ 91c: fa9775e3 bgeu a4,s1,8c6 <malloc+0x74>
+ if(p == freep)
+ 920: 00093703 ld a4,0(s2)
+ 924: 853e mv a0,a5
+ 926: fef719e3 bne a4,a5,918 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 92a: 854e mv a0,s3
+ 92c: 00000097 auipc ra,0x0
+ 930: b30080e7 jalr -1232(ra) # 45c <sbrk>
+ if(p == (char*)-1)
+ 934: fd5518e3 bne a0,s5,904 <malloc+0xb2>
+ return 0;
+ 938: 4501 li a0,0
+ 93a: bf45 j 8ea <malloc+0x98>
diff --git a/xv6-user/cat.c b/xv6-user/cat.c
new file mode 100644
index 0000000000000000000000000000000000000000..f9f86b5b220a93cf6c79a24fe1ac9909ddabacfd
--- /dev/null
+++ b/xv6-user/cat.c
@@ -0,0 +1,43 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+char buf[512];
+
+void
+cat(int fd)
+{
+ int n;
+
+ while((n = read(fd, buf, sizeof(buf))) > 0) {
+ if (write(1, buf, n) != n) {
+ fprintf(2, "cat: write error\n");
+ exit(1);
+ }
+ }
+ if(n < 0){
+ fprintf(2, "cat: read error\n");
+ exit(1);
+ }
+}
+
+int
+main(int argc, char *argv[])
+{
+ int fd, i;
+
+ if(argc <= 1){
+ cat(0);
+ exit(0);
+ }
+
+ for(i = 1; i < argc; i++){
+ if((fd = open(argv[i], 0)) < 0){
+ fprintf(2, "cat: cannot open %s\n", argv[i]);
+ exit(1);
+ }
+ cat(fd);
+ close(fd);
+ }
+ exit(0);
+}
diff --git a/xv6-user/cat.d b/xv6-user/cat.d
new file mode 100644
index 0000000000000000000000000000000000000000..2cc0456a35fe77d5e62d646ccd307f00efa3092e
--- /dev/null
+++ b/xv6-user/cat.d
@@ -0,0 +1,2 @@
+xv6-user/cat.o: xv6-user/cat.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/cat.o b/xv6-user/cat.o
new file mode 100644
index 0000000000000000000000000000000000000000..0f48dc9f082e60f9672bc8158d4692647607859b
Binary files /dev/null and b/xv6-user/cat.o differ
diff --git a/xv6-user/cat.sym b/xv6-user/cat.sym
new file mode 100644
index 0000000000000000000000000000000000000000..674cd1cbb12f0113134a58126f0a5649f38c7f21
--- /dev/null
+++ b/xv6-user/cat.sym
@@ -0,0 +1,78 @@
+0000000000000000 .text
+0000000000000940 .rodata
+0000000000000a00 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 cat.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000004c2 putc
+00000000000004e4 printint
+00000000000009e8 digits
+0000000000000000 umalloc.c
+0000000000000c00 freep
+0000000000000c08 base
+000000000000011e strcpy
+000000000000079a printf
+00000000000011f9 __global_pointer$
+000000000000047c dev
+0000000000000324 memmove
+00000000000004a0 trace
+0000000000000204 gets
+00000000000009f9 __SDATA_BEGIN__
+0000000000000452 getpid
+00000000000003b6 memcpy
+0000000000000000 cat
+0000000000000852 malloc
+0000000000000496 remove
+0000000000000464 sleep
+00000000000004a8 sysinfo
+0000000000000486 readdir
+00000000000003e8 pipe
+00000000000004b0 rename
+00000000000003fc write
+000000000000042c fstat
+000000000000076c fprintf
+0000000000000410 kill
+000000000000013a strcat
+000000000000058e vprintf
+0000000000000440 chdir
+0000000000000418 exec
+00000000000003e0 wait
+00000000000003f2 read
+000000000000037c memcmp
+00000000000003ce fork
+0000000000000c18 __BSS_END__
+000000000000045c sbrk
+0000000000000474 test_proc
+000000000000046c uptime
+00000000000009f9 __bss_start
+00000000000001be memset
+000000000000008a main
+0000000000000168 strcmp
+00000000000004b8 shutdown
+000000000000044a dup
+000000000000048e getcwd
+0000000000000a00 buf
+00000000000009f9 __DATA_BEGIN__
+000000000000027e stat
+00000000000009f9 _edata
+0000000000000c18 _end
+00000000000003d6 exit
+00000000000002c4 atoi
+0000000000000194 strlen
+0000000000000422 open
+00000000000001e0 strchr
+0000000000000436 mkdir
+0000000000000406 close
+00000000000007d0 free
diff --git a/xv6-user/echo.asm b/xv6-user/echo.asm
new file mode 100644
index 0000000000000000000000000000000000000000..7d27438ab278ff36dfb7c182f8ab552a84e23304
--- /dev/null
+++ b/xv6-user/echo.asm
@@ -0,0 +1,1453 @@
+
+xv6-user/_echo: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: e052 sd s4,0(sp)
+ e: 1800 addi s0,sp,48
+ int i;
+
+ for(i = 1; i < argc; i++){
+ 10: 4785 li a5,1
+ 12: 06a7d463 bge a5,a0,7a <main+0x7a>
+ 16: 00858493 addi s1,a1,8
+ 1a: ffe5099b addiw s3,a0,-2
+ 1e: 02099793 slli a5,s3,0x20
+ 22: 01d7d993 srli s3,a5,0x1d
+ 26: 05c1 addi a1,a1,16
+ 28: 99ae add s3,s3,a1
+ write(1, argv[i], strlen(argv[i]));
+ if(i + 1 < argc){
+ write(1, " ", 1);
+ 2a: 00001a17 auipc s4,0x1
+ 2e: 87ea0a13 addi s4,s4,-1922 # 8a8 <malloc+0xf0>
+ write(1, argv[i], strlen(argv[i]));
+ 32: 0004b903 ld s2,0(s1)
+ 36: 854a mv a0,s2
+ 38: 00000097 auipc ra,0x0
+ 3c: 0c2080e7 jalr 194(ra) # fa <strlen>
+ 40: 0005061b sext.w a2,a0
+ 44: 85ca mv a1,s2
+ 46: 4505 li a0,1
+ 48: 00000097 auipc ra,0x0
+ 4c: 31a080e7 jalr 794(ra) # 362 <write>
+ if(i + 1 < argc){
+ 50: 04a1 addi s1,s1,8
+ 52: 01348a63 beq s1,s3,66 <main+0x66>
+ write(1, " ", 1);
+ 56: 4605 li a2,1
+ 58: 85d2 mv a1,s4
+ 5a: 4505 li a0,1
+ 5c: 00000097 auipc ra,0x0
+ 60: 306080e7 jalr 774(ra) # 362 <write>
+ for(i = 1; i < argc; i++){
+ 64: b7f9 j 32 <main+0x32>
+ } else {
+ write(1, "\n", 1);
+ 66: 4605 li a2,1
+ 68: 00001597 auipc a1,0x1
+ 6c: 84858593 addi a1,a1,-1976 # 8b0 <malloc+0xf8>
+ 70: 4505 li a0,1
+ 72: 00000097 auipc ra,0x0
+ 76: 2f0080e7 jalr 752(ra) # 362 <write>
+ }
+ }
+ exit(0);
+ 7a: 4501 li a0,0
+ 7c: 00000097 auipc ra,0x0
+ 80: 2c0080e7 jalr 704(ra) # 33c <exit>
+
+0000000000000084 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 84: 1141 addi sp,sp,-16
+ 86: e422 sd s0,8(sp)
+ 88: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 8a: 87aa mv a5,a0
+ 8c: 0585 addi a1,a1,1
+ 8e: 0785 addi a5,a5,1
+ 90: fff5c703 lbu a4,-1(a1)
+ 94: fee78fa3 sb a4,-1(a5)
+ 98: fb75 bnez a4,8c <strcpy+0x8>
+ ;
+ return os;
+}
+ 9a: 6422 ld s0,8(sp)
+ 9c: 0141 addi sp,sp,16
+ 9e: 8082 ret
+
+00000000000000a0 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ a0: 1141 addi sp,sp,-16
+ a2: e422 sd s0,8(sp)
+ a4: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ a6: 00054783 lbu a5,0(a0)
+ aa: c385 beqz a5,ca <strcat+0x2a>
+ ac: 87aa mv a5,a0
+ s++;
+ ae: 0785 addi a5,a5,1
+ while(*s)
+ b0: 0007c703 lbu a4,0(a5)
+ b4: ff6d bnez a4,ae <strcat+0xe>
+ while((*s++ = *t++))
+ b6: 0585 addi a1,a1,1
+ b8: 0785 addi a5,a5,1
+ ba: fff5c703 lbu a4,-1(a1)
+ be: fee78fa3 sb a4,-1(a5)
+ c2: fb75 bnez a4,b6 <strcat+0x16>
+ ;
+ return os;
+}
+ c4: 6422 ld s0,8(sp)
+ c6: 0141 addi sp,sp,16
+ c8: 8082 ret
+ while(*s)
+ ca: 87aa mv a5,a0
+ cc: b7ed j b6 <strcat+0x16>
+
+00000000000000ce <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ ce: 1141 addi sp,sp,-16
+ d0: e422 sd s0,8(sp)
+ d2: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ d4: 00054783 lbu a5,0(a0)
+ d8: cb91 beqz a5,ec <strcmp+0x1e>
+ da: 0005c703 lbu a4,0(a1)
+ de: 00f71763 bne a4,a5,ec <strcmp+0x1e>
+ p++, q++;
+ e2: 0505 addi a0,a0,1
+ e4: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ e6: 00054783 lbu a5,0(a0)
+ ea: fbe5 bnez a5,da <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ ec: 0005c503 lbu a0,0(a1)
+}
+ f0: 40a7853b subw a0,a5,a0
+ f4: 6422 ld s0,8(sp)
+ f6: 0141 addi sp,sp,16
+ f8: 8082 ret
+
+00000000000000fa <strlen>:
+
+uint
+strlen(const char *s)
+{
+ fa: 1141 addi sp,sp,-16
+ fc: e422 sd s0,8(sp)
+ fe: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 100: 00054783 lbu a5,0(a0)
+ 104: cf91 beqz a5,120 <strlen+0x26>
+ 106: 0505 addi a0,a0,1
+ 108: 87aa mv a5,a0
+ 10a: 4685 li a3,1
+ 10c: 9e89 subw a3,a3,a0
+ 10e: 00f6853b addw a0,a3,a5
+ 112: 0785 addi a5,a5,1
+ 114: fff7c703 lbu a4,-1(a5)
+ 118: fb7d bnez a4,10e <strlen+0x14>
+ ;
+ return n;
+}
+ 11a: 6422 ld s0,8(sp)
+ 11c: 0141 addi sp,sp,16
+ 11e: 8082 ret
+ for(n = 0; s[n]; n++)
+ 120: 4501 li a0,0
+ 122: bfe5 j 11a <strlen+0x20>
+
+0000000000000124 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 124: 1141 addi sp,sp,-16
+ 126: e422 sd s0,8(sp)
+ 128: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 12a: ca19 beqz a2,140 <memset+0x1c>
+ 12c: 87aa mv a5,a0
+ 12e: 1602 slli a2,a2,0x20
+ 130: 9201 srli a2,a2,0x20
+ 132: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 136: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 13a: 0785 addi a5,a5,1
+ 13c: fee79de3 bne a5,a4,136 <memset+0x12>
+ }
+ return dst;
+}
+ 140: 6422 ld s0,8(sp)
+ 142: 0141 addi sp,sp,16
+ 144: 8082 ret
+
+0000000000000146 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 146: 1141 addi sp,sp,-16
+ 148: e422 sd s0,8(sp)
+ 14a: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 14c: 00054783 lbu a5,0(a0)
+ 150: cb99 beqz a5,166 <strchr+0x20>
+ if(*s == c)
+ 152: 00f58763 beq a1,a5,160 <strchr+0x1a>
+ for(; *s; s++)
+ 156: 0505 addi a0,a0,1
+ 158: 00054783 lbu a5,0(a0)
+ 15c: fbfd bnez a5,152 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 15e: 4501 li a0,0
+}
+ 160: 6422 ld s0,8(sp)
+ 162: 0141 addi sp,sp,16
+ 164: 8082 ret
+ return 0;
+ 166: 4501 li a0,0
+ 168: bfe5 j 160 <strchr+0x1a>
+
+000000000000016a <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 16a: 711d addi sp,sp,-96
+ 16c: ec86 sd ra,88(sp)
+ 16e: e8a2 sd s0,80(sp)
+ 170: e4a6 sd s1,72(sp)
+ 172: e0ca sd s2,64(sp)
+ 174: fc4e sd s3,56(sp)
+ 176: f852 sd s4,48(sp)
+ 178: f456 sd s5,40(sp)
+ 17a: f05a sd s6,32(sp)
+ 17c: ec5e sd s7,24(sp)
+ 17e: e862 sd s8,16(sp)
+ 180: 1080 addi s0,sp,96
+ 182: 8baa mv s7,a0
+ 184: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 186: 892a mv s2,a0
+ 188: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 18a: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 18e: 4b29 li s6,10
+ 190: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 192: 89a6 mv s3,s1
+ 194: 2485 addiw s1,s1,1
+ 196: 0344d763 bge s1,s4,1c4 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 19a: 4605 li a2,1
+ 19c: 85d6 mv a1,s5
+ 19e: 4501 li a0,0
+ 1a0: 00000097 auipc ra,0x0
+ 1a4: 1b8080e7 jalr 440(ra) # 358 <read>
+ if(cc < 1)
+ 1a8: 00a05e63 blez a0,1c4 <gets+0x5a>
+ buf[i++] = c;
+ 1ac: faf44783 lbu a5,-81(s0)
+ 1b0: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 1b4: 01678763 beq a5,s6,1c2 <gets+0x58>
+ 1b8: 0905 addi s2,s2,1
+ 1ba: fd879ce3 bne a5,s8,192 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 1be: 89a6 mv s3,s1
+ 1c0: a011 j 1c4 <gets+0x5a>
+ 1c2: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1c4: 99de add s3,s3,s7
+ 1c6: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1ca: 855e mv a0,s7
+ 1cc: 60e6 ld ra,88(sp)
+ 1ce: 6446 ld s0,80(sp)
+ 1d0: 64a6 ld s1,72(sp)
+ 1d2: 6906 ld s2,64(sp)
+ 1d4: 79e2 ld s3,56(sp)
+ 1d6: 7a42 ld s4,48(sp)
+ 1d8: 7aa2 ld s5,40(sp)
+ 1da: 7b02 ld s6,32(sp)
+ 1dc: 6be2 ld s7,24(sp)
+ 1de: 6c42 ld s8,16(sp)
+ 1e0: 6125 addi sp,sp,96
+ 1e2: 8082 ret
+
+00000000000001e4 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1e4: 1101 addi sp,sp,-32
+ 1e6: ec06 sd ra,24(sp)
+ 1e8: e822 sd s0,16(sp)
+ 1ea: e426 sd s1,8(sp)
+ 1ec: e04a sd s2,0(sp)
+ 1ee: 1000 addi s0,sp,32
+ 1f0: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1f2: 4581 li a1,0
+ 1f4: 00000097 auipc ra,0x0
+ 1f8: 194080e7 jalr 404(ra) # 388 <open>
+ if(fd < 0)
+ 1fc: 02054563 bltz a0,226 <stat+0x42>
+ 200: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 202: 85ca mv a1,s2
+ 204: 00000097 auipc ra,0x0
+ 208: 18e080e7 jalr 398(ra) # 392 <fstat>
+ 20c: 892a mv s2,a0
+ close(fd);
+ 20e: 8526 mv a0,s1
+ 210: 00000097 auipc ra,0x0
+ 214: 15c080e7 jalr 348(ra) # 36c <close>
+ return r;
+}
+ 218: 854a mv a0,s2
+ 21a: 60e2 ld ra,24(sp)
+ 21c: 6442 ld s0,16(sp)
+ 21e: 64a2 ld s1,8(sp)
+ 220: 6902 ld s2,0(sp)
+ 222: 6105 addi sp,sp,32
+ 224: 8082 ret
+ return -1;
+ 226: 597d li s2,-1
+ 228: bfc5 j 218 <stat+0x34>
+
+000000000000022a <atoi>:
+
+int
+atoi(const char *s)
+{
+ 22a: 1141 addi sp,sp,-16
+ 22c: e422 sd s0,8(sp)
+ 22e: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 230: 00054703 lbu a4,0(a0)
+ 234: 02d00793 li a5,45
+ int neg = 1;
+ 238: 4585 li a1,1
+ if (*s == '-') {
+ 23a: 04f70363 beq a4,a5,280 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 23e: 00054703 lbu a4,0(a0)
+ 242: fd07079b addiw a5,a4,-48
+ 246: 0ff7f793 zext.b a5,a5
+ 24a: 46a5 li a3,9
+ 24c: 02f6ed63 bltu a3,a5,286 <atoi+0x5c>
+ n = 0;
+ 250: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 252: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 254: 0505 addi a0,a0,1
+ 256: 0026979b slliw a5,a3,0x2
+ 25a: 9fb5 addw a5,a5,a3
+ 25c: 0017979b slliw a5,a5,0x1
+ 260: 9fb9 addw a5,a5,a4
+ 262: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 266: 00054703 lbu a4,0(a0)
+ 26a: fd07079b addiw a5,a4,-48
+ 26e: 0ff7f793 zext.b a5,a5
+ 272: fef671e3 bgeu a2,a5,254 <atoi+0x2a>
+ return n * neg;
+}
+ 276: 02d5853b mulw a0,a1,a3
+ 27a: 6422 ld s0,8(sp)
+ 27c: 0141 addi sp,sp,16
+ 27e: 8082 ret
+ s++;
+ 280: 0505 addi a0,a0,1
+ neg = -1;
+ 282: 55fd li a1,-1
+ 284: bf6d j 23e <atoi+0x14>
+ n = 0;
+ 286: 4681 li a3,0
+ 288: b7fd j 276 <atoi+0x4c>
+
+000000000000028a <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 28a: 1141 addi sp,sp,-16
+ 28c: e422 sd s0,8(sp)
+ 28e: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 290: 02b57463 bgeu a0,a1,2b8 <memmove+0x2e>
+ while(n-- > 0)
+ 294: 00c05f63 blez a2,2b2 <memmove+0x28>
+ 298: 1602 slli a2,a2,0x20
+ 29a: 9201 srli a2,a2,0x20
+ 29c: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 2a0: 872a mv a4,a0
+ *dst++ = *src++;
+ 2a2: 0585 addi a1,a1,1
+ 2a4: 0705 addi a4,a4,1
+ 2a6: fff5c683 lbu a3,-1(a1)
+ 2aa: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 2ae: fee79ae3 bne a5,a4,2a2 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 2b2: 6422 ld s0,8(sp)
+ 2b4: 0141 addi sp,sp,16
+ 2b6: 8082 ret
+ dst += n;
+ 2b8: 00c50733 add a4,a0,a2
+ src += n;
+ 2bc: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 2be: fec05ae3 blez a2,2b2 <memmove+0x28>
+ 2c2: fff6079b addiw a5,a2,-1
+ 2c6: 1782 slli a5,a5,0x20
+ 2c8: 9381 srli a5,a5,0x20
+ 2ca: fff7c793 not a5,a5
+ 2ce: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2d0: 15fd addi a1,a1,-1
+ 2d2: 177d addi a4,a4,-1
+ 2d4: 0005c683 lbu a3,0(a1)
+ 2d8: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2dc: fee79ae3 bne a5,a4,2d0 <memmove+0x46>
+ 2e0: bfc9 j 2b2 <memmove+0x28>
+
+00000000000002e2 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2e2: 1141 addi sp,sp,-16
+ 2e4: e422 sd s0,8(sp)
+ 2e6: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2e8: ca05 beqz a2,318 <memcmp+0x36>
+ 2ea: fff6069b addiw a3,a2,-1
+ 2ee: 1682 slli a3,a3,0x20
+ 2f0: 9281 srli a3,a3,0x20
+ 2f2: 0685 addi a3,a3,1
+ 2f4: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2f6: 00054783 lbu a5,0(a0)
+ 2fa: 0005c703 lbu a4,0(a1)
+ 2fe: 00e79863 bne a5,a4,30e <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 302: 0505 addi a0,a0,1
+ p2++;
+ 304: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 306: fed518e3 bne a0,a3,2f6 <memcmp+0x14>
+ }
+ return 0;
+ 30a: 4501 li a0,0
+ 30c: a019 j 312 <memcmp+0x30>
+ return *p1 - *p2;
+ 30e: 40e7853b subw a0,a5,a4
+}
+ 312: 6422 ld s0,8(sp)
+ 314: 0141 addi sp,sp,16
+ 316: 8082 ret
+ return 0;
+ 318: 4501 li a0,0
+ 31a: bfe5 j 312 <memcmp+0x30>
+
+000000000000031c <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 31c: 1141 addi sp,sp,-16
+ 31e: e406 sd ra,8(sp)
+ 320: e022 sd s0,0(sp)
+ 322: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 324: 00000097 auipc ra,0x0
+ 328: f66080e7 jalr -154(ra) # 28a <memmove>
+}
+ 32c: 60a2 ld ra,8(sp)
+ 32e: 6402 ld s0,0(sp)
+ 330: 0141 addi sp,sp,16
+ 332: 8082 ret
+
+0000000000000334 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 334: 4885 li a7,1
+ ecall
+ 336: 00000073 ecall
+ ret
+ 33a: 8082 ret
+
+000000000000033c <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 33c: 05d00893 li a7,93
+ ecall
+ 340: 00000073 ecall
+ ret
+ 344: 8082 ret
+
+0000000000000346 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 346: 488d li a7,3
+ ecall
+ 348: 00000073 ecall
+ ret
+ 34c: 8082 ret
+
+000000000000034e <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 34e: 03b00893 li a7,59
+ ecall
+ 352: 00000073 ecall
+ ret
+ 356: 8082 ret
+
+0000000000000358 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 358: 03f00893 li a7,63
+ ecall
+ 35c: 00000073 ecall
+ ret
+ 360: 8082 ret
+
+0000000000000362 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 362: 04000893 li a7,64
+ ecall
+ 366: 00000073 ecall
+ ret
+ 36a: 8082 ret
+
+000000000000036c <close>:
+.global close
+close:
+ li a7, SYS_close
+ 36c: 03900893 li a7,57
+ ecall
+ 370: 00000073 ecall
+ ret
+ 374: 8082 ret
+
+0000000000000376 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 376: 4899 li a7,6
+ ecall
+ 378: 00000073 ecall
+ ret
+ 37c: 8082 ret
+
+000000000000037e <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 37e: 0dd00893 li a7,221
+ ecall
+ 382: 00000073 ecall
+ ret
+ 386: 8082 ret
+
+0000000000000388 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 388: 03800893 li a7,56
+ ecall
+ 38c: 00000073 ecall
+ ret
+ 390: 8082 ret
+
+0000000000000392 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 392: 05000893 li a7,80
+ ecall
+ 396: 00000073 ecall
+ ret
+ 39a: 8082 ret
+
+000000000000039c <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 39c: 02200893 li a7,34
+ ecall
+ 3a0: 00000073 ecall
+ ret
+ 3a4: 8082 ret
+
+00000000000003a6 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 3a6: 03100893 li a7,49
+ ecall
+ 3aa: 00000073 ecall
+ ret
+ 3ae: 8082 ret
+
+00000000000003b0 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 3b0: 48dd li a7,23
+ ecall
+ 3b2: 00000073 ecall
+ ret
+ 3b6: 8082 ret
+
+00000000000003b8 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 3b8: 0ac00893 li a7,172
+ ecall
+ 3bc: 00000073 ecall
+ ret
+ 3c0: 8082 ret
+
+00000000000003c2 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 3c2: 48b1 li a7,12
+ ecall
+ 3c4: 00000073 ecall
+ ret
+ 3c8: 8082 ret
+
+00000000000003ca <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3ca: 48b5 li a7,13
+ ecall
+ 3cc: 00000073 ecall
+ ret
+ 3d0: 8082 ret
+
+00000000000003d2 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3d2: 48b9 li a7,14
+ ecall
+ 3d4: 00000073 ecall
+ ret
+ 3d8: 8082 ret
+
+00000000000003da <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3da: 48d9 li a7,22
+ ecall
+ 3dc: 00000073 ecall
+ ret
+ 3e0: 8082 ret
+
+00000000000003e2 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3e2: 03200893 li a7,50
+ ecall
+ 3e6: 00000073 ecall
+ ret
+ 3ea: 8082 ret
+
+00000000000003ec <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3ec: 48ed li a7,27
+ ecall
+ 3ee: 00000073 ecall
+ ret
+ 3f2: 8082 ret
+
+00000000000003f4 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3f4: 48c5 li a7,17
+ ecall
+ 3f6: 00000073 ecall
+ ret
+ 3fa: 8082 ret
+
+00000000000003fc <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3fc: 07500893 li a7,117
+ ecall
+ 400: 00000073 ecall
+ ret
+ 404: 8082 ret
+
+0000000000000406 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 406: 48c9 li a7,18
+ ecall
+ 408: 00000073 ecall
+ ret
+ 40c: 8082 ret
+
+000000000000040e <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 40e: 48cd li a7,19
+ ecall
+ 410: 00000073 ecall
+ ret
+ 414: 8082 ret
+
+0000000000000416 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 416: 48e9 li a7,26
+ ecall
+ 418: 00000073 ecall
+ ret
+ 41c: 8082 ret
+
+000000000000041e <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 41e: 0d200893 li a7,210
+ ecall
+ 422: 00000073 ecall
+ ret
+ 426: 8082 ret
+
+0000000000000428 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 428: 1101 addi sp,sp,-32
+ 42a: ec06 sd ra,24(sp)
+ 42c: e822 sd s0,16(sp)
+ 42e: 1000 addi s0,sp,32
+ 430: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 434: 4605 li a2,1
+ 436: fef40593 addi a1,s0,-17
+ 43a: 00000097 auipc ra,0x0
+ 43e: f28080e7 jalr -216(ra) # 362 <write>
+}
+ 442: 60e2 ld ra,24(sp)
+ 444: 6442 ld s0,16(sp)
+ 446: 6105 addi sp,sp,32
+ 448: 8082 ret
+
+000000000000044a <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 44a: 7139 addi sp,sp,-64
+ 44c: fc06 sd ra,56(sp)
+ 44e: f822 sd s0,48(sp)
+ 450: f426 sd s1,40(sp)
+ 452: f04a sd s2,32(sp)
+ 454: ec4e sd s3,24(sp)
+ 456: 0080 addi s0,sp,64
+ 458: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 45a: c299 beqz a3,460 <printint+0x16>
+ 45c: 0805c863 bltz a1,4ec <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 460: 2581 sext.w a1,a1
+ neg = 0;
+ 462: 4881 li a7,0
+ }
+
+ i = 0;
+ 464: fc040993 addi s3,s0,-64
+ neg = 0;
+ 468: 86ce mv a3,s3
+ i = 0;
+ 46a: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 46c: 2601 sext.w a2,a2
+ 46e: 00000517 auipc a0,0x0
+ 472: 4aa50513 addi a0,a0,1194 # 918 <digits>
+ 476: 883a mv a6,a4
+ 478: 2705 addiw a4,a4,1
+ 47a: 02c5f7bb remuw a5,a1,a2
+ 47e: 1782 slli a5,a5,0x20
+ 480: 9381 srli a5,a5,0x20
+ 482: 97aa add a5,a5,a0
+ 484: 0007c783 lbu a5,0(a5)
+ 488: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 48c: 0005879b sext.w a5,a1
+ 490: 02c5d5bb divuw a1,a1,a2
+ 494: 0685 addi a3,a3,1
+ 496: fec7f0e3 bgeu a5,a2,476 <printint+0x2c>
+ if(neg)
+ 49a: 00088c63 beqz a7,4b2 <printint+0x68>
+ buf[i++] = '-';
+ 49e: fd070793 addi a5,a4,-48
+ 4a2: 00878733 add a4,a5,s0
+ 4a6: 02d00793 li a5,45
+ 4aa: fef70823 sb a5,-16(a4)
+ 4ae: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 4b2: 02e05663 blez a4,4de <printint+0x94>
+ 4b6: fc040913 addi s2,s0,-64
+ 4ba: 993a add s2,s2,a4
+ 4bc: 19fd addi s3,s3,-1
+ 4be: 99ba add s3,s3,a4
+ 4c0: 377d addiw a4,a4,-1
+ 4c2: 1702 slli a4,a4,0x20
+ 4c4: 9301 srli a4,a4,0x20
+ 4c6: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4ca: fff94583 lbu a1,-1(s2)
+ 4ce: 8526 mv a0,s1
+ 4d0: 00000097 auipc ra,0x0
+ 4d4: f58080e7 jalr -168(ra) # 428 <putc>
+ while(--i >= 0)
+ 4d8: 197d addi s2,s2,-1
+ 4da: ff3918e3 bne s2,s3,4ca <printint+0x80>
+}
+ 4de: 70e2 ld ra,56(sp)
+ 4e0: 7442 ld s0,48(sp)
+ 4e2: 74a2 ld s1,40(sp)
+ 4e4: 7902 ld s2,32(sp)
+ 4e6: 69e2 ld s3,24(sp)
+ 4e8: 6121 addi sp,sp,64
+ 4ea: 8082 ret
+ x = -xx;
+ 4ec: 40b005bb negw a1,a1
+ neg = 1;
+ 4f0: 4885 li a7,1
+ x = -xx;
+ 4f2: bf8d j 464 <printint+0x1a>
+
+00000000000004f4 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4f4: 7119 addi sp,sp,-128
+ 4f6: fc86 sd ra,120(sp)
+ 4f8: f8a2 sd s0,112(sp)
+ 4fa: f4a6 sd s1,104(sp)
+ 4fc: f0ca sd s2,96(sp)
+ 4fe: ecce sd s3,88(sp)
+ 500: e8d2 sd s4,80(sp)
+ 502: e4d6 sd s5,72(sp)
+ 504: e0da sd s6,64(sp)
+ 506: fc5e sd s7,56(sp)
+ 508: f862 sd s8,48(sp)
+ 50a: f466 sd s9,40(sp)
+ 50c: f06a sd s10,32(sp)
+ 50e: ec6e sd s11,24(sp)
+ 510: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 512: 0005c903 lbu s2,0(a1)
+ 516: 18090f63 beqz s2,6b4 <vprintf+0x1c0>
+ 51a: 8aaa mv s5,a0
+ 51c: 8b32 mv s6,a2
+ 51e: 00158493 addi s1,a1,1
+ state = 0;
+ 522: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 524: 02500a13 li s4,37
+ 528: 4c55 li s8,21
+ 52a: 00000c97 auipc s9,0x0
+ 52e: 396c8c93 addi s9,s9,918 # 8c0 <malloc+0x108>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 532: 02800d93 li s11,40
+ putc(fd, 'x');
+ 536: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 538: 00000b97 auipc s7,0x0
+ 53c: 3e0b8b93 addi s7,s7,992 # 918 <digits>
+ 540: a839 j 55e <vprintf+0x6a>
+ putc(fd, c);
+ 542: 85ca mv a1,s2
+ 544: 8556 mv a0,s5
+ 546: 00000097 auipc ra,0x0
+ 54a: ee2080e7 jalr -286(ra) # 428 <putc>
+ 54e: a019 j 554 <vprintf+0x60>
+ } else if(state == '%'){
+ 550: 01498d63 beq s3,s4,56a <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 554: 0485 addi s1,s1,1
+ 556: fff4c903 lbu s2,-1(s1)
+ 55a: 14090d63 beqz s2,6b4 <vprintf+0x1c0>
+ if(state == 0){
+ 55e: fe0999e3 bnez s3,550 <vprintf+0x5c>
+ if(c == '%'){
+ 562: ff4910e3 bne s2,s4,542 <vprintf+0x4e>
+ state = '%';
+ 566: 89d2 mv s3,s4
+ 568: b7f5 j 554 <vprintf+0x60>
+ if(c == 'd'){
+ 56a: 11490c63 beq s2,s4,682 <vprintf+0x18e>
+ 56e: f9d9079b addiw a5,s2,-99
+ 572: 0ff7f793 zext.b a5,a5
+ 576: 10fc6e63 bltu s8,a5,692 <vprintf+0x19e>
+ 57a: f9d9079b addiw a5,s2,-99
+ 57e: 0ff7f713 zext.b a4,a5
+ 582: 10ec6863 bltu s8,a4,692 <vprintf+0x19e>
+ 586: 00271793 slli a5,a4,0x2
+ 58a: 97e6 add a5,a5,s9
+ 58c: 439c lw a5,0(a5)
+ 58e: 97e6 add a5,a5,s9
+ 590: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 592: 008b0913 addi s2,s6,8
+ 596: 4685 li a3,1
+ 598: 4629 li a2,10
+ 59a: 000b2583 lw a1,0(s6)
+ 59e: 8556 mv a0,s5
+ 5a0: 00000097 auipc ra,0x0
+ 5a4: eaa080e7 jalr -342(ra) # 44a <printint>
+ 5a8: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 5aa: 4981 li s3,0
+ 5ac: b765 j 554 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 5ae: 008b0913 addi s2,s6,8
+ 5b2: 4681 li a3,0
+ 5b4: 4629 li a2,10
+ 5b6: 000b2583 lw a1,0(s6)
+ 5ba: 8556 mv a0,s5
+ 5bc: 00000097 auipc ra,0x0
+ 5c0: e8e080e7 jalr -370(ra) # 44a <printint>
+ 5c4: 8b4a mv s6,s2
+ state = 0;
+ 5c6: 4981 li s3,0
+ 5c8: b771 j 554 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5ca: 008b0913 addi s2,s6,8
+ 5ce: 4681 li a3,0
+ 5d0: 866a mv a2,s10
+ 5d2: 000b2583 lw a1,0(s6)
+ 5d6: 8556 mv a0,s5
+ 5d8: 00000097 auipc ra,0x0
+ 5dc: e72080e7 jalr -398(ra) # 44a <printint>
+ 5e0: 8b4a mv s6,s2
+ state = 0;
+ 5e2: 4981 li s3,0
+ 5e4: bf85 j 554 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5e6: 008b0793 addi a5,s6,8
+ 5ea: f8f43423 sd a5,-120(s0)
+ 5ee: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5f2: 03000593 li a1,48
+ 5f6: 8556 mv a0,s5
+ 5f8: 00000097 auipc ra,0x0
+ 5fc: e30080e7 jalr -464(ra) # 428 <putc>
+ putc(fd, 'x');
+ 600: 07800593 li a1,120
+ 604: 8556 mv a0,s5
+ 606: 00000097 auipc ra,0x0
+ 60a: e22080e7 jalr -478(ra) # 428 <putc>
+ 60e: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 610: 03c9d793 srli a5,s3,0x3c
+ 614: 97de add a5,a5,s7
+ 616: 0007c583 lbu a1,0(a5)
+ 61a: 8556 mv a0,s5
+ 61c: 00000097 auipc ra,0x0
+ 620: e0c080e7 jalr -500(ra) # 428 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 624: 0992 slli s3,s3,0x4
+ 626: 397d addiw s2,s2,-1
+ 628: fe0914e3 bnez s2,610 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 62c: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 630: 4981 li s3,0
+ 632: b70d j 554 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 634: 008b0913 addi s2,s6,8
+ 638: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 63c: 02098163 beqz s3,65e <vprintf+0x16a>
+ while(*s != 0){
+ 640: 0009c583 lbu a1,0(s3)
+ 644: c5ad beqz a1,6ae <vprintf+0x1ba>
+ putc(fd, *s);
+ 646: 8556 mv a0,s5
+ 648: 00000097 auipc ra,0x0
+ 64c: de0080e7 jalr -544(ra) # 428 <putc>
+ s++;
+ 650: 0985 addi s3,s3,1
+ while(*s != 0){
+ 652: 0009c583 lbu a1,0(s3)
+ 656: f9e5 bnez a1,646 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 658: 8b4a mv s6,s2
+ state = 0;
+ 65a: 4981 li s3,0
+ 65c: bde5 j 554 <vprintf+0x60>
+ s = "(null)";
+ 65e: 00000997 auipc s3,0x0
+ 662: 25a98993 addi s3,s3,602 # 8b8 <malloc+0x100>
+ while(*s != 0){
+ 666: 85ee mv a1,s11
+ 668: bff9 j 646 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 66a: 008b0913 addi s2,s6,8
+ 66e: 000b4583 lbu a1,0(s6)
+ 672: 8556 mv a0,s5
+ 674: 00000097 auipc ra,0x0
+ 678: db4080e7 jalr -588(ra) # 428 <putc>
+ 67c: 8b4a mv s6,s2
+ state = 0;
+ 67e: 4981 li s3,0
+ 680: bdd1 j 554 <vprintf+0x60>
+ putc(fd, c);
+ 682: 85d2 mv a1,s4
+ 684: 8556 mv a0,s5
+ 686: 00000097 auipc ra,0x0
+ 68a: da2080e7 jalr -606(ra) # 428 <putc>
+ state = 0;
+ 68e: 4981 li s3,0
+ 690: b5d1 j 554 <vprintf+0x60>
+ putc(fd, '%');
+ 692: 85d2 mv a1,s4
+ 694: 8556 mv a0,s5
+ 696: 00000097 auipc ra,0x0
+ 69a: d92080e7 jalr -622(ra) # 428 <putc>
+ putc(fd, c);
+ 69e: 85ca mv a1,s2
+ 6a0: 8556 mv a0,s5
+ 6a2: 00000097 auipc ra,0x0
+ 6a6: d86080e7 jalr -634(ra) # 428 <putc>
+ state = 0;
+ 6aa: 4981 li s3,0
+ 6ac: b565 j 554 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6ae: 8b4a mv s6,s2
+ state = 0;
+ 6b0: 4981 li s3,0
+ 6b2: b54d j 554 <vprintf+0x60>
+ }
+ }
+}
+ 6b4: 70e6 ld ra,120(sp)
+ 6b6: 7446 ld s0,112(sp)
+ 6b8: 74a6 ld s1,104(sp)
+ 6ba: 7906 ld s2,96(sp)
+ 6bc: 69e6 ld s3,88(sp)
+ 6be: 6a46 ld s4,80(sp)
+ 6c0: 6aa6 ld s5,72(sp)
+ 6c2: 6b06 ld s6,64(sp)
+ 6c4: 7be2 ld s7,56(sp)
+ 6c6: 7c42 ld s8,48(sp)
+ 6c8: 7ca2 ld s9,40(sp)
+ 6ca: 7d02 ld s10,32(sp)
+ 6cc: 6de2 ld s11,24(sp)
+ 6ce: 6109 addi sp,sp,128
+ 6d0: 8082 ret
+
+00000000000006d2 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6d2: 715d addi sp,sp,-80
+ 6d4: ec06 sd ra,24(sp)
+ 6d6: e822 sd s0,16(sp)
+ 6d8: 1000 addi s0,sp,32
+ 6da: e010 sd a2,0(s0)
+ 6dc: e414 sd a3,8(s0)
+ 6de: e818 sd a4,16(s0)
+ 6e0: ec1c sd a5,24(s0)
+ 6e2: 03043023 sd a6,32(s0)
+ 6e6: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6ea: 8622 mv a2,s0
+ 6ec: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6f0: 00000097 auipc ra,0x0
+ 6f4: e04080e7 jalr -508(ra) # 4f4 <vprintf>
+}
+ 6f8: 60e2 ld ra,24(sp)
+ 6fa: 6442 ld s0,16(sp)
+ 6fc: 6161 addi sp,sp,80
+ 6fe: 8082 ret
+
+0000000000000700 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 700: 711d addi sp,sp,-96
+ 702: ec06 sd ra,24(sp)
+ 704: e822 sd s0,16(sp)
+ 706: 1000 addi s0,sp,32
+ 708: e40c sd a1,8(s0)
+ 70a: e810 sd a2,16(s0)
+ 70c: ec14 sd a3,24(s0)
+ 70e: f018 sd a4,32(s0)
+ 710: f41c sd a5,40(s0)
+ 712: 03043823 sd a6,48(s0)
+ 716: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 71a: 00840613 addi a2,s0,8
+ 71e: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 722: 85aa mv a1,a0
+ 724: 4505 li a0,1
+ 726: 00000097 auipc ra,0x0
+ 72a: dce080e7 jalr -562(ra) # 4f4 <vprintf>
+}
+ 72e: 60e2 ld ra,24(sp)
+ 730: 6442 ld s0,16(sp)
+ 732: 6125 addi sp,sp,96
+ 734: 8082 ret
+
+0000000000000736 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 736: 1141 addi sp,sp,-16
+ 738: e422 sd s0,8(sp)
+ 73a: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 73c: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 740: 00000797 auipc a5,0x0
+ 744: 1f07b783 ld a5,496(a5) # 930 <freep>
+ 748: a02d j 772 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 74a: 4618 lw a4,8(a2)
+ 74c: 9f2d addw a4,a4,a1
+ 74e: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 752: 6398 ld a4,0(a5)
+ 754: 6310 ld a2,0(a4)
+ 756: a83d j 794 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 758: ff852703 lw a4,-8(a0)
+ 75c: 9f31 addw a4,a4,a2
+ 75e: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 760: ff053683 ld a3,-16(a0)
+ 764: a091 j 7a8 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 766: 6398 ld a4,0(a5)
+ 768: 00e7e463 bltu a5,a4,770 <free+0x3a>
+ 76c: 00e6ea63 bltu a3,a4,780 <free+0x4a>
+{
+ 770: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 772: fed7fae3 bgeu a5,a3,766 <free+0x30>
+ 776: 6398 ld a4,0(a5)
+ 778: 00e6e463 bltu a3,a4,780 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 77c: fee7eae3 bltu a5,a4,770 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 780: ff852583 lw a1,-8(a0)
+ 784: 6390 ld a2,0(a5)
+ 786: 02059813 slli a6,a1,0x20
+ 78a: 01c85713 srli a4,a6,0x1c
+ 78e: 9736 add a4,a4,a3
+ 790: fae60de3 beq a2,a4,74a <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 794: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 798: 4790 lw a2,8(a5)
+ 79a: 02061593 slli a1,a2,0x20
+ 79e: 01c5d713 srli a4,a1,0x1c
+ 7a2: 973e add a4,a4,a5
+ 7a4: fae68ae3 beq a3,a4,758 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 7a8: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 7aa: 00000717 auipc a4,0x0
+ 7ae: 18f73323 sd a5,390(a4) # 930 <freep>
+}
+ 7b2: 6422 ld s0,8(sp)
+ 7b4: 0141 addi sp,sp,16
+ 7b6: 8082 ret
+
+00000000000007b8 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 7b8: 7139 addi sp,sp,-64
+ 7ba: fc06 sd ra,56(sp)
+ 7bc: f822 sd s0,48(sp)
+ 7be: f426 sd s1,40(sp)
+ 7c0: f04a sd s2,32(sp)
+ 7c2: ec4e sd s3,24(sp)
+ 7c4: e852 sd s4,16(sp)
+ 7c6: e456 sd s5,8(sp)
+ 7c8: e05a sd s6,0(sp)
+ 7ca: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7cc: 02051493 slli s1,a0,0x20
+ 7d0: 9081 srli s1,s1,0x20
+ 7d2: 04bd addi s1,s1,15
+ 7d4: 8091 srli s1,s1,0x4
+ 7d6: 00148a1b addiw s4,s1,1
+ 7da: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7dc: 00000517 auipc a0,0x0
+ 7e0: 15453503 ld a0,340(a0) # 930 <freep>
+ 7e4: c515 beqz a0,810 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7e6: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7e8: 4798 lw a4,8(a5)
+ 7ea: 04977163 bgeu a4,s1,82c <malloc+0x74>
+ 7ee: 89d2 mv s3,s4
+ 7f0: 000a071b sext.w a4,s4
+ 7f4: 6685 lui a3,0x1
+ 7f6: 00d77363 bgeu a4,a3,7fc <malloc+0x44>
+ 7fa: 6985 lui s3,0x1
+ 7fc: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 800: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 804: 00000917 auipc s2,0x0
+ 808: 12c90913 addi s2,s2,300 # 930 <freep>
+ if(p == (char*)-1)
+ 80c: 5afd li s5,-1
+ 80e: a8a5 j 886 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 810: 00000797 auipc a5,0x0
+ 814: 12078793 addi a5,a5,288 # 930 <freep>
+ 818: 00000717 auipc a4,0x0
+ 81c: 12070713 addi a4,a4,288 # 938 <base>
+ 820: e398 sd a4,0(a5)
+ 822: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 824: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 828: 87ba mv a5,a4
+ 82a: b7d1 j 7ee <malloc+0x36>
+ if(p->s.size == nunits)
+ 82c: 02e48c63 beq s1,a4,864 <malloc+0xac>
+ p->s.size -= nunits;
+ 830: 4147073b subw a4,a4,s4
+ 834: c798 sw a4,8(a5)
+ p += p->s.size;
+ 836: 02071693 slli a3,a4,0x20
+ 83a: 01c6d713 srli a4,a3,0x1c
+ 83e: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 840: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 844: 00000717 auipc a4,0x0
+ 848: 0ea73623 sd a0,236(a4) # 930 <freep>
+ return (void*)(p + 1);
+ 84c: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 850: 70e2 ld ra,56(sp)
+ 852: 7442 ld s0,48(sp)
+ 854: 74a2 ld s1,40(sp)
+ 856: 7902 ld s2,32(sp)
+ 858: 69e2 ld s3,24(sp)
+ 85a: 6a42 ld s4,16(sp)
+ 85c: 6aa2 ld s5,8(sp)
+ 85e: 6b02 ld s6,0(sp)
+ 860: 6121 addi sp,sp,64
+ 862: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 864: 6398 ld a4,0(a5)
+ 866: e118 sd a4,0(a0)
+ 868: bff1 j 844 <malloc+0x8c>
+ hp->s.size = nu;
+ 86a: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 86e: 0541 addi a0,a0,16
+ 870: 00000097 auipc ra,0x0
+ 874: ec6080e7 jalr -314(ra) # 736 <free>
+ return freep;
+ 878: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 87c: d971 beqz a0,850 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 87e: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 880: 4798 lw a4,8(a5)
+ 882: fa9775e3 bgeu a4,s1,82c <malloc+0x74>
+ if(p == freep)
+ 886: 00093703 ld a4,0(s2)
+ 88a: 853e mv a0,a5
+ 88c: fef719e3 bne a4,a5,87e <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 890: 854e mv a0,s3
+ 892: 00000097 auipc ra,0x0
+ 896: b30080e7 jalr -1232(ra) # 3c2 <sbrk>
+ if(p == (char*)-1)
+ 89a: fd5518e3 bne a0,s5,86a <malloc+0xb2>
+ return 0;
+ 89e: 4501 li a0,0
+ 8a0: bf45 j 850 <malloc+0x98>
diff --git a/xv6-user/echo.c b/xv6-user/echo.c
new file mode 100644
index 0000000000000000000000000000000000000000..1eb7b7bcb050e38212e9614359ec93a8d5003188
--- /dev/null
+++ b/xv6-user/echo.c
@@ -0,0 +1,19 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+
+ for(i = 1; i < argc; i++){
+ write(1, argv[i], strlen(argv[i]));
+ if(i + 1 < argc){
+ write(1, " ", 1);
+ } else {
+ write(1, "\n", 1);
+ }
+ }
+ exit(0);
+}
diff --git a/xv6-user/echo.d b/xv6-user/echo.d
new file mode 100644
index 0000000000000000000000000000000000000000..537516d1d48c42af024851d4e7bb00b8d361e126
--- /dev/null
+++ b/xv6-user/echo.d
@@ -0,0 +1,2 @@
+xv6-user/echo.o: xv6-user/echo.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/echo.o b/xv6-user/echo.o
new file mode 100644
index 0000000000000000000000000000000000000000..2e732782bcae8afbbeadcceb0f0e805cdc8d877a
Binary files /dev/null and b/xv6-user/echo.o differ
diff --git a/xv6-user/echo.sym b/xv6-user/echo.sym
new file mode 100644
index 0000000000000000000000000000000000000000..6a80fee417e396a2b334ccfbaaed4262d0d6328d
--- /dev/null
+++ b/xv6-user/echo.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+00000000000008a8 .rodata
+0000000000000930 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 echo.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000428 putc
+000000000000044a printint
+0000000000000918 digits
+0000000000000000 umalloc.c
+0000000000000930 freep
+0000000000000938 base
+0000000000000084 strcpy
+0000000000000700 printf
+0000000000001129 __global_pointer$
+00000000000003e2 dev
+000000000000028a memmove
+0000000000000406 trace
+000000000000016a gets
+0000000000000929 __SDATA_BEGIN__
+00000000000003b8 getpid
+000000000000031c memcpy
+00000000000007b8 malloc
+00000000000003fc remove
+00000000000003ca sleep
+000000000000040e sysinfo
+00000000000003ec readdir
+000000000000034e pipe
+0000000000000416 rename
+0000000000000362 write
+0000000000000392 fstat
+00000000000006d2 fprintf
+0000000000000376 kill
+00000000000000a0 strcat
+00000000000004f4 vprintf
+00000000000003a6 chdir
+000000000000037e exec
+0000000000000346 wait
+0000000000000358 read
+00000000000002e2 memcmp
+0000000000000334 fork
+0000000000000948 __BSS_END__
+00000000000003c2 sbrk
+00000000000003da test_proc
+00000000000003d2 uptime
+0000000000000929 __bss_start
+0000000000000124 memset
+0000000000000000 main
+00000000000000ce strcmp
+000000000000041e shutdown
+00000000000003b0 dup
+00000000000003f4 getcwd
+0000000000000929 __DATA_BEGIN__
+00000000000001e4 stat
+0000000000000929 _edata
+0000000000000948 _end
+000000000000033c exit
+000000000000022a atoi
+00000000000000fa strlen
+0000000000000388 open
+0000000000000146 strchr
+000000000000039c mkdir
+000000000000036c close
+0000000000000736 free
diff --git a/xv6-user/find.asm b/xv6-user/find.asm
new file mode 100644
index 0000000000000000000000000000000000000000..ac6fe3c23192479f43bea5bcfbf3d9206340c6fc
--- /dev/null
+++ b/xv6-user/find.asm
@@ -0,0 +1,1619 @@
+
+xv6-user/_find: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <find>:
+#include "xv6-user/user.h"
+
+static char path[512];
+
+void find(char *filename)
+{
+ 0: 7175 addi sp,sp,-144
+ 2: e506 sd ra,136(sp)
+ 4: e122 sd s0,128(sp)
+ 6: fca6 sd s1,120(sp)
+ 8: f8ca sd s2,112(sp)
+ a: f4ce sd s3,104(sp)
+ c: f0d2 sd s4,96(sp)
+ e: ecd6 sd s5,88(sp)
+ 10: e8da sd s6,80(sp)
+ 12: e4de sd s7,72(sp)
+ 14: e0e2 sd s8,64(sp)
+ 16: 0900 addi s0,sp,144
+ 18: 8a2a mv s4,a0
+ int fd;
+ struct stat st;
+ if ((fd = open(path, O_RDONLY)) < 0) {
+ 1a: 4581 li a1,0
+ 1c: 00001517 auipc a0,0x1
+ 20: b0450513 addi a0,a0,-1276 # b20 <path>
+ 24: 00000097 auipc ra,0x0
+ 28: 4e6080e7 jalr 1254(ra) # 50a <open>
+ 2c: 04054163 bltz a0,6e <find+0x6e>
+ 30: 84aa mv s1,a0
+ fprintf(2, "find: cannot open %s\n", path);
+ return;
+ }
+ if (fstat(fd, &st) < 0) {
+ 32: f7840593 addi a1,s0,-136
+ 36: 00000097 auipc ra,0x0
+ 3a: 4de080e7 jalr 1246(ra) # 514 <fstat>
+ 3e: 04054663 bltz a0,8a <find+0x8a>
+ fprintf(2, "find: cannot stat %s\n", path);
+ close(fd);
+ return;
+ }
+ if (st.type != T_DIR) {
+ 42: fa041703 lh a4,-96(s0)
+ 46: 4785 li a5,1
+ 48: 06f70463 beq a4,a5,b0 <find+0xb0>
+ close(fd);
+ 4c: 8526 mv a0,s1
+ 4e: 00000097 auipc ra,0x0
+ 52: 4a0080e7 jalr 1184(ra) # 4ee <close>
+ }
+ find(filename);
+ }
+ close(fd);
+ return;
+}
+ 56: 60aa ld ra,136(sp)
+ 58: 640a ld s0,128(sp)
+ 5a: 74e6 ld s1,120(sp)
+ 5c: 7946 ld s2,112(sp)
+ 5e: 79a6 ld s3,104(sp)
+ 60: 7a06 ld s4,96(sp)
+ 62: 6ae6 ld s5,88(sp)
+ 64: 6b46 ld s6,80(sp)
+ 66: 6ba6 ld s7,72(sp)
+ 68: 6c06 ld s8,64(sp)
+ 6a: 6149 addi sp,sp,144
+ 6c: 8082 ret
+ fprintf(2, "find: cannot open %s\n", path);
+ 6e: 00001617 auipc a2,0x1
+ 72: ab260613 addi a2,a2,-1358 # b20 <path>
+ 76: 00001597 auipc a1,0x1
+ 7a: 9b258593 addi a1,a1,-1614 # a28 <malloc+0xee>
+ 7e: 4509 li a0,2
+ 80: 00000097 auipc ra,0x0
+ 84: 7d4080e7 jalr 2004(ra) # 854 <fprintf>
+ return;
+ 88: b7f9 j 56 <find+0x56>
+ fprintf(2, "find: cannot stat %s\n", path);
+ 8a: 00001617 auipc a2,0x1
+ 8e: a9660613 addi a2,a2,-1386 # b20 <path>
+ 92: 00001597 auipc a1,0x1
+ 96: 9ae58593 addi a1,a1,-1618 # a40 <malloc+0x106>
+ 9a: 4509 li a0,2
+ 9c: 00000097 auipc ra,0x0
+ a0: 7b8080e7 jalr 1976(ra) # 854 <fprintf>
+ close(fd);
+ a4: 8526 mv a0,s1
+ a6: 00000097 auipc ra,0x0
+ aa: 448080e7 jalr 1096(ra) # 4ee <close>
+ return;
+ ae: b765 j 56 <find+0x56>
+ if (strlen(path) + 255 + 2 > sizeof(path)) {
+ b0: 00001517 auipc a0,0x1
+ b4: a7050513 addi a0,a0,-1424 # b20 <path>
+ b8: 00000097 auipc ra,0x0
+ bc: 1c4080e7 jalr 452(ra) # 27c <strlen>
+ c0: 1015051b addiw a0,a0,257
+ c4: 20000793 li a5,512
+ c8: 0aa7e863 bltu a5,a0,178 <find+0x178>
+ char *p = path + strlen(path) - 1;
+ cc: 00001917 auipc s2,0x1
+ d0: a5490913 addi s2,s2,-1452 # b20 <path>
+ d4: 854a mv a0,s2
+ d6: 00000097 auipc ra,0x0
+ da: 1a6080e7 jalr 422(ra) # 27c <strlen>
+ de: 1502 slli a0,a0,0x20
+ e0: 9101 srli a0,a0,0x20
+ e2: fff50793 addi a5,a0,-1
+ e6: 993e add s2,s2,a5
+ if (*p != '/') {
+ e8: 00094703 lbu a4,0(s2)
+ ec: 02f00793 li a5,47
+ f0: 00f70963 beq a4,a5,102 <find+0x102>
+ *++p = '/';
+ f4: 00f900a3 sb a5,1(s2)
+ f8: 00001917 auipc s2,0x1
+ fc: a2890913 addi s2,s2,-1496 # b20 <path>
+ 100: 992a add s2,s2,a0
+ p++;
+ 102: 0905 addi s2,s2,1
+ while (readdir(fd, &st)) {
+ 104: f7840993 addi s3,s0,-136
+ if (strcmp(p, ".") == 0 || strcmp(p, "..") == 0) {
+ 108: 00001a97 auipc s5,0x1
+ 10c: 968a8a93 addi s5,s5,-1688 # a70 <malloc+0x136>
+ 110: 00001b17 auipc s6,0x1
+ 114: 968b0b13 addi s6,s6,-1688 # a78 <malloc+0x13e>
+ fprintf(1, "%s\n", path);
+ 118: 00001c17 auipc s8,0x1
+ 11c: a08c0c13 addi s8,s8,-1528 # b20 <path>
+ 120: 00001b97 auipc s7,0x1
+ 124: 960b8b93 addi s7,s7,-1696 # a80 <malloc+0x146>
+ while (readdir(fd, &st)) {
+ 128: 85ce mv a1,s3
+ 12a: 8526 mv a0,s1
+ 12c: 00000097 auipc ra,0x0
+ 130: 442080e7 jalr 1090(ra) # 56e <readdir>
+ 134: c92d beqz a0,1a6 <find+0x1a6>
+ strcpy(p, st.name);
+ 136: 85ce mv a1,s3
+ 138: 854a mv a0,s2
+ 13a: 00000097 auipc ra,0x0
+ 13e: 0cc080e7 jalr 204(ra) # 206 <strcpy>
+ if (strcmp(p, ".") == 0 || strcmp(p, "..") == 0) {
+ 142: 85d6 mv a1,s5
+ 144: 854a mv a0,s2
+ 146: 00000097 auipc ra,0x0
+ 14a: 10a080e7 jalr 266(ra) # 250 <strcmp>
+ 14e: dd69 beqz a0,128 <find+0x128>
+ 150: 85da mv a1,s6
+ 152: 854a mv a0,s2
+ 154: 00000097 auipc ra,0x0
+ 158: 0fc080e7 jalr 252(ra) # 250 <strcmp>
+ 15c: d571 beqz a0,128 <find+0x128>
+ if (strcmp(p, filename) == 0) {
+ 15e: 85d2 mv a1,s4
+ 160: 854a mv a0,s2
+ 162: 00000097 auipc ra,0x0
+ 166: 0ee080e7 jalr 238(ra) # 250 <strcmp>
+ 16a: c515 beqz a0,196 <find+0x196>
+ find(filename);
+ 16c: 8552 mv a0,s4
+ 16e: 00000097 auipc ra,0x0
+ 172: e92080e7 jalr -366(ra) # 0 <find>
+ 176: bf4d j 128 <find+0x128>
+ fprintf(2, "find: path too long\n");
+ 178: 00001597 auipc a1,0x1
+ 17c: 8e058593 addi a1,a1,-1824 # a58 <malloc+0x11e>
+ 180: 4509 li a0,2
+ 182: 00000097 auipc ra,0x0
+ 186: 6d2080e7 jalr 1746(ra) # 854 <fprintf>
+ close(fd);
+ 18a: 8526 mv a0,s1
+ 18c: 00000097 auipc ra,0x0
+ 190: 362080e7 jalr 866(ra) # 4ee <close>
+ return;
+ 194: b5c9 j 56 <find+0x56>
+ fprintf(1, "%s\n", path);
+ 196: 8662 mv a2,s8
+ 198: 85de mv a1,s7
+ 19a: 4505 li a0,1
+ 19c: 00000097 auipc ra,0x0
+ 1a0: 6b8080e7 jalr 1720(ra) # 854 <fprintf>
+ 1a4: b7e1 j 16c <find+0x16c>
+ close(fd);
+ 1a6: 8526 mv a0,s1
+ 1a8: 00000097 auipc ra,0x0
+ 1ac: 346080e7 jalr 838(ra) # 4ee <close>
+ return;
+ 1b0: b55d j 56 <find+0x56>
+
+00000000000001b2 <main>:
+
+
+int main(int argc, char *argv[])
+{
+ 1b2: 1101 addi sp,sp,-32
+ 1b4: ec06 sd ra,24(sp)
+ 1b6: e822 sd s0,16(sp)
+ 1b8: e426 sd s1,8(sp)
+ 1ba: 1000 addi s0,sp,32
+ if (argc < 3) {
+ 1bc: 4789 li a5,2
+ 1be: 02a7c063 blt a5,a0,1de <main+0x2c>
+ fprintf(2, "Usage: find DIR FILENAME\n");
+ 1c2: 00001597 auipc a1,0x1
+ 1c6: 8c658593 addi a1,a1,-1850 # a88 <malloc+0x14e>
+ 1ca: 4509 li a0,2
+ 1cc: 00000097 auipc ra,0x0
+ 1d0: 688080e7 jalr 1672(ra) # 854 <fprintf>
+ exit(0);
+ 1d4: 4501 li a0,0
+ 1d6: 00000097 auipc ra,0x0
+ 1da: 2e8080e7 jalr 744(ra) # 4be <exit>
+ 1de: 84ae mv s1,a1
+ } else {
+ strcpy(path, argv[1]);
+ 1e0: 658c ld a1,8(a1)
+ 1e2: 00001517 auipc a0,0x1
+ 1e6: 93e50513 addi a0,a0,-1730 # b20 <path>
+ 1ea: 00000097 auipc ra,0x0
+ 1ee: 01c080e7 jalr 28(ra) # 206 <strcpy>
+ find(argv[2]);
+ 1f2: 6888 ld a0,16(s1)
+ 1f4: 00000097 auipc ra,0x0
+ 1f8: e0c080e7 jalr -500(ra) # 0 <find>
+ }
+ exit(0);
+ 1fc: 4501 li a0,0
+ 1fe: 00000097 auipc ra,0x0
+ 202: 2c0080e7 jalr 704(ra) # 4be <exit>
+
+0000000000000206 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 206: 1141 addi sp,sp,-16
+ 208: e422 sd s0,8(sp)
+ 20a: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 20c: 87aa mv a5,a0
+ 20e: 0585 addi a1,a1,1
+ 210: 0785 addi a5,a5,1
+ 212: fff5c703 lbu a4,-1(a1)
+ 216: fee78fa3 sb a4,-1(a5)
+ 21a: fb75 bnez a4,20e <strcpy+0x8>
+ ;
+ return os;
+}
+ 21c: 6422 ld s0,8(sp)
+ 21e: 0141 addi sp,sp,16
+ 220: 8082 ret
+
+0000000000000222 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 222: 1141 addi sp,sp,-16
+ 224: e422 sd s0,8(sp)
+ 226: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 228: 00054783 lbu a5,0(a0)
+ 22c: c385 beqz a5,24c <strcat+0x2a>
+ 22e: 87aa mv a5,a0
+ s++;
+ 230: 0785 addi a5,a5,1
+ while(*s)
+ 232: 0007c703 lbu a4,0(a5)
+ 236: ff6d bnez a4,230 <strcat+0xe>
+ while((*s++ = *t++))
+ 238: 0585 addi a1,a1,1
+ 23a: 0785 addi a5,a5,1
+ 23c: fff5c703 lbu a4,-1(a1)
+ 240: fee78fa3 sb a4,-1(a5)
+ 244: fb75 bnez a4,238 <strcat+0x16>
+ ;
+ return os;
+}
+ 246: 6422 ld s0,8(sp)
+ 248: 0141 addi sp,sp,16
+ 24a: 8082 ret
+ while(*s)
+ 24c: 87aa mv a5,a0
+ 24e: b7ed j 238 <strcat+0x16>
+
+0000000000000250 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 250: 1141 addi sp,sp,-16
+ 252: e422 sd s0,8(sp)
+ 254: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 256: 00054783 lbu a5,0(a0)
+ 25a: cb91 beqz a5,26e <strcmp+0x1e>
+ 25c: 0005c703 lbu a4,0(a1)
+ 260: 00f71763 bne a4,a5,26e <strcmp+0x1e>
+ p++, q++;
+ 264: 0505 addi a0,a0,1
+ 266: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 268: 00054783 lbu a5,0(a0)
+ 26c: fbe5 bnez a5,25c <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 26e: 0005c503 lbu a0,0(a1)
+}
+ 272: 40a7853b subw a0,a5,a0
+ 276: 6422 ld s0,8(sp)
+ 278: 0141 addi sp,sp,16
+ 27a: 8082 ret
+
+000000000000027c <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 27c: 1141 addi sp,sp,-16
+ 27e: e422 sd s0,8(sp)
+ 280: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 282: 00054783 lbu a5,0(a0)
+ 286: cf91 beqz a5,2a2 <strlen+0x26>
+ 288: 0505 addi a0,a0,1
+ 28a: 87aa mv a5,a0
+ 28c: 4685 li a3,1
+ 28e: 9e89 subw a3,a3,a0
+ 290: 00f6853b addw a0,a3,a5
+ 294: 0785 addi a5,a5,1
+ 296: fff7c703 lbu a4,-1(a5)
+ 29a: fb7d bnez a4,290 <strlen+0x14>
+ ;
+ return n;
+}
+ 29c: 6422 ld s0,8(sp)
+ 29e: 0141 addi sp,sp,16
+ 2a0: 8082 ret
+ for(n = 0; s[n]; n++)
+ 2a2: 4501 li a0,0
+ 2a4: bfe5 j 29c <strlen+0x20>
+
+00000000000002a6 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 2a6: 1141 addi sp,sp,-16
+ 2a8: e422 sd s0,8(sp)
+ 2aa: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 2ac: ca19 beqz a2,2c2 <memset+0x1c>
+ 2ae: 87aa mv a5,a0
+ 2b0: 1602 slli a2,a2,0x20
+ 2b2: 9201 srli a2,a2,0x20
+ 2b4: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 2b8: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 2bc: 0785 addi a5,a5,1
+ 2be: fee79de3 bne a5,a4,2b8 <memset+0x12>
+ }
+ return dst;
+}
+ 2c2: 6422 ld s0,8(sp)
+ 2c4: 0141 addi sp,sp,16
+ 2c6: 8082 ret
+
+00000000000002c8 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 2c8: 1141 addi sp,sp,-16
+ 2ca: e422 sd s0,8(sp)
+ 2cc: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 2ce: 00054783 lbu a5,0(a0)
+ 2d2: cb99 beqz a5,2e8 <strchr+0x20>
+ if(*s == c)
+ 2d4: 00f58763 beq a1,a5,2e2 <strchr+0x1a>
+ for(; *s; s++)
+ 2d8: 0505 addi a0,a0,1
+ 2da: 00054783 lbu a5,0(a0)
+ 2de: fbfd bnez a5,2d4 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 2e0: 4501 li a0,0
+}
+ 2e2: 6422 ld s0,8(sp)
+ 2e4: 0141 addi sp,sp,16
+ 2e6: 8082 ret
+ return 0;
+ 2e8: 4501 li a0,0
+ 2ea: bfe5 j 2e2 <strchr+0x1a>
+
+00000000000002ec <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 2ec: 711d addi sp,sp,-96
+ 2ee: ec86 sd ra,88(sp)
+ 2f0: e8a2 sd s0,80(sp)
+ 2f2: e4a6 sd s1,72(sp)
+ 2f4: e0ca sd s2,64(sp)
+ 2f6: fc4e sd s3,56(sp)
+ 2f8: f852 sd s4,48(sp)
+ 2fa: f456 sd s5,40(sp)
+ 2fc: f05a sd s6,32(sp)
+ 2fe: ec5e sd s7,24(sp)
+ 300: e862 sd s8,16(sp)
+ 302: 1080 addi s0,sp,96
+ 304: 8baa mv s7,a0
+ 306: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 308: 892a mv s2,a0
+ 30a: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 30c: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 310: 4b29 li s6,10
+ 312: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 314: 89a6 mv s3,s1
+ 316: 2485 addiw s1,s1,1
+ 318: 0344d763 bge s1,s4,346 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 31c: 4605 li a2,1
+ 31e: 85d6 mv a1,s5
+ 320: 4501 li a0,0
+ 322: 00000097 auipc ra,0x0
+ 326: 1b8080e7 jalr 440(ra) # 4da <read>
+ if(cc < 1)
+ 32a: 00a05e63 blez a0,346 <gets+0x5a>
+ buf[i++] = c;
+ 32e: faf44783 lbu a5,-81(s0)
+ 332: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 336: 01678763 beq a5,s6,344 <gets+0x58>
+ 33a: 0905 addi s2,s2,1
+ 33c: fd879ce3 bne a5,s8,314 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 340: 89a6 mv s3,s1
+ 342: a011 j 346 <gets+0x5a>
+ 344: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 346: 99de add s3,s3,s7
+ 348: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 34c: 855e mv a0,s7
+ 34e: 60e6 ld ra,88(sp)
+ 350: 6446 ld s0,80(sp)
+ 352: 64a6 ld s1,72(sp)
+ 354: 6906 ld s2,64(sp)
+ 356: 79e2 ld s3,56(sp)
+ 358: 7a42 ld s4,48(sp)
+ 35a: 7aa2 ld s5,40(sp)
+ 35c: 7b02 ld s6,32(sp)
+ 35e: 6be2 ld s7,24(sp)
+ 360: 6c42 ld s8,16(sp)
+ 362: 6125 addi sp,sp,96
+ 364: 8082 ret
+
+0000000000000366 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 366: 1101 addi sp,sp,-32
+ 368: ec06 sd ra,24(sp)
+ 36a: e822 sd s0,16(sp)
+ 36c: e426 sd s1,8(sp)
+ 36e: e04a sd s2,0(sp)
+ 370: 1000 addi s0,sp,32
+ 372: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 374: 4581 li a1,0
+ 376: 00000097 auipc ra,0x0
+ 37a: 194080e7 jalr 404(ra) # 50a <open>
+ if(fd < 0)
+ 37e: 02054563 bltz a0,3a8 <stat+0x42>
+ 382: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 384: 85ca mv a1,s2
+ 386: 00000097 auipc ra,0x0
+ 38a: 18e080e7 jalr 398(ra) # 514 <fstat>
+ 38e: 892a mv s2,a0
+ close(fd);
+ 390: 8526 mv a0,s1
+ 392: 00000097 auipc ra,0x0
+ 396: 15c080e7 jalr 348(ra) # 4ee <close>
+ return r;
+}
+ 39a: 854a mv a0,s2
+ 39c: 60e2 ld ra,24(sp)
+ 39e: 6442 ld s0,16(sp)
+ 3a0: 64a2 ld s1,8(sp)
+ 3a2: 6902 ld s2,0(sp)
+ 3a4: 6105 addi sp,sp,32
+ 3a6: 8082 ret
+ return -1;
+ 3a8: 597d li s2,-1
+ 3aa: bfc5 j 39a <stat+0x34>
+
+00000000000003ac <atoi>:
+
+int
+atoi(const char *s)
+{
+ 3ac: 1141 addi sp,sp,-16
+ 3ae: e422 sd s0,8(sp)
+ 3b0: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 3b2: 00054703 lbu a4,0(a0)
+ 3b6: 02d00793 li a5,45
+ int neg = 1;
+ 3ba: 4585 li a1,1
+ if (*s == '-') {
+ 3bc: 04f70363 beq a4,a5,402 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 3c0: 00054703 lbu a4,0(a0)
+ 3c4: fd07079b addiw a5,a4,-48
+ 3c8: 0ff7f793 zext.b a5,a5
+ 3cc: 46a5 li a3,9
+ 3ce: 02f6ed63 bltu a3,a5,408 <atoi+0x5c>
+ n = 0;
+ 3d2: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 3d4: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 3d6: 0505 addi a0,a0,1
+ 3d8: 0026979b slliw a5,a3,0x2
+ 3dc: 9fb5 addw a5,a5,a3
+ 3de: 0017979b slliw a5,a5,0x1
+ 3e2: 9fb9 addw a5,a5,a4
+ 3e4: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 3e8: 00054703 lbu a4,0(a0)
+ 3ec: fd07079b addiw a5,a4,-48
+ 3f0: 0ff7f793 zext.b a5,a5
+ 3f4: fef671e3 bgeu a2,a5,3d6 <atoi+0x2a>
+ return n * neg;
+}
+ 3f8: 02d5853b mulw a0,a1,a3
+ 3fc: 6422 ld s0,8(sp)
+ 3fe: 0141 addi sp,sp,16
+ 400: 8082 ret
+ s++;
+ 402: 0505 addi a0,a0,1
+ neg = -1;
+ 404: 55fd li a1,-1
+ 406: bf6d j 3c0 <atoi+0x14>
+ n = 0;
+ 408: 4681 li a3,0
+ 40a: b7fd j 3f8 <atoi+0x4c>
+
+000000000000040c <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 40c: 1141 addi sp,sp,-16
+ 40e: e422 sd s0,8(sp)
+ 410: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 412: 02b57463 bgeu a0,a1,43a <memmove+0x2e>
+ while(n-- > 0)
+ 416: 00c05f63 blez a2,434 <memmove+0x28>
+ 41a: 1602 slli a2,a2,0x20
+ 41c: 9201 srli a2,a2,0x20
+ 41e: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 422: 872a mv a4,a0
+ *dst++ = *src++;
+ 424: 0585 addi a1,a1,1
+ 426: 0705 addi a4,a4,1
+ 428: fff5c683 lbu a3,-1(a1)
+ 42c: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 430: fee79ae3 bne a5,a4,424 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 434: 6422 ld s0,8(sp)
+ 436: 0141 addi sp,sp,16
+ 438: 8082 ret
+ dst += n;
+ 43a: 00c50733 add a4,a0,a2
+ src += n;
+ 43e: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 440: fec05ae3 blez a2,434 <memmove+0x28>
+ 444: fff6079b addiw a5,a2,-1
+ 448: 1782 slli a5,a5,0x20
+ 44a: 9381 srli a5,a5,0x20
+ 44c: fff7c793 not a5,a5
+ 450: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 452: 15fd addi a1,a1,-1
+ 454: 177d addi a4,a4,-1
+ 456: 0005c683 lbu a3,0(a1)
+ 45a: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 45e: fee79ae3 bne a5,a4,452 <memmove+0x46>
+ 462: bfc9 j 434 <memmove+0x28>
+
+0000000000000464 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 464: 1141 addi sp,sp,-16
+ 466: e422 sd s0,8(sp)
+ 468: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 46a: ca05 beqz a2,49a <memcmp+0x36>
+ 46c: fff6069b addiw a3,a2,-1
+ 470: 1682 slli a3,a3,0x20
+ 472: 9281 srli a3,a3,0x20
+ 474: 0685 addi a3,a3,1
+ 476: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 478: 00054783 lbu a5,0(a0)
+ 47c: 0005c703 lbu a4,0(a1)
+ 480: 00e79863 bne a5,a4,490 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 484: 0505 addi a0,a0,1
+ p2++;
+ 486: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 488: fed518e3 bne a0,a3,478 <memcmp+0x14>
+ }
+ return 0;
+ 48c: 4501 li a0,0
+ 48e: a019 j 494 <memcmp+0x30>
+ return *p1 - *p2;
+ 490: 40e7853b subw a0,a5,a4
+}
+ 494: 6422 ld s0,8(sp)
+ 496: 0141 addi sp,sp,16
+ 498: 8082 ret
+ return 0;
+ 49a: 4501 li a0,0
+ 49c: bfe5 j 494 <memcmp+0x30>
+
+000000000000049e <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 49e: 1141 addi sp,sp,-16
+ 4a0: e406 sd ra,8(sp)
+ 4a2: e022 sd s0,0(sp)
+ 4a4: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 4a6: 00000097 auipc ra,0x0
+ 4aa: f66080e7 jalr -154(ra) # 40c <memmove>
+}
+ 4ae: 60a2 ld ra,8(sp)
+ 4b0: 6402 ld s0,0(sp)
+ 4b2: 0141 addi sp,sp,16
+ 4b4: 8082 ret
+
+00000000000004b6 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 4b6: 4885 li a7,1
+ ecall
+ 4b8: 00000073 ecall
+ ret
+ 4bc: 8082 ret
+
+00000000000004be <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 4be: 05d00893 li a7,93
+ ecall
+ 4c2: 00000073 ecall
+ ret
+ 4c6: 8082 ret
+
+00000000000004c8 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 4c8: 488d li a7,3
+ ecall
+ 4ca: 00000073 ecall
+ ret
+ 4ce: 8082 ret
+
+00000000000004d0 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 4d0: 03b00893 li a7,59
+ ecall
+ 4d4: 00000073 ecall
+ ret
+ 4d8: 8082 ret
+
+00000000000004da <read>:
+.global read
+read:
+ li a7, SYS_read
+ 4da: 03f00893 li a7,63
+ ecall
+ 4de: 00000073 ecall
+ ret
+ 4e2: 8082 ret
+
+00000000000004e4 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 4e4: 04000893 li a7,64
+ ecall
+ 4e8: 00000073 ecall
+ ret
+ 4ec: 8082 ret
+
+00000000000004ee <close>:
+.global close
+close:
+ li a7, SYS_close
+ 4ee: 03900893 li a7,57
+ ecall
+ 4f2: 00000073 ecall
+ ret
+ 4f6: 8082 ret
+
+00000000000004f8 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 4f8: 4899 li a7,6
+ ecall
+ 4fa: 00000073 ecall
+ ret
+ 4fe: 8082 ret
+
+0000000000000500 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 500: 0dd00893 li a7,221
+ ecall
+ 504: 00000073 ecall
+ ret
+ 508: 8082 ret
+
+000000000000050a <open>:
+.global open
+open:
+ li a7, SYS_open
+ 50a: 03800893 li a7,56
+ ecall
+ 50e: 00000073 ecall
+ ret
+ 512: 8082 ret
+
+0000000000000514 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 514: 05000893 li a7,80
+ ecall
+ 518: 00000073 ecall
+ ret
+ 51c: 8082 ret
+
+000000000000051e <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 51e: 02200893 li a7,34
+ ecall
+ 522: 00000073 ecall
+ ret
+ 526: 8082 ret
+
+0000000000000528 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 528: 03100893 li a7,49
+ ecall
+ 52c: 00000073 ecall
+ ret
+ 530: 8082 ret
+
+0000000000000532 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 532: 48dd li a7,23
+ ecall
+ 534: 00000073 ecall
+ ret
+ 538: 8082 ret
+
+000000000000053a <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 53a: 0ac00893 li a7,172
+ ecall
+ 53e: 00000073 ecall
+ ret
+ 542: 8082 ret
+
+0000000000000544 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 544: 48b1 li a7,12
+ ecall
+ 546: 00000073 ecall
+ ret
+ 54a: 8082 ret
+
+000000000000054c <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 54c: 48b5 li a7,13
+ ecall
+ 54e: 00000073 ecall
+ ret
+ 552: 8082 ret
+
+0000000000000554 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 554: 48b9 li a7,14
+ ecall
+ 556: 00000073 ecall
+ ret
+ 55a: 8082 ret
+
+000000000000055c <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 55c: 48d9 li a7,22
+ ecall
+ 55e: 00000073 ecall
+ ret
+ 562: 8082 ret
+
+0000000000000564 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 564: 03200893 li a7,50
+ ecall
+ 568: 00000073 ecall
+ ret
+ 56c: 8082 ret
+
+000000000000056e <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 56e: 48ed li a7,27
+ ecall
+ 570: 00000073 ecall
+ ret
+ 574: 8082 ret
+
+0000000000000576 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 576: 48c5 li a7,17
+ ecall
+ 578: 00000073 ecall
+ ret
+ 57c: 8082 ret
+
+000000000000057e <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 57e: 07500893 li a7,117
+ ecall
+ 582: 00000073 ecall
+ ret
+ 586: 8082 ret
+
+0000000000000588 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 588: 48c9 li a7,18
+ ecall
+ 58a: 00000073 ecall
+ ret
+ 58e: 8082 ret
+
+0000000000000590 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 590: 48cd li a7,19
+ ecall
+ 592: 00000073 ecall
+ ret
+ 596: 8082 ret
+
+0000000000000598 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 598: 48e9 li a7,26
+ ecall
+ 59a: 00000073 ecall
+ ret
+ 59e: 8082 ret
+
+00000000000005a0 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 5a0: 0d200893 li a7,210
+ ecall
+ 5a4: 00000073 ecall
+ ret
+ 5a8: 8082 ret
+
+00000000000005aa <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 5aa: 1101 addi sp,sp,-32
+ 5ac: ec06 sd ra,24(sp)
+ 5ae: e822 sd s0,16(sp)
+ 5b0: 1000 addi s0,sp,32
+ 5b2: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 5b6: 4605 li a2,1
+ 5b8: fef40593 addi a1,s0,-17
+ 5bc: 00000097 auipc ra,0x0
+ 5c0: f28080e7 jalr -216(ra) # 4e4 <write>
+}
+ 5c4: 60e2 ld ra,24(sp)
+ 5c6: 6442 ld s0,16(sp)
+ 5c8: 6105 addi sp,sp,32
+ 5ca: 8082 ret
+
+00000000000005cc <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 5cc: 7139 addi sp,sp,-64
+ 5ce: fc06 sd ra,56(sp)
+ 5d0: f822 sd s0,48(sp)
+ 5d2: f426 sd s1,40(sp)
+ 5d4: f04a sd s2,32(sp)
+ 5d6: ec4e sd s3,24(sp)
+ 5d8: 0080 addi s0,sp,64
+ 5da: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 5dc: c299 beqz a3,5e2 <printint+0x16>
+ 5de: 0805c863 bltz a1,66e <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 5e2: 2581 sext.w a1,a1
+ neg = 0;
+ 5e4: 4881 li a7,0
+ }
+
+ i = 0;
+ 5e6: fc040993 addi s3,s0,-64
+ neg = 0;
+ 5ea: 86ce mv a3,s3
+ i = 0;
+ 5ec: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 5ee: 2601 sext.w a2,a2
+ 5f0: 00000517 auipc a0,0x0
+ 5f4: 51850513 addi a0,a0,1304 # b08 <digits>
+ 5f8: 883a mv a6,a4
+ 5fa: 2705 addiw a4,a4,1
+ 5fc: 02c5f7bb remuw a5,a1,a2
+ 600: 1782 slli a5,a5,0x20
+ 602: 9381 srli a5,a5,0x20
+ 604: 97aa add a5,a5,a0
+ 606: 0007c783 lbu a5,0(a5)
+ 60a: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 60e: 0005879b sext.w a5,a1
+ 612: 02c5d5bb divuw a1,a1,a2
+ 616: 0685 addi a3,a3,1
+ 618: fec7f0e3 bgeu a5,a2,5f8 <printint+0x2c>
+ if(neg)
+ 61c: 00088c63 beqz a7,634 <printint+0x68>
+ buf[i++] = '-';
+ 620: fd070793 addi a5,a4,-48
+ 624: 00878733 add a4,a5,s0
+ 628: 02d00793 li a5,45
+ 62c: fef70823 sb a5,-16(a4)
+ 630: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 634: 02e05663 blez a4,660 <printint+0x94>
+ 638: fc040913 addi s2,s0,-64
+ 63c: 993a add s2,s2,a4
+ 63e: 19fd addi s3,s3,-1
+ 640: 99ba add s3,s3,a4
+ 642: 377d addiw a4,a4,-1
+ 644: 1702 slli a4,a4,0x20
+ 646: 9301 srli a4,a4,0x20
+ 648: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 64c: fff94583 lbu a1,-1(s2)
+ 650: 8526 mv a0,s1
+ 652: 00000097 auipc ra,0x0
+ 656: f58080e7 jalr -168(ra) # 5aa <putc>
+ while(--i >= 0)
+ 65a: 197d addi s2,s2,-1
+ 65c: ff3918e3 bne s2,s3,64c <printint+0x80>
+}
+ 660: 70e2 ld ra,56(sp)
+ 662: 7442 ld s0,48(sp)
+ 664: 74a2 ld s1,40(sp)
+ 666: 7902 ld s2,32(sp)
+ 668: 69e2 ld s3,24(sp)
+ 66a: 6121 addi sp,sp,64
+ 66c: 8082 ret
+ x = -xx;
+ 66e: 40b005bb negw a1,a1
+ neg = 1;
+ 672: 4885 li a7,1
+ x = -xx;
+ 674: bf8d j 5e6 <printint+0x1a>
+
+0000000000000676 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 676: 7119 addi sp,sp,-128
+ 678: fc86 sd ra,120(sp)
+ 67a: f8a2 sd s0,112(sp)
+ 67c: f4a6 sd s1,104(sp)
+ 67e: f0ca sd s2,96(sp)
+ 680: ecce sd s3,88(sp)
+ 682: e8d2 sd s4,80(sp)
+ 684: e4d6 sd s5,72(sp)
+ 686: e0da sd s6,64(sp)
+ 688: fc5e sd s7,56(sp)
+ 68a: f862 sd s8,48(sp)
+ 68c: f466 sd s9,40(sp)
+ 68e: f06a sd s10,32(sp)
+ 690: ec6e sd s11,24(sp)
+ 692: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 694: 0005c903 lbu s2,0(a1)
+ 698: 18090f63 beqz s2,836 <vprintf+0x1c0>
+ 69c: 8aaa mv s5,a0
+ 69e: 8b32 mv s6,a2
+ 6a0: 00158493 addi s1,a1,1
+ state = 0;
+ 6a4: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 6a6: 02500a13 li s4,37
+ 6aa: 4c55 li s8,21
+ 6ac: 00000c97 auipc s9,0x0
+ 6b0: 404c8c93 addi s9,s9,1028 # ab0 <malloc+0x176>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 6b4: 02800d93 li s11,40
+ putc(fd, 'x');
+ 6b8: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 6ba: 00000b97 auipc s7,0x0
+ 6be: 44eb8b93 addi s7,s7,1102 # b08 <digits>
+ 6c2: a839 j 6e0 <vprintf+0x6a>
+ putc(fd, c);
+ 6c4: 85ca mv a1,s2
+ 6c6: 8556 mv a0,s5
+ 6c8: 00000097 auipc ra,0x0
+ 6cc: ee2080e7 jalr -286(ra) # 5aa <putc>
+ 6d0: a019 j 6d6 <vprintf+0x60>
+ } else if(state == '%'){
+ 6d2: 01498d63 beq s3,s4,6ec <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 6d6: 0485 addi s1,s1,1
+ 6d8: fff4c903 lbu s2,-1(s1)
+ 6dc: 14090d63 beqz s2,836 <vprintf+0x1c0>
+ if(state == 0){
+ 6e0: fe0999e3 bnez s3,6d2 <vprintf+0x5c>
+ if(c == '%'){
+ 6e4: ff4910e3 bne s2,s4,6c4 <vprintf+0x4e>
+ state = '%';
+ 6e8: 89d2 mv s3,s4
+ 6ea: b7f5 j 6d6 <vprintf+0x60>
+ if(c == 'd'){
+ 6ec: 11490c63 beq s2,s4,804 <vprintf+0x18e>
+ 6f0: f9d9079b addiw a5,s2,-99
+ 6f4: 0ff7f793 zext.b a5,a5
+ 6f8: 10fc6e63 bltu s8,a5,814 <vprintf+0x19e>
+ 6fc: f9d9079b addiw a5,s2,-99
+ 700: 0ff7f713 zext.b a4,a5
+ 704: 10ec6863 bltu s8,a4,814 <vprintf+0x19e>
+ 708: 00271793 slli a5,a4,0x2
+ 70c: 97e6 add a5,a5,s9
+ 70e: 439c lw a5,0(a5)
+ 710: 97e6 add a5,a5,s9
+ 712: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 714: 008b0913 addi s2,s6,8
+ 718: 4685 li a3,1
+ 71a: 4629 li a2,10
+ 71c: 000b2583 lw a1,0(s6)
+ 720: 8556 mv a0,s5
+ 722: 00000097 auipc ra,0x0
+ 726: eaa080e7 jalr -342(ra) # 5cc <printint>
+ 72a: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 72c: 4981 li s3,0
+ 72e: b765 j 6d6 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 730: 008b0913 addi s2,s6,8
+ 734: 4681 li a3,0
+ 736: 4629 li a2,10
+ 738: 000b2583 lw a1,0(s6)
+ 73c: 8556 mv a0,s5
+ 73e: 00000097 auipc ra,0x0
+ 742: e8e080e7 jalr -370(ra) # 5cc <printint>
+ 746: 8b4a mv s6,s2
+ state = 0;
+ 748: 4981 li s3,0
+ 74a: b771 j 6d6 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 74c: 008b0913 addi s2,s6,8
+ 750: 4681 li a3,0
+ 752: 866a mv a2,s10
+ 754: 000b2583 lw a1,0(s6)
+ 758: 8556 mv a0,s5
+ 75a: 00000097 auipc ra,0x0
+ 75e: e72080e7 jalr -398(ra) # 5cc <printint>
+ 762: 8b4a mv s6,s2
+ state = 0;
+ 764: 4981 li s3,0
+ 766: bf85 j 6d6 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 768: 008b0793 addi a5,s6,8
+ 76c: f8f43423 sd a5,-120(s0)
+ 770: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 774: 03000593 li a1,48
+ 778: 8556 mv a0,s5
+ 77a: 00000097 auipc ra,0x0
+ 77e: e30080e7 jalr -464(ra) # 5aa <putc>
+ putc(fd, 'x');
+ 782: 07800593 li a1,120
+ 786: 8556 mv a0,s5
+ 788: 00000097 auipc ra,0x0
+ 78c: e22080e7 jalr -478(ra) # 5aa <putc>
+ 790: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 792: 03c9d793 srli a5,s3,0x3c
+ 796: 97de add a5,a5,s7
+ 798: 0007c583 lbu a1,0(a5)
+ 79c: 8556 mv a0,s5
+ 79e: 00000097 auipc ra,0x0
+ 7a2: e0c080e7 jalr -500(ra) # 5aa <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 7a6: 0992 slli s3,s3,0x4
+ 7a8: 397d addiw s2,s2,-1
+ 7aa: fe0914e3 bnez s2,792 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 7ae: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 7b2: 4981 li s3,0
+ 7b4: b70d j 6d6 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 7b6: 008b0913 addi s2,s6,8
+ 7ba: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 7be: 02098163 beqz s3,7e0 <vprintf+0x16a>
+ while(*s != 0){
+ 7c2: 0009c583 lbu a1,0(s3)
+ 7c6: c5ad beqz a1,830 <vprintf+0x1ba>
+ putc(fd, *s);
+ 7c8: 8556 mv a0,s5
+ 7ca: 00000097 auipc ra,0x0
+ 7ce: de0080e7 jalr -544(ra) # 5aa <putc>
+ s++;
+ 7d2: 0985 addi s3,s3,1
+ while(*s != 0){
+ 7d4: 0009c583 lbu a1,0(s3)
+ 7d8: f9e5 bnez a1,7c8 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 7da: 8b4a mv s6,s2
+ state = 0;
+ 7dc: 4981 li s3,0
+ 7de: bde5 j 6d6 <vprintf+0x60>
+ s = "(null)";
+ 7e0: 00000997 auipc s3,0x0
+ 7e4: 2c898993 addi s3,s3,712 # aa8 <malloc+0x16e>
+ while(*s != 0){
+ 7e8: 85ee mv a1,s11
+ 7ea: bff9 j 7c8 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 7ec: 008b0913 addi s2,s6,8
+ 7f0: 000b4583 lbu a1,0(s6)
+ 7f4: 8556 mv a0,s5
+ 7f6: 00000097 auipc ra,0x0
+ 7fa: db4080e7 jalr -588(ra) # 5aa <putc>
+ 7fe: 8b4a mv s6,s2
+ state = 0;
+ 800: 4981 li s3,0
+ 802: bdd1 j 6d6 <vprintf+0x60>
+ putc(fd, c);
+ 804: 85d2 mv a1,s4
+ 806: 8556 mv a0,s5
+ 808: 00000097 auipc ra,0x0
+ 80c: da2080e7 jalr -606(ra) # 5aa <putc>
+ state = 0;
+ 810: 4981 li s3,0
+ 812: b5d1 j 6d6 <vprintf+0x60>
+ putc(fd, '%');
+ 814: 85d2 mv a1,s4
+ 816: 8556 mv a0,s5
+ 818: 00000097 auipc ra,0x0
+ 81c: d92080e7 jalr -622(ra) # 5aa <putc>
+ putc(fd, c);
+ 820: 85ca mv a1,s2
+ 822: 8556 mv a0,s5
+ 824: 00000097 auipc ra,0x0
+ 828: d86080e7 jalr -634(ra) # 5aa <putc>
+ state = 0;
+ 82c: 4981 li s3,0
+ 82e: b565 j 6d6 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 830: 8b4a mv s6,s2
+ state = 0;
+ 832: 4981 li s3,0
+ 834: b54d j 6d6 <vprintf+0x60>
+ }
+ }
+}
+ 836: 70e6 ld ra,120(sp)
+ 838: 7446 ld s0,112(sp)
+ 83a: 74a6 ld s1,104(sp)
+ 83c: 7906 ld s2,96(sp)
+ 83e: 69e6 ld s3,88(sp)
+ 840: 6a46 ld s4,80(sp)
+ 842: 6aa6 ld s5,72(sp)
+ 844: 6b06 ld s6,64(sp)
+ 846: 7be2 ld s7,56(sp)
+ 848: 7c42 ld s8,48(sp)
+ 84a: 7ca2 ld s9,40(sp)
+ 84c: 7d02 ld s10,32(sp)
+ 84e: 6de2 ld s11,24(sp)
+ 850: 6109 addi sp,sp,128
+ 852: 8082 ret
+
+0000000000000854 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 854: 715d addi sp,sp,-80
+ 856: ec06 sd ra,24(sp)
+ 858: e822 sd s0,16(sp)
+ 85a: 1000 addi s0,sp,32
+ 85c: e010 sd a2,0(s0)
+ 85e: e414 sd a3,8(s0)
+ 860: e818 sd a4,16(s0)
+ 862: ec1c sd a5,24(s0)
+ 864: 03043023 sd a6,32(s0)
+ 868: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 86c: 8622 mv a2,s0
+ 86e: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 872: 00000097 auipc ra,0x0
+ 876: e04080e7 jalr -508(ra) # 676 <vprintf>
+}
+ 87a: 60e2 ld ra,24(sp)
+ 87c: 6442 ld s0,16(sp)
+ 87e: 6161 addi sp,sp,80
+ 880: 8082 ret
+
+0000000000000882 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 882: 711d addi sp,sp,-96
+ 884: ec06 sd ra,24(sp)
+ 886: e822 sd s0,16(sp)
+ 888: 1000 addi s0,sp,32
+ 88a: e40c sd a1,8(s0)
+ 88c: e810 sd a2,16(s0)
+ 88e: ec14 sd a3,24(s0)
+ 890: f018 sd a4,32(s0)
+ 892: f41c sd a5,40(s0)
+ 894: 03043823 sd a6,48(s0)
+ 898: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 89c: 00840613 addi a2,s0,8
+ 8a0: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 8a4: 85aa mv a1,a0
+ 8a6: 4505 li a0,1
+ 8a8: 00000097 auipc ra,0x0
+ 8ac: dce080e7 jalr -562(ra) # 676 <vprintf>
+}
+ 8b0: 60e2 ld ra,24(sp)
+ 8b2: 6442 ld s0,16(sp)
+ 8b4: 6125 addi sp,sp,96
+ 8b6: 8082 ret
+
+00000000000008b8 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 8b8: 1141 addi sp,sp,-16
+ 8ba: e422 sd s0,8(sp)
+ 8bc: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 8be: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 8c2: 00000797 auipc a5,0x0
+ 8c6: 45e7b783 ld a5,1118(a5) # d20 <freep>
+ 8ca: a02d j 8f4 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 8cc: 4618 lw a4,8(a2)
+ 8ce: 9f2d addw a4,a4,a1
+ 8d0: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8d4: 6398 ld a4,0(a5)
+ 8d6: 6310 ld a2,0(a4)
+ 8d8: a83d j 916 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 8da: ff852703 lw a4,-8(a0)
+ 8de: 9f31 addw a4,a4,a2
+ 8e0: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 8e2: ff053683 ld a3,-16(a0)
+ 8e6: a091 j 92a <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8e8: 6398 ld a4,0(a5)
+ 8ea: 00e7e463 bltu a5,a4,8f2 <free+0x3a>
+ 8ee: 00e6ea63 bltu a3,a4,902 <free+0x4a>
+{
+ 8f2: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 8f4: fed7fae3 bgeu a5,a3,8e8 <free+0x30>
+ 8f8: 6398 ld a4,0(a5)
+ 8fa: 00e6e463 bltu a3,a4,902 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8fe: fee7eae3 bltu a5,a4,8f2 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 902: ff852583 lw a1,-8(a0)
+ 906: 6390 ld a2,0(a5)
+ 908: 02059813 slli a6,a1,0x20
+ 90c: 01c85713 srli a4,a6,0x1c
+ 910: 9736 add a4,a4,a3
+ 912: fae60de3 beq a2,a4,8cc <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 916: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 91a: 4790 lw a2,8(a5)
+ 91c: 02061593 slli a1,a2,0x20
+ 920: 01c5d713 srli a4,a1,0x1c
+ 924: 973e add a4,a4,a5
+ 926: fae68ae3 beq a3,a4,8da <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 92a: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 92c: 00000717 auipc a4,0x0
+ 930: 3ef73a23 sd a5,1012(a4) # d20 <freep>
+}
+ 934: 6422 ld s0,8(sp)
+ 936: 0141 addi sp,sp,16
+ 938: 8082 ret
+
+000000000000093a <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 93a: 7139 addi sp,sp,-64
+ 93c: fc06 sd ra,56(sp)
+ 93e: f822 sd s0,48(sp)
+ 940: f426 sd s1,40(sp)
+ 942: f04a sd s2,32(sp)
+ 944: ec4e sd s3,24(sp)
+ 946: e852 sd s4,16(sp)
+ 948: e456 sd s5,8(sp)
+ 94a: e05a sd s6,0(sp)
+ 94c: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 94e: 02051493 slli s1,a0,0x20
+ 952: 9081 srli s1,s1,0x20
+ 954: 04bd addi s1,s1,15
+ 956: 8091 srli s1,s1,0x4
+ 958: 00148a1b addiw s4,s1,1
+ 95c: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 95e: 00000517 auipc a0,0x0
+ 962: 3c253503 ld a0,962(a0) # d20 <freep>
+ 966: c515 beqz a0,992 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 968: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 96a: 4798 lw a4,8(a5)
+ 96c: 04977163 bgeu a4,s1,9ae <malloc+0x74>
+ 970: 89d2 mv s3,s4
+ 972: 000a071b sext.w a4,s4
+ 976: 6685 lui a3,0x1
+ 978: 00d77363 bgeu a4,a3,97e <malloc+0x44>
+ 97c: 6985 lui s3,0x1
+ 97e: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 982: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 986: 00000917 auipc s2,0x0
+ 98a: 39a90913 addi s2,s2,922 # d20 <freep>
+ if(p == (char*)-1)
+ 98e: 5afd li s5,-1
+ 990: a8a5 j a08 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 992: 00000797 auipc a5,0x0
+ 996: 38e78793 addi a5,a5,910 # d20 <freep>
+ 99a: 00000717 auipc a4,0x0
+ 99e: 38e70713 addi a4,a4,910 # d28 <base>
+ 9a2: e398 sd a4,0(a5)
+ 9a4: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 9a6: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 9aa: 87ba mv a5,a4
+ 9ac: b7d1 j 970 <malloc+0x36>
+ if(p->s.size == nunits)
+ 9ae: 02e48c63 beq s1,a4,9e6 <malloc+0xac>
+ p->s.size -= nunits;
+ 9b2: 4147073b subw a4,a4,s4
+ 9b6: c798 sw a4,8(a5)
+ p += p->s.size;
+ 9b8: 02071693 slli a3,a4,0x20
+ 9bc: 01c6d713 srli a4,a3,0x1c
+ 9c0: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 9c2: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 9c6: 00000717 auipc a4,0x0
+ 9ca: 34a73d23 sd a0,858(a4) # d20 <freep>
+ return (void*)(p + 1);
+ 9ce: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 9d2: 70e2 ld ra,56(sp)
+ 9d4: 7442 ld s0,48(sp)
+ 9d6: 74a2 ld s1,40(sp)
+ 9d8: 7902 ld s2,32(sp)
+ 9da: 69e2 ld s3,24(sp)
+ 9dc: 6a42 ld s4,16(sp)
+ 9de: 6aa2 ld s5,8(sp)
+ 9e0: 6b02 ld s6,0(sp)
+ 9e2: 6121 addi sp,sp,64
+ 9e4: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 9e6: 6398 ld a4,0(a5)
+ 9e8: e118 sd a4,0(a0)
+ 9ea: bff1 j 9c6 <malloc+0x8c>
+ hp->s.size = nu;
+ 9ec: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 9f0: 0541 addi a0,a0,16
+ 9f2: 00000097 auipc ra,0x0
+ 9f6: ec6080e7 jalr -314(ra) # 8b8 <free>
+ return freep;
+ 9fa: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 9fe: d971 beqz a0,9d2 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ a00: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ a02: 4798 lw a4,8(a5)
+ a04: fa9775e3 bgeu a4,s1,9ae <malloc+0x74>
+ if(p == freep)
+ a08: 00093703 ld a4,0(s2)
+ a0c: 853e mv a0,a5
+ a0e: fef719e3 bne a4,a5,a00 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ a12: 854e mv a0,s3
+ a14: 00000097 auipc ra,0x0
+ a18: b30080e7 jalr -1232(ra) # 544 <sbrk>
+ if(p == (char*)-1)
+ a1c: fd5518e3 bne a0,s5,9ec <malloc+0xb2>
+ return 0;
+ a20: 4501 li a0,0
+ a22: bf45 j 9d2 <malloc+0x98>
diff --git a/xv6-user/find.c b/xv6-user/find.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6891703d8334349fbbb29120a2dcc57881c91a7
--- /dev/null
+++ b/xv6-user/find.c
@@ -0,0 +1,60 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+static char path[512];
+
+void find(char *filename)
+{
+ int fd;
+ struct stat st;
+ if ((fd = open(path, O_RDONLY)) < 0) {
+ fprintf(2, "find: cannot open %s\n", path);
+ return;
+ }
+ if (fstat(fd, &st) < 0) {
+ fprintf(2, "find: cannot stat %s\n", path);
+ close(fd);
+ return;
+ }
+ if (st.type != T_DIR) {
+ close(fd);
+ return;
+ }
+ if (strlen(path) + 255 + 2 > sizeof(path)) {
+ fprintf(2, "find: path too long\n");
+ close(fd);
+ return;
+ }
+ char *p = path + strlen(path) - 1;
+ if (*p != '/') {
+ *++p = '/';
+ }
+ p++;
+ while (readdir(fd, &st)) {
+ strcpy(p, st.name);
+ if (strcmp(p, ".") == 0 || strcmp(p, "..") == 0) {
+ continue;
+ }
+ if (strcmp(p, filename) == 0) {
+ fprintf(1, "%s\n", path);
+ }
+ find(filename);
+ }
+ close(fd);
+ return;
+}
+
+
+int main(int argc, char *argv[])
+{
+ if (argc < 3) {
+ fprintf(2, "Usage: find DIR FILENAME\n");
+ exit(0);
+ } else {
+ strcpy(path, argv[1]);
+ find(argv[2]);
+ }
+ exit(0);
+}
diff --git a/xv6-user/find.d b/xv6-user/find.d
new file mode 100644
index 0000000000000000000000000000000000000000..524a923fc101ba278cfa5947522cc8920220ce70
--- /dev/null
+++ b/xv6-user/find.d
@@ -0,0 +1,2 @@
+xv6-user/find.o: xv6-user/find.c kernel/include/types.h \
+ kernel/include/stat.h kernel/include/fcntl.h xv6-user/user.h
diff --git a/xv6-user/find.o b/xv6-user/find.o
new file mode 100644
index 0000000000000000000000000000000000000000..a360e583082690b378168c8282a5592692d532db
Binary files /dev/null and b/xv6-user/find.o differ
diff --git a/xv6-user/find.sym b/xv6-user/find.sym
new file mode 100644
index 0000000000000000000000000000000000000000..c68bfea39267ba7f7ad0776b9e12820603a94ddd
--- /dev/null
+++ b/xv6-user/find.sym
@@ -0,0 +1,78 @@
+0000000000000000 .text
+0000000000000a28 .rodata
+0000000000000b20 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 find.c
+0000000000000b20 path
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000005aa putc
+00000000000005cc printint
+0000000000000b08 digits
+0000000000000000 umalloc.c
+0000000000000d20 freep
+0000000000000d28 base
+0000000000000206 strcpy
+0000000000000882 printf
+0000000000001319 __global_pointer$
+0000000000000564 dev
+000000000000040c memmove
+0000000000000588 trace
+00000000000002ec gets
+0000000000000b19 __SDATA_BEGIN__
+000000000000053a getpid
+000000000000049e memcpy
+000000000000093a malloc
+000000000000057e remove
+000000000000054c sleep
+0000000000000590 sysinfo
+000000000000056e readdir
+00000000000004d0 pipe
+0000000000000598 rename
+00000000000004e4 write
+0000000000000514 fstat
+0000000000000854 fprintf
+00000000000004f8 kill
+0000000000000222 strcat
+0000000000000676 vprintf
+0000000000000528 chdir
+0000000000000500 exec
+00000000000004c8 wait
+00000000000004da read
+0000000000000000 find
+0000000000000464 memcmp
+00000000000004b6 fork
+0000000000000d38 __BSS_END__
+0000000000000544 sbrk
+000000000000055c test_proc
+0000000000000554 uptime
+0000000000000b19 __bss_start
+00000000000002a6 memset
+00000000000001b2 main
+0000000000000250 strcmp
+00000000000005a0 shutdown
+0000000000000532 dup
+0000000000000576 getcwd
+0000000000000b19 __DATA_BEGIN__
+0000000000000366 stat
+0000000000000b19 _edata
+0000000000000d38 _end
+00000000000004be exit
+00000000000003ac atoi
+000000000000027c strlen
+000000000000050a open
+00000000000002c8 strchr
+000000000000051e mkdir
+00000000000004ee close
+00000000000008b8 free
diff --git a/xv6-user/forktest.c b/xv6-user/forktest.c
new file mode 100644
index 0000000000000000000000000000000000000000..ca72bade90124a38512e432a2f72fe49ec3b4e1a
--- /dev/null
+++ b/xv6-user/forktest.c
@@ -0,0 +1,56 @@
+// Test that fork fails gracefully.
+// Tiny executable so that the limit can be filling the proc table.
+
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+#define N 1000
+
+void
+print(const char *s)
+{
+ write(1, s, strlen(s));
+}
+
+void
+forktest(void)
+{
+ int n, pid;
+
+ print("fork test\n");
+
+ for(n=0; n<N; n++){
+ pid = fork();
+ if(pid < 0)
+ break;
+ if(pid == 0)
+ exit(0);
+ }
+
+ if(n == N){
+ print("fork claimed to work N times!\n");
+ exit(1);
+ }
+
+ for(; n > 0; n--){
+ if(wait(0) < 0){
+ print("wait stopped early\n");
+ exit(1);
+ }
+ }
+
+ if(wait(0) != -1){
+ print("wait got too many\n");
+ exit(1);
+ }
+
+ print("fork test OK\n");
+}
+
+int
+main(void)
+{
+ forktest();
+ exit(0);
+}
diff --git a/xv6-user/grep.asm b/xv6-user/grep.asm
new file mode 100644
index 0000000000000000000000000000000000000000..3cab3552df5e2a5af29ec5d3d8f204c0a8c0e049
--- /dev/null
+++ b/xv6-user/grep.asm
@@ -0,0 +1,1709 @@
+
+xv6-user/_grep: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <matchstar>:
+ return 0;
+}
+
+// matchstar: search for c*re at beginning of text
+int matchstar(int c, char *re, char *text)
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: e052 sd s4,0(sp)
+ e: 1800 addi s0,sp,48
+ 10: 892a mv s2,a0
+ 12: 89ae mv s3,a1
+ 14: 84b2 mv s1,a2
+ do{ // a * matches zero or more instances
+ if(matchhere(re, text))
+ return 1;
+ }while(*text!='\0' && (*text++==c || c=='.'));
+ 16: 02e00a13 li s4,46
+ if(matchhere(re, text))
+ 1a: 85a6 mv a1,s1
+ 1c: 854e mv a0,s3
+ 1e: 00000097 auipc ra,0x0
+ 22: 030080e7 jalr 48(ra) # 4e <matchhere>
+ 26: e919 bnez a0,3c <matchstar+0x3c>
+ }while(*text!='\0' && (*text++==c || c=='.'));
+ 28: 0004c783 lbu a5,0(s1)
+ 2c: cb89 beqz a5,3e <matchstar+0x3e>
+ 2e: 0485 addi s1,s1,1
+ 30: 2781 sext.w a5,a5
+ 32: ff2784e3 beq a5,s2,1a <matchstar+0x1a>
+ 36: ff4902e3 beq s2,s4,1a <matchstar+0x1a>
+ 3a: a011 j 3e <matchstar+0x3e>
+ return 1;
+ 3c: 4505 li a0,1
+ return 0;
+}
+ 3e: 70a2 ld ra,40(sp)
+ 40: 7402 ld s0,32(sp)
+ 42: 64e2 ld s1,24(sp)
+ 44: 6942 ld s2,16(sp)
+ 46: 69a2 ld s3,8(sp)
+ 48: 6a02 ld s4,0(sp)
+ 4a: 6145 addi sp,sp,48
+ 4c: 8082 ret
+
+000000000000004e <matchhere>:
+ if(re[0] == '\0')
+ 4e: 00054703 lbu a4,0(a0)
+ 52: cb3d beqz a4,c8 <matchhere+0x7a>
+{
+ 54: 1141 addi sp,sp,-16
+ 56: e406 sd ra,8(sp)
+ 58: e022 sd s0,0(sp)
+ 5a: 0800 addi s0,sp,16
+ 5c: 87aa mv a5,a0
+ if(re[1] == '*')
+ 5e: 00154683 lbu a3,1(a0)
+ 62: 02a00613 li a2,42
+ 66: 02c68563 beq a3,a2,90 <matchhere+0x42>
+ if(re[0] == '$' && re[1] == '\0')
+ 6a: 02400613 li a2,36
+ 6e: 02c70a63 beq a4,a2,a2 <matchhere+0x54>
+ if(*text!='\0' && (re[0]=='.' || re[0]==*text))
+ 72: 0005c683 lbu a3,0(a1)
+ return 0;
+ 76: 4501 li a0,0
+ if(*text!='\0' && (re[0]=='.' || re[0]==*text))
+ 78: ca81 beqz a3,88 <matchhere+0x3a>
+ 7a: 02e00613 li a2,46
+ 7e: 02c70d63 beq a4,a2,b8 <matchhere+0x6a>
+ return 0;
+ 82: 4501 li a0,0
+ if(*text!='\0' && (re[0]=='.' || re[0]==*text))
+ 84: 02d70a63 beq a4,a3,b8 <matchhere+0x6a>
+}
+ 88: 60a2 ld ra,8(sp)
+ 8a: 6402 ld s0,0(sp)
+ 8c: 0141 addi sp,sp,16
+ 8e: 8082 ret
+ return matchstar(re[0], re+2, text);
+ 90: 862e mv a2,a1
+ 92: 00250593 addi a1,a0,2
+ 96: 853a mv a0,a4
+ 98: 00000097 auipc ra,0x0
+ 9c: f68080e7 jalr -152(ra) # 0 <matchstar>
+ a0: b7e5 j 88 <matchhere+0x3a>
+ if(re[0] == '$' && re[1] == '\0')
+ a2: c691 beqz a3,ae <matchhere+0x60>
+ if(*text!='\0' && (re[0]=='.' || re[0]==*text))
+ a4: 0005c683 lbu a3,0(a1)
+ a8: fee9 bnez a3,82 <matchhere+0x34>
+ return 0;
+ aa: 4501 li a0,0
+ ac: bff1 j 88 <matchhere+0x3a>
+ return *text == '\0';
+ ae: 0005c503 lbu a0,0(a1)
+ b2: 00153513 seqz a0,a0
+ b6: bfc9 j 88 <matchhere+0x3a>
+ return matchhere(re+1, text+1);
+ b8: 0585 addi a1,a1,1
+ ba: 00178513 addi a0,a5,1
+ be: 00000097 auipc ra,0x0
+ c2: f90080e7 jalr -112(ra) # 4e <matchhere>
+ c6: b7c9 j 88 <matchhere+0x3a>
+ return 1;
+ c8: 4505 li a0,1
+}
+ ca: 8082 ret
+
+00000000000000cc <match>:
+{
+ cc: 1101 addi sp,sp,-32
+ ce: ec06 sd ra,24(sp)
+ d0: e822 sd s0,16(sp)
+ d2: e426 sd s1,8(sp)
+ d4: e04a sd s2,0(sp)
+ d6: 1000 addi s0,sp,32
+ d8: 892a mv s2,a0
+ da: 84ae mv s1,a1
+ if(re[0] == '^')
+ dc: 00054703 lbu a4,0(a0)
+ e0: 05e00793 li a5,94
+ e4: 00f70e63 beq a4,a5,100 <match+0x34>
+ if(matchhere(re, text))
+ e8: 85a6 mv a1,s1
+ ea: 854a mv a0,s2
+ ec: 00000097 auipc ra,0x0
+ f0: f62080e7 jalr -158(ra) # 4e <matchhere>
+ f4: ed01 bnez a0,10c <match+0x40>
+ }while(*text++ != '\0');
+ f6: 0485 addi s1,s1,1
+ f8: fff4c783 lbu a5,-1(s1)
+ fc: f7f5 bnez a5,e8 <match+0x1c>
+ fe: a801 j 10e <match+0x42>
+ return matchhere(re+1, text);
+ 100: 0505 addi a0,a0,1
+ 102: 00000097 auipc ra,0x0
+ 106: f4c080e7 jalr -180(ra) # 4e <matchhere>
+ 10a: a011 j 10e <match+0x42>
+ return 1;
+ 10c: 4505 li a0,1
+}
+ 10e: 60e2 ld ra,24(sp)
+ 110: 6442 ld s0,16(sp)
+ 112: 64a2 ld s1,8(sp)
+ 114: 6902 ld s2,0(sp)
+ 116: 6105 addi sp,sp,32
+ 118: 8082 ret
+
+000000000000011a <grep>:
+{
+ 11a: 715d addi sp,sp,-80
+ 11c: e486 sd ra,72(sp)
+ 11e: e0a2 sd s0,64(sp)
+ 120: fc26 sd s1,56(sp)
+ 122: f84a sd s2,48(sp)
+ 124: f44e sd s3,40(sp)
+ 126: f052 sd s4,32(sp)
+ 128: ec56 sd s5,24(sp)
+ 12a: e85a sd s6,16(sp)
+ 12c: e45e sd s7,8(sp)
+ 12e: 0880 addi s0,sp,80
+ 130: 89aa mv s3,a0
+ 132: 8b2e mv s6,a1
+ m = 0;
+ 134: 4a01 li s4,0
+ while((n = read(fd, buf+m, sizeof(buf)-m-1)) > 0){
+ 136: 3ff00b93 li s7,1023
+ 13a: 00001a97 auipc s5,0x1
+ 13e: a36a8a93 addi s5,s5,-1482 # b70 <buf>
+ 142: a0a1 j 18a <grep+0x70>
+ p = q+1;
+ 144: 00148913 addi s2,s1,1
+ while((q = strchr(p, '\n')) != 0){
+ 148: 45a9 li a1,10
+ 14a: 854a mv a0,s2
+ 14c: 00000097 auipc ra,0x0
+ 150: 214080e7 jalr 532(ra) # 360 <strchr>
+ 154: 84aa mv s1,a0
+ 156: c905 beqz a0,186 <grep+0x6c>
+ *q = 0;
+ 158: 00048023 sb zero,0(s1)
+ if(match(pattern, p)){
+ 15c: 85ca mv a1,s2
+ 15e: 854e mv a0,s3
+ 160: 00000097 auipc ra,0x0
+ 164: f6c080e7 jalr -148(ra) # cc <match>
+ 168: dd71 beqz a0,144 <grep+0x2a>
+ *q = '\n';
+ 16a: 47a9 li a5,10
+ 16c: 00f48023 sb a5,0(s1)
+ write(1, p, q+1 - p);
+ 170: 00148613 addi a2,s1,1
+ 174: 4126063b subw a2,a2,s2
+ 178: 85ca mv a1,s2
+ 17a: 4505 li a0,1
+ 17c: 00000097 auipc ra,0x0
+ 180: 400080e7 jalr 1024(ra) # 57c <write>
+ 184: b7c1 j 144 <grep+0x2a>
+ if(m > 0){
+ 186: 03404563 bgtz s4,1b0 <grep+0x96>
+ while((n = read(fd, buf+m, sizeof(buf)-m-1)) > 0){
+ 18a: 414b863b subw a2,s7,s4
+ 18e: 014a85b3 add a1,s5,s4
+ 192: 855a mv a0,s6
+ 194: 00000097 auipc ra,0x0
+ 198: 3de080e7 jalr 990(ra) # 572 <read>
+ 19c: 02a05663 blez a0,1c8 <grep+0xae>
+ m += n;
+ 1a0: 00aa0a3b addw s4,s4,a0
+ buf[m] = '\0';
+ 1a4: 014a87b3 add a5,s5,s4
+ 1a8: 00078023 sb zero,0(a5)
+ p = buf;
+ 1ac: 8956 mv s2,s5
+ while((q = strchr(p, '\n')) != 0){
+ 1ae: bf69 j 148 <grep+0x2e>
+ m -= p - buf;
+ 1b0: 415907b3 sub a5,s2,s5
+ 1b4: 40fa0a3b subw s4,s4,a5
+ memmove(buf, p, m);
+ 1b8: 8652 mv a2,s4
+ 1ba: 85ca mv a1,s2
+ 1bc: 8556 mv a0,s5
+ 1be: 00000097 auipc ra,0x0
+ 1c2: 2e6080e7 jalr 742(ra) # 4a4 <memmove>
+ 1c6: b7d1 j 18a <grep+0x70>
+}
+ 1c8: 60a6 ld ra,72(sp)
+ 1ca: 6406 ld s0,64(sp)
+ 1cc: 74e2 ld s1,56(sp)
+ 1ce: 7942 ld s2,48(sp)
+ 1d0: 79a2 ld s3,40(sp)
+ 1d2: 7a02 ld s4,32(sp)
+ 1d4: 6ae2 ld s5,24(sp)
+ 1d6: 6b42 ld s6,16(sp)
+ 1d8: 6ba2 ld s7,8(sp)
+ 1da: 6161 addi sp,sp,80
+ 1dc: 8082 ret
+
+00000000000001de <main>:
+{
+ 1de: 7139 addi sp,sp,-64
+ 1e0: fc06 sd ra,56(sp)
+ 1e2: f822 sd s0,48(sp)
+ 1e4: f426 sd s1,40(sp)
+ 1e6: f04a sd s2,32(sp)
+ 1e8: ec4e sd s3,24(sp)
+ 1ea: e852 sd s4,16(sp)
+ 1ec: e456 sd s5,8(sp)
+ 1ee: 0080 addi s0,sp,64
+ if(argc <= 1){
+ 1f0: 4785 li a5,1
+ 1f2: 04a7de63 bge a5,a0,24e <main+0x70>
+ pattern = argv[1];
+ 1f6: 0085ba03 ld s4,8(a1)
+ if(argc <= 2){
+ 1fa: 4789 li a5,2
+ 1fc: 06a7d763 bge a5,a0,26a <main+0x8c>
+ 200: 01058913 addi s2,a1,16
+ 204: ffd5099b addiw s3,a0,-3
+ 208: 02099793 slli a5,s3,0x20
+ 20c: 01d7d993 srli s3,a5,0x1d
+ 210: 05e1 addi a1,a1,24
+ 212: 99ae add s3,s3,a1
+ if((fd = open(argv[i], 0)) < 0){
+ 214: 4581 li a1,0
+ 216: 00093503 ld a0,0(s2)
+ 21a: 00000097 auipc ra,0x0
+ 21e: 388080e7 jalr 904(ra) # 5a2 <open>
+ 222: 84aa mv s1,a0
+ 224: 04054e63 bltz a0,280 <main+0xa2>
+ grep(pattern, fd);
+ 228: 85aa mv a1,a0
+ 22a: 8552 mv a0,s4
+ 22c: 00000097 auipc ra,0x0
+ 230: eee080e7 jalr -274(ra) # 11a <grep>
+ close(fd);
+ 234: 8526 mv a0,s1
+ 236: 00000097 auipc ra,0x0
+ 23a: 350080e7 jalr 848(ra) # 586 <close>
+ for(i = 2; i < argc; i++){
+ 23e: 0921 addi s2,s2,8
+ 240: fd391ae3 bne s2,s3,214 <main+0x36>
+ exit(0);
+ 244: 4501 li a0,0
+ 246: 00000097 auipc ra,0x0
+ 24a: 310080e7 jalr 784(ra) # 556 <exit>
+ fprintf(2, "usage: grep pattern [file ...]\n");
+ 24e: 00001597 auipc a1,0x1
+ 252: 87258593 addi a1,a1,-1934 # ac0 <malloc+0xee>
+ 256: 4509 li a0,2
+ 258: 00000097 auipc ra,0x0
+ 25c: 694080e7 jalr 1684(ra) # 8ec <fprintf>
+ exit(1);
+ 260: 4505 li a0,1
+ 262: 00000097 auipc ra,0x0
+ 266: 2f4080e7 jalr 756(ra) # 556 <exit>
+ grep(pattern, 0);
+ 26a: 4581 li a1,0
+ 26c: 8552 mv a0,s4
+ 26e: 00000097 auipc ra,0x0
+ 272: eac080e7 jalr -340(ra) # 11a <grep>
+ exit(0);
+ 276: 4501 li a0,0
+ 278: 00000097 auipc ra,0x0
+ 27c: 2de080e7 jalr 734(ra) # 556 <exit>
+ printf("grep: cannot open %s\n", argv[i]);
+ 280: 00093583 ld a1,0(s2)
+ 284: 00001517 auipc a0,0x1
+ 288: 85c50513 addi a0,a0,-1956 # ae0 <malloc+0x10e>
+ 28c: 00000097 auipc ra,0x0
+ 290: 68e080e7 jalr 1678(ra) # 91a <printf>
+ exit(1);
+ 294: 4505 li a0,1
+ 296: 00000097 auipc ra,0x0
+ 29a: 2c0080e7 jalr 704(ra) # 556 <exit>
+
+000000000000029e <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 29e: 1141 addi sp,sp,-16
+ 2a0: e422 sd s0,8(sp)
+ 2a2: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 2a4: 87aa mv a5,a0
+ 2a6: 0585 addi a1,a1,1
+ 2a8: 0785 addi a5,a5,1
+ 2aa: fff5c703 lbu a4,-1(a1)
+ 2ae: fee78fa3 sb a4,-1(a5)
+ 2b2: fb75 bnez a4,2a6 <strcpy+0x8>
+ ;
+ return os;
+}
+ 2b4: 6422 ld s0,8(sp)
+ 2b6: 0141 addi sp,sp,16
+ 2b8: 8082 ret
+
+00000000000002ba <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 2ba: 1141 addi sp,sp,-16
+ 2bc: e422 sd s0,8(sp)
+ 2be: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 2c0: 00054783 lbu a5,0(a0)
+ 2c4: c385 beqz a5,2e4 <strcat+0x2a>
+ 2c6: 87aa mv a5,a0
+ s++;
+ 2c8: 0785 addi a5,a5,1
+ while(*s)
+ 2ca: 0007c703 lbu a4,0(a5)
+ 2ce: ff6d bnez a4,2c8 <strcat+0xe>
+ while((*s++ = *t++))
+ 2d0: 0585 addi a1,a1,1
+ 2d2: 0785 addi a5,a5,1
+ 2d4: fff5c703 lbu a4,-1(a1)
+ 2d8: fee78fa3 sb a4,-1(a5)
+ 2dc: fb75 bnez a4,2d0 <strcat+0x16>
+ ;
+ return os;
+}
+ 2de: 6422 ld s0,8(sp)
+ 2e0: 0141 addi sp,sp,16
+ 2e2: 8082 ret
+ while(*s)
+ 2e4: 87aa mv a5,a0
+ 2e6: b7ed j 2d0 <strcat+0x16>
+
+00000000000002e8 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 2e8: 1141 addi sp,sp,-16
+ 2ea: e422 sd s0,8(sp)
+ 2ec: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 2ee: 00054783 lbu a5,0(a0)
+ 2f2: cb91 beqz a5,306 <strcmp+0x1e>
+ 2f4: 0005c703 lbu a4,0(a1)
+ 2f8: 00f71763 bne a4,a5,306 <strcmp+0x1e>
+ p++, q++;
+ 2fc: 0505 addi a0,a0,1
+ 2fe: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 300: 00054783 lbu a5,0(a0)
+ 304: fbe5 bnez a5,2f4 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 306: 0005c503 lbu a0,0(a1)
+}
+ 30a: 40a7853b subw a0,a5,a0
+ 30e: 6422 ld s0,8(sp)
+ 310: 0141 addi sp,sp,16
+ 312: 8082 ret
+
+0000000000000314 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 314: 1141 addi sp,sp,-16
+ 316: e422 sd s0,8(sp)
+ 318: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 31a: 00054783 lbu a5,0(a0)
+ 31e: cf91 beqz a5,33a <strlen+0x26>
+ 320: 0505 addi a0,a0,1
+ 322: 87aa mv a5,a0
+ 324: 4685 li a3,1
+ 326: 9e89 subw a3,a3,a0
+ 328: 00f6853b addw a0,a3,a5
+ 32c: 0785 addi a5,a5,1
+ 32e: fff7c703 lbu a4,-1(a5)
+ 332: fb7d bnez a4,328 <strlen+0x14>
+ ;
+ return n;
+}
+ 334: 6422 ld s0,8(sp)
+ 336: 0141 addi sp,sp,16
+ 338: 8082 ret
+ for(n = 0; s[n]; n++)
+ 33a: 4501 li a0,0
+ 33c: bfe5 j 334 <strlen+0x20>
+
+000000000000033e <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 33e: 1141 addi sp,sp,-16
+ 340: e422 sd s0,8(sp)
+ 342: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 344: ca19 beqz a2,35a <memset+0x1c>
+ 346: 87aa mv a5,a0
+ 348: 1602 slli a2,a2,0x20
+ 34a: 9201 srli a2,a2,0x20
+ 34c: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 350: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 354: 0785 addi a5,a5,1
+ 356: fee79de3 bne a5,a4,350 <memset+0x12>
+ }
+ return dst;
+}
+ 35a: 6422 ld s0,8(sp)
+ 35c: 0141 addi sp,sp,16
+ 35e: 8082 ret
+
+0000000000000360 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 360: 1141 addi sp,sp,-16
+ 362: e422 sd s0,8(sp)
+ 364: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 366: 00054783 lbu a5,0(a0)
+ 36a: cb99 beqz a5,380 <strchr+0x20>
+ if(*s == c)
+ 36c: 00f58763 beq a1,a5,37a <strchr+0x1a>
+ for(; *s; s++)
+ 370: 0505 addi a0,a0,1
+ 372: 00054783 lbu a5,0(a0)
+ 376: fbfd bnez a5,36c <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 378: 4501 li a0,0
+}
+ 37a: 6422 ld s0,8(sp)
+ 37c: 0141 addi sp,sp,16
+ 37e: 8082 ret
+ return 0;
+ 380: 4501 li a0,0
+ 382: bfe5 j 37a <strchr+0x1a>
+
+0000000000000384 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 384: 711d addi sp,sp,-96
+ 386: ec86 sd ra,88(sp)
+ 388: e8a2 sd s0,80(sp)
+ 38a: e4a6 sd s1,72(sp)
+ 38c: e0ca sd s2,64(sp)
+ 38e: fc4e sd s3,56(sp)
+ 390: f852 sd s4,48(sp)
+ 392: f456 sd s5,40(sp)
+ 394: f05a sd s6,32(sp)
+ 396: ec5e sd s7,24(sp)
+ 398: e862 sd s8,16(sp)
+ 39a: 1080 addi s0,sp,96
+ 39c: 8baa mv s7,a0
+ 39e: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 3a0: 892a mv s2,a0
+ 3a2: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 3a4: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 3a8: 4b29 li s6,10
+ 3aa: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 3ac: 89a6 mv s3,s1
+ 3ae: 2485 addiw s1,s1,1
+ 3b0: 0344d763 bge s1,s4,3de <gets+0x5a>
+ cc = read(0, &c, 1);
+ 3b4: 4605 li a2,1
+ 3b6: 85d6 mv a1,s5
+ 3b8: 4501 li a0,0
+ 3ba: 00000097 auipc ra,0x0
+ 3be: 1b8080e7 jalr 440(ra) # 572 <read>
+ if(cc < 1)
+ 3c2: 00a05e63 blez a0,3de <gets+0x5a>
+ buf[i++] = c;
+ 3c6: faf44783 lbu a5,-81(s0)
+ 3ca: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 3ce: 01678763 beq a5,s6,3dc <gets+0x58>
+ 3d2: 0905 addi s2,s2,1
+ 3d4: fd879ce3 bne a5,s8,3ac <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 3d8: 89a6 mv s3,s1
+ 3da: a011 j 3de <gets+0x5a>
+ 3dc: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 3de: 99de add s3,s3,s7
+ 3e0: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 3e4: 855e mv a0,s7
+ 3e6: 60e6 ld ra,88(sp)
+ 3e8: 6446 ld s0,80(sp)
+ 3ea: 64a6 ld s1,72(sp)
+ 3ec: 6906 ld s2,64(sp)
+ 3ee: 79e2 ld s3,56(sp)
+ 3f0: 7a42 ld s4,48(sp)
+ 3f2: 7aa2 ld s5,40(sp)
+ 3f4: 7b02 ld s6,32(sp)
+ 3f6: 6be2 ld s7,24(sp)
+ 3f8: 6c42 ld s8,16(sp)
+ 3fa: 6125 addi sp,sp,96
+ 3fc: 8082 ret
+
+00000000000003fe <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 3fe: 1101 addi sp,sp,-32
+ 400: ec06 sd ra,24(sp)
+ 402: e822 sd s0,16(sp)
+ 404: e426 sd s1,8(sp)
+ 406: e04a sd s2,0(sp)
+ 408: 1000 addi s0,sp,32
+ 40a: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 40c: 4581 li a1,0
+ 40e: 00000097 auipc ra,0x0
+ 412: 194080e7 jalr 404(ra) # 5a2 <open>
+ if(fd < 0)
+ 416: 02054563 bltz a0,440 <stat+0x42>
+ 41a: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 41c: 85ca mv a1,s2
+ 41e: 00000097 auipc ra,0x0
+ 422: 18e080e7 jalr 398(ra) # 5ac <fstat>
+ 426: 892a mv s2,a0
+ close(fd);
+ 428: 8526 mv a0,s1
+ 42a: 00000097 auipc ra,0x0
+ 42e: 15c080e7 jalr 348(ra) # 586 <close>
+ return r;
+}
+ 432: 854a mv a0,s2
+ 434: 60e2 ld ra,24(sp)
+ 436: 6442 ld s0,16(sp)
+ 438: 64a2 ld s1,8(sp)
+ 43a: 6902 ld s2,0(sp)
+ 43c: 6105 addi sp,sp,32
+ 43e: 8082 ret
+ return -1;
+ 440: 597d li s2,-1
+ 442: bfc5 j 432 <stat+0x34>
+
+0000000000000444 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 444: 1141 addi sp,sp,-16
+ 446: e422 sd s0,8(sp)
+ 448: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 44a: 00054703 lbu a4,0(a0)
+ 44e: 02d00793 li a5,45
+ int neg = 1;
+ 452: 4585 li a1,1
+ if (*s == '-') {
+ 454: 04f70363 beq a4,a5,49a <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 458: 00054703 lbu a4,0(a0)
+ 45c: fd07079b addiw a5,a4,-48
+ 460: 0ff7f793 zext.b a5,a5
+ 464: 46a5 li a3,9
+ 466: 02f6ed63 bltu a3,a5,4a0 <atoi+0x5c>
+ n = 0;
+ 46a: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 46c: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 46e: 0505 addi a0,a0,1
+ 470: 0026979b slliw a5,a3,0x2
+ 474: 9fb5 addw a5,a5,a3
+ 476: 0017979b slliw a5,a5,0x1
+ 47a: 9fb9 addw a5,a5,a4
+ 47c: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 480: 00054703 lbu a4,0(a0)
+ 484: fd07079b addiw a5,a4,-48
+ 488: 0ff7f793 zext.b a5,a5
+ 48c: fef671e3 bgeu a2,a5,46e <atoi+0x2a>
+ return n * neg;
+}
+ 490: 02d5853b mulw a0,a1,a3
+ 494: 6422 ld s0,8(sp)
+ 496: 0141 addi sp,sp,16
+ 498: 8082 ret
+ s++;
+ 49a: 0505 addi a0,a0,1
+ neg = -1;
+ 49c: 55fd li a1,-1
+ 49e: bf6d j 458 <atoi+0x14>
+ n = 0;
+ 4a0: 4681 li a3,0
+ 4a2: b7fd j 490 <atoi+0x4c>
+
+00000000000004a4 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 4a4: 1141 addi sp,sp,-16
+ 4a6: e422 sd s0,8(sp)
+ 4a8: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 4aa: 02b57463 bgeu a0,a1,4d2 <memmove+0x2e>
+ while(n-- > 0)
+ 4ae: 00c05f63 blez a2,4cc <memmove+0x28>
+ 4b2: 1602 slli a2,a2,0x20
+ 4b4: 9201 srli a2,a2,0x20
+ 4b6: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 4ba: 872a mv a4,a0
+ *dst++ = *src++;
+ 4bc: 0585 addi a1,a1,1
+ 4be: 0705 addi a4,a4,1
+ 4c0: fff5c683 lbu a3,-1(a1)
+ 4c4: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 4c8: fee79ae3 bne a5,a4,4bc <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 4cc: 6422 ld s0,8(sp)
+ 4ce: 0141 addi sp,sp,16
+ 4d0: 8082 ret
+ dst += n;
+ 4d2: 00c50733 add a4,a0,a2
+ src += n;
+ 4d6: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 4d8: fec05ae3 blez a2,4cc <memmove+0x28>
+ 4dc: fff6079b addiw a5,a2,-1
+ 4e0: 1782 slli a5,a5,0x20
+ 4e2: 9381 srli a5,a5,0x20
+ 4e4: fff7c793 not a5,a5
+ 4e8: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 4ea: 15fd addi a1,a1,-1
+ 4ec: 177d addi a4,a4,-1
+ 4ee: 0005c683 lbu a3,0(a1)
+ 4f2: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 4f6: fee79ae3 bne a5,a4,4ea <memmove+0x46>
+ 4fa: bfc9 j 4cc <memmove+0x28>
+
+00000000000004fc <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 4fc: 1141 addi sp,sp,-16
+ 4fe: e422 sd s0,8(sp)
+ 500: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 502: ca05 beqz a2,532 <memcmp+0x36>
+ 504: fff6069b addiw a3,a2,-1
+ 508: 1682 slli a3,a3,0x20
+ 50a: 9281 srli a3,a3,0x20
+ 50c: 0685 addi a3,a3,1
+ 50e: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 510: 00054783 lbu a5,0(a0)
+ 514: 0005c703 lbu a4,0(a1)
+ 518: 00e79863 bne a5,a4,528 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 51c: 0505 addi a0,a0,1
+ p2++;
+ 51e: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 520: fed518e3 bne a0,a3,510 <memcmp+0x14>
+ }
+ return 0;
+ 524: 4501 li a0,0
+ 526: a019 j 52c <memcmp+0x30>
+ return *p1 - *p2;
+ 528: 40e7853b subw a0,a5,a4
+}
+ 52c: 6422 ld s0,8(sp)
+ 52e: 0141 addi sp,sp,16
+ 530: 8082 ret
+ return 0;
+ 532: 4501 li a0,0
+ 534: bfe5 j 52c <memcmp+0x30>
+
+0000000000000536 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 536: 1141 addi sp,sp,-16
+ 538: e406 sd ra,8(sp)
+ 53a: e022 sd s0,0(sp)
+ 53c: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 53e: 00000097 auipc ra,0x0
+ 542: f66080e7 jalr -154(ra) # 4a4 <memmove>
+}
+ 546: 60a2 ld ra,8(sp)
+ 548: 6402 ld s0,0(sp)
+ 54a: 0141 addi sp,sp,16
+ 54c: 8082 ret
+
+000000000000054e <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 54e: 4885 li a7,1
+ ecall
+ 550: 00000073 ecall
+ ret
+ 554: 8082 ret
+
+0000000000000556 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 556: 05d00893 li a7,93
+ ecall
+ 55a: 00000073 ecall
+ ret
+ 55e: 8082 ret
+
+0000000000000560 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 560: 488d li a7,3
+ ecall
+ 562: 00000073 ecall
+ ret
+ 566: 8082 ret
+
+0000000000000568 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 568: 03b00893 li a7,59
+ ecall
+ 56c: 00000073 ecall
+ ret
+ 570: 8082 ret
+
+0000000000000572 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 572: 03f00893 li a7,63
+ ecall
+ 576: 00000073 ecall
+ ret
+ 57a: 8082 ret
+
+000000000000057c <write>:
+.global write
+write:
+ li a7, SYS_write
+ 57c: 04000893 li a7,64
+ ecall
+ 580: 00000073 ecall
+ ret
+ 584: 8082 ret
+
+0000000000000586 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 586: 03900893 li a7,57
+ ecall
+ 58a: 00000073 ecall
+ ret
+ 58e: 8082 ret
+
+0000000000000590 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 590: 4899 li a7,6
+ ecall
+ 592: 00000073 ecall
+ ret
+ 596: 8082 ret
+
+0000000000000598 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 598: 0dd00893 li a7,221
+ ecall
+ 59c: 00000073 ecall
+ ret
+ 5a0: 8082 ret
+
+00000000000005a2 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 5a2: 03800893 li a7,56
+ ecall
+ 5a6: 00000073 ecall
+ ret
+ 5aa: 8082 ret
+
+00000000000005ac <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 5ac: 05000893 li a7,80
+ ecall
+ 5b0: 00000073 ecall
+ ret
+ 5b4: 8082 ret
+
+00000000000005b6 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 5b6: 02200893 li a7,34
+ ecall
+ 5ba: 00000073 ecall
+ ret
+ 5be: 8082 ret
+
+00000000000005c0 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 5c0: 03100893 li a7,49
+ ecall
+ 5c4: 00000073 ecall
+ ret
+ 5c8: 8082 ret
+
+00000000000005ca <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 5ca: 48dd li a7,23
+ ecall
+ 5cc: 00000073 ecall
+ ret
+ 5d0: 8082 ret
+
+00000000000005d2 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 5d2: 0ac00893 li a7,172
+ ecall
+ 5d6: 00000073 ecall
+ ret
+ 5da: 8082 ret
+
+00000000000005dc <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 5dc: 48b1 li a7,12
+ ecall
+ 5de: 00000073 ecall
+ ret
+ 5e2: 8082 ret
+
+00000000000005e4 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 5e4: 48b5 li a7,13
+ ecall
+ 5e6: 00000073 ecall
+ ret
+ 5ea: 8082 ret
+
+00000000000005ec <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 5ec: 48b9 li a7,14
+ ecall
+ 5ee: 00000073 ecall
+ ret
+ 5f2: 8082 ret
+
+00000000000005f4 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 5f4: 48d9 li a7,22
+ ecall
+ 5f6: 00000073 ecall
+ ret
+ 5fa: 8082 ret
+
+00000000000005fc <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 5fc: 03200893 li a7,50
+ ecall
+ 600: 00000073 ecall
+ ret
+ 604: 8082 ret
+
+0000000000000606 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 606: 48ed li a7,27
+ ecall
+ 608: 00000073 ecall
+ ret
+ 60c: 8082 ret
+
+000000000000060e <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 60e: 48c5 li a7,17
+ ecall
+ 610: 00000073 ecall
+ ret
+ 614: 8082 ret
+
+0000000000000616 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 616: 07500893 li a7,117
+ ecall
+ 61a: 00000073 ecall
+ ret
+ 61e: 8082 ret
+
+0000000000000620 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 620: 48c9 li a7,18
+ ecall
+ 622: 00000073 ecall
+ ret
+ 626: 8082 ret
+
+0000000000000628 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 628: 48cd li a7,19
+ ecall
+ 62a: 00000073 ecall
+ ret
+ 62e: 8082 ret
+
+0000000000000630 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 630: 48e9 li a7,26
+ ecall
+ 632: 00000073 ecall
+ ret
+ 636: 8082 ret
+
+0000000000000638 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 638: 0d200893 li a7,210
+ ecall
+ 63c: 00000073 ecall
+ ret
+ 640: 8082 ret
+
+0000000000000642 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 642: 1101 addi sp,sp,-32
+ 644: ec06 sd ra,24(sp)
+ 646: e822 sd s0,16(sp)
+ 648: 1000 addi s0,sp,32
+ 64a: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 64e: 4605 li a2,1
+ 650: fef40593 addi a1,s0,-17
+ 654: 00000097 auipc ra,0x0
+ 658: f28080e7 jalr -216(ra) # 57c <write>
+}
+ 65c: 60e2 ld ra,24(sp)
+ 65e: 6442 ld s0,16(sp)
+ 660: 6105 addi sp,sp,32
+ 662: 8082 ret
+
+0000000000000664 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 664: 7139 addi sp,sp,-64
+ 666: fc06 sd ra,56(sp)
+ 668: f822 sd s0,48(sp)
+ 66a: f426 sd s1,40(sp)
+ 66c: f04a sd s2,32(sp)
+ 66e: ec4e sd s3,24(sp)
+ 670: 0080 addi s0,sp,64
+ 672: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 674: c299 beqz a3,67a <printint+0x16>
+ 676: 0805c863 bltz a1,706 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 67a: 2581 sext.w a1,a1
+ neg = 0;
+ 67c: 4881 li a7,0
+ }
+
+ i = 0;
+ 67e: fc040993 addi s3,s0,-64
+ neg = 0;
+ 682: 86ce mv a3,s3
+ i = 0;
+ 684: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 686: 2601 sext.w a2,a2
+ 688: 00000517 auipc a0,0x0
+ 68c: 4d050513 addi a0,a0,1232 # b58 <digits>
+ 690: 883a mv a6,a4
+ 692: 2705 addiw a4,a4,1
+ 694: 02c5f7bb remuw a5,a1,a2
+ 698: 1782 slli a5,a5,0x20
+ 69a: 9381 srli a5,a5,0x20
+ 69c: 97aa add a5,a5,a0
+ 69e: 0007c783 lbu a5,0(a5)
+ 6a2: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 6a6: 0005879b sext.w a5,a1
+ 6aa: 02c5d5bb divuw a1,a1,a2
+ 6ae: 0685 addi a3,a3,1
+ 6b0: fec7f0e3 bgeu a5,a2,690 <printint+0x2c>
+ if(neg)
+ 6b4: 00088c63 beqz a7,6cc <printint+0x68>
+ buf[i++] = '-';
+ 6b8: fd070793 addi a5,a4,-48
+ 6bc: 00878733 add a4,a5,s0
+ 6c0: 02d00793 li a5,45
+ 6c4: fef70823 sb a5,-16(a4)
+ 6c8: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 6cc: 02e05663 blez a4,6f8 <printint+0x94>
+ 6d0: fc040913 addi s2,s0,-64
+ 6d4: 993a add s2,s2,a4
+ 6d6: 19fd addi s3,s3,-1
+ 6d8: 99ba add s3,s3,a4
+ 6da: 377d addiw a4,a4,-1
+ 6dc: 1702 slli a4,a4,0x20
+ 6de: 9301 srli a4,a4,0x20
+ 6e0: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 6e4: fff94583 lbu a1,-1(s2)
+ 6e8: 8526 mv a0,s1
+ 6ea: 00000097 auipc ra,0x0
+ 6ee: f58080e7 jalr -168(ra) # 642 <putc>
+ while(--i >= 0)
+ 6f2: 197d addi s2,s2,-1
+ 6f4: ff3918e3 bne s2,s3,6e4 <printint+0x80>
+}
+ 6f8: 70e2 ld ra,56(sp)
+ 6fa: 7442 ld s0,48(sp)
+ 6fc: 74a2 ld s1,40(sp)
+ 6fe: 7902 ld s2,32(sp)
+ 700: 69e2 ld s3,24(sp)
+ 702: 6121 addi sp,sp,64
+ 704: 8082 ret
+ x = -xx;
+ 706: 40b005bb negw a1,a1
+ neg = 1;
+ 70a: 4885 li a7,1
+ x = -xx;
+ 70c: bf8d j 67e <printint+0x1a>
+
+000000000000070e <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 70e: 7119 addi sp,sp,-128
+ 710: fc86 sd ra,120(sp)
+ 712: f8a2 sd s0,112(sp)
+ 714: f4a6 sd s1,104(sp)
+ 716: f0ca sd s2,96(sp)
+ 718: ecce sd s3,88(sp)
+ 71a: e8d2 sd s4,80(sp)
+ 71c: e4d6 sd s5,72(sp)
+ 71e: e0da sd s6,64(sp)
+ 720: fc5e sd s7,56(sp)
+ 722: f862 sd s8,48(sp)
+ 724: f466 sd s9,40(sp)
+ 726: f06a sd s10,32(sp)
+ 728: ec6e sd s11,24(sp)
+ 72a: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 72c: 0005c903 lbu s2,0(a1)
+ 730: 18090f63 beqz s2,8ce <vprintf+0x1c0>
+ 734: 8aaa mv s5,a0
+ 736: 8b32 mv s6,a2
+ 738: 00158493 addi s1,a1,1
+ state = 0;
+ 73c: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 73e: 02500a13 li s4,37
+ 742: 4c55 li s8,21
+ 744: 00000c97 auipc s9,0x0
+ 748: 3bcc8c93 addi s9,s9,956 # b00 <malloc+0x12e>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 74c: 02800d93 li s11,40
+ putc(fd, 'x');
+ 750: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 752: 00000b97 auipc s7,0x0
+ 756: 406b8b93 addi s7,s7,1030 # b58 <digits>
+ 75a: a839 j 778 <vprintf+0x6a>
+ putc(fd, c);
+ 75c: 85ca mv a1,s2
+ 75e: 8556 mv a0,s5
+ 760: 00000097 auipc ra,0x0
+ 764: ee2080e7 jalr -286(ra) # 642 <putc>
+ 768: a019 j 76e <vprintf+0x60>
+ } else if(state == '%'){
+ 76a: 01498d63 beq s3,s4,784 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 76e: 0485 addi s1,s1,1
+ 770: fff4c903 lbu s2,-1(s1)
+ 774: 14090d63 beqz s2,8ce <vprintf+0x1c0>
+ if(state == 0){
+ 778: fe0999e3 bnez s3,76a <vprintf+0x5c>
+ if(c == '%'){
+ 77c: ff4910e3 bne s2,s4,75c <vprintf+0x4e>
+ state = '%';
+ 780: 89d2 mv s3,s4
+ 782: b7f5 j 76e <vprintf+0x60>
+ if(c == 'd'){
+ 784: 11490c63 beq s2,s4,89c <vprintf+0x18e>
+ 788: f9d9079b addiw a5,s2,-99
+ 78c: 0ff7f793 zext.b a5,a5
+ 790: 10fc6e63 bltu s8,a5,8ac <vprintf+0x19e>
+ 794: f9d9079b addiw a5,s2,-99
+ 798: 0ff7f713 zext.b a4,a5
+ 79c: 10ec6863 bltu s8,a4,8ac <vprintf+0x19e>
+ 7a0: 00271793 slli a5,a4,0x2
+ 7a4: 97e6 add a5,a5,s9
+ 7a6: 439c lw a5,0(a5)
+ 7a8: 97e6 add a5,a5,s9
+ 7aa: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 7ac: 008b0913 addi s2,s6,8
+ 7b0: 4685 li a3,1
+ 7b2: 4629 li a2,10
+ 7b4: 000b2583 lw a1,0(s6)
+ 7b8: 8556 mv a0,s5
+ 7ba: 00000097 auipc ra,0x0
+ 7be: eaa080e7 jalr -342(ra) # 664 <printint>
+ 7c2: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 7c4: 4981 li s3,0
+ 7c6: b765 j 76e <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 7c8: 008b0913 addi s2,s6,8
+ 7cc: 4681 li a3,0
+ 7ce: 4629 li a2,10
+ 7d0: 000b2583 lw a1,0(s6)
+ 7d4: 8556 mv a0,s5
+ 7d6: 00000097 auipc ra,0x0
+ 7da: e8e080e7 jalr -370(ra) # 664 <printint>
+ 7de: 8b4a mv s6,s2
+ state = 0;
+ 7e0: 4981 li s3,0
+ 7e2: b771 j 76e <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 7e4: 008b0913 addi s2,s6,8
+ 7e8: 4681 li a3,0
+ 7ea: 866a mv a2,s10
+ 7ec: 000b2583 lw a1,0(s6)
+ 7f0: 8556 mv a0,s5
+ 7f2: 00000097 auipc ra,0x0
+ 7f6: e72080e7 jalr -398(ra) # 664 <printint>
+ 7fa: 8b4a mv s6,s2
+ state = 0;
+ 7fc: 4981 li s3,0
+ 7fe: bf85 j 76e <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 800: 008b0793 addi a5,s6,8
+ 804: f8f43423 sd a5,-120(s0)
+ 808: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 80c: 03000593 li a1,48
+ 810: 8556 mv a0,s5
+ 812: 00000097 auipc ra,0x0
+ 816: e30080e7 jalr -464(ra) # 642 <putc>
+ putc(fd, 'x');
+ 81a: 07800593 li a1,120
+ 81e: 8556 mv a0,s5
+ 820: 00000097 auipc ra,0x0
+ 824: e22080e7 jalr -478(ra) # 642 <putc>
+ 828: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 82a: 03c9d793 srli a5,s3,0x3c
+ 82e: 97de add a5,a5,s7
+ 830: 0007c583 lbu a1,0(a5)
+ 834: 8556 mv a0,s5
+ 836: 00000097 auipc ra,0x0
+ 83a: e0c080e7 jalr -500(ra) # 642 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 83e: 0992 slli s3,s3,0x4
+ 840: 397d addiw s2,s2,-1
+ 842: fe0914e3 bnez s2,82a <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 846: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 84a: 4981 li s3,0
+ 84c: b70d j 76e <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 84e: 008b0913 addi s2,s6,8
+ 852: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 856: 02098163 beqz s3,878 <vprintf+0x16a>
+ while(*s != 0){
+ 85a: 0009c583 lbu a1,0(s3)
+ 85e: c5ad beqz a1,8c8 <vprintf+0x1ba>
+ putc(fd, *s);
+ 860: 8556 mv a0,s5
+ 862: 00000097 auipc ra,0x0
+ 866: de0080e7 jalr -544(ra) # 642 <putc>
+ s++;
+ 86a: 0985 addi s3,s3,1
+ while(*s != 0){
+ 86c: 0009c583 lbu a1,0(s3)
+ 870: f9e5 bnez a1,860 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 872: 8b4a mv s6,s2
+ state = 0;
+ 874: 4981 li s3,0
+ 876: bde5 j 76e <vprintf+0x60>
+ s = "(null)";
+ 878: 00000997 auipc s3,0x0
+ 87c: 28098993 addi s3,s3,640 # af8 <malloc+0x126>
+ while(*s != 0){
+ 880: 85ee mv a1,s11
+ 882: bff9 j 860 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 884: 008b0913 addi s2,s6,8
+ 888: 000b4583 lbu a1,0(s6)
+ 88c: 8556 mv a0,s5
+ 88e: 00000097 auipc ra,0x0
+ 892: db4080e7 jalr -588(ra) # 642 <putc>
+ 896: 8b4a mv s6,s2
+ state = 0;
+ 898: 4981 li s3,0
+ 89a: bdd1 j 76e <vprintf+0x60>
+ putc(fd, c);
+ 89c: 85d2 mv a1,s4
+ 89e: 8556 mv a0,s5
+ 8a0: 00000097 auipc ra,0x0
+ 8a4: da2080e7 jalr -606(ra) # 642 <putc>
+ state = 0;
+ 8a8: 4981 li s3,0
+ 8aa: b5d1 j 76e <vprintf+0x60>
+ putc(fd, '%');
+ 8ac: 85d2 mv a1,s4
+ 8ae: 8556 mv a0,s5
+ 8b0: 00000097 auipc ra,0x0
+ 8b4: d92080e7 jalr -622(ra) # 642 <putc>
+ putc(fd, c);
+ 8b8: 85ca mv a1,s2
+ 8ba: 8556 mv a0,s5
+ 8bc: 00000097 auipc ra,0x0
+ 8c0: d86080e7 jalr -634(ra) # 642 <putc>
+ state = 0;
+ 8c4: 4981 li s3,0
+ 8c6: b565 j 76e <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 8c8: 8b4a mv s6,s2
+ state = 0;
+ 8ca: 4981 li s3,0
+ 8cc: b54d j 76e <vprintf+0x60>
+ }
+ }
+}
+ 8ce: 70e6 ld ra,120(sp)
+ 8d0: 7446 ld s0,112(sp)
+ 8d2: 74a6 ld s1,104(sp)
+ 8d4: 7906 ld s2,96(sp)
+ 8d6: 69e6 ld s3,88(sp)
+ 8d8: 6a46 ld s4,80(sp)
+ 8da: 6aa6 ld s5,72(sp)
+ 8dc: 6b06 ld s6,64(sp)
+ 8de: 7be2 ld s7,56(sp)
+ 8e0: 7c42 ld s8,48(sp)
+ 8e2: 7ca2 ld s9,40(sp)
+ 8e4: 7d02 ld s10,32(sp)
+ 8e6: 6de2 ld s11,24(sp)
+ 8e8: 6109 addi sp,sp,128
+ 8ea: 8082 ret
+
+00000000000008ec <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 8ec: 715d addi sp,sp,-80
+ 8ee: ec06 sd ra,24(sp)
+ 8f0: e822 sd s0,16(sp)
+ 8f2: 1000 addi s0,sp,32
+ 8f4: e010 sd a2,0(s0)
+ 8f6: e414 sd a3,8(s0)
+ 8f8: e818 sd a4,16(s0)
+ 8fa: ec1c sd a5,24(s0)
+ 8fc: 03043023 sd a6,32(s0)
+ 900: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 904: 8622 mv a2,s0
+ 906: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 90a: 00000097 auipc ra,0x0
+ 90e: e04080e7 jalr -508(ra) # 70e <vprintf>
+}
+ 912: 60e2 ld ra,24(sp)
+ 914: 6442 ld s0,16(sp)
+ 916: 6161 addi sp,sp,80
+ 918: 8082 ret
+
+000000000000091a <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 91a: 711d addi sp,sp,-96
+ 91c: ec06 sd ra,24(sp)
+ 91e: e822 sd s0,16(sp)
+ 920: 1000 addi s0,sp,32
+ 922: e40c sd a1,8(s0)
+ 924: e810 sd a2,16(s0)
+ 926: ec14 sd a3,24(s0)
+ 928: f018 sd a4,32(s0)
+ 92a: f41c sd a5,40(s0)
+ 92c: 03043823 sd a6,48(s0)
+ 930: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 934: 00840613 addi a2,s0,8
+ 938: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 93c: 85aa mv a1,a0
+ 93e: 4505 li a0,1
+ 940: 00000097 auipc ra,0x0
+ 944: dce080e7 jalr -562(ra) # 70e <vprintf>
+}
+ 948: 60e2 ld ra,24(sp)
+ 94a: 6442 ld s0,16(sp)
+ 94c: 6125 addi sp,sp,96
+ 94e: 8082 ret
+
+0000000000000950 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 950: 1141 addi sp,sp,-16
+ 952: e422 sd s0,8(sp)
+ 954: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 956: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 95a: 00000797 auipc a5,0x0
+ 95e: 6167b783 ld a5,1558(a5) # f70 <freep>
+ 962: a02d j 98c <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 964: 4618 lw a4,8(a2)
+ 966: 9f2d addw a4,a4,a1
+ 968: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 96c: 6398 ld a4,0(a5)
+ 96e: 6310 ld a2,0(a4)
+ 970: a83d j 9ae <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 972: ff852703 lw a4,-8(a0)
+ 976: 9f31 addw a4,a4,a2
+ 978: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 97a: ff053683 ld a3,-16(a0)
+ 97e: a091 j 9c2 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 980: 6398 ld a4,0(a5)
+ 982: 00e7e463 bltu a5,a4,98a <free+0x3a>
+ 986: 00e6ea63 bltu a3,a4,99a <free+0x4a>
+{
+ 98a: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 98c: fed7fae3 bgeu a5,a3,980 <free+0x30>
+ 990: 6398 ld a4,0(a5)
+ 992: 00e6e463 bltu a3,a4,99a <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 996: fee7eae3 bltu a5,a4,98a <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 99a: ff852583 lw a1,-8(a0)
+ 99e: 6390 ld a2,0(a5)
+ 9a0: 02059813 slli a6,a1,0x20
+ 9a4: 01c85713 srli a4,a6,0x1c
+ 9a8: 9736 add a4,a4,a3
+ 9aa: fae60de3 beq a2,a4,964 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 9ae: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 9b2: 4790 lw a2,8(a5)
+ 9b4: 02061593 slli a1,a2,0x20
+ 9b8: 01c5d713 srli a4,a1,0x1c
+ 9bc: 973e add a4,a4,a5
+ 9be: fae68ae3 beq a3,a4,972 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 9c2: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 9c4: 00000717 auipc a4,0x0
+ 9c8: 5af73623 sd a5,1452(a4) # f70 <freep>
+}
+ 9cc: 6422 ld s0,8(sp)
+ 9ce: 0141 addi sp,sp,16
+ 9d0: 8082 ret
+
+00000000000009d2 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 9d2: 7139 addi sp,sp,-64
+ 9d4: fc06 sd ra,56(sp)
+ 9d6: f822 sd s0,48(sp)
+ 9d8: f426 sd s1,40(sp)
+ 9da: f04a sd s2,32(sp)
+ 9dc: ec4e sd s3,24(sp)
+ 9de: e852 sd s4,16(sp)
+ 9e0: e456 sd s5,8(sp)
+ 9e2: e05a sd s6,0(sp)
+ 9e4: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 9e6: 02051493 slli s1,a0,0x20
+ 9ea: 9081 srli s1,s1,0x20
+ 9ec: 04bd addi s1,s1,15
+ 9ee: 8091 srli s1,s1,0x4
+ 9f0: 00148a1b addiw s4,s1,1
+ 9f4: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 9f6: 00000517 auipc a0,0x0
+ 9fa: 57a53503 ld a0,1402(a0) # f70 <freep>
+ 9fe: c515 beqz a0,a2a <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ a00: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ a02: 4798 lw a4,8(a5)
+ a04: 04977163 bgeu a4,s1,a46 <malloc+0x74>
+ a08: 89d2 mv s3,s4
+ a0a: 000a071b sext.w a4,s4
+ a0e: 6685 lui a3,0x1
+ a10: 00d77363 bgeu a4,a3,a16 <malloc+0x44>
+ a14: 6985 lui s3,0x1
+ a16: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ a1a: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ a1e: 00000917 auipc s2,0x0
+ a22: 55290913 addi s2,s2,1362 # f70 <freep>
+ if(p == (char*)-1)
+ a26: 5afd li s5,-1
+ a28: a8a5 j aa0 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ a2a: 00000797 auipc a5,0x0
+ a2e: 54678793 addi a5,a5,1350 # f70 <freep>
+ a32: 00000717 auipc a4,0x0
+ a36: 54670713 addi a4,a4,1350 # f78 <base>
+ a3a: e398 sd a4,0(a5)
+ a3c: e798 sd a4,8(a5)
+ base.s.size = 0;
+ a3e: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ a42: 87ba mv a5,a4
+ a44: b7d1 j a08 <malloc+0x36>
+ if(p->s.size == nunits)
+ a46: 02e48c63 beq s1,a4,a7e <malloc+0xac>
+ p->s.size -= nunits;
+ a4a: 4147073b subw a4,a4,s4
+ a4e: c798 sw a4,8(a5)
+ p += p->s.size;
+ a50: 02071693 slli a3,a4,0x20
+ a54: 01c6d713 srli a4,a3,0x1c
+ a58: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ a5a: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ a5e: 00000717 auipc a4,0x0
+ a62: 50a73923 sd a0,1298(a4) # f70 <freep>
+ return (void*)(p + 1);
+ a66: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ a6a: 70e2 ld ra,56(sp)
+ a6c: 7442 ld s0,48(sp)
+ a6e: 74a2 ld s1,40(sp)
+ a70: 7902 ld s2,32(sp)
+ a72: 69e2 ld s3,24(sp)
+ a74: 6a42 ld s4,16(sp)
+ a76: 6aa2 ld s5,8(sp)
+ a78: 6b02 ld s6,0(sp)
+ a7a: 6121 addi sp,sp,64
+ a7c: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ a7e: 6398 ld a4,0(a5)
+ a80: e118 sd a4,0(a0)
+ a82: bff1 j a5e <malloc+0x8c>
+ hp->s.size = nu;
+ a84: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ a88: 0541 addi a0,a0,16
+ a8a: 00000097 auipc ra,0x0
+ a8e: ec6080e7 jalr -314(ra) # 950 <free>
+ return freep;
+ a92: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ a96: d971 beqz a0,a6a <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ a98: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ a9a: 4798 lw a4,8(a5)
+ a9c: fa9775e3 bgeu a4,s1,a46 <malloc+0x74>
+ if(p == freep)
+ aa0: 00093703 ld a4,0(s2)
+ aa4: 853e mv a0,a5
+ aa6: fef719e3 bne a4,a5,a98 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ aaa: 854e mv a0,s3
+ aac: 00000097 auipc ra,0x0
+ ab0: b30080e7 jalr -1232(ra) # 5dc <sbrk>
+ if(p == (char*)-1)
+ ab4: fd5518e3 bne a0,s5,a84 <malloc+0xb2>
+ return 0;
+ ab8: 4501 li a0,0
+ aba: bf45 j a6a <malloc+0x98>
diff --git a/xv6-user/grep.c b/xv6-user/grep.c
new file mode 100644
index 0000000000000000000000000000000000000000..50579de690069502df2206904c6f437333447300
--- /dev/null
+++ b/xv6-user/grep.c
@@ -0,0 +1,105 @@
+// Simple grep. Only supports ^ . * $ operators.
+
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+char buf[1024];
+int match(char*, char*);
+
+void
+grep(char *pattern, int fd)
+{
+ int n, m;
+ char *p, *q;
+
+ m = 0;
+ while((n = read(fd, buf+m, sizeof(buf)-m-1)) > 0){
+ m += n;
+ buf[m] = '\0';
+ p = buf;
+ while((q = strchr(p, '\n')) != 0){
+ *q = 0;
+ if(match(pattern, p)){
+ *q = '\n';
+ write(1, p, q+1 - p);
+ }
+ p = q+1;
+ }
+ if(m > 0){
+ m -= p - buf;
+ memmove(buf, p, m);
+ }
+ }
+}
+
+int
+main(int argc, char *argv[])
+{
+ int fd, i;
+ char *pattern;
+
+ if(argc <= 1){
+ fprintf(2, "usage: grep pattern [file ...]\n");
+ exit(1);
+ }
+ pattern = argv[1];
+
+ if(argc <= 2){
+ grep(pattern, 0);
+ exit(0);
+ }
+
+ for(i = 2; i < argc; i++){
+ if((fd = open(argv[i], 0)) < 0){
+ printf("grep: cannot open %s\n", argv[i]);
+ exit(1);
+ }
+ grep(pattern, fd);
+ close(fd);
+ }
+ exit(0);
+}
+
+// Regexp matcher from Kernighan & Pike,
+// The Practice of Programming, Chapter 9.
+
+int matchhere(char*, char*);
+int matchstar(int, char*, char*);
+
+int
+match(char *re, char *text)
+{
+ if(re[0] == '^')
+ return matchhere(re+1, text);
+ do{ // must look at empty string
+ if(matchhere(re, text))
+ return 1;
+ }while(*text++ != '\0');
+ return 0;
+}
+
+// matchhere: search for re at beginning of text
+int matchhere(char *re, char *text)
+{
+ if(re[0] == '\0')
+ return 1;
+ if(re[1] == '*')
+ return matchstar(re[0], re+2, text);
+ if(re[0] == '$' && re[1] == '\0')
+ return *text == '\0';
+ if(*text!='\0' && (re[0]=='.' || re[0]==*text))
+ return matchhere(re+1, text+1);
+ return 0;
+}
+
+// matchstar: search for c*re at beginning of text
+int matchstar(int c, char *re, char *text)
+{
+ do{ // a * matches zero or more instances
+ if(matchhere(re, text))
+ return 1;
+ }while(*text!='\0' && (*text++==c || c=='.'));
+ return 0;
+}
+
diff --git a/xv6-user/grep.d b/xv6-user/grep.d
new file mode 100644
index 0000000000000000000000000000000000000000..9b9c76fd7bf45f7930e12df74e2029b4a7dd9dd6
--- /dev/null
+++ b/xv6-user/grep.d
@@ -0,0 +1,2 @@
+xv6-user/grep.o: xv6-user/grep.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/grep.o b/xv6-user/grep.o
new file mode 100644
index 0000000000000000000000000000000000000000..b4de4ff0ebb82646d17961bc6242c0699f380af6
Binary files /dev/null and b/xv6-user/grep.o differ
diff --git a/xv6-user/grep.sym b/xv6-user/grep.sym
new file mode 100644
index 0000000000000000000000000000000000000000..96ec18f6cf1593de06226c4a3dd2a062121de891
--- /dev/null
+++ b/xv6-user/grep.sym
@@ -0,0 +1,81 @@
+0000000000000000 .text
+0000000000000ac0 .rodata
+0000000000000b70 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 grep.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000642 putc
+0000000000000664 printint
+0000000000000b58 digits
+0000000000000000 umalloc.c
+0000000000000f70 freep
+0000000000000f78 base
+000000000000029e strcpy
+000000000000091a printf
+0000000000001369 __global_pointer$
+00000000000005fc dev
+00000000000004a4 memmove
+000000000000004e matchhere
+0000000000000620 trace
+0000000000000384 gets
+0000000000000b69 __SDATA_BEGIN__
+00000000000005d2 getpid
+0000000000000536 memcpy
+000000000000011a grep
+00000000000009d2 malloc
+0000000000000616 remove
+00000000000005e4 sleep
+0000000000000628 sysinfo
+0000000000000606 readdir
+0000000000000568 pipe
+0000000000000630 rename
+000000000000057c write
+00000000000005ac fstat
+00000000000008ec fprintf
+0000000000000590 kill
+00000000000002ba strcat
+000000000000070e vprintf
+00000000000005c0 chdir
+0000000000000598 exec
+0000000000000560 wait
+0000000000000572 read
+00000000000004fc memcmp
+000000000000054e fork
+0000000000000f88 __BSS_END__
+00000000000005dc sbrk
+00000000000005f4 test_proc
+00000000000005ec uptime
+0000000000000b69 __bss_start
+000000000000033e memset
+00000000000001de main
+0000000000000000 matchstar
+00000000000002e8 strcmp
+0000000000000638 shutdown
+00000000000005ca dup
+000000000000060e getcwd
+0000000000000b70 buf
+0000000000000b69 __DATA_BEGIN__
+00000000000003fe stat
+0000000000000b69 _edata
+0000000000000f88 _end
+00000000000000cc match
+0000000000000556 exit
+0000000000000444 atoi
+0000000000000314 strlen
+00000000000005a2 open
+0000000000000360 strchr
+00000000000005b6 mkdir
+0000000000000586 close
+0000000000000950 free
diff --git a/xv6-user/grind.c b/xv6-user/grind.c
new file mode 100644
index 0000000000000000000000000000000000000000..cfdf8b85b19f669e9c6b5425cfcefc1628131eed
--- /dev/null
+++ b/xv6-user/grind.c
@@ -0,0 +1,349 @@
+//
+// run random system calls in parallel forever.
+//
+
+#include "kernel/include/param.h"
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+#include "kernel/include/fs.h"
+#include "kernel/include/fcntl.h"
+#include "kernel/include/syscall.h"
+#include "kernel/include/memlayout.h"
+#include "kernel/include/riscv.h"
+
+// from FreeBSD.
+int
+do_rand(unsigned long *ctx)
+{
+/*
+ * Compute x = (7^5 * x) mod (2^31 - 1)
+ * without overflowing 31 bits:
+ * (2^31 - 1) = 127773 * (7^5) + 2836
+ * From "Random number generators: good ones are hard to find",
+ * Park and Miller, Communications of the ACM, vol. 31, no. 10,
+ * October 1988, p. 1195.
+ */
+ long hi, lo, x;
+
+ /* Transform to [1, 0x7ffffffe] range. */
+ x = (*ctx % 0x7ffffffe) + 1;
+ hi = x / 127773;
+ lo = x % 127773;
+ x = 16807 * lo - 2836 * hi;
+ if (x < 0)
+ x += 0x7fffffff;
+ /* Transform to [0, 0x7ffffffd] range. */
+ x--;
+ *ctx = x;
+ return (x);
+}
+
+unsigned long rand_next = 1;
+
+int
+rand(void)
+{
+ return (do_rand(&rand_next));
+}
+
+void
+go(int which_child)
+{
+ int fd = -1;
+ static char buf[999];
+ char *break0 = sbrk(0);
+ uint64 iters = 0;
+
+ mkdir("grindir");
+ if(chdir("grindir") != 0){
+ printf("chdir grindir failed\n");
+ exit(1);
+ }
+ chdir("/");
+
+ while(1){
+ iters++;
+ if((iters % 500) == 0)
+ write(1, which_child?"B":"A", 1);
+ int what = rand() % 23;
+ if(what == 1){
+ close(open("grindir/../a", O_CREATE|O_RDWR));
+ } else if(what == 2){
+ close(open("grindir/../grindir/../b", O_CREATE|O_RDWR));
+ } else if(what == 3){
+ unlink("grindir/../a");
+ } else if(what == 4){
+ if(chdir("grindir") != 0){
+ printf("chdir grindir failed\n");
+ exit(1);
+ }
+ unlink("../b");
+ chdir("/");
+ } else if(what == 5){
+ close(fd);
+ fd = open("/grindir/../a", O_CREATE|O_RDWR);
+ } else if(what == 6){
+ close(fd);
+ fd = open("/./grindir/./../b", O_CREATE|O_RDWR);
+ } else if(what == 7){
+ write(fd, buf, sizeof(buf));
+ } else if(what == 8){
+ read(fd, buf, sizeof(buf));
+ } else if(what == 9){
+ mkdir("grindir/../a");
+ close(open("a/../a/./a", O_CREATE|O_RDWR));
+ unlink("a/a");
+ } else if(what == 10){
+ mkdir("/../b");
+ close(open("grindir/../b/b", O_CREATE|O_RDWR));
+ unlink("b/b");
+ } else if(what == 11){
+ unlink("b");
+ link("../grindir/./../a", "../b");
+ } else if(what == 12){
+ unlink("../grindir/../a");
+ link(".././b", "/grindir/../a");
+ } else if(what == 13){
+ int pid = fork();
+ if(pid == 0){
+ exit(0);
+ } else if(pid < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ wait(0);
+ } else if(what == 14){
+ int pid = fork();
+ if(pid == 0){
+ fork();
+ fork();
+ exit(0);
+ } else if(pid < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ wait(0);
+ } else if(what == 15){
+ sbrk(6011);
+ } else if(what == 16){
+ if(sbrk(0) > break0)
+ sbrk(-(sbrk(0) - break0));
+ } else if(what == 17){
+ int pid = fork();
+ if(pid == 0){
+ close(open("a", O_CREATE|O_RDWR));
+ exit(0);
+ } else if(pid < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ if(chdir("../grindir/..") != 0){
+ printf("chdir failed\n");
+ exit(1);
+ }
+ kill(pid);
+ wait(0);
+ } else if(what == 18){
+ int pid = fork();
+ if(pid == 0){
+ kill(getpid());
+ exit(0);
+ } else if(pid < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ wait(0);
+ } else if(what == 19){
+ int fds[2];
+ if(pipe(fds) < 0){
+ printf("grind: pipe failed\n");
+ exit(1);
+ }
+ int pid = fork();
+ if(pid == 0){
+ fork();
+ fork();
+ if(write(fds[1], "x", 1) != 1)
+ printf("grind: pipe write failed\n");
+ char c;
+ if(read(fds[0], &c, 1) != 1)
+ printf("grind: pipe read failed\n");
+ exit(0);
+ } else if(pid < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ close(fds[0]);
+ close(fds[1]);
+ wait(0);
+ } else if(what == 20){
+ int pid = fork();
+ if(pid == 0){
+ unlink("a");
+ mkdir("a");
+ chdir("a");
+ unlink("../a");
+ fd = open("x", O_CREATE|O_RDWR);
+ unlink("x");
+ exit(0);
+ } else if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ wait(0);
+ } else if(what == 21){
+ unlink("c");
+ // should always succeed. check that there are free i-nodes,
+ // file descriptors, blocks.
+ int fd1 = open("c", O_CREATE|O_RDWR);
+ if(fd1 < 0){
+ printf("create c failed\n");
+ exit(1);
+ }
+ if(write(fd1, "x", 1) != 1){
+ printf("write c failed\n");
+ exit(1);
+ }
+ struct stat st;
+ if(fstat(fd1, &st) != 0){
+ printf("fstat failed\n");
+ exit(1);
+ }
+ if(st.size != 1){
+ printf("fstat reports wrong size %d\n", (int)st.size);
+ exit(1);
+ }
+ if(st.ino > 200){
+ printf("fstat reports crazy i-number %d\n", st.ino);
+ exit(1);
+ }
+ close(fd1);
+ unlink("c");
+ } else if(what == 22){
+ // echo hi | cat
+ int aa[2], bb[2];
+ if(pipe(aa) < 0){
+ fprintf(2, "pipe failed\n");
+ exit(1);
+ }
+ if(pipe(bb) < 0){
+ fprintf(2, "pipe failed\n");
+ exit(1);
+ }
+ int pid1 = fork();
+ if(pid1 == 0){
+ close(bb[0]);
+ close(bb[1]);
+ close(aa[0]);
+ close(1);
+ if(dup(aa[1]) != 1){
+ fprintf(2, "dup failed\n");
+ exit(1);
+ }
+ close(aa[1]);
+ char *args[3] = { "echo", "hi", 0 };
+ exec("grindir/../echo", args);
+ fprintf(2, "echo: not found\n");
+ exit(2);
+ } else if(pid1 < 0){
+ fprintf(2, "fork failed\n");
+ exit(3);
+ }
+ int pid2 = fork();
+ if(pid2 == 0){
+ close(aa[1]);
+ close(bb[0]);
+ close(0);
+ if(dup(aa[0]) != 0){
+ fprintf(2, "dup failed\n");
+ exit(4);
+ }
+ close(aa[0]);
+ close(1);
+ if(dup(bb[1]) != 1){
+ fprintf(2, "dup failed\n");
+ exit(5);
+ }
+ close(bb[1]);
+ char *args[2] = { "cat", 0 };
+ exec("/cat", args);
+ fprintf(2, "cat: not found\n");
+ exit(6);
+ } else if(pid2 < 0){
+ fprintf(2, "fork failed\n");
+ exit(7);
+ }
+ close(aa[0]);
+ close(aa[1]);
+ close(bb[1]);
+ char buf[3] = { 0, 0, 0 };
+ read(bb[0], buf+0, 1);
+ read(bb[0], buf+1, 1);
+ close(bb[0]);
+ int st1, st2;
+ wait(&st1);
+ wait(&st2);
+ if(st1 != 0 || st2 != 0 || strcmp(buf, "hi") != 0){
+ printf("exec pipeline failed %d %d \"%s\"\n", st1, st2, buf);
+ exit(1);
+ }
+ }
+ }
+}
+
+void
+iter()
+{
+ unlink("a");
+ unlink("b");
+
+ int pid1 = fork();
+ if(pid1 < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ if(pid1 == 0){
+ rand_next = 31;
+ go(0);
+ exit(0);
+ }
+
+ int pid2 = fork();
+ if(pid2 < 0){
+ printf("grind: fork failed\n");
+ exit(1);
+ }
+ if(pid2 == 0){
+ rand_next = 7177;
+ go(1);
+ exit(0);
+ }
+
+ int st1 = -1;
+ wait(&st1);
+ if(st1 != 0){
+ kill(pid1);
+ kill(pid2);
+ }
+ int st2 = -1;
+ wait(&st2);
+
+ exit(0);
+}
+
+int
+main()
+{
+ while(1){
+ int pid = fork();
+ if(pid == 0){
+ iter();
+ exit(0);
+ }
+ if(pid > 0){
+ wait(0);
+ }
+ sleep(20);
+ }
+}
diff --git a/xv6-user/init.asm b/xv6-user/init.asm
new file mode 100644
index 0000000000000000000000000000000000000000..279a2e91a807db93c2cce5347a47e2defb1bf2c5
--- /dev/null
+++ b/xv6-user/init.asm
@@ -0,0 +1,1525 @@
+
+xv6-user/_init: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+ __asm_syscall("r"(a7))
+}
+
+int
+main(void)
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: e052 sd s4,0(sp)
+ e: 1800 addi s0,sp,48
+
+ // if(open("console", O_RDWR) < 0){
+ // mknod("console", CONSOLE, 0);
+ // open("console", O_RDWR);
+ // }
+ dev(O_RDWR, CONSOLE, 0);
+ 10: 4601 li a2,0
+ 12: 4585 li a1,1
+ 14: 4509 li a0,2
+ 16: 00000097 auipc ra,0x0
+ 1a: 456080e7 jalr 1110(ra) # 46c <dev>
+ dup(0); // stdout
+ 1e: 4501 li a0,0
+ 20: 00000097 auipc ra,0x0
+ 24: 41a080e7 jalr 1050(ra) # 43a <dup>
+ dup(0); // stderr
+ 28: 4501 li a0,0
+ 2a: 00000097 auipc ra,0x0
+ 2e: 410080e7 jalr 1040(ra) # 43a <dup>
+
+ for(int i=0;i<counts;i++){
+ 32: 00001797 auipc a5,0x1
+ 36: afe7a783 lw a5,-1282(a5) # b30 <counts>
+ 3a: 0af05d63 blez a5,f4 <main+0xf4>
+ 3e: 4901 li s2,0
+ printf("init: starting sh\n");
+ 40: 00001a17 auipc s4,0x1
+ 44: 8f0a0a13 addi s4,s4,-1808 # 930 <malloc+0xee>
+ for(int i=0;i<counts;i++){
+ 48: 00001997 auipc s3,0x1
+ 4c: ae898993 addi s3,s3,-1304 # b30 <counts>
+ 50: a8b9 j ae <main+0xae>
+ pid = fork();
+ if(pid < 0){
+ printf("init: fork failed\n");
+ 52: 00001517 auipc a0,0x1
+ 56: 8f650513 addi a0,a0,-1802 # 948 <malloc+0x106>
+ 5a: 00000097 auipc ra,0x0
+ 5e: 730080e7 jalr 1840(ra) # 78a <printf>
+ exit(1);
+ 62: 4505 li a0,1
+ 64: 00000097 auipc ra,0x0
+ 68: 362080e7 jalr 866(ra) # 3c6 <exit>
+ }
+ if(pid == 0){
+ exec(tests[i], argv);
+ 6c: 090e slli s2,s2,0x3
+ 6e: 00001797 auipc a5,0x1
+ 72: aca78793 addi a5,a5,-1334 # b38 <tests>
+ 76: 97ca add a5,a5,s2
+ 78: 00001597 auipc a1,0x1
+ 7c: bc858593 addi a1,a1,-1080 # c40 <argv>
+ 80: 6388 ld a0,0(a5)
+ 82: 00000097 auipc ra,0x0
+ 86: 386080e7 jalr 902(ra) # 408 <exec>
+ printf("init: exec sh failed\n");
+ 8a: 00001517 auipc a0,0x1
+ 8e: 8d650513 addi a0,a0,-1834 # 960 <malloc+0x11e>
+ 92: 00000097 auipc ra,0x0
+ 96: 6f8080e7 jalr 1784(ra) # 78a <printf>
+ exit(1);
+ 9a: 4505 li a0,1
+ 9c: 00000097 auipc ra,0x0
+ a0: 32a080e7 jalr 810(ra) # 3c6 <exit>
+ for(int i=0;i<counts;i++){
+ a4: 2905 addiw s2,s2,1
+ a6: 0009a783 lw a5,0(s3)
+ aa: 04f95563 bge s2,a5,f4 <main+0xf4>
+ printf("init: starting sh\n");
+ ae: 8552 mv a0,s4
+ b0: 00000097 auipc ra,0x0
+ b4: 6da080e7 jalr 1754(ra) # 78a <printf>
+ pid = fork();
+ b8: 00000097 auipc ra,0x0
+ bc: 306080e7 jalr 774(ra) # 3be <fork>
+ c0: 84aa mv s1,a0
+ if(pid < 0){
+ c2: f80548e3 bltz a0,52 <main+0x52>
+ if(pid == 0){
+ c6: d15d beqz a0,6c <main+0x6c>
+ }
+
+ for(;;){
+ // this call to wait() returns if the shell exits,
+ // or if a parentless process exits.
+ wpid = wait((int *) 0);
+ c8: 4501 li a0,0
+ ca: 00000097 auipc ra,0x0
+ ce: 306080e7 jalr 774(ra) # 3d0 <wait>
+ if(wpid == pid){
+ d2: fca489e3 beq s1,a0,a4 <main+0xa4>
+ // the shell exited; restart it.
+ break;
+ } else if(wpid < 0){
+ d6: fe0559e3 bgez a0,c8 <main+0xc8>
+ printf("init: wait returned an error\n");
+ da: 00001517 auipc a0,0x1
+ de: 89e50513 addi a0,a0,-1890 # 978 <malloc+0x136>
+ e2: 00000097 auipc ra,0x0
+ e6: 6a8080e7 jalr 1704(ra) # 78a <printf>
+ exit(1);
+ ea: 4505 li a0,1
+ ec: 00000097 auipc ra,0x0
+ f0: 2da080e7 jalr 730(ra) # 3c6 <exit>
+ register long a7 __asm__("a7") = n;
+ f4: 0d200893 li a7,210
+ __asm_syscall("r"(a7))
+ f8: 00000073 ecall
+ }
+ }
+ }
+ __syscall0(SYS_shutdown);
+ return 0;
+}
+ fc: 4501 li a0,0
+ fe: 70a2 ld ra,40(sp)
+ 100: 7402 ld s0,32(sp)
+ 102: 64e2 ld s1,24(sp)
+ 104: 6942 ld s2,16(sp)
+ 106: 69a2 ld s3,8(sp)
+ 108: 6a02 ld s4,0(sp)
+ 10a: 6145 addi sp,sp,48
+ 10c: 8082 ret
+
+000000000000010e <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 10e: 1141 addi sp,sp,-16
+ 110: e422 sd s0,8(sp)
+ 112: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 114: 87aa mv a5,a0
+ 116: 0585 addi a1,a1,1
+ 118: 0785 addi a5,a5,1
+ 11a: fff5c703 lbu a4,-1(a1)
+ 11e: fee78fa3 sb a4,-1(a5)
+ 122: fb75 bnez a4,116 <strcpy+0x8>
+ ;
+ return os;
+}
+ 124: 6422 ld s0,8(sp)
+ 126: 0141 addi sp,sp,16
+ 128: 8082 ret
+
+000000000000012a <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 12a: 1141 addi sp,sp,-16
+ 12c: e422 sd s0,8(sp)
+ 12e: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 130: 00054783 lbu a5,0(a0)
+ 134: c385 beqz a5,154 <strcat+0x2a>
+ 136: 87aa mv a5,a0
+ s++;
+ 138: 0785 addi a5,a5,1
+ while(*s)
+ 13a: 0007c703 lbu a4,0(a5)
+ 13e: ff6d bnez a4,138 <strcat+0xe>
+ while((*s++ = *t++))
+ 140: 0585 addi a1,a1,1
+ 142: 0785 addi a5,a5,1
+ 144: fff5c703 lbu a4,-1(a1)
+ 148: fee78fa3 sb a4,-1(a5)
+ 14c: fb75 bnez a4,140 <strcat+0x16>
+ ;
+ return os;
+}
+ 14e: 6422 ld s0,8(sp)
+ 150: 0141 addi sp,sp,16
+ 152: 8082 ret
+ while(*s)
+ 154: 87aa mv a5,a0
+ 156: b7ed j 140 <strcat+0x16>
+
+0000000000000158 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 158: 1141 addi sp,sp,-16
+ 15a: e422 sd s0,8(sp)
+ 15c: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 15e: 00054783 lbu a5,0(a0)
+ 162: cb91 beqz a5,176 <strcmp+0x1e>
+ 164: 0005c703 lbu a4,0(a1)
+ 168: 00f71763 bne a4,a5,176 <strcmp+0x1e>
+ p++, q++;
+ 16c: 0505 addi a0,a0,1
+ 16e: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 170: 00054783 lbu a5,0(a0)
+ 174: fbe5 bnez a5,164 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 176: 0005c503 lbu a0,0(a1)
+}
+ 17a: 40a7853b subw a0,a5,a0
+ 17e: 6422 ld s0,8(sp)
+ 180: 0141 addi sp,sp,16
+ 182: 8082 ret
+
+0000000000000184 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 184: 1141 addi sp,sp,-16
+ 186: e422 sd s0,8(sp)
+ 188: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 18a: 00054783 lbu a5,0(a0)
+ 18e: cf91 beqz a5,1aa <strlen+0x26>
+ 190: 0505 addi a0,a0,1
+ 192: 87aa mv a5,a0
+ 194: 4685 li a3,1
+ 196: 9e89 subw a3,a3,a0
+ 198: 00f6853b addw a0,a3,a5
+ 19c: 0785 addi a5,a5,1
+ 19e: fff7c703 lbu a4,-1(a5)
+ 1a2: fb7d bnez a4,198 <strlen+0x14>
+ ;
+ return n;
+}
+ 1a4: 6422 ld s0,8(sp)
+ 1a6: 0141 addi sp,sp,16
+ 1a8: 8082 ret
+ for(n = 0; s[n]; n++)
+ 1aa: 4501 li a0,0
+ 1ac: bfe5 j 1a4 <strlen+0x20>
+
+00000000000001ae <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 1ae: 1141 addi sp,sp,-16
+ 1b0: e422 sd s0,8(sp)
+ 1b2: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 1b4: ca19 beqz a2,1ca <memset+0x1c>
+ 1b6: 87aa mv a5,a0
+ 1b8: 1602 slli a2,a2,0x20
+ 1ba: 9201 srli a2,a2,0x20
+ 1bc: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 1c0: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 1c4: 0785 addi a5,a5,1
+ 1c6: fee79de3 bne a5,a4,1c0 <memset+0x12>
+ }
+ return dst;
+}
+ 1ca: 6422 ld s0,8(sp)
+ 1cc: 0141 addi sp,sp,16
+ 1ce: 8082 ret
+
+00000000000001d0 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 1d0: 1141 addi sp,sp,-16
+ 1d2: e422 sd s0,8(sp)
+ 1d4: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 1d6: 00054783 lbu a5,0(a0)
+ 1da: cb99 beqz a5,1f0 <strchr+0x20>
+ if(*s == c)
+ 1dc: 00f58763 beq a1,a5,1ea <strchr+0x1a>
+ for(; *s; s++)
+ 1e0: 0505 addi a0,a0,1
+ 1e2: 00054783 lbu a5,0(a0)
+ 1e6: fbfd bnez a5,1dc <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 1e8: 4501 li a0,0
+}
+ 1ea: 6422 ld s0,8(sp)
+ 1ec: 0141 addi sp,sp,16
+ 1ee: 8082 ret
+ return 0;
+ 1f0: 4501 li a0,0
+ 1f2: bfe5 j 1ea <strchr+0x1a>
+
+00000000000001f4 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 1f4: 711d addi sp,sp,-96
+ 1f6: ec86 sd ra,88(sp)
+ 1f8: e8a2 sd s0,80(sp)
+ 1fa: e4a6 sd s1,72(sp)
+ 1fc: e0ca sd s2,64(sp)
+ 1fe: fc4e sd s3,56(sp)
+ 200: f852 sd s4,48(sp)
+ 202: f456 sd s5,40(sp)
+ 204: f05a sd s6,32(sp)
+ 206: ec5e sd s7,24(sp)
+ 208: e862 sd s8,16(sp)
+ 20a: 1080 addi s0,sp,96
+ 20c: 8baa mv s7,a0
+ 20e: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 210: 892a mv s2,a0
+ 212: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 214: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 218: 4b29 li s6,10
+ 21a: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 21c: 89a6 mv s3,s1
+ 21e: 2485 addiw s1,s1,1
+ 220: 0344d763 bge s1,s4,24e <gets+0x5a>
+ cc = read(0, &c, 1);
+ 224: 4605 li a2,1
+ 226: 85d6 mv a1,s5
+ 228: 4501 li a0,0
+ 22a: 00000097 auipc ra,0x0
+ 22e: 1b8080e7 jalr 440(ra) # 3e2 <read>
+ if(cc < 1)
+ 232: 00a05e63 blez a0,24e <gets+0x5a>
+ buf[i++] = c;
+ 236: faf44783 lbu a5,-81(s0)
+ 23a: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 23e: 01678763 beq a5,s6,24c <gets+0x58>
+ 242: 0905 addi s2,s2,1
+ 244: fd879ce3 bne a5,s8,21c <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 248: 89a6 mv s3,s1
+ 24a: a011 j 24e <gets+0x5a>
+ 24c: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 24e: 99de add s3,s3,s7
+ 250: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 254: 855e mv a0,s7
+ 256: 60e6 ld ra,88(sp)
+ 258: 6446 ld s0,80(sp)
+ 25a: 64a6 ld s1,72(sp)
+ 25c: 6906 ld s2,64(sp)
+ 25e: 79e2 ld s3,56(sp)
+ 260: 7a42 ld s4,48(sp)
+ 262: 7aa2 ld s5,40(sp)
+ 264: 7b02 ld s6,32(sp)
+ 266: 6be2 ld s7,24(sp)
+ 268: 6c42 ld s8,16(sp)
+ 26a: 6125 addi sp,sp,96
+ 26c: 8082 ret
+
+000000000000026e <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 26e: 1101 addi sp,sp,-32
+ 270: ec06 sd ra,24(sp)
+ 272: e822 sd s0,16(sp)
+ 274: e426 sd s1,8(sp)
+ 276: e04a sd s2,0(sp)
+ 278: 1000 addi s0,sp,32
+ 27a: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 27c: 4581 li a1,0
+ 27e: 00000097 auipc ra,0x0
+ 282: 194080e7 jalr 404(ra) # 412 <open>
+ if(fd < 0)
+ 286: 02054563 bltz a0,2b0 <stat+0x42>
+ 28a: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 28c: 85ca mv a1,s2
+ 28e: 00000097 auipc ra,0x0
+ 292: 18e080e7 jalr 398(ra) # 41c <fstat>
+ 296: 892a mv s2,a0
+ close(fd);
+ 298: 8526 mv a0,s1
+ 29a: 00000097 auipc ra,0x0
+ 29e: 15c080e7 jalr 348(ra) # 3f6 <close>
+ return r;
+}
+ 2a2: 854a mv a0,s2
+ 2a4: 60e2 ld ra,24(sp)
+ 2a6: 6442 ld s0,16(sp)
+ 2a8: 64a2 ld s1,8(sp)
+ 2aa: 6902 ld s2,0(sp)
+ 2ac: 6105 addi sp,sp,32
+ 2ae: 8082 ret
+ return -1;
+ 2b0: 597d li s2,-1
+ 2b2: bfc5 j 2a2 <stat+0x34>
+
+00000000000002b4 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 2b4: 1141 addi sp,sp,-16
+ 2b6: e422 sd s0,8(sp)
+ 2b8: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 2ba: 00054703 lbu a4,0(a0)
+ 2be: 02d00793 li a5,45
+ int neg = 1;
+ 2c2: 4585 li a1,1
+ if (*s == '-') {
+ 2c4: 04f70363 beq a4,a5,30a <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 2c8: 00054703 lbu a4,0(a0)
+ 2cc: fd07079b addiw a5,a4,-48
+ 2d0: 0ff7f793 zext.b a5,a5
+ 2d4: 46a5 li a3,9
+ 2d6: 02f6ed63 bltu a3,a5,310 <atoi+0x5c>
+ n = 0;
+ 2da: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 2dc: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 2de: 0505 addi a0,a0,1
+ 2e0: 0026979b slliw a5,a3,0x2
+ 2e4: 9fb5 addw a5,a5,a3
+ 2e6: 0017979b slliw a5,a5,0x1
+ 2ea: 9fb9 addw a5,a5,a4
+ 2ec: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 2f0: 00054703 lbu a4,0(a0)
+ 2f4: fd07079b addiw a5,a4,-48
+ 2f8: 0ff7f793 zext.b a5,a5
+ 2fc: fef671e3 bgeu a2,a5,2de <atoi+0x2a>
+ return n * neg;
+}
+ 300: 02d5853b mulw a0,a1,a3
+ 304: 6422 ld s0,8(sp)
+ 306: 0141 addi sp,sp,16
+ 308: 8082 ret
+ s++;
+ 30a: 0505 addi a0,a0,1
+ neg = -1;
+ 30c: 55fd li a1,-1
+ 30e: bf6d j 2c8 <atoi+0x14>
+ n = 0;
+ 310: 4681 li a3,0
+ 312: b7fd j 300 <atoi+0x4c>
+
+0000000000000314 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 314: 1141 addi sp,sp,-16
+ 316: e422 sd s0,8(sp)
+ 318: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 31a: 02b57463 bgeu a0,a1,342 <memmove+0x2e>
+ while(n-- > 0)
+ 31e: 00c05f63 blez a2,33c <memmove+0x28>
+ 322: 1602 slli a2,a2,0x20
+ 324: 9201 srli a2,a2,0x20
+ 326: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 32a: 872a mv a4,a0
+ *dst++ = *src++;
+ 32c: 0585 addi a1,a1,1
+ 32e: 0705 addi a4,a4,1
+ 330: fff5c683 lbu a3,-1(a1)
+ 334: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 338: fee79ae3 bne a5,a4,32c <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 33c: 6422 ld s0,8(sp)
+ 33e: 0141 addi sp,sp,16
+ 340: 8082 ret
+ dst += n;
+ 342: 00c50733 add a4,a0,a2
+ src += n;
+ 346: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 348: fec05ae3 blez a2,33c <memmove+0x28>
+ 34c: fff6079b addiw a5,a2,-1
+ 350: 1782 slli a5,a5,0x20
+ 352: 9381 srli a5,a5,0x20
+ 354: fff7c793 not a5,a5
+ 358: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 35a: 15fd addi a1,a1,-1
+ 35c: 177d addi a4,a4,-1
+ 35e: 0005c683 lbu a3,0(a1)
+ 362: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 366: fee79ae3 bne a5,a4,35a <memmove+0x46>
+ 36a: bfc9 j 33c <memmove+0x28>
+
+000000000000036c <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 36c: 1141 addi sp,sp,-16
+ 36e: e422 sd s0,8(sp)
+ 370: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 372: ca05 beqz a2,3a2 <memcmp+0x36>
+ 374: fff6069b addiw a3,a2,-1
+ 378: 1682 slli a3,a3,0x20
+ 37a: 9281 srli a3,a3,0x20
+ 37c: 0685 addi a3,a3,1
+ 37e: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 380: 00054783 lbu a5,0(a0)
+ 384: 0005c703 lbu a4,0(a1)
+ 388: 00e79863 bne a5,a4,398 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 38c: 0505 addi a0,a0,1
+ p2++;
+ 38e: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 390: fed518e3 bne a0,a3,380 <memcmp+0x14>
+ }
+ return 0;
+ 394: 4501 li a0,0
+ 396: a019 j 39c <memcmp+0x30>
+ return *p1 - *p2;
+ 398: 40e7853b subw a0,a5,a4
+}
+ 39c: 6422 ld s0,8(sp)
+ 39e: 0141 addi sp,sp,16
+ 3a0: 8082 ret
+ return 0;
+ 3a2: 4501 li a0,0
+ 3a4: bfe5 j 39c <memcmp+0x30>
+
+00000000000003a6 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 3a6: 1141 addi sp,sp,-16
+ 3a8: e406 sd ra,8(sp)
+ 3aa: e022 sd s0,0(sp)
+ 3ac: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 3ae: 00000097 auipc ra,0x0
+ 3b2: f66080e7 jalr -154(ra) # 314 <memmove>
+}
+ 3b6: 60a2 ld ra,8(sp)
+ 3b8: 6402 ld s0,0(sp)
+ 3ba: 0141 addi sp,sp,16
+ 3bc: 8082 ret
+
+00000000000003be <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 3be: 4885 li a7,1
+ ecall
+ 3c0: 00000073 ecall
+ ret
+ 3c4: 8082 ret
+
+00000000000003c6 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 3c6: 05d00893 li a7,93
+ ecall
+ 3ca: 00000073 ecall
+ ret
+ 3ce: 8082 ret
+
+00000000000003d0 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 3d0: 488d li a7,3
+ ecall
+ 3d2: 00000073 ecall
+ ret
+ 3d6: 8082 ret
+
+00000000000003d8 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 3d8: 03b00893 li a7,59
+ ecall
+ 3dc: 00000073 ecall
+ ret
+ 3e0: 8082 ret
+
+00000000000003e2 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 3e2: 03f00893 li a7,63
+ ecall
+ 3e6: 00000073 ecall
+ ret
+ 3ea: 8082 ret
+
+00000000000003ec <write>:
+.global write
+write:
+ li a7, SYS_write
+ 3ec: 04000893 li a7,64
+ ecall
+ 3f0: 00000073 ecall
+ ret
+ 3f4: 8082 ret
+
+00000000000003f6 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 3f6: 03900893 li a7,57
+ ecall
+ 3fa: 00000073 ecall
+ ret
+ 3fe: 8082 ret
+
+0000000000000400 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 400: 4899 li a7,6
+ ecall
+ 402: 00000073 ecall
+ ret
+ 406: 8082 ret
+
+0000000000000408 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 408: 0dd00893 li a7,221
+ ecall
+ 40c: 00000073 ecall
+ ret
+ 410: 8082 ret
+
+0000000000000412 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 412: 03800893 li a7,56
+ ecall
+ 416: 00000073 ecall
+ ret
+ 41a: 8082 ret
+
+000000000000041c <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 41c: 05000893 li a7,80
+ ecall
+ 420: 00000073 ecall
+ ret
+ 424: 8082 ret
+
+0000000000000426 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 426: 02200893 li a7,34
+ ecall
+ 42a: 00000073 ecall
+ ret
+ 42e: 8082 ret
+
+0000000000000430 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 430: 03100893 li a7,49
+ ecall
+ 434: 00000073 ecall
+ ret
+ 438: 8082 ret
+
+000000000000043a <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 43a: 48dd li a7,23
+ ecall
+ 43c: 00000073 ecall
+ ret
+ 440: 8082 ret
+
+0000000000000442 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 442: 0ac00893 li a7,172
+ ecall
+ 446: 00000073 ecall
+ ret
+ 44a: 8082 ret
+
+000000000000044c <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 44c: 48b1 li a7,12
+ ecall
+ 44e: 00000073 ecall
+ ret
+ 452: 8082 ret
+
+0000000000000454 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 454: 48b5 li a7,13
+ ecall
+ 456: 00000073 ecall
+ ret
+ 45a: 8082 ret
+
+000000000000045c <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 45c: 48b9 li a7,14
+ ecall
+ 45e: 00000073 ecall
+ ret
+ 462: 8082 ret
+
+0000000000000464 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 464: 48d9 li a7,22
+ ecall
+ 466: 00000073 ecall
+ ret
+ 46a: 8082 ret
+
+000000000000046c <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 46c: 03200893 li a7,50
+ ecall
+ 470: 00000073 ecall
+ ret
+ 474: 8082 ret
+
+0000000000000476 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 476: 48ed li a7,27
+ ecall
+ 478: 00000073 ecall
+ ret
+ 47c: 8082 ret
+
+000000000000047e <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 47e: 48c5 li a7,17
+ ecall
+ 480: 00000073 ecall
+ ret
+ 484: 8082 ret
+
+0000000000000486 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 486: 07500893 li a7,117
+ ecall
+ 48a: 00000073 ecall
+ ret
+ 48e: 8082 ret
+
+0000000000000490 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 490: 48c9 li a7,18
+ ecall
+ 492: 00000073 ecall
+ ret
+ 496: 8082 ret
+
+0000000000000498 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 498: 48cd li a7,19
+ ecall
+ 49a: 00000073 ecall
+ ret
+ 49e: 8082 ret
+
+00000000000004a0 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 4a0: 48e9 li a7,26
+ ecall
+ 4a2: 00000073 ecall
+ ret
+ 4a6: 8082 ret
+
+00000000000004a8 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 4a8: 0d200893 li a7,210
+ ecall
+ 4ac: 00000073 ecall
+ ret
+ 4b0: 8082 ret
+
+00000000000004b2 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 4b2: 1101 addi sp,sp,-32
+ 4b4: ec06 sd ra,24(sp)
+ 4b6: e822 sd s0,16(sp)
+ 4b8: 1000 addi s0,sp,32
+ 4ba: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 4be: 4605 li a2,1
+ 4c0: fef40593 addi a1,s0,-17
+ 4c4: 00000097 auipc ra,0x0
+ 4c8: f28080e7 jalr -216(ra) # 3ec <write>
+}
+ 4cc: 60e2 ld ra,24(sp)
+ 4ce: 6442 ld s0,16(sp)
+ 4d0: 6105 addi sp,sp,32
+ 4d2: 8082 ret
+
+00000000000004d4 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 4d4: 7139 addi sp,sp,-64
+ 4d6: fc06 sd ra,56(sp)
+ 4d8: f822 sd s0,48(sp)
+ 4da: f426 sd s1,40(sp)
+ 4dc: f04a sd s2,32(sp)
+ 4de: ec4e sd s3,24(sp)
+ 4e0: 0080 addi s0,sp,64
+ 4e2: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 4e4: c299 beqz a3,4ea <printint+0x16>
+ 4e6: 0805c863 bltz a1,576 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 4ea: 2581 sext.w a1,a1
+ neg = 0;
+ 4ec: 4881 li a7,0
+ }
+
+ i = 0;
+ 4ee: fc040993 addi s3,s0,-64
+ neg = 0;
+ 4f2: 86ce mv a3,s3
+ i = 0;
+ 4f4: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 4f6: 2601 sext.w a2,a2
+ 4f8: 00000517 auipc a0,0x0
+ 4fc: 62050513 addi a0,a0,1568 # b18 <digits>
+ 500: 883a mv a6,a4
+ 502: 2705 addiw a4,a4,1
+ 504: 02c5f7bb remuw a5,a1,a2
+ 508: 1782 slli a5,a5,0x20
+ 50a: 9381 srli a5,a5,0x20
+ 50c: 97aa add a5,a5,a0
+ 50e: 0007c783 lbu a5,0(a5)
+ 512: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 516: 0005879b sext.w a5,a1
+ 51a: 02c5d5bb divuw a1,a1,a2
+ 51e: 0685 addi a3,a3,1
+ 520: fec7f0e3 bgeu a5,a2,500 <printint+0x2c>
+ if(neg)
+ 524: 00088c63 beqz a7,53c <printint+0x68>
+ buf[i++] = '-';
+ 528: fd070793 addi a5,a4,-48
+ 52c: 00878733 add a4,a5,s0
+ 530: 02d00793 li a5,45
+ 534: fef70823 sb a5,-16(a4)
+ 538: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 53c: 02e05663 blez a4,568 <printint+0x94>
+ 540: fc040913 addi s2,s0,-64
+ 544: 993a add s2,s2,a4
+ 546: 19fd addi s3,s3,-1
+ 548: 99ba add s3,s3,a4
+ 54a: 377d addiw a4,a4,-1
+ 54c: 1702 slli a4,a4,0x20
+ 54e: 9301 srli a4,a4,0x20
+ 550: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 554: fff94583 lbu a1,-1(s2)
+ 558: 8526 mv a0,s1
+ 55a: 00000097 auipc ra,0x0
+ 55e: f58080e7 jalr -168(ra) # 4b2 <putc>
+ while(--i >= 0)
+ 562: 197d addi s2,s2,-1
+ 564: ff3918e3 bne s2,s3,554 <printint+0x80>
+}
+ 568: 70e2 ld ra,56(sp)
+ 56a: 7442 ld s0,48(sp)
+ 56c: 74a2 ld s1,40(sp)
+ 56e: 7902 ld s2,32(sp)
+ 570: 69e2 ld s3,24(sp)
+ 572: 6121 addi sp,sp,64
+ 574: 8082 ret
+ x = -xx;
+ 576: 40b005bb negw a1,a1
+ neg = 1;
+ 57a: 4885 li a7,1
+ x = -xx;
+ 57c: bf8d j 4ee <printint+0x1a>
+
+000000000000057e <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 57e: 7119 addi sp,sp,-128
+ 580: fc86 sd ra,120(sp)
+ 582: f8a2 sd s0,112(sp)
+ 584: f4a6 sd s1,104(sp)
+ 586: f0ca sd s2,96(sp)
+ 588: ecce sd s3,88(sp)
+ 58a: e8d2 sd s4,80(sp)
+ 58c: e4d6 sd s5,72(sp)
+ 58e: e0da sd s6,64(sp)
+ 590: fc5e sd s7,56(sp)
+ 592: f862 sd s8,48(sp)
+ 594: f466 sd s9,40(sp)
+ 596: f06a sd s10,32(sp)
+ 598: ec6e sd s11,24(sp)
+ 59a: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 59c: 0005c903 lbu s2,0(a1)
+ 5a0: 18090f63 beqz s2,73e <vprintf+0x1c0>
+ 5a4: 8aaa mv s5,a0
+ 5a6: 8b32 mv s6,a2
+ 5a8: 00158493 addi s1,a1,1
+ state = 0;
+ 5ac: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 5ae: 02500a13 li s4,37
+ 5b2: 4c55 li s8,21
+ 5b4: 00000c97 auipc s9,0x0
+ 5b8: 50cc8c93 addi s9,s9,1292 # ac0 <malloc+0x27e>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 5bc: 02800d93 li s11,40
+ putc(fd, 'x');
+ 5c0: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5c2: 00000b97 auipc s7,0x0
+ 5c6: 556b8b93 addi s7,s7,1366 # b18 <digits>
+ 5ca: a839 j 5e8 <vprintf+0x6a>
+ putc(fd, c);
+ 5cc: 85ca mv a1,s2
+ 5ce: 8556 mv a0,s5
+ 5d0: 00000097 auipc ra,0x0
+ 5d4: ee2080e7 jalr -286(ra) # 4b2 <putc>
+ 5d8: a019 j 5de <vprintf+0x60>
+ } else if(state == '%'){
+ 5da: 01498d63 beq s3,s4,5f4 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 5de: 0485 addi s1,s1,1
+ 5e0: fff4c903 lbu s2,-1(s1)
+ 5e4: 14090d63 beqz s2,73e <vprintf+0x1c0>
+ if(state == 0){
+ 5e8: fe0999e3 bnez s3,5da <vprintf+0x5c>
+ if(c == '%'){
+ 5ec: ff4910e3 bne s2,s4,5cc <vprintf+0x4e>
+ state = '%';
+ 5f0: 89d2 mv s3,s4
+ 5f2: b7f5 j 5de <vprintf+0x60>
+ if(c == 'd'){
+ 5f4: 11490c63 beq s2,s4,70c <vprintf+0x18e>
+ 5f8: f9d9079b addiw a5,s2,-99
+ 5fc: 0ff7f793 zext.b a5,a5
+ 600: 10fc6e63 bltu s8,a5,71c <vprintf+0x19e>
+ 604: f9d9079b addiw a5,s2,-99
+ 608: 0ff7f713 zext.b a4,a5
+ 60c: 10ec6863 bltu s8,a4,71c <vprintf+0x19e>
+ 610: 00271793 slli a5,a4,0x2
+ 614: 97e6 add a5,a5,s9
+ 616: 439c lw a5,0(a5)
+ 618: 97e6 add a5,a5,s9
+ 61a: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 61c: 008b0913 addi s2,s6,8
+ 620: 4685 li a3,1
+ 622: 4629 li a2,10
+ 624: 000b2583 lw a1,0(s6)
+ 628: 8556 mv a0,s5
+ 62a: 00000097 auipc ra,0x0
+ 62e: eaa080e7 jalr -342(ra) # 4d4 <printint>
+ 632: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 634: 4981 li s3,0
+ 636: b765 j 5de <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 638: 008b0913 addi s2,s6,8
+ 63c: 4681 li a3,0
+ 63e: 4629 li a2,10
+ 640: 000b2583 lw a1,0(s6)
+ 644: 8556 mv a0,s5
+ 646: 00000097 auipc ra,0x0
+ 64a: e8e080e7 jalr -370(ra) # 4d4 <printint>
+ 64e: 8b4a mv s6,s2
+ state = 0;
+ 650: 4981 li s3,0
+ 652: b771 j 5de <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 654: 008b0913 addi s2,s6,8
+ 658: 4681 li a3,0
+ 65a: 866a mv a2,s10
+ 65c: 000b2583 lw a1,0(s6)
+ 660: 8556 mv a0,s5
+ 662: 00000097 auipc ra,0x0
+ 666: e72080e7 jalr -398(ra) # 4d4 <printint>
+ 66a: 8b4a mv s6,s2
+ state = 0;
+ 66c: 4981 li s3,0
+ 66e: bf85 j 5de <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 670: 008b0793 addi a5,s6,8
+ 674: f8f43423 sd a5,-120(s0)
+ 678: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 67c: 03000593 li a1,48
+ 680: 8556 mv a0,s5
+ 682: 00000097 auipc ra,0x0
+ 686: e30080e7 jalr -464(ra) # 4b2 <putc>
+ putc(fd, 'x');
+ 68a: 07800593 li a1,120
+ 68e: 8556 mv a0,s5
+ 690: 00000097 auipc ra,0x0
+ 694: e22080e7 jalr -478(ra) # 4b2 <putc>
+ 698: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 69a: 03c9d793 srli a5,s3,0x3c
+ 69e: 97de add a5,a5,s7
+ 6a0: 0007c583 lbu a1,0(a5)
+ 6a4: 8556 mv a0,s5
+ 6a6: 00000097 auipc ra,0x0
+ 6aa: e0c080e7 jalr -500(ra) # 4b2 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 6ae: 0992 slli s3,s3,0x4
+ 6b0: 397d addiw s2,s2,-1
+ 6b2: fe0914e3 bnez s2,69a <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 6b6: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 6ba: 4981 li s3,0
+ 6bc: b70d j 5de <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6be: 008b0913 addi s2,s6,8
+ 6c2: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 6c6: 02098163 beqz s3,6e8 <vprintf+0x16a>
+ while(*s != 0){
+ 6ca: 0009c583 lbu a1,0(s3)
+ 6ce: c5ad beqz a1,738 <vprintf+0x1ba>
+ putc(fd, *s);
+ 6d0: 8556 mv a0,s5
+ 6d2: 00000097 auipc ra,0x0
+ 6d6: de0080e7 jalr -544(ra) # 4b2 <putc>
+ s++;
+ 6da: 0985 addi s3,s3,1
+ while(*s != 0){
+ 6dc: 0009c583 lbu a1,0(s3)
+ 6e0: f9e5 bnez a1,6d0 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 6e2: 8b4a mv s6,s2
+ state = 0;
+ 6e4: 4981 li s3,0
+ 6e6: bde5 j 5de <vprintf+0x60>
+ s = "(null)";
+ 6e8: 00000997 auipc s3,0x0
+ 6ec: 3d098993 addi s3,s3,976 # ab8 <malloc+0x276>
+ while(*s != 0){
+ 6f0: 85ee mv a1,s11
+ 6f2: bff9 j 6d0 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 6f4: 008b0913 addi s2,s6,8
+ 6f8: 000b4583 lbu a1,0(s6)
+ 6fc: 8556 mv a0,s5
+ 6fe: 00000097 auipc ra,0x0
+ 702: db4080e7 jalr -588(ra) # 4b2 <putc>
+ 706: 8b4a mv s6,s2
+ state = 0;
+ 708: 4981 li s3,0
+ 70a: bdd1 j 5de <vprintf+0x60>
+ putc(fd, c);
+ 70c: 85d2 mv a1,s4
+ 70e: 8556 mv a0,s5
+ 710: 00000097 auipc ra,0x0
+ 714: da2080e7 jalr -606(ra) # 4b2 <putc>
+ state = 0;
+ 718: 4981 li s3,0
+ 71a: b5d1 j 5de <vprintf+0x60>
+ putc(fd, '%');
+ 71c: 85d2 mv a1,s4
+ 71e: 8556 mv a0,s5
+ 720: 00000097 auipc ra,0x0
+ 724: d92080e7 jalr -622(ra) # 4b2 <putc>
+ putc(fd, c);
+ 728: 85ca mv a1,s2
+ 72a: 8556 mv a0,s5
+ 72c: 00000097 auipc ra,0x0
+ 730: d86080e7 jalr -634(ra) # 4b2 <putc>
+ state = 0;
+ 734: 4981 li s3,0
+ 736: b565 j 5de <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 738: 8b4a mv s6,s2
+ state = 0;
+ 73a: 4981 li s3,0
+ 73c: b54d j 5de <vprintf+0x60>
+ }
+ }
+}
+ 73e: 70e6 ld ra,120(sp)
+ 740: 7446 ld s0,112(sp)
+ 742: 74a6 ld s1,104(sp)
+ 744: 7906 ld s2,96(sp)
+ 746: 69e6 ld s3,88(sp)
+ 748: 6a46 ld s4,80(sp)
+ 74a: 6aa6 ld s5,72(sp)
+ 74c: 6b06 ld s6,64(sp)
+ 74e: 7be2 ld s7,56(sp)
+ 750: 7c42 ld s8,48(sp)
+ 752: 7ca2 ld s9,40(sp)
+ 754: 7d02 ld s10,32(sp)
+ 756: 6de2 ld s11,24(sp)
+ 758: 6109 addi sp,sp,128
+ 75a: 8082 ret
+
+000000000000075c <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 75c: 715d addi sp,sp,-80
+ 75e: ec06 sd ra,24(sp)
+ 760: e822 sd s0,16(sp)
+ 762: 1000 addi s0,sp,32
+ 764: e010 sd a2,0(s0)
+ 766: e414 sd a3,8(s0)
+ 768: e818 sd a4,16(s0)
+ 76a: ec1c sd a5,24(s0)
+ 76c: 03043023 sd a6,32(s0)
+ 770: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 774: 8622 mv a2,s0
+ 776: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 77a: 00000097 auipc ra,0x0
+ 77e: e04080e7 jalr -508(ra) # 57e <vprintf>
+}
+ 782: 60e2 ld ra,24(sp)
+ 784: 6442 ld s0,16(sp)
+ 786: 6161 addi sp,sp,80
+ 788: 8082 ret
+
+000000000000078a <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 78a: 711d addi sp,sp,-96
+ 78c: ec06 sd ra,24(sp)
+ 78e: e822 sd s0,16(sp)
+ 790: 1000 addi s0,sp,32
+ 792: e40c sd a1,8(s0)
+ 794: e810 sd a2,16(s0)
+ 796: ec14 sd a3,24(s0)
+ 798: f018 sd a4,32(s0)
+ 79a: f41c sd a5,40(s0)
+ 79c: 03043823 sd a6,48(s0)
+ 7a0: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 7a4: 00840613 addi a2,s0,8
+ 7a8: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 7ac: 85aa mv a1,a0
+ 7ae: 4505 li a0,1
+ 7b0: 00000097 auipc ra,0x0
+ 7b4: dce080e7 jalr -562(ra) # 57e <vprintf>
+}
+ 7b8: 60e2 ld ra,24(sp)
+ 7ba: 6442 ld s0,16(sp)
+ 7bc: 6125 addi sp,sp,96
+ 7be: 8082 ret
+
+00000000000007c0 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 7c0: 1141 addi sp,sp,-16
+ 7c2: e422 sd s0,8(sp)
+ 7c4: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 7c6: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 7ca: 00000797 auipc a5,0x0
+ 7ce: 47e7b783 ld a5,1150(a5) # c48 <freep>
+ 7d2: a02d j 7fc <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 7d4: 4618 lw a4,8(a2)
+ 7d6: 9f2d addw a4,a4,a1
+ 7d8: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 7dc: 6398 ld a4,0(a5)
+ 7de: 6310 ld a2,0(a4)
+ 7e0: a83d j 81e <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 7e2: ff852703 lw a4,-8(a0)
+ 7e6: 9f31 addw a4,a4,a2
+ 7e8: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 7ea: ff053683 ld a3,-16(a0)
+ 7ee: a091 j 832 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 7f0: 6398 ld a4,0(a5)
+ 7f2: 00e7e463 bltu a5,a4,7fa <free+0x3a>
+ 7f6: 00e6ea63 bltu a3,a4,80a <free+0x4a>
+{
+ 7fa: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 7fc: fed7fae3 bgeu a5,a3,7f0 <free+0x30>
+ 800: 6398 ld a4,0(a5)
+ 802: 00e6e463 bltu a3,a4,80a <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 806: fee7eae3 bltu a5,a4,7fa <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 80a: ff852583 lw a1,-8(a0)
+ 80e: 6390 ld a2,0(a5)
+ 810: 02059813 slli a6,a1,0x20
+ 814: 01c85713 srli a4,a6,0x1c
+ 818: 9736 add a4,a4,a3
+ 81a: fae60de3 beq a2,a4,7d4 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 81e: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 822: 4790 lw a2,8(a5)
+ 824: 02061593 slli a1,a2,0x20
+ 828: 01c5d713 srli a4,a1,0x1c
+ 82c: 973e add a4,a4,a5
+ 82e: fae68ae3 beq a3,a4,7e2 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 832: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 834: 00000717 auipc a4,0x0
+ 838: 40f73a23 sd a5,1044(a4) # c48 <freep>
+}
+ 83c: 6422 ld s0,8(sp)
+ 83e: 0141 addi sp,sp,16
+ 840: 8082 ret
+
+0000000000000842 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 842: 7139 addi sp,sp,-64
+ 844: fc06 sd ra,56(sp)
+ 846: f822 sd s0,48(sp)
+ 848: f426 sd s1,40(sp)
+ 84a: f04a sd s2,32(sp)
+ 84c: ec4e sd s3,24(sp)
+ 84e: e852 sd s4,16(sp)
+ 850: e456 sd s5,8(sp)
+ 852: e05a sd s6,0(sp)
+ 854: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 856: 02051493 slli s1,a0,0x20
+ 85a: 9081 srli s1,s1,0x20
+ 85c: 04bd addi s1,s1,15
+ 85e: 8091 srli s1,s1,0x4
+ 860: 00148a1b addiw s4,s1,1
+ 864: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 866: 00000517 auipc a0,0x0
+ 86a: 3e253503 ld a0,994(a0) # c48 <freep>
+ 86e: c515 beqz a0,89a <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 870: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 872: 4798 lw a4,8(a5)
+ 874: 04977163 bgeu a4,s1,8b6 <malloc+0x74>
+ 878: 89d2 mv s3,s4
+ 87a: 000a071b sext.w a4,s4
+ 87e: 6685 lui a3,0x1
+ 880: 00d77363 bgeu a4,a3,886 <malloc+0x44>
+ 884: 6985 lui s3,0x1
+ 886: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 88a: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 88e: 00000917 auipc s2,0x0
+ 892: 3ba90913 addi s2,s2,954 # c48 <freep>
+ if(p == (char*)-1)
+ 896: 5afd li s5,-1
+ 898: a8a5 j 910 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 89a: 00000797 auipc a5,0x0
+ 89e: 3ae78793 addi a5,a5,942 # c48 <freep>
+ 8a2: 00000717 auipc a4,0x0
+ 8a6: 3ae70713 addi a4,a4,942 # c50 <base>
+ 8aa: e398 sd a4,0(a5)
+ 8ac: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 8ae: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 8b2: 87ba mv a5,a4
+ 8b4: b7d1 j 878 <malloc+0x36>
+ if(p->s.size == nunits)
+ 8b6: 02e48c63 beq s1,a4,8ee <malloc+0xac>
+ p->s.size -= nunits;
+ 8ba: 4147073b subw a4,a4,s4
+ 8be: c798 sw a4,8(a5)
+ p += p->s.size;
+ 8c0: 02071693 slli a3,a4,0x20
+ 8c4: 01c6d713 srli a4,a3,0x1c
+ 8c8: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 8ca: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 8ce: 00000717 auipc a4,0x0
+ 8d2: 36a73d23 sd a0,890(a4) # c48 <freep>
+ return (void*)(p + 1);
+ 8d6: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 8da: 70e2 ld ra,56(sp)
+ 8dc: 7442 ld s0,48(sp)
+ 8de: 74a2 ld s1,40(sp)
+ 8e0: 7902 ld s2,32(sp)
+ 8e2: 69e2 ld s3,24(sp)
+ 8e4: 6a42 ld s4,16(sp)
+ 8e6: 6aa2 ld s5,8(sp)
+ 8e8: 6b02 ld s6,0(sp)
+ 8ea: 6121 addi sp,sp,64
+ 8ec: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 8ee: 6398 ld a4,0(a5)
+ 8f0: e118 sd a4,0(a0)
+ 8f2: bff1 j 8ce <malloc+0x8c>
+ hp->s.size = nu;
+ 8f4: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 8f8: 0541 addi a0,a0,16
+ 8fa: 00000097 auipc ra,0x0
+ 8fe: ec6080e7 jalr -314(ra) # 7c0 <free>
+ return freep;
+ 902: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 906: d971 beqz a0,8da <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 908: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 90a: 4798 lw a4,8(a5)
+ 90c: fa9775e3 bgeu a4,s1,8b6 <malloc+0x74>
+ if(p == freep)
+ 910: 00093703 ld a4,0(s2)
+ 914: 853e mv a0,a5
+ 916: fef719e3 bne a4,a5,908 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 91a: 854e mv a0,s3
+ 91c: 00000097 auipc ra,0x0
+ 920: b30080e7 jalr -1232(ra) # 44c <sbrk>
+ if(p == (char*)-1)
+ 924: fd5518e3 bne a0,s5,8f4 <malloc+0xb2>
+ return 0;
+ 928: 4501 li a0,0
+ 92a: bf45 j 8da <malloc+0x98>
diff --git a/xv6-user/init.c b/xv6-user/init.c
new file mode 100644
index 0000000000000000000000000000000000000000..998cc8a4ea28d060f79b52aeb5e02b59347fce63
--- /dev/null
+++ b/xv6-user/init.c
@@ -0,0 +1,104 @@
+// init: The initial user-level program
+
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/file.h"
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+#include "kernel/include/sysnum.h"
+char *argv[] = {0};
+char *tests[]={
+ "brk",
+ "chdir",
+ "clone",
+ "close",
+ "dup",
+ "dup2",
+ "execve",
+ "exit",
+ "fork",
+ "fstat",
+ "getcwd",
+ "getdents",
+ "getpid",
+ "getppid",
+ "gettimeofday",
+ "mkdir_",
+ "mmap",
+ "mount",
+ "munmap",
+ "open",
+ "openat",
+ "pipe",
+ "read",
+ "sleep",
+ "test_echo",
+ "times",
+ "umount",
+ "uname",
+ "unlink",
+ "wait",
+ "waitpid",
+ "write",
+ "yield",
+};
+int counts = sizeof(tests) / sizeof((tests)[0]);
+
+#define __asm_syscall(...) \
+ __asm__ __volatile__("ecall\n\t" \
+ : "=r"(a0) \
+ : __VA_ARGS__ \
+ : "memory"); \
+ return a0;
+static inline long __syscall0(long n)
+{
+ register long a7 __asm__("a7") = n;
+ register long a0 __asm__("a0");
+ __asm_syscall("r"(a7))
+}
+
+int
+main(void)
+{
+ int pid, wpid;
+
+ // if(open("console", O_RDWR) < 0){
+ // mknod("console", CONSOLE, 0);
+ // open("console", O_RDWR);
+ // }
+ dev(O_RDWR, CONSOLE, 0);
+ dup(0); // stdout
+ dup(0); // stderr
+
+ for(int i=0;i<counts;i++){
+ printf("init: starting sh\n");
+ pid = fork();
+ if(pid < 0){
+ printf("init: fork failed\n");
+ exit(1);
+ }
+ if(pid == 0){
+ exec(tests[i], argv);
+ printf("init: exec sh failed\n");
+ exit(1);
+ }
+
+ for(;;){
+ // this call to wait() returns if the shell exits,
+ // or if a parentless process exits.
+ wpid = wait((int *) 0);
+ if(wpid == pid){
+ // the shell exited; restart it.
+ break;
+ } else if(wpid < 0){
+ printf("init: wait returned an error\n");
+ exit(1);
+ } else {
+ // it was a parentless process; do nothing.
+ }
+ }
+ }
+ __syscall0(SYS_shutdown);
+ return 0;
+}
diff --git a/xv6-user/init.d b/xv6-user/init.d
new file mode 100644
index 0000000000000000000000000000000000000000..d717fb9d03c05733da373d381ca89e3e6297ceba
--- /dev/null
+++ b/xv6-user/init.d
@@ -0,0 +1,3 @@
+xv6-user/init.o: xv6-user/init.c kernel/include/types.h \
+ kernel/include/stat.h kernel/include/file.h kernel/include/fcntl.h \
+ xv6-user/user.h kernel/include/sysnum.h
diff --git a/xv6-user/init.o b/xv6-user/init.o
new file mode 100644
index 0000000000000000000000000000000000000000..4d026c5db0a932a5c6b25b0942529ec2bd8c4990
Binary files /dev/null and b/xv6-user/init.o differ
diff --git a/xv6-user/init.sym b/xv6-user/init.sym
new file mode 100644
index 0000000000000000000000000000000000000000..232294b54881081bbe4a405656aa94fe80d6d505
--- /dev/null
+++ b/xv6-user/init.sym
@@ -0,0 +1,80 @@
+0000000000000000 .text
+0000000000000930 .rodata
+0000000000000b30 .data
+0000000000000c40 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 init.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000004b2 putc
+00000000000004d4 printint
+0000000000000b18 digits
+0000000000000000 umalloc.c
+0000000000000c48 freep
+0000000000000c50 base
+000000000000010e strcpy
+000000000000078a printf
+0000000000001330 __global_pointer$
+000000000000046c dev
+0000000000000c40 argv
+0000000000000314 memmove
+0000000000000490 trace
+00000000000001f4 gets
+0000000000000c40 __SDATA_BEGIN__
+0000000000000442 getpid
+00000000000003a6 memcpy
+0000000000000842 malloc
+0000000000000486 remove
+0000000000000454 sleep
+0000000000000498 sysinfo
+0000000000000476 readdir
+00000000000003d8 pipe
+00000000000004a0 rename
+00000000000003ec write
+000000000000041c fstat
+000000000000075c fprintf
+0000000000000400 kill
+000000000000012a strcat
+000000000000057e vprintf
+0000000000000430 chdir
+0000000000000408 exec
+00000000000003d0 wait
+00000000000003e2 read
+000000000000036c memcmp
+00000000000003be fork
+0000000000000c60 __BSS_END__
+000000000000044c sbrk
+0000000000000464 test_proc
+000000000000045c uptime
+0000000000000c40 __bss_start
+00000000000001ae memset
+0000000000000000 main
+0000000000000b38 tests
+0000000000000158 strcmp
+00000000000004a8 shutdown
+000000000000043a dup
+000000000000047e getcwd
+0000000000000b30 __DATA_BEGIN__
+000000000000026e stat
+0000000000000c40 _edata
+0000000000000c60 _end
+00000000000003c6 exit
+00000000000002b4 atoi
+0000000000000184 strlen
+0000000000000412 open
+00000000000001d0 strchr
+0000000000000b30 counts
+0000000000000426 mkdir
+00000000000003f6 close
+00000000000007c0 free
diff --git a/xv6-user/initcode b/xv6-user/initcode
new file mode 100644
index 0000000000000000000000000000000000000000..d67c5f3d7e9c60c03d2efeef72ce8778768e065c
Binary files /dev/null and b/xv6-user/initcode differ
diff --git a/xv6-user/initcode.S b/xv6-user/initcode.S
new file mode 100644
index 0000000000000000000000000000000000000000..656395c91c65dd4ae1113f6adf5f56fa35a7a39d
--- /dev/null
+++ b/xv6-user/initcode.S
@@ -0,0 +1,28 @@
+# Initial process that execs /init.
+# This code runs in user space.
+
+#include "include/sysnum.h"
+
+# exec(init, argv)
+.globl start
+start:
+ la a0, init
+ la a1, argv
+ li a7, SYS_exec
+ ecall
+
+# for(;;) exit();
+exit:
+ li a7, SYS_exit
+ ecall
+ jal exit
+
+# char init[] = "/init\0";
+init:
+ .string "/init\0"
+
+# char *argv[] = { init, 0 };
+.p2align 2
+argv:
+ .long init
+ .long 0
diff --git a/xv6-user/initcode.asm b/xv6-user/initcode.asm
new file mode 100644
index 0000000000000000000000000000000000000000..594574bdd18940db7352cfff436746a1c2d7f892
--- /dev/null
+++ b/xv6-user/initcode.asm
@@ -0,0 +1,41 @@
+
+xv6-user/initcode.o: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <start>:
+#include "include/sysnum.h"
+
+# exec(init, argv)
+.globl start
+start:
+ la a0, init
+ 0: 00000517 auipc a0,0x0
+ 4: 00053503 ld a0,0(a0) # 0 <start>
+ la a1, argv
+ 8: 00000597 auipc a1,0x0
+ c: 0005b583 ld a1,0(a1) # 8 <start+0x8>
+ li a7, SYS_exec
+ 10: 0dd00893 li a7,221
+ ecall
+ 14: 00000073 ecall
+
+0000000000000018 <exit>:
+
+# for(;;) exit();
+exit:
+ li a7, SYS_exit
+ 18: 05d00893 li a7,93
+ ecall
+ 1c: 00000073 ecall
+ jal exit
+ 20: ff9ff0ef jal ra,18 <exit>
+
+0000000000000024 <init>:
+ 24: 696e692f .word 0x696e692f
+ 28: Address 0x0000000000000028 is out of bounds.
+
+
+000000000000002b <argv>:
+ ...
diff --git a/xv6-user/initcode.d b/xv6-user/initcode.d
new file mode 100644
index 0000000000000000000000000000000000000000..5e38d6f574ccc8ccb1eaad4c379b7ceb53a1865e
--- /dev/null
+++ b/xv6-user/initcode.d
@@ -0,0 +1 @@
+xv6-user/initcode.o: xv6-user/initcode.S kernel/include/sysnum.h
diff --git a/xv6-user/initcode.o b/xv6-user/initcode.o
new file mode 100644
index 0000000000000000000000000000000000000000..39b646b5e61d0d35a05fdd78f88e1f8b4e3aff11
Binary files /dev/null and b/xv6-user/initcode.o differ
diff --git a/xv6-user/initcode.out b/xv6-user/initcode.out
new file mode 100644
index 0000000000000000000000000000000000000000..94964173e5a767f67e60fc517bf20e31996abb84
Binary files /dev/null and b/xv6-user/initcode.out differ
diff --git a/xv6-user/kill.asm b/xv6-user/kill.asm
new file mode 100644
index 0000000000000000000000000000000000000000..133741abe05442a956820ccc2371044521958c82
--- /dev/null
+++ b/xv6-user/kill.asm
@@ -0,0 +1,1438 @@
+
+xv6-user/_kill: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char **argv)
+{
+ 0: 1101 addi sp,sp,-32
+ 2: ec06 sd ra,24(sp)
+ 4: e822 sd s0,16(sp)
+ 6: e426 sd s1,8(sp)
+ 8: e04a sd s2,0(sp)
+ a: 1000 addi s0,sp,32
+ int i;
+
+ if(argc < 2){
+ c: 4785 li a5,1
+ e: 02a7dd63 bge a5,a0,48 <main+0x48>
+ 12: 00858493 addi s1,a1,8
+ 16: ffe5091b addiw s2,a0,-2
+ 1a: 02091793 slli a5,s2,0x20
+ 1e: 01d7d913 srli s2,a5,0x1d
+ 22: 05c1 addi a1,a1,16
+ 24: 992e add s2,s2,a1
+ fprintf(2, "usage: kill pid...\n");
+ exit(1);
+ }
+ for(i=1; i<argc; i++)
+ kill(atoi(argv[i]));
+ 26: 6088 ld a0,0(s1)
+ 28: 00000097 auipc ra,0x0
+ 2c: 1e2080e7 jalr 482(ra) # 20a <atoi>
+ 30: 00000097 auipc ra,0x0
+ 34: 326080e7 jalr 806(ra) # 356 <kill>
+ for(i=1; i<argc; i++)
+ 38: 04a1 addi s1,s1,8
+ 3a: ff2496e3 bne s1,s2,26 <main+0x26>
+ exit(0);
+ 3e: 4501 li a0,0
+ 40: 00000097 auipc ra,0x0
+ 44: 2dc080e7 jalr 732(ra) # 31c <exit>
+ fprintf(2, "usage: kill pid...\n");
+ 48: 00001597 auipc a1,0x1
+ 4c: 84058593 addi a1,a1,-1984 # 888 <malloc+0xf0>
+ 50: 4509 li a0,2
+ 52: 00000097 auipc ra,0x0
+ 56: 660080e7 jalr 1632(ra) # 6b2 <fprintf>
+ exit(1);
+ 5a: 4505 li a0,1
+ 5c: 00000097 auipc ra,0x0
+ 60: 2c0080e7 jalr 704(ra) # 31c <exit>
+
+0000000000000064 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 64: 1141 addi sp,sp,-16
+ 66: e422 sd s0,8(sp)
+ 68: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 6a: 87aa mv a5,a0
+ 6c: 0585 addi a1,a1,1
+ 6e: 0785 addi a5,a5,1
+ 70: fff5c703 lbu a4,-1(a1)
+ 74: fee78fa3 sb a4,-1(a5)
+ 78: fb75 bnez a4,6c <strcpy+0x8>
+ ;
+ return os;
+}
+ 7a: 6422 ld s0,8(sp)
+ 7c: 0141 addi sp,sp,16
+ 7e: 8082 ret
+
+0000000000000080 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 80: 1141 addi sp,sp,-16
+ 82: e422 sd s0,8(sp)
+ 84: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 86: 00054783 lbu a5,0(a0)
+ 8a: c385 beqz a5,aa <strcat+0x2a>
+ 8c: 87aa mv a5,a0
+ s++;
+ 8e: 0785 addi a5,a5,1
+ while(*s)
+ 90: 0007c703 lbu a4,0(a5)
+ 94: ff6d bnez a4,8e <strcat+0xe>
+ while((*s++ = *t++))
+ 96: 0585 addi a1,a1,1
+ 98: 0785 addi a5,a5,1
+ 9a: fff5c703 lbu a4,-1(a1)
+ 9e: fee78fa3 sb a4,-1(a5)
+ a2: fb75 bnez a4,96 <strcat+0x16>
+ ;
+ return os;
+}
+ a4: 6422 ld s0,8(sp)
+ a6: 0141 addi sp,sp,16
+ a8: 8082 ret
+ while(*s)
+ aa: 87aa mv a5,a0
+ ac: b7ed j 96 <strcat+0x16>
+
+00000000000000ae <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ ae: 1141 addi sp,sp,-16
+ b0: e422 sd s0,8(sp)
+ b2: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ b4: 00054783 lbu a5,0(a0)
+ b8: cb91 beqz a5,cc <strcmp+0x1e>
+ ba: 0005c703 lbu a4,0(a1)
+ be: 00f71763 bne a4,a5,cc <strcmp+0x1e>
+ p++, q++;
+ c2: 0505 addi a0,a0,1
+ c4: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ c6: 00054783 lbu a5,0(a0)
+ ca: fbe5 bnez a5,ba <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ cc: 0005c503 lbu a0,0(a1)
+}
+ d0: 40a7853b subw a0,a5,a0
+ d4: 6422 ld s0,8(sp)
+ d6: 0141 addi sp,sp,16
+ d8: 8082 ret
+
+00000000000000da <strlen>:
+
+uint
+strlen(const char *s)
+{
+ da: 1141 addi sp,sp,-16
+ dc: e422 sd s0,8(sp)
+ de: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ e0: 00054783 lbu a5,0(a0)
+ e4: cf91 beqz a5,100 <strlen+0x26>
+ e6: 0505 addi a0,a0,1
+ e8: 87aa mv a5,a0
+ ea: 4685 li a3,1
+ ec: 9e89 subw a3,a3,a0
+ ee: 00f6853b addw a0,a3,a5
+ f2: 0785 addi a5,a5,1
+ f4: fff7c703 lbu a4,-1(a5)
+ f8: fb7d bnez a4,ee <strlen+0x14>
+ ;
+ return n;
+}
+ fa: 6422 ld s0,8(sp)
+ fc: 0141 addi sp,sp,16
+ fe: 8082 ret
+ for(n = 0; s[n]; n++)
+ 100: 4501 li a0,0
+ 102: bfe5 j fa <strlen+0x20>
+
+0000000000000104 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 104: 1141 addi sp,sp,-16
+ 106: e422 sd s0,8(sp)
+ 108: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 10a: ca19 beqz a2,120 <memset+0x1c>
+ 10c: 87aa mv a5,a0
+ 10e: 1602 slli a2,a2,0x20
+ 110: 9201 srli a2,a2,0x20
+ 112: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 116: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 11a: 0785 addi a5,a5,1
+ 11c: fee79de3 bne a5,a4,116 <memset+0x12>
+ }
+ return dst;
+}
+ 120: 6422 ld s0,8(sp)
+ 122: 0141 addi sp,sp,16
+ 124: 8082 ret
+
+0000000000000126 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 126: 1141 addi sp,sp,-16
+ 128: e422 sd s0,8(sp)
+ 12a: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 12c: 00054783 lbu a5,0(a0)
+ 130: cb99 beqz a5,146 <strchr+0x20>
+ if(*s == c)
+ 132: 00f58763 beq a1,a5,140 <strchr+0x1a>
+ for(; *s; s++)
+ 136: 0505 addi a0,a0,1
+ 138: 00054783 lbu a5,0(a0)
+ 13c: fbfd bnez a5,132 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 13e: 4501 li a0,0
+}
+ 140: 6422 ld s0,8(sp)
+ 142: 0141 addi sp,sp,16
+ 144: 8082 ret
+ return 0;
+ 146: 4501 li a0,0
+ 148: bfe5 j 140 <strchr+0x1a>
+
+000000000000014a <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 14a: 711d addi sp,sp,-96
+ 14c: ec86 sd ra,88(sp)
+ 14e: e8a2 sd s0,80(sp)
+ 150: e4a6 sd s1,72(sp)
+ 152: e0ca sd s2,64(sp)
+ 154: fc4e sd s3,56(sp)
+ 156: f852 sd s4,48(sp)
+ 158: f456 sd s5,40(sp)
+ 15a: f05a sd s6,32(sp)
+ 15c: ec5e sd s7,24(sp)
+ 15e: e862 sd s8,16(sp)
+ 160: 1080 addi s0,sp,96
+ 162: 8baa mv s7,a0
+ 164: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 166: 892a mv s2,a0
+ 168: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 16a: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 16e: 4b29 li s6,10
+ 170: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 172: 89a6 mv s3,s1
+ 174: 2485 addiw s1,s1,1
+ 176: 0344d763 bge s1,s4,1a4 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 17a: 4605 li a2,1
+ 17c: 85d6 mv a1,s5
+ 17e: 4501 li a0,0
+ 180: 00000097 auipc ra,0x0
+ 184: 1b8080e7 jalr 440(ra) # 338 <read>
+ if(cc < 1)
+ 188: 00a05e63 blez a0,1a4 <gets+0x5a>
+ buf[i++] = c;
+ 18c: faf44783 lbu a5,-81(s0)
+ 190: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 194: 01678763 beq a5,s6,1a2 <gets+0x58>
+ 198: 0905 addi s2,s2,1
+ 19a: fd879ce3 bne a5,s8,172 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 19e: 89a6 mv s3,s1
+ 1a0: a011 j 1a4 <gets+0x5a>
+ 1a2: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1a4: 99de add s3,s3,s7
+ 1a6: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1aa: 855e mv a0,s7
+ 1ac: 60e6 ld ra,88(sp)
+ 1ae: 6446 ld s0,80(sp)
+ 1b0: 64a6 ld s1,72(sp)
+ 1b2: 6906 ld s2,64(sp)
+ 1b4: 79e2 ld s3,56(sp)
+ 1b6: 7a42 ld s4,48(sp)
+ 1b8: 7aa2 ld s5,40(sp)
+ 1ba: 7b02 ld s6,32(sp)
+ 1bc: 6be2 ld s7,24(sp)
+ 1be: 6c42 ld s8,16(sp)
+ 1c0: 6125 addi sp,sp,96
+ 1c2: 8082 ret
+
+00000000000001c4 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1c4: 1101 addi sp,sp,-32
+ 1c6: ec06 sd ra,24(sp)
+ 1c8: e822 sd s0,16(sp)
+ 1ca: e426 sd s1,8(sp)
+ 1cc: e04a sd s2,0(sp)
+ 1ce: 1000 addi s0,sp,32
+ 1d0: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1d2: 4581 li a1,0
+ 1d4: 00000097 auipc ra,0x0
+ 1d8: 194080e7 jalr 404(ra) # 368 <open>
+ if(fd < 0)
+ 1dc: 02054563 bltz a0,206 <stat+0x42>
+ 1e0: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1e2: 85ca mv a1,s2
+ 1e4: 00000097 auipc ra,0x0
+ 1e8: 18e080e7 jalr 398(ra) # 372 <fstat>
+ 1ec: 892a mv s2,a0
+ close(fd);
+ 1ee: 8526 mv a0,s1
+ 1f0: 00000097 auipc ra,0x0
+ 1f4: 15c080e7 jalr 348(ra) # 34c <close>
+ return r;
+}
+ 1f8: 854a mv a0,s2
+ 1fa: 60e2 ld ra,24(sp)
+ 1fc: 6442 ld s0,16(sp)
+ 1fe: 64a2 ld s1,8(sp)
+ 200: 6902 ld s2,0(sp)
+ 202: 6105 addi sp,sp,32
+ 204: 8082 ret
+ return -1;
+ 206: 597d li s2,-1
+ 208: bfc5 j 1f8 <stat+0x34>
+
+000000000000020a <atoi>:
+
+int
+atoi(const char *s)
+{
+ 20a: 1141 addi sp,sp,-16
+ 20c: e422 sd s0,8(sp)
+ 20e: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 210: 00054703 lbu a4,0(a0)
+ 214: 02d00793 li a5,45
+ int neg = 1;
+ 218: 4585 li a1,1
+ if (*s == '-') {
+ 21a: 04f70363 beq a4,a5,260 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 21e: 00054703 lbu a4,0(a0)
+ 222: fd07079b addiw a5,a4,-48
+ 226: 0ff7f793 zext.b a5,a5
+ 22a: 46a5 li a3,9
+ 22c: 02f6ed63 bltu a3,a5,266 <atoi+0x5c>
+ n = 0;
+ 230: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 232: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 234: 0505 addi a0,a0,1
+ 236: 0026979b slliw a5,a3,0x2
+ 23a: 9fb5 addw a5,a5,a3
+ 23c: 0017979b slliw a5,a5,0x1
+ 240: 9fb9 addw a5,a5,a4
+ 242: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 246: 00054703 lbu a4,0(a0)
+ 24a: fd07079b addiw a5,a4,-48
+ 24e: 0ff7f793 zext.b a5,a5
+ 252: fef671e3 bgeu a2,a5,234 <atoi+0x2a>
+ return n * neg;
+}
+ 256: 02d5853b mulw a0,a1,a3
+ 25a: 6422 ld s0,8(sp)
+ 25c: 0141 addi sp,sp,16
+ 25e: 8082 ret
+ s++;
+ 260: 0505 addi a0,a0,1
+ neg = -1;
+ 262: 55fd li a1,-1
+ 264: bf6d j 21e <atoi+0x14>
+ n = 0;
+ 266: 4681 li a3,0
+ 268: b7fd j 256 <atoi+0x4c>
+
+000000000000026a <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 26a: 1141 addi sp,sp,-16
+ 26c: e422 sd s0,8(sp)
+ 26e: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 270: 02b57463 bgeu a0,a1,298 <memmove+0x2e>
+ while(n-- > 0)
+ 274: 00c05f63 blez a2,292 <memmove+0x28>
+ 278: 1602 slli a2,a2,0x20
+ 27a: 9201 srli a2,a2,0x20
+ 27c: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 280: 872a mv a4,a0
+ *dst++ = *src++;
+ 282: 0585 addi a1,a1,1
+ 284: 0705 addi a4,a4,1
+ 286: fff5c683 lbu a3,-1(a1)
+ 28a: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 28e: fee79ae3 bne a5,a4,282 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 292: 6422 ld s0,8(sp)
+ 294: 0141 addi sp,sp,16
+ 296: 8082 ret
+ dst += n;
+ 298: 00c50733 add a4,a0,a2
+ src += n;
+ 29c: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 29e: fec05ae3 blez a2,292 <memmove+0x28>
+ 2a2: fff6079b addiw a5,a2,-1
+ 2a6: 1782 slli a5,a5,0x20
+ 2a8: 9381 srli a5,a5,0x20
+ 2aa: fff7c793 not a5,a5
+ 2ae: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2b0: 15fd addi a1,a1,-1
+ 2b2: 177d addi a4,a4,-1
+ 2b4: 0005c683 lbu a3,0(a1)
+ 2b8: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2bc: fee79ae3 bne a5,a4,2b0 <memmove+0x46>
+ 2c0: bfc9 j 292 <memmove+0x28>
+
+00000000000002c2 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2c2: 1141 addi sp,sp,-16
+ 2c4: e422 sd s0,8(sp)
+ 2c6: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2c8: ca05 beqz a2,2f8 <memcmp+0x36>
+ 2ca: fff6069b addiw a3,a2,-1
+ 2ce: 1682 slli a3,a3,0x20
+ 2d0: 9281 srli a3,a3,0x20
+ 2d2: 0685 addi a3,a3,1
+ 2d4: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2d6: 00054783 lbu a5,0(a0)
+ 2da: 0005c703 lbu a4,0(a1)
+ 2de: 00e79863 bne a5,a4,2ee <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2e2: 0505 addi a0,a0,1
+ p2++;
+ 2e4: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2e6: fed518e3 bne a0,a3,2d6 <memcmp+0x14>
+ }
+ return 0;
+ 2ea: 4501 li a0,0
+ 2ec: a019 j 2f2 <memcmp+0x30>
+ return *p1 - *p2;
+ 2ee: 40e7853b subw a0,a5,a4
+}
+ 2f2: 6422 ld s0,8(sp)
+ 2f4: 0141 addi sp,sp,16
+ 2f6: 8082 ret
+ return 0;
+ 2f8: 4501 li a0,0
+ 2fa: bfe5 j 2f2 <memcmp+0x30>
+
+00000000000002fc <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 2fc: 1141 addi sp,sp,-16
+ 2fe: e406 sd ra,8(sp)
+ 300: e022 sd s0,0(sp)
+ 302: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 304: 00000097 auipc ra,0x0
+ 308: f66080e7 jalr -154(ra) # 26a <memmove>
+}
+ 30c: 60a2 ld ra,8(sp)
+ 30e: 6402 ld s0,0(sp)
+ 310: 0141 addi sp,sp,16
+ 312: 8082 ret
+
+0000000000000314 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 314: 4885 li a7,1
+ ecall
+ 316: 00000073 ecall
+ ret
+ 31a: 8082 ret
+
+000000000000031c <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 31c: 05d00893 li a7,93
+ ecall
+ 320: 00000073 ecall
+ ret
+ 324: 8082 ret
+
+0000000000000326 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 326: 488d li a7,3
+ ecall
+ 328: 00000073 ecall
+ ret
+ 32c: 8082 ret
+
+000000000000032e <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 32e: 03b00893 li a7,59
+ ecall
+ 332: 00000073 ecall
+ ret
+ 336: 8082 ret
+
+0000000000000338 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 338: 03f00893 li a7,63
+ ecall
+ 33c: 00000073 ecall
+ ret
+ 340: 8082 ret
+
+0000000000000342 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 342: 04000893 li a7,64
+ ecall
+ 346: 00000073 ecall
+ ret
+ 34a: 8082 ret
+
+000000000000034c <close>:
+.global close
+close:
+ li a7, SYS_close
+ 34c: 03900893 li a7,57
+ ecall
+ 350: 00000073 ecall
+ ret
+ 354: 8082 ret
+
+0000000000000356 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 356: 4899 li a7,6
+ ecall
+ 358: 00000073 ecall
+ ret
+ 35c: 8082 ret
+
+000000000000035e <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 35e: 0dd00893 li a7,221
+ ecall
+ 362: 00000073 ecall
+ ret
+ 366: 8082 ret
+
+0000000000000368 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 368: 03800893 li a7,56
+ ecall
+ 36c: 00000073 ecall
+ ret
+ 370: 8082 ret
+
+0000000000000372 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 372: 05000893 li a7,80
+ ecall
+ 376: 00000073 ecall
+ ret
+ 37a: 8082 ret
+
+000000000000037c <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 37c: 02200893 li a7,34
+ ecall
+ 380: 00000073 ecall
+ ret
+ 384: 8082 ret
+
+0000000000000386 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 386: 03100893 li a7,49
+ ecall
+ 38a: 00000073 ecall
+ ret
+ 38e: 8082 ret
+
+0000000000000390 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 390: 48dd li a7,23
+ ecall
+ 392: 00000073 ecall
+ ret
+ 396: 8082 ret
+
+0000000000000398 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 398: 0ac00893 li a7,172
+ ecall
+ 39c: 00000073 ecall
+ ret
+ 3a0: 8082 ret
+
+00000000000003a2 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 3a2: 48b1 li a7,12
+ ecall
+ 3a4: 00000073 ecall
+ ret
+ 3a8: 8082 ret
+
+00000000000003aa <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3aa: 48b5 li a7,13
+ ecall
+ 3ac: 00000073 ecall
+ ret
+ 3b0: 8082 ret
+
+00000000000003b2 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3b2: 48b9 li a7,14
+ ecall
+ 3b4: 00000073 ecall
+ ret
+ 3b8: 8082 ret
+
+00000000000003ba <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3ba: 48d9 li a7,22
+ ecall
+ 3bc: 00000073 ecall
+ ret
+ 3c0: 8082 ret
+
+00000000000003c2 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3c2: 03200893 li a7,50
+ ecall
+ 3c6: 00000073 ecall
+ ret
+ 3ca: 8082 ret
+
+00000000000003cc <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3cc: 48ed li a7,27
+ ecall
+ 3ce: 00000073 ecall
+ ret
+ 3d2: 8082 ret
+
+00000000000003d4 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3d4: 48c5 li a7,17
+ ecall
+ 3d6: 00000073 ecall
+ ret
+ 3da: 8082 ret
+
+00000000000003dc <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3dc: 07500893 li a7,117
+ ecall
+ 3e0: 00000073 ecall
+ ret
+ 3e4: 8082 ret
+
+00000000000003e6 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3e6: 48c9 li a7,18
+ ecall
+ 3e8: 00000073 ecall
+ ret
+ 3ec: 8082 ret
+
+00000000000003ee <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 3ee: 48cd li a7,19
+ ecall
+ 3f0: 00000073 ecall
+ ret
+ 3f4: 8082 ret
+
+00000000000003f6 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 3f6: 48e9 li a7,26
+ ecall
+ 3f8: 00000073 ecall
+ ret
+ 3fc: 8082 ret
+
+00000000000003fe <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 3fe: 0d200893 li a7,210
+ ecall
+ 402: 00000073 ecall
+ ret
+ 406: 8082 ret
+
+0000000000000408 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 408: 1101 addi sp,sp,-32
+ 40a: ec06 sd ra,24(sp)
+ 40c: e822 sd s0,16(sp)
+ 40e: 1000 addi s0,sp,32
+ 410: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 414: 4605 li a2,1
+ 416: fef40593 addi a1,s0,-17
+ 41a: 00000097 auipc ra,0x0
+ 41e: f28080e7 jalr -216(ra) # 342 <write>
+}
+ 422: 60e2 ld ra,24(sp)
+ 424: 6442 ld s0,16(sp)
+ 426: 6105 addi sp,sp,32
+ 428: 8082 ret
+
+000000000000042a <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 42a: 7139 addi sp,sp,-64
+ 42c: fc06 sd ra,56(sp)
+ 42e: f822 sd s0,48(sp)
+ 430: f426 sd s1,40(sp)
+ 432: f04a sd s2,32(sp)
+ 434: ec4e sd s3,24(sp)
+ 436: 0080 addi s0,sp,64
+ 438: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 43a: c299 beqz a3,440 <printint+0x16>
+ 43c: 0805c863 bltz a1,4cc <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 440: 2581 sext.w a1,a1
+ neg = 0;
+ 442: 4881 li a7,0
+ }
+
+ i = 0;
+ 444: fc040993 addi s3,s0,-64
+ neg = 0;
+ 448: 86ce mv a3,s3
+ i = 0;
+ 44a: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 44c: 2601 sext.w a2,a2
+ 44e: 00000517 auipc a0,0x0
+ 452: 4b250513 addi a0,a0,1202 # 900 <digits>
+ 456: 883a mv a6,a4
+ 458: 2705 addiw a4,a4,1
+ 45a: 02c5f7bb remuw a5,a1,a2
+ 45e: 1782 slli a5,a5,0x20
+ 460: 9381 srli a5,a5,0x20
+ 462: 97aa add a5,a5,a0
+ 464: 0007c783 lbu a5,0(a5)
+ 468: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 46c: 0005879b sext.w a5,a1
+ 470: 02c5d5bb divuw a1,a1,a2
+ 474: 0685 addi a3,a3,1
+ 476: fec7f0e3 bgeu a5,a2,456 <printint+0x2c>
+ if(neg)
+ 47a: 00088c63 beqz a7,492 <printint+0x68>
+ buf[i++] = '-';
+ 47e: fd070793 addi a5,a4,-48
+ 482: 00878733 add a4,a5,s0
+ 486: 02d00793 li a5,45
+ 48a: fef70823 sb a5,-16(a4)
+ 48e: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 492: 02e05663 blez a4,4be <printint+0x94>
+ 496: fc040913 addi s2,s0,-64
+ 49a: 993a add s2,s2,a4
+ 49c: 19fd addi s3,s3,-1
+ 49e: 99ba add s3,s3,a4
+ 4a0: 377d addiw a4,a4,-1
+ 4a2: 1702 slli a4,a4,0x20
+ 4a4: 9301 srli a4,a4,0x20
+ 4a6: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4aa: fff94583 lbu a1,-1(s2)
+ 4ae: 8526 mv a0,s1
+ 4b0: 00000097 auipc ra,0x0
+ 4b4: f58080e7 jalr -168(ra) # 408 <putc>
+ while(--i >= 0)
+ 4b8: 197d addi s2,s2,-1
+ 4ba: ff3918e3 bne s2,s3,4aa <printint+0x80>
+}
+ 4be: 70e2 ld ra,56(sp)
+ 4c0: 7442 ld s0,48(sp)
+ 4c2: 74a2 ld s1,40(sp)
+ 4c4: 7902 ld s2,32(sp)
+ 4c6: 69e2 ld s3,24(sp)
+ 4c8: 6121 addi sp,sp,64
+ 4ca: 8082 ret
+ x = -xx;
+ 4cc: 40b005bb negw a1,a1
+ neg = 1;
+ 4d0: 4885 li a7,1
+ x = -xx;
+ 4d2: bf8d j 444 <printint+0x1a>
+
+00000000000004d4 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4d4: 7119 addi sp,sp,-128
+ 4d6: fc86 sd ra,120(sp)
+ 4d8: f8a2 sd s0,112(sp)
+ 4da: f4a6 sd s1,104(sp)
+ 4dc: f0ca sd s2,96(sp)
+ 4de: ecce sd s3,88(sp)
+ 4e0: e8d2 sd s4,80(sp)
+ 4e2: e4d6 sd s5,72(sp)
+ 4e4: e0da sd s6,64(sp)
+ 4e6: fc5e sd s7,56(sp)
+ 4e8: f862 sd s8,48(sp)
+ 4ea: f466 sd s9,40(sp)
+ 4ec: f06a sd s10,32(sp)
+ 4ee: ec6e sd s11,24(sp)
+ 4f0: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 4f2: 0005c903 lbu s2,0(a1)
+ 4f6: 18090f63 beqz s2,694 <vprintf+0x1c0>
+ 4fa: 8aaa mv s5,a0
+ 4fc: 8b32 mv s6,a2
+ 4fe: 00158493 addi s1,a1,1
+ state = 0;
+ 502: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 504: 02500a13 li s4,37
+ 508: 4c55 li s8,21
+ 50a: 00000c97 auipc s9,0x0
+ 50e: 39ec8c93 addi s9,s9,926 # 8a8 <malloc+0x110>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 512: 02800d93 li s11,40
+ putc(fd, 'x');
+ 516: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 518: 00000b97 auipc s7,0x0
+ 51c: 3e8b8b93 addi s7,s7,1000 # 900 <digits>
+ 520: a839 j 53e <vprintf+0x6a>
+ putc(fd, c);
+ 522: 85ca mv a1,s2
+ 524: 8556 mv a0,s5
+ 526: 00000097 auipc ra,0x0
+ 52a: ee2080e7 jalr -286(ra) # 408 <putc>
+ 52e: a019 j 534 <vprintf+0x60>
+ } else if(state == '%'){
+ 530: 01498d63 beq s3,s4,54a <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 534: 0485 addi s1,s1,1
+ 536: fff4c903 lbu s2,-1(s1)
+ 53a: 14090d63 beqz s2,694 <vprintf+0x1c0>
+ if(state == 0){
+ 53e: fe0999e3 bnez s3,530 <vprintf+0x5c>
+ if(c == '%'){
+ 542: ff4910e3 bne s2,s4,522 <vprintf+0x4e>
+ state = '%';
+ 546: 89d2 mv s3,s4
+ 548: b7f5 j 534 <vprintf+0x60>
+ if(c == 'd'){
+ 54a: 11490c63 beq s2,s4,662 <vprintf+0x18e>
+ 54e: f9d9079b addiw a5,s2,-99
+ 552: 0ff7f793 zext.b a5,a5
+ 556: 10fc6e63 bltu s8,a5,672 <vprintf+0x19e>
+ 55a: f9d9079b addiw a5,s2,-99
+ 55e: 0ff7f713 zext.b a4,a5
+ 562: 10ec6863 bltu s8,a4,672 <vprintf+0x19e>
+ 566: 00271793 slli a5,a4,0x2
+ 56a: 97e6 add a5,a5,s9
+ 56c: 439c lw a5,0(a5)
+ 56e: 97e6 add a5,a5,s9
+ 570: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 572: 008b0913 addi s2,s6,8
+ 576: 4685 li a3,1
+ 578: 4629 li a2,10
+ 57a: 000b2583 lw a1,0(s6)
+ 57e: 8556 mv a0,s5
+ 580: 00000097 auipc ra,0x0
+ 584: eaa080e7 jalr -342(ra) # 42a <printint>
+ 588: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 58a: 4981 li s3,0
+ 58c: b765 j 534 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 58e: 008b0913 addi s2,s6,8
+ 592: 4681 li a3,0
+ 594: 4629 li a2,10
+ 596: 000b2583 lw a1,0(s6)
+ 59a: 8556 mv a0,s5
+ 59c: 00000097 auipc ra,0x0
+ 5a0: e8e080e7 jalr -370(ra) # 42a <printint>
+ 5a4: 8b4a mv s6,s2
+ state = 0;
+ 5a6: 4981 li s3,0
+ 5a8: b771 j 534 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5aa: 008b0913 addi s2,s6,8
+ 5ae: 4681 li a3,0
+ 5b0: 866a mv a2,s10
+ 5b2: 000b2583 lw a1,0(s6)
+ 5b6: 8556 mv a0,s5
+ 5b8: 00000097 auipc ra,0x0
+ 5bc: e72080e7 jalr -398(ra) # 42a <printint>
+ 5c0: 8b4a mv s6,s2
+ state = 0;
+ 5c2: 4981 li s3,0
+ 5c4: bf85 j 534 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5c6: 008b0793 addi a5,s6,8
+ 5ca: f8f43423 sd a5,-120(s0)
+ 5ce: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5d2: 03000593 li a1,48
+ 5d6: 8556 mv a0,s5
+ 5d8: 00000097 auipc ra,0x0
+ 5dc: e30080e7 jalr -464(ra) # 408 <putc>
+ putc(fd, 'x');
+ 5e0: 07800593 li a1,120
+ 5e4: 8556 mv a0,s5
+ 5e6: 00000097 auipc ra,0x0
+ 5ea: e22080e7 jalr -478(ra) # 408 <putc>
+ 5ee: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5f0: 03c9d793 srli a5,s3,0x3c
+ 5f4: 97de add a5,a5,s7
+ 5f6: 0007c583 lbu a1,0(a5)
+ 5fa: 8556 mv a0,s5
+ 5fc: 00000097 auipc ra,0x0
+ 600: e0c080e7 jalr -500(ra) # 408 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 604: 0992 slli s3,s3,0x4
+ 606: 397d addiw s2,s2,-1
+ 608: fe0914e3 bnez s2,5f0 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 60c: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 610: 4981 li s3,0
+ 612: b70d j 534 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 614: 008b0913 addi s2,s6,8
+ 618: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 61c: 02098163 beqz s3,63e <vprintf+0x16a>
+ while(*s != 0){
+ 620: 0009c583 lbu a1,0(s3)
+ 624: c5ad beqz a1,68e <vprintf+0x1ba>
+ putc(fd, *s);
+ 626: 8556 mv a0,s5
+ 628: 00000097 auipc ra,0x0
+ 62c: de0080e7 jalr -544(ra) # 408 <putc>
+ s++;
+ 630: 0985 addi s3,s3,1
+ while(*s != 0){
+ 632: 0009c583 lbu a1,0(s3)
+ 636: f9e5 bnez a1,626 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 638: 8b4a mv s6,s2
+ state = 0;
+ 63a: 4981 li s3,0
+ 63c: bde5 j 534 <vprintf+0x60>
+ s = "(null)";
+ 63e: 00000997 auipc s3,0x0
+ 642: 26298993 addi s3,s3,610 # 8a0 <malloc+0x108>
+ while(*s != 0){
+ 646: 85ee mv a1,s11
+ 648: bff9 j 626 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 64a: 008b0913 addi s2,s6,8
+ 64e: 000b4583 lbu a1,0(s6)
+ 652: 8556 mv a0,s5
+ 654: 00000097 auipc ra,0x0
+ 658: db4080e7 jalr -588(ra) # 408 <putc>
+ 65c: 8b4a mv s6,s2
+ state = 0;
+ 65e: 4981 li s3,0
+ 660: bdd1 j 534 <vprintf+0x60>
+ putc(fd, c);
+ 662: 85d2 mv a1,s4
+ 664: 8556 mv a0,s5
+ 666: 00000097 auipc ra,0x0
+ 66a: da2080e7 jalr -606(ra) # 408 <putc>
+ state = 0;
+ 66e: 4981 li s3,0
+ 670: b5d1 j 534 <vprintf+0x60>
+ putc(fd, '%');
+ 672: 85d2 mv a1,s4
+ 674: 8556 mv a0,s5
+ 676: 00000097 auipc ra,0x0
+ 67a: d92080e7 jalr -622(ra) # 408 <putc>
+ putc(fd, c);
+ 67e: 85ca mv a1,s2
+ 680: 8556 mv a0,s5
+ 682: 00000097 auipc ra,0x0
+ 686: d86080e7 jalr -634(ra) # 408 <putc>
+ state = 0;
+ 68a: 4981 li s3,0
+ 68c: b565 j 534 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 68e: 8b4a mv s6,s2
+ state = 0;
+ 690: 4981 li s3,0
+ 692: b54d j 534 <vprintf+0x60>
+ }
+ }
+}
+ 694: 70e6 ld ra,120(sp)
+ 696: 7446 ld s0,112(sp)
+ 698: 74a6 ld s1,104(sp)
+ 69a: 7906 ld s2,96(sp)
+ 69c: 69e6 ld s3,88(sp)
+ 69e: 6a46 ld s4,80(sp)
+ 6a0: 6aa6 ld s5,72(sp)
+ 6a2: 6b06 ld s6,64(sp)
+ 6a4: 7be2 ld s7,56(sp)
+ 6a6: 7c42 ld s8,48(sp)
+ 6a8: 7ca2 ld s9,40(sp)
+ 6aa: 7d02 ld s10,32(sp)
+ 6ac: 6de2 ld s11,24(sp)
+ 6ae: 6109 addi sp,sp,128
+ 6b0: 8082 ret
+
+00000000000006b2 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6b2: 715d addi sp,sp,-80
+ 6b4: ec06 sd ra,24(sp)
+ 6b6: e822 sd s0,16(sp)
+ 6b8: 1000 addi s0,sp,32
+ 6ba: e010 sd a2,0(s0)
+ 6bc: e414 sd a3,8(s0)
+ 6be: e818 sd a4,16(s0)
+ 6c0: ec1c sd a5,24(s0)
+ 6c2: 03043023 sd a6,32(s0)
+ 6c6: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6ca: 8622 mv a2,s0
+ 6cc: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6d0: 00000097 auipc ra,0x0
+ 6d4: e04080e7 jalr -508(ra) # 4d4 <vprintf>
+}
+ 6d8: 60e2 ld ra,24(sp)
+ 6da: 6442 ld s0,16(sp)
+ 6dc: 6161 addi sp,sp,80
+ 6de: 8082 ret
+
+00000000000006e0 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6e0: 711d addi sp,sp,-96
+ 6e2: ec06 sd ra,24(sp)
+ 6e4: e822 sd s0,16(sp)
+ 6e6: 1000 addi s0,sp,32
+ 6e8: e40c sd a1,8(s0)
+ 6ea: e810 sd a2,16(s0)
+ 6ec: ec14 sd a3,24(s0)
+ 6ee: f018 sd a4,32(s0)
+ 6f0: f41c sd a5,40(s0)
+ 6f2: 03043823 sd a6,48(s0)
+ 6f6: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6fa: 00840613 addi a2,s0,8
+ 6fe: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 702: 85aa mv a1,a0
+ 704: 4505 li a0,1
+ 706: 00000097 auipc ra,0x0
+ 70a: dce080e7 jalr -562(ra) # 4d4 <vprintf>
+}
+ 70e: 60e2 ld ra,24(sp)
+ 710: 6442 ld s0,16(sp)
+ 712: 6125 addi sp,sp,96
+ 714: 8082 ret
+
+0000000000000716 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 716: 1141 addi sp,sp,-16
+ 718: e422 sd s0,8(sp)
+ 71a: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 71c: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 720: 00000797 auipc a5,0x0
+ 724: 1f87b783 ld a5,504(a5) # 918 <freep>
+ 728: a02d j 752 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 72a: 4618 lw a4,8(a2)
+ 72c: 9f2d addw a4,a4,a1
+ 72e: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 732: 6398 ld a4,0(a5)
+ 734: 6310 ld a2,0(a4)
+ 736: a83d j 774 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 738: ff852703 lw a4,-8(a0)
+ 73c: 9f31 addw a4,a4,a2
+ 73e: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 740: ff053683 ld a3,-16(a0)
+ 744: a091 j 788 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 746: 6398 ld a4,0(a5)
+ 748: 00e7e463 bltu a5,a4,750 <free+0x3a>
+ 74c: 00e6ea63 bltu a3,a4,760 <free+0x4a>
+{
+ 750: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 752: fed7fae3 bgeu a5,a3,746 <free+0x30>
+ 756: 6398 ld a4,0(a5)
+ 758: 00e6e463 bltu a3,a4,760 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 75c: fee7eae3 bltu a5,a4,750 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 760: ff852583 lw a1,-8(a0)
+ 764: 6390 ld a2,0(a5)
+ 766: 02059813 slli a6,a1,0x20
+ 76a: 01c85713 srli a4,a6,0x1c
+ 76e: 9736 add a4,a4,a3
+ 770: fae60de3 beq a2,a4,72a <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 774: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 778: 4790 lw a2,8(a5)
+ 77a: 02061593 slli a1,a2,0x20
+ 77e: 01c5d713 srli a4,a1,0x1c
+ 782: 973e add a4,a4,a5
+ 784: fae68ae3 beq a3,a4,738 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 788: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 78a: 00000717 auipc a4,0x0
+ 78e: 18f73723 sd a5,398(a4) # 918 <freep>
+}
+ 792: 6422 ld s0,8(sp)
+ 794: 0141 addi sp,sp,16
+ 796: 8082 ret
+
+0000000000000798 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 798: 7139 addi sp,sp,-64
+ 79a: fc06 sd ra,56(sp)
+ 79c: f822 sd s0,48(sp)
+ 79e: f426 sd s1,40(sp)
+ 7a0: f04a sd s2,32(sp)
+ 7a2: ec4e sd s3,24(sp)
+ 7a4: e852 sd s4,16(sp)
+ 7a6: e456 sd s5,8(sp)
+ 7a8: e05a sd s6,0(sp)
+ 7aa: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7ac: 02051493 slli s1,a0,0x20
+ 7b0: 9081 srli s1,s1,0x20
+ 7b2: 04bd addi s1,s1,15
+ 7b4: 8091 srli s1,s1,0x4
+ 7b6: 00148a1b addiw s4,s1,1
+ 7ba: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7bc: 00000517 auipc a0,0x0
+ 7c0: 15c53503 ld a0,348(a0) # 918 <freep>
+ 7c4: c515 beqz a0,7f0 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7c6: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7c8: 4798 lw a4,8(a5)
+ 7ca: 04977163 bgeu a4,s1,80c <malloc+0x74>
+ 7ce: 89d2 mv s3,s4
+ 7d0: 000a071b sext.w a4,s4
+ 7d4: 6685 lui a3,0x1
+ 7d6: 00d77363 bgeu a4,a3,7dc <malloc+0x44>
+ 7da: 6985 lui s3,0x1
+ 7dc: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7e0: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7e4: 00000917 auipc s2,0x0
+ 7e8: 13490913 addi s2,s2,308 # 918 <freep>
+ if(p == (char*)-1)
+ 7ec: 5afd li s5,-1
+ 7ee: a8a5 j 866 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 7f0: 00000797 auipc a5,0x0
+ 7f4: 12878793 addi a5,a5,296 # 918 <freep>
+ 7f8: 00000717 auipc a4,0x0
+ 7fc: 12870713 addi a4,a4,296 # 920 <base>
+ 800: e398 sd a4,0(a5)
+ 802: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 804: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 808: 87ba mv a5,a4
+ 80a: b7d1 j 7ce <malloc+0x36>
+ if(p->s.size == nunits)
+ 80c: 02e48c63 beq s1,a4,844 <malloc+0xac>
+ p->s.size -= nunits;
+ 810: 4147073b subw a4,a4,s4
+ 814: c798 sw a4,8(a5)
+ p += p->s.size;
+ 816: 02071693 slli a3,a4,0x20
+ 81a: 01c6d713 srli a4,a3,0x1c
+ 81e: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 820: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 824: 00000717 auipc a4,0x0
+ 828: 0ea73a23 sd a0,244(a4) # 918 <freep>
+ return (void*)(p + 1);
+ 82c: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 830: 70e2 ld ra,56(sp)
+ 832: 7442 ld s0,48(sp)
+ 834: 74a2 ld s1,40(sp)
+ 836: 7902 ld s2,32(sp)
+ 838: 69e2 ld s3,24(sp)
+ 83a: 6a42 ld s4,16(sp)
+ 83c: 6aa2 ld s5,8(sp)
+ 83e: 6b02 ld s6,0(sp)
+ 840: 6121 addi sp,sp,64
+ 842: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 844: 6398 ld a4,0(a5)
+ 846: e118 sd a4,0(a0)
+ 848: bff1 j 824 <malloc+0x8c>
+ hp->s.size = nu;
+ 84a: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 84e: 0541 addi a0,a0,16
+ 850: 00000097 auipc ra,0x0
+ 854: ec6080e7 jalr -314(ra) # 716 <free>
+ return freep;
+ 858: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 85c: d971 beqz a0,830 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 85e: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 860: 4798 lw a4,8(a5)
+ 862: fa9775e3 bgeu a4,s1,80c <malloc+0x74>
+ if(p == freep)
+ 866: 00093703 ld a4,0(s2)
+ 86a: 853e mv a0,a5
+ 86c: fef719e3 bne a4,a5,85e <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 870: 854e mv a0,s3
+ 872: 00000097 auipc ra,0x0
+ 876: b30080e7 jalr -1232(ra) # 3a2 <sbrk>
+ if(p == (char*)-1)
+ 87a: fd5518e3 bne a0,s5,84a <malloc+0xb2>
+ return 0;
+ 87e: 4501 li a0,0
+ 880: bf45 j 830 <malloc+0x98>
diff --git a/xv6-user/kill.c b/xv6-user/kill.c
new file mode 100644
index 0000000000000000000000000000000000000000..e5752444f3441baea1bac630874f641f8ad66f28
--- /dev/null
+++ b/xv6-user/kill.c
@@ -0,0 +1,17 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char **argv)
+{
+ int i;
+
+ if(argc < 2){
+ fprintf(2, "usage: kill pid...\n");
+ exit(1);
+ }
+ for(i=1; i<argc; i++)
+ kill(atoi(argv[i]));
+ exit(0);
+}
diff --git a/xv6-user/kill.d b/xv6-user/kill.d
new file mode 100644
index 0000000000000000000000000000000000000000..2800e5dab41306b06d115d987c802f9049f0737c
--- /dev/null
+++ b/xv6-user/kill.d
@@ -0,0 +1,2 @@
+xv6-user/kill.o: xv6-user/kill.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/kill.o b/xv6-user/kill.o
new file mode 100644
index 0000000000000000000000000000000000000000..f8a45372080b3a159b8b57510b34bd0bda31cc78
Binary files /dev/null and b/xv6-user/kill.o differ
diff --git a/xv6-user/kill.sym b/xv6-user/kill.sym
new file mode 100644
index 0000000000000000000000000000000000000000..de36443da912bb6607b7a6abe19933adfedd12b5
--- /dev/null
+++ b/xv6-user/kill.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+0000000000000888 .rodata
+0000000000000918 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 kill.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000408 putc
+000000000000042a printint
+0000000000000900 digits
+0000000000000000 umalloc.c
+0000000000000918 freep
+0000000000000920 base
+0000000000000064 strcpy
+00000000000006e0 printf
+0000000000001111 __global_pointer$
+00000000000003c2 dev
+000000000000026a memmove
+00000000000003e6 trace
+000000000000014a gets
+0000000000000911 __SDATA_BEGIN__
+0000000000000398 getpid
+00000000000002fc memcpy
+0000000000000798 malloc
+00000000000003dc remove
+00000000000003aa sleep
+00000000000003ee sysinfo
+00000000000003cc readdir
+000000000000032e pipe
+00000000000003f6 rename
+0000000000000342 write
+0000000000000372 fstat
+00000000000006b2 fprintf
+0000000000000356 kill
+0000000000000080 strcat
+00000000000004d4 vprintf
+0000000000000386 chdir
+000000000000035e exec
+0000000000000326 wait
+0000000000000338 read
+00000000000002c2 memcmp
+0000000000000314 fork
+0000000000000930 __BSS_END__
+00000000000003a2 sbrk
+00000000000003ba test_proc
+00000000000003b2 uptime
+0000000000000911 __bss_start
+0000000000000104 memset
+0000000000000000 main
+00000000000000ae strcmp
+00000000000003fe shutdown
+0000000000000390 dup
+00000000000003d4 getcwd
+0000000000000911 __DATA_BEGIN__
+00000000000001c4 stat
+0000000000000911 _edata
+0000000000000930 _end
+000000000000031c exit
+000000000000020a atoi
+00000000000000da strlen
+0000000000000368 open
+0000000000000126 strchr
+000000000000037c mkdir
+000000000000034c close
+0000000000000716 free
diff --git a/xv6-user/ln.c b/xv6-user/ln.c
new file mode 100644
index 0000000000000000000000000000000000000000..6173775857666a1d2927d98aac528a24f63e4be2
--- /dev/null
+++ b/xv6-user/ln.c
@@ -0,0 +1,15 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ if(argc != 3){
+ fprintf(2, "Usage: ln old new\n");
+ exit(1);
+ }
+ if(link(argv[1], argv[2]) < 0)
+ fprintf(2, "link %s %s: failed\n", argv[1], argv[2]);
+ exit(0);
+}
diff --git a/xv6-user/ls.asm b/xv6-user/ls.asm
new file mode 100644
index 0000000000000000000000000000000000000000..cd690cc56ccf132f7121c4f302ac57388fb5deb3
--- /dev/null
+++ b/xv6-user/ls.asm
@@ -0,0 +1,1628 @@
+
+xv6-user/_ls: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <fmtname>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+char*
+fmtname(char *name)
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: 1800 addi s0,sp,48
+ e: 892a mv s2,a0
+ static char buf[STAT_MAX_NAME+1];
+ int len = strlen(name);
+ 10: 00000097 auipc ra,0x0
+ 14: 24c080e7 jalr 588(ra) # 25c <strlen>
+ 18: 0005049b sext.w s1,a0
+
+ // Return blank-padded name.
+ if(len >= STAT_MAX_NAME)
+ 1c: 47fd li a5,31
+ 1e: 0097da63 bge a5,s1,32 <fmtname+0x32>
+ return name;
+ memmove(buf, name, len);
+ memset(buf + len, ' ', STAT_MAX_NAME - len);
+ buf[STAT_MAX_NAME] = '\0';
+ return buf;
+}
+ 22: 854a mv a0,s2
+ 24: 70a2 ld ra,40(sp)
+ 26: 7402 ld s0,32(sp)
+ 28: 64e2 ld s1,24(sp)
+ 2a: 6942 ld s2,16(sp)
+ 2c: 69a2 ld s3,8(sp)
+ 2e: 6145 addi sp,sp,48
+ 30: 8082 ret
+ memmove(buf, name, len);
+ 32: 00001997 auipc s3,0x1
+ 36: ab698993 addi s3,s3,-1354 # ae8 <buf.0>
+ 3a: 8626 mv a2,s1
+ 3c: 85ca mv a1,s2
+ 3e: 854e mv a0,s3
+ 40: 00000097 auipc ra,0x0
+ 44: 3ac080e7 jalr 940(ra) # 3ec <memmove>
+ memset(buf + len, ' ', STAT_MAX_NAME - len);
+ 48: 02000613 li a2,32
+ 4c: 9e05 subw a2,a2,s1
+ 4e: 02000593 li a1,32
+ 52: 00998533 add a0,s3,s1
+ 56: 00000097 auipc ra,0x0
+ 5a: 230080e7 jalr 560(ra) # 286 <memset>
+ buf[STAT_MAX_NAME] = '\0';
+ 5e: 02098023 sb zero,32(s3)
+ return buf;
+ 62: 894e mv s2,s3
+ 64: bf7d j 22 <fmtname+0x22>
+
+0000000000000066 <ls>:
+
+void
+ls(char *path)
+{
+ 66: 7119 addi sp,sp,-128
+ 68: fc86 sd ra,120(sp)
+ 6a: f8a2 sd s0,112(sp)
+ 6c: f4a6 sd s1,104(sp)
+ 6e: f0ca sd s2,96(sp)
+ 70: ecce sd s3,88(sp)
+ 72: e8d2 sd s4,80(sp)
+ 74: 0100 addi s0,sp,128
+ 76: 892a mv s2,a0
+ int fd;
+ struct stat st;
+ char *types[] = {
+ 78: f8043023 sd zero,-128(s0)
+ 7c: 00001797 auipc a5,0x1
+ 80: 98c78793 addi a5,a5,-1652 # a08 <malloc+0xee>
+ 84: f8f43423 sd a5,-120(s0)
+ 88: 00001797 auipc a5,0x1
+ 8c: 98878793 addi a5,a5,-1656 # a10 <malloc+0xf6>
+ 90: f8f43823 sd a5,-112(s0)
+ [T_DIR] "DIR ",
+ [T_FILE] "FILE",
+ };
+
+ if((fd = open(path, 0)) < 0){
+ 94: 4581 li a1,0
+ 96: 00000097 auipc ra,0x0
+ 9a: 454080e7 jalr 1108(ra) # 4ea <open>
+ 9e: 02054863 bltz a0,ce <ls+0x68>
+ a2: 84aa mv s1,a0
+ fprintf(2, "ls: cannot open %s\n", path);
+ return;
+ }
+
+ if(fstat(fd, &st) < 0){
+ a4: f9840593 addi a1,s0,-104
+ a8: 00000097 auipc ra,0x0
+ ac: 44c080e7 jalr 1100(ra) # 4f4 <fstat>
+ b0: 02054a63 bltz a0,e4 <ls+0x7e>
+ fprintf(2, "ls: cannot stat %s\n", path);
+ close(fd);
+ return;
+ }
+
+ if (st.type == T_DIR){
+ b4: fc041703 lh a4,-64(s0)
+ b8: 4785 li a5,1
+ ba: 08f71f63 bne a4,a5,158 <ls+0xf2>
+ while(readdir(fd, &st) == 1){
+ be: f9840913 addi s2,s0,-104
+ c2: 4985 li s3,1
+ printf("%s %s\t%d\n", fmtname(st.name), types[st.type], st.size);
+ c4: 00001a17 auipc s4,0x1
+ c8: 984a0a13 addi s4,s4,-1660 # a48 <malloc+0x12e>
+ cc: a08d j 12e <ls+0xc8>
+ fprintf(2, "ls: cannot open %s\n", path);
+ ce: 864a mv a2,s2
+ d0: 00001597 auipc a1,0x1
+ d4: 94858593 addi a1,a1,-1720 # a18 <malloc+0xfe>
+ d8: 4509 li a0,2
+ da: 00000097 auipc ra,0x0
+ de: 75a080e7 jalr 1882(ra) # 834 <fprintf>
+ return;
+ e2: a09d j 148 <ls+0xe2>
+ fprintf(2, "ls: cannot stat %s\n", path);
+ e4: 864a mv a2,s2
+ e6: 00001597 auipc a1,0x1
+ ea: 94a58593 addi a1,a1,-1718 # a30 <malloc+0x116>
+ ee: 4509 li a0,2
+ f0: 00000097 auipc ra,0x0
+ f4: 744080e7 jalr 1860(ra) # 834 <fprintf>
+ close(fd);
+ f8: 8526 mv a0,s1
+ fa: 00000097 auipc ra,0x0
+ fe: 3d4080e7 jalr 980(ra) # 4ce <close>
+ return;
+ 102: a099 j 148 <ls+0xe2>
+ printf("%s %s\t%d\n", fmtname(st.name), types[st.type], st.size);
+ 104: 854a mv a0,s2
+ 106: 00000097 auipc ra,0x0
+ 10a: efa080e7 jalr -262(ra) # 0 <fmtname>
+ 10e: 85aa mv a1,a0
+ 110: fc041783 lh a5,-64(s0)
+ 114: 078e slli a5,a5,0x3
+ 116: fd078793 addi a5,a5,-48
+ 11a: 97a2 add a5,a5,s0
+ 11c: fc843683 ld a3,-56(s0)
+ 120: fb07b603 ld a2,-80(a5)
+ 124: 8552 mv a0,s4
+ 126: 00000097 auipc ra,0x0
+ 12a: 73c080e7 jalr 1852(ra) # 862 <printf>
+ while(readdir(fd, &st) == 1){
+ 12e: 85ca mv a1,s2
+ 130: 8526 mv a0,s1
+ 132: 00000097 auipc ra,0x0
+ 136: 41c080e7 jalr 1052(ra) # 54e <readdir>
+ 13a: fd3505e3 beq a0,s3,104 <ls+0x9e>
+ }
+ } else {
+ printf("%s %s\t%l\n", fmtname(st.name), types[st.type], st.size);
+ }
+ close(fd);
+ 13e: 8526 mv a0,s1
+ 140: 00000097 auipc ra,0x0
+ 144: 38e080e7 jalr 910(ra) # 4ce <close>
+}
+ 148: 70e6 ld ra,120(sp)
+ 14a: 7446 ld s0,112(sp)
+ 14c: 74a6 ld s1,104(sp)
+ 14e: 7906 ld s2,96(sp)
+ 150: 69e6 ld s3,88(sp)
+ 152: 6a46 ld s4,80(sp)
+ 154: 6109 addi sp,sp,128
+ 156: 8082 ret
+ printf("%s %s\t%l\n", fmtname(st.name), types[st.type], st.size);
+ 158: f9840513 addi a0,s0,-104
+ 15c: 00000097 auipc ra,0x0
+ 160: ea4080e7 jalr -348(ra) # 0 <fmtname>
+ 164: 85aa mv a1,a0
+ 166: fc041783 lh a5,-64(s0)
+ 16a: 078e slli a5,a5,0x3
+ 16c: fd078793 addi a5,a5,-48
+ 170: 97a2 add a5,a5,s0
+ 172: fc843683 ld a3,-56(s0)
+ 176: fb07b603 ld a2,-80(a5)
+ 17a: 00001517 auipc a0,0x1
+ 17e: 8de50513 addi a0,a0,-1826 # a58 <malloc+0x13e>
+ 182: 00000097 auipc ra,0x0
+ 186: 6e0080e7 jalr 1760(ra) # 862 <printf>
+ 18a: bf55 j 13e <ls+0xd8>
+
+000000000000018c <main>:
+
+int
+main(int argc, char *argv[])
+{
+ 18c: 1101 addi sp,sp,-32
+ 18e: ec06 sd ra,24(sp)
+ 190: e822 sd s0,16(sp)
+ 192: e426 sd s1,8(sp)
+ 194: e04a sd s2,0(sp)
+ 196: 1000 addi s0,sp,32
+ int i;
+
+ if(argc < 2){
+ 198: 4785 li a5,1
+ 19a: 02a7d963 bge a5,a0,1cc <main+0x40>
+ 19e: 00858493 addi s1,a1,8
+ 1a2: ffe5091b addiw s2,a0,-2
+ 1a6: 02091793 slli a5,s2,0x20
+ 1aa: 01d7d913 srli s2,a5,0x1d
+ 1ae: 05c1 addi a1,a1,16
+ 1b0: 992e add s2,s2,a1
+ ls(".");
+ exit(0);
+ }
+ for(i=1; i<argc; i++)
+ ls(argv[i]);
+ 1b2: 6088 ld a0,0(s1)
+ 1b4: 00000097 auipc ra,0x0
+ 1b8: eb2080e7 jalr -334(ra) # 66 <ls>
+ for(i=1; i<argc; i++)
+ 1bc: 04a1 addi s1,s1,8
+ 1be: ff249ae3 bne s1,s2,1b2 <main+0x26>
+ exit(0);
+ 1c2: 4501 li a0,0
+ 1c4: 00000097 auipc ra,0x0
+ 1c8: 2da080e7 jalr 730(ra) # 49e <exit>
+ ls(".");
+ 1cc: 00001517 auipc a0,0x1
+ 1d0: 89c50513 addi a0,a0,-1892 # a68 <malloc+0x14e>
+ 1d4: 00000097 auipc ra,0x0
+ 1d8: e92080e7 jalr -366(ra) # 66 <ls>
+ exit(0);
+ 1dc: 4501 li a0,0
+ 1de: 00000097 auipc ra,0x0
+ 1e2: 2c0080e7 jalr 704(ra) # 49e <exit>
+
+00000000000001e6 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 1e6: 1141 addi sp,sp,-16
+ 1e8: e422 sd s0,8(sp)
+ 1ea: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 1ec: 87aa mv a5,a0
+ 1ee: 0585 addi a1,a1,1
+ 1f0: 0785 addi a5,a5,1
+ 1f2: fff5c703 lbu a4,-1(a1)
+ 1f6: fee78fa3 sb a4,-1(a5)
+ 1fa: fb75 bnez a4,1ee <strcpy+0x8>
+ ;
+ return os;
+}
+ 1fc: 6422 ld s0,8(sp)
+ 1fe: 0141 addi sp,sp,16
+ 200: 8082 ret
+
+0000000000000202 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 202: 1141 addi sp,sp,-16
+ 204: e422 sd s0,8(sp)
+ 206: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 208: 00054783 lbu a5,0(a0)
+ 20c: c385 beqz a5,22c <strcat+0x2a>
+ 20e: 87aa mv a5,a0
+ s++;
+ 210: 0785 addi a5,a5,1
+ while(*s)
+ 212: 0007c703 lbu a4,0(a5)
+ 216: ff6d bnez a4,210 <strcat+0xe>
+ while((*s++ = *t++))
+ 218: 0585 addi a1,a1,1
+ 21a: 0785 addi a5,a5,1
+ 21c: fff5c703 lbu a4,-1(a1)
+ 220: fee78fa3 sb a4,-1(a5)
+ 224: fb75 bnez a4,218 <strcat+0x16>
+ ;
+ return os;
+}
+ 226: 6422 ld s0,8(sp)
+ 228: 0141 addi sp,sp,16
+ 22a: 8082 ret
+ while(*s)
+ 22c: 87aa mv a5,a0
+ 22e: b7ed j 218 <strcat+0x16>
+
+0000000000000230 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 230: 1141 addi sp,sp,-16
+ 232: e422 sd s0,8(sp)
+ 234: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 236: 00054783 lbu a5,0(a0)
+ 23a: cb91 beqz a5,24e <strcmp+0x1e>
+ 23c: 0005c703 lbu a4,0(a1)
+ 240: 00f71763 bne a4,a5,24e <strcmp+0x1e>
+ p++, q++;
+ 244: 0505 addi a0,a0,1
+ 246: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 248: 00054783 lbu a5,0(a0)
+ 24c: fbe5 bnez a5,23c <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 24e: 0005c503 lbu a0,0(a1)
+}
+ 252: 40a7853b subw a0,a5,a0
+ 256: 6422 ld s0,8(sp)
+ 258: 0141 addi sp,sp,16
+ 25a: 8082 ret
+
+000000000000025c <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 25c: 1141 addi sp,sp,-16
+ 25e: e422 sd s0,8(sp)
+ 260: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 262: 00054783 lbu a5,0(a0)
+ 266: cf91 beqz a5,282 <strlen+0x26>
+ 268: 0505 addi a0,a0,1
+ 26a: 87aa mv a5,a0
+ 26c: 4685 li a3,1
+ 26e: 9e89 subw a3,a3,a0
+ 270: 00f6853b addw a0,a3,a5
+ 274: 0785 addi a5,a5,1
+ 276: fff7c703 lbu a4,-1(a5)
+ 27a: fb7d bnez a4,270 <strlen+0x14>
+ ;
+ return n;
+}
+ 27c: 6422 ld s0,8(sp)
+ 27e: 0141 addi sp,sp,16
+ 280: 8082 ret
+ for(n = 0; s[n]; n++)
+ 282: 4501 li a0,0
+ 284: bfe5 j 27c <strlen+0x20>
+
+0000000000000286 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 286: 1141 addi sp,sp,-16
+ 288: e422 sd s0,8(sp)
+ 28a: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 28c: ca19 beqz a2,2a2 <memset+0x1c>
+ 28e: 87aa mv a5,a0
+ 290: 1602 slli a2,a2,0x20
+ 292: 9201 srli a2,a2,0x20
+ 294: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 298: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 29c: 0785 addi a5,a5,1
+ 29e: fee79de3 bne a5,a4,298 <memset+0x12>
+ }
+ return dst;
+}
+ 2a2: 6422 ld s0,8(sp)
+ 2a4: 0141 addi sp,sp,16
+ 2a6: 8082 ret
+
+00000000000002a8 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 2a8: 1141 addi sp,sp,-16
+ 2aa: e422 sd s0,8(sp)
+ 2ac: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 2ae: 00054783 lbu a5,0(a0)
+ 2b2: cb99 beqz a5,2c8 <strchr+0x20>
+ if(*s == c)
+ 2b4: 00f58763 beq a1,a5,2c2 <strchr+0x1a>
+ for(; *s; s++)
+ 2b8: 0505 addi a0,a0,1
+ 2ba: 00054783 lbu a5,0(a0)
+ 2be: fbfd bnez a5,2b4 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 2c0: 4501 li a0,0
+}
+ 2c2: 6422 ld s0,8(sp)
+ 2c4: 0141 addi sp,sp,16
+ 2c6: 8082 ret
+ return 0;
+ 2c8: 4501 li a0,0
+ 2ca: bfe5 j 2c2 <strchr+0x1a>
+
+00000000000002cc <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 2cc: 711d addi sp,sp,-96
+ 2ce: ec86 sd ra,88(sp)
+ 2d0: e8a2 sd s0,80(sp)
+ 2d2: e4a6 sd s1,72(sp)
+ 2d4: e0ca sd s2,64(sp)
+ 2d6: fc4e sd s3,56(sp)
+ 2d8: f852 sd s4,48(sp)
+ 2da: f456 sd s5,40(sp)
+ 2dc: f05a sd s6,32(sp)
+ 2de: ec5e sd s7,24(sp)
+ 2e0: e862 sd s8,16(sp)
+ 2e2: 1080 addi s0,sp,96
+ 2e4: 8baa mv s7,a0
+ 2e6: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 2e8: 892a mv s2,a0
+ 2ea: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 2ec: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 2f0: 4b29 li s6,10
+ 2f2: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 2f4: 89a6 mv s3,s1
+ 2f6: 2485 addiw s1,s1,1
+ 2f8: 0344d763 bge s1,s4,326 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 2fc: 4605 li a2,1
+ 2fe: 85d6 mv a1,s5
+ 300: 4501 li a0,0
+ 302: 00000097 auipc ra,0x0
+ 306: 1b8080e7 jalr 440(ra) # 4ba <read>
+ if(cc < 1)
+ 30a: 00a05e63 blez a0,326 <gets+0x5a>
+ buf[i++] = c;
+ 30e: faf44783 lbu a5,-81(s0)
+ 312: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 316: 01678763 beq a5,s6,324 <gets+0x58>
+ 31a: 0905 addi s2,s2,1
+ 31c: fd879ce3 bne a5,s8,2f4 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 320: 89a6 mv s3,s1
+ 322: a011 j 326 <gets+0x5a>
+ 324: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 326: 99de add s3,s3,s7
+ 328: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 32c: 855e mv a0,s7
+ 32e: 60e6 ld ra,88(sp)
+ 330: 6446 ld s0,80(sp)
+ 332: 64a6 ld s1,72(sp)
+ 334: 6906 ld s2,64(sp)
+ 336: 79e2 ld s3,56(sp)
+ 338: 7a42 ld s4,48(sp)
+ 33a: 7aa2 ld s5,40(sp)
+ 33c: 7b02 ld s6,32(sp)
+ 33e: 6be2 ld s7,24(sp)
+ 340: 6c42 ld s8,16(sp)
+ 342: 6125 addi sp,sp,96
+ 344: 8082 ret
+
+0000000000000346 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 346: 1101 addi sp,sp,-32
+ 348: ec06 sd ra,24(sp)
+ 34a: e822 sd s0,16(sp)
+ 34c: e426 sd s1,8(sp)
+ 34e: e04a sd s2,0(sp)
+ 350: 1000 addi s0,sp,32
+ 352: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 354: 4581 li a1,0
+ 356: 00000097 auipc ra,0x0
+ 35a: 194080e7 jalr 404(ra) # 4ea <open>
+ if(fd < 0)
+ 35e: 02054563 bltz a0,388 <stat+0x42>
+ 362: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 364: 85ca mv a1,s2
+ 366: 00000097 auipc ra,0x0
+ 36a: 18e080e7 jalr 398(ra) # 4f4 <fstat>
+ 36e: 892a mv s2,a0
+ close(fd);
+ 370: 8526 mv a0,s1
+ 372: 00000097 auipc ra,0x0
+ 376: 15c080e7 jalr 348(ra) # 4ce <close>
+ return r;
+}
+ 37a: 854a mv a0,s2
+ 37c: 60e2 ld ra,24(sp)
+ 37e: 6442 ld s0,16(sp)
+ 380: 64a2 ld s1,8(sp)
+ 382: 6902 ld s2,0(sp)
+ 384: 6105 addi sp,sp,32
+ 386: 8082 ret
+ return -1;
+ 388: 597d li s2,-1
+ 38a: bfc5 j 37a <stat+0x34>
+
+000000000000038c <atoi>:
+
+int
+atoi(const char *s)
+{
+ 38c: 1141 addi sp,sp,-16
+ 38e: e422 sd s0,8(sp)
+ 390: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 392: 00054703 lbu a4,0(a0)
+ 396: 02d00793 li a5,45
+ int neg = 1;
+ 39a: 4585 li a1,1
+ if (*s == '-') {
+ 39c: 04f70363 beq a4,a5,3e2 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 3a0: 00054703 lbu a4,0(a0)
+ 3a4: fd07079b addiw a5,a4,-48
+ 3a8: 0ff7f793 zext.b a5,a5
+ 3ac: 46a5 li a3,9
+ 3ae: 02f6ed63 bltu a3,a5,3e8 <atoi+0x5c>
+ n = 0;
+ 3b2: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 3b4: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 3b6: 0505 addi a0,a0,1
+ 3b8: 0026979b slliw a5,a3,0x2
+ 3bc: 9fb5 addw a5,a5,a3
+ 3be: 0017979b slliw a5,a5,0x1
+ 3c2: 9fb9 addw a5,a5,a4
+ 3c4: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 3c8: 00054703 lbu a4,0(a0)
+ 3cc: fd07079b addiw a5,a4,-48
+ 3d0: 0ff7f793 zext.b a5,a5
+ 3d4: fef671e3 bgeu a2,a5,3b6 <atoi+0x2a>
+ return n * neg;
+}
+ 3d8: 02d5853b mulw a0,a1,a3
+ 3dc: 6422 ld s0,8(sp)
+ 3de: 0141 addi sp,sp,16
+ 3e0: 8082 ret
+ s++;
+ 3e2: 0505 addi a0,a0,1
+ neg = -1;
+ 3e4: 55fd li a1,-1
+ 3e6: bf6d j 3a0 <atoi+0x14>
+ n = 0;
+ 3e8: 4681 li a3,0
+ 3ea: b7fd j 3d8 <atoi+0x4c>
+
+00000000000003ec <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 3ec: 1141 addi sp,sp,-16
+ 3ee: e422 sd s0,8(sp)
+ 3f0: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 3f2: 02b57463 bgeu a0,a1,41a <memmove+0x2e>
+ while(n-- > 0)
+ 3f6: 00c05f63 blez a2,414 <memmove+0x28>
+ 3fa: 1602 slli a2,a2,0x20
+ 3fc: 9201 srli a2,a2,0x20
+ 3fe: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 402: 872a mv a4,a0
+ *dst++ = *src++;
+ 404: 0585 addi a1,a1,1
+ 406: 0705 addi a4,a4,1
+ 408: fff5c683 lbu a3,-1(a1)
+ 40c: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 410: fee79ae3 bne a5,a4,404 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 414: 6422 ld s0,8(sp)
+ 416: 0141 addi sp,sp,16
+ 418: 8082 ret
+ dst += n;
+ 41a: 00c50733 add a4,a0,a2
+ src += n;
+ 41e: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 420: fec05ae3 blez a2,414 <memmove+0x28>
+ 424: fff6079b addiw a5,a2,-1
+ 428: 1782 slli a5,a5,0x20
+ 42a: 9381 srli a5,a5,0x20
+ 42c: fff7c793 not a5,a5
+ 430: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 432: 15fd addi a1,a1,-1
+ 434: 177d addi a4,a4,-1
+ 436: 0005c683 lbu a3,0(a1)
+ 43a: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 43e: fee79ae3 bne a5,a4,432 <memmove+0x46>
+ 442: bfc9 j 414 <memmove+0x28>
+
+0000000000000444 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 444: 1141 addi sp,sp,-16
+ 446: e422 sd s0,8(sp)
+ 448: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 44a: ca05 beqz a2,47a <memcmp+0x36>
+ 44c: fff6069b addiw a3,a2,-1
+ 450: 1682 slli a3,a3,0x20
+ 452: 9281 srli a3,a3,0x20
+ 454: 0685 addi a3,a3,1
+ 456: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 458: 00054783 lbu a5,0(a0)
+ 45c: 0005c703 lbu a4,0(a1)
+ 460: 00e79863 bne a5,a4,470 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 464: 0505 addi a0,a0,1
+ p2++;
+ 466: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 468: fed518e3 bne a0,a3,458 <memcmp+0x14>
+ }
+ return 0;
+ 46c: 4501 li a0,0
+ 46e: a019 j 474 <memcmp+0x30>
+ return *p1 - *p2;
+ 470: 40e7853b subw a0,a5,a4
+}
+ 474: 6422 ld s0,8(sp)
+ 476: 0141 addi sp,sp,16
+ 478: 8082 ret
+ return 0;
+ 47a: 4501 li a0,0
+ 47c: bfe5 j 474 <memcmp+0x30>
+
+000000000000047e <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 47e: 1141 addi sp,sp,-16
+ 480: e406 sd ra,8(sp)
+ 482: e022 sd s0,0(sp)
+ 484: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 486: 00000097 auipc ra,0x0
+ 48a: f66080e7 jalr -154(ra) # 3ec <memmove>
+}
+ 48e: 60a2 ld ra,8(sp)
+ 490: 6402 ld s0,0(sp)
+ 492: 0141 addi sp,sp,16
+ 494: 8082 ret
+
+0000000000000496 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 496: 4885 li a7,1
+ ecall
+ 498: 00000073 ecall
+ ret
+ 49c: 8082 ret
+
+000000000000049e <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 49e: 05d00893 li a7,93
+ ecall
+ 4a2: 00000073 ecall
+ ret
+ 4a6: 8082 ret
+
+00000000000004a8 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 4a8: 488d li a7,3
+ ecall
+ 4aa: 00000073 ecall
+ ret
+ 4ae: 8082 ret
+
+00000000000004b0 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 4b0: 03b00893 li a7,59
+ ecall
+ 4b4: 00000073 ecall
+ ret
+ 4b8: 8082 ret
+
+00000000000004ba <read>:
+.global read
+read:
+ li a7, SYS_read
+ 4ba: 03f00893 li a7,63
+ ecall
+ 4be: 00000073 ecall
+ ret
+ 4c2: 8082 ret
+
+00000000000004c4 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 4c4: 04000893 li a7,64
+ ecall
+ 4c8: 00000073 ecall
+ ret
+ 4cc: 8082 ret
+
+00000000000004ce <close>:
+.global close
+close:
+ li a7, SYS_close
+ 4ce: 03900893 li a7,57
+ ecall
+ 4d2: 00000073 ecall
+ ret
+ 4d6: 8082 ret
+
+00000000000004d8 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 4d8: 4899 li a7,6
+ ecall
+ 4da: 00000073 ecall
+ ret
+ 4de: 8082 ret
+
+00000000000004e0 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 4e0: 0dd00893 li a7,221
+ ecall
+ 4e4: 00000073 ecall
+ ret
+ 4e8: 8082 ret
+
+00000000000004ea <open>:
+.global open
+open:
+ li a7, SYS_open
+ 4ea: 03800893 li a7,56
+ ecall
+ 4ee: 00000073 ecall
+ ret
+ 4f2: 8082 ret
+
+00000000000004f4 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 4f4: 05000893 li a7,80
+ ecall
+ 4f8: 00000073 ecall
+ ret
+ 4fc: 8082 ret
+
+00000000000004fe <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 4fe: 02200893 li a7,34
+ ecall
+ 502: 00000073 ecall
+ ret
+ 506: 8082 ret
+
+0000000000000508 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 508: 03100893 li a7,49
+ ecall
+ 50c: 00000073 ecall
+ ret
+ 510: 8082 ret
+
+0000000000000512 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 512: 48dd li a7,23
+ ecall
+ 514: 00000073 ecall
+ ret
+ 518: 8082 ret
+
+000000000000051a <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 51a: 0ac00893 li a7,172
+ ecall
+ 51e: 00000073 ecall
+ ret
+ 522: 8082 ret
+
+0000000000000524 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 524: 48b1 li a7,12
+ ecall
+ 526: 00000073 ecall
+ ret
+ 52a: 8082 ret
+
+000000000000052c <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 52c: 48b5 li a7,13
+ ecall
+ 52e: 00000073 ecall
+ ret
+ 532: 8082 ret
+
+0000000000000534 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 534: 48b9 li a7,14
+ ecall
+ 536: 00000073 ecall
+ ret
+ 53a: 8082 ret
+
+000000000000053c <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 53c: 48d9 li a7,22
+ ecall
+ 53e: 00000073 ecall
+ ret
+ 542: 8082 ret
+
+0000000000000544 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 544: 03200893 li a7,50
+ ecall
+ 548: 00000073 ecall
+ ret
+ 54c: 8082 ret
+
+000000000000054e <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 54e: 48ed li a7,27
+ ecall
+ 550: 00000073 ecall
+ ret
+ 554: 8082 ret
+
+0000000000000556 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 556: 48c5 li a7,17
+ ecall
+ 558: 00000073 ecall
+ ret
+ 55c: 8082 ret
+
+000000000000055e <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 55e: 07500893 li a7,117
+ ecall
+ 562: 00000073 ecall
+ ret
+ 566: 8082 ret
+
+0000000000000568 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 568: 48c9 li a7,18
+ ecall
+ 56a: 00000073 ecall
+ ret
+ 56e: 8082 ret
+
+0000000000000570 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 570: 48cd li a7,19
+ ecall
+ 572: 00000073 ecall
+ ret
+ 576: 8082 ret
+
+0000000000000578 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 578: 48e9 li a7,26
+ ecall
+ 57a: 00000073 ecall
+ ret
+ 57e: 8082 ret
+
+0000000000000580 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 580: 0d200893 li a7,210
+ ecall
+ 584: 00000073 ecall
+ ret
+ 588: 8082 ret
+
+000000000000058a <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 58a: 1101 addi sp,sp,-32
+ 58c: ec06 sd ra,24(sp)
+ 58e: e822 sd s0,16(sp)
+ 590: 1000 addi s0,sp,32
+ 592: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 596: 4605 li a2,1
+ 598: fef40593 addi a1,s0,-17
+ 59c: 00000097 auipc ra,0x0
+ 5a0: f28080e7 jalr -216(ra) # 4c4 <write>
+}
+ 5a4: 60e2 ld ra,24(sp)
+ 5a6: 6442 ld s0,16(sp)
+ 5a8: 6105 addi sp,sp,32
+ 5aa: 8082 ret
+
+00000000000005ac <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 5ac: 7139 addi sp,sp,-64
+ 5ae: fc06 sd ra,56(sp)
+ 5b0: f822 sd s0,48(sp)
+ 5b2: f426 sd s1,40(sp)
+ 5b4: f04a sd s2,32(sp)
+ 5b6: ec4e sd s3,24(sp)
+ 5b8: 0080 addi s0,sp,64
+ 5ba: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 5bc: c299 beqz a3,5c2 <printint+0x16>
+ 5be: 0805c863 bltz a1,64e <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 5c2: 2581 sext.w a1,a1
+ neg = 0;
+ 5c4: 4881 li a7,0
+ }
+
+ i = 0;
+ 5c6: fc040993 addi s3,s0,-64
+ neg = 0;
+ 5ca: 86ce mv a3,s3
+ i = 0;
+ 5cc: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 5ce: 2601 sext.w a2,a2
+ 5d0: 00000517 auipc a0,0x0
+ 5d4: 50050513 addi a0,a0,1280 # ad0 <digits>
+ 5d8: 883a mv a6,a4
+ 5da: 2705 addiw a4,a4,1
+ 5dc: 02c5f7bb remuw a5,a1,a2
+ 5e0: 1782 slli a5,a5,0x20
+ 5e2: 9381 srli a5,a5,0x20
+ 5e4: 97aa add a5,a5,a0
+ 5e6: 0007c783 lbu a5,0(a5)
+ 5ea: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 5ee: 0005879b sext.w a5,a1
+ 5f2: 02c5d5bb divuw a1,a1,a2
+ 5f6: 0685 addi a3,a3,1
+ 5f8: fec7f0e3 bgeu a5,a2,5d8 <printint+0x2c>
+ if(neg)
+ 5fc: 00088c63 beqz a7,614 <printint+0x68>
+ buf[i++] = '-';
+ 600: fd070793 addi a5,a4,-48
+ 604: 00878733 add a4,a5,s0
+ 608: 02d00793 li a5,45
+ 60c: fef70823 sb a5,-16(a4)
+ 610: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 614: 02e05663 blez a4,640 <printint+0x94>
+ 618: fc040913 addi s2,s0,-64
+ 61c: 993a add s2,s2,a4
+ 61e: 19fd addi s3,s3,-1
+ 620: 99ba add s3,s3,a4
+ 622: 377d addiw a4,a4,-1
+ 624: 1702 slli a4,a4,0x20
+ 626: 9301 srli a4,a4,0x20
+ 628: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 62c: fff94583 lbu a1,-1(s2)
+ 630: 8526 mv a0,s1
+ 632: 00000097 auipc ra,0x0
+ 636: f58080e7 jalr -168(ra) # 58a <putc>
+ while(--i >= 0)
+ 63a: 197d addi s2,s2,-1
+ 63c: ff3918e3 bne s2,s3,62c <printint+0x80>
+}
+ 640: 70e2 ld ra,56(sp)
+ 642: 7442 ld s0,48(sp)
+ 644: 74a2 ld s1,40(sp)
+ 646: 7902 ld s2,32(sp)
+ 648: 69e2 ld s3,24(sp)
+ 64a: 6121 addi sp,sp,64
+ 64c: 8082 ret
+ x = -xx;
+ 64e: 40b005bb negw a1,a1
+ neg = 1;
+ 652: 4885 li a7,1
+ x = -xx;
+ 654: bf8d j 5c6 <printint+0x1a>
+
+0000000000000656 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 656: 7119 addi sp,sp,-128
+ 658: fc86 sd ra,120(sp)
+ 65a: f8a2 sd s0,112(sp)
+ 65c: f4a6 sd s1,104(sp)
+ 65e: f0ca sd s2,96(sp)
+ 660: ecce sd s3,88(sp)
+ 662: e8d2 sd s4,80(sp)
+ 664: e4d6 sd s5,72(sp)
+ 666: e0da sd s6,64(sp)
+ 668: fc5e sd s7,56(sp)
+ 66a: f862 sd s8,48(sp)
+ 66c: f466 sd s9,40(sp)
+ 66e: f06a sd s10,32(sp)
+ 670: ec6e sd s11,24(sp)
+ 672: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 674: 0005c903 lbu s2,0(a1)
+ 678: 18090f63 beqz s2,816 <vprintf+0x1c0>
+ 67c: 8aaa mv s5,a0
+ 67e: 8b32 mv s6,a2
+ 680: 00158493 addi s1,a1,1
+ state = 0;
+ 684: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 686: 02500a13 li s4,37
+ 68a: 4c55 li s8,21
+ 68c: 00000c97 auipc s9,0x0
+ 690: 3ecc8c93 addi s9,s9,1004 # a78 <malloc+0x15e>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 694: 02800d93 li s11,40
+ putc(fd, 'x');
+ 698: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 69a: 00000b97 auipc s7,0x0
+ 69e: 436b8b93 addi s7,s7,1078 # ad0 <digits>
+ 6a2: a839 j 6c0 <vprintf+0x6a>
+ putc(fd, c);
+ 6a4: 85ca mv a1,s2
+ 6a6: 8556 mv a0,s5
+ 6a8: 00000097 auipc ra,0x0
+ 6ac: ee2080e7 jalr -286(ra) # 58a <putc>
+ 6b0: a019 j 6b6 <vprintf+0x60>
+ } else if(state == '%'){
+ 6b2: 01498d63 beq s3,s4,6cc <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 6b6: 0485 addi s1,s1,1
+ 6b8: fff4c903 lbu s2,-1(s1)
+ 6bc: 14090d63 beqz s2,816 <vprintf+0x1c0>
+ if(state == 0){
+ 6c0: fe0999e3 bnez s3,6b2 <vprintf+0x5c>
+ if(c == '%'){
+ 6c4: ff4910e3 bne s2,s4,6a4 <vprintf+0x4e>
+ state = '%';
+ 6c8: 89d2 mv s3,s4
+ 6ca: b7f5 j 6b6 <vprintf+0x60>
+ if(c == 'd'){
+ 6cc: 11490c63 beq s2,s4,7e4 <vprintf+0x18e>
+ 6d0: f9d9079b addiw a5,s2,-99
+ 6d4: 0ff7f793 zext.b a5,a5
+ 6d8: 10fc6e63 bltu s8,a5,7f4 <vprintf+0x19e>
+ 6dc: f9d9079b addiw a5,s2,-99
+ 6e0: 0ff7f713 zext.b a4,a5
+ 6e4: 10ec6863 bltu s8,a4,7f4 <vprintf+0x19e>
+ 6e8: 00271793 slli a5,a4,0x2
+ 6ec: 97e6 add a5,a5,s9
+ 6ee: 439c lw a5,0(a5)
+ 6f0: 97e6 add a5,a5,s9
+ 6f2: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 6f4: 008b0913 addi s2,s6,8
+ 6f8: 4685 li a3,1
+ 6fa: 4629 li a2,10
+ 6fc: 000b2583 lw a1,0(s6)
+ 700: 8556 mv a0,s5
+ 702: 00000097 auipc ra,0x0
+ 706: eaa080e7 jalr -342(ra) # 5ac <printint>
+ 70a: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 70c: 4981 li s3,0
+ 70e: b765 j 6b6 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 710: 008b0913 addi s2,s6,8
+ 714: 4681 li a3,0
+ 716: 4629 li a2,10
+ 718: 000b2583 lw a1,0(s6)
+ 71c: 8556 mv a0,s5
+ 71e: 00000097 auipc ra,0x0
+ 722: e8e080e7 jalr -370(ra) # 5ac <printint>
+ 726: 8b4a mv s6,s2
+ state = 0;
+ 728: 4981 li s3,0
+ 72a: b771 j 6b6 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 72c: 008b0913 addi s2,s6,8
+ 730: 4681 li a3,0
+ 732: 866a mv a2,s10
+ 734: 000b2583 lw a1,0(s6)
+ 738: 8556 mv a0,s5
+ 73a: 00000097 auipc ra,0x0
+ 73e: e72080e7 jalr -398(ra) # 5ac <printint>
+ 742: 8b4a mv s6,s2
+ state = 0;
+ 744: 4981 li s3,0
+ 746: bf85 j 6b6 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 748: 008b0793 addi a5,s6,8
+ 74c: f8f43423 sd a5,-120(s0)
+ 750: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 754: 03000593 li a1,48
+ 758: 8556 mv a0,s5
+ 75a: 00000097 auipc ra,0x0
+ 75e: e30080e7 jalr -464(ra) # 58a <putc>
+ putc(fd, 'x');
+ 762: 07800593 li a1,120
+ 766: 8556 mv a0,s5
+ 768: 00000097 auipc ra,0x0
+ 76c: e22080e7 jalr -478(ra) # 58a <putc>
+ 770: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 772: 03c9d793 srli a5,s3,0x3c
+ 776: 97de add a5,a5,s7
+ 778: 0007c583 lbu a1,0(a5)
+ 77c: 8556 mv a0,s5
+ 77e: 00000097 auipc ra,0x0
+ 782: e0c080e7 jalr -500(ra) # 58a <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 786: 0992 slli s3,s3,0x4
+ 788: 397d addiw s2,s2,-1
+ 78a: fe0914e3 bnez s2,772 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 78e: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 792: 4981 li s3,0
+ 794: b70d j 6b6 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 796: 008b0913 addi s2,s6,8
+ 79a: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 79e: 02098163 beqz s3,7c0 <vprintf+0x16a>
+ while(*s != 0){
+ 7a2: 0009c583 lbu a1,0(s3)
+ 7a6: c5ad beqz a1,810 <vprintf+0x1ba>
+ putc(fd, *s);
+ 7a8: 8556 mv a0,s5
+ 7aa: 00000097 auipc ra,0x0
+ 7ae: de0080e7 jalr -544(ra) # 58a <putc>
+ s++;
+ 7b2: 0985 addi s3,s3,1
+ while(*s != 0){
+ 7b4: 0009c583 lbu a1,0(s3)
+ 7b8: f9e5 bnez a1,7a8 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 7ba: 8b4a mv s6,s2
+ state = 0;
+ 7bc: 4981 li s3,0
+ 7be: bde5 j 6b6 <vprintf+0x60>
+ s = "(null)";
+ 7c0: 00000997 auipc s3,0x0
+ 7c4: 2b098993 addi s3,s3,688 # a70 <malloc+0x156>
+ while(*s != 0){
+ 7c8: 85ee mv a1,s11
+ 7ca: bff9 j 7a8 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 7cc: 008b0913 addi s2,s6,8
+ 7d0: 000b4583 lbu a1,0(s6)
+ 7d4: 8556 mv a0,s5
+ 7d6: 00000097 auipc ra,0x0
+ 7da: db4080e7 jalr -588(ra) # 58a <putc>
+ 7de: 8b4a mv s6,s2
+ state = 0;
+ 7e0: 4981 li s3,0
+ 7e2: bdd1 j 6b6 <vprintf+0x60>
+ putc(fd, c);
+ 7e4: 85d2 mv a1,s4
+ 7e6: 8556 mv a0,s5
+ 7e8: 00000097 auipc ra,0x0
+ 7ec: da2080e7 jalr -606(ra) # 58a <putc>
+ state = 0;
+ 7f0: 4981 li s3,0
+ 7f2: b5d1 j 6b6 <vprintf+0x60>
+ putc(fd, '%');
+ 7f4: 85d2 mv a1,s4
+ 7f6: 8556 mv a0,s5
+ 7f8: 00000097 auipc ra,0x0
+ 7fc: d92080e7 jalr -622(ra) # 58a <putc>
+ putc(fd, c);
+ 800: 85ca mv a1,s2
+ 802: 8556 mv a0,s5
+ 804: 00000097 auipc ra,0x0
+ 808: d86080e7 jalr -634(ra) # 58a <putc>
+ state = 0;
+ 80c: 4981 li s3,0
+ 80e: b565 j 6b6 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 810: 8b4a mv s6,s2
+ state = 0;
+ 812: 4981 li s3,0
+ 814: b54d j 6b6 <vprintf+0x60>
+ }
+ }
+}
+ 816: 70e6 ld ra,120(sp)
+ 818: 7446 ld s0,112(sp)
+ 81a: 74a6 ld s1,104(sp)
+ 81c: 7906 ld s2,96(sp)
+ 81e: 69e6 ld s3,88(sp)
+ 820: 6a46 ld s4,80(sp)
+ 822: 6aa6 ld s5,72(sp)
+ 824: 6b06 ld s6,64(sp)
+ 826: 7be2 ld s7,56(sp)
+ 828: 7c42 ld s8,48(sp)
+ 82a: 7ca2 ld s9,40(sp)
+ 82c: 7d02 ld s10,32(sp)
+ 82e: 6de2 ld s11,24(sp)
+ 830: 6109 addi sp,sp,128
+ 832: 8082 ret
+
+0000000000000834 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 834: 715d addi sp,sp,-80
+ 836: ec06 sd ra,24(sp)
+ 838: e822 sd s0,16(sp)
+ 83a: 1000 addi s0,sp,32
+ 83c: e010 sd a2,0(s0)
+ 83e: e414 sd a3,8(s0)
+ 840: e818 sd a4,16(s0)
+ 842: ec1c sd a5,24(s0)
+ 844: 03043023 sd a6,32(s0)
+ 848: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 84c: 8622 mv a2,s0
+ 84e: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 852: 00000097 auipc ra,0x0
+ 856: e04080e7 jalr -508(ra) # 656 <vprintf>
+}
+ 85a: 60e2 ld ra,24(sp)
+ 85c: 6442 ld s0,16(sp)
+ 85e: 6161 addi sp,sp,80
+ 860: 8082 ret
+
+0000000000000862 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 862: 711d addi sp,sp,-96
+ 864: ec06 sd ra,24(sp)
+ 866: e822 sd s0,16(sp)
+ 868: 1000 addi s0,sp,32
+ 86a: e40c sd a1,8(s0)
+ 86c: e810 sd a2,16(s0)
+ 86e: ec14 sd a3,24(s0)
+ 870: f018 sd a4,32(s0)
+ 872: f41c sd a5,40(s0)
+ 874: 03043823 sd a6,48(s0)
+ 878: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 87c: 00840613 addi a2,s0,8
+ 880: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 884: 85aa mv a1,a0
+ 886: 4505 li a0,1
+ 888: 00000097 auipc ra,0x0
+ 88c: dce080e7 jalr -562(ra) # 656 <vprintf>
+}
+ 890: 60e2 ld ra,24(sp)
+ 892: 6442 ld s0,16(sp)
+ 894: 6125 addi sp,sp,96
+ 896: 8082 ret
+
+0000000000000898 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 898: 1141 addi sp,sp,-16
+ 89a: e422 sd s0,8(sp)
+ 89c: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 89e: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 8a2: 00000797 auipc a5,0x0
+ 8a6: 26e7b783 ld a5,622(a5) # b10 <freep>
+ 8aa: a02d j 8d4 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 8ac: 4618 lw a4,8(a2)
+ 8ae: 9f2d addw a4,a4,a1
+ 8b0: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8b4: 6398 ld a4,0(a5)
+ 8b6: 6310 ld a2,0(a4)
+ 8b8: a83d j 8f6 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 8ba: ff852703 lw a4,-8(a0)
+ 8be: 9f31 addw a4,a4,a2
+ 8c0: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 8c2: ff053683 ld a3,-16(a0)
+ 8c6: a091 j 90a <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8c8: 6398 ld a4,0(a5)
+ 8ca: 00e7e463 bltu a5,a4,8d2 <free+0x3a>
+ 8ce: 00e6ea63 bltu a3,a4,8e2 <free+0x4a>
+{
+ 8d2: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 8d4: fed7fae3 bgeu a5,a3,8c8 <free+0x30>
+ 8d8: 6398 ld a4,0(a5)
+ 8da: 00e6e463 bltu a3,a4,8e2 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8de: fee7eae3 bltu a5,a4,8d2 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 8e2: ff852583 lw a1,-8(a0)
+ 8e6: 6390 ld a2,0(a5)
+ 8e8: 02059813 slli a6,a1,0x20
+ 8ec: 01c85713 srli a4,a6,0x1c
+ 8f0: 9736 add a4,a4,a3
+ 8f2: fae60de3 beq a2,a4,8ac <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8f6: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 8fa: 4790 lw a2,8(a5)
+ 8fc: 02061593 slli a1,a2,0x20
+ 900: 01c5d713 srli a4,a1,0x1c
+ 904: 973e add a4,a4,a5
+ 906: fae68ae3 beq a3,a4,8ba <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 90a: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 90c: 00000717 auipc a4,0x0
+ 910: 20f73223 sd a5,516(a4) # b10 <freep>
+}
+ 914: 6422 ld s0,8(sp)
+ 916: 0141 addi sp,sp,16
+ 918: 8082 ret
+
+000000000000091a <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 91a: 7139 addi sp,sp,-64
+ 91c: fc06 sd ra,56(sp)
+ 91e: f822 sd s0,48(sp)
+ 920: f426 sd s1,40(sp)
+ 922: f04a sd s2,32(sp)
+ 924: ec4e sd s3,24(sp)
+ 926: e852 sd s4,16(sp)
+ 928: e456 sd s5,8(sp)
+ 92a: e05a sd s6,0(sp)
+ 92c: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 92e: 02051493 slli s1,a0,0x20
+ 932: 9081 srli s1,s1,0x20
+ 934: 04bd addi s1,s1,15
+ 936: 8091 srli s1,s1,0x4
+ 938: 00148a1b addiw s4,s1,1
+ 93c: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 93e: 00000517 auipc a0,0x0
+ 942: 1d253503 ld a0,466(a0) # b10 <freep>
+ 946: c515 beqz a0,972 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 948: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 94a: 4798 lw a4,8(a5)
+ 94c: 04977163 bgeu a4,s1,98e <malloc+0x74>
+ 950: 89d2 mv s3,s4
+ 952: 000a071b sext.w a4,s4
+ 956: 6685 lui a3,0x1
+ 958: 00d77363 bgeu a4,a3,95e <malloc+0x44>
+ 95c: 6985 lui s3,0x1
+ 95e: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 962: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 966: 00000917 auipc s2,0x0
+ 96a: 1aa90913 addi s2,s2,426 # b10 <freep>
+ if(p == (char*)-1)
+ 96e: 5afd li s5,-1
+ 970: a8a5 j 9e8 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 972: 00000797 auipc a5,0x0
+ 976: 19e78793 addi a5,a5,414 # b10 <freep>
+ 97a: 00000717 auipc a4,0x0
+ 97e: 19e70713 addi a4,a4,414 # b18 <base>
+ 982: e398 sd a4,0(a5)
+ 984: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 986: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 98a: 87ba mv a5,a4
+ 98c: b7d1 j 950 <malloc+0x36>
+ if(p->s.size == nunits)
+ 98e: 02e48c63 beq s1,a4,9c6 <malloc+0xac>
+ p->s.size -= nunits;
+ 992: 4147073b subw a4,a4,s4
+ 996: c798 sw a4,8(a5)
+ p += p->s.size;
+ 998: 02071693 slli a3,a4,0x20
+ 99c: 01c6d713 srli a4,a3,0x1c
+ 9a0: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 9a2: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 9a6: 00000717 auipc a4,0x0
+ 9aa: 16a73523 sd a0,362(a4) # b10 <freep>
+ return (void*)(p + 1);
+ 9ae: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 9b2: 70e2 ld ra,56(sp)
+ 9b4: 7442 ld s0,48(sp)
+ 9b6: 74a2 ld s1,40(sp)
+ 9b8: 7902 ld s2,32(sp)
+ 9ba: 69e2 ld s3,24(sp)
+ 9bc: 6a42 ld s4,16(sp)
+ 9be: 6aa2 ld s5,8(sp)
+ 9c0: 6b02 ld s6,0(sp)
+ 9c2: 6121 addi sp,sp,64
+ 9c4: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 9c6: 6398 ld a4,0(a5)
+ 9c8: e118 sd a4,0(a0)
+ 9ca: bff1 j 9a6 <malloc+0x8c>
+ hp->s.size = nu;
+ 9cc: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 9d0: 0541 addi a0,a0,16
+ 9d2: 00000097 auipc ra,0x0
+ 9d6: ec6080e7 jalr -314(ra) # 898 <free>
+ return freep;
+ 9da: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 9de: d971 beqz a0,9b2 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 9e0: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 9e2: 4798 lw a4,8(a5)
+ 9e4: fa9775e3 bgeu a4,s1,98e <malloc+0x74>
+ if(p == freep)
+ 9e8: 00093703 ld a4,0(s2)
+ 9ec: 853e mv a0,a5
+ 9ee: fef719e3 bne a4,a5,9e0 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 9f2: 854e mv a0,s3
+ 9f4: 00000097 auipc ra,0x0
+ 9f8: b30080e7 jalr -1232(ra) # 524 <sbrk>
+ if(p == (char*)-1)
+ 9fc: fd5518e3 bne a0,s5,9cc <malloc+0xb2>
+ return 0;
+ a00: 4501 li a0,0
+ a02: bf45 j 9b2 <malloc+0x98>
diff --git a/xv6-user/ls.c b/xv6-user/ls.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e7385acc07616f09b3cf7e41f228fa960a3258a
--- /dev/null
+++ b/xv6-user/ls.c
@@ -0,0 +1,63 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+char*
+fmtname(char *name)
+{
+ static char buf[STAT_MAX_NAME+1];
+ int len = strlen(name);
+
+ // Return blank-padded name.
+ if(len >= STAT_MAX_NAME)
+ return name;
+ memmove(buf, name, len);
+ memset(buf + len, ' ', STAT_MAX_NAME - len);
+ buf[STAT_MAX_NAME] = '\0';
+ return buf;
+}
+
+void
+ls(char *path)
+{
+ int fd;
+ struct stat st;
+ char *types[] = {
+ [T_DIR] "DIR ",
+ [T_FILE] "FILE",
+ };
+
+ if((fd = open(path, 0)) < 0){
+ fprintf(2, "ls: cannot open %s\n", path);
+ return;
+ }
+
+ if(fstat(fd, &st) < 0){
+ fprintf(2, "ls: cannot stat %s\n", path);
+ close(fd);
+ return;
+ }
+
+ if (st.type == T_DIR){
+ while(readdir(fd, &st) == 1){
+ printf("%s %s\t%d\n", fmtname(st.name), types[st.type], st.size);
+ }
+ } else {
+ printf("%s %s\t%l\n", fmtname(st.name), types[st.type], st.size);
+ }
+ close(fd);
+}
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+
+ if(argc < 2){
+ ls(".");
+ exit(0);
+ }
+ for(i=1; i<argc; i++)
+ ls(argv[i]);
+ exit(0);
+}
diff --git a/xv6-user/ls.d b/xv6-user/ls.d
new file mode 100644
index 0000000000000000000000000000000000000000..0df9d1ef2f370007e45d7fe511c2e5de43f678ff
--- /dev/null
+++ b/xv6-user/ls.d
@@ -0,0 +1,2 @@
+xv6-user/ls.o: xv6-user/ls.c kernel/include/types.h kernel/include/stat.h \
+ xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/ls.o b/xv6-user/ls.o
new file mode 100644
index 0000000000000000000000000000000000000000..3dfff6d31f8c91c54186c08e2a3c29ced00ae340
Binary files /dev/null and b/xv6-user/ls.o differ
diff --git a/xv6-user/ls.sym b/xv6-user/ls.sym
new file mode 100644
index 0000000000000000000000000000000000000000..f887c2b174ce7efa4a014ac4826b2f03c337fe6c
--- /dev/null
+++ b/xv6-user/ls.sym
@@ -0,0 +1,79 @@
+0000000000000000 .text
+0000000000000a08 .rodata
+0000000000000ae8 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 ls.c
+0000000000000ae8 buf.0
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+000000000000058a putc
+00000000000005ac printint
+0000000000000ad0 digits
+0000000000000000 umalloc.c
+0000000000000b10 freep
+0000000000000b18 base
+00000000000001e6 strcpy
+0000000000000000 fmtname
+0000000000000862 printf
+00000000000012e1 __global_pointer$
+0000000000000544 dev
+00000000000003ec memmove
+0000000000000568 trace
+00000000000002cc gets
+0000000000000ae1 __SDATA_BEGIN__
+000000000000051a getpid
+000000000000047e memcpy
+000000000000091a malloc
+000000000000055e remove
+000000000000052c sleep
+0000000000000570 sysinfo
+000000000000054e readdir
+00000000000004b0 pipe
+0000000000000578 rename
+00000000000004c4 write
+00000000000004f4 fstat
+0000000000000834 fprintf
+00000000000004d8 kill
+0000000000000202 strcat
+0000000000000656 vprintf
+0000000000000508 chdir
+00000000000004e0 exec
+00000000000004a8 wait
+00000000000004ba read
+0000000000000444 memcmp
+0000000000000496 fork
+0000000000000b28 __BSS_END__
+0000000000000524 sbrk
+000000000000053c test_proc
+0000000000000534 uptime
+0000000000000ae1 __bss_start
+0000000000000286 memset
+000000000000018c main
+0000000000000230 strcmp
+0000000000000580 shutdown
+0000000000000512 dup
+0000000000000556 getcwd
+0000000000000ae1 __DATA_BEGIN__
+0000000000000346 stat
+0000000000000ae1 _edata
+0000000000000b28 _end
+0000000000000066 ls
+000000000000049e exit
+000000000000038c atoi
+000000000000025c strlen
+00000000000004ea open
+00000000000002a8 strchr
+00000000000004fe mkdir
+00000000000004ce close
+0000000000000898 free
diff --git a/xv6-user/mkdir.asm b/xv6-user/mkdir.asm
new file mode 100644
index 0000000000000000000000000000000000000000..5148a707bda5f28e903250c14ee17d47461c2bbf
--- /dev/null
+++ b/xv6-user/mkdir.asm
@@ -0,0 +1,1451 @@
+
+xv6-user/_mkdir: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: 1800 addi s0,sp,48
+ int i;
+
+ if(argc < 2){
+ e: 4785 li a5,1
+ 10: 02a7d763 bge a5,a0,3e <main+0x3e>
+ 14: 00858493 addi s1,a1,8
+ 18: ffe5091b addiw s2,a0,-2
+ 1c: 02091793 slli a5,s2,0x20
+ 20: 01d7d913 srli s2,a5,0x1d
+ 24: 05c1 addi a1,a1,16
+ 26: 992e add s2,s2,a1
+ fprintf(2, "Usage: mkdir files...\n");
+ exit(1);
+ }
+
+ for(i = 1; i < argc; i++){
+ if(mkdir(argv[i]) < 0){
+ 28: 6088 ld a0,0(s1)
+ 2a: 00000097 auipc ra,0x0
+ 2e: 366080e7 jalr 870(ra) # 390 <mkdir>
+ 32: 02054463 bltz a0,5a <main+0x5a>
+ for(i = 1; i < argc; i++){
+ 36: 04a1 addi s1,s1,8
+ 38: ff2498e3 bne s1,s2,28 <main+0x28>
+ 3c: a80d j 6e <main+0x6e>
+ fprintf(2, "Usage: mkdir files...\n");
+ 3e: 00001597 auipc a1,0x1
+ 42: 85a58593 addi a1,a1,-1958 # 898 <malloc+0xec>
+ 46: 4509 li a0,2
+ 48: 00000097 auipc ra,0x0
+ 4c: 67e080e7 jalr 1662(ra) # 6c6 <fprintf>
+ exit(1);
+ 50: 4505 li a0,1
+ 52: 00000097 auipc ra,0x0
+ 56: 2de080e7 jalr 734(ra) # 330 <exit>
+ fprintf(2, "mkdir: %s failed to create\n", argv[i]);
+ 5a: 6090 ld a2,0(s1)
+ 5c: 00001597 auipc a1,0x1
+ 60: 85458593 addi a1,a1,-1964 # 8b0 <malloc+0x104>
+ 64: 4509 li a0,2
+ 66: 00000097 auipc ra,0x0
+ 6a: 660080e7 jalr 1632(ra) # 6c6 <fprintf>
+ break;
+ }
+ }
+
+ exit(0);
+ 6e: 4501 li a0,0
+ 70: 00000097 auipc ra,0x0
+ 74: 2c0080e7 jalr 704(ra) # 330 <exit>
+
+0000000000000078 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 78: 1141 addi sp,sp,-16
+ 7a: e422 sd s0,8(sp)
+ 7c: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 7e: 87aa mv a5,a0
+ 80: 0585 addi a1,a1,1
+ 82: 0785 addi a5,a5,1
+ 84: fff5c703 lbu a4,-1(a1)
+ 88: fee78fa3 sb a4,-1(a5)
+ 8c: fb75 bnez a4,80 <strcpy+0x8>
+ ;
+ return os;
+}
+ 8e: 6422 ld s0,8(sp)
+ 90: 0141 addi sp,sp,16
+ 92: 8082 ret
+
+0000000000000094 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 94: 1141 addi sp,sp,-16
+ 96: e422 sd s0,8(sp)
+ 98: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 9a: 00054783 lbu a5,0(a0)
+ 9e: c385 beqz a5,be <strcat+0x2a>
+ a0: 87aa mv a5,a0
+ s++;
+ a2: 0785 addi a5,a5,1
+ while(*s)
+ a4: 0007c703 lbu a4,0(a5)
+ a8: ff6d bnez a4,a2 <strcat+0xe>
+ while((*s++ = *t++))
+ aa: 0585 addi a1,a1,1
+ ac: 0785 addi a5,a5,1
+ ae: fff5c703 lbu a4,-1(a1)
+ b2: fee78fa3 sb a4,-1(a5)
+ b6: fb75 bnez a4,aa <strcat+0x16>
+ ;
+ return os;
+}
+ b8: 6422 ld s0,8(sp)
+ ba: 0141 addi sp,sp,16
+ bc: 8082 ret
+ while(*s)
+ be: 87aa mv a5,a0
+ c0: b7ed j aa <strcat+0x16>
+
+00000000000000c2 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ c2: 1141 addi sp,sp,-16
+ c4: e422 sd s0,8(sp)
+ c6: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ c8: 00054783 lbu a5,0(a0)
+ cc: cb91 beqz a5,e0 <strcmp+0x1e>
+ ce: 0005c703 lbu a4,0(a1)
+ d2: 00f71763 bne a4,a5,e0 <strcmp+0x1e>
+ p++, q++;
+ d6: 0505 addi a0,a0,1
+ d8: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ da: 00054783 lbu a5,0(a0)
+ de: fbe5 bnez a5,ce <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ e0: 0005c503 lbu a0,0(a1)
+}
+ e4: 40a7853b subw a0,a5,a0
+ e8: 6422 ld s0,8(sp)
+ ea: 0141 addi sp,sp,16
+ ec: 8082 ret
+
+00000000000000ee <strlen>:
+
+uint
+strlen(const char *s)
+{
+ ee: 1141 addi sp,sp,-16
+ f0: e422 sd s0,8(sp)
+ f2: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ f4: 00054783 lbu a5,0(a0)
+ f8: cf91 beqz a5,114 <strlen+0x26>
+ fa: 0505 addi a0,a0,1
+ fc: 87aa mv a5,a0
+ fe: 4685 li a3,1
+ 100: 9e89 subw a3,a3,a0
+ 102: 00f6853b addw a0,a3,a5
+ 106: 0785 addi a5,a5,1
+ 108: fff7c703 lbu a4,-1(a5)
+ 10c: fb7d bnez a4,102 <strlen+0x14>
+ ;
+ return n;
+}
+ 10e: 6422 ld s0,8(sp)
+ 110: 0141 addi sp,sp,16
+ 112: 8082 ret
+ for(n = 0; s[n]; n++)
+ 114: 4501 li a0,0
+ 116: bfe5 j 10e <strlen+0x20>
+
+0000000000000118 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 118: 1141 addi sp,sp,-16
+ 11a: e422 sd s0,8(sp)
+ 11c: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 11e: ca19 beqz a2,134 <memset+0x1c>
+ 120: 87aa mv a5,a0
+ 122: 1602 slli a2,a2,0x20
+ 124: 9201 srli a2,a2,0x20
+ 126: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 12a: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 12e: 0785 addi a5,a5,1
+ 130: fee79de3 bne a5,a4,12a <memset+0x12>
+ }
+ return dst;
+}
+ 134: 6422 ld s0,8(sp)
+ 136: 0141 addi sp,sp,16
+ 138: 8082 ret
+
+000000000000013a <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 13a: 1141 addi sp,sp,-16
+ 13c: e422 sd s0,8(sp)
+ 13e: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 140: 00054783 lbu a5,0(a0)
+ 144: cb99 beqz a5,15a <strchr+0x20>
+ if(*s == c)
+ 146: 00f58763 beq a1,a5,154 <strchr+0x1a>
+ for(; *s; s++)
+ 14a: 0505 addi a0,a0,1
+ 14c: 00054783 lbu a5,0(a0)
+ 150: fbfd bnez a5,146 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 152: 4501 li a0,0
+}
+ 154: 6422 ld s0,8(sp)
+ 156: 0141 addi sp,sp,16
+ 158: 8082 ret
+ return 0;
+ 15a: 4501 li a0,0
+ 15c: bfe5 j 154 <strchr+0x1a>
+
+000000000000015e <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 15e: 711d addi sp,sp,-96
+ 160: ec86 sd ra,88(sp)
+ 162: e8a2 sd s0,80(sp)
+ 164: e4a6 sd s1,72(sp)
+ 166: e0ca sd s2,64(sp)
+ 168: fc4e sd s3,56(sp)
+ 16a: f852 sd s4,48(sp)
+ 16c: f456 sd s5,40(sp)
+ 16e: f05a sd s6,32(sp)
+ 170: ec5e sd s7,24(sp)
+ 172: e862 sd s8,16(sp)
+ 174: 1080 addi s0,sp,96
+ 176: 8baa mv s7,a0
+ 178: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 17a: 892a mv s2,a0
+ 17c: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 17e: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 182: 4b29 li s6,10
+ 184: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 186: 89a6 mv s3,s1
+ 188: 2485 addiw s1,s1,1
+ 18a: 0344d763 bge s1,s4,1b8 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 18e: 4605 li a2,1
+ 190: 85d6 mv a1,s5
+ 192: 4501 li a0,0
+ 194: 00000097 auipc ra,0x0
+ 198: 1b8080e7 jalr 440(ra) # 34c <read>
+ if(cc < 1)
+ 19c: 00a05e63 blez a0,1b8 <gets+0x5a>
+ buf[i++] = c;
+ 1a0: faf44783 lbu a5,-81(s0)
+ 1a4: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 1a8: 01678763 beq a5,s6,1b6 <gets+0x58>
+ 1ac: 0905 addi s2,s2,1
+ 1ae: fd879ce3 bne a5,s8,186 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 1b2: 89a6 mv s3,s1
+ 1b4: a011 j 1b8 <gets+0x5a>
+ 1b6: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1b8: 99de add s3,s3,s7
+ 1ba: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1be: 855e mv a0,s7
+ 1c0: 60e6 ld ra,88(sp)
+ 1c2: 6446 ld s0,80(sp)
+ 1c4: 64a6 ld s1,72(sp)
+ 1c6: 6906 ld s2,64(sp)
+ 1c8: 79e2 ld s3,56(sp)
+ 1ca: 7a42 ld s4,48(sp)
+ 1cc: 7aa2 ld s5,40(sp)
+ 1ce: 7b02 ld s6,32(sp)
+ 1d0: 6be2 ld s7,24(sp)
+ 1d2: 6c42 ld s8,16(sp)
+ 1d4: 6125 addi sp,sp,96
+ 1d6: 8082 ret
+
+00000000000001d8 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1d8: 1101 addi sp,sp,-32
+ 1da: ec06 sd ra,24(sp)
+ 1dc: e822 sd s0,16(sp)
+ 1de: e426 sd s1,8(sp)
+ 1e0: e04a sd s2,0(sp)
+ 1e2: 1000 addi s0,sp,32
+ 1e4: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1e6: 4581 li a1,0
+ 1e8: 00000097 auipc ra,0x0
+ 1ec: 194080e7 jalr 404(ra) # 37c <open>
+ if(fd < 0)
+ 1f0: 02054563 bltz a0,21a <stat+0x42>
+ 1f4: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1f6: 85ca mv a1,s2
+ 1f8: 00000097 auipc ra,0x0
+ 1fc: 18e080e7 jalr 398(ra) # 386 <fstat>
+ 200: 892a mv s2,a0
+ close(fd);
+ 202: 8526 mv a0,s1
+ 204: 00000097 auipc ra,0x0
+ 208: 15c080e7 jalr 348(ra) # 360 <close>
+ return r;
+}
+ 20c: 854a mv a0,s2
+ 20e: 60e2 ld ra,24(sp)
+ 210: 6442 ld s0,16(sp)
+ 212: 64a2 ld s1,8(sp)
+ 214: 6902 ld s2,0(sp)
+ 216: 6105 addi sp,sp,32
+ 218: 8082 ret
+ return -1;
+ 21a: 597d li s2,-1
+ 21c: bfc5 j 20c <stat+0x34>
+
+000000000000021e <atoi>:
+
+int
+atoi(const char *s)
+{
+ 21e: 1141 addi sp,sp,-16
+ 220: e422 sd s0,8(sp)
+ 222: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 224: 00054703 lbu a4,0(a0)
+ 228: 02d00793 li a5,45
+ int neg = 1;
+ 22c: 4585 li a1,1
+ if (*s == '-') {
+ 22e: 04f70363 beq a4,a5,274 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 232: 00054703 lbu a4,0(a0)
+ 236: fd07079b addiw a5,a4,-48
+ 23a: 0ff7f793 zext.b a5,a5
+ 23e: 46a5 li a3,9
+ 240: 02f6ed63 bltu a3,a5,27a <atoi+0x5c>
+ n = 0;
+ 244: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 246: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 248: 0505 addi a0,a0,1
+ 24a: 0026979b slliw a5,a3,0x2
+ 24e: 9fb5 addw a5,a5,a3
+ 250: 0017979b slliw a5,a5,0x1
+ 254: 9fb9 addw a5,a5,a4
+ 256: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 25a: 00054703 lbu a4,0(a0)
+ 25e: fd07079b addiw a5,a4,-48
+ 262: 0ff7f793 zext.b a5,a5
+ 266: fef671e3 bgeu a2,a5,248 <atoi+0x2a>
+ return n * neg;
+}
+ 26a: 02d5853b mulw a0,a1,a3
+ 26e: 6422 ld s0,8(sp)
+ 270: 0141 addi sp,sp,16
+ 272: 8082 ret
+ s++;
+ 274: 0505 addi a0,a0,1
+ neg = -1;
+ 276: 55fd li a1,-1
+ 278: bf6d j 232 <atoi+0x14>
+ n = 0;
+ 27a: 4681 li a3,0
+ 27c: b7fd j 26a <atoi+0x4c>
+
+000000000000027e <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 27e: 1141 addi sp,sp,-16
+ 280: e422 sd s0,8(sp)
+ 282: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 284: 02b57463 bgeu a0,a1,2ac <memmove+0x2e>
+ while(n-- > 0)
+ 288: 00c05f63 blez a2,2a6 <memmove+0x28>
+ 28c: 1602 slli a2,a2,0x20
+ 28e: 9201 srli a2,a2,0x20
+ 290: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 294: 872a mv a4,a0
+ *dst++ = *src++;
+ 296: 0585 addi a1,a1,1
+ 298: 0705 addi a4,a4,1
+ 29a: fff5c683 lbu a3,-1(a1)
+ 29e: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 2a2: fee79ae3 bne a5,a4,296 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 2a6: 6422 ld s0,8(sp)
+ 2a8: 0141 addi sp,sp,16
+ 2aa: 8082 ret
+ dst += n;
+ 2ac: 00c50733 add a4,a0,a2
+ src += n;
+ 2b0: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 2b2: fec05ae3 blez a2,2a6 <memmove+0x28>
+ 2b6: fff6079b addiw a5,a2,-1
+ 2ba: 1782 slli a5,a5,0x20
+ 2bc: 9381 srli a5,a5,0x20
+ 2be: fff7c793 not a5,a5
+ 2c2: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2c4: 15fd addi a1,a1,-1
+ 2c6: 177d addi a4,a4,-1
+ 2c8: 0005c683 lbu a3,0(a1)
+ 2cc: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2d0: fee79ae3 bne a5,a4,2c4 <memmove+0x46>
+ 2d4: bfc9 j 2a6 <memmove+0x28>
+
+00000000000002d6 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2d6: 1141 addi sp,sp,-16
+ 2d8: e422 sd s0,8(sp)
+ 2da: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2dc: ca05 beqz a2,30c <memcmp+0x36>
+ 2de: fff6069b addiw a3,a2,-1
+ 2e2: 1682 slli a3,a3,0x20
+ 2e4: 9281 srli a3,a3,0x20
+ 2e6: 0685 addi a3,a3,1
+ 2e8: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2ea: 00054783 lbu a5,0(a0)
+ 2ee: 0005c703 lbu a4,0(a1)
+ 2f2: 00e79863 bne a5,a4,302 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2f6: 0505 addi a0,a0,1
+ p2++;
+ 2f8: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2fa: fed518e3 bne a0,a3,2ea <memcmp+0x14>
+ }
+ return 0;
+ 2fe: 4501 li a0,0
+ 300: a019 j 306 <memcmp+0x30>
+ return *p1 - *p2;
+ 302: 40e7853b subw a0,a5,a4
+}
+ 306: 6422 ld s0,8(sp)
+ 308: 0141 addi sp,sp,16
+ 30a: 8082 ret
+ return 0;
+ 30c: 4501 li a0,0
+ 30e: bfe5 j 306 <memcmp+0x30>
+
+0000000000000310 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 310: 1141 addi sp,sp,-16
+ 312: e406 sd ra,8(sp)
+ 314: e022 sd s0,0(sp)
+ 316: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 318: 00000097 auipc ra,0x0
+ 31c: f66080e7 jalr -154(ra) # 27e <memmove>
+}
+ 320: 60a2 ld ra,8(sp)
+ 322: 6402 ld s0,0(sp)
+ 324: 0141 addi sp,sp,16
+ 326: 8082 ret
+
+0000000000000328 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 328: 4885 li a7,1
+ ecall
+ 32a: 00000073 ecall
+ ret
+ 32e: 8082 ret
+
+0000000000000330 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 330: 05d00893 li a7,93
+ ecall
+ 334: 00000073 ecall
+ ret
+ 338: 8082 ret
+
+000000000000033a <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 33a: 488d li a7,3
+ ecall
+ 33c: 00000073 ecall
+ ret
+ 340: 8082 ret
+
+0000000000000342 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 342: 03b00893 li a7,59
+ ecall
+ 346: 00000073 ecall
+ ret
+ 34a: 8082 ret
+
+000000000000034c <read>:
+.global read
+read:
+ li a7, SYS_read
+ 34c: 03f00893 li a7,63
+ ecall
+ 350: 00000073 ecall
+ ret
+ 354: 8082 ret
+
+0000000000000356 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 356: 04000893 li a7,64
+ ecall
+ 35a: 00000073 ecall
+ ret
+ 35e: 8082 ret
+
+0000000000000360 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 360: 03900893 li a7,57
+ ecall
+ 364: 00000073 ecall
+ ret
+ 368: 8082 ret
+
+000000000000036a <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 36a: 4899 li a7,6
+ ecall
+ 36c: 00000073 ecall
+ ret
+ 370: 8082 ret
+
+0000000000000372 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 372: 0dd00893 li a7,221
+ ecall
+ 376: 00000073 ecall
+ ret
+ 37a: 8082 ret
+
+000000000000037c <open>:
+.global open
+open:
+ li a7, SYS_open
+ 37c: 03800893 li a7,56
+ ecall
+ 380: 00000073 ecall
+ ret
+ 384: 8082 ret
+
+0000000000000386 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 386: 05000893 li a7,80
+ ecall
+ 38a: 00000073 ecall
+ ret
+ 38e: 8082 ret
+
+0000000000000390 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 390: 02200893 li a7,34
+ ecall
+ 394: 00000073 ecall
+ ret
+ 398: 8082 ret
+
+000000000000039a <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 39a: 03100893 li a7,49
+ ecall
+ 39e: 00000073 ecall
+ ret
+ 3a2: 8082 ret
+
+00000000000003a4 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 3a4: 48dd li a7,23
+ ecall
+ 3a6: 00000073 ecall
+ ret
+ 3aa: 8082 ret
+
+00000000000003ac <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 3ac: 0ac00893 li a7,172
+ ecall
+ 3b0: 00000073 ecall
+ ret
+ 3b4: 8082 ret
+
+00000000000003b6 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 3b6: 48b1 li a7,12
+ ecall
+ 3b8: 00000073 ecall
+ ret
+ 3bc: 8082 ret
+
+00000000000003be <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3be: 48b5 li a7,13
+ ecall
+ 3c0: 00000073 ecall
+ ret
+ 3c4: 8082 ret
+
+00000000000003c6 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3c6: 48b9 li a7,14
+ ecall
+ 3c8: 00000073 ecall
+ ret
+ 3cc: 8082 ret
+
+00000000000003ce <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3ce: 48d9 li a7,22
+ ecall
+ 3d0: 00000073 ecall
+ ret
+ 3d4: 8082 ret
+
+00000000000003d6 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3d6: 03200893 li a7,50
+ ecall
+ 3da: 00000073 ecall
+ ret
+ 3de: 8082 ret
+
+00000000000003e0 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3e0: 48ed li a7,27
+ ecall
+ 3e2: 00000073 ecall
+ ret
+ 3e6: 8082 ret
+
+00000000000003e8 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3e8: 48c5 li a7,17
+ ecall
+ 3ea: 00000073 ecall
+ ret
+ 3ee: 8082 ret
+
+00000000000003f0 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3f0: 07500893 li a7,117
+ ecall
+ 3f4: 00000073 ecall
+ ret
+ 3f8: 8082 ret
+
+00000000000003fa <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3fa: 48c9 li a7,18
+ ecall
+ 3fc: 00000073 ecall
+ ret
+ 400: 8082 ret
+
+0000000000000402 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 402: 48cd li a7,19
+ ecall
+ 404: 00000073 ecall
+ ret
+ 408: 8082 ret
+
+000000000000040a <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 40a: 48e9 li a7,26
+ ecall
+ 40c: 00000073 ecall
+ ret
+ 410: 8082 ret
+
+0000000000000412 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 412: 0d200893 li a7,210
+ ecall
+ 416: 00000073 ecall
+ ret
+ 41a: 8082 ret
+
+000000000000041c <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 41c: 1101 addi sp,sp,-32
+ 41e: ec06 sd ra,24(sp)
+ 420: e822 sd s0,16(sp)
+ 422: 1000 addi s0,sp,32
+ 424: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 428: 4605 li a2,1
+ 42a: fef40593 addi a1,s0,-17
+ 42e: 00000097 auipc ra,0x0
+ 432: f28080e7 jalr -216(ra) # 356 <write>
+}
+ 436: 60e2 ld ra,24(sp)
+ 438: 6442 ld s0,16(sp)
+ 43a: 6105 addi sp,sp,32
+ 43c: 8082 ret
+
+000000000000043e <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 43e: 7139 addi sp,sp,-64
+ 440: fc06 sd ra,56(sp)
+ 442: f822 sd s0,48(sp)
+ 444: f426 sd s1,40(sp)
+ 446: f04a sd s2,32(sp)
+ 448: ec4e sd s3,24(sp)
+ 44a: 0080 addi s0,sp,64
+ 44c: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 44e: c299 beqz a3,454 <printint+0x16>
+ 450: 0805c863 bltz a1,4e0 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 454: 2581 sext.w a1,a1
+ neg = 0;
+ 456: 4881 li a7,0
+ }
+
+ i = 0;
+ 458: fc040993 addi s3,s0,-64
+ neg = 0;
+ 45c: 86ce mv a3,s3
+ i = 0;
+ 45e: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 460: 2601 sext.w a2,a2
+ 462: 00000517 auipc a0,0x0
+ 466: 4ce50513 addi a0,a0,1230 # 930 <digits>
+ 46a: 883a mv a6,a4
+ 46c: 2705 addiw a4,a4,1
+ 46e: 02c5f7bb remuw a5,a1,a2
+ 472: 1782 slli a5,a5,0x20
+ 474: 9381 srli a5,a5,0x20
+ 476: 97aa add a5,a5,a0
+ 478: 0007c783 lbu a5,0(a5)
+ 47c: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 480: 0005879b sext.w a5,a1
+ 484: 02c5d5bb divuw a1,a1,a2
+ 488: 0685 addi a3,a3,1
+ 48a: fec7f0e3 bgeu a5,a2,46a <printint+0x2c>
+ if(neg)
+ 48e: 00088c63 beqz a7,4a6 <printint+0x68>
+ buf[i++] = '-';
+ 492: fd070793 addi a5,a4,-48
+ 496: 00878733 add a4,a5,s0
+ 49a: 02d00793 li a5,45
+ 49e: fef70823 sb a5,-16(a4)
+ 4a2: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 4a6: 02e05663 blez a4,4d2 <printint+0x94>
+ 4aa: fc040913 addi s2,s0,-64
+ 4ae: 993a add s2,s2,a4
+ 4b0: 19fd addi s3,s3,-1
+ 4b2: 99ba add s3,s3,a4
+ 4b4: 377d addiw a4,a4,-1
+ 4b6: 1702 slli a4,a4,0x20
+ 4b8: 9301 srli a4,a4,0x20
+ 4ba: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4be: fff94583 lbu a1,-1(s2)
+ 4c2: 8526 mv a0,s1
+ 4c4: 00000097 auipc ra,0x0
+ 4c8: f58080e7 jalr -168(ra) # 41c <putc>
+ while(--i >= 0)
+ 4cc: 197d addi s2,s2,-1
+ 4ce: ff3918e3 bne s2,s3,4be <printint+0x80>
+}
+ 4d2: 70e2 ld ra,56(sp)
+ 4d4: 7442 ld s0,48(sp)
+ 4d6: 74a2 ld s1,40(sp)
+ 4d8: 7902 ld s2,32(sp)
+ 4da: 69e2 ld s3,24(sp)
+ 4dc: 6121 addi sp,sp,64
+ 4de: 8082 ret
+ x = -xx;
+ 4e0: 40b005bb negw a1,a1
+ neg = 1;
+ 4e4: 4885 li a7,1
+ x = -xx;
+ 4e6: bf8d j 458 <printint+0x1a>
+
+00000000000004e8 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4e8: 7119 addi sp,sp,-128
+ 4ea: fc86 sd ra,120(sp)
+ 4ec: f8a2 sd s0,112(sp)
+ 4ee: f4a6 sd s1,104(sp)
+ 4f0: f0ca sd s2,96(sp)
+ 4f2: ecce sd s3,88(sp)
+ 4f4: e8d2 sd s4,80(sp)
+ 4f6: e4d6 sd s5,72(sp)
+ 4f8: e0da sd s6,64(sp)
+ 4fa: fc5e sd s7,56(sp)
+ 4fc: f862 sd s8,48(sp)
+ 4fe: f466 sd s9,40(sp)
+ 500: f06a sd s10,32(sp)
+ 502: ec6e sd s11,24(sp)
+ 504: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 506: 0005c903 lbu s2,0(a1)
+ 50a: 18090f63 beqz s2,6a8 <vprintf+0x1c0>
+ 50e: 8aaa mv s5,a0
+ 510: 8b32 mv s6,a2
+ 512: 00158493 addi s1,a1,1
+ state = 0;
+ 516: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 518: 02500a13 li s4,37
+ 51c: 4c55 li s8,21
+ 51e: 00000c97 auipc s9,0x0
+ 522: 3bac8c93 addi s9,s9,954 # 8d8 <malloc+0x12c>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 526: 02800d93 li s11,40
+ putc(fd, 'x');
+ 52a: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 52c: 00000b97 auipc s7,0x0
+ 530: 404b8b93 addi s7,s7,1028 # 930 <digits>
+ 534: a839 j 552 <vprintf+0x6a>
+ putc(fd, c);
+ 536: 85ca mv a1,s2
+ 538: 8556 mv a0,s5
+ 53a: 00000097 auipc ra,0x0
+ 53e: ee2080e7 jalr -286(ra) # 41c <putc>
+ 542: a019 j 548 <vprintf+0x60>
+ } else if(state == '%'){
+ 544: 01498d63 beq s3,s4,55e <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 548: 0485 addi s1,s1,1
+ 54a: fff4c903 lbu s2,-1(s1)
+ 54e: 14090d63 beqz s2,6a8 <vprintf+0x1c0>
+ if(state == 0){
+ 552: fe0999e3 bnez s3,544 <vprintf+0x5c>
+ if(c == '%'){
+ 556: ff4910e3 bne s2,s4,536 <vprintf+0x4e>
+ state = '%';
+ 55a: 89d2 mv s3,s4
+ 55c: b7f5 j 548 <vprintf+0x60>
+ if(c == 'd'){
+ 55e: 11490c63 beq s2,s4,676 <vprintf+0x18e>
+ 562: f9d9079b addiw a5,s2,-99
+ 566: 0ff7f793 zext.b a5,a5
+ 56a: 10fc6e63 bltu s8,a5,686 <vprintf+0x19e>
+ 56e: f9d9079b addiw a5,s2,-99
+ 572: 0ff7f713 zext.b a4,a5
+ 576: 10ec6863 bltu s8,a4,686 <vprintf+0x19e>
+ 57a: 00271793 slli a5,a4,0x2
+ 57e: 97e6 add a5,a5,s9
+ 580: 439c lw a5,0(a5)
+ 582: 97e6 add a5,a5,s9
+ 584: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 586: 008b0913 addi s2,s6,8
+ 58a: 4685 li a3,1
+ 58c: 4629 li a2,10
+ 58e: 000b2583 lw a1,0(s6)
+ 592: 8556 mv a0,s5
+ 594: 00000097 auipc ra,0x0
+ 598: eaa080e7 jalr -342(ra) # 43e <printint>
+ 59c: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 59e: 4981 li s3,0
+ 5a0: b765 j 548 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 5a2: 008b0913 addi s2,s6,8
+ 5a6: 4681 li a3,0
+ 5a8: 4629 li a2,10
+ 5aa: 000b2583 lw a1,0(s6)
+ 5ae: 8556 mv a0,s5
+ 5b0: 00000097 auipc ra,0x0
+ 5b4: e8e080e7 jalr -370(ra) # 43e <printint>
+ 5b8: 8b4a mv s6,s2
+ state = 0;
+ 5ba: 4981 li s3,0
+ 5bc: b771 j 548 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5be: 008b0913 addi s2,s6,8
+ 5c2: 4681 li a3,0
+ 5c4: 866a mv a2,s10
+ 5c6: 000b2583 lw a1,0(s6)
+ 5ca: 8556 mv a0,s5
+ 5cc: 00000097 auipc ra,0x0
+ 5d0: e72080e7 jalr -398(ra) # 43e <printint>
+ 5d4: 8b4a mv s6,s2
+ state = 0;
+ 5d6: 4981 li s3,0
+ 5d8: bf85 j 548 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5da: 008b0793 addi a5,s6,8
+ 5de: f8f43423 sd a5,-120(s0)
+ 5e2: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5e6: 03000593 li a1,48
+ 5ea: 8556 mv a0,s5
+ 5ec: 00000097 auipc ra,0x0
+ 5f0: e30080e7 jalr -464(ra) # 41c <putc>
+ putc(fd, 'x');
+ 5f4: 07800593 li a1,120
+ 5f8: 8556 mv a0,s5
+ 5fa: 00000097 auipc ra,0x0
+ 5fe: e22080e7 jalr -478(ra) # 41c <putc>
+ 602: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 604: 03c9d793 srli a5,s3,0x3c
+ 608: 97de add a5,a5,s7
+ 60a: 0007c583 lbu a1,0(a5)
+ 60e: 8556 mv a0,s5
+ 610: 00000097 auipc ra,0x0
+ 614: e0c080e7 jalr -500(ra) # 41c <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 618: 0992 slli s3,s3,0x4
+ 61a: 397d addiw s2,s2,-1
+ 61c: fe0914e3 bnez s2,604 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 620: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 624: 4981 li s3,0
+ 626: b70d j 548 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 628: 008b0913 addi s2,s6,8
+ 62c: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 630: 02098163 beqz s3,652 <vprintf+0x16a>
+ while(*s != 0){
+ 634: 0009c583 lbu a1,0(s3)
+ 638: c5ad beqz a1,6a2 <vprintf+0x1ba>
+ putc(fd, *s);
+ 63a: 8556 mv a0,s5
+ 63c: 00000097 auipc ra,0x0
+ 640: de0080e7 jalr -544(ra) # 41c <putc>
+ s++;
+ 644: 0985 addi s3,s3,1
+ while(*s != 0){
+ 646: 0009c583 lbu a1,0(s3)
+ 64a: f9e5 bnez a1,63a <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 64c: 8b4a mv s6,s2
+ state = 0;
+ 64e: 4981 li s3,0
+ 650: bde5 j 548 <vprintf+0x60>
+ s = "(null)";
+ 652: 00000997 auipc s3,0x0
+ 656: 27e98993 addi s3,s3,638 # 8d0 <malloc+0x124>
+ while(*s != 0){
+ 65a: 85ee mv a1,s11
+ 65c: bff9 j 63a <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 65e: 008b0913 addi s2,s6,8
+ 662: 000b4583 lbu a1,0(s6)
+ 666: 8556 mv a0,s5
+ 668: 00000097 auipc ra,0x0
+ 66c: db4080e7 jalr -588(ra) # 41c <putc>
+ 670: 8b4a mv s6,s2
+ state = 0;
+ 672: 4981 li s3,0
+ 674: bdd1 j 548 <vprintf+0x60>
+ putc(fd, c);
+ 676: 85d2 mv a1,s4
+ 678: 8556 mv a0,s5
+ 67a: 00000097 auipc ra,0x0
+ 67e: da2080e7 jalr -606(ra) # 41c <putc>
+ state = 0;
+ 682: 4981 li s3,0
+ 684: b5d1 j 548 <vprintf+0x60>
+ putc(fd, '%');
+ 686: 85d2 mv a1,s4
+ 688: 8556 mv a0,s5
+ 68a: 00000097 auipc ra,0x0
+ 68e: d92080e7 jalr -622(ra) # 41c <putc>
+ putc(fd, c);
+ 692: 85ca mv a1,s2
+ 694: 8556 mv a0,s5
+ 696: 00000097 auipc ra,0x0
+ 69a: d86080e7 jalr -634(ra) # 41c <putc>
+ state = 0;
+ 69e: 4981 li s3,0
+ 6a0: b565 j 548 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6a2: 8b4a mv s6,s2
+ state = 0;
+ 6a4: 4981 li s3,0
+ 6a6: b54d j 548 <vprintf+0x60>
+ }
+ }
+}
+ 6a8: 70e6 ld ra,120(sp)
+ 6aa: 7446 ld s0,112(sp)
+ 6ac: 74a6 ld s1,104(sp)
+ 6ae: 7906 ld s2,96(sp)
+ 6b0: 69e6 ld s3,88(sp)
+ 6b2: 6a46 ld s4,80(sp)
+ 6b4: 6aa6 ld s5,72(sp)
+ 6b6: 6b06 ld s6,64(sp)
+ 6b8: 7be2 ld s7,56(sp)
+ 6ba: 7c42 ld s8,48(sp)
+ 6bc: 7ca2 ld s9,40(sp)
+ 6be: 7d02 ld s10,32(sp)
+ 6c0: 6de2 ld s11,24(sp)
+ 6c2: 6109 addi sp,sp,128
+ 6c4: 8082 ret
+
+00000000000006c6 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6c6: 715d addi sp,sp,-80
+ 6c8: ec06 sd ra,24(sp)
+ 6ca: e822 sd s0,16(sp)
+ 6cc: 1000 addi s0,sp,32
+ 6ce: e010 sd a2,0(s0)
+ 6d0: e414 sd a3,8(s0)
+ 6d2: e818 sd a4,16(s0)
+ 6d4: ec1c sd a5,24(s0)
+ 6d6: 03043023 sd a6,32(s0)
+ 6da: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6de: 8622 mv a2,s0
+ 6e0: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6e4: 00000097 auipc ra,0x0
+ 6e8: e04080e7 jalr -508(ra) # 4e8 <vprintf>
+}
+ 6ec: 60e2 ld ra,24(sp)
+ 6ee: 6442 ld s0,16(sp)
+ 6f0: 6161 addi sp,sp,80
+ 6f2: 8082 ret
+
+00000000000006f4 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6f4: 711d addi sp,sp,-96
+ 6f6: ec06 sd ra,24(sp)
+ 6f8: e822 sd s0,16(sp)
+ 6fa: 1000 addi s0,sp,32
+ 6fc: e40c sd a1,8(s0)
+ 6fe: e810 sd a2,16(s0)
+ 700: ec14 sd a3,24(s0)
+ 702: f018 sd a4,32(s0)
+ 704: f41c sd a5,40(s0)
+ 706: 03043823 sd a6,48(s0)
+ 70a: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 70e: 00840613 addi a2,s0,8
+ 712: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 716: 85aa mv a1,a0
+ 718: 4505 li a0,1
+ 71a: 00000097 auipc ra,0x0
+ 71e: dce080e7 jalr -562(ra) # 4e8 <vprintf>
+}
+ 722: 60e2 ld ra,24(sp)
+ 724: 6442 ld s0,16(sp)
+ 726: 6125 addi sp,sp,96
+ 728: 8082 ret
+
+000000000000072a <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 72a: 1141 addi sp,sp,-16
+ 72c: e422 sd s0,8(sp)
+ 72e: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 730: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 734: 00000797 auipc a5,0x0
+ 738: 2147b783 ld a5,532(a5) # 948 <freep>
+ 73c: a02d j 766 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 73e: 4618 lw a4,8(a2)
+ 740: 9f2d addw a4,a4,a1
+ 742: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 746: 6398 ld a4,0(a5)
+ 748: 6310 ld a2,0(a4)
+ 74a: a83d j 788 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 74c: ff852703 lw a4,-8(a0)
+ 750: 9f31 addw a4,a4,a2
+ 752: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 754: ff053683 ld a3,-16(a0)
+ 758: a091 j 79c <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 75a: 6398 ld a4,0(a5)
+ 75c: 00e7e463 bltu a5,a4,764 <free+0x3a>
+ 760: 00e6ea63 bltu a3,a4,774 <free+0x4a>
+{
+ 764: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 766: fed7fae3 bgeu a5,a3,75a <free+0x30>
+ 76a: 6398 ld a4,0(a5)
+ 76c: 00e6e463 bltu a3,a4,774 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 770: fee7eae3 bltu a5,a4,764 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 774: ff852583 lw a1,-8(a0)
+ 778: 6390 ld a2,0(a5)
+ 77a: 02059813 slli a6,a1,0x20
+ 77e: 01c85713 srli a4,a6,0x1c
+ 782: 9736 add a4,a4,a3
+ 784: fae60de3 beq a2,a4,73e <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 788: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 78c: 4790 lw a2,8(a5)
+ 78e: 02061593 slli a1,a2,0x20
+ 792: 01c5d713 srli a4,a1,0x1c
+ 796: 973e add a4,a4,a5
+ 798: fae68ae3 beq a3,a4,74c <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 79c: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 79e: 00000717 auipc a4,0x0
+ 7a2: 1af73523 sd a5,426(a4) # 948 <freep>
+}
+ 7a6: 6422 ld s0,8(sp)
+ 7a8: 0141 addi sp,sp,16
+ 7aa: 8082 ret
+
+00000000000007ac <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 7ac: 7139 addi sp,sp,-64
+ 7ae: fc06 sd ra,56(sp)
+ 7b0: f822 sd s0,48(sp)
+ 7b2: f426 sd s1,40(sp)
+ 7b4: f04a sd s2,32(sp)
+ 7b6: ec4e sd s3,24(sp)
+ 7b8: e852 sd s4,16(sp)
+ 7ba: e456 sd s5,8(sp)
+ 7bc: e05a sd s6,0(sp)
+ 7be: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7c0: 02051493 slli s1,a0,0x20
+ 7c4: 9081 srli s1,s1,0x20
+ 7c6: 04bd addi s1,s1,15
+ 7c8: 8091 srli s1,s1,0x4
+ 7ca: 00148a1b addiw s4,s1,1
+ 7ce: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7d0: 00000517 auipc a0,0x0
+ 7d4: 17853503 ld a0,376(a0) # 948 <freep>
+ 7d8: c515 beqz a0,804 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7da: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7dc: 4798 lw a4,8(a5)
+ 7de: 04977163 bgeu a4,s1,820 <malloc+0x74>
+ 7e2: 89d2 mv s3,s4
+ 7e4: 000a071b sext.w a4,s4
+ 7e8: 6685 lui a3,0x1
+ 7ea: 00d77363 bgeu a4,a3,7f0 <malloc+0x44>
+ 7ee: 6985 lui s3,0x1
+ 7f0: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7f4: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7f8: 00000917 auipc s2,0x0
+ 7fc: 15090913 addi s2,s2,336 # 948 <freep>
+ if(p == (char*)-1)
+ 800: 5afd li s5,-1
+ 802: a8a5 j 87a <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 804: 00000797 auipc a5,0x0
+ 808: 14478793 addi a5,a5,324 # 948 <freep>
+ 80c: 00000717 auipc a4,0x0
+ 810: 14470713 addi a4,a4,324 # 950 <base>
+ 814: e398 sd a4,0(a5)
+ 816: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 818: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 81c: 87ba mv a5,a4
+ 81e: b7d1 j 7e2 <malloc+0x36>
+ if(p->s.size == nunits)
+ 820: 02e48c63 beq s1,a4,858 <malloc+0xac>
+ p->s.size -= nunits;
+ 824: 4147073b subw a4,a4,s4
+ 828: c798 sw a4,8(a5)
+ p += p->s.size;
+ 82a: 02071693 slli a3,a4,0x20
+ 82e: 01c6d713 srli a4,a3,0x1c
+ 832: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 834: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 838: 00000717 auipc a4,0x0
+ 83c: 10a73823 sd a0,272(a4) # 948 <freep>
+ return (void*)(p + 1);
+ 840: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 844: 70e2 ld ra,56(sp)
+ 846: 7442 ld s0,48(sp)
+ 848: 74a2 ld s1,40(sp)
+ 84a: 7902 ld s2,32(sp)
+ 84c: 69e2 ld s3,24(sp)
+ 84e: 6a42 ld s4,16(sp)
+ 850: 6aa2 ld s5,8(sp)
+ 852: 6b02 ld s6,0(sp)
+ 854: 6121 addi sp,sp,64
+ 856: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 858: 6398 ld a4,0(a5)
+ 85a: e118 sd a4,0(a0)
+ 85c: bff1 j 838 <malloc+0x8c>
+ hp->s.size = nu;
+ 85e: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 862: 0541 addi a0,a0,16
+ 864: 00000097 auipc ra,0x0
+ 868: ec6080e7 jalr -314(ra) # 72a <free>
+ return freep;
+ 86c: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 870: d971 beqz a0,844 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 872: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 874: 4798 lw a4,8(a5)
+ 876: fa9775e3 bgeu a4,s1,820 <malloc+0x74>
+ if(p == freep)
+ 87a: 00093703 ld a4,0(s2)
+ 87e: 853e mv a0,a5
+ 880: fef719e3 bne a4,a5,872 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 884: 854e mv a0,s3
+ 886: 00000097 auipc ra,0x0
+ 88a: b30080e7 jalr -1232(ra) # 3b6 <sbrk>
+ if(p == (char*)-1)
+ 88e: fd5518e3 bne a0,s5,85e <malloc+0xb2>
+ return 0;
+ 892: 4501 li a0,0
+ 894: bf45 j 844 <malloc+0x98>
diff --git a/xv6-user/mkdir.c b/xv6-user/mkdir.c
new file mode 100644
index 0000000000000000000000000000000000000000..86f7a094cd66e1895c15e5a0aac0c966cae3472a
--- /dev/null
+++ b/xv6-user/mkdir.c
@@ -0,0 +1,23 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+
+ if(argc < 2){
+ fprintf(2, "Usage: mkdir files...\n");
+ exit(1);
+ }
+
+ for(i = 1; i < argc; i++){
+ if(mkdir(argv[i]) < 0){
+ fprintf(2, "mkdir: %s failed to create\n", argv[i]);
+ break;
+ }
+ }
+
+ exit(0);
+}
diff --git a/xv6-user/mkdir.d b/xv6-user/mkdir.d
new file mode 100644
index 0000000000000000000000000000000000000000..0b5064af0e804f9410f848d4eb974b392bf7cdf3
--- /dev/null
+++ b/xv6-user/mkdir.d
@@ -0,0 +1,2 @@
+xv6-user/mkdir.o: xv6-user/mkdir.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/mkdir.o b/xv6-user/mkdir.o
new file mode 100644
index 0000000000000000000000000000000000000000..90ad3ecc02ddce9024c90f4b6c54b779db29ab27
Binary files /dev/null and b/xv6-user/mkdir.o differ
diff --git a/xv6-user/mkdir.sym b/xv6-user/mkdir.sym
new file mode 100644
index 0000000000000000000000000000000000000000..9b71bf6fbb28f7c2b74ca5b8f5ae33a58b6d7fe6
--- /dev/null
+++ b/xv6-user/mkdir.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+0000000000000898 .rodata
+0000000000000948 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 mkdir.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+000000000000041c putc
+000000000000043e printint
+0000000000000930 digits
+0000000000000000 umalloc.c
+0000000000000948 freep
+0000000000000950 base
+0000000000000078 strcpy
+00000000000006f4 printf
+0000000000001141 __global_pointer$
+00000000000003d6 dev
+000000000000027e memmove
+00000000000003fa trace
+000000000000015e gets
+0000000000000941 __SDATA_BEGIN__
+00000000000003ac getpid
+0000000000000310 memcpy
+00000000000007ac malloc
+00000000000003f0 remove
+00000000000003be sleep
+0000000000000402 sysinfo
+00000000000003e0 readdir
+0000000000000342 pipe
+000000000000040a rename
+0000000000000356 write
+0000000000000386 fstat
+00000000000006c6 fprintf
+000000000000036a kill
+0000000000000094 strcat
+00000000000004e8 vprintf
+000000000000039a chdir
+0000000000000372 exec
+000000000000033a wait
+000000000000034c read
+00000000000002d6 memcmp
+0000000000000328 fork
+0000000000000960 __BSS_END__
+00000000000003b6 sbrk
+00000000000003ce test_proc
+00000000000003c6 uptime
+0000000000000941 __bss_start
+0000000000000118 memset
+0000000000000000 main
+00000000000000c2 strcmp
+0000000000000412 shutdown
+00000000000003a4 dup
+00000000000003e8 getcwd
+0000000000000941 __DATA_BEGIN__
+00000000000001d8 stat
+0000000000000941 _edata
+0000000000000960 _end
+0000000000000330 exit
+000000000000021e atoi
+00000000000000ee strlen
+000000000000037c open
+000000000000013a strchr
+0000000000000390 mkdir
+0000000000000360 close
+000000000000072a free
diff --git a/xv6-user/mv.asm b/xv6-user/mv.asm
new file mode 100644
index 0000000000000000000000000000000000000000..802866423db066174d833dd6fae6d0aab1fecb36
--- /dev/null
+++ b/xv6-user/mv.asm
@@ -0,0 +1,1569 @@
+
+xv6-user/_mv: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/fcntl.h"
+#include "kernel/include/param.h"
+#include "xv6-user/user.h"
+
+int main(int argc, char *argv[])
+{
+ 0: d9010113 addi sp,sp,-624
+ 4: 26113423 sd ra,616(sp)
+ 8: 26813023 sd s0,608(sp)
+ c: 24913c23 sd s1,600(sp)
+ 10: 25213823 sd s2,592(sp)
+ 14: 1c80 addi s0,sp,624
+ if (argc < 3) {
+ 16: 4789 li a5,2
+ 18: 02a7c063 blt a5,a0,38 <main+0x38>
+ fprintf(2, "Usage: mv old_name new_name\n");
+ 1c: 00001597 auipc a1,0x1
+ 20: 9ac58593 addi a1,a1,-1620 # 9c8 <malloc+0xea>
+ 24: 4509 li a0,2
+ 26: 00000097 auipc ra,0x0
+ 2a: 7d2080e7 jalr 2002(ra) # 7f8 <fprintf>
+ exit(1);
+ 2e: 4505 li a0,1
+ 30: 00000097 auipc ra,0x0
+ 34: 432080e7 jalr 1074(ra) # 462 <exit>
+ 38: 84ae mv s1,a1
+ }
+
+ char src[MAXPATH];
+ char dst[MAXPATH];
+ strcpy(src, argv[1]);
+ 3a: 658c ld a1,8(a1)
+ 3c: ed840513 addi a0,s0,-296
+ 40: 00000097 auipc ra,0x0
+ 44: 16a080e7 jalr 362(ra) # 1aa <strcpy>
+ strcpy(dst, argv[2]);
+ 48: 688c ld a1,16(s1)
+ 4a: dd040493 addi s1,s0,-560
+ 4e: 8526 mv a0,s1
+ 50: 00000097 auipc ra,0x0
+ 54: 15a080e7 jalr 346(ra) # 1aa <strcpy>
+ int fd = open(dst, O_RDONLY);
+ 58: 4581 li a1,0
+ 5a: 8526 mv a0,s1
+ 5c: 00000097 auipc ra,0x0
+ 60: 452080e7 jalr 1106(ra) # 4ae <open>
+ 64: 84aa mv s1,a0
+ if (fd >= 0) {
+ 66: 0e054763 bltz a0,154 <main+0x154>
+ struct stat st;
+ fstat(fd, &st);
+ 6a: d9840593 addi a1,s0,-616
+ 6e: 00000097 auipc ra,0x0
+ 72: 44a080e7 jalr 1098(ra) # 4b8 <fstat>
+ close(fd);
+ 76: 8526 mv a0,s1
+ 78: 00000097 auipc ra,0x0
+ 7c: 41a080e7 jalr 1050(ra) # 492 <close>
+ if (st.type == T_DIR) {
+ 80: dc041703 lh a4,-576(s0)
+ 84: 4785 li a5,1
+ 86: 02f70263 beq a4,a5,aa <main+0xaa>
+ fprintf(2, "mv: fail! final dst path too long (exceed MAX=%d)!\n", MAXPATH);
+ exit(-1);
+ }
+ }
+ } else {
+ fprintf(2, "mv: fail! %s exists!\n", dst);
+ 8a: dd040613 addi a2,s0,-560
+ 8e: 00001597 auipc a1,0x1
+ 92: 99258593 addi a1,a1,-1646 # a20 <malloc+0x142>
+ 96: 4509 li a0,2
+ 98: 00000097 auipc ra,0x0
+ 9c: 760080e7 jalr 1888(ra) # 7f8 <fprintf>
+ exit(-1);
+ a0: 557d li a0,-1
+ a2: 00000097 auipc ra,0x0
+ a6: 3c0080e7 jalr 960(ra) # 462 <exit>
+ for (ps = src + strlen(src) - 1; ps >= src; ps--) { // trim '/' in tail
+ aa: ed840493 addi s1,s0,-296
+ ae: 8526 mv a0,s1
+ b0: 00000097 auipc ra,0x0
+ b4: 170080e7 jalr 368(ra) # 220 <strlen>
+ b8: 02051793 slli a5,a0,0x20
+ bc: 9381 srli a5,a5,0x20
+ be: 17fd addi a5,a5,-1
+ c0: 97a6 add a5,a5,s1
+ c2: 0297ec63 bltu a5,s1,fa <main+0xfa>
+ if (*ps != '/') {
+ c6: 02f00693 li a3,47
+ for (ps = src + strlen(src) - 1; ps >= src; ps--) { // trim '/' in tail
+ ca: 8626 mv a2,s1
+ if (*ps != '/') {
+ cc: 0007c703 lbu a4,0(a5)
+ d0: 00d71663 bne a4,a3,dc <main+0xdc>
+ for (ps = src + strlen(src) - 1; ps >= src; ps--) { // trim '/' in tail
+ d4: 17fd addi a5,a5,-1
+ d6: fec7fbe3 bgeu a5,a2,cc <main+0xcc>
+ da: a005 j fa <main+0xfa>
+ *(ps + 1) = '\0';
+ dc: 000780a3 sb zero,1(a5)
+ for (; ps >= src && *ps != '/'; ps--);
+ e0: 02f00693 li a3,47
+ e4: ed840613 addi a2,s0,-296
+ e8: 00c7e963 bltu a5,a2,fa <main+0xfa>
+ ec: 0007c703 lbu a4,0(a5)
+ f0: 00d70563 beq a4,a3,fa <main+0xfa>
+ f4: 17fd addi a5,a5,-1
+ f6: fec7fbe3 bgeu a5,a2,ec <main+0xec>
+ ps++;
+ fa: 00178493 addi s1,a5,1
+ pd = dst + strlen(dst);
+ fe: dd040913 addi s2,s0,-560
+ 102: 854a mv a0,s2
+ 104: 00000097 auipc ra,0x0
+ 108: 11c080e7 jalr 284(ra) # 220 <strlen>
+ 10c: 1502 slli a0,a0,0x20
+ 10e: 9101 srli a0,a0,0x20
+ 110: 992a add s2,s2,a0
+ *pd++ = '/';
+ 112: 00190793 addi a5,s2,1
+ 116: 02f00713 li a4,47
+ 11a: 00e90023 sb a4,0(s2)
+ if (pd >= dst + MAXPATH) {
+ 11e: ed440693 addi a3,s0,-300
+ while (*ps) {
+ 122: 0004c703 lbu a4,0(s1)
+ 126: c71d beqz a4,154 <main+0x154>
+ *pd++ = *ps++;
+ 128: 0485 addi s1,s1,1
+ 12a: 0785 addi a5,a5,1
+ 12c: fee78fa3 sb a4,-1(a5)
+ if (pd >= dst + MAXPATH) {
+ 130: fed7e9e3 bltu a5,a3,122 <main+0x122>
+ fprintf(2, "mv: fail! final dst path too long (exceed MAX=%d)!\n", MAXPATH);
+ 134: 10400613 li a2,260
+ 138: 00001597 auipc a1,0x1
+ 13c: 8b058593 addi a1,a1,-1872 # 9e8 <malloc+0x10a>
+ 140: 4509 li a0,2
+ 142: 00000097 auipc ra,0x0
+ 146: 6b6080e7 jalr 1718(ra) # 7f8 <fprintf>
+ exit(-1);
+ 14a: 557d li a0,-1
+ 14c: 00000097 auipc ra,0x0
+ 150: 316080e7 jalr 790(ra) # 462 <exit>
+ }
+ }
+ printf("moving [%s] to [%s]\n", src, dst);
+ 154: dd040913 addi s2,s0,-560
+ 158: 864a mv a2,s2
+ 15a: ed840493 addi s1,s0,-296
+ 15e: 85a6 mv a1,s1
+ 160: 00001517 auipc a0,0x1
+ 164: 8d850513 addi a0,a0,-1832 # a38 <malloc+0x15a>
+ 168: 00000097 auipc ra,0x0
+ 16c: 6be080e7 jalr 1726(ra) # 826 <printf>
+ if (rename(src, dst) < 0) {
+ 170: 85ca mv a1,s2
+ 172: 8526 mv a0,s1
+ 174: 00000097 auipc ra,0x0
+ 178: 3c8080e7 jalr 968(ra) # 53c <rename>
+ 17c: 00054763 bltz a0,18a <main+0x18a>
+ fprintf(2, "mv: fail to rename %s to %s!\n", src, dst);
+ exit(-1);
+ }
+ exit(0);
+ 180: 4501 li a0,0
+ 182: 00000097 auipc ra,0x0
+ 186: 2e0080e7 jalr 736(ra) # 462 <exit>
+ fprintf(2, "mv: fail to rename %s to %s!\n", src, dst);
+ 18a: 86ca mv a3,s2
+ 18c: 8626 mv a2,s1
+ 18e: 00001597 auipc a1,0x1
+ 192: 8c258593 addi a1,a1,-1854 # a50 <malloc+0x172>
+ 196: 4509 li a0,2
+ 198: 00000097 auipc ra,0x0
+ 19c: 660080e7 jalr 1632(ra) # 7f8 <fprintf>
+ exit(-1);
+ 1a0: 557d li a0,-1
+ 1a2: 00000097 auipc ra,0x0
+ 1a6: 2c0080e7 jalr 704(ra) # 462 <exit>
+
+00000000000001aa <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 1aa: 1141 addi sp,sp,-16
+ 1ac: e422 sd s0,8(sp)
+ 1ae: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 1b0: 87aa mv a5,a0
+ 1b2: 0585 addi a1,a1,1
+ 1b4: 0785 addi a5,a5,1
+ 1b6: fff5c703 lbu a4,-1(a1)
+ 1ba: fee78fa3 sb a4,-1(a5)
+ 1be: fb75 bnez a4,1b2 <strcpy+0x8>
+ ;
+ return os;
+}
+ 1c0: 6422 ld s0,8(sp)
+ 1c2: 0141 addi sp,sp,16
+ 1c4: 8082 ret
+
+00000000000001c6 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 1c6: 1141 addi sp,sp,-16
+ 1c8: e422 sd s0,8(sp)
+ 1ca: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 1cc: 00054783 lbu a5,0(a0)
+ 1d0: c385 beqz a5,1f0 <strcat+0x2a>
+ 1d2: 87aa mv a5,a0
+ s++;
+ 1d4: 0785 addi a5,a5,1
+ while(*s)
+ 1d6: 0007c703 lbu a4,0(a5)
+ 1da: ff6d bnez a4,1d4 <strcat+0xe>
+ while((*s++ = *t++))
+ 1dc: 0585 addi a1,a1,1
+ 1de: 0785 addi a5,a5,1
+ 1e0: fff5c703 lbu a4,-1(a1)
+ 1e4: fee78fa3 sb a4,-1(a5)
+ 1e8: fb75 bnez a4,1dc <strcat+0x16>
+ ;
+ return os;
+}
+ 1ea: 6422 ld s0,8(sp)
+ 1ec: 0141 addi sp,sp,16
+ 1ee: 8082 ret
+ while(*s)
+ 1f0: 87aa mv a5,a0
+ 1f2: b7ed j 1dc <strcat+0x16>
+
+00000000000001f4 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 1f4: 1141 addi sp,sp,-16
+ 1f6: e422 sd s0,8(sp)
+ 1f8: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 1fa: 00054783 lbu a5,0(a0)
+ 1fe: cb91 beqz a5,212 <strcmp+0x1e>
+ 200: 0005c703 lbu a4,0(a1)
+ 204: 00f71763 bne a4,a5,212 <strcmp+0x1e>
+ p++, q++;
+ 208: 0505 addi a0,a0,1
+ 20a: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 20c: 00054783 lbu a5,0(a0)
+ 210: fbe5 bnez a5,200 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 212: 0005c503 lbu a0,0(a1)
+}
+ 216: 40a7853b subw a0,a5,a0
+ 21a: 6422 ld s0,8(sp)
+ 21c: 0141 addi sp,sp,16
+ 21e: 8082 ret
+
+0000000000000220 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 220: 1141 addi sp,sp,-16
+ 222: e422 sd s0,8(sp)
+ 224: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 226: 00054783 lbu a5,0(a0)
+ 22a: cf91 beqz a5,246 <strlen+0x26>
+ 22c: 0505 addi a0,a0,1
+ 22e: 87aa mv a5,a0
+ 230: 4685 li a3,1
+ 232: 9e89 subw a3,a3,a0
+ 234: 00f6853b addw a0,a3,a5
+ 238: 0785 addi a5,a5,1
+ 23a: fff7c703 lbu a4,-1(a5)
+ 23e: fb7d bnez a4,234 <strlen+0x14>
+ ;
+ return n;
+}
+ 240: 6422 ld s0,8(sp)
+ 242: 0141 addi sp,sp,16
+ 244: 8082 ret
+ for(n = 0; s[n]; n++)
+ 246: 4501 li a0,0
+ 248: bfe5 j 240 <strlen+0x20>
+
+000000000000024a <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 24a: 1141 addi sp,sp,-16
+ 24c: e422 sd s0,8(sp)
+ 24e: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 250: ca19 beqz a2,266 <memset+0x1c>
+ 252: 87aa mv a5,a0
+ 254: 1602 slli a2,a2,0x20
+ 256: 9201 srli a2,a2,0x20
+ 258: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 25c: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 260: 0785 addi a5,a5,1
+ 262: fee79de3 bne a5,a4,25c <memset+0x12>
+ }
+ return dst;
+}
+ 266: 6422 ld s0,8(sp)
+ 268: 0141 addi sp,sp,16
+ 26a: 8082 ret
+
+000000000000026c <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 26c: 1141 addi sp,sp,-16
+ 26e: e422 sd s0,8(sp)
+ 270: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 272: 00054783 lbu a5,0(a0)
+ 276: cb99 beqz a5,28c <strchr+0x20>
+ if(*s == c)
+ 278: 00f58763 beq a1,a5,286 <strchr+0x1a>
+ for(; *s; s++)
+ 27c: 0505 addi a0,a0,1
+ 27e: 00054783 lbu a5,0(a0)
+ 282: fbfd bnez a5,278 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 284: 4501 li a0,0
+}
+ 286: 6422 ld s0,8(sp)
+ 288: 0141 addi sp,sp,16
+ 28a: 8082 ret
+ return 0;
+ 28c: 4501 li a0,0
+ 28e: bfe5 j 286 <strchr+0x1a>
+
+0000000000000290 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 290: 711d addi sp,sp,-96
+ 292: ec86 sd ra,88(sp)
+ 294: e8a2 sd s0,80(sp)
+ 296: e4a6 sd s1,72(sp)
+ 298: e0ca sd s2,64(sp)
+ 29a: fc4e sd s3,56(sp)
+ 29c: f852 sd s4,48(sp)
+ 29e: f456 sd s5,40(sp)
+ 2a0: f05a sd s6,32(sp)
+ 2a2: ec5e sd s7,24(sp)
+ 2a4: e862 sd s8,16(sp)
+ 2a6: 1080 addi s0,sp,96
+ 2a8: 8baa mv s7,a0
+ 2aa: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 2ac: 892a mv s2,a0
+ 2ae: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 2b0: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 2b4: 4b29 li s6,10
+ 2b6: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 2b8: 89a6 mv s3,s1
+ 2ba: 2485 addiw s1,s1,1
+ 2bc: 0344d763 bge s1,s4,2ea <gets+0x5a>
+ cc = read(0, &c, 1);
+ 2c0: 4605 li a2,1
+ 2c2: 85d6 mv a1,s5
+ 2c4: 4501 li a0,0
+ 2c6: 00000097 auipc ra,0x0
+ 2ca: 1b8080e7 jalr 440(ra) # 47e <read>
+ if(cc < 1)
+ 2ce: 00a05e63 blez a0,2ea <gets+0x5a>
+ buf[i++] = c;
+ 2d2: faf44783 lbu a5,-81(s0)
+ 2d6: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 2da: 01678763 beq a5,s6,2e8 <gets+0x58>
+ 2de: 0905 addi s2,s2,1
+ 2e0: fd879ce3 bne a5,s8,2b8 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 2e4: 89a6 mv s3,s1
+ 2e6: a011 j 2ea <gets+0x5a>
+ 2e8: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 2ea: 99de add s3,s3,s7
+ 2ec: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 2f0: 855e mv a0,s7
+ 2f2: 60e6 ld ra,88(sp)
+ 2f4: 6446 ld s0,80(sp)
+ 2f6: 64a6 ld s1,72(sp)
+ 2f8: 6906 ld s2,64(sp)
+ 2fa: 79e2 ld s3,56(sp)
+ 2fc: 7a42 ld s4,48(sp)
+ 2fe: 7aa2 ld s5,40(sp)
+ 300: 7b02 ld s6,32(sp)
+ 302: 6be2 ld s7,24(sp)
+ 304: 6c42 ld s8,16(sp)
+ 306: 6125 addi sp,sp,96
+ 308: 8082 ret
+
+000000000000030a <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 30a: 1101 addi sp,sp,-32
+ 30c: ec06 sd ra,24(sp)
+ 30e: e822 sd s0,16(sp)
+ 310: e426 sd s1,8(sp)
+ 312: e04a sd s2,0(sp)
+ 314: 1000 addi s0,sp,32
+ 316: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 318: 4581 li a1,0
+ 31a: 00000097 auipc ra,0x0
+ 31e: 194080e7 jalr 404(ra) # 4ae <open>
+ if(fd < 0)
+ 322: 02054563 bltz a0,34c <stat+0x42>
+ 326: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 328: 85ca mv a1,s2
+ 32a: 00000097 auipc ra,0x0
+ 32e: 18e080e7 jalr 398(ra) # 4b8 <fstat>
+ 332: 892a mv s2,a0
+ close(fd);
+ 334: 8526 mv a0,s1
+ 336: 00000097 auipc ra,0x0
+ 33a: 15c080e7 jalr 348(ra) # 492 <close>
+ return r;
+}
+ 33e: 854a mv a0,s2
+ 340: 60e2 ld ra,24(sp)
+ 342: 6442 ld s0,16(sp)
+ 344: 64a2 ld s1,8(sp)
+ 346: 6902 ld s2,0(sp)
+ 348: 6105 addi sp,sp,32
+ 34a: 8082 ret
+ return -1;
+ 34c: 597d li s2,-1
+ 34e: bfc5 j 33e <stat+0x34>
+
+0000000000000350 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 350: 1141 addi sp,sp,-16
+ 352: e422 sd s0,8(sp)
+ 354: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 356: 00054703 lbu a4,0(a0)
+ 35a: 02d00793 li a5,45
+ int neg = 1;
+ 35e: 4585 li a1,1
+ if (*s == '-') {
+ 360: 04f70363 beq a4,a5,3a6 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 364: 00054703 lbu a4,0(a0)
+ 368: fd07079b addiw a5,a4,-48
+ 36c: 0ff7f793 zext.b a5,a5
+ 370: 46a5 li a3,9
+ 372: 02f6ed63 bltu a3,a5,3ac <atoi+0x5c>
+ n = 0;
+ 376: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 378: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 37a: 0505 addi a0,a0,1
+ 37c: 0026979b slliw a5,a3,0x2
+ 380: 9fb5 addw a5,a5,a3
+ 382: 0017979b slliw a5,a5,0x1
+ 386: 9fb9 addw a5,a5,a4
+ 388: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 38c: 00054703 lbu a4,0(a0)
+ 390: fd07079b addiw a5,a4,-48
+ 394: 0ff7f793 zext.b a5,a5
+ 398: fef671e3 bgeu a2,a5,37a <atoi+0x2a>
+ return n * neg;
+}
+ 39c: 02d5853b mulw a0,a1,a3
+ 3a0: 6422 ld s0,8(sp)
+ 3a2: 0141 addi sp,sp,16
+ 3a4: 8082 ret
+ s++;
+ 3a6: 0505 addi a0,a0,1
+ neg = -1;
+ 3a8: 55fd li a1,-1
+ 3aa: bf6d j 364 <atoi+0x14>
+ n = 0;
+ 3ac: 4681 li a3,0
+ 3ae: b7fd j 39c <atoi+0x4c>
+
+00000000000003b0 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 3b0: 1141 addi sp,sp,-16
+ 3b2: e422 sd s0,8(sp)
+ 3b4: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 3b6: 02b57463 bgeu a0,a1,3de <memmove+0x2e>
+ while(n-- > 0)
+ 3ba: 00c05f63 blez a2,3d8 <memmove+0x28>
+ 3be: 1602 slli a2,a2,0x20
+ 3c0: 9201 srli a2,a2,0x20
+ 3c2: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 3c6: 872a mv a4,a0
+ *dst++ = *src++;
+ 3c8: 0585 addi a1,a1,1
+ 3ca: 0705 addi a4,a4,1
+ 3cc: fff5c683 lbu a3,-1(a1)
+ 3d0: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 3d4: fee79ae3 bne a5,a4,3c8 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 3d8: 6422 ld s0,8(sp)
+ 3da: 0141 addi sp,sp,16
+ 3dc: 8082 ret
+ dst += n;
+ 3de: 00c50733 add a4,a0,a2
+ src += n;
+ 3e2: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 3e4: fec05ae3 blez a2,3d8 <memmove+0x28>
+ 3e8: fff6079b addiw a5,a2,-1
+ 3ec: 1782 slli a5,a5,0x20
+ 3ee: 9381 srli a5,a5,0x20
+ 3f0: fff7c793 not a5,a5
+ 3f4: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 3f6: 15fd addi a1,a1,-1
+ 3f8: 177d addi a4,a4,-1
+ 3fa: 0005c683 lbu a3,0(a1)
+ 3fe: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 402: fee79ae3 bne a5,a4,3f6 <memmove+0x46>
+ 406: bfc9 j 3d8 <memmove+0x28>
+
+0000000000000408 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 408: 1141 addi sp,sp,-16
+ 40a: e422 sd s0,8(sp)
+ 40c: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 40e: ca05 beqz a2,43e <memcmp+0x36>
+ 410: fff6069b addiw a3,a2,-1
+ 414: 1682 slli a3,a3,0x20
+ 416: 9281 srli a3,a3,0x20
+ 418: 0685 addi a3,a3,1
+ 41a: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 41c: 00054783 lbu a5,0(a0)
+ 420: 0005c703 lbu a4,0(a1)
+ 424: 00e79863 bne a5,a4,434 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 428: 0505 addi a0,a0,1
+ p2++;
+ 42a: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 42c: fed518e3 bne a0,a3,41c <memcmp+0x14>
+ }
+ return 0;
+ 430: 4501 li a0,0
+ 432: a019 j 438 <memcmp+0x30>
+ return *p1 - *p2;
+ 434: 40e7853b subw a0,a5,a4
+}
+ 438: 6422 ld s0,8(sp)
+ 43a: 0141 addi sp,sp,16
+ 43c: 8082 ret
+ return 0;
+ 43e: 4501 li a0,0
+ 440: bfe5 j 438 <memcmp+0x30>
+
+0000000000000442 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 442: 1141 addi sp,sp,-16
+ 444: e406 sd ra,8(sp)
+ 446: e022 sd s0,0(sp)
+ 448: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 44a: 00000097 auipc ra,0x0
+ 44e: f66080e7 jalr -154(ra) # 3b0 <memmove>
+}
+ 452: 60a2 ld ra,8(sp)
+ 454: 6402 ld s0,0(sp)
+ 456: 0141 addi sp,sp,16
+ 458: 8082 ret
+
+000000000000045a <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 45a: 4885 li a7,1
+ ecall
+ 45c: 00000073 ecall
+ ret
+ 460: 8082 ret
+
+0000000000000462 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 462: 05d00893 li a7,93
+ ecall
+ 466: 00000073 ecall
+ ret
+ 46a: 8082 ret
+
+000000000000046c <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 46c: 488d li a7,3
+ ecall
+ 46e: 00000073 ecall
+ ret
+ 472: 8082 ret
+
+0000000000000474 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 474: 03b00893 li a7,59
+ ecall
+ 478: 00000073 ecall
+ ret
+ 47c: 8082 ret
+
+000000000000047e <read>:
+.global read
+read:
+ li a7, SYS_read
+ 47e: 03f00893 li a7,63
+ ecall
+ 482: 00000073 ecall
+ ret
+ 486: 8082 ret
+
+0000000000000488 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 488: 04000893 li a7,64
+ ecall
+ 48c: 00000073 ecall
+ ret
+ 490: 8082 ret
+
+0000000000000492 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 492: 03900893 li a7,57
+ ecall
+ 496: 00000073 ecall
+ ret
+ 49a: 8082 ret
+
+000000000000049c <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 49c: 4899 li a7,6
+ ecall
+ 49e: 00000073 ecall
+ ret
+ 4a2: 8082 ret
+
+00000000000004a4 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 4a4: 0dd00893 li a7,221
+ ecall
+ 4a8: 00000073 ecall
+ ret
+ 4ac: 8082 ret
+
+00000000000004ae <open>:
+.global open
+open:
+ li a7, SYS_open
+ 4ae: 03800893 li a7,56
+ ecall
+ 4b2: 00000073 ecall
+ ret
+ 4b6: 8082 ret
+
+00000000000004b8 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 4b8: 05000893 li a7,80
+ ecall
+ 4bc: 00000073 ecall
+ ret
+ 4c0: 8082 ret
+
+00000000000004c2 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 4c2: 02200893 li a7,34
+ ecall
+ 4c6: 00000073 ecall
+ ret
+ 4ca: 8082 ret
+
+00000000000004cc <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 4cc: 03100893 li a7,49
+ ecall
+ 4d0: 00000073 ecall
+ ret
+ 4d4: 8082 ret
+
+00000000000004d6 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 4d6: 48dd li a7,23
+ ecall
+ 4d8: 00000073 ecall
+ ret
+ 4dc: 8082 ret
+
+00000000000004de <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 4de: 0ac00893 li a7,172
+ ecall
+ 4e2: 00000073 ecall
+ ret
+ 4e6: 8082 ret
+
+00000000000004e8 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 4e8: 48b1 li a7,12
+ ecall
+ 4ea: 00000073 ecall
+ ret
+ 4ee: 8082 ret
+
+00000000000004f0 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 4f0: 48b5 li a7,13
+ ecall
+ 4f2: 00000073 ecall
+ ret
+ 4f6: 8082 ret
+
+00000000000004f8 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 4f8: 48b9 li a7,14
+ ecall
+ 4fa: 00000073 ecall
+ ret
+ 4fe: 8082 ret
+
+0000000000000500 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 500: 48d9 li a7,22
+ ecall
+ 502: 00000073 ecall
+ ret
+ 506: 8082 ret
+
+0000000000000508 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 508: 03200893 li a7,50
+ ecall
+ 50c: 00000073 ecall
+ ret
+ 510: 8082 ret
+
+0000000000000512 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 512: 48ed li a7,27
+ ecall
+ 514: 00000073 ecall
+ ret
+ 518: 8082 ret
+
+000000000000051a <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 51a: 48c5 li a7,17
+ ecall
+ 51c: 00000073 ecall
+ ret
+ 520: 8082 ret
+
+0000000000000522 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 522: 07500893 li a7,117
+ ecall
+ 526: 00000073 ecall
+ ret
+ 52a: 8082 ret
+
+000000000000052c <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 52c: 48c9 li a7,18
+ ecall
+ 52e: 00000073 ecall
+ ret
+ 532: 8082 ret
+
+0000000000000534 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 534: 48cd li a7,19
+ ecall
+ 536: 00000073 ecall
+ ret
+ 53a: 8082 ret
+
+000000000000053c <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 53c: 48e9 li a7,26
+ ecall
+ 53e: 00000073 ecall
+ ret
+ 542: 8082 ret
+
+0000000000000544 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 544: 0d200893 li a7,210
+ ecall
+ 548: 00000073 ecall
+ ret
+ 54c: 8082 ret
+
+000000000000054e <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 54e: 1101 addi sp,sp,-32
+ 550: ec06 sd ra,24(sp)
+ 552: e822 sd s0,16(sp)
+ 554: 1000 addi s0,sp,32
+ 556: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 55a: 4605 li a2,1
+ 55c: fef40593 addi a1,s0,-17
+ 560: 00000097 auipc ra,0x0
+ 564: f28080e7 jalr -216(ra) # 488 <write>
+}
+ 568: 60e2 ld ra,24(sp)
+ 56a: 6442 ld s0,16(sp)
+ 56c: 6105 addi sp,sp,32
+ 56e: 8082 ret
+
+0000000000000570 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 570: 7139 addi sp,sp,-64
+ 572: fc06 sd ra,56(sp)
+ 574: f822 sd s0,48(sp)
+ 576: f426 sd s1,40(sp)
+ 578: f04a sd s2,32(sp)
+ 57a: ec4e sd s3,24(sp)
+ 57c: 0080 addi s0,sp,64
+ 57e: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 580: c299 beqz a3,586 <printint+0x16>
+ 582: 0805c863 bltz a1,612 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 586: 2581 sext.w a1,a1
+ neg = 0;
+ 588: 4881 li a7,0
+ }
+
+ i = 0;
+ 58a: fc040993 addi s3,s0,-64
+ neg = 0;
+ 58e: 86ce mv a3,s3
+ i = 0;
+ 590: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 592: 2601 sext.w a2,a2
+ 594: 00000517 auipc a0,0x0
+ 598: 53c50513 addi a0,a0,1340 # ad0 <digits>
+ 59c: 883a mv a6,a4
+ 59e: 2705 addiw a4,a4,1
+ 5a0: 02c5f7bb remuw a5,a1,a2
+ 5a4: 1782 slli a5,a5,0x20
+ 5a6: 9381 srli a5,a5,0x20
+ 5a8: 97aa add a5,a5,a0
+ 5aa: 0007c783 lbu a5,0(a5)
+ 5ae: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 5b2: 0005879b sext.w a5,a1
+ 5b6: 02c5d5bb divuw a1,a1,a2
+ 5ba: 0685 addi a3,a3,1
+ 5bc: fec7f0e3 bgeu a5,a2,59c <printint+0x2c>
+ if(neg)
+ 5c0: 00088c63 beqz a7,5d8 <printint+0x68>
+ buf[i++] = '-';
+ 5c4: fd070793 addi a5,a4,-48
+ 5c8: 00878733 add a4,a5,s0
+ 5cc: 02d00793 li a5,45
+ 5d0: fef70823 sb a5,-16(a4)
+ 5d4: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 5d8: 02e05663 blez a4,604 <printint+0x94>
+ 5dc: fc040913 addi s2,s0,-64
+ 5e0: 993a add s2,s2,a4
+ 5e2: 19fd addi s3,s3,-1
+ 5e4: 99ba add s3,s3,a4
+ 5e6: 377d addiw a4,a4,-1
+ 5e8: 1702 slli a4,a4,0x20
+ 5ea: 9301 srli a4,a4,0x20
+ 5ec: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 5f0: fff94583 lbu a1,-1(s2)
+ 5f4: 8526 mv a0,s1
+ 5f6: 00000097 auipc ra,0x0
+ 5fa: f58080e7 jalr -168(ra) # 54e <putc>
+ while(--i >= 0)
+ 5fe: 197d addi s2,s2,-1
+ 600: ff3918e3 bne s2,s3,5f0 <printint+0x80>
+}
+ 604: 70e2 ld ra,56(sp)
+ 606: 7442 ld s0,48(sp)
+ 608: 74a2 ld s1,40(sp)
+ 60a: 7902 ld s2,32(sp)
+ 60c: 69e2 ld s3,24(sp)
+ 60e: 6121 addi sp,sp,64
+ 610: 8082 ret
+ x = -xx;
+ 612: 40b005bb negw a1,a1
+ neg = 1;
+ 616: 4885 li a7,1
+ x = -xx;
+ 618: bf8d j 58a <printint+0x1a>
+
+000000000000061a <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 61a: 7119 addi sp,sp,-128
+ 61c: fc86 sd ra,120(sp)
+ 61e: f8a2 sd s0,112(sp)
+ 620: f4a6 sd s1,104(sp)
+ 622: f0ca sd s2,96(sp)
+ 624: ecce sd s3,88(sp)
+ 626: e8d2 sd s4,80(sp)
+ 628: e4d6 sd s5,72(sp)
+ 62a: e0da sd s6,64(sp)
+ 62c: fc5e sd s7,56(sp)
+ 62e: f862 sd s8,48(sp)
+ 630: f466 sd s9,40(sp)
+ 632: f06a sd s10,32(sp)
+ 634: ec6e sd s11,24(sp)
+ 636: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 638: 0005c903 lbu s2,0(a1)
+ 63c: 18090f63 beqz s2,7da <vprintf+0x1c0>
+ 640: 8aaa mv s5,a0
+ 642: 8b32 mv s6,a2
+ 644: 00158493 addi s1,a1,1
+ state = 0;
+ 648: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 64a: 02500a13 li s4,37
+ 64e: 4c55 li s8,21
+ 650: 00000c97 auipc s9,0x0
+ 654: 428c8c93 addi s9,s9,1064 # a78 <malloc+0x19a>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 658: 02800d93 li s11,40
+ putc(fd, 'x');
+ 65c: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 65e: 00000b97 auipc s7,0x0
+ 662: 472b8b93 addi s7,s7,1138 # ad0 <digits>
+ 666: a839 j 684 <vprintf+0x6a>
+ putc(fd, c);
+ 668: 85ca mv a1,s2
+ 66a: 8556 mv a0,s5
+ 66c: 00000097 auipc ra,0x0
+ 670: ee2080e7 jalr -286(ra) # 54e <putc>
+ 674: a019 j 67a <vprintf+0x60>
+ } else if(state == '%'){
+ 676: 01498d63 beq s3,s4,690 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 67a: 0485 addi s1,s1,1
+ 67c: fff4c903 lbu s2,-1(s1)
+ 680: 14090d63 beqz s2,7da <vprintf+0x1c0>
+ if(state == 0){
+ 684: fe0999e3 bnez s3,676 <vprintf+0x5c>
+ if(c == '%'){
+ 688: ff4910e3 bne s2,s4,668 <vprintf+0x4e>
+ state = '%';
+ 68c: 89d2 mv s3,s4
+ 68e: b7f5 j 67a <vprintf+0x60>
+ if(c == 'd'){
+ 690: 11490c63 beq s2,s4,7a8 <vprintf+0x18e>
+ 694: f9d9079b addiw a5,s2,-99
+ 698: 0ff7f793 zext.b a5,a5
+ 69c: 10fc6e63 bltu s8,a5,7b8 <vprintf+0x19e>
+ 6a0: f9d9079b addiw a5,s2,-99
+ 6a4: 0ff7f713 zext.b a4,a5
+ 6a8: 10ec6863 bltu s8,a4,7b8 <vprintf+0x19e>
+ 6ac: 00271793 slli a5,a4,0x2
+ 6b0: 97e6 add a5,a5,s9
+ 6b2: 439c lw a5,0(a5)
+ 6b4: 97e6 add a5,a5,s9
+ 6b6: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 6b8: 008b0913 addi s2,s6,8
+ 6bc: 4685 li a3,1
+ 6be: 4629 li a2,10
+ 6c0: 000b2583 lw a1,0(s6)
+ 6c4: 8556 mv a0,s5
+ 6c6: 00000097 auipc ra,0x0
+ 6ca: eaa080e7 jalr -342(ra) # 570 <printint>
+ 6ce: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 6d0: 4981 li s3,0
+ 6d2: b765 j 67a <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 6d4: 008b0913 addi s2,s6,8
+ 6d8: 4681 li a3,0
+ 6da: 4629 li a2,10
+ 6dc: 000b2583 lw a1,0(s6)
+ 6e0: 8556 mv a0,s5
+ 6e2: 00000097 auipc ra,0x0
+ 6e6: e8e080e7 jalr -370(ra) # 570 <printint>
+ 6ea: 8b4a mv s6,s2
+ state = 0;
+ 6ec: 4981 li s3,0
+ 6ee: b771 j 67a <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 6f0: 008b0913 addi s2,s6,8
+ 6f4: 4681 li a3,0
+ 6f6: 866a mv a2,s10
+ 6f8: 000b2583 lw a1,0(s6)
+ 6fc: 8556 mv a0,s5
+ 6fe: 00000097 auipc ra,0x0
+ 702: e72080e7 jalr -398(ra) # 570 <printint>
+ 706: 8b4a mv s6,s2
+ state = 0;
+ 708: 4981 li s3,0
+ 70a: bf85 j 67a <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 70c: 008b0793 addi a5,s6,8
+ 710: f8f43423 sd a5,-120(s0)
+ 714: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 718: 03000593 li a1,48
+ 71c: 8556 mv a0,s5
+ 71e: 00000097 auipc ra,0x0
+ 722: e30080e7 jalr -464(ra) # 54e <putc>
+ putc(fd, 'x');
+ 726: 07800593 li a1,120
+ 72a: 8556 mv a0,s5
+ 72c: 00000097 auipc ra,0x0
+ 730: e22080e7 jalr -478(ra) # 54e <putc>
+ 734: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 736: 03c9d793 srli a5,s3,0x3c
+ 73a: 97de add a5,a5,s7
+ 73c: 0007c583 lbu a1,0(a5)
+ 740: 8556 mv a0,s5
+ 742: 00000097 auipc ra,0x0
+ 746: e0c080e7 jalr -500(ra) # 54e <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 74a: 0992 slli s3,s3,0x4
+ 74c: 397d addiw s2,s2,-1
+ 74e: fe0914e3 bnez s2,736 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 752: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 756: 4981 li s3,0
+ 758: b70d j 67a <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 75a: 008b0913 addi s2,s6,8
+ 75e: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 762: 02098163 beqz s3,784 <vprintf+0x16a>
+ while(*s != 0){
+ 766: 0009c583 lbu a1,0(s3)
+ 76a: c5ad beqz a1,7d4 <vprintf+0x1ba>
+ putc(fd, *s);
+ 76c: 8556 mv a0,s5
+ 76e: 00000097 auipc ra,0x0
+ 772: de0080e7 jalr -544(ra) # 54e <putc>
+ s++;
+ 776: 0985 addi s3,s3,1
+ while(*s != 0){
+ 778: 0009c583 lbu a1,0(s3)
+ 77c: f9e5 bnez a1,76c <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 77e: 8b4a mv s6,s2
+ state = 0;
+ 780: 4981 li s3,0
+ 782: bde5 j 67a <vprintf+0x60>
+ s = "(null)";
+ 784: 00000997 auipc s3,0x0
+ 788: 2ec98993 addi s3,s3,748 # a70 <malloc+0x192>
+ while(*s != 0){
+ 78c: 85ee mv a1,s11
+ 78e: bff9 j 76c <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 790: 008b0913 addi s2,s6,8
+ 794: 000b4583 lbu a1,0(s6)
+ 798: 8556 mv a0,s5
+ 79a: 00000097 auipc ra,0x0
+ 79e: db4080e7 jalr -588(ra) # 54e <putc>
+ 7a2: 8b4a mv s6,s2
+ state = 0;
+ 7a4: 4981 li s3,0
+ 7a6: bdd1 j 67a <vprintf+0x60>
+ putc(fd, c);
+ 7a8: 85d2 mv a1,s4
+ 7aa: 8556 mv a0,s5
+ 7ac: 00000097 auipc ra,0x0
+ 7b0: da2080e7 jalr -606(ra) # 54e <putc>
+ state = 0;
+ 7b4: 4981 li s3,0
+ 7b6: b5d1 j 67a <vprintf+0x60>
+ putc(fd, '%');
+ 7b8: 85d2 mv a1,s4
+ 7ba: 8556 mv a0,s5
+ 7bc: 00000097 auipc ra,0x0
+ 7c0: d92080e7 jalr -622(ra) # 54e <putc>
+ putc(fd, c);
+ 7c4: 85ca mv a1,s2
+ 7c6: 8556 mv a0,s5
+ 7c8: 00000097 auipc ra,0x0
+ 7cc: d86080e7 jalr -634(ra) # 54e <putc>
+ state = 0;
+ 7d0: 4981 li s3,0
+ 7d2: b565 j 67a <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 7d4: 8b4a mv s6,s2
+ state = 0;
+ 7d6: 4981 li s3,0
+ 7d8: b54d j 67a <vprintf+0x60>
+ }
+ }
+}
+ 7da: 70e6 ld ra,120(sp)
+ 7dc: 7446 ld s0,112(sp)
+ 7de: 74a6 ld s1,104(sp)
+ 7e0: 7906 ld s2,96(sp)
+ 7e2: 69e6 ld s3,88(sp)
+ 7e4: 6a46 ld s4,80(sp)
+ 7e6: 6aa6 ld s5,72(sp)
+ 7e8: 6b06 ld s6,64(sp)
+ 7ea: 7be2 ld s7,56(sp)
+ 7ec: 7c42 ld s8,48(sp)
+ 7ee: 7ca2 ld s9,40(sp)
+ 7f0: 7d02 ld s10,32(sp)
+ 7f2: 6de2 ld s11,24(sp)
+ 7f4: 6109 addi sp,sp,128
+ 7f6: 8082 ret
+
+00000000000007f8 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 7f8: 715d addi sp,sp,-80
+ 7fa: ec06 sd ra,24(sp)
+ 7fc: e822 sd s0,16(sp)
+ 7fe: 1000 addi s0,sp,32
+ 800: e010 sd a2,0(s0)
+ 802: e414 sd a3,8(s0)
+ 804: e818 sd a4,16(s0)
+ 806: ec1c sd a5,24(s0)
+ 808: 03043023 sd a6,32(s0)
+ 80c: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 810: 8622 mv a2,s0
+ 812: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 816: 00000097 auipc ra,0x0
+ 81a: e04080e7 jalr -508(ra) # 61a <vprintf>
+}
+ 81e: 60e2 ld ra,24(sp)
+ 820: 6442 ld s0,16(sp)
+ 822: 6161 addi sp,sp,80
+ 824: 8082 ret
+
+0000000000000826 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 826: 711d addi sp,sp,-96
+ 828: ec06 sd ra,24(sp)
+ 82a: e822 sd s0,16(sp)
+ 82c: 1000 addi s0,sp,32
+ 82e: e40c sd a1,8(s0)
+ 830: e810 sd a2,16(s0)
+ 832: ec14 sd a3,24(s0)
+ 834: f018 sd a4,32(s0)
+ 836: f41c sd a5,40(s0)
+ 838: 03043823 sd a6,48(s0)
+ 83c: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 840: 00840613 addi a2,s0,8
+ 844: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 848: 85aa mv a1,a0
+ 84a: 4505 li a0,1
+ 84c: 00000097 auipc ra,0x0
+ 850: dce080e7 jalr -562(ra) # 61a <vprintf>
+}
+ 854: 60e2 ld ra,24(sp)
+ 856: 6442 ld s0,16(sp)
+ 858: 6125 addi sp,sp,96
+ 85a: 8082 ret
+
+000000000000085c <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 85c: 1141 addi sp,sp,-16
+ 85e: e422 sd s0,8(sp)
+ 860: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 862: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 866: 00000797 auipc a5,0x0
+ 86a: 2827b783 ld a5,642(a5) # ae8 <freep>
+ 86e: a02d j 898 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 870: 4618 lw a4,8(a2)
+ 872: 9f2d addw a4,a4,a1
+ 874: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 878: 6398 ld a4,0(a5)
+ 87a: 6310 ld a2,0(a4)
+ 87c: a83d j 8ba <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 87e: ff852703 lw a4,-8(a0)
+ 882: 9f31 addw a4,a4,a2
+ 884: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 886: ff053683 ld a3,-16(a0)
+ 88a: a091 j 8ce <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 88c: 6398 ld a4,0(a5)
+ 88e: 00e7e463 bltu a5,a4,896 <free+0x3a>
+ 892: 00e6ea63 bltu a3,a4,8a6 <free+0x4a>
+{
+ 896: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 898: fed7fae3 bgeu a5,a3,88c <free+0x30>
+ 89c: 6398 ld a4,0(a5)
+ 89e: 00e6e463 bltu a3,a4,8a6 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8a2: fee7eae3 bltu a5,a4,896 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 8a6: ff852583 lw a1,-8(a0)
+ 8aa: 6390 ld a2,0(a5)
+ 8ac: 02059813 slli a6,a1,0x20
+ 8b0: 01c85713 srli a4,a6,0x1c
+ 8b4: 9736 add a4,a4,a3
+ 8b6: fae60de3 beq a2,a4,870 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8ba: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 8be: 4790 lw a2,8(a5)
+ 8c0: 02061593 slli a1,a2,0x20
+ 8c4: 01c5d713 srli a4,a1,0x1c
+ 8c8: 973e add a4,a4,a5
+ 8ca: fae68ae3 beq a3,a4,87e <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 8ce: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 8d0: 00000717 auipc a4,0x0
+ 8d4: 20f73c23 sd a5,536(a4) # ae8 <freep>
+}
+ 8d8: 6422 ld s0,8(sp)
+ 8da: 0141 addi sp,sp,16
+ 8dc: 8082 ret
+
+00000000000008de <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 8de: 7139 addi sp,sp,-64
+ 8e0: fc06 sd ra,56(sp)
+ 8e2: f822 sd s0,48(sp)
+ 8e4: f426 sd s1,40(sp)
+ 8e6: f04a sd s2,32(sp)
+ 8e8: ec4e sd s3,24(sp)
+ 8ea: e852 sd s4,16(sp)
+ 8ec: e456 sd s5,8(sp)
+ 8ee: e05a sd s6,0(sp)
+ 8f0: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 8f2: 02051493 slli s1,a0,0x20
+ 8f6: 9081 srli s1,s1,0x20
+ 8f8: 04bd addi s1,s1,15
+ 8fa: 8091 srli s1,s1,0x4
+ 8fc: 00148a1b addiw s4,s1,1
+ 900: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 902: 00000517 auipc a0,0x0
+ 906: 1e653503 ld a0,486(a0) # ae8 <freep>
+ 90a: c515 beqz a0,936 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 90c: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 90e: 4798 lw a4,8(a5)
+ 910: 04977163 bgeu a4,s1,952 <malloc+0x74>
+ 914: 89d2 mv s3,s4
+ 916: 000a071b sext.w a4,s4
+ 91a: 6685 lui a3,0x1
+ 91c: 00d77363 bgeu a4,a3,922 <malloc+0x44>
+ 920: 6985 lui s3,0x1
+ 922: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 926: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 92a: 00000917 auipc s2,0x0
+ 92e: 1be90913 addi s2,s2,446 # ae8 <freep>
+ if(p == (char*)-1)
+ 932: 5afd li s5,-1
+ 934: a8a5 j 9ac <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 936: 00000797 auipc a5,0x0
+ 93a: 1b278793 addi a5,a5,434 # ae8 <freep>
+ 93e: 00000717 auipc a4,0x0
+ 942: 1b270713 addi a4,a4,434 # af0 <base>
+ 946: e398 sd a4,0(a5)
+ 948: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 94a: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 94e: 87ba mv a5,a4
+ 950: b7d1 j 914 <malloc+0x36>
+ if(p->s.size == nunits)
+ 952: 02e48c63 beq s1,a4,98a <malloc+0xac>
+ p->s.size -= nunits;
+ 956: 4147073b subw a4,a4,s4
+ 95a: c798 sw a4,8(a5)
+ p += p->s.size;
+ 95c: 02071693 slli a3,a4,0x20
+ 960: 01c6d713 srli a4,a3,0x1c
+ 964: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 966: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 96a: 00000717 auipc a4,0x0
+ 96e: 16a73f23 sd a0,382(a4) # ae8 <freep>
+ return (void*)(p + 1);
+ 972: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 976: 70e2 ld ra,56(sp)
+ 978: 7442 ld s0,48(sp)
+ 97a: 74a2 ld s1,40(sp)
+ 97c: 7902 ld s2,32(sp)
+ 97e: 69e2 ld s3,24(sp)
+ 980: 6a42 ld s4,16(sp)
+ 982: 6aa2 ld s5,8(sp)
+ 984: 6b02 ld s6,0(sp)
+ 986: 6121 addi sp,sp,64
+ 988: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 98a: 6398 ld a4,0(a5)
+ 98c: e118 sd a4,0(a0)
+ 98e: bff1 j 96a <malloc+0x8c>
+ hp->s.size = nu;
+ 990: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 994: 0541 addi a0,a0,16
+ 996: 00000097 auipc ra,0x0
+ 99a: ec6080e7 jalr -314(ra) # 85c <free>
+ return freep;
+ 99e: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 9a2: d971 beqz a0,976 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 9a4: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 9a6: 4798 lw a4,8(a5)
+ 9a8: fa9775e3 bgeu a4,s1,952 <malloc+0x74>
+ if(p == freep)
+ 9ac: 00093703 ld a4,0(s2)
+ 9b0: 853e mv a0,a5
+ 9b2: fef719e3 bne a4,a5,9a4 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 9b6: 854e mv a0,s3
+ 9b8: 00000097 auipc ra,0x0
+ 9bc: b30080e7 jalr -1232(ra) # 4e8 <sbrk>
+ if(p == (char*)-1)
+ 9c0: fd5518e3 bne a0,s5,990 <malloc+0xb2>
+ return 0;
+ 9c4: 4501 li a0,0
+ 9c6: bf45 j 976 <malloc+0x98>
diff --git a/xv6-user/mv.c b/xv6-user/mv.c
new file mode 100644
index 0000000000000000000000000000000000000000..6dc2aa9d15f06e375844876410b15a2011b82a80
--- /dev/null
+++ b/xv6-user/mv.c
@@ -0,0 +1,53 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/fcntl.h"
+#include "kernel/include/param.h"
+#include "xv6-user/user.h"
+
+int main(int argc, char *argv[])
+{
+ if (argc < 3) {
+ fprintf(2, "Usage: mv old_name new_name\n");
+ exit(1);
+ }
+
+ char src[MAXPATH];
+ char dst[MAXPATH];
+ strcpy(src, argv[1]);
+ strcpy(dst, argv[2]);
+ int fd = open(dst, O_RDONLY);
+ if (fd >= 0) {
+ struct stat st;
+ fstat(fd, &st);
+ close(fd);
+ if (st.type == T_DIR) {
+ char *ps, *pd;
+ for (ps = src + strlen(src) - 1; ps >= src; ps--) { // trim '/' in tail
+ if (*ps != '/') {
+ *(ps + 1) = '\0';
+ break;
+ }
+ }
+ for (; ps >= src && *ps != '/'; ps--);
+ ps++;
+ pd = dst + strlen(dst);
+ *pd++ = '/';
+ while (*ps) {
+ *pd++ = *ps++;
+ if (pd >= dst + MAXPATH) {
+ fprintf(2, "mv: fail! final dst path too long (exceed MAX=%d)!\n", MAXPATH);
+ exit(-1);
+ }
+ }
+ } else {
+ fprintf(2, "mv: fail! %s exists!\n", dst);
+ exit(-1);
+ }
+ }
+ printf("moving [%s] to [%s]\n", src, dst);
+ if (rename(src, dst) < 0) {
+ fprintf(2, "mv: fail to rename %s to %s!\n", src, dst);
+ exit(-1);
+ }
+ exit(0);
+}
\ No newline at end of file
diff --git a/xv6-user/mv.d b/xv6-user/mv.d
new file mode 100644
index 0000000000000000000000000000000000000000..db02e40cd154b9d20958974804db9ca3036ea9f1
--- /dev/null
+++ b/xv6-user/mv.d
@@ -0,0 +1,2 @@
+xv6-user/mv.o: xv6-user/mv.c kernel/include/types.h kernel/include/stat.h \
+ kernel/include/fcntl.h kernel/include/param.h xv6-user/user.h
diff --git a/xv6-user/mv.o b/xv6-user/mv.o
new file mode 100644
index 0000000000000000000000000000000000000000..5d7d6f6d7bd63c332432d426e2ad0e3c5f1e2f94
Binary files /dev/null and b/xv6-user/mv.o differ
diff --git a/xv6-user/mv.sym b/xv6-user/mv.sym
new file mode 100644
index 0000000000000000000000000000000000000000..4a197c1d9798b9968c2f3400fec37f4d3de1ed83
--- /dev/null
+++ b/xv6-user/mv.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+00000000000009c8 .rodata
+0000000000000ae8 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 mv.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+000000000000054e putc
+0000000000000570 printint
+0000000000000ad0 digits
+0000000000000000 umalloc.c
+0000000000000ae8 freep
+0000000000000af0 base
+00000000000001aa strcpy
+0000000000000826 printf
+00000000000012e1 __global_pointer$
+0000000000000508 dev
+00000000000003b0 memmove
+000000000000052c trace
+0000000000000290 gets
+0000000000000ae1 __SDATA_BEGIN__
+00000000000004de getpid
+0000000000000442 memcpy
+00000000000008de malloc
+0000000000000522 remove
+00000000000004f0 sleep
+0000000000000534 sysinfo
+0000000000000512 readdir
+0000000000000474 pipe
+000000000000053c rename
+0000000000000488 write
+00000000000004b8 fstat
+00000000000007f8 fprintf
+000000000000049c kill
+00000000000001c6 strcat
+000000000000061a vprintf
+00000000000004cc chdir
+00000000000004a4 exec
+000000000000046c wait
+000000000000047e read
+0000000000000408 memcmp
+000000000000045a fork
+0000000000000b00 __BSS_END__
+00000000000004e8 sbrk
+0000000000000500 test_proc
+00000000000004f8 uptime
+0000000000000ae1 __bss_start
+000000000000024a memset
+0000000000000000 main
+00000000000001f4 strcmp
+0000000000000544 shutdown
+00000000000004d6 dup
+000000000000051a getcwd
+0000000000000ae1 __DATA_BEGIN__
+000000000000030a stat
+0000000000000ae1 _edata
+0000000000000b00 _end
+0000000000000462 exit
+0000000000000350 atoi
+0000000000000220 strlen
+00000000000004ae open
+000000000000026c strchr
+00000000000004c2 mkdir
+0000000000000492 close
+000000000000085c free
diff --git a/xv6-user/printf.c b/xv6-user/printf.c
new file mode 100644
index 0000000000000000000000000000000000000000..1704ce08202ca168b0579edf3ef9ddfc6a0c2586
--- /dev/null
+++ b/xv6-user/printf.c
@@ -0,0 +1,113 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+#include <stdarg.h>
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ write(fd, &c, 1);
+}
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ }
+
+ i = 0;
+ do{
+ buf[i++] = digits[x % base];
+ }while((x /= base) != 0);
+ if(neg)
+ buf[i++] = '-';
+
+ while(--i >= 0)
+ putc(fd, buf[i]);
+}
+
+static void
+printptr(int fd, uint64 x) {
+ int i;
+ putc(fd, '0');
+ putc(fd, 'x');
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ c = fmt[i] & 0xff;
+ if(state == 0){
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ if(c == 'd'){
+ printint(fd, va_arg(ap, int), 10, 1);
+ } else if(c == 'l') {
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ } else if(c == 'x') {
+ printint(fd, va_arg(ap, int), 16, 0);
+ } else if(c == 'p') {
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ putc(fd, *s);
+ s++;
+ }
+ } else if(c == 'c'){
+ putc(fd, va_arg(ap, uint));
+ } else if(c == '%'){
+ putc(fd, c);
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ }
+ }
+}
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ vprintf(fd, fmt, ap);
+}
+
+void
+printf(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ vprintf(1, fmt, ap);
+}
diff --git a/xv6-user/printf.d b/xv6-user/printf.d
new file mode 100644
index 0000000000000000000000000000000000000000..c7f4f8d9ce8c34e38fae9c58bde3b53f5fb81abc
--- /dev/null
+++ b/xv6-user/printf.d
@@ -0,0 +1,3 @@
+xv6-user/printf.o: xv6-user/printf.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h \
+ /usr/lib/gcc-cross/riscv64-linux-gnu/11/include/stdarg.h
diff --git a/xv6-user/printf.o b/xv6-user/printf.o
new file mode 100644
index 0000000000000000000000000000000000000000..ce2c3c55938fc37e5b3fdfeab7d2240a3c70ca6f
Binary files /dev/null and b/xv6-user/printf.o differ
diff --git a/xv6-user/rm.asm b/xv6-user/rm.asm
new file mode 100644
index 0000000000000000000000000000000000000000..7d421ef4ab01cc9468d760b09a25c49edfaaf110
--- /dev/null
+++ b/xv6-user/rm.asm
@@ -0,0 +1,1453 @@
+
+xv6-user/_rm: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ 0: 7179 addi sp,sp,-48
+ 2: f406 sd ra,40(sp)
+ 4: f022 sd s0,32(sp)
+ 6: ec26 sd s1,24(sp)
+ 8: e84a sd s2,16(sp)
+ a: e44e sd s3,8(sp)
+ c: 1800 addi s0,sp,48
+ int i;
+
+ if(argc < 2){
+ e: 4785 li a5,1
+ 10: 02a7d163 bge a5,a0,32 <main+0x32>
+ 14: 00858493 addi s1,a1,8
+ 18: ffe5091b addiw s2,a0,-2
+ 1c: 02091793 slli a5,s2,0x20
+ 20: 01d7d913 srli s2,a5,0x1d
+ 24: 05c1 addi a1,a1,16
+ 26: 992e add s2,s2,a1
+ exit(1);
+ }
+
+ for(i = 1; i < argc; i++){
+ if(remove(argv[i]) < 0){
+ fprintf(2, "rm: %s failed to delete\n", argv[i]);
+ 28: 00001997 auipc s3,0x1
+ 2c: 89098993 addi s3,s3,-1904 # 8b8 <malloc+0x108>
+ 30: a015 j 54 <main+0x54>
+ fprintf(2, "Usage: rm files...\n");
+ 32: 00001597 auipc a1,0x1
+ 36: 86e58593 addi a1,a1,-1938 # 8a0 <malloc+0xf0>
+ 3a: 4509 li a0,2
+ 3c: 00000097 auipc ra,0x0
+ 40: 68e080e7 jalr 1678(ra) # 6ca <fprintf>
+ exit(1);
+ 44: 4505 li a0,1
+ 46: 00000097 auipc ra,0x0
+ 4a: 2ee080e7 jalr 750(ra) # 334 <exit>
+ for(i = 1; i < argc; i++){
+ 4e: 04a1 addi s1,s1,8
+ 50: 03248163 beq s1,s2,72 <main+0x72>
+ if(remove(argv[i]) < 0){
+ 54: 6088 ld a0,0(s1)
+ 56: 00000097 auipc ra,0x0
+ 5a: 39e080e7 jalr 926(ra) # 3f4 <remove>
+ 5e: fe0558e3 bgez a0,4e <main+0x4e>
+ fprintf(2, "rm: %s failed to delete\n", argv[i]);
+ 62: 6090 ld a2,0(s1)
+ 64: 85ce mv a1,s3
+ 66: 4509 li a0,2
+ 68: 00000097 auipc ra,0x0
+ 6c: 662080e7 jalr 1634(ra) # 6ca <fprintf>
+ 70: bff9 j 4e <main+0x4e>
+ }
+ }
+
+ exit(0);
+ 72: 4501 li a0,0
+ 74: 00000097 auipc ra,0x0
+ 78: 2c0080e7 jalr 704(ra) # 334 <exit>
+
+000000000000007c <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 7c: 1141 addi sp,sp,-16
+ 7e: e422 sd s0,8(sp)
+ 80: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 82: 87aa mv a5,a0
+ 84: 0585 addi a1,a1,1
+ 86: 0785 addi a5,a5,1
+ 88: fff5c703 lbu a4,-1(a1)
+ 8c: fee78fa3 sb a4,-1(a5)
+ 90: fb75 bnez a4,84 <strcpy+0x8>
+ ;
+ return os;
+}
+ 92: 6422 ld s0,8(sp)
+ 94: 0141 addi sp,sp,16
+ 96: 8082 ret
+
+0000000000000098 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 98: 1141 addi sp,sp,-16
+ 9a: e422 sd s0,8(sp)
+ 9c: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 9e: 00054783 lbu a5,0(a0)
+ a2: c385 beqz a5,c2 <strcat+0x2a>
+ a4: 87aa mv a5,a0
+ s++;
+ a6: 0785 addi a5,a5,1
+ while(*s)
+ a8: 0007c703 lbu a4,0(a5)
+ ac: ff6d bnez a4,a6 <strcat+0xe>
+ while((*s++ = *t++))
+ ae: 0585 addi a1,a1,1
+ b0: 0785 addi a5,a5,1
+ b2: fff5c703 lbu a4,-1(a1)
+ b6: fee78fa3 sb a4,-1(a5)
+ ba: fb75 bnez a4,ae <strcat+0x16>
+ ;
+ return os;
+}
+ bc: 6422 ld s0,8(sp)
+ be: 0141 addi sp,sp,16
+ c0: 8082 ret
+ while(*s)
+ c2: 87aa mv a5,a0
+ c4: b7ed j ae <strcat+0x16>
+
+00000000000000c6 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ c6: 1141 addi sp,sp,-16
+ c8: e422 sd s0,8(sp)
+ ca: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ cc: 00054783 lbu a5,0(a0)
+ d0: cb91 beqz a5,e4 <strcmp+0x1e>
+ d2: 0005c703 lbu a4,0(a1)
+ d6: 00f71763 bne a4,a5,e4 <strcmp+0x1e>
+ p++, q++;
+ da: 0505 addi a0,a0,1
+ dc: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ de: 00054783 lbu a5,0(a0)
+ e2: fbe5 bnez a5,d2 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ e4: 0005c503 lbu a0,0(a1)
+}
+ e8: 40a7853b subw a0,a5,a0
+ ec: 6422 ld s0,8(sp)
+ ee: 0141 addi sp,sp,16
+ f0: 8082 ret
+
+00000000000000f2 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ f2: 1141 addi sp,sp,-16
+ f4: e422 sd s0,8(sp)
+ f6: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ f8: 00054783 lbu a5,0(a0)
+ fc: cf91 beqz a5,118 <strlen+0x26>
+ fe: 0505 addi a0,a0,1
+ 100: 87aa mv a5,a0
+ 102: 4685 li a3,1
+ 104: 9e89 subw a3,a3,a0
+ 106: 00f6853b addw a0,a3,a5
+ 10a: 0785 addi a5,a5,1
+ 10c: fff7c703 lbu a4,-1(a5)
+ 110: fb7d bnez a4,106 <strlen+0x14>
+ ;
+ return n;
+}
+ 112: 6422 ld s0,8(sp)
+ 114: 0141 addi sp,sp,16
+ 116: 8082 ret
+ for(n = 0; s[n]; n++)
+ 118: 4501 li a0,0
+ 11a: bfe5 j 112 <strlen+0x20>
+
+000000000000011c <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 11c: 1141 addi sp,sp,-16
+ 11e: e422 sd s0,8(sp)
+ 120: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 122: ca19 beqz a2,138 <memset+0x1c>
+ 124: 87aa mv a5,a0
+ 126: 1602 slli a2,a2,0x20
+ 128: 9201 srli a2,a2,0x20
+ 12a: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 12e: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 132: 0785 addi a5,a5,1
+ 134: fee79de3 bne a5,a4,12e <memset+0x12>
+ }
+ return dst;
+}
+ 138: 6422 ld s0,8(sp)
+ 13a: 0141 addi sp,sp,16
+ 13c: 8082 ret
+
+000000000000013e <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 13e: 1141 addi sp,sp,-16
+ 140: e422 sd s0,8(sp)
+ 142: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 144: 00054783 lbu a5,0(a0)
+ 148: cb99 beqz a5,15e <strchr+0x20>
+ if(*s == c)
+ 14a: 00f58763 beq a1,a5,158 <strchr+0x1a>
+ for(; *s; s++)
+ 14e: 0505 addi a0,a0,1
+ 150: 00054783 lbu a5,0(a0)
+ 154: fbfd bnez a5,14a <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 156: 4501 li a0,0
+}
+ 158: 6422 ld s0,8(sp)
+ 15a: 0141 addi sp,sp,16
+ 15c: 8082 ret
+ return 0;
+ 15e: 4501 li a0,0
+ 160: bfe5 j 158 <strchr+0x1a>
+
+0000000000000162 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 162: 711d addi sp,sp,-96
+ 164: ec86 sd ra,88(sp)
+ 166: e8a2 sd s0,80(sp)
+ 168: e4a6 sd s1,72(sp)
+ 16a: e0ca sd s2,64(sp)
+ 16c: fc4e sd s3,56(sp)
+ 16e: f852 sd s4,48(sp)
+ 170: f456 sd s5,40(sp)
+ 172: f05a sd s6,32(sp)
+ 174: ec5e sd s7,24(sp)
+ 176: e862 sd s8,16(sp)
+ 178: 1080 addi s0,sp,96
+ 17a: 8baa mv s7,a0
+ 17c: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 17e: 892a mv s2,a0
+ 180: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 182: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 186: 4b29 li s6,10
+ 188: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 18a: 89a6 mv s3,s1
+ 18c: 2485 addiw s1,s1,1
+ 18e: 0344d763 bge s1,s4,1bc <gets+0x5a>
+ cc = read(0, &c, 1);
+ 192: 4605 li a2,1
+ 194: 85d6 mv a1,s5
+ 196: 4501 li a0,0
+ 198: 00000097 auipc ra,0x0
+ 19c: 1b8080e7 jalr 440(ra) # 350 <read>
+ if(cc < 1)
+ 1a0: 00a05e63 blez a0,1bc <gets+0x5a>
+ buf[i++] = c;
+ 1a4: faf44783 lbu a5,-81(s0)
+ 1a8: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 1ac: 01678763 beq a5,s6,1ba <gets+0x58>
+ 1b0: 0905 addi s2,s2,1
+ 1b2: fd879ce3 bne a5,s8,18a <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 1b6: 89a6 mv s3,s1
+ 1b8: a011 j 1bc <gets+0x5a>
+ 1ba: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1bc: 99de add s3,s3,s7
+ 1be: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1c2: 855e mv a0,s7
+ 1c4: 60e6 ld ra,88(sp)
+ 1c6: 6446 ld s0,80(sp)
+ 1c8: 64a6 ld s1,72(sp)
+ 1ca: 6906 ld s2,64(sp)
+ 1cc: 79e2 ld s3,56(sp)
+ 1ce: 7a42 ld s4,48(sp)
+ 1d0: 7aa2 ld s5,40(sp)
+ 1d2: 7b02 ld s6,32(sp)
+ 1d4: 6be2 ld s7,24(sp)
+ 1d6: 6c42 ld s8,16(sp)
+ 1d8: 6125 addi sp,sp,96
+ 1da: 8082 ret
+
+00000000000001dc <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1dc: 1101 addi sp,sp,-32
+ 1de: ec06 sd ra,24(sp)
+ 1e0: e822 sd s0,16(sp)
+ 1e2: e426 sd s1,8(sp)
+ 1e4: e04a sd s2,0(sp)
+ 1e6: 1000 addi s0,sp,32
+ 1e8: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1ea: 4581 li a1,0
+ 1ec: 00000097 auipc ra,0x0
+ 1f0: 194080e7 jalr 404(ra) # 380 <open>
+ if(fd < 0)
+ 1f4: 02054563 bltz a0,21e <stat+0x42>
+ 1f8: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1fa: 85ca mv a1,s2
+ 1fc: 00000097 auipc ra,0x0
+ 200: 18e080e7 jalr 398(ra) # 38a <fstat>
+ 204: 892a mv s2,a0
+ close(fd);
+ 206: 8526 mv a0,s1
+ 208: 00000097 auipc ra,0x0
+ 20c: 15c080e7 jalr 348(ra) # 364 <close>
+ return r;
+}
+ 210: 854a mv a0,s2
+ 212: 60e2 ld ra,24(sp)
+ 214: 6442 ld s0,16(sp)
+ 216: 64a2 ld s1,8(sp)
+ 218: 6902 ld s2,0(sp)
+ 21a: 6105 addi sp,sp,32
+ 21c: 8082 ret
+ return -1;
+ 21e: 597d li s2,-1
+ 220: bfc5 j 210 <stat+0x34>
+
+0000000000000222 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 222: 1141 addi sp,sp,-16
+ 224: e422 sd s0,8(sp)
+ 226: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 228: 00054703 lbu a4,0(a0)
+ 22c: 02d00793 li a5,45
+ int neg = 1;
+ 230: 4585 li a1,1
+ if (*s == '-') {
+ 232: 04f70363 beq a4,a5,278 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 236: 00054703 lbu a4,0(a0)
+ 23a: fd07079b addiw a5,a4,-48
+ 23e: 0ff7f793 zext.b a5,a5
+ 242: 46a5 li a3,9
+ 244: 02f6ed63 bltu a3,a5,27e <atoi+0x5c>
+ n = 0;
+ 248: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 24a: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 24c: 0505 addi a0,a0,1
+ 24e: 0026979b slliw a5,a3,0x2
+ 252: 9fb5 addw a5,a5,a3
+ 254: 0017979b slliw a5,a5,0x1
+ 258: 9fb9 addw a5,a5,a4
+ 25a: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 25e: 00054703 lbu a4,0(a0)
+ 262: fd07079b addiw a5,a4,-48
+ 266: 0ff7f793 zext.b a5,a5
+ 26a: fef671e3 bgeu a2,a5,24c <atoi+0x2a>
+ return n * neg;
+}
+ 26e: 02d5853b mulw a0,a1,a3
+ 272: 6422 ld s0,8(sp)
+ 274: 0141 addi sp,sp,16
+ 276: 8082 ret
+ s++;
+ 278: 0505 addi a0,a0,1
+ neg = -1;
+ 27a: 55fd li a1,-1
+ 27c: bf6d j 236 <atoi+0x14>
+ n = 0;
+ 27e: 4681 li a3,0
+ 280: b7fd j 26e <atoi+0x4c>
+
+0000000000000282 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 282: 1141 addi sp,sp,-16
+ 284: e422 sd s0,8(sp)
+ 286: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 288: 02b57463 bgeu a0,a1,2b0 <memmove+0x2e>
+ while(n-- > 0)
+ 28c: 00c05f63 blez a2,2aa <memmove+0x28>
+ 290: 1602 slli a2,a2,0x20
+ 292: 9201 srli a2,a2,0x20
+ 294: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 298: 872a mv a4,a0
+ *dst++ = *src++;
+ 29a: 0585 addi a1,a1,1
+ 29c: 0705 addi a4,a4,1
+ 29e: fff5c683 lbu a3,-1(a1)
+ 2a2: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 2a6: fee79ae3 bne a5,a4,29a <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 2aa: 6422 ld s0,8(sp)
+ 2ac: 0141 addi sp,sp,16
+ 2ae: 8082 ret
+ dst += n;
+ 2b0: 00c50733 add a4,a0,a2
+ src += n;
+ 2b4: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 2b6: fec05ae3 blez a2,2aa <memmove+0x28>
+ 2ba: fff6079b addiw a5,a2,-1
+ 2be: 1782 slli a5,a5,0x20
+ 2c0: 9381 srli a5,a5,0x20
+ 2c2: fff7c793 not a5,a5
+ 2c6: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2c8: 15fd addi a1,a1,-1
+ 2ca: 177d addi a4,a4,-1
+ 2cc: 0005c683 lbu a3,0(a1)
+ 2d0: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2d4: fee79ae3 bne a5,a4,2c8 <memmove+0x46>
+ 2d8: bfc9 j 2aa <memmove+0x28>
+
+00000000000002da <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2da: 1141 addi sp,sp,-16
+ 2dc: e422 sd s0,8(sp)
+ 2de: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2e0: ca05 beqz a2,310 <memcmp+0x36>
+ 2e2: fff6069b addiw a3,a2,-1
+ 2e6: 1682 slli a3,a3,0x20
+ 2e8: 9281 srli a3,a3,0x20
+ 2ea: 0685 addi a3,a3,1
+ 2ec: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2ee: 00054783 lbu a5,0(a0)
+ 2f2: 0005c703 lbu a4,0(a1)
+ 2f6: 00e79863 bne a5,a4,306 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2fa: 0505 addi a0,a0,1
+ p2++;
+ 2fc: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2fe: fed518e3 bne a0,a3,2ee <memcmp+0x14>
+ }
+ return 0;
+ 302: 4501 li a0,0
+ 304: a019 j 30a <memcmp+0x30>
+ return *p1 - *p2;
+ 306: 40e7853b subw a0,a5,a4
+}
+ 30a: 6422 ld s0,8(sp)
+ 30c: 0141 addi sp,sp,16
+ 30e: 8082 ret
+ return 0;
+ 310: 4501 li a0,0
+ 312: bfe5 j 30a <memcmp+0x30>
+
+0000000000000314 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 314: 1141 addi sp,sp,-16
+ 316: e406 sd ra,8(sp)
+ 318: e022 sd s0,0(sp)
+ 31a: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 31c: 00000097 auipc ra,0x0
+ 320: f66080e7 jalr -154(ra) # 282 <memmove>
+}
+ 324: 60a2 ld ra,8(sp)
+ 326: 6402 ld s0,0(sp)
+ 328: 0141 addi sp,sp,16
+ 32a: 8082 ret
+
+000000000000032c <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 32c: 4885 li a7,1
+ ecall
+ 32e: 00000073 ecall
+ ret
+ 332: 8082 ret
+
+0000000000000334 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 334: 05d00893 li a7,93
+ ecall
+ 338: 00000073 ecall
+ ret
+ 33c: 8082 ret
+
+000000000000033e <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 33e: 488d li a7,3
+ ecall
+ 340: 00000073 ecall
+ ret
+ 344: 8082 ret
+
+0000000000000346 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 346: 03b00893 li a7,59
+ ecall
+ 34a: 00000073 ecall
+ ret
+ 34e: 8082 ret
+
+0000000000000350 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 350: 03f00893 li a7,63
+ ecall
+ 354: 00000073 ecall
+ ret
+ 358: 8082 ret
+
+000000000000035a <write>:
+.global write
+write:
+ li a7, SYS_write
+ 35a: 04000893 li a7,64
+ ecall
+ 35e: 00000073 ecall
+ ret
+ 362: 8082 ret
+
+0000000000000364 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 364: 03900893 li a7,57
+ ecall
+ 368: 00000073 ecall
+ ret
+ 36c: 8082 ret
+
+000000000000036e <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 36e: 4899 li a7,6
+ ecall
+ 370: 00000073 ecall
+ ret
+ 374: 8082 ret
+
+0000000000000376 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 376: 0dd00893 li a7,221
+ ecall
+ 37a: 00000073 ecall
+ ret
+ 37e: 8082 ret
+
+0000000000000380 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 380: 03800893 li a7,56
+ ecall
+ 384: 00000073 ecall
+ ret
+ 388: 8082 ret
+
+000000000000038a <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 38a: 05000893 li a7,80
+ ecall
+ 38e: 00000073 ecall
+ ret
+ 392: 8082 ret
+
+0000000000000394 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 394: 02200893 li a7,34
+ ecall
+ 398: 00000073 ecall
+ ret
+ 39c: 8082 ret
+
+000000000000039e <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 39e: 03100893 li a7,49
+ ecall
+ 3a2: 00000073 ecall
+ ret
+ 3a6: 8082 ret
+
+00000000000003a8 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 3a8: 48dd li a7,23
+ ecall
+ 3aa: 00000073 ecall
+ ret
+ 3ae: 8082 ret
+
+00000000000003b0 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 3b0: 0ac00893 li a7,172
+ ecall
+ 3b4: 00000073 ecall
+ ret
+ 3b8: 8082 ret
+
+00000000000003ba <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 3ba: 48b1 li a7,12
+ ecall
+ 3bc: 00000073 ecall
+ ret
+ 3c0: 8082 ret
+
+00000000000003c2 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3c2: 48b5 li a7,13
+ ecall
+ 3c4: 00000073 ecall
+ ret
+ 3c8: 8082 ret
+
+00000000000003ca <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3ca: 48b9 li a7,14
+ ecall
+ 3cc: 00000073 ecall
+ ret
+ 3d0: 8082 ret
+
+00000000000003d2 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3d2: 48d9 li a7,22
+ ecall
+ 3d4: 00000073 ecall
+ ret
+ 3d8: 8082 ret
+
+00000000000003da <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3da: 03200893 li a7,50
+ ecall
+ 3de: 00000073 ecall
+ ret
+ 3e2: 8082 ret
+
+00000000000003e4 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3e4: 48ed li a7,27
+ ecall
+ 3e6: 00000073 ecall
+ ret
+ 3ea: 8082 ret
+
+00000000000003ec <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3ec: 48c5 li a7,17
+ ecall
+ 3ee: 00000073 ecall
+ ret
+ 3f2: 8082 ret
+
+00000000000003f4 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3f4: 07500893 li a7,117
+ ecall
+ 3f8: 00000073 ecall
+ ret
+ 3fc: 8082 ret
+
+00000000000003fe <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3fe: 48c9 li a7,18
+ ecall
+ 400: 00000073 ecall
+ ret
+ 404: 8082 ret
+
+0000000000000406 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 406: 48cd li a7,19
+ ecall
+ 408: 00000073 ecall
+ ret
+ 40c: 8082 ret
+
+000000000000040e <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 40e: 48e9 li a7,26
+ ecall
+ 410: 00000073 ecall
+ ret
+ 414: 8082 ret
+
+0000000000000416 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 416: 0d200893 li a7,210
+ ecall
+ 41a: 00000073 ecall
+ ret
+ 41e: 8082 ret
+
+0000000000000420 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 420: 1101 addi sp,sp,-32
+ 422: ec06 sd ra,24(sp)
+ 424: e822 sd s0,16(sp)
+ 426: 1000 addi s0,sp,32
+ 428: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 42c: 4605 li a2,1
+ 42e: fef40593 addi a1,s0,-17
+ 432: 00000097 auipc ra,0x0
+ 436: f28080e7 jalr -216(ra) # 35a <write>
+}
+ 43a: 60e2 ld ra,24(sp)
+ 43c: 6442 ld s0,16(sp)
+ 43e: 6105 addi sp,sp,32
+ 440: 8082 ret
+
+0000000000000442 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 442: 7139 addi sp,sp,-64
+ 444: fc06 sd ra,56(sp)
+ 446: f822 sd s0,48(sp)
+ 448: f426 sd s1,40(sp)
+ 44a: f04a sd s2,32(sp)
+ 44c: ec4e sd s3,24(sp)
+ 44e: 0080 addi s0,sp,64
+ 450: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 452: c299 beqz a3,458 <printint+0x16>
+ 454: 0805c863 bltz a1,4e4 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 458: 2581 sext.w a1,a1
+ neg = 0;
+ 45a: 4881 li a7,0
+ }
+
+ i = 0;
+ 45c: fc040993 addi s3,s0,-64
+ neg = 0;
+ 460: 86ce mv a3,s3
+ i = 0;
+ 462: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 464: 2601 sext.w a2,a2
+ 466: 00000517 auipc a0,0x0
+ 46a: 4d250513 addi a0,a0,1234 # 938 <digits>
+ 46e: 883a mv a6,a4
+ 470: 2705 addiw a4,a4,1
+ 472: 02c5f7bb remuw a5,a1,a2
+ 476: 1782 slli a5,a5,0x20
+ 478: 9381 srli a5,a5,0x20
+ 47a: 97aa add a5,a5,a0
+ 47c: 0007c783 lbu a5,0(a5)
+ 480: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 484: 0005879b sext.w a5,a1
+ 488: 02c5d5bb divuw a1,a1,a2
+ 48c: 0685 addi a3,a3,1
+ 48e: fec7f0e3 bgeu a5,a2,46e <printint+0x2c>
+ if(neg)
+ 492: 00088c63 beqz a7,4aa <printint+0x68>
+ buf[i++] = '-';
+ 496: fd070793 addi a5,a4,-48
+ 49a: 00878733 add a4,a5,s0
+ 49e: 02d00793 li a5,45
+ 4a2: fef70823 sb a5,-16(a4)
+ 4a6: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 4aa: 02e05663 blez a4,4d6 <printint+0x94>
+ 4ae: fc040913 addi s2,s0,-64
+ 4b2: 993a add s2,s2,a4
+ 4b4: 19fd addi s3,s3,-1
+ 4b6: 99ba add s3,s3,a4
+ 4b8: 377d addiw a4,a4,-1
+ 4ba: 1702 slli a4,a4,0x20
+ 4bc: 9301 srli a4,a4,0x20
+ 4be: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4c2: fff94583 lbu a1,-1(s2)
+ 4c6: 8526 mv a0,s1
+ 4c8: 00000097 auipc ra,0x0
+ 4cc: f58080e7 jalr -168(ra) # 420 <putc>
+ while(--i >= 0)
+ 4d0: 197d addi s2,s2,-1
+ 4d2: ff3918e3 bne s2,s3,4c2 <printint+0x80>
+}
+ 4d6: 70e2 ld ra,56(sp)
+ 4d8: 7442 ld s0,48(sp)
+ 4da: 74a2 ld s1,40(sp)
+ 4dc: 7902 ld s2,32(sp)
+ 4de: 69e2 ld s3,24(sp)
+ 4e0: 6121 addi sp,sp,64
+ 4e2: 8082 ret
+ x = -xx;
+ 4e4: 40b005bb negw a1,a1
+ neg = 1;
+ 4e8: 4885 li a7,1
+ x = -xx;
+ 4ea: bf8d j 45c <printint+0x1a>
+
+00000000000004ec <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4ec: 7119 addi sp,sp,-128
+ 4ee: fc86 sd ra,120(sp)
+ 4f0: f8a2 sd s0,112(sp)
+ 4f2: f4a6 sd s1,104(sp)
+ 4f4: f0ca sd s2,96(sp)
+ 4f6: ecce sd s3,88(sp)
+ 4f8: e8d2 sd s4,80(sp)
+ 4fa: e4d6 sd s5,72(sp)
+ 4fc: e0da sd s6,64(sp)
+ 4fe: fc5e sd s7,56(sp)
+ 500: f862 sd s8,48(sp)
+ 502: f466 sd s9,40(sp)
+ 504: f06a sd s10,32(sp)
+ 506: ec6e sd s11,24(sp)
+ 508: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 50a: 0005c903 lbu s2,0(a1)
+ 50e: 18090f63 beqz s2,6ac <vprintf+0x1c0>
+ 512: 8aaa mv s5,a0
+ 514: 8b32 mv s6,a2
+ 516: 00158493 addi s1,a1,1
+ state = 0;
+ 51a: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 51c: 02500a13 li s4,37
+ 520: 4c55 li s8,21
+ 522: 00000c97 auipc s9,0x0
+ 526: 3bec8c93 addi s9,s9,958 # 8e0 <malloc+0x130>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 52a: 02800d93 li s11,40
+ putc(fd, 'x');
+ 52e: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 530: 00000b97 auipc s7,0x0
+ 534: 408b8b93 addi s7,s7,1032 # 938 <digits>
+ 538: a839 j 556 <vprintf+0x6a>
+ putc(fd, c);
+ 53a: 85ca mv a1,s2
+ 53c: 8556 mv a0,s5
+ 53e: 00000097 auipc ra,0x0
+ 542: ee2080e7 jalr -286(ra) # 420 <putc>
+ 546: a019 j 54c <vprintf+0x60>
+ } else if(state == '%'){
+ 548: 01498d63 beq s3,s4,562 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 54c: 0485 addi s1,s1,1
+ 54e: fff4c903 lbu s2,-1(s1)
+ 552: 14090d63 beqz s2,6ac <vprintf+0x1c0>
+ if(state == 0){
+ 556: fe0999e3 bnez s3,548 <vprintf+0x5c>
+ if(c == '%'){
+ 55a: ff4910e3 bne s2,s4,53a <vprintf+0x4e>
+ state = '%';
+ 55e: 89d2 mv s3,s4
+ 560: b7f5 j 54c <vprintf+0x60>
+ if(c == 'd'){
+ 562: 11490c63 beq s2,s4,67a <vprintf+0x18e>
+ 566: f9d9079b addiw a5,s2,-99
+ 56a: 0ff7f793 zext.b a5,a5
+ 56e: 10fc6e63 bltu s8,a5,68a <vprintf+0x19e>
+ 572: f9d9079b addiw a5,s2,-99
+ 576: 0ff7f713 zext.b a4,a5
+ 57a: 10ec6863 bltu s8,a4,68a <vprintf+0x19e>
+ 57e: 00271793 slli a5,a4,0x2
+ 582: 97e6 add a5,a5,s9
+ 584: 439c lw a5,0(a5)
+ 586: 97e6 add a5,a5,s9
+ 588: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 58a: 008b0913 addi s2,s6,8
+ 58e: 4685 li a3,1
+ 590: 4629 li a2,10
+ 592: 000b2583 lw a1,0(s6)
+ 596: 8556 mv a0,s5
+ 598: 00000097 auipc ra,0x0
+ 59c: eaa080e7 jalr -342(ra) # 442 <printint>
+ 5a0: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 5a2: 4981 li s3,0
+ 5a4: b765 j 54c <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 5a6: 008b0913 addi s2,s6,8
+ 5aa: 4681 li a3,0
+ 5ac: 4629 li a2,10
+ 5ae: 000b2583 lw a1,0(s6)
+ 5b2: 8556 mv a0,s5
+ 5b4: 00000097 auipc ra,0x0
+ 5b8: e8e080e7 jalr -370(ra) # 442 <printint>
+ 5bc: 8b4a mv s6,s2
+ state = 0;
+ 5be: 4981 li s3,0
+ 5c0: b771 j 54c <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5c2: 008b0913 addi s2,s6,8
+ 5c6: 4681 li a3,0
+ 5c8: 866a mv a2,s10
+ 5ca: 000b2583 lw a1,0(s6)
+ 5ce: 8556 mv a0,s5
+ 5d0: 00000097 auipc ra,0x0
+ 5d4: e72080e7 jalr -398(ra) # 442 <printint>
+ 5d8: 8b4a mv s6,s2
+ state = 0;
+ 5da: 4981 li s3,0
+ 5dc: bf85 j 54c <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5de: 008b0793 addi a5,s6,8
+ 5e2: f8f43423 sd a5,-120(s0)
+ 5e6: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5ea: 03000593 li a1,48
+ 5ee: 8556 mv a0,s5
+ 5f0: 00000097 auipc ra,0x0
+ 5f4: e30080e7 jalr -464(ra) # 420 <putc>
+ putc(fd, 'x');
+ 5f8: 07800593 li a1,120
+ 5fc: 8556 mv a0,s5
+ 5fe: 00000097 auipc ra,0x0
+ 602: e22080e7 jalr -478(ra) # 420 <putc>
+ 606: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 608: 03c9d793 srli a5,s3,0x3c
+ 60c: 97de add a5,a5,s7
+ 60e: 0007c583 lbu a1,0(a5)
+ 612: 8556 mv a0,s5
+ 614: 00000097 auipc ra,0x0
+ 618: e0c080e7 jalr -500(ra) # 420 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 61c: 0992 slli s3,s3,0x4
+ 61e: 397d addiw s2,s2,-1
+ 620: fe0914e3 bnez s2,608 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 624: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 628: 4981 li s3,0
+ 62a: b70d j 54c <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 62c: 008b0913 addi s2,s6,8
+ 630: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 634: 02098163 beqz s3,656 <vprintf+0x16a>
+ while(*s != 0){
+ 638: 0009c583 lbu a1,0(s3)
+ 63c: c5ad beqz a1,6a6 <vprintf+0x1ba>
+ putc(fd, *s);
+ 63e: 8556 mv a0,s5
+ 640: 00000097 auipc ra,0x0
+ 644: de0080e7 jalr -544(ra) # 420 <putc>
+ s++;
+ 648: 0985 addi s3,s3,1
+ while(*s != 0){
+ 64a: 0009c583 lbu a1,0(s3)
+ 64e: f9e5 bnez a1,63e <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 650: 8b4a mv s6,s2
+ state = 0;
+ 652: 4981 li s3,0
+ 654: bde5 j 54c <vprintf+0x60>
+ s = "(null)";
+ 656: 00000997 auipc s3,0x0
+ 65a: 28298993 addi s3,s3,642 # 8d8 <malloc+0x128>
+ while(*s != 0){
+ 65e: 85ee mv a1,s11
+ 660: bff9 j 63e <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 662: 008b0913 addi s2,s6,8
+ 666: 000b4583 lbu a1,0(s6)
+ 66a: 8556 mv a0,s5
+ 66c: 00000097 auipc ra,0x0
+ 670: db4080e7 jalr -588(ra) # 420 <putc>
+ 674: 8b4a mv s6,s2
+ state = 0;
+ 676: 4981 li s3,0
+ 678: bdd1 j 54c <vprintf+0x60>
+ putc(fd, c);
+ 67a: 85d2 mv a1,s4
+ 67c: 8556 mv a0,s5
+ 67e: 00000097 auipc ra,0x0
+ 682: da2080e7 jalr -606(ra) # 420 <putc>
+ state = 0;
+ 686: 4981 li s3,0
+ 688: b5d1 j 54c <vprintf+0x60>
+ putc(fd, '%');
+ 68a: 85d2 mv a1,s4
+ 68c: 8556 mv a0,s5
+ 68e: 00000097 auipc ra,0x0
+ 692: d92080e7 jalr -622(ra) # 420 <putc>
+ putc(fd, c);
+ 696: 85ca mv a1,s2
+ 698: 8556 mv a0,s5
+ 69a: 00000097 auipc ra,0x0
+ 69e: d86080e7 jalr -634(ra) # 420 <putc>
+ state = 0;
+ 6a2: 4981 li s3,0
+ 6a4: b565 j 54c <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6a6: 8b4a mv s6,s2
+ state = 0;
+ 6a8: 4981 li s3,0
+ 6aa: b54d j 54c <vprintf+0x60>
+ }
+ }
+}
+ 6ac: 70e6 ld ra,120(sp)
+ 6ae: 7446 ld s0,112(sp)
+ 6b0: 74a6 ld s1,104(sp)
+ 6b2: 7906 ld s2,96(sp)
+ 6b4: 69e6 ld s3,88(sp)
+ 6b6: 6a46 ld s4,80(sp)
+ 6b8: 6aa6 ld s5,72(sp)
+ 6ba: 6b06 ld s6,64(sp)
+ 6bc: 7be2 ld s7,56(sp)
+ 6be: 7c42 ld s8,48(sp)
+ 6c0: 7ca2 ld s9,40(sp)
+ 6c2: 7d02 ld s10,32(sp)
+ 6c4: 6de2 ld s11,24(sp)
+ 6c6: 6109 addi sp,sp,128
+ 6c8: 8082 ret
+
+00000000000006ca <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6ca: 715d addi sp,sp,-80
+ 6cc: ec06 sd ra,24(sp)
+ 6ce: e822 sd s0,16(sp)
+ 6d0: 1000 addi s0,sp,32
+ 6d2: e010 sd a2,0(s0)
+ 6d4: e414 sd a3,8(s0)
+ 6d6: e818 sd a4,16(s0)
+ 6d8: ec1c sd a5,24(s0)
+ 6da: 03043023 sd a6,32(s0)
+ 6de: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6e2: 8622 mv a2,s0
+ 6e4: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6e8: 00000097 auipc ra,0x0
+ 6ec: e04080e7 jalr -508(ra) # 4ec <vprintf>
+}
+ 6f0: 60e2 ld ra,24(sp)
+ 6f2: 6442 ld s0,16(sp)
+ 6f4: 6161 addi sp,sp,80
+ 6f6: 8082 ret
+
+00000000000006f8 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6f8: 711d addi sp,sp,-96
+ 6fa: ec06 sd ra,24(sp)
+ 6fc: e822 sd s0,16(sp)
+ 6fe: 1000 addi s0,sp,32
+ 700: e40c sd a1,8(s0)
+ 702: e810 sd a2,16(s0)
+ 704: ec14 sd a3,24(s0)
+ 706: f018 sd a4,32(s0)
+ 708: f41c sd a5,40(s0)
+ 70a: 03043823 sd a6,48(s0)
+ 70e: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 712: 00840613 addi a2,s0,8
+ 716: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 71a: 85aa mv a1,a0
+ 71c: 4505 li a0,1
+ 71e: 00000097 auipc ra,0x0
+ 722: dce080e7 jalr -562(ra) # 4ec <vprintf>
+}
+ 726: 60e2 ld ra,24(sp)
+ 728: 6442 ld s0,16(sp)
+ 72a: 6125 addi sp,sp,96
+ 72c: 8082 ret
+
+000000000000072e <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 72e: 1141 addi sp,sp,-16
+ 730: e422 sd s0,8(sp)
+ 732: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 734: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 738: 00000797 auipc a5,0x0
+ 73c: 2187b783 ld a5,536(a5) # 950 <freep>
+ 740: a02d j 76a <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 742: 4618 lw a4,8(a2)
+ 744: 9f2d addw a4,a4,a1
+ 746: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 74a: 6398 ld a4,0(a5)
+ 74c: 6310 ld a2,0(a4)
+ 74e: a83d j 78c <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 750: ff852703 lw a4,-8(a0)
+ 754: 9f31 addw a4,a4,a2
+ 756: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 758: ff053683 ld a3,-16(a0)
+ 75c: a091 j 7a0 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 75e: 6398 ld a4,0(a5)
+ 760: 00e7e463 bltu a5,a4,768 <free+0x3a>
+ 764: 00e6ea63 bltu a3,a4,778 <free+0x4a>
+{
+ 768: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 76a: fed7fae3 bgeu a5,a3,75e <free+0x30>
+ 76e: 6398 ld a4,0(a5)
+ 770: 00e6e463 bltu a3,a4,778 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 774: fee7eae3 bltu a5,a4,768 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 778: ff852583 lw a1,-8(a0)
+ 77c: 6390 ld a2,0(a5)
+ 77e: 02059813 slli a6,a1,0x20
+ 782: 01c85713 srli a4,a6,0x1c
+ 786: 9736 add a4,a4,a3
+ 788: fae60de3 beq a2,a4,742 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 78c: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 790: 4790 lw a2,8(a5)
+ 792: 02061593 slli a1,a2,0x20
+ 796: 01c5d713 srli a4,a1,0x1c
+ 79a: 973e add a4,a4,a5
+ 79c: fae68ae3 beq a3,a4,750 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 7a0: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 7a2: 00000717 auipc a4,0x0
+ 7a6: 1af73723 sd a5,430(a4) # 950 <freep>
+}
+ 7aa: 6422 ld s0,8(sp)
+ 7ac: 0141 addi sp,sp,16
+ 7ae: 8082 ret
+
+00000000000007b0 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 7b0: 7139 addi sp,sp,-64
+ 7b2: fc06 sd ra,56(sp)
+ 7b4: f822 sd s0,48(sp)
+ 7b6: f426 sd s1,40(sp)
+ 7b8: f04a sd s2,32(sp)
+ 7ba: ec4e sd s3,24(sp)
+ 7bc: e852 sd s4,16(sp)
+ 7be: e456 sd s5,8(sp)
+ 7c0: e05a sd s6,0(sp)
+ 7c2: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7c4: 02051493 slli s1,a0,0x20
+ 7c8: 9081 srli s1,s1,0x20
+ 7ca: 04bd addi s1,s1,15
+ 7cc: 8091 srli s1,s1,0x4
+ 7ce: 00148a1b addiw s4,s1,1
+ 7d2: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7d4: 00000517 auipc a0,0x0
+ 7d8: 17c53503 ld a0,380(a0) # 950 <freep>
+ 7dc: c515 beqz a0,808 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7de: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7e0: 4798 lw a4,8(a5)
+ 7e2: 04977163 bgeu a4,s1,824 <malloc+0x74>
+ 7e6: 89d2 mv s3,s4
+ 7e8: 000a071b sext.w a4,s4
+ 7ec: 6685 lui a3,0x1
+ 7ee: 00d77363 bgeu a4,a3,7f4 <malloc+0x44>
+ 7f2: 6985 lui s3,0x1
+ 7f4: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7f8: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7fc: 00000917 auipc s2,0x0
+ 800: 15490913 addi s2,s2,340 # 950 <freep>
+ if(p == (char*)-1)
+ 804: 5afd li s5,-1
+ 806: a8a5 j 87e <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 808: 00000797 auipc a5,0x0
+ 80c: 14878793 addi a5,a5,328 # 950 <freep>
+ 810: 00000717 auipc a4,0x0
+ 814: 14870713 addi a4,a4,328 # 958 <base>
+ 818: e398 sd a4,0(a5)
+ 81a: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 81c: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 820: 87ba mv a5,a4
+ 822: b7d1 j 7e6 <malloc+0x36>
+ if(p->s.size == nunits)
+ 824: 02e48c63 beq s1,a4,85c <malloc+0xac>
+ p->s.size -= nunits;
+ 828: 4147073b subw a4,a4,s4
+ 82c: c798 sw a4,8(a5)
+ p += p->s.size;
+ 82e: 02071693 slli a3,a4,0x20
+ 832: 01c6d713 srli a4,a3,0x1c
+ 836: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 838: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 83c: 00000717 auipc a4,0x0
+ 840: 10a73a23 sd a0,276(a4) # 950 <freep>
+ return (void*)(p + 1);
+ 844: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 848: 70e2 ld ra,56(sp)
+ 84a: 7442 ld s0,48(sp)
+ 84c: 74a2 ld s1,40(sp)
+ 84e: 7902 ld s2,32(sp)
+ 850: 69e2 ld s3,24(sp)
+ 852: 6a42 ld s4,16(sp)
+ 854: 6aa2 ld s5,8(sp)
+ 856: 6b02 ld s6,0(sp)
+ 858: 6121 addi sp,sp,64
+ 85a: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 85c: 6398 ld a4,0(a5)
+ 85e: e118 sd a4,0(a0)
+ 860: bff1 j 83c <malloc+0x8c>
+ hp->s.size = nu;
+ 862: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 866: 0541 addi a0,a0,16
+ 868: 00000097 auipc ra,0x0
+ 86c: ec6080e7 jalr -314(ra) # 72e <free>
+ return freep;
+ 870: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 874: d971 beqz a0,848 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 876: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 878: 4798 lw a4,8(a5)
+ 87a: fa9775e3 bgeu a4,s1,824 <malloc+0x74>
+ if(p == freep)
+ 87e: 00093703 ld a4,0(s2)
+ 882: 853e mv a0,a5
+ 884: fef719e3 bne a4,a5,876 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 888: 854e mv a0,s3
+ 88a: 00000097 auipc ra,0x0
+ 88e: b30080e7 jalr -1232(ra) # 3ba <sbrk>
+ if(p == (char*)-1)
+ 892: fd5518e3 bne a0,s5,862 <malloc+0xb2>
+ return 0;
+ 896: 4501 li a0,0
+ 898: bf45 j 848 <malloc+0x98>
diff --git a/xv6-user/rm.c b/xv6-user/rm.c
new file mode 100644
index 0000000000000000000000000000000000000000..170b20096681aa8c6584ecab5e86ab62b6cc2ebd
--- /dev/null
+++ b/xv6-user/rm.c
@@ -0,0 +1,23 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+
+ if(argc < 2){
+ fprintf(2, "Usage: rm files...\n");
+ exit(1);
+ }
+
+ for(i = 1; i < argc; i++){
+ if(remove(argv[i]) < 0){
+ fprintf(2, "rm: %s failed to delete\n", argv[i]);
+ }
+ }
+
+ exit(0);
+}
diff --git a/xv6-user/rm.d b/xv6-user/rm.d
new file mode 100644
index 0000000000000000000000000000000000000000..38a71085b4c273a22ad0347575bb404264f98c64
--- /dev/null
+++ b/xv6-user/rm.d
@@ -0,0 +1,2 @@
+xv6-user/rm.o: xv6-user/rm.c kernel/include/types.h kernel/include/stat.h \
+ kernel/include/fcntl.h xv6-user/user.h
diff --git a/xv6-user/rm.o b/xv6-user/rm.o
new file mode 100644
index 0000000000000000000000000000000000000000..95a492affec725edf5de65fc226fe7471de939aa
Binary files /dev/null and b/xv6-user/rm.o differ
diff --git a/xv6-user/rm.sym b/xv6-user/rm.sym
new file mode 100644
index 0000000000000000000000000000000000000000..659a8ba9b4c46701ba72999dc6b04557804d1387
--- /dev/null
+++ b/xv6-user/rm.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+00000000000008a0 .rodata
+0000000000000950 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 rm.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000420 putc
+0000000000000442 printint
+0000000000000938 digits
+0000000000000000 umalloc.c
+0000000000000950 freep
+0000000000000958 base
+000000000000007c strcpy
+00000000000006f8 printf
+0000000000001149 __global_pointer$
+00000000000003da dev
+0000000000000282 memmove
+00000000000003fe trace
+0000000000000162 gets
+0000000000000949 __SDATA_BEGIN__
+00000000000003b0 getpid
+0000000000000314 memcpy
+00000000000007b0 malloc
+00000000000003f4 remove
+00000000000003c2 sleep
+0000000000000406 sysinfo
+00000000000003e4 readdir
+0000000000000346 pipe
+000000000000040e rename
+000000000000035a write
+000000000000038a fstat
+00000000000006ca fprintf
+000000000000036e kill
+0000000000000098 strcat
+00000000000004ec vprintf
+000000000000039e chdir
+0000000000000376 exec
+000000000000033e wait
+0000000000000350 read
+00000000000002da memcmp
+000000000000032c fork
+0000000000000968 __BSS_END__
+00000000000003ba sbrk
+00000000000003d2 test_proc
+00000000000003ca uptime
+0000000000000949 __bss_start
+000000000000011c memset
+0000000000000000 main
+00000000000000c6 strcmp
+0000000000000416 shutdown
+00000000000003a8 dup
+00000000000003ec getcwd
+0000000000000949 __DATA_BEGIN__
+00000000000001dc stat
+0000000000000949 _edata
+0000000000000968 _end
+0000000000000334 exit
+0000000000000222 atoi
+00000000000000f2 strlen
+0000000000000380 open
+000000000000013e strchr
+0000000000000394 mkdir
+0000000000000364 close
+000000000000072e free
diff --git a/xv6-user/sh.asm b/xv6-user/sh.asm
new file mode 100644
index 0000000000000000000000000000000000000000..53dc7abc564b6b2cb7ae2df0f3f6cd0f4e2a18da
--- /dev/null
+++ b/xv6-user/sh.asm
@@ -0,0 +1,3403 @@
+
+xv6-user/_sh: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <checkenvname>:
+
+char mycwd[128];
+
+int
+checkenvname(char* s)
+{
+ 0: 1141 addi sp,sp,-16
+ 2: e422 sd s0,8(sp)
+ 4: 0800 addi s0,sp,16
+ 6: 88aa mv a7,a0
+ if((*s >= 'A' && *s <= 'Z') ||
+ 8: 00054703 lbu a4,0(a0)
+ c: fdf77793 andi a5,a4,-33
+ 10: fbf7879b addiw a5,a5,-65
+ 14: 0ff7f793 zext.b a5,a5
+ 18: 46e5 li a3,25
+ 1a: 00f6f763 bgeu a3,a5,28 <checkenvname+0x28>
+ (*s >= 'a' && *s <= 'z') ||
+ 1e: 05f00793 li a5,95
+ *s == '_')
+ ;
+ else
+ return 0;
+ 22: 4501 li a0,0
+ (*s >= 'a' && *s <= 'z') ||
+ 24: 02f71e63 bne a4,a5,60 <checkenvname+0x60>
+ char *tmp = s + 1;
+ 28: 00188713 addi a4,a7,1
+ while((*tmp >= 'A' && *tmp <= 'Z') ||
+ (*tmp >= 'a' && *tmp <= 'z') ||
+ (*tmp >= '0' && *tmp <= '9') ||
+ 2c: 4665 li a2,25
+ (*tmp >= 'a' && *tmp <= 'z') ||
+ 2e: 45a5 li a1,9
+ (*tmp >= '0' && *tmp <= '9') ||
+ 30: 05f00813 li a6,95
+ while((*tmp >= 'A' && *tmp <= 'Z') ||
+ 34: a011 j 38 <checkenvname+0x38>
+ *tmp == '_')
+ tmp++;
+ 36: 0705 addi a4,a4,1
+ while((*tmp >= 'A' && *tmp <= 'Z') ||
+ 38: 00074683 lbu a3,0(a4)
+ (*tmp >= '0' && *tmp <= '9') ||
+ 3c: fdf6f793 andi a5,a3,-33
+ 40: fbf7879b addiw a5,a5,-65
+ 44: 0ff7f793 zext.b a5,a5
+ 48: fef677e3 bgeu a2,a5,36 <checkenvname+0x36>
+ 4c: fd06879b addiw a5,a3,-48
+ (*tmp >= 'a' && *tmp <= 'z') ||
+ 50: 0ff7f793 zext.b a5,a5
+ 54: fef5f1e3 bgeu a1,a5,36 <checkenvname+0x36>
+ (*tmp >= '0' && *tmp <= '9') ||
+ 58: fd068fe3 beq a3,a6,36 <checkenvname+0x36>
+ return (int)(tmp - s);
+ 5c: 4117053b subw a0,a4,a7
+}
+ 60: 6422 ld s0,8(sp)
+ 62: 0141 addi sp,sp,16
+ 64: 8082 ret
+
+0000000000000066 <export>:
+
+int
+export(char *argv[])
+{
+ 66: 7131 addi sp,sp,-192
+ 68: fd06 sd ra,184(sp)
+ 6a: f922 sd s0,176(sp)
+ 6c: f526 sd s1,168(sp)
+ 6e: f14a sd s2,160(sp)
+ 70: ed4e sd s3,152(sp)
+ 72: e952 sd s4,144(sp)
+ 74: e556 sd s5,136(sp)
+ 76: e15a sd s6,128(sp)
+ 78: 0180 addi s0,sp,192
+ 7a: 84aa mv s1,a0
+ if(!strcmp(argv[1], "-p"))
+ 7c: 00001597 auipc a1,0x1
+ 80: 7dc58593 addi a1,a1,2012 # 1858 <malloc+0xec>
+ 84: 6508 ld a0,8(a0)
+ 86: 00001097 auipc ra,0x1
+ 8a: ffc080e7 jalr -4(ra) # 1082 <strcmp>
+ 8e: e12d bnez a0,f0 <export+0x8a>
+ 90: 89aa mv s3,a0
+ { // print all the env vars
+ if(!nenv)
+ 92: 00002b17 auipc s6,0x2
+ 96: a2eb2b03 lw s6,-1490(s6) # 1ac0 <nenv>
+ 9a: 040b0163 beqz s6,dc <export+0x76>
+ {
+ printf("NO env var exported\n");
+ return 0;
+ }
+ for(int i=0; i<nenv; i++)
+ 9e: 00002497 auipc s1,0x2
+ a2: b1248493 addi s1,s1,-1262 # 1bb0 <envs>
+ a6: 892a mv s2,a0
+ printf("export %s=%s\n", envs[i].name, envs[i].value);
+ a8: 00001a97 auipc s5,0x1
+ ac: 7d0a8a93 addi s5,s5,2000 # 1878 <malloc+0x10c>
+ for(int i=0; i<nenv; i++)
+ b0: 00002a17 auipc s4,0x2
+ b4: a10a0a13 addi s4,s4,-1520 # 1ac0 <nenv>
+ b8: 0f605c63 blez s6,1b0 <export+0x14a>
+ printf("export %s=%s\n", envs[i].name, envs[i].value);
+ bc: 02048613 addi a2,s1,32
+ c0: 85a6 mv a1,s1
+ c2: 8556 mv a0,s5
+ c4: 00001097 auipc ra,0x1
+ c8: 5f0080e7 jalr 1520(ra) # 16b4 <printf>
+ for(int i=0; i<nenv; i++)
+ cc: 2905 addiw s2,s2,1
+ ce: 08048493 addi s1,s1,128
+ d2: 000a2783 lw a5,0(s4)
+ d6: fef943e3 blt s2,a5,bc <export+0x56>
+ da: a8d9 j 1b0 <export+0x14a>
+ printf("NO env var exported\n");
+ dc: 00001517 auipc a0,0x1
+ e0: 78450513 addi a0,a0,1924 # 1860 <malloc+0xf4>
+ e4: 00001097 auipc ra,0x1
+ e8: 5d0080e7 jalr 1488(ra) # 16b4 <printf>
+ return 0;
+ ec: 89da mv s3,s6
+ ee: a0c9 j 1b0 <export+0x14a>
+ return 0;
+ }
+ else if(nenv == NENVS)
+ f0: 00002997 auipc s3,0x2
+ f4: 9d09a983 lw s3,-1584(s3) # 1ac0 <nenv>
+ f8: 47c1 li a5,16
+ fa: 0cf98663 beq s3,a5,1c6 <export+0x160>
+ {
+ fprintf(2, "too many env vars\n");
+ return -1;
+ }
+ char name[32], value[96];
+ char *s = argv[1], *t = name;
+ fe: 0084b903 ld s2,8(s1)
+
+ for(s=argv[1], t=name; (*t=*s++)!='='; t++)
+ 102: 00190493 addi s1,s2,1
+ 106: 00094783 lbu a5,0(s2)
+ 10a: faf40023 sb a5,-96(s0)
+ 10e: 03d00713 li a4,61
+ 112: 0ce78563 beq a5,a4,1dc <export+0x176>
+ 116: fa040793 addi a5,s0,-96
+ 11a: 03d00693 li a3,61
+ 11e: 0785 addi a5,a5,1
+ 120: 0485 addi s1,s1,1
+ 122: fff4c703 lbu a4,-1(s1)
+ 126: 00e78023 sb a4,0(a5)
+ 12a: fed71ae3 bne a4,a3,11e <export+0xb8>
+ ;
+ *t = 0;
+ 12e: 00078023 sb zero,0(a5)
+
+ if(checkenvname(name) != ((s - argv[1]) - 1))
+ 132: fa040513 addi a0,s0,-96
+ 136: 00000097 auipc ra,0x0
+ 13a: eca080e7 jalr -310(ra) # 0 <checkenvname>
+ 13e: 41248933 sub s2,s1,s2
+ 142: 197d addi s2,s2,-1
+ 144: 09251f63 bne a0,s2,1e2 <export+0x17c>
+ {
+ fprintf(2, "Invalid NAME!\n");
+ return -1;
+ }
+ for(t=value; (*t=*s); s++, t++)
+ 148: 0004c703 lbu a4,0(s1)
+ 14c: f4e40023 sb a4,-192(s0)
+ 150: f4040793 addi a5,s0,-192
+ 154: cb01 beqz a4,164 <export+0xfe>
+ 156: 0485 addi s1,s1,1
+ 158: 0785 addi a5,a5,1
+ 15a: 0004c703 lbu a4,0(s1)
+ 15e: 00e78023 sb a4,0(a5)
+ 162: fb75 bnez a4,156 <export+0xf0>
+ ;
+ if(*--t == '/')
+ 164: fff7c683 lbu a3,-1(a5)
+ 168: 02f00713 li a4,47
+ 16c: 08e68663 beq a3,a4,1f8 <export+0x192>
+ *t = 0;
+
+ strcpy(envs[nenv].name, name);
+ 170: 00799513 slli a0,s3,0x7
+ 174: 00002917 auipc s2,0x2
+ 178: a3c90913 addi s2,s2,-1476 # 1bb0 <envs>
+ 17c: fa040593 addi a1,s0,-96
+ 180: 954a add a0,a0,s2
+ 182: 00001097 auipc ra,0x1
+ 186: eb6080e7 jalr -330(ra) # 1038 <strcpy>
+ strcpy(envs[nenv].value, value);
+ 18a: 00002497 auipc s1,0x2
+ 18e: 93648493 addi s1,s1,-1738 # 1ac0 <nenv>
+ 192: 4088 lw a0,0(s1)
+ 194: 051e slli a0,a0,0x7
+ 196: 02050513 addi a0,a0,32
+ 19a: f4040593 addi a1,s0,-192
+ 19e: 954a add a0,a0,s2
+ 1a0: 00001097 auipc ra,0x1
+ 1a4: e98080e7 jalr -360(ra) # 1038 <strcpy>
+ nenv++;
+ 1a8: 409c lw a5,0(s1)
+ 1aa: 2785 addiw a5,a5,1
+ 1ac: c09c sw a5,0(s1)
+ return 0;
+ 1ae: 4981 li s3,0
+}
+ 1b0: 854e mv a0,s3
+ 1b2: 70ea ld ra,184(sp)
+ 1b4: 744a ld s0,176(sp)
+ 1b6: 74aa ld s1,168(sp)
+ 1b8: 790a ld s2,160(sp)
+ 1ba: 69ea ld s3,152(sp)
+ 1bc: 6a4a ld s4,144(sp)
+ 1be: 6aaa ld s5,136(sp)
+ 1c0: 6b0a ld s6,128(sp)
+ 1c2: 6129 addi sp,sp,192
+ 1c4: 8082 ret
+ fprintf(2, "too many env vars\n");
+ 1c6: 00001597 auipc a1,0x1
+ 1ca: 6c258593 addi a1,a1,1730 # 1888 <malloc+0x11c>
+ 1ce: 4509 li a0,2
+ 1d0: 00001097 auipc ra,0x1
+ 1d4: 4b6080e7 jalr 1206(ra) # 1686 <fprintf>
+ return -1;
+ 1d8: 59fd li s3,-1
+ 1da: bfd9 j 1b0 <export+0x14a>
+ for(s=argv[1], t=name; (*t=*s++)!='='; t++)
+ 1dc: fa040793 addi a5,s0,-96
+ 1e0: b7b9 j 12e <export+0xc8>
+ fprintf(2, "Invalid NAME!\n");
+ 1e2: 00001597 auipc a1,0x1
+ 1e6: 6be58593 addi a1,a1,1726 # 18a0 <malloc+0x134>
+ 1ea: 4509 li a0,2
+ 1ec: 00001097 auipc ra,0x1
+ 1f0: 49a080e7 jalr 1178(ra) # 1686 <fprintf>
+ return -1;
+ 1f4: 59fd li s3,-1
+ 1f6: bf6d j 1b0 <export+0x14a>
+ *t = 0;
+ 1f8: fe078fa3 sb zero,-1(a5)
+ 1fc: bf95 j 170 <export+0x10a>
+
+00000000000001fe <replace>:
+
+int
+replace(char *buf)
+{
+ 1fe: 7111 addi sp,sp,-256
+ 200: fd86 sd ra,248(sp)
+ 202: f9a2 sd s0,240(sp)
+ 204: f5a6 sd s1,232(sp)
+ 206: f1ca sd s2,224(sp)
+ 208: edce sd s3,216(sp)
+ 20a: e9d2 sd s4,208(sp)
+ 20c: e5d6 sd s5,200(sp)
+ 20e: e1da sd s6,192(sp)
+ 210: fd5e sd s7,184(sp)
+ 212: f962 sd s8,176(sp)
+ 214: f566 sd s9,168(sp)
+ 216: f16a sd s10,160(sp)
+ 218: ed6e sd s11,152(sp)
+ 21a: 0200 addi s0,sp,256
+ 21c: 89aa mv s3,a0
+ char raw[100], name[32], *s, *t, *tmp;
+ int n = 0;
+ strcpy(raw, buf);
+ 21e: 85aa mv a1,a0
+ 220: f2840513 addi a0,s0,-216
+ 224: 00001097 auipc ra,0x1
+ 228: e14080e7 jalr -492(ra) # 1038 <strcpy>
+ for(s=raw, t=buf; (*t=*s); t++)
+ 22c: f2844783 lbu a5,-216(s0)
+ 230: 00f98023 sb a5,0(s3)
+ 234: c7f5 beqz a5,320 <replace+0x122>
+ int n = 0;
+ 236: 4c81 li s9,0
+ for(s=raw, t=buf; (*t=*s); t++)
+ 238: f2840713 addi a4,s0,-216
+ {
+ if(*s++ == '$'){
+ 23c: 02400c13 li s8,36
+ tmp = name;
+ if((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || *s == '_')
+ 240: 4965 li s2,25
+ {
+ *tmp++ = *s++;
+ while((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || (*s >= '0' && *s <= '9') || *s == '_')
+ 242: 4a25 li s4,9
+ 244: 05f00a93 li s5,95
+ *tmp++ = *s++;
+ *tmp = 0;
+ for(int i=0; i<nenv; i++)
+ 248: 00002b17 auipc s6,0x2
+ 24c: 878b0b13 addi s6,s6,-1928 # 1ac0 <nenv>
+ if(!strcmp(name, envs[i].name))
+ 250: f0840b93 addi s7,s0,-248
+ 254: a03d j 282 <replace+0x84>
+ if((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || *s == '_')
+ 256: 00174683 lbu a3,1(a4)
+ 25a: fdf6f793 andi a5,a3,-33
+ 25e: fbf7879b addiw a5,a5,-65
+ 262: 0ff7f793 zext.b a5,a5
+ 266: 02f97563 bgeu s2,a5,290 <replace+0x92>
+ 26a: 03568363 beq a3,s5,290 <replace+0x92>
+ for(tmp=envs[i].value; (*t=*tmp); t++, tmp++)
+ ;
+ t--;
+ }
+ n++;
+ 26e: 2c85 addiw s9,s9,1
+ 270: 86ce mv a3,s3
+ 272: 8726 mv a4,s1
+ for(s=raw, t=buf; (*t=*s); t++)
+ 274: 00168993 addi s3,a3,1
+ 278: 00074783 lbu a5,0(a4)
+ 27c: 00f680a3 sb a5,1(a3)
+ 280: c3cd beqz a5,322 <replace+0x124>
+ if(*s++ == '$'){
+ 282: 00170493 addi s1,a4,1
+ 286: fd8788e3 beq a5,s8,256 <replace+0x58>
+ 28a: 86ce mv a3,s3
+ 28c: 8726 mv a4,s1
+ 28e: b7dd j 274 <replace+0x76>
+ *tmp++ = *s++;
+ 290: 00270493 addi s1,a4,2
+ 294: f0d40423 sb a3,-248(s0)
+ 298: f0940693 addi a3,s0,-247
+ while((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || (*s >= '0' && *s <= '9') || *s == '_')
+ 29c: a029 j 2a6 <replace+0xa8>
+ *tmp++ = *s++;
+ 29e: 0485 addi s1,s1,1
+ 2a0: 0685 addi a3,a3,1
+ 2a2: fee68fa3 sb a4,-1(a3)
+ while((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || (*s >= '0' && *s <= '9') || *s == '_')
+ 2a6: 0004c703 lbu a4,0(s1)
+ 2aa: fdf77793 andi a5,a4,-33
+ 2ae: fbf7879b addiw a5,a5,-65
+ 2b2: 0ff7f793 zext.b a5,a5
+ 2b6: fef974e3 bgeu s2,a5,29e <replace+0xa0>
+ 2ba: fd07079b addiw a5,a4,-48
+ 2be: 0ff7f793 zext.b a5,a5
+ 2c2: fcfa7ee3 bgeu s4,a5,29e <replace+0xa0>
+ 2c6: fd570ce3 beq a4,s5,29e <replace+0xa0>
+ *tmp = 0;
+ 2ca: 00068023 sb zero,0(a3)
+ for(int i=0; i<nenv; i++)
+ 2ce: 000b2783 lw a5,0(s6)
+ 2d2: 04f05563 blez a5,31c <replace+0x11e>
+ 2d6: 00002d17 auipc s10,0x2
+ 2da: 8fad0d13 addi s10,s10,-1798 # 1bd0 <envs+0x20>
+ 2de: 4d81 li s11,0
+ 2e0: a801 j 2f0 <replace+0xf2>
+ 2e2: 2d85 addiw s11,s11,1
+ 2e4: 080d0d13 addi s10,s10,128
+ 2e8: 000b2783 lw a5,0(s6)
+ 2ec: 02fdd863 bge s11,a5,31c <replace+0x11e>
+ if(!strcmp(name, envs[i].name))
+ 2f0: fe0d0593 addi a1,s10,-32
+ 2f4: 855e mv a0,s7
+ 2f6: 00001097 auipc ra,0x1
+ 2fa: d8c080e7 jalr -628(ra) # 1082 <strcmp>
+ 2fe: f175 bnez a0,2e2 <replace+0xe4>
+ for(tmp=envs[i].value; (*t=*tmp); t++, tmp++)
+ 300: 87ea mv a5,s10
+ 302: 000d4703 lbu a4,0(s10)
+ 306: 00e98023 sb a4,0(s3)
+ 30a: df61 beqz a4,2e2 <replace+0xe4>
+ 30c: 0985 addi s3,s3,1
+ 30e: 0785 addi a5,a5,1
+ 310: 0007c703 lbu a4,0(a5)
+ 314: 00e98023 sb a4,0(s3)
+ 318: fb75 bnez a4,30c <replace+0x10e>
+ 31a: b7e1 j 2e2 <replace+0xe4>
+ t--;
+ 31c: 19fd addi s3,s3,-1
+ 31e: bf81 j 26e <replace+0x70>
+ int n = 0;
+ 320: 4c81 li s9,0
+ }
+ }
+ return n;
+}
+ 322: 8566 mv a0,s9
+ 324: 70ee ld ra,248(sp)
+ 326: 744e ld s0,240(sp)
+ 328: 74ae ld s1,232(sp)
+ 32a: 790e ld s2,224(sp)
+ 32c: 69ee ld s3,216(sp)
+ 32e: 6a4e ld s4,208(sp)
+ 330: 6aae ld s5,200(sp)
+ 332: 6b0e ld s6,192(sp)
+ 334: 7bea ld s7,184(sp)
+ 336: 7c4a ld s8,176(sp)
+ 338: 7caa ld s9,168(sp)
+ 33a: 7d0a ld s10,160(sp)
+ 33c: 6dea ld s11,152(sp)
+ 33e: 6111 addi sp,sp,256
+ 340: 8082 ret
+
+0000000000000342 <getcmd>:
+ exit(0);
+}
+
+int
+getcmd(char *buf, int nbuf)
+{
+ 342: 1101 addi sp,sp,-32
+ 344: ec06 sd ra,24(sp)
+ 346: e822 sd s0,16(sp)
+ 348: e426 sd s1,8(sp)
+ 34a: e04a sd s2,0(sp)
+ 34c: 1000 addi s0,sp,32
+ 34e: 84aa mv s1,a0
+ 350: 892e mv s2,a1
+ fprintf(2, "-> %s $ ", mycwd);
+ 352: 00001617 auipc a2,0x1
+ 356: 77660613 addi a2,a2,1910 # 1ac8 <mycwd>
+ 35a: 00001597 auipc a1,0x1
+ 35e: 55658593 addi a1,a1,1366 # 18b0 <malloc+0x144>
+ 362: 4509 li a0,2
+ 364: 00001097 auipc ra,0x1
+ 368: 322080e7 jalr 802(ra) # 1686 <fprintf>
+ memset(buf, 0, nbuf);
+ 36c: 864a mv a2,s2
+ 36e: 4581 li a1,0
+ 370: 8526 mv a0,s1
+ 372: 00001097 auipc ra,0x1
+ 376: d66080e7 jalr -666(ra) # 10d8 <memset>
+ gets(buf, nbuf);
+ 37a: 85ca mv a1,s2
+ 37c: 8526 mv a0,s1
+ 37e: 00001097 auipc ra,0x1
+ 382: da0080e7 jalr -608(ra) # 111e <gets>
+ if(buf[0] == 0) // EOF
+ 386: 0004c503 lbu a0,0(s1)
+ 38a: 00153513 seqz a0,a0
+ return -1;
+ return 0;
+}
+ 38e: 40a00533 neg a0,a0
+ 392: 60e2 ld ra,24(sp)
+ 394: 6442 ld s0,16(sp)
+ 396: 64a2 ld s1,8(sp)
+ 398: 6902 ld s2,0(sp)
+ 39a: 6105 addi sp,sp,32
+ 39c: 8082 ret
+
+000000000000039e <panic>:
+ exit(0);
+}
+
+void
+panic(char *s)
+{
+ 39e: 1141 addi sp,sp,-16
+ 3a0: e406 sd ra,8(sp)
+ 3a2: e022 sd s0,0(sp)
+ 3a4: 0800 addi s0,sp,16
+ 3a6: 862a mv a2,a0
+ fprintf(2, "%s\n", s);
+ 3a8: 00001597 auipc a1,0x1
+ 3ac: 51858593 addi a1,a1,1304 # 18c0 <malloc+0x154>
+ 3b0: 4509 li a0,2
+ 3b2: 00001097 auipc ra,0x1
+ 3b6: 2d4080e7 jalr 724(ra) # 1686 <fprintf>
+ exit(1);
+ 3ba: 4505 li a0,1
+ 3bc: 00001097 auipc ra,0x1
+ 3c0: f34080e7 jalr -204(ra) # 12f0 <exit>
+
+00000000000003c4 <fork1>:
+}
+
+int
+fork1(void)
+{
+ 3c4: 1141 addi sp,sp,-16
+ 3c6: e406 sd ra,8(sp)
+ 3c8: e022 sd s0,0(sp)
+ 3ca: 0800 addi s0,sp,16
+ int pid;
+
+ pid = fork();
+ 3cc: 00001097 auipc ra,0x1
+ 3d0: f1c080e7 jalr -228(ra) # 12e8 <fork>
+ if(pid == -1)
+ 3d4: 57fd li a5,-1
+ 3d6: 00f50663 beq a0,a5,3e2 <fork1+0x1e>
+ panic("fork");
+ return pid;
+}
+ 3da: 60a2 ld ra,8(sp)
+ 3dc: 6402 ld s0,0(sp)
+ 3de: 0141 addi sp,sp,16
+ 3e0: 8082 ret
+ panic("fork");
+ 3e2: 00001517 auipc a0,0x1
+ 3e6: 4e650513 addi a0,a0,1254 # 18c8 <malloc+0x15c>
+ 3ea: 00000097 auipc ra,0x0
+ 3ee: fb4080e7 jalr -76(ra) # 39e <panic>
+
+00000000000003f2 <runcmd>:
+{
+ 3f2: 7135 addi sp,sp,-160
+ 3f4: ed06 sd ra,152(sp)
+ 3f6: e922 sd s0,144(sp)
+ 3f8: e526 sd s1,136(sp)
+ 3fa: e14a sd s2,128(sp)
+ 3fc: fcce sd s3,120(sp)
+ 3fe: f8d2 sd s4,112(sp)
+ 400: f4d6 sd s5,104(sp)
+ 402: f0da sd s6,96(sp)
+ 404: ecde sd s7,88(sp)
+ 406: 1100 addi s0,sp,160
+ if(cmd == 0)
+ 408: c10d beqz a0,42a <runcmd+0x38>
+ 40a: 84aa mv s1,a0
+ switch(cmd->type){
+ 40c: 4118 lw a4,0(a0)
+ 40e: 4795 li a5,5
+ 410: 02e7e263 bltu a5,a4,434 <runcmd+0x42>
+ 414: 00056783 lwu a5,0(a0)
+ 418: 078a slli a5,a5,0x2
+ 41a: 00001717 auipc a4,0x1
+ 41e: 5ee70713 addi a4,a4,1518 # 1a08 <malloc+0x29c>
+ 422: 97ba add a5,a5,a4
+ 424: 439c lw a5,0(a5)
+ 426: 97ba add a5,a5,a4
+ 428: 8782 jr a5
+ exit(1);
+ 42a: 4505 li a0,1
+ 42c: 00001097 auipc ra,0x1
+ 430: ec4080e7 jalr -316(ra) # 12f0 <exit>
+ panic("runcmd");
+ 434: 00001517 auipc a0,0x1
+ 438: 49c50513 addi a0,a0,1180 # 18d0 <malloc+0x164>
+ 43c: 00000097 auipc ra,0x0
+ 440: f62080e7 jalr -158(ra) # 39e <panic>
+ if(ecmd->argv[0] == 0)
+ 444: 6508 ld a0,8(a0)
+ 446: c155 beqz a0,4ea <runcmd+0xf8>
+ exec(ecmd->argv[0], ecmd->argv);
+ 448: 00848a13 addi s4,s1,8
+ 44c: 85d2 mv a1,s4
+ 44e: 00001097 auipc ra,0x1
+ 452: ee4080e7 jalr -284(ra) # 1332 <exec>
+ for(i=0; i<nenv; i++)
+ 456: 00001797 auipc a5,0x1
+ 45a: 66a7a783 lw a5,1642(a5) # 1ac0 <nenv>
+ 45e: 06f05763 blez a5,4cc <runcmd+0xda>
+ 462: 00001917 auipc s2,0x1
+ 466: 76f90913 addi s2,s2,1903 # 1bd1 <envs+0x21>
+ 46a: 4981 li s3,0
+ *s_tmp++ = '/';
+ 46c: 02f00b93 li s7,47
+ exec(env_cmd, ecmd->argv);
+ 470: f6840b13 addi s6,s0,-152
+ for(i=0; i<nenv; i++)
+ 474: 00001a97 auipc s5,0x1
+ 478: 64ca8a93 addi s5,s5,1612 # 1ac0 <nenv>
+ while((*s_tmp = *d_tmp++))
+ 47c: 874a mv a4,s2
+ 47e: fff94783 lbu a5,-1(s2)
+ 482: f6f40423 sb a5,-152(s0)
+ 486: c7bd beqz a5,4f4 <runcmd+0x102>
+ char *s_tmp = env_cmd;
+ 488: f6840793 addi a5,s0,-152
+ s_tmp++;
+ 48c: 0785 addi a5,a5,1
+ while((*s_tmp = *d_tmp++))
+ 48e: 0705 addi a4,a4,1
+ 490: fff74683 lbu a3,-1(a4)
+ 494: 00d78023 sb a3,0(a5)
+ 498: faf5 bnez a3,48c <runcmd+0x9a>
+ *s_tmp++ = '/';
+ 49a: 00178713 addi a4,a5,1
+ 49e: 01778023 sb s7,0(a5)
+ d_tmp = ecmd->argv[0];
+ 4a2: 649c ld a5,8(s1)
+ while((*s_tmp++ = *d_tmp++))
+ 4a4: 0785 addi a5,a5,1
+ 4a6: 0705 addi a4,a4,1
+ 4a8: fff7c683 lbu a3,-1(a5)
+ 4ac: fed70fa3 sb a3,-1(a4)
+ 4b0: faf5 bnez a3,4a4 <runcmd+0xb2>
+ exec(env_cmd, ecmd->argv);
+ 4b2: 85d2 mv a1,s4
+ 4b4: 855a mv a0,s6
+ 4b6: 00001097 auipc ra,0x1
+ 4ba: e7c080e7 jalr -388(ra) # 1332 <exec>
+ for(i=0; i<nenv; i++)
+ 4be: 2985 addiw s3,s3,1
+ 4c0: 08090913 addi s2,s2,128
+ 4c4: 000aa783 lw a5,0(s5)
+ 4c8: faf9cae3 blt s3,a5,47c <runcmd+0x8a>
+ fprintf(2, "exec %s failed\n", ecmd->argv[0]);
+ 4cc: 6490 ld a2,8(s1)
+ 4ce: 00001597 auipc a1,0x1
+ 4d2: 40a58593 addi a1,a1,1034 # 18d8 <malloc+0x16c>
+ 4d6: 4509 li a0,2
+ 4d8: 00001097 auipc ra,0x1
+ 4dc: 1ae080e7 jalr 430(ra) # 1686 <fprintf>
+ exit(0);
+ 4e0: 4501 li a0,0
+ 4e2: 00001097 auipc ra,0x1
+ 4e6: e0e080e7 jalr -498(ra) # 12f0 <exit>
+ exit(1);
+ 4ea: 4505 li a0,1
+ 4ec: 00001097 auipc ra,0x1
+ 4f0: e04080e7 jalr -508(ra) # 12f0 <exit>
+ char *s_tmp = env_cmd;
+ 4f4: f6840793 addi a5,s0,-152
+ 4f8: b74d j 49a <runcmd+0xa8>
+ close(rcmd->fd);
+ 4fa: 5148 lw a0,36(a0)
+ 4fc: 00001097 auipc ra,0x1
+ 500: e24080e7 jalr -476(ra) # 1320 <close>
+ if(open(rcmd->file, rcmd->mode) < 0){
+ 504: 508c lw a1,32(s1)
+ 506: 6888 ld a0,16(s1)
+ 508: 00001097 auipc ra,0x1
+ 50c: e34080e7 jalr -460(ra) # 133c <open>
+ 510: 00054763 bltz a0,51e <runcmd+0x12c>
+ runcmd(rcmd->cmd);
+ 514: 6488 ld a0,8(s1)
+ 516: 00000097 auipc ra,0x0
+ 51a: edc080e7 jalr -292(ra) # 3f2 <runcmd>
+ fprintf(2, "open %s failed\n", rcmd->file);
+ 51e: 6890 ld a2,16(s1)
+ 520: 00001597 auipc a1,0x1
+ 524: 3c858593 addi a1,a1,968 # 18e8 <malloc+0x17c>
+ 528: 4509 li a0,2
+ 52a: 00001097 auipc ra,0x1
+ 52e: 15c080e7 jalr 348(ra) # 1686 <fprintf>
+ exit(1);
+ 532: 4505 li a0,1
+ 534: 00001097 auipc ra,0x1
+ 538: dbc080e7 jalr -580(ra) # 12f0 <exit>
+ if(fork1() == 0)
+ 53c: 00000097 auipc ra,0x0
+ 540: e88080e7 jalr -376(ra) # 3c4 <fork1>
+ 544: c919 beqz a0,55a <runcmd+0x168>
+ wait(0);
+ 546: 4501 li a0,0
+ 548: 00001097 auipc ra,0x1
+ 54c: db2080e7 jalr -590(ra) # 12fa <wait>
+ runcmd(lcmd->right);
+ 550: 6888 ld a0,16(s1)
+ 552: 00000097 auipc ra,0x0
+ 556: ea0080e7 jalr -352(ra) # 3f2 <runcmd>
+ runcmd(lcmd->left);
+ 55a: 6488 ld a0,8(s1)
+ 55c: 00000097 auipc ra,0x0
+ 560: e96080e7 jalr -362(ra) # 3f2 <runcmd>
+ if(pipe(p) < 0)
+ 564: fa840513 addi a0,s0,-88
+ 568: 00001097 auipc ra,0x1
+ 56c: d9a080e7 jalr -614(ra) # 1302 <pipe>
+ 570: 04054363 bltz a0,5b6 <runcmd+0x1c4>
+ if(fork1() == 0){
+ 574: 00000097 auipc ra,0x0
+ 578: e50080e7 jalr -432(ra) # 3c4 <fork1>
+ 57c: c529 beqz a0,5c6 <runcmd+0x1d4>
+ if(fork1() == 0){
+ 57e: 00000097 auipc ra,0x0
+ 582: e46080e7 jalr -442(ra) # 3c4 <fork1>
+ 586: cd25 beqz a0,5fe <runcmd+0x20c>
+ close(p[0]);
+ 588: fa842503 lw a0,-88(s0)
+ 58c: 00001097 auipc ra,0x1
+ 590: d94080e7 jalr -620(ra) # 1320 <close>
+ close(p[1]);
+ 594: fac42503 lw a0,-84(s0)
+ 598: 00001097 auipc ra,0x1
+ 59c: d88080e7 jalr -632(ra) # 1320 <close>
+ wait(0);
+ 5a0: 4501 li a0,0
+ 5a2: 00001097 auipc ra,0x1
+ 5a6: d58080e7 jalr -680(ra) # 12fa <wait>
+ wait(0);
+ 5aa: 4501 li a0,0
+ 5ac: 00001097 auipc ra,0x1
+ 5b0: d4e080e7 jalr -690(ra) # 12fa <wait>
+ break;
+ 5b4: b735 j 4e0 <runcmd+0xee>
+ panic("pipe");
+ 5b6: 00001517 auipc a0,0x1
+ 5ba: 34250513 addi a0,a0,834 # 18f8 <malloc+0x18c>
+ 5be: 00000097 auipc ra,0x0
+ 5c2: de0080e7 jalr -544(ra) # 39e <panic>
+ close(1);
+ 5c6: 4505 li a0,1
+ 5c8: 00001097 auipc ra,0x1
+ 5cc: d58080e7 jalr -680(ra) # 1320 <close>
+ dup(p[1]);
+ 5d0: fac42503 lw a0,-84(s0)
+ 5d4: 00001097 auipc ra,0x1
+ 5d8: d90080e7 jalr -624(ra) # 1364 <dup>
+ close(p[0]);
+ 5dc: fa842503 lw a0,-88(s0)
+ 5e0: 00001097 auipc ra,0x1
+ 5e4: d40080e7 jalr -704(ra) # 1320 <close>
+ close(p[1]);
+ 5e8: fac42503 lw a0,-84(s0)
+ 5ec: 00001097 auipc ra,0x1
+ 5f0: d34080e7 jalr -716(ra) # 1320 <close>
+ runcmd(pcmd->left);
+ 5f4: 6488 ld a0,8(s1)
+ 5f6: 00000097 auipc ra,0x0
+ 5fa: dfc080e7 jalr -516(ra) # 3f2 <runcmd>
+ close(0);
+ 5fe: 00001097 auipc ra,0x1
+ 602: d22080e7 jalr -734(ra) # 1320 <close>
+ dup(p[0]);
+ 606: fa842503 lw a0,-88(s0)
+ 60a: 00001097 auipc ra,0x1
+ 60e: d5a080e7 jalr -678(ra) # 1364 <dup>
+ close(p[0]);
+ 612: fa842503 lw a0,-88(s0)
+ 616: 00001097 auipc ra,0x1
+ 61a: d0a080e7 jalr -758(ra) # 1320 <close>
+ close(p[1]);
+ 61e: fac42503 lw a0,-84(s0)
+ 622: 00001097 auipc ra,0x1
+ 626: cfe080e7 jalr -770(ra) # 1320 <close>
+ runcmd(pcmd->right);
+ 62a: 6888 ld a0,16(s1)
+ 62c: 00000097 auipc ra,0x0
+ 630: dc6080e7 jalr -570(ra) # 3f2 <runcmd>
+ if(fork1() == 0)
+ 634: 00000097 auipc ra,0x0
+ 638: d90080e7 jalr -624(ra) # 3c4 <fork1>
+ 63c: ea0512e3 bnez a0,4e0 <runcmd+0xee>
+ runcmd(bcmd->cmd);
+ 640: 6488 ld a0,8(s1)
+ 642: 00000097 auipc ra,0x0
+ 646: db0080e7 jalr -592(ra) # 3f2 <runcmd>
+
+000000000000064a <execcmd>:
+//PAGEBREAK!
+// Constructors
+
+struct cmd*
+execcmd(void)
+{
+ 64a: 1101 addi sp,sp,-32
+ 64c: ec06 sd ra,24(sp)
+ 64e: e822 sd s0,16(sp)
+ 650: e426 sd s1,8(sp)
+ 652: 1000 addi s0,sp,32
+ struct execcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ 654: 0a800513 li a0,168
+ 658: 00001097 auipc ra,0x1
+ 65c: 114080e7 jalr 276(ra) # 176c <malloc>
+ 660: 84aa mv s1,a0
+ memset(cmd, 0, sizeof(*cmd));
+ 662: 0a800613 li a2,168
+ 666: 4581 li a1,0
+ 668: 00001097 auipc ra,0x1
+ 66c: a70080e7 jalr -1424(ra) # 10d8 <memset>
+ cmd->type = EXEC;
+ 670: 4785 li a5,1
+ 672: c09c sw a5,0(s1)
+ return (struct cmd*)cmd;
+}
+ 674: 8526 mv a0,s1
+ 676: 60e2 ld ra,24(sp)
+ 678: 6442 ld s0,16(sp)
+ 67a: 64a2 ld s1,8(sp)
+ 67c: 6105 addi sp,sp,32
+ 67e: 8082 ret
+
+0000000000000680 <redircmd>:
+
+struct cmd*
+redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
+{
+ 680: 7139 addi sp,sp,-64
+ 682: fc06 sd ra,56(sp)
+ 684: f822 sd s0,48(sp)
+ 686: f426 sd s1,40(sp)
+ 688: f04a sd s2,32(sp)
+ 68a: ec4e sd s3,24(sp)
+ 68c: e852 sd s4,16(sp)
+ 68e: e456 sd s5,8(sp)
+ 690: e05a sd s6,0(sp)
+ 692: 0080 addi s0,sp,64
+ 694: 8b2a mv s6,a0
+ 696: 8aae mv s5,a1
+ 698: 8a32 mv s4,a2
+ 69a: 89b6 mv s3,a3
+ 69c: 893a mv s2,a4
+ struct redircmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ 69e: 02800513 li a0,40
+ 6a2: 00001097 auipc ra,0x1
+ 6a6: 0ca080e7 jalr 202(ra) # 176c <malloc>
+ 6aa: 84aa mv s1,a0
+ memset(cmd, 0, sizeof(*cmd));
+ 6ac: 02800613 li a2,40
+ 6b0: 4581 li a1,0
+ 6b2: 00001097 auipc ra,0x1
+ 6b6: a26080e7 jalr -1498(ra) # 10d8 <memset>
+ cmd->type = REDIR;
+ 6ba: 4789 li a5,2
+ 6bc: c09c sw a5,0(s1)
+ cmd->cmd = subcmd;
+ 6be: 0164b423 sd s6,8(s1)
+ cmd->file = file;
+ 6c2: 0154b823 sd s5,16(s1)
+ cmd->efile = efile;
+ 6c6: 0144bc23 sd s4,24(s1)
+ cmd->mode = mode;
+ 6ca: 0334a023 sw s3,32(s1)
+ cmd->fd = fd;
+ 6ce: 0324a223 sw s2,36(s1)
+ return (struct cmd*)cmd;
+}
+ 6d2: 8526 mv a0,s1
+ 6d4: 70e2 ld ra,56(sp)
+ 6d6: 7442 ld s0,48(sp)
+ 6d8: 74a2 ld s1,40(sp)
+ 6da: 7902 ld s2,32(sp)
+ 6dc: 69e2 ld s3,24(sp)
+ 6de: 6a42 ld s4,16(sp)
+ 6e0: 6aa2 ld s5,8(sp)
+ 6e2: 6b02 ld s6,0(sp)
+ 6e4: 6121 addi sp,sp,64
+ 6e6: 8082 ret
+
+00000000000006e8 <pipecmd>:
+
+struct cmd*
+pipecmd(struct cmd *left, struct cmd *right)
+{
+ 6e8: 7179 addi sp,sp,-48
+ 6ea: f406 sd ra,40(sp)
+ 6ec: f022 sd s0,32(sp)
+ 6ee: ec26 sd s1,24(sp)
+ 6f0: e84a sd s2,16(sp)
+ 6f2: e44e sd s3,8(sp)
+ 6f4: 1800 addi s0,sp,48
+ 6f6: 89aa mv s3,a0
+ 6f8: 892e mv s2,a1
+ struct pipecmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ 6fa: 4561 li a0,24
+ 6fc: 00001097 auipc ra,0x1
+ 700: 070080e7 jalr 112(ra) # 176c <malloc>
+ 704: 84aa mv s1,a0
+ memset(cmd, 0, sizeof(*cmd));
+ 706: 4661 li a2,24
+ 708: 4581 li a1,0
+ 70a: 00001097 auipc ra,0x1
+ 70e: 9ce080e7 jalr -1586(ra) # 10d8 <memset>
+ cmd->type = PIPE;
+ 712: 478d li a5,3
+ 714: c09c sw a5,0(s1)
+ cmd->left = left;
+ 716: 0134b423 sd s3,8(s1)
+ cmd->right = right;
+ 71a: 0124b823 sd s2,16(s1)
+ return (struct cmd*)cmd;
+}
+ 71e: 8526 mv a0,s1
+ 720: 70a2 ld ra,40(sp)
+ 722: 7402 ld s0,32(sp)
+ 724: 64e2 ld s1,24(sp)
+ 726: 6942 ld s2,16(sp)
+ 728: 69a2 ld s3,8(sp)
+ 72a: 6145 addi sp,sp,48
+ 72c: 8082 ret
+
+000000000000072e <listcmd>:
+
+struct cmd*
+listcmd(struct cmd *left, struct cmd *right)
+{
+ 72e: 7179 addi sp,sp,-48
+ 730: f406 sd ra,40(sp)
+ 732: f022 sd s0,32(sp)
+ 734: ec26 sd s1,24(sp)
+ 736: e84a sd s2,16(sp)
+ 738: e44e sd s3,8(sp)
+ 73a: 1800 addi s0,sp,48
+ 73c: 89aa mv s3,a0
+ 73e: 892e mv s2,a1
+ struct listcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ 740: 4561 li a0,24
+ 742: 00001097 auipc ra,0x1
+ 746: 02a080e7 jalr 42(ra) # 176c <malloc>
+ 74a: 84aa mv s1,a0
+ memset(cmd, 0, sizeof(*cmd));
+ 74c: 4661 li a2,24
+ 74e: 4581 li a1,0
+ 750: 00001097 auipc ra,0x1
+ 754: 988080e7 jalr -1656(ra) # 10d8 <memset>
+ cmd->type = LIST;
+ 758: 4791 li a5,4
+ 75a: c09c sw a5,0(s1)
+ cmd->left = left;
+ 75c: 0134b423 sd s3,8(s1)
+ cmd->right = right;
+ 760: 0124b823 sd s2,16(s1)
+ return (struct cmd*)cmd;
+}
+ 764: 8526 mv a0,s1
+ 766: 70a2 ld ra,40(sp)
+ 768: 7402 ld s0,32(sp)
+ 76a: 64e2 ld s1,24(sp)
+ 76c: 6942 ld s2,16(sp)
+ 76e: 69a2 ld s3,8(sp)
+ 770: 6145 addi sp,sp,48
+ 772: 8082 ret
+
+0000000000000774 <backcmd>:
+
+struct cmd*
+backcmd(struct cmd *subcmd)
+{
+ 774: 1101 addi sp,sp,-32
+ 776: ec06 sd ra,24(sp)
+ 778: e822 sd s0,16(sp)
+ 77a: e426 sd s1,8(sp)
+ 77c: e04a sd s2,0(sp)
+ 77e: 1000 addi s0,sp,32
+ 780: 892a mv s2,a0
+ struct backcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ 782: 4541 li a0,16
+ 784: 00001097 auipc ra,0x1
+ 788: fe8080e7 jalr -24(ra) # 176c <malloc>
+ 78c: 84aa mv s1,a0
+ memset(cmd, 0, sizeof(*cmd));
+ 78e: 4641 li a2,16
+ 790: 4581 li a1,0
+ 792: 00001097 auipc ra,0x1
+ 796: 946080e7 jalr -1722(ra) # 10d8 <memset>
+ cmd->type = BACK;
+ 79a: 4795 li a5,5
+ 79c: c09c sw a5,0(s1)
+ cmd->cmd = subcmd;
+ 79e: 0124b423 sd s2,8(s1)
+ return (struct cmd*)cmd;
+}
+ 7a2: 8526 mv a0,s1
+ 7a4: 60e2 ld ra,24(sp)
+ 7a6: 6442 ld s0,16(sp)
+ 7a8: 64a2 ld s1,8(sp)
+ 7aa: 6902 ld s2,0(sp)
+ 7ac: 6105 addi sp,sp,32
+ 7ae: 8082 ret
+
+00000000000007b0 <gettoken>:
+char whitespace[] = " \t\r\n\v";
+char symbols[] = "<|>&;()";
+
+int
+gettoken(char **ps, char *es, char **q, char **eq)
+{
+ 7b0: 7139 addi sp,sp,-64
+ 7b2: fc06 sd ra,56(sp)
+ 7b4: f822 sd s0,48(sp)
+ 7b6: f426 sd s1,40(sp)
+ 7b8: f04a sd s2,32(sp)
+ 7ba: ec4e sd s3,24(sp)
+ 7bc: e852 sd s4,16(sp)
+ 7be: e456 sd s5,8(sp)
+ 7c0: e05a sd s6,0(sp)
+ 7c2: 0080 addi s0,sp,64
+ 7c4: 8a2a mv s4,a0
+ 7c6: 892e mv s2,a1
+ 7c8: 8ab2 mv s5,a2
+ 7ca: 8b36 mv s6,a3
+ char *s;
+ int ret;
+
+ s = *ps;
+ 7cc: 6104 ld s1,0(a0)
+ while(s < es && strchr(whitespace, *s))
+ 7ce: 00001997 auipc s3,0x1
+ 7d2: 2e298993 addi s3,s3,738 # 1ab0 <whitespace>
+ 7d6: 00b4fe63 bgeu s1,a1,7f2 <gettoken+0x42>
+ 7da: 0004c583 lbu a1,0(s1)
+ 7de: 854e mv a0,s3
+ 7e0: 00001097 auipc ra,0x1
+ 7e4: 91a080e7 jalr -1766(ra) # 10fa <strchr>
+ 7e8: c509 beqz a0,7f2 <gettoken+0x42>
+ s++;
+ 7ea: 0485 addi s1,s1,1
+ while(s < es && strchr(whitespace, *s))
+ 7ec: fe9917e3 bne s2,s1,7da <gettoken+0x2a>
+ s++;
+ 7f0: 84ca mv s1,s2
+ if(q)
+ 7f2: 000a8463 beqz s5,7fa <gettoken+0x4a>
+ *q = s;
+ 7f6: 009ab023 sd s1,0(s5)
+ ret = *s;
+ 7fa: 0004c783 lbu a5,0(s1)
+ 7fe: 00078a9b sext.w s5,a5
+ switch(*s){
+ 802: 03c00713 li a4,60
+ 806: 06f76663 bltu a4,a5,872 <gettoken+0xc2>
+ 80a: 03a00713 li a4,58
+ 80e: 00f76e63 bltu a4,a5,82a <gettoken+0x7a>
+ 812: cf89 beqz a5,82c <gettoken+0x7c>
+ 814: 02600713 li a4,38
+ 818: 00e78963 beq a5,a4,82a <gettoken+0x7a>
+ 81c: fd87879b addiw a5,a5,-40
+ 820: 0ff7f793 zext.b a5,a5
+ 824: 4705 li a4,1
+ 826: 06f76d63 bltu a4,a5,8a0 <gettoken+0xf0>
+ case '(':
+ case ')':
+ case ';':
+ case '&':
+ case '<':
+ s++;
+ 82a: 0485 addi s1,s1,1
+ ret = 'a';
+ while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
+ s++;
+ break;
+ }
+ if(eq)
+ 82c: 000b0463 beqz s6,834 <gettoken+0x84>
+ *eq = s;
+ 830: 009b3023 sd s1,0(s6)
+
+ while(s < es && strchr(whitespace, *s))
+ 834: 00001997 auipc s3,0x1
+ 838: 27c98993 addi s3,s3,636 # 1ab0 <whitespace>
+ 83c: 0124fe63 bgeu s1,s2,858 <gettoken+0xa8>
+ 840: 0004c583 lbu a1,0(s1)
+ 844: 854e mv a0,s3
+ 846: 00001097 auipc ra,0x1
+ 84a: 8b4080e7 jalr -1868(ra) # 10fa <strchr>
+ 84e: c509 beqz a0,858 <gettoken+0xa8>
+ s++;
+ 850: 0485 addi s1,s1,1
+ while(s < es && strchr(whitespace, *s))
+ 852: fe9917e3 bne s2,s1,840 <gettoken+0x90>
+ s++;
+ 856: 84ca mv s1,s2
+ *ps = s;
+ 858: 009a3023 sd s1,0(s4)
+ return ret;
+}
+ 85c: 8556 mv a0,s5
+ 85e: 70e2 ld ra,56(sp)
+ 860: 7442 ld s0,48(sp)
+ 862: 74a2 ld s1,40(sp)
+ 864: 7902 ld s2,32(sp)
+ 866: 69e2 ld s3,24(sp)
+ 868: 6a42 ld s4,16(sp)
+ 86a: 6aa2 ld s5,8(sp)
+ 86c: 6b02 ld s6,0(sp)
+ 86e: 6121 addi sp,sp,64
+ 870: 8082 ret
+ switch(*s){
+ 872: 03e00713 li a4,62
+ 876: 02e79163 bne a5,a4,898 <gettoken+0xe8>
+ s++;
+ 87a: 00148693 addi a3,s1,1
+ if(*s == '>'){
+ 87e: 0014c703 lbu a4,1(s1)
+ 882: 03e00793 li a5,62
+ s++;
+ 886: 0489 addi s1,s1,2
+ ret = '+';
+ 888: 02b00a93 li s5,43
+ if(*s == '>'){
+ 88c: faf700e3 beq a4,a5,82c <gettoken+0x7c>
+ s++;
+ 890: 84b6 mv s1,a3
+ ret = *s;
+ 892: 03e00a93 li s5,62
+ 896: bf59 j 82c <gettoken+0x7c>
+ switch(*s){
+ 898: 07c00713 li a4,124
+ 89c: f8e787e3 beq a5,a4,82a <gettoken+0x7a>
+ while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
+ 8a0: 00001997 auipc s3,0x1
+ 8a4: 21098993 addi s3,s3,528 # 1ab0 <whitespace>
+ 8a8: 00001a97 auipc s5,0x1
+ 8ac: 210a8a93 addi s5,s5,528 # 1ab8 <symbols>
+ 8b0: 0324f663 bgeu s1,s2,8dc <gettoken+0x12c>
+ 8b4: 0004c583 lbu a1,0(s1)
+ 8b8: 854e mv a0,s3
+ 8ba: 00001097 auipc ra,0x1
+ 8be: 840080e7 jalr -1984(ra) # 10fa <strchr>
+ 8c2: e50d bnez a0,8ec <gettoken+0x13c>
+ 8c4: 0004c583 lbu a1,0(s1)
+ 8c8: 8556 mv a0,s5
+ 8ca: 00001097 auipc ra,0x1
+ 8ce: 830080e7 jalr -2000(ra) # 10fa <strchr>
+ 8d2: e911 bnez a0,8e6 <gettoken+0x136>
+ s++;
+ 8d4: 0485 addi s1,s1,1
+ while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
+ 8d6: fc991fe3 bne s2,s1,8b4 <gettoken+0x104>
+ s++;
+ 8da: 84ca mv s1,s2
+ if(eq)
+ 8dc: 06100a93 li s5,97
+ 8e0: f40b18e3 bnez s6,830 <gettoken+0x80>
+ 8e4: bf95 j 858 <gettoken+0xa8>
+ ret = 'a';
+ 8e6: 06100a93 li s5,97
+ 8ea: b789 j 82c <gettoken+0x7c>
+ 8ec: 06100a93 li s5,97
+ 8f0: bf35 j 82c <gettoken+0x7c>
+
+00000000000008f2 <peek>:
+
+int
+peek(char **ps, char *es, char *toks)
+{
+ 8f2: 7139 addi sp,sp,-64
+ 8f4: fc06 sd ra,56(sp)
+ 8f6: f822 sd s0,48(sp)
+ 8f8: f426 sd s1,40(sp)
+ 8fa: f04a sd s2,32(sp)
+ 8fc: ec4e sd s3,24(sp)
+ 8fe: e852 sd s4,16(sp)
+ 900: e456 sd s5,8(sp)
+ 902: 0080 addi s0,sp,64
+ 904: 8a2a mv s4,a0
+ 906: 892e mv s2,a1
+ 908: 8ab2 mv s5,a2
+ char *s;
+
+ s = *ps;
+ 90a: 6104 ld s1,0(a0)
+ while(s < es && strchr(whitespace, *s))
+ 90c: 00001997 auipc s3,0x1
+ 910: 1a498993 addi s3,s3,420 # 1ab0 <whitespace>
+ 914: 00b4fe63 bgeu s1,a1,930 <peek+0x3e>
+ 918: 0004c583 lbu a1,0(s1)
+ 91c: 854e mv a0,s3
+ 91e: 00000097 auipc ra,0x0
+ 922: 7dc080e7 jalr 2012(ra) # 10fa <strchr>
+ 926: c509 beqz a0,930 <peek+0x3e>
+ s++;
+ 928: 0485 addi s1,s1,1
+ while(s < es && strchr(whitespace, *s))
+ 92a: fe9917e3 bne s2,s1,918 <peek+0x26>
+ s++;
+ 92e: 84ca mv s1,s2
+ *ps = s;
+ 930: 009a3023 sd s1,0(s4)
+ return *s && strchr(toks, *s);
+ 934: 0004c583 lbu a1,0(s1)
+ 938: 4501 li a0,0
+ 93a: e991 bnez a1,94e <peek+0x5c>
+}
+ 93c: 70e2 ld ra,56(sp)
+ 93e: 7442 ld s0,48(sp)
+ 940: 74a2 ld s1,40(sp)
+ 942: 7902 ld s2,32(sp)
+ 944: 69e2 ld s3,24(sp)
+ 946: 6a42 ld s4,16(sp)
+ 948: 6aa2 ld s5,8(sp)
+ 94a: 6121 addi sp,sp,64
+ 94c: 8082 ret
+ return *s && strchr(toks, *s);
+ 94e: 8556 mv a0,s5
+ 950: 00000097 auipc ra,0x0
+ 954: 7aa080e7 jalr 1962(ra) # 10fa <strchr>
+ 958: 00a03533 snez a0,a0
+ 95c: b7c5 j 93c <peek+0x4a>
+
+000000000000095e <parseredirs>:
+ return cmd;
+}
+
+struct cmd*
+parseredirs(struct cmd *cmd, char **ps, char *es)
+{
+ 95e: 7119 addi sp,sp,-128
+ 960: fc86 sd ra,120(sp)
+ 962: f8a2 sd s0,112(sp)
+ 964: f4a6 sd s1,104(sp)
+ 966: f0ca sd s2,96(sp)
+ 968: ecce sd s3,88(sp)
+ 96a: e8d2 sd s4,80(sp)
+ 96c: e4d6 sd s5,72(sp)
+ 96e: e0da sd s6,64(sp)
+ 970: fc5e sd s7,56(sp)
+ 972: f862 sd s8,48(sp)
+ 974: f466 sd s9,40(sp)
+ 976: f06a sd s10,32(sp)
+ 978: ec6e sd s11,24(sp)
+ 97a: 0100 addi s0,sp,128
+ 97c: 8a2a mv s4,a0
+ 97e: 89ae mv s3,a1
+ 980: 8932 mv s2,a2
+ int tok;
+ char *q, *eq;
+
+ while(peek(ps, es, "<>")){
+ 982: 00001b97 auipc s7,0x1
+ 986: f9eb8b93 addi s7,s7,-98 # 1920 <malloc+0x1b4>
+ tok = gettoken(ps, es, 0, 0);
+ if(gettoken(ps, es, &q, &eq) != 'a')
+ 98a: f8040d13 addi s10,s0,-128
+ 98e: f8840c93 addi s9,s0,-120
+ 992: 06100c13 li s8,97
+ panic("missing file for redirection");
+ switch(tok){
+ 996: 03c00d93 li s11,60
+ while(peek(ps, es, "<>")){
+ 99a: a02d j 9c4 <parseredirs+0x66>
+ panic("missing file for redirection");
+ 99c: 00001517 auipc a0,0x1
+ 9a0: f6450513 addi a0,a0,-156 # 1900 <malloc+0x194>
+ 9a4: 00000097 auipc ra,0x0
+ 9a8: 9fa080e7 jalr -1542(ra) # 39e <panic>
+ case '<':
+ cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
+ 9ac: 4701 li a4,0
+ 9ae: 4681 li a3,0
+ 9b0: f8043603 ld a2,-128(s0)
+ 9b4: f8843583 ld a1,-120(s0)
+ 9b8: 8552 mv a0,s4
+ 9ba: 00000097 auipc ra,0x0
+ 9be: cc6080e7 jalr -826(ra) # 680 <redircmd>
+ 9c2: 8a2a mv s4,a0
+ switch(tok){
+ 9c4: 03e00b13 li s6,62
+ 9c8: 02b00a93 li s5,43
+ while(peek(ps, es, "<>")){
+ 9cc: 865e mv a2,s7
+ 9ce: 85ca mv a1,s2
+ 9d0: 854e mv a0,s3
+ 9d2: 00000097 auipc ra,0x0
+ 9d6: f20080e7 jalr -224(ra) # 8f2 <peek>
+ 9da: c535 beqz a0,a46 <parseredirs+0xe8>
+ tok = gettoken(ps, es, 0, 0);
+ 9dc: 4681 li a3,0
+ 9de: 4601 li a2,0
+ 9e0: 85ca mv a1,s2
+ 9e2: 854e mv a0,s3
+ 9e4: 00000097 auipc ra,0x0
+ 9e8: dcc080e7 jalr -564(ra) # 7b0 <gettoken>
+ 9ec: 84aa mv s1,a0
+ if(gettoken(ps, es, &q, &eq) != 'a')
+ 9ee: 86ea mv a3,s10
+ 9f0: 8666 mv a2,s9
+ 9f2: 85ca mv a1,s2
+ 9f4: 854e mv a0,s3
+ 9f6: 00000097 auipc ra,0x0
+ 9fa: dba080e7 jalr -582(ra) # 7b0 <gettoken>
+ 9fe: f9851fe3 bne a0,s8,99c <parseredirs+0x3e>
+ switch(tok){
+ a02: fbb485e3 beq s1,s11,9ac <parseredirs+0x4e>
+ a06: 03648263 beq s1,s6,a2a <parseredirs+0xcc>
+ a0a: fd5491e3 bne s1,s5,9cc <parseredirs+0x6e>
+ break;
+ case '>':
+ cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_TRUNC, 1);
+ break;
+ case '+': // >>
+ cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_APPEND, 1);
+ a0e: 4705 li a4,1
+ a10: 20500693 li a3,517
+ a14: f8043603 ld a2,-128(s0)
+ a18: f8843583 ld a1,-120(s0)
+ a1c: 8552 mv a0,s4
+ a1e: 00000097 auipc ra,0x0
+ a22: c62080e7 jalr -926(ra) # 680 <redircmd>
+ a26: 8a2a mv s4,a0
+ break;
+ a28: bf71 j 9c4 <parseredirs+0x66>
+ cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_TRUNC, 1);
+ a2a: 4705 li a4,1
+ a2c: 60100693 li a3,1537
+ a30: f8043603 ld a2,-128(s0)
+ a34: f8843583 ld a1,-120(s0)
+ a38: 8552 mv a0,s4
+ a3a: 00000097 auipc ra,0x0
+ a3e: c46080e7 jalr -954(ra) # 680 <redircmd>
+ a42: 8a2a mv s4,a0
+ break;
+ a44: b741 j 9c4 <parseredirs+0x66>
+ }
+ }
+ return cmd;
+}
+ a46: 8552 mv a0,s4
+ a48: 70e6 ld ra,120(sp)
+ a4a: 7446 ld s0,112(sp)
+ a4c: 74a6 ld s1,104(sp)
+ a4e: 7906 ld s2,96(sp)
+ a50: 69e6 ld s3,88(sp)
+ a52: 6a46 ld s4,80(sp)
+ a54: 6aa6 ld s5,72(sp)
+ a56: 6b06 ld s6,64(sp)
+ a58: 7be2 ld s7,56(sp)
+ a5a: 7c42 ld s8,48(sp)
+ a5c: 7ca2 ld s9,40(sp)
+ a5e: 7d02 ld s10,32(sp)
+ a60: 6de2 ld s11,24(sp)
+ a62: 6109 addi sp,sp,128
+ a64: 8082 ret
+
+0000000000000a66 <parseexec>:
+ return cmd;
+}
+
+struct cmd*
+parseexec(char **ps, char *es)
+{
+ a66: 7119 addi sp,sp,-128
+ a68: fc86 sd ra,120(sp)
+ a6a: f8a2 sd s0,112(sp)
+ a6c: f4a6 sd s1,104(sp)
+ a6e: f0ca sd s2,96(sp)
+ a70: ecce sd s3,88(sp)
+ a72: e8d2 sd s4,80(sp)
+ a74: e4d6 sd s5,72(sp)
+ a76: e0da sd s6,64(sp)
+ a78: fc5e sd s7,56(sp)
+ a7a: f862 sd s8,48(sp)
+ a7c: f466 sd s9,40(sp)
+ a7e: f06a sd s10,32(sp)
+ a80: ec6e sd s11,24(sp)
+ a82: 0100 addi s0,sp,128
+ a84: 8a2a mv s4,a0
+ a86: 8aae mv s5,a1
+ char *q, *eq;
+ int tok, argc;
+ struct execcmd *cmd;
+ struct cmd *ret;
+
+ if(peek(ps, es, "("))
+ a88: 00001617 auipc a2,0x1
+ a8c: ea060613 addi a2,a2,-352 # 1928 <malloc+0x1bc>
+ a90: 00000097 auipc ra,0x0
+ a94: e62080e7 jalr -414(ra) # 8f2 <peek>
+ a98: ed05 bnez a0,ad0 <parseexec+0x6a>
+ a9a: 89aa mv s3,a0
+ return parseblock(ps, es);
+
+ ret = execcmd();
+ a9c: 00000097 auipc ra,0x0
+ aa0: bae080e7 jalr -1106(ra) # 64a <execcmd>
+ aa4: 8daa mv s11,a0
+ cmd = (struct execcmd*)ret;
+
+ argc = 0;
+ ret = parseredirs(ret, ps, es);
+ aa6: 8656 mv a2,s5
+ aa8: 85d2 mv a1,s4
+ aaa: 00000097 auipc ra,0x0
+ aae: eb4080e7 jalr -332(ra) # 95e <parseredirs>
+ ab2: 84aa mv s1,a0
+ while(!peek(ps, es, "|)&;")){
+ ab4: 008d8913 addi s2,s11,8
+ ab8: 00001b17 auipc s6,0x1
+ abc: e90b0b13 addi s6,s6,-368 # 1948 <malloc+0x1dc>
+ if((tok=gettoken(ps, es, &q, &eq)) == 0)
+ ac0: f8040c13 addi s8,s0,-128
+ ac4: f8840b93 addi s7,s0,-120
+ break;
+ if(tok != 'a')
+ ac8: 06100d13 li s10,97
+ panic("syntax");
+ cmd->argv[argc] = q;
+ cmd->eargv[argc] = eq;
+ argc++;
+ if(argc >= MAXARGS)
+ acc: 4ca9 li s9,10
+ while(!peek(ps, es, "|)&;")){
+ ace: a881 j b1e <parseexec+0xb8>
+ return parseblock(ps, es);
+ ad0: 85d6 mv a1,s5
+ ad2: 8552 mv a0,s4
+ ad4: 00000097 auipc ra,0x0
+ ad8: 1bc080e7 jalr 444(ra) # c90 <parseblock>
+ adc: 84aa mv s1,a0
+ ret = parseredirs(ret, ps, es);
+ }
+ cmd->argv[argc] = 0;
+ cmd->eargv[argc] = 0;
+ return ret;
+}
+ ade: 8526 mv a0,s1
+ ae0: 70e6 ld ra,120(sp)
+ ae2: 7446 ld s0,112(sp)
+ ae4: 74a6 ld s1,104(sp)
+ ae6: 7906 ld s2,96(sp)
+ ae8: 69e6 ld s3,88(sp)
+ aea: 6a46 ld s4,80(sp)
+ aec: 6aa6 ld s5,72(sp)
+ aee: 6b06 ld s6,64(sp)
+ af0: 7be2 ld s7,56(sp)
+ af2: 7c42 ld s8,48(sp)
+ af4: 7ca2 ld s9,40(sp)
+ af6: 7d02 ld s10,32(sp)
+ af8: 6de2 ld s11,24(sp)
+ afa: 6109 addi sp,sp,128
+ afc: 8082 ret
+ panic("syntax");
+ afe: 00001517 auipc a0,0x1
+ b02: e3250513 addi a0,a0,-462 # 1930 <malloc+0x1c4>
+ b06: 00000097 auipc ra,0x0
+ b0a: 898080e7 jalr -1896(ra) # 39e <panic>
+ ret = parseredirs(ret, ps, es);
+ b0e: 8656 mv a2,s5
+ b10: 85d2 mv a1,s4
+ b12: 8526 mv a0,s1
+ b14: 00000097 auipc ra,0x0
+ b18: e4a080e7 jalr -438(ra) # 95e <parseredirs>
+ b1c: 84aa mv s1,a0
+ while(!peek(ps, es, "|)&;")){
+ b1e: 865a mv a2,s6
+ b20: 85d6 mv a1,s5
+ b22: 8552 mv a0,s4
+ b24: 00000097 auipc ra,0x0
+ b28: dce080e7 jalr -562(ra) # 8f2 <peek>
+ b2c: e121 bnez a0,b6c <parseexec+0x106>
+ if((tok=gettoken(ps, es, &q, &eq)) == 0)
+ b2e: 86e2 mv a3,s8
+ b30: 865e mv a2,s7
+ b32: 85d6 mv a1,s5
+ b34: 8552 mv a0,s4
+ b36: 00000097 auipc ra,0x0
+ b3a: c7a080e7 jalr -902(ra) # 7b0 <gettoken>
+ b3e: c51d beqz a0,b6c <parseexec+0x106>
+ if(tok != 'a')
+ b40: fba51fe3 bne a0,s10,afe <parseexec+0x98>
+ cmd->argv[argc] = q;
+ b44: f8843783 ld a5,-120(s0)
+ b48: 00f93023 sd a5,0(s2)
+ cmd->eargv[argc] = eq;
+ b4c: f8043783 ld a5,-128(s0)
+ b50: 04f93823 sd a5,80(s2)
+ argc++;
+ b54: 2985 addiw s3,s3,1
+ if(argc >= MAXARGS)
+ b56: 0921 addi s2,s2,8
+ b58: fb999be3 bne s3,s9,b0e <parseexec+0xa8>
+ panic("too many args");
+ b5c: 00001517 auipc a0,0x1
+ b60: ddc50513 addi a0,a0,-548 # 1938 <malloc+0x1cc>
+ b64: 00000097 auipc ra,0x0
+ b68: 83a080e7 jalr -1990(ra) # 39e <panic>
+ cmd->argv[argc] = 0;
+ b6c: 098e slli s3,s3,0x3
+ b6e: 9dce add s11,s11,s3
+ b70: 000db423 sd zero,8(s11)
+ cmd->eargv[argc] = 0;
+ b74: 040dbc23 sd zero,88(s11)
+ return ret;
+ b78: b79d j ade <parseexec+0x78>
+
+0000000000000b7a <parsepipe>:
+{
+ b7a: 7179 addi sp,sp,-48
+ b7c: f406 sd ra,40(sp)
+ b7e: f022 sd s0,32(sp)
+ b80: ec26 sd s1,24(sp)
+ b82: e84a sd s2,16(sp)
+ b84: e44e sd s3,8(sp)
+ b86: 1800 addi s0,sp,48
+ b88: 892a mv s2,a0
+ b8a: 89ae mv s3,a1
+ cmd = parseexec(ps, es);
+ b8c: 00000097 auipc ra,0x0
+ b90: eda080e7 jalr -294(ra) # a66 <parseexec>
+ b94: 84aa mv s1,a0
+ if(peek(ps, es, "|")){
+ b96: 00001617 auipc a2,0x1
+ b9a: dba60613 addi a2,a2,-582 # 1950 <malloc+0x1e4>
+ b9e: 85ce mv a1,s3
+ ba0: 854a mv a0,s2
+ ba2: 00000097 auipc ra,0x0
+ ba6: d50080e7 jalr -688(ra) # 8f2 <peek>
+ baa: e909 bnez a0,bbc <parsepipe+0x42>
+}
+ bac: 8526 mv a0,s1
+ bae: 70a2 ld ra,40(sp)
+ bb0: 7402 ld s0,32(sp)
+ bb2: 64e2 ld s1,24(sp)
+ bb4: 6942 ld s2,16(sp)
+ bb6: 69a2 ld s3,8(sp)
+ bb8: 6145 addi sp,sp,48
+ bba: 8082 ret
+ gettoken(ps, es, 0, 0);
+ bbc: 4681 li a3,0
+ bbe: 4601 li a2,0
+ bc0: 85ce mv a1,s3
+ bc2: 854a mv a0,s2
+ bc4: 00000097 auipc ra,0x0
+ bc8: bec080e7 jalr -1044(ra) # 7b0 <gettoken>
+ cmd = pipecmd(cmd, parsepipe(ps, es));
+ bcc: 85ce mv a1,s3
+ bce: 854a mv a0,s2
+ bd0: 00000097 auipc ra,0x0
+ bd4: faa080e7 jalr -86(ra) # b7a <parsepipe>
+ bd8: 85aa mv a1,a0
+ bda: 8526 mv a0,s1
+ bdc: 00000097 auipc ra,0x0
+ be0: b0c080e7 jalr -1268(ra) # 6e8 <pipecmd>
+ be4: 84aa mv s1,a0
+ return cmd;
+ be6: b7d9 j bac <parsepipe+0x32>
+
+0000000000000be8 <parseline>:
+{
+ be8: 7179 addi sp,sp,-48
+ bea: f406 sd ra,40(sp)
+ bec: f022 sd s0,32(sp)
+ bee: ec26 sd s1,24(sp)
+ bf0: e84a sd s2,16(sp)
+ bf2: e44e sd s3,8(sp)
+ bf4: e052 sd s4,0(sp)
+ bf6: 1800 addi s0,sp,48
+ bf8: 892a mv s2,a0
+ bfa: 89ae mv s3,a1
+ cmd = parsepipe(ps, es);
+ bfc: 00000097 auipc ra,0x0
+ c00: f7e080e7 jalr -130(ra) # b7a <parsepipe>
+ c04: 84aa mv s1,a0
+ while(peek(ps, es, "&")){
+ c06: 00001a17 auipc s4,0x1
+ c0a: d52a0a13 addi s4,s4,-686 # 1958 <malloc+0x1ec>
+ c0e: a839 j c2c <parseline+0x44>
+ gettoken(ps, es, 0, 0);
+ c10: 4681 li a3,0
+ c12: 4601 li a2,0
+ c14: 85ce mv a1,s3
+ c16: 854a mv a0,s2
+ c18: 00000097 auipc ra,0x0
+ c1c: b98080e7 jalr -1128(ra) # 7b0 <gettoken>
+ cmd = backcmd(cmd);
+ c20: 8526 mv a0,s1
+ c22: 00000097 auipc ra,0x0
+ c26: b52080e7 jalr -1198(ra) # 774 <backcmd>
+ c2a: 84aa mv s1,a0
+ while(peek(ps, es, "&")){
+ c2c: 8652 mv a2,s4
+ c2e: 85ce mv a1,s3
+ c30: 854a mv a0,s2
+ c32: 00000097 auipc ra,0x0
+ c36: cc0080e7 jalr -832(ra) # 8f2 <peek>
+ c3a: f979 bnez a0,c10 <parseline+0x28>
+ if(peek(ps, es, ";")){
+ c3c: 00001617 auipc a2,0x1
+ c40: d2460613 addi a2,a2,-732 # 1960 <malloc+0x1f4>
+ c44: 85ce mv a1,s3
+ c46: 854a mv a0,s2
+ c48: 00000097 auipc ra,0x0
+ c4c: caa080e7 jalr -854(ra) # 8f2 <peek>
+ c50: e911 bnez a0,c64 <parseline+0x7c>
+}
+ c52: 8526 mv a0,s1
+ c54: 70a2 ld ra,40(sp)
+ c56: 7402 ld s0,32(sp)
+ c58: 64e2 ld s1,24(sp)
+ c5a: 6942 ld s2,16(sp)
+ c5c: 69a2 ld s3,8(sp)
+ c5e: 6a02 ld s4,0(sp)
+ c60: 6145 addi sp,sp,48
+ c62: 8082 ret
+ gettoken(ps, es, 0, 0);
+ c64: 4681 li a3,0
+ c66: 4601 li a2,0
+ c68: 85ce mv a1,s3
+ c6a: 854a mv a0,s2
+ c6c: 00000097 auipc ra,0x0
+ c70: b44080e7 jalr -1212(ra) # 7b0 <gettoken>
+ cmd = listcmd(cmd, parseline(ps, es));
+ c74: 85ce mv a1,s3
+ c76: 854a mv a0,s2
+ c78: 00000097 auipc ra,0x0
+ c7c: f70080e7 jalr -144(ra) # be8 <parseline>
+ c80: 85aa mv a1,a0
+ c82: 8526 mv a0,s1
+ c84: 00000097 auipc ra,0x0
+ c88: aaa080e7 jalr -1366(ra) # 72e <listcmd>
+ c8c: 84aa mv s1,a0
+ return cmd;
+ c8e: b7d1 j c52 <parseline+0x6a>
+
+0000000000000c90 <parseblock>:
+{
+ c90: 7179 addi sp,sp,-48
+ c92: f406 sd ra,40(sp)
+ c94: f022 sd s0,32(sp)
+ c96: ec26 sd s1,24(sp)
+ c98: e84a sd s2,16(sp)
+ c9a: e44e sd s3,8(sp)
+ c9c: 1800 addi s0,sp,48
+ c9e: 84aa mv s1,a0
+ ca0: 892e mv s2,a1
+ if(!peek(ps, es, "("))
+ ca2: 00001617 auipc a2,0x1
+ ca6: c8660613 addi a2,a2,-890 # 1928 <malloc+0x1bc>
+ caa: 00000097 auipc ra,0x0
+ cae: c48080e7 jalr -952(ra) # 8f2 <peek>
+ cb2: c12d beqz a0,d14 <parseblock+0x84>
+ gettoken(ps, es, 0, 0);
+ cb4: 4681 li a3,0
+ cb6: 4601 li a2,0
+ cb8: 85ca mv a1,s2
+ cba: 8526 mv a0,s1
+ cbc: 00000097 auipc ra,0x0
+ cc0: af4080e7 jalr -1292(ra) # 7b0 <gettoken>
+ cmd = parseline(ps, es);
+ cc4: 85ca mv a1,s2
+ cc6: 8526 mv a0,s1
+ cc8: 00000097 auipc ra,0x0
+ ccc: f20080e7 jalr -224(ra) # be8 <parseline>
+ cd0: 89aa mv s3,a0
+ if(!peek(ps, es, ")"))
+ cd2: 00001617 auipc a2,0x1
+ cd6: ca660613 addi a2,a2,-858 # 1978 <malloc+0x20c>
+ cda: 85ca mv a1,s2
+ cdc: 8526 mv a0,s1
+ cde: 00000097 auipc ra,0x0
+ ce2: c14080e7 jalr -1004(ra) # 8f2 <peek>
+ ce6: cd1d beqz a0,d24 <parseblock+0x94>
+ gettoken(ps, es, 0, 0);
+ ce8: 4681 li a3,0
+ cea: 4601 li a2,0
+ cec: 85ca mv a1,s2
+ cee: 8526 mv a0,s1
+ cf0: 00000097 auipc ra,0x0
+ cf4: ac0080e7 jalr -1344(ra) # 7b0 <gettoken>
+ cmd = parseredirs(cmd, ps, es);
+ cf8: 864a mv a2,s2
+ cfa: 85a6 mv a1,s1
+ cfc: 854e mv a0,s3
+ cfe: 00000097 auipc ra,0x0
+ d02: c60080e7 jalr -928(ra) # 95e <parseredirs>
+}
+ d06: 70a2 ld ra,40(sp)
+ d08: 7402 ld s0,32(sp)
+ d0a: 64e2 ld s1,24(sp)
+ d0c: 6942 ld s2,16(sp)
+ d0e: 69a2 ld s3,8(sp)
+ d10: 6145 addi sp,sp,48
+ d12: 8082 ret
+ panic("parseblock");
+ d14: 00001517 auipc a0,0x1
+ d18: c5450513 addi a0,a0,-940 # 1968 <malloc+0x1fc>
+ d1c: fffff097 auipc ra,0xfffff
+ d20: 682080e7 jalr 1666(ra) # 39e <panic>
+ panic("syntax - missing )");
+ d24: 00001517 auipc a0,0x1
+ d28: c5c50513 addi a0,a0,-932 # 1980 <malloc+0x214>
+ d2c: fffff097 auipc ra,0xfffff
+ d30: 672080e7 jalr 1650(ra) # 39e <panic>
+
+0000000000000d34 <nulterminate>:
+
+// NUL-terminate all the counted strings.
+struct cmd*
+nulterminate(struct cmd *cmd)
+{
+ d34: 1101 addi sp,sp,-32
+ d36: ec06 sd ra,24(sp)
+ d38: e822 sd s0,16(sp)
+ d3a: e426 sd s1,8(sp)
+ d3c: 1000 addi s0,sp,32
+ d3e: 84aa mv s1,a0
+ struct execcmd *ecmd;
+ struct listcmd *lcmd;
+ struct pipecmd *pcmd;
+ struct redircmd *rcmd;
+
+ if(cmd == 0)
+ d40: c521 beqz a0,d88 <nulterminate+0x54>
+ return 0;
+
+ switch(cmd->type){
+ d42: 4118 lw a4,0(a0)
+ d44: 4795 li a5,5
+ d46: 04e7e163 bltu a5,a4,d88 <nulterminate+0x54>
+ d4a: 00056783 lwu a5,0(a0)
+ d4e: 078a slli a5,a5,0x2
+ d50: 00001717 auipc a4,0x1
+ d54: cd070713 addi a4,a4,-816 # 1a20 <malloc+0x2b4>
+ d58: 97ba add a5,a5,a4
+ d5a: 439c lw a5,0(a5)
+ d5c: 97ba add a5,a5,a4
+ d5e: 8782 jr a5
+ case EXEC:
+ ecmd = (struct execcmd*)cmd;
+ for(i=0; ecmd->argv[i]; i++)
+ d60: 651c ld a5,8(a0)
+ d62: c39d beqz a5,d88 <nulterminate+0x54>
+ d64: 01050793 addi a5,a0,16
+ *ecmd->eargv[i] = 0;
+ d68: 67b8 ld a4,72(a5)
+ d6a: 00070023 sb zero,0(a4)
+ for(i=0; ecmd->argv[i]; i++)
+ d6e: 07a1 addi a5,a5,8
+ d70: ff87b703 ld a4,-8(a5)
+ d74: fb75 bnez a4,d68 <nulterminate+0x34>
+ d76: a809 j d88 <nulterminate+0x54>
+ break;
+
+ case REDIR:
+ rcmd = (struct redircmd*)cmd;
+ nulterminate(rcmd->cmd);
+ d78: 6508 ld a0,8(a0)
+ d7a: 00000097 auipc ra,0x0
+ d7e: fba080e7 jalr -70(ra) # d34 <nulterminate>
+ *rcmd->efile = 0;
+ d82: 6c9c ld a5,24(s1)
+ d84: 00078023 sb zero,0(a5)
+ bcmd = (struct backcmd*)cmd;
+ nulterminate(bcmd->cmd);
+ break;
+ }
+ return cmd;
+ d88: 8526 mv a0,s1
+ d8a: 60e2 ld ra,24(sp)
+ d8c: 6442 ld s0,16(sp)
+ d8e: 64a2 ld s1,8(sp)
+ d90: 6105 addi sp,sp,32
+ d92: 8082 ret
+ nulterminate(pcmd->left);
+ d94: 6508 ld a0,8(a0)
+ d96: 00000097 auipc ra,0x0
+ d9a: f9e080e7 jalr -98(ra) # d34 <nulterminate>
+ nulterminate(pcmd->right);
+ d9e: 6888 ld a0,16(s1)
+ da0: 00000097 auipc ra,0x0
+ da4: f94080e7 jalr -108(ra) # d34 <nulterminate>
+ break;
+ da8: b7c5 j d88 <nulterminate+0x54>
+ nulterminate(lcmd->left);
+ daa: 6508 ld a0,8(a0)
+ dac: 00000097 auipc ra,0x0
+ db0: f88080e7 jalr -120(ra) # d34 <nulterminate>
+ nulterminate(lcmd->right);
+ db4: 6888 ld a0,16(s1)
+ db6: 00000097 auipc ra,0x0
+ dba: f7e080e7 jalr -130(ra) # d34 <nulterminate>
+ break;
+ dbe: b7e9 j d88 <nulterminate+0x54>
+ nulterminate(bcmd->cmd);
+ dc0: 6508 ld a0,8(a0)
+ dc2: 00000097 auipc ra,0x0
+ dc6: f72080e7 jalr -142(ra) # d34 <nulterminate>
+ break;
+ dca: bf7d j d88 <nulterminate+0x54>
+
+0000000000000dcc <parsecmd>:
+{
+ dcc: 7139 addi sp,sp,-64
+ dce: fc06 sd ra,56(sp)
+ dd0: f822 sd s0,48(sp)
+ dd2: f426 sd s1,40(sp)
+ dd4: f04a sd s2,32(sp)
+ dd6: ec4e sd s3,24(sp)
+ dd8: 0080 addi s0,sp,64
+ dda: fca43423 sd a0,-56(s0)
+ es = s + strlen(s);
+ dde: 84aa mv s1,a0
+ de0: 00000097 auipc ra,0x0
+ de4: 2ce080e7 jalr 718(ra) # 10ae <strlen>
+ de8: 1502 slli a0,a0,0x20
+ dea: 9101 srli a0,a0,0x20
+ dec: 94aa add s1,s1,a0
+ cmd = parseline(&s, es);
+ dee: 85a6 mv a1,s1
+ df0: fc840913 addi s2,s0,-56
+ df4: 854a mv a0,s2
+ df6: 00000097 auipc ra,0x0
+ dfa: df2080e7 jalr -526(ra) # be8 <parseline>
+ dfe: 89aa mv s3,a0
+ peek(&s, es, "");
+ e00: 00001617 auipc a2,0x1
+ e04: bf060613 addi a2,a2,-1040 # 19f0 <malloc+0x284>
+ e08: 85a6 mv a1,s1
+ e0a: 854a mv a0,s2
+ e0c: 00000097 auipc ra,0x0
+ e10: ae6080e7 jalr -1306(ra) # 8f2 <peek>
+ if(s != es){
+ e14: fc843603 ld a2,-56(s0)
+ e18: 00961f63 bne a2,s1,e36 <parsecmd+0x6a>
+ nulterminate(cmd);
+ e1c: 854e mv a0,s3
+ e1e: 00000097 auipc ra,0x0
+ e22: f16080e7 jalr -234(ra) # d34 <nulterminate>
+}
+ e26: 854e mv a0,s3
+ e28: 70e2 ld ra,56(sp)
+ e2a: 7442 ld s0,48(sp)
+ e2c: 74a2 ld s1,40(sp)
+ e2e: 7902 ld s2,32(sp)
+ e30: 69e2 ld s3,24(sp)
+ e32: 6121 addi sp,sp,64
+ e34: 8082 ret
+ fprintf(2, "leftovers: %s\n", s);
+ e36: 00001597 auipc a1,0x1
+ e3a: b6258593 addi a1,a1,-1182 # 1998 <malloc+0x22c>
+ e3e: 4509 li a0,2
+ e40: 00001097 auipc ra,0x1
+ e44: 846080e7 jalr -1978(ra) # 1686 <fprintf>
+ panic("syntax");
+ e48: 00001517 auipc a0,0x1
+ e4c: ae850513 addi a0,a0,-1304 # 1930 <malloc+0x1c4>
+ e50: fffff097 auipc ra,0xfffff
+ e54: 54e080e7 jalr 1358(ra) # 39e <panic>
+
+0000000000000e58 <main>:
+{
+ e58: 711d addi sp,sp,-96
+ e5a: ec86 sd ra,88(sp)
+ e5c: e8a2 sd s0,80(sp)
+ e5e: e4a6 sd s1,72(sp)
+ e60: e0ca sd s2,64(sp)
+ e62: fc4e sd s3,56(sp)
+ e64: f852 sd s4,48(sp)
+ e66: f456 sd s5,40(sp)
+ e68: f05a sd s6,32(sp)
+ e6a: ec5e sd s7,24(sp)
+ e6c: e862 sd s8,16(sp)
+ e6e: e466 sd s9,8(sp)
+ e70: 1080 addi s0,sp,96
+ while((fd = dev(O_RDWR, 1, 0)) >= 0){
+ e72: 4601 li a2,0
+ e74: 4585 li a1,1
+ e76: 4509 li a0,2
+ e78: 00000097 auipc ra,0x0
+ e7c: 51e080e7 jalr 1310(ra) # 1396 <dev>
+ e80: 00054963 bltz a0,e92 <main+0x3a>
+ if(fd >= 3){
+ e84: 4789 li a5,2
+ e86: fea7d6e3 bge a5,a0,e72 <main+0x1a>
+ close(fd);
+ e8a: 00000097 auipc ra,0x0
+ e8e: 496080e7 jalr 1174(ra) # 1320 <close>
+ strcpy(envs[nenv].name, "SHELL");
+ e92: 00001497 auipc s1,0x1
+ e96: c2e48493 addi s1,s1,-978 # 1ac0 <nenv>
+ e9a: 4088 lw a0,0(s1)
+ e9c: 051e slli a0,a0,0x7
+ e9e: 00001917 auipc s2,0x1
+ ea2: d1290913 addi s2,s2,-750 # 1bb0 <envs>
+ ea6: 00001597 auipc a1,0x1
+ eaa: b0258593 addi a1,a1,-1278 # 19a8 <malloc+0x23c>
+ eae: 954a add a0,a0,s2
+ eb0: 00000097 auipc ra,0x0
+ eb4: 188080e7 jalr 392(ra) # 1038 <strcpy>
+ strcpy(envs[nenv].value, "/bin");
+ eb8: 4088 lw a0,0(s1)
+ eba: 051e slli a0,a0,0x7
+ ebc: 02050513 addi a0,a0,32
+ ec0: 00001597 auipc a1,0x1
+ ec4: af058593 addi a1,a1,-1296 # 19b0 <malloc+0x244>
+ ec8: 954a add a0,a0,s2
+ eca: 00000097 auipc ra,0x0
+ ece: 16e080e7 jalr 366(ra) # 1038 <strcpy>
+ nenv++;
+ ed2: 409c lw a5,0(s1)
+ ed4: 2785 addiw a5,a5,1
+ ed6: c09c sw a5,0(s1)
+ getcwd(mycwd);
+ ed8: 00001517 auipc a0,0x1
+ edc: bf050513 addi a0,a0,-1040 # 1ac8 <mycwd>
+ ee0: 00000097 auipc ra,0x0
+ ee4: 4c8080e7 jalr 1224(ra) # 13a8 <getcwd>
+ while(getcmd(buf, sizeof(buf)) >= 0){
+ ee8: 00001917 auipc s2,0x1
+ eec: c6090913 addi s2,s2,-928 # 1b48 <buf.0>
+ replace(buf);
+ ef0: 89a6 mv s3,s1
+ if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
+ ef2: 06300a13 li s4,99
+ else if(!strcmp(ecmd->argv[0], "export"))
+ ef6: 00001a97 auipc s5,0x1
+ efa: ad2a8a93 addi s5,s5,-1326 # 19c8 <malloc+0x25c>
+ fprintf(2, "export failed\n");
+ efe: 00001b97 auipc s7,0x1
+ f02: afab8b93 addi s7,s7,-1286 # 19f8 <malloc+0x28c>
+ fprintf(2, "Usage: export [-p] [NAME=VALUE]\n");
+ f06: 00001b17 auipc s6,0x1
+ f0a: acab0b13 addi s6,s6,-1334 # 19d0 <malloc+0x264>
+ if(chdir(buf+3) < 0)
+ f0e: 00001c17 auipc s8,0x1
+ f12: c3dc0c13 addi s8,s8,-963 # 1b4b <buf.0+0x3>
+ getcwd(mycwd);
+ f16: 00001c97 auipc s9,0x1
+ f1a: bb2c8c93 addi s9,s9,-1102 # 1ac8 <mycwd>
+ while(getcmd(buf, sizeof(buf)) >= 0){
+ f1e: a8a5 j f96 <main+0x13e>
+ if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
+ f20: 08a9c703 lbu a4,138(s3)
+ f24: 02000793 li a5,32
+ f28: 08f71f63 bne a4,a5,fc6 <main+0x16e>
+ buf[strlen(buf)-1] = 0; // chop \n
+ f2c: 854a mv a0,s2
+ f2e: 00000097 auipc ra,0x0
+ f32: 180080e7 jalr 384(ra) # 10ae <strlen>
+ f36: fff5079b addiw a5,a0,-1
+ f3a: 1782 slli a5,a5,0x20
+ f3c: 9381 srli a5,a5,0x20
+ f3e: 97ce add a5,a5,s3
+ f40: 08078423 sb zero,136(a5)
+ if(chdir(buf+3) < 0)
+ f44: 8562 mv a0,s8
+ f46: 00000097 auipc ra,0x0
+ f4a: 414080e7 jalr 1044(ra) # 135a <chdir>
+ f4e: 00054863 bltz a0,f5e <main+0x106>
+ getcwd(mycwd);
+ f52: 8566 mv a0,s9
+ f54: 00000097 auipc ra,0x0
+ f58: 454080e7 jalr 1108(ra) # 13a8 <getcwd>
+ f5c: a82d j f96 <main+0x13e>
+ fprintf(2, "cannot cd %s\n", buf+3);
+ f5e: 8662 mv a2,s8
+ f60: 00001597 auipc a1,0x1
+ f64: a5858593 addi a1,a1,-1448 # 19b8 <malloc+0x24c>
+ f68: 4509 li a0,2
+ f6a: 00000097 auipc ra,0x0
+ f6e: 71c080e7 jalr 1820(ra) # 1686 <fprintf>
+ f72: b7c5 j f52 <main+0xfa>
+ free(cmd);
+ f74: 8526 mv a0,s1
+ f76: 00000097 auipc ra,0x0
+ f7a: 774080e7 jalr 1908(ra) # 16ea <free>
+ continue;
+ f7e: a821 j f96 <main+0x13e>
+ fprintf(2, "Usage: export [-p] [NAME=VALUE]\n");
+ f80: 85da mv a1,s6
+ f82: 4509 li a0,2
+ f84: 00000097 auipc ra,0x0
+ f88: 702080e7 jalr 1794(ra) # 1686 <fprintf>
+ free(cmd);
+ f8c: 8526 mv a0,s1
+ f8e: 00000097 auipc ra,0x0
+ f92: 75c080e7 jalr 1884(ra) # 16ea <free>
+ while(getcmd(buf, sizeof(buf)) >= 0){
+ f96: 06400593 li a1,100
+ f9a: 854a mv a0,s2
+ f9c: fffff097 auipc ra,0xfffff
+ fa0: 3a6080e7 jalr 934(ra) # 342 <getcmd>
+ fa4: 08054563 bltz a0,102e <main+0x1d6>
+ replace(buf);
+ fa8: 854a mv a0,s2
+ faa: fffff097 auipc ra,0xfffff
+ fae: 254080e7 jalr 596(ra) # 1fe <replace>
+ if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
+ fb2: 0889c783 lbu a5,136(s3)
+ fb6: 01479863 bne a5,s4,fc6 <main+0x16e>
+ fba: 0899c703 lbu a4,137(s3)
+ fbe: 06400793 li a5,100
+ fc2: f4f70fe3 beq a4,a5,f20 <main+0xc8>
+ struct cmd *cmd = parsecmd(buf);
+ fc6: 854a mv a0,s2
+ fc8: 00000097 auipc ra,0x0
+ fcc: e04080e7 jalr -508(ra) # dcc <parsecmd>
+ fd0: 84aa mv s1,a0
+ if(ecmd->argv[0] == 0) {
+ fd2: 6508 ld a0,8(a0)
+ fd4: d145 beqz a0,f74 <main+0x11c>
+ else if(!strcmp(ecmd->argv[0], "export"))
+ fd6: 85d6 mv a1,s5
+ fd8: 00000097 auipc ra,0x0
+ fdc: 0aa080e7 jalr 170(ra) # 1082 <strcmp>
+ fe0: e115 bnez a0,1004 <main+0x1ac>
+ if(ecmd->argv[1] == NULL)
+ fe2: 689c ld a5,16(s1)
+ fe4: dfd1 beqz a5,f80 <main+0x128>
+ else if(export(ecmd->argv) < 0)
+ fe6: 00848513 addi a0,s1,8
+ fea: fffff097 auipc ra,0xfffff
+ fee: 07c080e7 jalr 124(ra) # 66 <export>
+ ff2: f8055de3 bgez a0,f8c <main+0x134>
+ fprintf(2, "export failed\n");
+ ff6: 85de mv a1,s7
+ ff8: 4509 li a0,2
+ ffa: 00000097 auipc ra,0x0
+ ffe: 68c080e7 jalr 1676(ra) # 1686 <fprintf>
+ 1002: b769 j f8c <main+0x134>
+ else if(fork1() == 0)
+ 1004: fffff097 auipc ra,0xfffff
+ 1008: 3c0080e7 jalr 960(ra) # 3c4 <fork1>
+ 100c: cd01 beqz a0,1024 <main+0x1cc>
+ wait(0);
+ 100e: 4501 li a0,0
+ 1010: 00000097 auipc ra,0x0
+ 1014: 2ea080e7 jalr 746(ra) # 12fa <wait>
+ free(cmd);
+ 1018: 8526 mv a0,s1
+ 101a: 00000097 auipc ra,0x0
+ 101e: 6d0080e7 jalr 1744(ra) # 16ea <free>
+ 1022: bf95 j f96 <main+0x13e>
+ runcmd(cmd);
+ 1024: 8526 mv a0,s1
+ 1026: fffff097 auipc ra,0xfffff
+ 102a: 3cc080e7 jalr 972(ra) # 3f2 <runcmd>
+ exit(0);
+ 102e: 4501 li a0,0
+ 1030: 00000097 auipc ra,0x0
+ 1034: 2c0080e7 jalr 704(ra) # 12f0 <exit>
+
+0000000000001038 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 1038: 1141 addi sp,sp,-16
+ 103a: e422 sd s0,8(sp)
+ 103c: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 103e: 87aa mv a5,a0
+ 1040: 0585 addi a1,a1,1
+ 1042: 0785 addi a5,a5,1
+ 1044: fff5c703 lbu a4,-1(a1)
+ 1048: fee78fa3 sb a4,-1(a5)
+ 104c: fb75 bnez a4,1040 <strcpy+0x8>
+ ;
+ return os;
+}
+ 104e: 6422 ld s0,8(sp)
+ 1050: 0141 addi sp,sp,16
+ 1052: 8082 ret
+
+0000000000001054 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 1054: 1141 addi sp,sp,-16
+ 1056: e422 sd s0,8(sp)
+ 1058: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 105a: 00054783 lbu a5,0(a0)
+ 105e: c385 beqz a5,107e <strcat+0x2a>
+ 1060: 87aa mv a5,a0
+ s++;
+ 1062: 0785 addi a5,a5,1
+ while(*s)
+ 1064: 0007c703 lbu a4,0(a5)
+ 1068: ff6d bnez a4,1062 <strcat+0xe>
+ while((*s++ = *t++))
+ 106a: 0585 addi a1,a1,1
+ 106c: 0785 addi a5,a5,1
+ 106e: fff5c703 lbu a4,-1(a1)
+ 1072: fee78fa3 sb a4,-1(a5)
+ 1076: fb75 bnez a4,106a <strcat+0x16>
+ ;
+ return os;
+}
+ 1078: 6422 ld s0,8(sp)
+ 107a: 0141 addi sp,sp,16
+ 107c: 8082 ret
+ while(*s)
+ 107e: 87aa mv a5,a0
+ 1080: b7ed j 106a <strcat+0x16>
+
+0000000000001082 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 1082: 1141 addi sp,sp,-16
+ 1084: e422 sd s0,8(sp)
+ 1086: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 1088: 00054783 lbu a5,0(a0)
+ 108c: cb91 beqz a5,10a0 <strcmp+0x1e>
+ 108e: 0005c703 lbu a4,0(a1)
+ 1092: 00f71763 bne a4,a5,10a0 <strcmp+0x1e>
+ p++, q++;
+ 1096: 0505 addi a0,a0,1
+ 1098: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 109a: 00054783 lbu a5,0(a0)
+ 109e: fbe5 bnez a5,108e <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 10a0: 0005c503 lbu a0,0(a1)
+}
+ 10a4: 40a7853b subw a0,a5,a0
+ 10a8: 6422 ld s0,8(sp)
+ 10aa: 0141 addi sp,sp,16
+ 10ac: 8082 ret
+
+00000000000010ae <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 10ae: 1141 addi sp,sp,-16
+ 10b0: e422 sd s0,8(sp)
+ 10b2: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 10b4: 00054783 lbu a5,0(a0)
+ 10b8: cf91 beqz a5,10d4 <strlen+0x26>
+ 10ba: 0505 addi a0,a0,1
+ 10bc: 87aa mv a5,a0
+ 10be: 4685 li a3,1
+ 10c0: 9e89 subw a3,a3,a0
+ 10c2: 00f6853b addw a0,a3,a5
+ 10c6: 0785 addi a5,a5,1
+ 10c8: fff7c703 lbu a4,-1(a5)
+ 10cc: fb7d bnez a4,10c2 <strlen+0x14>
+ ;
+ return n;
+}
+ 10ce: 6422 ld s0,8(sp)
+ 10d0: 0141 addi sp,sp,16
+ 10d2: 8082 ret
+ for(n = 0; s[n]; n++)
+ 10d4: 4501 li a0,0
+ 10d6: bfe5 j 10ce <strlen+0x20>
+
+00000000000010d8 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 10d8: 1141 addi sp,sp,-16
+ 10da: e422 sd s0,8(sp)
+ 10dc: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 10de: ca19 beqz a2,10f4 <memset+0x1c>
+ 10e0: 87aa mv a5,a0
+ 10e2: 1602 slli a2,a2,0x20
+ 10e4: 9201 srli a2,a2,0x20
+ 10e6: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 10ea: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 10ee: 0785 addi a5,a5,1
+ 10f0: fee79de3 bne a5,a4,10ea <memset+0x12>
+ }
+ return dst;
+}
+ 10f4: 6422 ld s0,8(sp)
+ 10f6: 0141 addi sp,sp,16
+ 10f8: 8082 ret
+
+00000000000010fa <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 10fa: 1141 addi sp,sp,-16
+ 10fc: e422 sd s0,8(sp)
+ 10fe: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 1100: 00054783 lbu a5,0(a0)
+ 1104: cb99 beqz a5,111a <strchr+0x20>
+ if(*s == c)
+ 1106: 00f58763 beq a1,a5,1114 <strchr+0x1a>
+ for(; *s; s++)
+ 110a: 0505 addi a0,a0,1
+ 110c: 00054783 lbu a5,0(a0)
+ 1110: fbfd bnez a5,1106 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 1112: 4501 li a0,0
+}
+ 1114: 6422 ld s0,8(sp)
+ 1116: 0141 addi sp,sp,16
+ 1118: 8082 ret
+ return 0;
+ 111a: 4501 li a0,0
+ 111c: bfe5 j 1114 <strchr+0x1a>
+
+000000000000111e <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 111e: 711d addi sp,sp,-96
+ 1120: ec86 sd ra,88(sp)
+ 1122: e8a2 sd s0,80(sp)
+ 1124: e4a6 sd s1,72(sp)
+ 1126: e0ca sd s2,64(sp)
+ 1128: fc4e sd s3,56(sp)
+ 112a: f852 sd s4,48(sp)
+ 112c: f456 sd s5,40(sp)
+ 112e: f05a sd s6,32(sp)
+ 1130: ec5e sd s7,24(sp)
+ 1132: e862 sd s8,16(sp)
+ 1134: 1080 addi s0,sp,96
+ 1136: 8baa mv s7,a0
+ 1138: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 113a: 892a mv s2,a0
+ 113c: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 113e: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 1142: 4b29 li s6,10
+ 1144: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 1146: 89a6 mv s3,s1
+ 1148: 2485 addiw s1,s1,1
+ 114a: 0344d763 bge s1,s4,1178 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 114e: 4605 li a2,1
+ 1150: 85d6 mv a1,s5
+ 1152: 4501 li a0,0
+ 1154: 00000097 auipc ra,0x0
+ 1158: 1b8080e7 jalr 440(ra) # 130c <read>
+ if(cc < 1)
+ 115c: 00a05e63 blez a0,1178 <gets+0x5a>
+ buf[i++] = c;
+ 1160: faf44783 lbu a5,-81(s0)
+ 1164: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 1168: 01678763 beq a5,s6,1176 <gets+0x58>
+ 116c: 0905 addi s2,s2,1
+ 116e: fd879ce3 bne a5,s8,1146 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 1172: 89a6 mv s3,s1
+ 1174: a011 j 1178 <gets+0x5a>
+ 1176: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1178: 99de add s3,s3,s7
+ 117a: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 117e: 855e mv a0,s7
+ 1180: 60e6 ld ra,88(sp)
+ 1182: 6446 ld s0,80(sp)
+ 1184: 64a6 ld s1,72(sp)
+ 1186: 6906 ld s2,64(sp)
+ 1188: 79e2 ld s3,56(sp)
+ 118a: 7a42 ld s4,48(sp)
+ 118c: 7aa2 ld s5,40(sp)
+ 118e: 7b02 ld s6,32(sp)
+ 1190: 6be2 ld s7,24(sp)
+ 1192: 6c42 ld s8,16(sp)
+ 1194: 6125 addi sp,sp,96
+ 1196: 8082 ret
+
+0000000000001198 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1198: 1101 addi sp,sp,-32
+ 119a: ec06 sd ra,24(sp)
+ 119c: e822 sd s0,16(sp)
+ 119e: e426 sd s1,8(sp)
+ 11a0: e04a sd s2,0(sp)
+ 11a2: 1000 addi s0,sp,32
+ 11a4: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 11a6: 4581 li a1,0
+ 11a8: 00000097 auipc ra,0x0
+ 11ac: 194080e7 jalr 404(ra) # 133c <open>
+ if(fd < 0)
+ 11b0: 02054563 bltz a0,11da <stat+0x42>
+ 11b4: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 11b6: 85ca mv a1,s2
+ 11b8: 00000097 auipc ra,0x0
+ 11bc: 18e080e7 jalr 398(ra) # 1346 <fstat>
+ 11c0: 892a mv s2,a0
+ close(fd);
+ 11c2: 8526 mv a0,s1
+ 11c4: 00000097 auipc ra,0x0
+ 11c8: 15c080e7 jalr 348(ra) # 1320 <close>
+ return r;
+}
+ 11cc: 854a mv a0,s2
+ 11ce: 60e2 ld ra,24(sp)
+ 11d0: 6442 ld s0,16(sp)
+ 11d2: 64a2 ld s1,8(sp)
+ 11d4: 6902 ld s2,0(sp)
+ 11d6: 6105 addi sp,sp,32
+ 11d8: 8082 ret
+ return -1;
+ 11da: 597d li s2,-1
+ 11dc: bfc5 j 11cc <stat+0x34>
+
+00000000000011de <atoi>:
+
+int
+atoi(const char *s)
+{
+ 11de: 1141 addi sp,sp,-16
+ 11e0: e422 sd s0,8(sp)
+ 11e2: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 11e4: 00054703 lbu a4,0(a0)
+ 11e8: 02d00793 li a5,45
+ int neg = 1;
+ 11ec: 4585 li a1,1
+ if (*s == '-') {
+ 11ee: 04f70363 beq a4,a5,1234 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 11f2: 00054703 lbu a4,0(a0)
+ 11f6: fd07079b addiw a5,a4,-48
+ 11fa: 0ff7f793 zext.b a5,a5
+ 11fe: 46a5 li a3,9
+ 1200: 02f6ed63 bltu a3,a5,123a <atoi+0x5c>
+ n = 0;
+ 1204: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 1206: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 1208: 0505 addi a0,a0,1
+ 120a: 0026979b slliw a5,a3,0x2
+ 120e: 9fb5 addw a5,a5,a3
+ 1210: 0017979b slliw a5,a5,0x1
+ 1214: 9fb9 addw a5,a5,a4
+ 1216: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 121a: 00054703 lbu a4,0(a0)
+ 121e: fd07079b addiw a5,a4,-48
+ 1222: 0ff7f793 zext.b a5,a5
+ 1226: fef671e3 bgeu a2,a5,1208 <atoi+0x2a>
+ return n * neg;
+}
+ 122a: 02d5853b mulw a0,a1,a3
+ 122e: 6422 ld s0,8(sp)
+ 1230: 0141 addi sp,sp,16
+ 1232: 8082 ret
+ s++;
+ 1234: 0505 addi a0,a0,1
+ neg = -1;
+ 1236: 55fd li a1,-1
+ 1238: bf6d j 11f2 <atoi+0x14>
+ n = 0;
+ 123a: 4681 li a3,0
+ 123c: b7fd j 122a <atoi+0x4c>
+
+000000000000123e <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 123e: 1141 addi sp,sp,-16
+ 1240: e422 sd s0,8(sp)
+ 1242: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 1244: 02b57463 bgeu a0,a1,126c <memmove+0x2e>
+ while(n-- > 0)
+ 1248: 00c05f63 blez a2,1266 <memmove+0x28>
+ 124c: 1602 slli a2,a2,0x20
+ 124e: 9201 srli a2,a2,0x20
+ 1250: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 1254: 872a mv a4,a0
+ *dst++ = *src++;
+ 1256: 0585 addi a1,a1,1
+ 1258: 0705 addi a4,a4,1
+ 125a: fff5c683 lbu a3,-1(a1)
+ 125e: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 1262: fee79ae3 bne a5,a4,1256 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 1266: 6422 ld s0,8(sp)
+ 1268: 0141 addi sp,sp,16
+ 126a: 8082 ret
+ dst += n;
+ 126c: 00c50733 add a4,a0,a2
+ src += n;
+ 1270: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 1272: fec05ae3 blez a2,1266 <memmove+0x28>
+ 1276: fff6079b addiw a5,a2,-1
+ 127a: 1782 slli a5,a5,0x20
+ 127c: 9381 srli a5,a5,0x20
+ 127e: fff7c793 not a5,a5
+ 1282: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 1284: 15fd addi a1,a1,-1
+ 1286: 177d addi a4,a4,-1
+ 1288: 0005c683 lbu a3,0(a1)
+ 128c: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 1290: fee79ae3 bne a5,a4,1284 <memmove+0x46>
+ 1294: bfc9 j 1266 <memmove+0x28>
+
+0000000000001296 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 1296: 1141 addi sp,sp,-16
+ 1298: e422 sd s0,8(sp)
+ 129a: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 129c: ca05 beqz a2,12cc <memcmp+0x36>
+ 129e: fff6069b addiw a3,a2,-1
+ 12a2: 1682 slli a3,a3,0x20
+ 12a4: 9281 srli a3,a3,0x20
+ 12a6: 0685 addi a3,a3,1
+ 12a8: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 12aa: 00054783 lbu a5,0(a0)
+ 12ae: 0005c703 lbu a4,0(a1)
+ 12b2: 00e79863 bne a5,a4,12c2 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 12b6: 0505 addi a0,a0,1
+ p2++;
+ 12b8: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 12ba: fed518e3 bne a0,a3,12aa <memcmp+0x14>
+ }
+ return 0;
+ 12be: 4501 li a0,0
+ 12c0: a019 j 12c6 <memcmp+0x30>
+ return *p1 - *p2;
+ 12c2: 40e7853b subw a0,a5,a4
+}
+ 12c6: 6422 ld s0,8(sp)
+ 12c8: 0141 addi sp,sp,16
+ 12ca: 8082 ret
+ return 0;
+ 12cc: 4501 li a0,0
+ 12ce: bfe5 j 12c6 <memcmp+0x30>
+
+00000000000012d0 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 12d0: 1141 addi sp,sp,-16
+ 12d2: e406 sd ra,8(sp)
+ 12d4: e022 sd s0,0(sp)
+ 12d6: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 12d8: 00000097 auipc ra,0x0
+ 12dc: f66080e7 jalr -154(ra) # 123e <memmove>
+}
+ 12e0: 60a2 ld ra,8(sp)
+ 12e2: 6402 ld s0,0(sp)
+ 12e4: 0141 addi sp,sp,16
+ 12e6: 8082 ret
+
+00000000000012e8 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 12e8: 4885 li a7,1
+ ecall
+ 12ea: 00000073 ecall
+ ret
+ 12ee: 8082 ret
+
+00000000000012f0 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 12f0: 05d00893 li a7,93
+ ecall
+ 12f4: 00000073 ecall
+ ret
+ 12f8: 8082 ret
+
+00000000000012fa <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 12fa: 488d li a7,3
+ ecall
+ 12fc: 00000073 ecall
+ ret
+ 1300: 8082 ret
+
+0000000000001302 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 1302: 03b00893 li a7,59
+ ecall
+ 1306: 00000073 ecall
+ ret
+ 130a: 8082 ret
+
+000000000000130c <read>:
+.global read
+read:
+ li a7, SYS_read
+ 130c: 03f00893 li a7,63
+ ecall
+ 1310: 00000073 ecall
+ ret
+ 1314: 8082 ret
+
+0000000000001316 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 1316: 04000893 li a7,64
+ ecall
+ 131a: 00000073 ecall
+ ret
+ 131e: 8082 ret
+
+0000000000001320 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 1320: 03900893 li a7,57
+ ecall
+ 1324: 00000073 ecall
+ ret
+ 1328: 8082 ret
+
+000000000000132a <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 132a: 4899 li a7,6
+ ecall
+ 132c: 00000073 ecall
+ ret
+ 1330: 8082 ret
+
+0000000000001332 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 1332: 0dd00893 li a7,221
+ ecall
+ 1336: 00000073 ecall
+ ret
+ 133a: 8082 ret
+
+000000000000133c <open>:
+.global open
+open:
+ li a7, SYS_open
+ 133c: 03800893 li a7,56
+ ecall
+ 1340: 00000073 ecall
+ ret
+ 1344: 8082 ret
+
+0000000000001346 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 1346: 05000893 li a7,80
+ ecall
+ 134a: 00000073 ecall
+ ret
+ 134e: 8082 ret
+
+0000000000001350 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 1350: 02200893 li a7,34
+ ecall
+ 1354: 00000073 ecall
+ ret
+ 1358: 8082 ret
+
+000000000000135a <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 135a: 03100893 li a7,49
+ ecall
+ 135e: 00000073 ecall
+ ret
+ 1362: 8082 ret
+
+0000000000001364 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 1364: 48dd li a7,23
+ ecall
+ 1366: 00000073 ecall
+ ret
+ 136a: 8082 ret
+
+000000000000136c <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 136c: 0ac00893 li a7,172
+ ecall
+ 1370: 00000073 ecall
+ ret
+ 1374: 8082 ret
+
+0000000000001376 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 1376: 48b1 li a7,12
+ ecall
+ 1378: 00000073 ecall
+ ret
+ 137c: 8082 ret
+
+000000000000137e <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 137e: 48b5 li a7,13
+ ecall
+ 1380: 00000073 ecall
+ ret
+ 1384: 8082 ret
+
+0000000000001386 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 1386: 48b9 li a7,14
+ ecall
+ 1388: 00000073 ecall
+ ret
+ 138c: 8082 ret
+
+000000000000138e <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 138e: 48d9 li a7,22
+ ecall
+ 1390: 00000073 ecall
+ ret
+ 1394: 8082 ret
+
+0000000000001396 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 1396: 03200893 li a7,50
+ ecall
+ 139a: 00000073 ecall
+ ret
+ 139e: 8082 ret
+
+00000000000013a0 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 13a0: 48ed li a7,27
+ ecall
+ 13a2: 00000073 ecall
+ ret
+ 13a6: 8082 ret
+
+00000000000013a8 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 13a8: 48c5 li a7,17
+ ecall
+ 13aa: 00000073 ecall
+ ret
+ 13ae: 8082 ret
+
+00000000000013b0 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 13b0: 07500893 li a7,117
+ ecall
+ 13b4: 00000073 ecall
+ ret
+ 13b8: 8082 ret
+
+00000000000013ba <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 13ba: 48c9 li a7,18
+ ecall
+ 13bc: 00000073 ecall
+ ret
+ 13c0: 8082 ret
+
+00000000000013c2 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 13c2: 48cd li a7,19
+ ecall
+ 13c4: 00000073 ecall
+ ret
+ 13c8: 8082 ret
+
+00000000000013ca <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 13ca: 48e9 li a7,26
+ ecall
+ 13cc: 00000073 ecall
+ ret
+ 13d0: 8082 ret
+
+00000000000013d2 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 13d2: 0d200893 li a7,210
+ ecall
+ 13d6: 00000073 ecall
+ ret
+ 13da: 8082 ret
+
+00000000000013dc <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 13dc: 1101 addi sp,sp,-32
+ 13de: ec06 sd ra,24(sp)
+ 13e0: e822 sd s0,16(sp)
+ 13e2: 1000 addi s0,sp,32
+ 13e4: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 13e8: 4605 li a2,1
+ 13ea: fef40593 addi a1,s0,-17
+ 13ee: 00000097 auipc ra,0x0
+ 13f2: f28080e7 jalr -216(ra) # 1316 <write>
+}
+ 13f6: 60e2 ld ra,24(sp)
+ 13f8: 6442 ld s0,16(sp)
+ 13fa: 6105 addi sp,sp,32
+ 13fc: 8082 ret
+
+00000000000013fe <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 13fe: 7139 addi sp,sp,-64
+ 1400: fc06 sd ra,56(sp)
+ 1402: f822 sd s0,48(sp)
+ 1404: f426 sd s1,40(sp)
+ 1406: f04a sd s2,32(sp)
+ 1408: ec4e sd s3,24(sp)
+ 140a: 0080 addi s0,sp,64
+ 140c: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 140e: c299 beqz a3,1414 <printint+0x16>
+ 1410: 0805c863 bltz a1,14a0 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 1414: 2581 sext.w a1,a1
+ neg = 0;
+ 1416: 4881 li a7,0
+ }
+
+ i = 0;
+ 1418: fc040993 addi s3,s0,-64
+ neg = 0;
+ 141c: 86ce mv a3,s3
+ i = 0;
+ 141e: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 1420: 2601 sext.w a2,a2
+ 1422: 00000517 auipc a0,0x0
+ 1426: 67650513 addi a0,a0,1654 # 1a98 <digits>
+ 142a: 883a mv a6,a4
+ 142c: 2705 addiw a4,a4,1
+ 142e: 02c5f7bb remuw a5,a1,a2
+ 1432: 1782 slli a5,a5,0x20
+ 1434: 9381 srli a5,a5,0x20
+ 1436: 97aa add a5,a5,a0
+ 1438: 0007c783 lbu a5,0(a5)
+ 143c: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 1440: 0005879b sext.w a5,a1
+ 1444: 02c5d5bb divuw a1,a1,a2
+ 1448: 0685 addi a3,a3,1
+ 144a: fec7f0e3 bgeu a5,a2,142a <printint+0x2c>
+ if(neg)
+ 144e: 00088c63 beqz a7,1466 <printint+0x68>
+ buf[i++] = '-';
+ 1452: fd070793 addi a5,a4,-48
+ 1456: 00878733 add a4,a5,s0
+ 145a: 02d00793 li a5,45
+ 145e: fef70823 sb a5,-16(a4)
+ 1462: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 1466: 02e05663 blez a4,1492 <printint+0x94>
+ 146a: fc040913 addi s2,s0,-64
+ 146e: 993a add s2,s2,a4
+ 1470: 19fd addi s3,s3,-1
+ 1472: 99ba add s3,s3,a4
+ 1474: 377d addiw a4,a4,-1
+ 1476: 1702 slli a4,a4,0x20
+ 1478: 9301 srli a4,a4,0x20
+ 147a: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 147e: fff94583 lbu a1,-1(s2)
+ 1482: 8526 mv a0,s1
+ 1484: 00000097 auipc ra,0x0
+ 1488: f58080e7 jalr -168(ra) # 13dc <putc>
+ while(--i >= 0)
+ 148c: 197d addi s2,s2,-1
+ 148e: ff3918e3 bne s2,s3,147e <printint+0x80>
+}
+ 1492: 70e2 ld ra,56(sp)
+ 1494: 7442 ld s0,48(sp)
+ 1496: 74a2 ld s1,40(sp)
+ 1498: 7902 ld s2,32(sp)
+ 149a: 69e2 ld s3,24(sp)
+ 149c: 6121 addi sp,sp,64
+ 149e: 8082 ret
+ x = -xx;
+ 14a0: 40b005bb negw a1,a1
+ neg = 1;
+ 14a4: 4885 li a7,1
+ x = -xx;
+ 14a6: bf8d j 1418 <printint+0x1a>
+
+00000000000014a8 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 14a8: 7119 addi sp,sp,-128
+ 14aa: fc86 sd ra,120(sp)
+ 14ac: f8a2 sd s0,112(sp)
+ 14ae: f4a6 sd s1,104(sp)
+ 14b0: f0ca sd s2,96(sp)
+ 14b2: ecce sd s3,88(sp)
+ 14b4: e8d2 sd s4,80(sp)
+ 14b6: e4d6 sd s5,72(sp)
+ 14b8: e0da sd s6,64(sp)
+ 14ba: fc5e sd s7,56(sp)
+ 14bc: f862 sd s8,48(sp)
+ 14be: f466 sd s9,40(sp)
+ 14c0: f06a sd s10,32(sp)
+ 14c2: ec6e sd s11,24(sp)
+ 14c4: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 14c6: 0005c903 lbu s2,0(a1)
+ 14ca: 18090f63 beqz s2,1668 <vprintf+0x1c0>
+ 14ce: 8aaa mv s5,a0
+ 14d0: 8b32 mv s6,a2
+ 14d2: 00158493 addi s1,a1,1
+ state = 0;
+ 14d6: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 14d8: 02500a13 li s4,37
+ 14dc: 4c55 li s8,21
+ 14de: 00000c97 auipc s9,0x0
+ 14e2: 562c8c93 addi s9,s9,1378 # 1a40 <malloc+0x2d4>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 14e6: 02800d93 li s11,40
+ putc(fd, 'x');
+ 14ea: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 14ec: 00000b97 auipc s7,0x0
+ 14f0: 5acb8b93 addi s7,s7,1452 # 1a98 <digits>
+ 14f4: a839 j 1512 <vprintf+0x6a>
+ putc(fd, c);
+ 14f6: 85ca mv a1,s2
+ 14f8: 8556 mv a0,s5
+ 14fa: 00000097 auipc ra,0x0
+ 14fe: ee2080e7 jalr -286(ra) # 13dc <putc>
+ 1502: a019 j 1508 <vprintf+0x60>
+ } else if(state == '%'){
+ 1504: 01498d63 beq s3,s4,151e <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 1508: 0485 addi s1,s1,1
+ 150a: fff4c903 lbu s2,-1(s1)
+ 150e: 14090d63 beqz s2,1668 <vprintf+0x1c0>
+ if(state == 0){
+ 1512: fe0999e3 bnez s3,1504 <vprintf+0x5c>
+ if(c == '%'){
+ 1516: ff4910e3 bne s2,s4,14f6 <vprintf+0x4e>
+ state = '%';
+ 151a: 89d2 mv s3,s4
+ 151c: b7f5 j 1508 <vprintf+0x60>
+ if(c == 'd'){
+ 151e: 11490c63 beq s2,s4,1636 <vprintf+0x18e>
+ 1522: f9d9079b addiw a5,s2,-99
+ 1526: 0ff7f793 zext.b a5,a5
+ 152a: 10fc6e63 bltu s8,a5,1646 <vprintf+0x19e>
+ 152e: f9d9079b addiw a5,s2,-99
+ 1532: 0ff7f713 zext.b a4,a5
+ 1536: 10ec6863 bltu s8,a4,1646 <vprintf+0x19e>
+ 153a: 00271793 slli a5,a4,0x2
+ 153e: 97e6 add a5,a5,s9
+ 1540: 439c lw a5,0(a5)
+ 1542: 97e6 add a5,a5,s9
+ 1544: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 1546: 008b0913 addi s2,s6,8
+ 154a: 4685 li a3,1
+ 154c: 4629 li a2,10
+ 154e: 000b2583 lw a1,0(s6)
+ 1552: 8556 mv a0,s5
+ 1554: 00000097 auipc ra,0x0
+ 1558: eaa080e7 jalr -342(ra) # 13fe <printint>
+ 155c: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 155e: 4981 li s3,0
+ 1560: b765 j 1508 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 1562: 008b0913 addi s2,s6,8
+ 1566: 4681 li a3,0
+ 1568: 4629 li a2,10
+ 156a: 000b2583 lw a1,0(s6)
+ 156e: 8556 mv a0,s5
+ 1570: 00000097 auipc ra,0x0
+ 1574: e8e080e7 jalr -370(ra) # 13fe <printint>
+ 1578: 8b4a mv s6,s2
+ state = 0;
+ 157a: 4981 li s3,0
+ 157c: b771 j 1508 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 157e: 008b0913 addi s2,s6,8
+ 1582: 4681 li a3,0
+ 1584: 866a mv a2,s10
+ 1586: 000b2583 lw a1,0(s6)
+ 158a: 8556 mv a0,s5
+ 158c: 00000097 auipc ra,0x0
+ 1590: e72080e7 jalr -398(ra) # 13fe <printint>
+ 1594: 8b4a mv s6,s2
+ state = 0;
+ 1596: 4981 li s3,0
+ 1598: bf85 j 1508 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 159a: 008b0793 addi a5,s6,8
+ 159e: f8f43423 sd a5,-120(s0)
+ 15a2: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 15a6: 03000593 li a1,48
+ 15aa: 8556 mv a0,s5
+ 15ac: 00000097 auipc ra,0x0
+ 15b0: e30080e7 jalr -464(ra) # 13dc <putc>
+ putc(fd, 'x');
+ 15b4: 07800593 li a1,120
+ 15b8: 8556 mv a0,s5
+ 15ba: 00000097 auipc ra,0x0
+ 15be: e22080e7 jalr -478(ra) # 13dc <putc>
+ 15c2: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 15c4: 03c9d793 srli a5,s3,0x3c
+ 15c8: 97de add a5,a5,s7
+ 15ca: 0007c583 lbu a1,0(a5)
+ 15ce: 8556 mv a0,s5
+ 15d0: 00000097 auipc ra,0x0
+ 15d4: e0c080e7 jalr -500(ra) # 13dc <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 15d8: 0992 slli s3,s3,0x4
+ 15da: 397d addiw s2,s2,-1
+ 15dc: fe0914e3 bnez s2,15c4 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 15e0: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 15e4: 4981 li s3,0
+ 15e6: b70d j 1508 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 15e8: 008b0913 addi s2,s6,8
+ 15ec: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 15f0: 02098163 beqz s3,1612 <vprintf+0x16a>
+ while(*s != 0){
+ 15f4: 0009c583 lbu a1,0(s3)
+ 15f8: c5ad beqz a1,1662 <vprintf+0x1ba>
+ putc(fd, *s);
+ 15fa: 8556 mv a0,s5
+ 15fc: 00000097 auipc ra,0x0
+ 1600: de0080e7 jalr -544(ra) # 13dc <putc>
+ s++;
+ 1604: 0985 addi s3,s3,1
+ while(*s != 0){
+ 1606: 0009c583 lbu a1,0(s3)
+ 160a: f9e5 bnez a1,15fa <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 160c: 8b4a mv s6,s2
+ state = 0;
+ 160e: 4981 li s3,0
+ 1610: bde5 j 1508 <vprintf+0x60>
+ s = "(null)";
+ 1612: 00000997 auipc s3,0x0
+ 1616: 42698993 addi s3,s3,1062 # 1a38 <malloc+0x2cc>
+ while(*s != 0){
+ 161a: 85ee mv a1,s11
+ 161c: bff9 j 15fa <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 161e: 008b0913 addi s2,s6,8
+ 1622: 000b4583 lbu a1,0(s6)
+ 1626: 8556 mv a0,s5
+ 1628: 00000097 auipc ra,0x0
+ 162c: db4080e7 jalr -588(ra) # 13dc <putc>
+ 1630: 8b4a mv s6,s2
+ state = 0;
+ 1632: 4981 li s3,0
+ 1634: bdd1 j 1508 <vprintf+0x60>
+ putc(fd, c);
+ 1636: 85d2 mv a1,s4
+ 1638: 8556 mv a0,s5
+ 163a: 00000097 auipc ra,0x0
+ 163e: da2080e7 jalr -606(ra) # 13dc <putc>
+ state = 0;
+ 1642: 4981 li s3,0
+ 1644: b5d1 j 1508 <vprintf+0x60>
+ putc(fd, '%');
+ 1646: 85d2 mv a1,s4
+ 1648: 8556 mv a0,s5
+ 164a: 00000097 auipc ra,0x0
+ 164e: d92080e7 jalr -622(ra) # 13dc <putc>
+ putc(fd, c);
+ 1652: 85ca mv a1,s2
+ 1654: 8556 mv a0,s5
+ 1656: 00000097 auipc ra,0x0
+ 165a: d86080e7 jalr -634(ra) # 13dc <putc>
+ state = 0;
+ 165e: 4981 li s3,0
+ 1660: b565 j 1508 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 1662: 8b4a mv s6,s2
+ state = 0;
+ 1664: 4981 li s3,0
+ 1666: b54d j 1508 <vprintf+0x60>
+ }
+ }
+}
+ 1668: 70e6 ld ra,120(sp)
+ 166a: 7446 ld s0,112(sp)
+ 166c: 74a6 ld s1,104(sp)
+ 166e: 7906 ld s2,96(sp)
+ 1670: 69e6 ld s3,88(sp)
+ 1672: 6a46 ld s4,80(sp)
+ 1674: 6aa6 ld s5,72(sp)
+ 1676: 6b06 ld s6,64(sp)
+ 1678: 7be2 ld s7,56(sp)
+ 167a: 7c42 ld s8,48(sp)
+ 167c: 7ca2 ld s9,40(sp)
+ 167e: 7d02 ld s10,32(sp)
+ 1680: 6de2 ld s11,24(sp)
+ 1682: 6109 addi sp,sp,128
+ 1684: 8082 ret
+
+0000000000001686 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 1686: 715d addi sp,sp,-80
+ 1688: ec06 sd ra,24(sp)
+ 168a: e822 sd s0,16(sp)
+ 168c: 1000 addi s0,sp,32
+ 168e: e010 sd a2,0(s0)
+ 1690: e414 sd a3,8(s0)
+ 1692: e818 sd a4,16(s0)
+ 1694: ec1c sd a5,24(s0)
+ 1696: 03043023 sd a6,32(s0)
+ 169a: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 169e: 8622 mv a2,s0
+ 16a0: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 16a4: 00000097 auipc ra,0x0
+ 16a8: e04080e7 jalr -508(ra) # 14a8 <vprintf>
+}
+ 16ac: 60e2 ld ra,24(sp)
+ 16ae: 6442 ld s0,16(sp)
+ 16b0: 6161 addi sp,sp,80
+ 16b2: 8082 ret
+
+00000000000016b4 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 16b4: 711d addi sp,sp,-96
+ 16b6: ec06 sd ra,24(sp)
+ 16b8: e822 sd s0,16(sp)
+ 16ba: 1000 addi s0,sp,32
+ 16bc: e40c sd a1,8(s0)
+ 16be: e810 sd a2,16(s0)
+ 16c0: ec14 sd a3,24(s0)
+ 16c2: f018 sd a4,32(s0)
+ 16c4: f41c sd a5,40(s0)
+ 16c6: 03043823 sd a6,48(s0)
+ 16ca: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 16ce: 00840613 addi a2,s0,8
+ 16d2: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 16d6: 85aa mv a1,a0
+ 16d8: 4505 li a0,1
+ 16da: 00000097 auipc ra,0x0
+ 16de: dce080e7 jalr -562(ra) # 14a8 <vprintf>
+}
+ 16e2: 60e2 ld ra,24(sp)
+ 16e4: 6442 ld s0,16(sp)
+ 16e6: 6125 addi sp,sp,96
+ 16e8: 8082 ret
+
+00000000000016ea <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 16ea: 1141 addi sp,sp,-16
+ 16ec: e422 sd s0,8(sp)
+ 16ee: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 16f0: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 16f4: 00001797 auipc a5,0x1
+ 16f8: cbc7b783 ld a5,-836(a5) # 23b0 <freep>
+ 16fc: a02d j 1726 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 16fe: 4618 lw a4,8(a2)
+ 1700: 9f2d addw a4,a4,a1
+ 1702: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 1706: 6398 ld a4,0(a5)
+ 1708: 6310 ld a2,0(a4)
+ 170a: a83d j 1748 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 170c: ff852703 lw a4,-8(a0)
+ 1710: 9f31 addw a4,a4,a2
+ 1712: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 1714: ff053683 ld a3,-16(a0)
+ 1718: a091 j 175c <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 171a: 6398 ld a4,0(a5)
+ 171c: 00e7e463 bltu a5,a4,1724 <free+0x3a>
+ 1720: 00e6ea63 bltu a3,a4,1734 <free+0x4a>
+{
+ 1724: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 1726: fed7fae3 bgeu a5,a3,171a <free+0x30>
+ 172a: 6398 ld a4,0(a5)
+ 172c: 00e6e463 bltu a3,a4,1734 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 1730: fee7eae3 bltu a5,a4,1724 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 1734: ff852583 lw a1,-8(a0)
+ 1738: 6390 ld a2,0(a5)
+ 173a: 02059813 slli a6,a1,0x20
+ 173e: 01c85713 srli a4,a6,0x1c
+ 1742: 9736 add a4,a4,a3
+ 1744: fae60de3 beq a2,a4,16fe <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 1748: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 174c: 4790 lw a2,8(a5)
+ 174e: 02061593 slli a1,a2,0x20
+ 1752: 01c5d713 srli a4,a1,0x1c
+ 1756: 973e add a4,a4,a5
+ 1758: fae68ae3 beq a3,a4,170c <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 175c: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 175e: 00001717 auipc a4,0x1
+ 1762: c4f73923 sd a5,-942(a4) # 23b0 <freep>
+}
+ 1766: 6422 ld s0,8(sp)
+ 1768: 0141 addi sp,sp,16
+ 176a: 8082 ret
+
+000000000000176c <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 176c: 7139 addi sp,sp,-64
+ 176e: fc06 sd ra,56(sp)
+ 1770: f822 sd s0,48(sp)
+ 1772: f426 sd s1,40(sp)
+ 1774: f04a sd s2,32(sp)
+ 1776: ec4e sd s3,24(sp)
+ 1778: e852 sd s4,16(sp)
+ 177a: e456 sd s5,8(sp)
+ 177c: e05a sd s6,0(sp)
+ 177e: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 1780: 02051493 slli s1,a0,0x20
+ 1784: 9081 srli s1,s1,0x20
+ 1786: 04bd addi s1,s1,15
+ 1788: 8091 srli s1,s1,0x4
+ 178a: 00148a1b addiw s4,s1,1
+ 178e: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 1790: 00001517 auipc a0,0x1
+ 1794: c2053503 ld a0,-992(a0) # 23b0 <freep>
+ 1798: c515 beqz a0,17c4 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 179a: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 179c: 4798 lw a4,8(a5)
+ 179e: 04977163 bgeu a4,s1,17e0 <malloc+0x74>
+ 17a2: 89d2 mv s3,s4
+ 17a4: 000a071b sext.w a4,s4
+ 17a8: 6685 lui a3,0x1
+ 17aa: 00d77363 bgeu a4,a3,17b0 <malloc+0x44>
+ 17ae: 6985 lui s3,0x1
+ 17b0: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 17b4: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 17b8: 00001917 auipc s2,0x1
+ 17bc: bf890913 addi s2,s2,-1032 # 23b0 <freep>
+ if(p == (char*)-1)
+ 17c0: 5afd li s5,-1
+ 17c2: a8a5 j 183a <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 17c4: 00001797 auipc a5,0x1
+ 17c8: bec78793 addi a5,a5,-1044 # 23b0 <freep>
+ 17cc: 00001717 auipc a4,0x1
+ 17d0: bec70713 addi a4,a4,-1044 # 23b8 <base>
+ 17d4: e398 sd a4,0(a5)
+ 17d6: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 17d8: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 17dc: 87ba mv a5,a4
+ 17de: b7d1 j 17a2 <malloc+0x36>
+ if(p->s.size == nunits)
+ 17e0: 02e48c63 beq s1,a4,1818 <malloc+0xac>
+ p->s.size -= nunits;
+ 17e4: 4147073b subw a4,a4,s4
+ 17e8: c798 sw a4,8(a5)
+ p += p->s.size;
+ 17ea: 02071693 slli a3,a4,0x20
+ 17ee: 01c6d713 srli a4,a3,0x1c
+ 17f2: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 17f4: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 17f8: 00001717 auipc a4,0x1
+ 17fc: baa73c23 sd a0,-1096(a4) # 23b0 <freep>
+ return (void*)(p + 1);
+ 1800: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 1804: 70e2 ld ra,56(sp)
+ 1806: 7442 ld s0,48(sp)
+ 1808: 74a2 ld s1,40(sp)
+ 180a: 7902 ld s2,32(sp)
+ 180c: 69e2 ld s3,24(sp)
+ 180e: 6a42 ld s4,16(sp)
+ 1810: 6aa2 ld s5,8(sp)
+ 1812: 6b02 ld s6,0(sp)
+ 1814: 6121 addi sp,sp,64
+ 1816: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 1818: 6398 ld a4,0(a5)
+ 181a: e118 sd a4,0(a0)
+ 181c: bff1 j 17f8 <malloc+0x8c>
+ hp->s.size = nu;
+ 181e: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 1822: 0541 addi a0,a0,16
+ 1824: 00000097 auipc ra,0x0
+ 1828: ec6080e7 jalr -314(ra) # 16ea <free>
+ return freep;
+ 182c: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 1830: d971 beqz a0,1804 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 1832: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 1834: 4798 lw a4,8(a5)
+ 1836: fa9775e3 bgeu a4,s1,17e0 <malloc+0x74>
+ if(p == freep)
+ 183a: 00093703 ld a4,0(s2)
+ 183e: 853e mv a0,a5
+ 1840: fef719e3 bne a4,a5,1832 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 1844: 854e mv a0,s3
+ 1846: 00000097 auipc ra,0x0
+ 184a: b30080e7 jalr -1232(ra) # 1376 <sbrk>
+ if(p == (char*)-1)
+ 184e: fd5518e3 bne a0,s5,181e <malloc+0xb2>
+ return 0;
+ 1852: 4501 li a0,0
+ 1854: bf45 j 1804 <malloc+0x98>
diff --git a/xv6-user/sh.c b/xv6-user/sh.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ad3a621c01829c1b6cf40de9986486ab7f47cb4
--- /dev/null
+++ b/xv6-user/sh.c
@@ -0,0 +1,637 @@
+// Shell.
+
+#include "kernel/include/types.h"
+#include "xv6-user/user.h"
+#include "kernel/include/fcntl.h"
+
+// Parsed command representation
+#define EXEC 1
+#define REDIR 2
+#define PIPE 3
+#define LIST 4
+#define BACK 5
+
+#define NENVS 16
+#define MAXARGS 10
+
+struct env{
+ char name[32];
+ char value[96];
+};
+
+struct env envs[NENVS];
+int nenv = 0;
+
+struct cmd {
+ int type;
+};
+
+struct execcmd {
+ int type;
+ char *argv[MAXARGS];
+ char *eargv[MAXARGS];
+};
+
+struct redircmd {
+ int type;
+ struct cmd *cmd;
+ char *file;
+ char *efile;
+ int mode;
+ int fd;
+};
+
+struct pipecmd {
+ int type;
+ struct cmd *left;
+ struct cmd *right;
+};
+
+struct listcmd {
+ int type;
+ struct cmd *left;
+ struct cmd *right;
+};
+
+struct backcmd {
+ int type;
+ struct cmd *cmd;
+};
+
+int fork1(void); // Fork but panics on failure.
+void panic(char*);
+struct cmd *parsecmd(char*);
+
+char mycwd[128];
+
+int
+checkenvname(char* s)
+{
+ if((*s >= 'A' && *s <= 'Z') ||
+ (*s >= 'a' && *s <= 'z') ||
+ *s == '_')
+ ;
+ else
+ return 0;
+ char *tmp = s + 1;
+ while((*tmp >= 'A' && *tmp <= 'Z') ||
+ (*tmp >= 'a' && *tmp <= 'z') ||
+ (*tmp >= '0' && *tmp <= '9') ||
+ *tmp == '_')
+ tmp++;
+ return (int)(tmp - s);
+}
+
+int
+export(char *argv[])
+{
+ if(!strcmp(argv[1], "-p"))
+ { // print all the env vars
+ if(!nenv)
+ {
+ printf("NO env var exported\n");
+ return 0;
+ }
+ for(int i=0; i<nenv; i++)
+ printf("export %s=%s\n", envs[i].name, envs[i].value);
+ return 0;
+ }
+ else if(nenv == NENVS)
+ {
+ fprintf(2, "too many env vars\n");
+ return -1;
+ }
+ char name[32], value[96];
+ char *s = argv[1], *t = name;
+
+ for(s=argv[1], t=name; (*t=*s++)!='='; t++)
+ ;
+ *t = 0;
+
+ if(checkenvname(name) != ((s - argv[1]) - 1))
+ {
+ fprintf(2, "Invalid NAME!\n");
+ return -1;
+ }
+ for(t=value; (*t=*s); s++, t++)
+ ;
+ if(*--t == '/')
+ *t = 0;
+
+ strcpy(envs[nenv].name, name);
+ strcpy(envs[nenv].value, value);
+ nenv++;
+ return 0;
+}
+
+int
+replace(char *buf)
+{
+ char raw[100], name[32], *s, *t, *tmp;
+ int n = 0;
+ strcpy(raw, buf);
+ for(s=raw, t=buf; (*t=*s); t++)
+ {
+ if(*s++ == '$'){
+ tmp = name;
+ if((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || *s == '_')
+ {
+ *tmp++ = *s++;
+ while((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || (*s >= '0' && *s <= '9') || *s == '_')
+ *tmp++ = *s++;
+ *tmp = 0;
+ for(int i=0; i<nenv; i++)
+ if(!strcmp(name, envs[i].name))
+ for(tmp=envs[i].value; (*t=*tmp); t++, tmp++)
+ ;
+ t--;
+ }
+ n++;
+ }
+ }
+ return n;
+}
+
+// Execute cmd. Never returns.
+void
+runcmd(struct cmd *cmd)
+{
+ int p[2];
+ struct backcmd *bcmd;
+ struct execcmd *ecmd;
+ struct listcmd *lcmd;
+ struct pipecmd *pcmd;
+ struct redircmd *rcmd;
+
+ if(cmd == 0)
+ exit(1);
+
+ switch(cmd->type){
+ default:
+ panic("runcmd");
+
+ case EXEC:
+ ecmd = (struct execcmd*)cmd;
+ if(ecmd->argv[0] == 0)
+ exit(1);
+
+ exec(ecmd->argv[0], ecmd->argv);
+
+ int i;
+ char env_cmd[64];
+ for(i=0; i<nenv; i++)
+ {
+ char *s_tmp = env_cmd;
+ char *d_tmp = envs[i].value;
+ while((*s_tmp = *d_tmp++))
+ s_tmp++;
+ *s_tmp++ = '/';
+ d_tmp = ecmd->argv[0];
+ while((*s_tmp++ = *d_tmp++))
+ ;
+
+ exec(env_cmd, ecmd->argv);
+ }
+ fprintf(2, "exec %s failed\n", ecmd->argv[0]);
+ break;
+
+ case REDIR:
+ rcmd = (struct redircmd*)cmd;
+ close(rcmd->fd);
+ if(open(rcmd->file, rcmd->mode) < 0){
+ fprintf(2, "open %s failed\n", rcmd->file);
+ exit(1);
+ }
+ runcmd(rcmd->cmd);
+ break;
+
+ case LIST:
+ lcmd = (struct listcmd*)cmd;
+ if(fork1() == 0)
+ runcmd(lcmd->left);
+ wait(0);
+ runcmd(lcmd->right);
+ break;
+
+ case PIPE:
+ pcmd = (struct pipecmd*)cmd;
+ if(pipe(p) < 0)
+ panic("pipe");
+ if(fork1() == 0){
+ close(1);
+ dup(p[1]);
+ close(p[0]);
+ close(p[1]);
+ runcmd(pcmd->left);
+ }
+ if(fork1() == 0){
+ close(0);
+ dup(p[0]);
+ close(p[0]);
+ close(p[1]);
+ runcmd(pcmd->right);
+ }
+ close(p[0]);
+ close(p[1]);
+ wait(0);
+ wait(0);
+ break;
+
+ case BACK:
+ bcmd = (struct backcmd*)cmd;
+ if(fork1() == 0)
+ runcmd(bcmd->cmd);
+ break;
+ }
+ exit(0);
+}
+
+int
+getcmd(char *buf, int nbuf)
+{
+ fprintf(2, "-> %s $ ", mycwd);
+ memset(buf, 0, nbuf);
+ gets(buf, nbuf);
+ if(buf[0] == 0) // EOF
+ return -1;
+ return 0;
+}
+
+int
+main(void)
+{
+ static char buf[100];
+ int fd;
+
+ // Ensure that three file descriptors are open.
+ while((fd = dev(O_RDWR, 1, 0)) >= 0){
+ if(fd >= 3){
+ close(fd);
+ break;
+ }
+ }
+
+ // Add an embedded env var(for basic commands in shell)
+ strcpy(envs[nenv].name, "SHELL");
+ strcpy(envs[nenv].value, "/bin");
+ nenv++;
+
+ getcwd(mycwd);
+ // Read and run input commands.
+ while(getcmd(buf, sizeof(buf)) >= 0){
+ replace(buf);
+ if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
+ // Chdir must be called by the parent, not the child.
+ buf[strlen(buf)-1] = 0; // chop \n
+ if(chdir(buf+3) < 0)
+ fprintf(2, "cannot cd %s\n", buf+3);
+ getcwd(mycwd);
+ }
+ else{
+ struct cmd *cmd = parsecmd(buf);
+ struct execcmd *ecmd;
+
+ ecmd = (struct execcmd*)cmd;
+ if(ecmd->argv[0] == 0) {
+ free(cmd);
+ continue;
+ }
+ else if(!strcmp(ecmd->argv[0], "export"))
+ {
+ // Export must be called by the parent, not the child.
+ if(ecmd->argv[1] == NULL)
+ fprintf(2, "Usage: export [-p] [NAME=VALUE]\n");
+ else if(export(ecmd->argv) < 0)
+ fprintf(2, "export failed\n");
+ free(cmd);
+ continue;
+ }
+ else if(fork1() == 0)
+ runcmd(cmd);
+ wait(0);
+ free(cmd);
+ }
+ }
+ exit(0);
+}
+
+void
+panic(char *s)
+{
+ fprintf(2, "%s\n", s);
+ exit(1);
+}
+
+int
+fork1(void)
+{
+ int pid;
+
+ pid = fork();
+ if(pid == -1)
+ panic("fork");
+ return pid;
+}
+
+//PAGEBREAK!
+// Constructors
+
+struct cmd*
+execcmd(void)
+{
+ struct execcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->type = EXEC;
+ return (struct cmd*)cmd;
+}
+
+struct cmd*
+redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
+{
+ struct redircmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->type = REDIR;
+ cmd->cmd = subcmd;
+ cmd->file = file;
+ cmd->efile = efile;
+ cmd->mode = mode;
+ cmd->fd = fd;
+ return (struct cmd*)cmd;
+}
+
+struct cmd*
+pipecmd(struct cmd *left, struct cmd *right)
+{
+ struct pipecmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->type = PIPE;
+ cmd->left = left;
+ cmd->right = right;
+ return (struct cmd*)cmd;
+}
+
+struct cmd*
+listcmd(struct cmd *left, struct cmd *right)
+{
+ struct listcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->type = LIST;
+ cmd->left = left;
+ cmd->right = right;
+ return (struct cmd*)cmd;
+}
+
+struct cmd*
+backcmd(struct cmd *subcmd)
+{
+ struct backcmd *cmd;
+
+ cmd = malloc(sizeof(*cmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->type = BACK;
+ cmd->cmd = subcmd;
+ return (struct cmd*)cmd;
+}
+//PAGEBREAK!
+// Parsing
+
+char whitespace[] = " \t\r\n\v";
+char symbols[] = "<|>&;()";
+
+int
+gettoken(char **ps, char *es, char **q, char **eq)
+{
+ char *s;
+ int ret;
+
+ s = *ps;
+ while(s < es && strchr(whitespace, *s))
+ s++;
+ if(q)
+ *q = s;
+ ret = *s;
+ switch(*s){
+ case 0:
+ break;
+ case '|':
+ case '(':
+ case ')':
+ case ';':
+ case '&':
+ case '<':
+ s++;
+ break;
+ case '>':
+ s++;
+ if(*s == '>'){
+ ret = '+';
+ s++;
+ }
+ break;
+ default:
+ ret = 'a';
+ while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
+ s++;
+ break;
+ }
+ if(eq)
+ *eq = s;
+
+ while(s < es && strchr(whitespace, *s))
+ s++;
+ *ps = s;
+ return ret;
+}
+
+int
+peek(char **ps, char *es, char *toks)
+{
+ char *s;
+
+ s = *ps;
+ while(s < es && strchr(whitespace, *s))
+ s++;
+ *ps = s;
+ return *s && strchr(toks, *s);
+}
+
+struct cmd *parseline(char**, char*);
+struct cmd *parsepipe(char**, char*);
+struct cmd *parseexec(char**, char*);
+struct cmd *nulterminate(struct cmd*);
+
+struct cmd*
+parsecmd(char *s)
+{
+ char *es;
+ struct cmd *cmd;
+
+ es = s + strlen(s);
+ cmd = parseline(&s, es);
+ peek(&s, es, "");
+ if(s != es){
+ fprintf(2, "leftovers: %s\n", s);
+ panic("syntax");
+ }
+ nulterminate(cmd);
+ return cmd;
+}
+
+struct cmd*
+parseline(char **ps, char *es)
+{
+ struct cmd *cmd;
+
+ cmd = parsepipe(ps, es);
+ while(peek(ps, es, "&")){
+ gettoken(ps, es, 0, 0);
+ cmd = backcmd(cmd);
+ }
+ if(peek(ps, es, ";")){
+ gettoken(ps, es, 0, 0);
+ cmd = listcmd(cmd, parseline(ps, es));
+ }
+ return cmd;
+}
+
+struct cmd*
+parsepipe(char **ps, char *es)
+{
+ struct cmd *cmd;
+
+ cmd = parseexec(ps, es);
+ if(peek(ps, es, "|")){
+ gettoken(ps, es, 0, 0);
+ cmd = pipecmd(cmd, parsepipe(ps, es));
+ }
+ return cmd;
+}
+
+struct cmd*
+parseredirs(struct cmd *cmd, char **ps, char *es)
+{
+ int tok;
+ char *q, *eq;
+
+ while(peek(ps, es, "<>")){
+ tok = gettoken(ps, es, 0, 0);
+ if(gettoken(ps, es, &q, &eq) != 'a')
+ panic("missing file for redirection");
+ switch(tok){
+ case '<':
+ cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
+ break;
+ case '>':
+ cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_TRUNC, 1);
+ break;
+ case '+': // >>
+ cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_APPEND, 1);
+ break;
+ }
+ }
+ return cmd;
+}
+
+struct cmd*
+parseblock(char **ps, char *es)
+{
+ struct cmd *cmd;
+
+ if(!peek(ps, es, "("))
+ panic("parseblock");
+ gettoken(ps, es, 0, 0);
+ cmd = parseline(ps, es);
+ if(!peek(ps, es, ")"))
+ panic("syntax - missing )");
+ gettoken(ps, es, 0, 0);
+ cmd = parseredirs(cmd, ps, es);
+ return cmd;
+}
+
+struct cmd*
+parseexec(char **ps, char *es)
+{
+ char *q, *eq;
+ int tok, argc;
+ struct execcmd *cmd;
+ struct cmd *ret;
+
+ if(peek(ps, es, "("))
+ return parseblock(ps, es);
+
+ ret = execcmd();
+ cmd = (struct execcmd*)ret;
+
+ argc = 0;
+ ret = parseredirs(ret, ps, es);
+ while(!peek(ps, es, "|)&;")){
+ if((tok=gettoken(ps, es, &q, &eq)) == 0)
+ break;
+ if(tok != 'a')
+ panic("syntax");
+ cmd->argv[argc] = q;
+ cmd->eargv[argc] = eq;
+ argc++;
+ if(argc >= MAXARGS)
+ panic("too many args");
+ ret = parseredirs(ret, ps, es);
+ }
+ cmd->argv[argc] = 0;
+ cmd->eargv[argc] = 0;
+ return ret;
+}
+
+// NUL-terminate all the counted strings.
+struct cmd*
+nulterminate(struct cmd *cmd)
+{
+ int i;
+ struct backcmd *bcmd;
+ struct execcmd *ecmd;
+ struct listcmd *lcmd;
+ struct pipecmd *pcmd;
+ struct redircmd *rcmd;
+
+ if(cmd == 0)
+ return 0;
+
+ switch(cmd->type){
+ case EXEC:
+ ecmd = (struct execcmd*)cmd;
+ for(i=0; ecmd->argv[i]; i++)
+ *ecmd->eargv[i] = 0;
+ break;
+
+ case REDIR:
+ rcmd = (struct redircmd*)cmd;
+ nulterminate(rcmd->cmd);
+ *rcmd->efile = 0;
+ break;
+
+ case PIPE:
+ pcmd = (struct pipecmd*)cmd;
+ nulterminate(pcmd->left);
+ nulterminate(pcmd->right);
+ break;
+
+ case LIST:
+ lcmd = (struct listcmd*)cmd;
+ nulterminate(lcmd->left);
+ nulterminate(lcmd->right);
+ break;
+
+ case BACK:
+ bcmd = (struct backcmd*)cmd;
+ nulterminate(bcmd->cmd);
+ break;
+ }
+ return cmd;
+}
\ No newline at end of file
diff --git a/xv6-user/sh.d b/xv6-user/sh.d
new file mode 100644
index 0000000000000000000000000000000000000000..2c29b2b13b91e3c5d620de0612e8eb102670f419
--- /dev/null
+++ b/xv6-user/sh.d
@@ -0,0 +1,2 @@
+xv6-user/sh.o: xv6-user/sh.c kernel/include/types.h xv6-user/user.h \
+ kernel/include/stat.h kernel/include/fcntl.h
diff --git a/xv6-user/sh.o b/xv6-user/sh.o
new file mode 100644
index 0000000000000000000000000000000000000000..e8085435744ca4716231aaf2d8f2de2011bd9bb2
Binary files /dev/null and b/xv6-user/sh.o differ
diff --git a/xv6-user/sh.sym b/xv6-user/sh.sym
new file mode 100644
index 0000000000000000000000000000000000000000..bef600d0ecfba2ee362a0887766f309e4ae71a17
--- /dev/null
+++ b/xv6-user/sh.sym
@@ -0,0 +1,104 @@
+0000000000000000 .text
+0000000000001858 .rodata
+0000000000001ab0 .data
+0000000000001ac0 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 sh.c
+0000000000001b48 buf.0
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000013dc putc
+00000000000013fe printint
+0000000000001a98 digits
+0000000000000000 umalloc.c
+00000000000023b0 freep
+00000000000023b8 base
+0000000000001038 strcpy
+00000000000016b4 printf
+00000000000022b0 __global_pointer$
+0000000000001396 dev
+000000000000123e memmove
+000000000000064a execcmd
+00000000000013ba trace
+000000000000111e gets
+0000000000001ac0 __SDATA_BEGIN__
+000000000000136c getpid
+0000000000000b7a parsepipe
+0000000000000dcc parsecmd
+00000000000012d0 memcpy
+0000000000000774 backcmd
+00000000000008f2 peek
+0000000000001ac8 mycwd
+000000000000095e parseredirs
+00000000000007b0 gettoken
+000000000000176c malloc
+00000000000013b0 remove
+000000000000137e sleep
+00000000000013c2 sysinfo
+0000000000001ab0 whitespace
+0000000000001bb0 envs
+00000000000013a0 readdir
+00000000000003c4 fork1
+0000000000000d34 nulterminate
+0000000000001302 pipe
+00000000000013ca rename
+0000000000000342 getcmd
+0000000000001316 write
+00000000000001fe replace
+0000000000001346 fstat
+0000000000001686 fprintf
+000000000000132a kill
+0000000000001054 strcat
+00000000000014a8 vprintf
+000000000000135a chdir
+0000000000000be8 parseline
+00000000000003f2 runcmd
+0000000000000c90 parseblock
+0000000000001332 exec
+00000000000012fa wait
+0000000000001ab8 symbols
+000000000000130c read
+0000000000000a66 parseexec
+000000000000039e panic
+0000000000001296 memcmp
+00000000000012e8 fork
+00000000000023c8 __BSS_END__
+0000000000001376 sbrk
+000000000000138e test_proc
+0000000000001386 uptime
+0000000000001ac0 __bss_start
+00000000000010d8 memset
+0000000000000e58 main
+0000000000000000 checkenvname
+0000000000001082 strcmp
+00000000000013d2 shutdown
+0000000000001364 dup
+00000000000013a8 getcwd
+00000000000006e8 pipecmd
+0000000000000066 export
+0000000000000680 redircmd
+0000000000001ab0 __DATA_BEGIN__
+0000000000001198 stat
+0000000000001ac0 _edata
+00000000000023c8 _end
+00000000000012f0 exit
+00000000000011de atoi
+00000000000010ae strlen
+000000000000133c open
+00000000000010fa strchr
+0000000000001350 mkdir
+0000000000001320 close
+0000000000001ac0 nenv
+000000000000072e listcmd
+00000000000016ea free
diff --git a/xv6-user/sleep.asm b/xv6-user/sleep.asm
new file mode 100644
index 0000000000000000000000000000000000000000..a4f62c4885751f2b1318d4dbd2b9b07c5c6ff631
--- /dev/null
+++ b/xv6-user/sleep.asm
@@ -0,0 +1,1438 @@
+
+xv6-user/_sleep: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ 0: 1141 addi sp,sp,-16
+ 2: e406 sd ra,8(sp)
+ 4: e022 sd s0,0(sp)
+ 6: 0800 addi s0,sp,16
+ if (argc <= 1) {
+ 8: 4785 li a5,1
+ a: 02a7d663 bge a5,a0,36 <main+0x36>
+ fprintf(2, "Usage: sleep TIME\n");
+ exit(1);
+ }
+ int time = atoi(argv[1]);
+ e: 6588 ld a0,8(a1)
+ 10: 00000097 auipc ra,0x0
+ 14: 1fa080e7 jalr 506(ra) # 20a <atoi>
+ if (time == 0) {
+ 18: ed0d bnez a0,52 <main+0x52>
+ fprintf(2, "Usage: sleep TIME\nTIME should be an integer larger than 0.\n");
+ 1a: 00001597 auipc a1,0x1
+ 1e: 88658593 addi a1,a1,-1914 # 8a0 <malloc+0x108>
+ 22: 4509 li a0,2
+ 24: 00000097 auipc ra,0x0
+ 28: 68e080e7 jalr 1678(ra) # 6b2 <fprintf>
+ exit(1);
+ 2c: 4505 li a0,1
+ 2e: 00000097 auipc ra,0x0
+ 32: 2ee080e7 jalr 750(ra) # 31c <exit>
+ fprintf(2, "Usage: sleep TIME\n");
+ 36: 00001597 auipc a1,0x1
+ 3a: 85258593 addi a1,a1,-1966 # 888 <malloc+0xf0>
+ 3e: 4509 li a0,2
+ 40: 00000097 auipc ra,0x0
+ 44: 672080e7 jalr 1650(ra) # 6b2 <fprintf>
+ exit(1);
+ 48: 4505 li a0,1
+ 4a: 00000097 auipc ra,0x0
+ 4e: 2d2080e7 jalr 722(ra) # 31c <exit>
+ }
+ sleep(time);
+ 52: 00000097 auipc ra,0x0
+ 56: 358080e7 jalr 856(ra) # 3aa <sleep>
+ exit(0);
+ 5a: 4501 li a0,0
+ 5c: 00000097 auipc ra,0x0
+ 60: 2c0080e7 jalr 704(ra) # 31c <exit>
+
+0000000000000064 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 64: 1141 addi sp,sp,-16
+ 66: e422 sd s0,8(sp)
+ 68: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 6a: 87aa mv a5,a0
+ 6c: 0585 addi a1,a1,1
+ 6e: 0785 addi a5,a5,1
+ 70: fff5c703 lbu a4,-1(a1)
+ 74: fee78fa3 sb a4,-1(a5)
+ 78: fb75 bnez a4,6c <strcpy+0x8>
+ ;
+ return os;
+}
+ 7a: 6422 ld s0,8(sp)
+ 7c: 0141 addi sp,sp,16
+ 7e: 8082 ret
+
+0000000000000080 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 80: 1141 addi sp,sp,-16
+ 82: e422 sd s0,8(sp)
+ 84: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 86: 00054783 lbu a5,0(a0)
+ 8a: c385 beqz a5,aa <strcat+0x2a>
+ 8c: 87aa mv a5,a0
+ s++;
+ 8e: 0785 addi a5,a5,1
+ while(*s)
+ 90: 0007c703 lbu a4,0(a5)
+ 94: ff6d bnez a4,8e <strcat+0xe>
+ while((*s++ = *t++))
+ 96: 0585 addi a1,a1,1
+ 98: 0785 addi a5,a5,1
+ 9a: fff5c703 lbu a4,-1(a1)
+ 9e: fee78fa3 sb a4,-1(a5)
+ a2: fb75 bnez a4,96 <strcat+0x16>
+ ;
+ return os;
+}
+ a4: 6422 ld s0,8(sp)
+ a6: 0141 addi sp,sp,16
+ a8: 8082 ret
+ while(*s)
+ aa: 87aa mv a5,a0
+ ac: b7ed j 96 <strcat+0x16>
+
+00000000000000ae <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ ae: 1141 addi sp,sp,-16
+ b0: e422 sd s0,8(sp)
+ b2: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ b4: 00054783 lbu a5,0(a0)
+ b8: cb91 beqz a5,cc <strcmp+0x1e>
+ ba: 0005c703 lbu a4,0(a1)
+ be: 00f71763 bne a4,a5,cc <strcmp+0x1e>
+ p++, q++;
+ c2: 0505 addi a0,a0,1
+ c4: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ c6: 00054783 lbu a5,0(a0)
+ ca: fbe5 bnez a5,ba <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ cc: 0005c503 lbu a0,0(a1)
+}
+ d0: 40a7853b subw a0,a5,a0
+ d4: 6422 ld s0,8(sp)
+ d6: 0141 addi sp,sp,16
+ d8: 8082 ret
+
+00000000000000da <strlen>:
+
+uint
+strlen(const char *s)
+{
+ da: 1141 addi sp,sp,-16
+ dc: e422 sd s0,8(sp)
+ de: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ e0: 00054783 lbu a5,0(a0)
+ e4: cf91 beqz a5,100 <strlen+0x26>
+ e6: 0505 addi a0,a0,1
+ e8: 87aa mv a5,a0
+ ea: 4685 li a3,1
+ ec: 9e89 subw a3,a3,a0
+ ee: 00f6853b addw a0,a3,a5
+ f2: 0785 addi a5,a5,1
+ f4: fff7c703 lbu a4,-1(a5)
+ f8: fb7d bnez a4,ee <strlen+0x14>
+ ;
+ return n;
+}
+ fa: 6422 ld s0,8(sp)
+ fc: 0141 addi sp,sp,16
+ fe: 8082 ret
+ for(n = 0; s[n]; n++)
+ 100: 4501 li a0,0
+ 102: bfe5 j fa <strlen+0x20>
+
+0000000000000104 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 104: 1141 addi sp,sp,-16
+ 106: e422 sd s0,8(sp)
+ 108: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 10a: ca19 beqz a2,120 <memset+0x1c>
+ 10c: 87aa mv a5,a0
+ 10e: 1602 slli a2,a2,0x20
+ 110: 9201 srli a2,a2,0x20
+ 112: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 116: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 11a: 0785 addi a5,a5,1
+ 11c: fee79de3 bne a5,a4,116 <memset+0x12>
+ }
+ return dst;
+}
+ 120: 6422 ld s0,8(sp)
+ 122: 0141 addi sp,sp,16
+ 124: 8082 ret
+
+0000000000000126 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 126: 1141 addi sp,sp,-16
+ 128: e422 sd s0,8(sp)
+ 12a: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 12c: 00054783 lbu a5,0(a0)
+ 130: cb99 beqz a5,146 <strchr+0x20>
+ if(*s == c)
+ 132: 00f58763 beq a1,a5,140 <strchr+0x1a>
+ for(; *s; s++)
+ 136: 0505 addi a0,a0,1
+ 138: 00054783 lbu a5,0(a0)
+ 13c: fbfd bnez a5,132 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 13e: 4501 li a0,0
+}
+ 140: 6422 ld s0,8(sp)
+ 142: 0141 addi sp,sp,16
+ 144: 8082 ret
+ return 0;
+ 146: 4501 li a0,0
+ 148: bfe5 j 140 <strchr+0x1a>
+
+000000000000014a <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 14a: 711d addi sp,sp,-96
+ 14c: ec86 sd ra,88(sp)
+ 14e: e8a2 sd s0,80(sp)
+ 150: e4a6 sd s1,72(sp)
+ 152: e0ca sd s2,64(sp)
+ 154: fc4e sd s3,56(sp)
+ 156: f852 sd s4,48(sp)
+ 158: f456 sd s5,40(sp)
+ 15a: f05a sd s6,32(sp)
+ 15c: ec5e sd s7,24(sp)
+ 15e: e862 sd s8,16(sp)
+ 160: 1080 addi s0,sp,96
+ 162: 8baa mv s7,a0
+ 164: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 166: 892a mv s2,a0
+ 168: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 16a: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 16e: 4b29 li s6,10
+ 170: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 172: 89a6 mv s3,s1
+ 174: 2485 addiw s1,s1,1
+ 176: 0344d763 bge s1,s4,1a4 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 17a: 4605 li a2,1
+ 17c: 85d6 mv a1,s5
+ 17e: 4501 li a0,0
+ 180: 00000097 auipc ra,0x0
+ 184: 1b8080e7 jalr 440(ra) # 338 <read>
+ if(cc < 1)
+ 188: 00a05e63 blez a0,1a4 <gets+0x5a>
+ buf[i++] = c;
+ 18c: faf44783 lbu a5,-81(s0)
+ 190: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 194: 01678763 beq a5,s6,1a2 <gets+0x58>
+ 198: 0905 addi s2,s2,1
+ 19a: fd879ce3 bne a5,s8,172 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 19e: 89a6 mv s3,s1
+ 1a0: a011 j 1a4 <gets+0x5a>
+ 1a2: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 1a4: 99de add s3,s3,s7
+ 1a6: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1aa: 855e mv a0,s7
+ 1ac: 60e6 ld ra,88(sp)
+ 1ae: 6446 ld s0,80(sp)
+ 1b0: 64a6 ld s1,72(sp)
+ 1b2: 6906 ld s2,64(sp)
+ 1b4: 79e2 ld s3,56(sp)
+ 1b6: 7a42 ld s4,48(sp)
+ 1b8: 7aa2 ld s5,40(sp)
+ 1ba: 7b02 ld s6,32(sp)
+ 1bc: 6be2 ld s7,24(sp)
+ 1be: 6c42 ld s8,16(sp)
+ 1c0: 6125 addi sp,sp,96
+ 1c2: 8082 ret
+
+00000000000001c4 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1c4: 1101 addi sp,sp,-32
+ 1c6: ec06 sd ra,24(sp)
+ 1c8: e822 sd s0,16(sp)
+ 1ca: e426 sd s1,8(sp)
+ 1cc: e04a sd s2,0(sp)
+ 1ce: 1000 addi s0,sp,32
+ 1d0: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1d2: 4581 li a1,0
+ 1d4: 00000097 auipc ra,0x0
+ 1d8: 194080e7 jalr 404(ra) # 368 <open>
+ if(fd < 0)
+ 1dc: 02054563 bltz a0,206 <stat+0x42>
+ 1e0: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1e2: 85ca mv a1,s2
+ 1e4: 00000097 auipc ra,0x0
+ 1e8: 18e080e7 jalr 398(ra) # 372 <fstat>
+ 1ec: 892a mv s2,a0
+ close(fd);
+ 1ee: 8526 mv a0,s1
+ 1f0: 00000097 auipc ra,0x0
+ 1f4: 15c080e7 jalr 348(ra) # 34c <close>
+ return r;
+}
+ 1f8: 854a mv a0,s2
+ 1fa: 60e2 ld ra,24(sp)
+ 1fc: 6442 ld s0,16(sp)
+ 1fe: 64a2 ld s1,8(sp)
+ 200: 6902 ld s2,0(sp)
+ 202: 6105 addi sp,sp,32
+ 204: 8082 ret
+ return -1;
+ 206: 597d li s2,-1
+ 208: bfc5 j 1f8 <stat+0x34>
+
+000000000000020a <atoi>:
+
+int
+atoi(const char *s)
+{
+ 20a: 1141 addi sp,sp,-16
+ 20c: e422 sd s0,8(sp)
+ 20e: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 210: 00054703 lbu a4,0(a0)
+ 214: 02d00793 li a5,45
+ int neg = 1;
+ 218: 4585 li a1,1
+ if (*s == '-') {
+ 21a: 04f70363 beq a4,a5,260 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 21e: 00054703 lbu a4,0(a0)
+ 222: fd07079b addiw a5,a4,-48
+ 226: 0ff7f793 zext.b a5,a5
+ 22a: 46a5 li a3,9
+ 22c: 02f6ed63 bltu a3,a5,266 <atoi+0x5c>
+ n = 0;
+ 230: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 232: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 234: 0505 addi a0,a0,1
+ 236: 0026979b slliw a5,a3,0x2
+ 23a: 9fb5 addw a5,a5,a3
+ 23c: 0017979b slliw a5,a5,0x1
+ 240: 9fb9 addw a5,a5,a4
+ 242: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 246: 00054703 lbu a4,0(a0)
+ 24a: fd07079b addiw a5,a4,-48
+ 24e: 0ff7f793 zext.b a5,a5
+ 252: fef671e3 bgeu a2,a5,234 <atoi+0x2a>
+ return n * neg;
+}
+ 256: 02d5853b mulw a0,a1,a3
+ 25a: 6422 ld s0,8(sp)
+ 25c: 0141 addi sp,sp,16
+ 25e: 8082 ret
+ s++;
+ 260: 0505 addi a0,a0,1
+ neg = -1;
+ 262: 55fd li a1,-1
+ 264: bf6d j 21e <atoi+0x14>
+ n = 0;
+ 266: 4681 li a3,0
+ 268: b7fd j 256 <atoi+0x4c>
+
+000000000000026a <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 26a: 1141 addi sp,sp,-16
+ 26c: e422 sd s0,8(sp)
+ 26e: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 270: 02b57463 bgeu a0,a1,298 <memmove+0x2e>
+ while(n-- > 0)
+ 274: 00c05f63 blez a2,292 <memmove+0x28>
+ 278: 1602 slli a2,a2,0x20
+ 27a: 9201 srli a2,a2,0x20
+ 27c: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 280: 872a mv a4,a0
+ *dst++ = *src++;
+ 282: 0585 addi a1,a1,1
+ 284: 0705 addi a4,a4,1
+ 286: fff5c683 lbu a3,-1(a1)
+ 28a: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 28e: fee79ae3 bne a5,a4,282 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 292: 6422 ld s0,8(sp)
+ 294: 0141 addi sp,sp,16
+ 296: 8082 ret
+ dst += n;
+ 298: 00c50733 add a4,a0,a2
+ src += n;
+ 29c: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 29e: fec05ae3 blez a2,292 <memmove+0x28>
+ 2a2: fff6079b addiw a5,a2,-1
+ 2a6: 1782 slli a5,a5,0x20
+ 2a8: 9381 srli a5,a5,0x20
+ 2aa: fff7c793 not a5,a5
+ 2ae: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2b0: 15fd addi a1,a1,-1
+ 2b2: 177d addi a4,a4,-1
+ 2b4: 0005c683 lbu a3,0(a1)
+ 2b8: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2bc: fee79ae3 bne a5,a4,2b0 <memmove+0x46>
+ 2c0: bfc9 j 292 <memmove+0x28>
+
+00000000000002c2 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2c2: 1141 addi sp,sp,-16
+ 2c4: e422 sd s0,8(sp)
+ 2c6: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2c8: ca05 beqz a2,2f8 <memcmp+0x36>
+ 2ca: fff6069b addiw a3,a2,-1
+ 2ce: 1682 slli a3,a3,0x20
+ 2d0: 9281 srli a3,a3,0x20
+ 2d2: 0685 addi a3,a3,1
+ 2d4: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2d6: 00054783 lbu a5,0(a0)
+ 2da: 0005c703 lbu a4,0(a1)
+ 2de: 00e79863 bne a5,a4,2ee <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2e2: 0505 addi a0,a0,1
+ p2++;
+ 2e4: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2e6: fed518e3 bne a0,a3,2d6 <memcmp+0x14>
+ }
+ return 0;
+ 2ea: 4501 li a0,0
+ 2ec: a019 j 2f2 <memcmp+0x30>
+ return *p1 - *p2;
+ 2ee: 40e7853b subw a0,a5,a4
+}
+ 2f2: 6422 ld s0,8(sp)
+ 2f4: 0141 addi sp,sp,16
+ 2f6: 8082 ret
+ return 0;
+ 2f8: 4501 li a0,0
+ 2fa: bfe5 j 2f2 <memcmp+0x30>
+
+00000000000002fc <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 2fc: 1141 addi sp,sp,-16
+ 2fe: e406 sd ra,8(sp)
+ 300: e022 sd s0,0(sp)
+ 302: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 304: 00000097 auipc ra,0x0
+ 308: f66080e7 jalr -154(ra) # 26a <memmove>
+}
+ 30c: 60a2 ld ra,8(sp)
+ 30e: 6402 ld s0,0(sp)
+ 310: 0141 addi sp,sp,16
+ 312: 8082 ret
+
+0000000000000314 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 314: 4885 li a7,1
+ ecall
+ 316: 00000073 ecall
+ ret
+ 31a: 8082 ret
+
+000000000000031c <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 31c: 05d00893 li a7,93
+ ecall
+ 320: 00000073 ecall
+ ret
+ 324: 8082 ret
+
+0000000000000326 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 326: 488d li a7,3
+ ecall
+ 328: 00000073 ecall
+ ret
+ 32c: 8082 ret
+
+000000000000032e <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 32e: 03b00893 li a7,59
+ ecall
+ 332: 00000073 ecall
+ ret
+ 336: 8082 ret
+
+0000000000000338 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 338: 03f00893 li a7,63
+ ecall
+ 33c: 00000073 ecall
+ ret
+ 340: 8082 ret
+
+0000000000000342 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 342: 04000893 li a7,64
+ ecall
+ 346: 00000073 ecall
+ ret
+ 34a: 8082 ret
+
+000000000000034c <close>:
+.global close
+close:
+ li a7, SYS_close
+ 34c: 03900893 li a7,57
+ ecall
+ 350: 00000073 ecall
+ ret
+ 354: 8082 ret
+
+0000000000000356 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 356: 4899 li a7,6
+ ecall
+ 358: 00000073 ecall
+ ret
+ 35c: 8082 ret
+
+000000000000035e <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 35e: 0dd00893 li a7,221
+ ecall
+ 362: 00000073 ecall
+ ret
+ 366: 8082 ret
+
+0000000000000368 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 368: 03800893 li a7,56
+ ecall
+ 36c: 00000073 ecall
+ ret
+ 370: 8082 ret
+
+0000000000000372 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 372: 05000893 li a7,80
+ ecall
+ 376: 00000073 ecall
+ ret
+ 37a: 8082 ret
+
+000000000000037c <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 37c: 02200893 li a7,34
+ ecall
+ 380: 00000073 ecall
+ ret
+ 384: 8082 ret
+
+0000000000000386 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 386: 03100893 li a7,49
+ ecall
+ 38a: 00000073 ecall
+ ret
+ 38e: 8082 ret
+
+0000000000000390 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 390: 48dd li a7,23
+ ecall
+ 392: 00000073 ecall
+ ret
+ 396: 8082 ret
+
+0000000000000398 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 398: 0ac00893 li a7,172
+ ecall
+ 39c: 00000073 ecall
+ ret
+ 3a0: 8082 ret
+
+00000000000003a2 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 3a2: 48b1 li a7,12
+ ecall
+ 3a4: 00000073 ecall
+ ret
+ 3a8: 8082 ret
+
+00000000000003aa <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3aa: 48b5 li a7,13
+ ecall
+ 3ac: 00000073 ecall
+ ret
+ 3b0: 8082 ret
+
+00000000000003b2 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3b2: 48b9 li a7,14
+ ecall
+ 3b4: 00000073 ecall
+ ret
+ 3b8: 8082 ret
+
+00000000000003ba <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3ba: 48d9 li a7,22
+ ecall
+ 3bc: 00000073 ecall
+ ret
+ 3c0: 8082 ret
+
+00000000000003c2 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3c2: 03200893 li a7,50
+ ecall
+ 3c6: 00000073 ecall
+ ret
+ 3ca: 8082 ret
+
+00000000000003cc <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3cc: 48ed li a7,27
+ ecall
+ 3ce: 00000073 ecall
+ ret
+ 3d2: 8082 ret
+
+00000000000003d4 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3d4: 48c5 li a7,17
+ ecall
+ 3d6: 00000073 ecall
+ ret
+ 3da: 8082 ret
+
+00000000000003dc <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3dc: 07500893 li a7,117
+ ecall
+ 3e0: 00000073 ecall
+ ret
+ 3e4: 8082 ret
+
+00000000000003e6 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3e6: 48c9 li a7,18
+ ecall
+ 3e8: 00000073 ecall
+ ret
+ 3ec: 8082 ret
+
+00000000000003ee <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 3ee: 48cd li a7,19
+ ecall
+ 3f0: 00000073 ecall
+ ret
+ 3f4: 8082 ret
+
+00000000000003f6 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 3f6: 48e9 li a7,26
+ ecall
+ 3f8: 00000073 ecall
+ ret
+ 3fc: 8082 ret
+
+00000000000003fe <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 3fe: 0d200893 li a7,210
+ ecall
+ 402: 00000073 ecall
+ ret
+ 406: 8082 ret
+
+0000000000000408 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 408: 1101 addi sp,sp,-32
+ 40a: ec06 sd ra,24(sp)
+ 40c: e822 sd s0,16(sp)
+ 40e: 1000 addi s0,sp,32
+ 410: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 414: 4605 li a2,1
+ 416: fef40593 addi a1,s0,-17
+ 41a: 00000097 auipc ra,0x0
+ 41e: f28080e7 jalr -216(ra) # 342 <write>
+}
+ 422: 60e2 ld ra,24(sp)
+ 424: 6442 ld s0,16(sp)
+ 426: 6105 addi sp,sp,32
+ 428: 8082 ret
+
+000000000000042a <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 42a: 7139 addi sp,sp,-64
+ 42c: fc06 sd ra,56(sp)
+ 42e: f822 sd s0,48(sp)
+ 430: f426 sd s1,40(sp)
+ 432: f04a sd s2,32(sp)
+ 434: ec4e sd s3,24(sp)
+ 436: 0080 addi s0,sp,64
+ 438: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 43a: c299 beqz a3,440 <printint+0x16>
+ 43c: 0805c863 bltz a1,4cc <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 440: 2581 sext.w a1,a1
+ neg = 0;
+ 442: 4881 li a7,0
+ }
+
+ i = 0;
+ 444: fc040993 addi s3,s0,-64
+ neg = 0;
+ 448: 86ce mv a3,s3
+ i = 0;
+ 44a: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 44c: 2601 sext.w a2,a2
+ 44e: 00000517 auipc a0,0x0
+ 452: 4f250513 addi a0,a0,1266 # 940 <digits>
+ 456: 883a mv a6,a4
+ 458: 2705 addiw a4,a4,1
+ 45a: 02c5f7bb remuw a5,a1,a2
+ 45e: 1782 slli a5,a5,0x20
+ 460: 9381 srli a5,a5,0x20
+ 462: 97aa add a5,a5,a0
+ 464: 0007c783 lbu a5,0(a5)
+ 468: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 46c: 0005879b sext.w a5,a1
+ 470: 02c5d5bb divuw a1,a1,a2
+ 474: 0685 addi a3,a3,1
+ 476: fec7f0e3 bgeu a5,a2,456 <printint+0x2c>
+ if(neg)
+ 47a: 00088c63 beqz a7,492 <printint+0x68>
+ buf[i++] = '-';
+ 47e: fd070793 addi a5,a4,-48
+ 482: 00878733 add a4,a5,s0
+ 486: 02d00793 li a5,45
+ 48a: fef70823 sb a5,-16(a4)
+ 48e: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 492: 02e05663 blez a4,4be <printint+0x94>
+ 496: fc040913 addi s2,s0,-64
+ 49a: 993a add s2,s2,a4
+ 49c: 19fd addi s3,s3,-1
+ 49e: 99ba add s3,s3,a4
+ 4a0: 377d addiw a4,a4,-1
+ 4a2: 1702 slli a4,a4,0x20
+ 4a4: 9301 srli a4,a4,0x20
+ 4a6: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4aa: fff94583 lbu a1,-1(s2)
+ 4ae: 8526 mv a0,s1
+ 4b0: 00000097 auipc ra,0x0
+ 4b4: f58080e7 jalr -168(ra) # 408 <putc>
+ while(--i >= 0)
+ 4b8: 197d addi s2,s2,-1
+ 4ba: ff3918e3 bne s2,s3,4aa <printint+0x80>
+}
+ 4be: 70e2 ld ra,56(sp)
+ 4c0: 7442 ld s0,48(sp)
+ 4c2: 74a2 ld s1,40(sp)
+ 4c4: 7902 ld s2,32(sp)
+ 4c6: 69e2 ld s3,24(sp)
+ 4c8: 6121 addi sp,sp,64
+ 4ca: 8082 ret
+ x = -xx;
+ 4cc: 40b005bb negw a1,a1
+ neg = 1;
+ 4d0: 4885 li a7,1
+ x = -xx;
+ 4d2: bf8d j 444 <printint+0x1a>
+
+00000000000004d4 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4d4: 7119 addi sp,sp,-128
+ 4d6: fc86 sd ra,120(sp)
+ 4d8: f8a2 sd s0,112(sp)
+ 4da: f4a6 sd s1,104(sp)
+ 4dc: f0ca sd s2,96(sp)
+ 4de: ecce sd s3,88(sp)
+ 4e0: e8d2 sd s4,80(sp)
+ 4e2: e4d6 sd s5,72(sp)
+ 4e4: e0da sd s6,64(sp)
+ 4e6: fc5e sd s7,56(sp)
+ 4e8: f862 sd s8,48(sp)
+ 4ea: f466 sd s9,40(sp)
+ 4ec: f06a sd s10,32(sp)
+ 4ee: ec6e sd s11,24(sp)
+ 4f0: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 4f2: 0005c903 lbu s2,0(a1)
+ 4f6: 18090f63 beqz s2,694 <vprintf+0x1c0>
+ 4fa: 8aaa mv s5,a0
+ 4fc: 8b32 mv s6,a2
+ 4fe: 00158493 addi s1,a1,1
+ state = 0;
+ 502: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 504: 02500a13 li s4,37
+ 508: 4c55 li s8,21
+ 50a: 00000c97 auipc s9,0x0
+ 50e: 3dec8c93 addi s9,s9,990 # 8e8 <malloc+0x150>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 512: 02800d93 li s11,40
+ putc(fd, 'x');
+ 516: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 518: 00000b97 auipc s7,0x0
+ 51c: 428b8b93 addi s7,s7,1064 # 940 <digits>
+ 520: a839 j 53e <vprintf+0x6a>
+ putc(fd, c);
+ 522: 85ca mv a1,s2
+ 524: 8556 mv a0,s5
+ 526: 00000097 auipc ra,0x0
+ 52a: ee2080e7 jalr -286(ra) # 408 <putc>
+ 52e: a019 j 534 <vprintf+0x60>
+ } else if(state == '%'){
+ 530: 01498d63 beq s3,s4,54a <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 534: 0485 addi s1,s1,1
+ 536: fff4c903 lbu s2,-1(s1)
+ 53a: 14090d63 beqz s2,694 <vprintf+0x1c0>
+ if(state == 0){
+ 53e: fe0999e3 bnez s3,530 <vprintf+0x5c>
+ if(c == '%'){
+ 542: ff4910e3 bne s2,s4,522 <vprintf+0x4e>
+ state = '%';
+ 546: 89d2 mv s3,s4
+ 548: b7f5 j 534 <vprintf+0x60>
+ if(c == 'd'){
+ 54a: 11490c63 beq s2,s4,662 <vprintf+0x18e>
+ 54e: f9d9079b addiw a5,s2,-99
+ 552: 0ff7f793 zext.b a5,a5
+ 556: 10fc6e63 bltu s8,a5,672 <vprintf+0x19e>
+ 55a: f9d9079b addiw a5,s2,-99
+ 55e: 0ff7f713 zext.b a4,a5
+ 562: 10ec6863 bltu s8,a4,672 <vprintf+0x19e>
+ 566: 00271793 slli a5,a4,0x2
+ 56a: 97e6 add a5,a5,s9
+ 56c: 439c lw a5,0(a5)
+ 56e: 97e6 add a5,a5,s9
+ 570: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 572: 008b0913 addi s2,s6,8
+ 576: 4685 li a3,1
+ 578: 4629 li a2,10
+ 57a: 000b2583 lw a1,0(s6)
+ 57e: 8556 mv a0,s5
+ 580: 00000097 auipc ra,0x0
+ 584: eaa080e7 jalr -342(ra) # 42a <printint>
+ 588: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 58a: 4981 li s3,0
+ 58c: b765 j 534 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 58e: 008b0913 addi s2,s6,8
+ 592: 4681 li a3,0
+ 594: 4629 li a2,10
+ 596: 000b2583 lw a1,0(s6)
+ 59a: 8556 mv a0,s5
+ 59c: 00000097 auipc ra,0x0
+ 5a0: e8e080e7 jalr -370(ra) # 42a <printint>
+ 5a4: 8b4a mv s6,s2
+ state = 0;
+ 5a6: 4981 li s3,0
+ 5a8: b771 j 534 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5aa: 008b0913 addi s2,s6,8
+ 5ae: 4681 li a3,0
+ 5b0: 866a mv a2,s10
+ 5b2: 000b2583 lw a1,0(s6)
+ 5b6: 8556 mv a0,s5
+ 5b8: 00000097 auipc ra,0x0
+ 5bc: e72080e7 jalr -398(ra) # 42a <printint>
+ 5c0: 8b4a mv s6,s2
+ state = 0;
+ 5c2: 4981 li s3,0
+ 5c4: bf85 j 534 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5c6: 008b0793 addi a5,s6,8
+ 5ca: f8f43423 sd a5,-120(s0)
+ 5ce: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5d2: 03000593 li a1,48
+ 5d6: 8556 mv a0,s5
+ 5d8: 00000097 auipc ra,0x0
+ 5dc: e30080e7 jalr -464(ra) # 408 <putc>
+ putc(fd, 'x');
+ 5e0: 07800593 li a1,120
+ 5e4: 8556 mv a0,s5
+ 5e6: 00000097 auipc ra,0x0
+ 5ea: e22080e7 jalr -478(ra) # 408 <putc>
+ 5ee: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5f0: 03c9d793 srli a5,s3,0x3c
+ 5f4: 97de add a5,a5,s7
+ 5f6: 0007c583 lbu a1,0(a5)
+ 5fa: 8556 mv a0,s5
+ 5fc: 00000097 auipc ra,0x0
+ 600: e0c080e7 jalr -500(ra) # 408 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 604: 0992 slli s3,s3,0x4
+ 606: 397d addiw s2,s2,-1
+ 608: fe0914e3 bnez s2,5f0 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 60c: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 610: 4981 li s3,0
+ 612: b70d j 534 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 614: 008b0913 addi s2,s6,8
+ 618: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 61c: 02098163 beqz s3,63e <vprintf+0x16a>
+ while(*s != 0){
+ 620: 0009c583 lbu a1,0(s3)
+ 624: c5ad beqz a1,68e <vprintf+0x1ba>
+ putc(fd, *s);
+ 626: 8556 mv a0,s5
+ 628: 00000097 auipc ra,0x0
+ 62c: de0080e7 jalr -544(ra) # 408 <putc>
+ s++;
+ 630: 0985 addi s3,s3,1
+ while(*s != 0){
+ 632: 0009c583 lbu a1,0(s3)
+ 636: f9e5 bnez a1,626 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 638: 8b4a mv s6,s2
+ state = 0;
+ 63a: 4981 li s3,0
+ 63c: bde5 j 534 <vprintf+0x60>
+ s = "(null)";
+ 63e: 00000997 auipc s3,0x0
+ 642: 2a298993 addi s3,s3,674 # 8e0 <malloc+0x148>
+ while(*s != 0){
+ 646: 85ee mv a1,s11
+ 648: bff9 j 626 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 64a: 008b0913 addi s2,s6,8
+ 64e: 000b4583 lbu a1,0(s6)
+ 652: 8556 mv a0,s5
+ 654: 00000097 auipc ra,0x0
+ 658: db4080e7 jalr -588(ra) # 408 <putc>
+ 65c: 8b4a mv s6,s2
+ state = 0;
+ 65e: 4981 li s3,0
+ 660: bdd1 j 534 <vprintf+0x60>
+ putc(fd, c);
+ 662: 85d2 mv a1,s4
+ 664: 8556 mv a0,s5
+ 666: 00000097 auipc ra,0x0
+ 66a: da2080e7 jalr -606(ra) # 408 <putc>
+ state = 0;
+ 66e: 4981 li s3,0
+ 670: b5d1 j 534 <vprintf+0x60>
+ putc(fd, '%');
+ 672: 85d2 mv a1,s4
+ 674: 8556 mv a0,s5
+ 676: 00000097 auipc ra,0x0
+ 67a: d92080e7 jalr -622(ra) # 408 <putc>
+ putc(fd, c);
+ 67e: 85ca mv a1,s2
+ 680: 8556 mv a0,s5
+ 682: 00000097 auipc ra,0x0
+ 686: d86080e7 jalr -634(ra) # 408 <putc>
+ state = 0;
+ 68a: 4981 li s3,0
+ 68c: b565 j 534 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 68e: 8b4a mv s6,s2
+ state = 0;
+ 690: 4981 li s3,0
+ 692: b54d j 534 <vprintf+0x60>
+ }
+ }
+}
+ 694: 70e6 ld ra,120(sp)
+ 696: 7446 ld s0,112(sp)
+ 698: 74a6 ld s1,104(sp)
+ 69a: 7906 ld s2,96(sp)
+ 69c: 69e6 ld s3,88(sp)
+ 69e: 6a46 ld s4,80(sp)
+ 6a0: 6aa6 ld s5,72(sp)
+ 6a2: 6b06 ld s6,64(sp)
+ 6a4: 7be2 ld s7,56(sp)
+ 6a6: 7c42 ld s8,48(sp)
+ 6a8: 7ca2 ld s9,40(sp)
+ 6aa: 7d02 ld s10,32(sp)
+ 6ac: 6de2 ld s11,24(sp)
+ 6ae: 6109 addi sp,sp,128
+ 6b0: 8082 ret
+
+00000000000006b2 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6b2: 715d addi sp,sp,-80
+ 6b4: ec06 sd ra,24(sp)
+ 6b6: e822 sd s0,16(sp)
+ 6b8: 1000 addi s0,sp,32
+ 6ba: e010 sd a2,0(s0)
+ 6bc: e414 sd a3,8(s0)
+ 6be: e818 sd a4,16(s0)
+ 6c0: ec1c sd a5,24(s0)
+ 6c2: 03043023 sd a6,32(s0)
+ 6c6: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6ca: 8622 mv a2,s0
+ 6cc: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6d0: 00000097 auipc ra,0x0
+ 6d4: e04080e7 jalr -508(ra) # 4d4 <vprintf>
+}
+ 6d8: 60e2 ld ra,24(sp)
+ 6da: 6442 ld s0,16(sp)
+ 6dc: 6161 addi sp,sp,80
+ 6de: 8082 ret
+
+00000000000006e0 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6e0: 711d addi sp,sp,-96
+ 6e2: ec06 sd ra,24(sp)
+ 6e4: e822 sd s0,16(sp)
+ 6e6: 1000 addi s0,sp,32
+ 6e8: e40c sd a1,8(s0)
+ 6ea: e810 sd a2,16(s0)
+ 6ec: ec14 sd a3,24(s0)
+ 6ee: f018 sd a4,32(s0)
+ 6f0: f41c sd a5,40(s0)
+ 6f2: 03043823 sd a6,48(s0)
+ 6f6: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6fa: 00840613 addi a2,s0,8
+ 6fe: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 702: 85aa mv a1,a0
+ 704: 4505 li a0,1
+ 706: 00000097 auipc ra,0x0
+ 70a: dce080e7 jalr -562(ra) # 4d4 <vprintf>
+}
+ 70e: 60e2 ld ra,24(sp)
+ 710: 6442 ld s0,16(sp)
+ 712: 6125 addi sp,sp,96
+ 714: 8082 ret
+
+0000000000000716 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 716: 1141 addi sp,sp,-16
+ 718: e422 sd s0,8(sp)
+ 71a: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 71c: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 720: 00000797 auipc a5,0x0
+ 724: 2387b783 ld a5,568(a5) # 958 <freep>
+ 728: a02d j 752 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 72a: 4618 lw a4,8(a2)
+ 72c: 9f2d addw a4,a4,a1
+ 72e: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 732: 6398 ld a4,0(a5)
+ 734: 6310 ld a2,0(a4)
+ 736: a83d j 774 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 738: ff852703 lw a4,-8(a0)
+ 73c: 9f31 addw a4,a4,a2
+ 73e: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 740: ff053683 ld a3,-16(a0)
+ 744: a091 j 788 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 746: 6398 ld a4,0(a5)
+ 748: 00e7e463 bltu a5,a4,750 <free+0x3a>
+ 74c: 00e6ea63 bltu a3,a4,760 <free+0x4a>
+{
+ 750: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 752: fed7fae3 bgeu a5,a3,746 <free+0x30>
+ 756: 6398 ld a4,0(a5)
+ 758: 00e6e463 bltu a3,a4,760 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 75c: fee7eae3 bltu a5,a4,750 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 760: ff852583 lw a1,-8(a0)
+ 764: 6390 ld a2,0(a5)
+ 766: 02059813 slli a6,a1,0x20
+ 76a: 01c85713 srli a4,a6,0x1c
+ 76e: 9736 add a4,a4,a3
+ 770: fae60de3 beq a2,a4,72a <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 774: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 778: 4790 lw a2,8(a5)
+ 77a: 02061593 slli a1,a2,0x20
+ 77e: 01c5d713 srli a4,a1,0x1c
+ 782: 973e add a4,a4,a5
+ 784: fae68ae3 beq a3,a4,738 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 788: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 78a: 00000717 auipc a4,0x0
+ 78e: 1cf73723 sd a5,462(a4) # 958 <freep>
+}
+ 792: 6422 ld s0,8(sp)
+ 794: 0141 addi sp,sp,16
+ 796: 8082 ret
+
+0000000000000798 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 798: 7139 addi sp,sp,-64
+ 79a: fc06 sd ra,56(sp)
+ 79c: f822 sd s0,48(sp)
+ 79e: f426 sd s1,40(sp)
+ 7a0: f04a sd s2,32(sp)
+ 7a2: ec4e sd s3,24(sp)
+ 7a4: e852 sd s4,16(sp)
+ 7a6: e456 sd s5,8(sp)
+ 7a8: e05a sd s6,0(sp)
+ 7aa: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7ac: 02051493 slli s1,a0,0x20
+ 7b0: 9081 srli s1,s1,0x20
+ 7b2: 04bd addi s1,s1,15
+ 7b4: 8091 srli s1,s1,0x4
+ 7b6: 00148a1b addiw s4,s1,1
+ 7ba: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7bc: 00000517 auipc a0,0x0
+ 7c0: 19c53503 ld a0,412(a0) # 958 <freep>
+ 7c4: c515 beqz a0,7f0 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7c6: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7c8: 4798 lw a4,8(a5)
+ 7ca: 04977163 bgeu a4,s1,80c <malloc+0x74>
+ 7ce: 89d2 mv s3,s4
+ 7d0: 000a071b sext.w a4,s4
+ 7d4: 6685 lui a3,0x1
+ 7d6: 00d77363 bgeu a4,a3,7dc <malloc+0x44>
+ 7da: 6985 lui s3,0x1
+ 7dc: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7e0: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7e4: 00000917 auipc s2,0x0
+ 7e8: 17490913 addi s2,s2,372 # 958 <freep>
+ if(p == (char*)-1)
+ 7ec: 5afd li s5,-1
+ 7ee: a8a5 j 866 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 7f0: 00000797 auipc a5,0x0
+ 7f4: 16878793 addi a5,a5,360 # 958 <freep>
+ 7f8: 00000717 auipc a4,0x0
+ 7fc: 16870713 addi a4,a4,360 # 960 <base>
+ 800: e398 sd a4,0(a5)
+ 802: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 804: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 808: 87ba mv a5,a4
+ 80a: b7d1 j 7ce <malloc+0x36>
+ if(p->s.size == nunits)
+ 80c: 02e48c63 beq s1,a4,844 <malloc+0xac>
+ p->s.size -= nunits;
+ 810: 4147073b subw a4,a4,s4
+ 814: c798 sw a4,8(a5)
+ p += p->s.size;
+ 816: 02071693 slli a3,a4,0x20
+ 81a: 01c6d713 srli a4,a3,0x1c
+ 81e: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 820: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 824: 00000717 auipc a4,0x0
+ 828: 12a73a23 sd a0,308(a4) # 958 <freep>
+ return (void*)(p + 1);
+ 82c: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 830: 70e2 ld ra,56(sp)
+ 832: 7442 ld s0,48(sp)
+ 834: 74a2 ld s1,40(sp)
+ 836: 7902 ld s2,32(sp)
+ 838: 69e2 ld s3,24(sp)
+ 83a: 6a42 ld s4,16(sp)
+ 83c: 6aa2 ld s5,8(sp)
+ 83e: 6b02 ld s6,0(sp)
+ 840: 6121 addi sp,sp,64
+ 842: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 844: 6398 ld a4,0(a5)
+ 846: e118 sd a4,0(a0)
+ 848: bff1 j 824 <malloc+0x8c>
+ hp->s.size = nu;
+ 84a: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 84e: 0541 addi a0,a0,16
+ 850: 00000097 auipc ra,0x0
+ 854: ec6080e7 jalr -314(ra) # 716 <free>
+ return freep;
+ 858: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 85c: d971 beqz a0,830 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 85e: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 860: 4798 lw a4,8(a5)
+ 862: fa9775e3 bgeu a4,s1,80c <malloc+0x74>
+ if(p == freep)
+ 866: 00093703 ld a4,0(s2)
+ 86a: 853e mv a0,a5
+ 86c: fef719e3 bne a4,a5,85e <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 870: 854e mv a0,s3
+ 872: 00000097 auipc ra,0x0
+ 876: b30080e7 jalr -1232(ra) # 3a2 <sbrk>
+ if(p == (char*)-1)
+ 87a: fd5518e3 bne a0,s5,84a <malloc+0xb2>
+ return 0;
+ 87e: 4501 li a0,0
+ 880: bf45 j 830 <malloc+0x98>
diff --git a/xv6-user/sleep.c b/xv6-user/sleep.c
new file mode 100644
index 0000000000000000000000000000000000000000..b36de5b9bc7fa634e79738085d647909071f47e1
--- /dev/null
+++ b/xv6-user/sleep.c
@@ -0,0 +1,19 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ if (argc <= 1) {
+ fprintf(2, "Usage: sleep TIME\n");
+ exit(1);
+ }
+ int time = atoi(argv[1]);
+ if (time == 0) {
+ fprintf(2, "Usage: sleep TIME\nTIME should be an integer larger than 0.\n");
+ exit(1);
+ }
+ sleep(time);
+ exit(0);
+}
diff --git a/xv6-user/sleep.d b/xv6-user/sleep.d
new file mode 100644
index 0000000000000000000000000000000000000000..1a0cab5f6b0d67dc4ae6077c347b3e9fca786524
--- /dev/null
+++ b/xv6-user/sleep.d
@@ -0,0 +1,2 @@
+xv6-user/sleep.o: xv6-user/sleep.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/sleep.o b/xv6-user/sleep.o
new file mode 100644
index 0000000000000000000000000000000000000000..7bd27cec5254e36517c13741c378cedb13c82090
Binary files /dev/null and b/xv6-user/sleep.o differ
diff --git a/xv6-user/sleep.sym b/xv6-user/sleep.sym
new file mode 100644
index 0000000000000000000000000000000000000000..c5aaa58974bc17bebd171d7eb7f407bb8f44626c
--- /dev/null
+++ b/xv6-user/sleep.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+0000000000000888 .rodata
+0000000000000958 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 sleep.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000408 putc
+000000000000042a printint
+0000000000000940 digits
+0000000000000000 umalloc.c
+0000000000000958 freep
+0000000000000960 base
+0000000000000064 strcpy
+00000000000006e0 printf
+0000000000001151 __global_pointer$
+00000000000003c2 dev
+000000000000026a memmove
+00000000000003e6 trace
+000000000000014a gets
+0000000000000951 __SDATA_BEGIN__
+0000000000000398 getpid
+00000000000002fc memcpy
+0000000000000798 malloc
+00000000000003dc remove
+00000000000003aa sleep
+00000000000003ee sysinfo
+00000000000003cc readdir
+000000000000032e pipe
+00000000000003f6 rename
+0000000000000342 write
+0000000000000372 fstat
+00000000000006b2 fprintf
+0000000000000356 kill
+0000000000000080 strcat
+00000000000004d4 vprintf
+0000000000000386 chdir
+000000000000035e exec
+0000000000000326 wait
+0000000000000338 read
+00000000000002c2 memcmp
+0000000000000314 fork
+0000000000000970 __BSS_END__
+00000000000003a2 sbrk
+00000000000003ba test_proc
+00000000000003b2 uptime
+0000000000000951 __bss_start
+0000000000000104 memset
+0000000000000000 main
+00000000000000ae strcmp
+00000000000003fe shutdown
+0000000000000390 dup
+00000000000003d4 getcwd
+0000000000000951 __DATA_BEGIN__
+00000000000001c4 stat
+0000000000000951 _edata
+0000000000000970 _end
+000000000000031c exit
+000000000000020a atoi
+00000000000000da strlen
+0000000000000368 open
+0000000000000126 strchr
+000000000000037c mkdir
+000000000000034c close
+0000000000000716 free
diff --git a/xv6-user/strace.asm b/xv6-user/strace.asm
new file mode 100644
index 0000000000000000000000000000000000000000..4b4006b420cd7af2da3ac52f5eea40aba68f705f
--- /dev/null
+++ b/xv6-user/strace.asm
@@ -0,0 +1,1475 @@
+
+xv6-user/_strace: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ 0: 712d addi sp,sp,-288
+ 2: ee06 sd ra,280(sp)
+ 4: ea22 sd s0,272(sp)
+ 6: e626 sd s1,264(sp)
+ 8: e24a sd s2,256(sp)
+ a: 1200 addi s0,sp,288
+ c: 892e mv s2,a1
+ int i;
+ char *nargv[MAXARG];
+
+ if(argc < 3 /*|| (argv[1][0] < '0' || argv[1][0] > '9')*/){
+ e: 4789 li a5,2
+ 10: 02a7c163 blt a5,a0,32 <main+0x32>
+ fprintf(2, "usage: %s MASK COMMAND\n", argv[0]);
+ 14: 6190 ld a2,0(a1)
+ 16: 00001597 auipc a1,0x1
+ 1a: 8ca58593 addi a1,a1,-1846 # 8e0 <malloc+0xea>
+ 1e: 4509 li a0,2
+ 20: 00000097 auipc ra,0x0
+ 24: 6f0080e7 jalr 1776(ra) # 710 <fprintf>
+ exit(1);
+ 28: 4505 li a0,1
+ 2a: 00000097 auipc ra,0x0
+ 2e: 350080e7 jalr 848(ra) # 37a <exit>
+ 32: 84aa mv s1,a0
+ }
+
+ if (trace(atoi(argv[1])) < 0) {
+ 34: 6588 ld a0,8(a1)
+ 36: 00000097 auipc ra,0x0
+ 3a: 232080e7 jalr 562(ra) # 268 <atoi>
+ 3e: 00000097 auipc ra,0x0
+ 42: 406080e7 jalr 1030(ra) # 444 <trace>
+ 46: 04054e63 bltz a0,a2 <main+0xa2>
+ 4a: 01090793 addi a5,s2,16
+ 4e: ee040713 addi a4,s0,-288
+ 52: ffd4869b addiw a3,s1,-3
+ 56: 02069613 slli a2,a3,0x20
+ 5a: 01d65693 srli a3,a2,0x1d
+ 5e: 96be add a3,a3,a5
+ 60: 10090593 addi a1,s2,256
+ fprintf(2, "%s: strace failed\n", argv[0]);
+ exit(1);
+ }
+
+ for(i = 2; i < argc && i < MAXARG; i++){
+ nargv[i-2] = argv[i];
+ 64: 6390 ld a2,0(a5)
+ 66: e310 sd a2,0(a4)
+ for(i = 2; i < argc && i < MAXARG; i++){
+ 68: 00d78663 beq a5,a3,74 <main+0x74>
+ 6c: 07a1 addi a5,a5,8
+ 6e: 0721 addi a4,a4,8
+ 70: feb79ae3 bne a5,a1,64 <main+0x64>
+ }
+ exec(nargv[0], nargv);
+ 74: ee040593 addi a1,s0,-288
+ 78: ee043503 ld a0,-288(s0)
+ 7c: 00000097 auipc ra,0x0
+ 80: 340080e7 jalr 832(ra) # 3bc <exec>
+ printf("strace: exec %s fail\n", nargv[0]);
+ 84: ee043583 ld a1,-288(s0)
+ 88: 00001517 auipc a0,0x1
+ 8c: 88850513 addi a0,a0,-1912 # 910 <malloc+0x11a>
+ 90: 00000097 auipc ra,0x0
+ 94: 6ae080e7 jalr 1710(ra) # 73e <printf>
+ exit(0);
+ 98: 4501 li a0,0
+ 9a: 00000097 auipc ra,0x0
+ 9e: 2e0080e7 jalr 736(ra) # 37a <exit>
+ fprintf(2, "%s: strace failed\n", argv[0]);
+ a2: 00093603 ld a2,0(s2)
+ a6: 00001597 auipc a1,0x1
+ aa: 85258593 addi a1,a1,-1966 # 8f8 <malloc+0x102>
+ ae: 4509 li a0,2
+ b0: 00000097 auipc ra,0x0
+ b4: 660080e7 jalr 1632(ra) # 710 <fprintf>
+ exit(1);
+ b8: 4505 li a0,1
+ ba: 00000097 auipc ra,0x0
+ be: 2c0080e7 jalr 704(ra) # 37a <exit>
+
+00000000000000c2 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ c2: 1141 addi sp,sp,-16
+ c4: e422 sd s0,8(sp)
+ c6: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ c8: 87aa mv a5,a0
+ ca: 0585 addi a1,a1,1
+ cc: 0785 addi a5,a5,1
+ ce: fff5c703 lbu a4,-1(a1)
+ d2: fee78fa3 sb a4,-1(a5)
+ d6: fb75 bnez a4,ca <strcpy+0x8>
+ ;
+ return os;
+}
+ d8: 6422 ld s0,8(sp)
+ da: 0141 addi sp,sp,16
+ dc: 8082 ret
+
+00000000000000de <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ de: 1141 addi sp,sp,-16
+ e0: e422 sd s0,8(sp)
+ e2: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ e4: 00054783 lbu a5,0(a0)
+ e8: c385 beqz a5,108 <strcat+0x2a>
+ ea: 87aa mv a5,a0
+ s++;
+ ec: 0785 addi a5,a5,1
+ while(*s)
+ ee: 0007c703 lbu a4,0(a5)
+ f2: ff6d bnez a4,ec <strcat+0xe>
+ while((*s++ = *t++))
+ f4: 0585 addi a1,a1,1
+ f6: 0785 addi a5,a5,1
+ f8: fff5c703 lbu a4,-1(a1)
+ fc: fee78fa3 sb a4,-1(a5)
+ 100: fb75 bnez a4,f4 <strcat+0x16>
+ ;
+ return os;
+}
+ 102: 6422 ld s0,8(sp)
+ 104: 0141 addi sp,sp,16
+ 106: 8082 ret
+ while(*s)
+ 108: 87aa mv a5,a0
+ 10a: b7ed j f4 <strcat+0x16>
+
+000000000000010c <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 10c: 1141 addi sp,sp,-16
+ 10e: e422 sd s0,8(sp)
+ 110: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 112: 00054783 lbu a5,0(a0)
+ 116: cb91 beqz a5,12a <strcmp+0x1e>
+ 118: 0005c703 lbu a4,0(a1)
+ 11c: 00f71763 bne a4,a5,12a <strcmp+0x1e>
+ p++, q++;
+ 120: 0505 addi a0,a0,1
+ 122: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 124: 00054783 lbu a5,0(a0)
+ 128: fbe5 bnez a5,118 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 12a: 0005c503 lbu a0,0(a1)
+}
+ 12e: 40a7853b subw a0,a5,a0
+ 132: 6422 ld s0,8(sp)
+ 134: 0141 addi sp,sp,16
+ 136: 8082 ret
+
+0000000000000138 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 138: 1141 addi sp,sp,-16
+ 13a: e422 sd s0,8(sp)
+ 13c: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 13e: 00054783 lbu a5,0(a0)
+ 142: cf91 beqz a5,15e <strlen+0x26>
+ 144: 0505 addi a0,a0,1
+ 146: 87aa mv a5,a0
+ 148: 4685 li a3,1
+ 14a: 9e89 subw a3,a3,a0
+ 14c: 00f6853b addw a0,a3,a5
+ 150: 0785 addi a5,a5,1
+ 152: fff7c703 lbu a4,-1(a5)
+ 156: fb7d bnez a4,14c <strlen+0x14>
+ ;
+ return n;
+}
+ 158: 6422 ld s0,8(sp)
+ 15a: 0141 addi sp,sp,16
+ 15c: 8082 ret
+ for(n = 0; s[n]; n++)
+ 15e: 4501 li a0,0
+ 160: bfe5 j 158 <strlen+0x20>
+
+0000000000000162 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 162: 1141 addi sp,sp,-16
+ 164: e422 sd s0,8(sp)
+ 166: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 168: ca19 beqz a2,17e <memset+0x1c>
+ 16a: 87aa mv a5,a0
+ 16c: 1602 slli a2,a2,0x20
+ 16e: 9201 srli a2,a2,0x20
+ 170: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 174: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 178: 0785 addi a5,a5,1
+ 17a: fee79de3 bne a5,a4,174 <memset+0x12>
+ }
+ return dst;
+}
+ 17e: 6422 ld s0,8(sp)
+ 180: 0141 addi sp,sp,16
+ 182: 8082 ret
+
+0000000000000184 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 184: 1141 addi sp,sp,-16
+ 186: e422 sd s0,8(sp)
+ 188: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 18a: 00054783 lbu a5,0(a0)
+ 18e: cb99 beqz a5,1a4 <strchr+0x20>
+ if(*s == c)
+ 190: 00f58763 beq a1,a5,19e <strchr+0x1a>
+ for(; *s; s++)
+ 194: 0505 addi a0,a0,1
+ 196: 00054783 lbu a5,0(a0)
+ 19a: fbfd bnez a5,190 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 19c: 4501 li a0,0
+}
+ 19e: 6422 ld s0,8(sp)
+ 1a0: 0141 addi sp,sp,16
+ 1a2: 8082 ret
+ return 0;
+ 1a4: 4501 li a0,0
+ 1a6: bfe5 j 19e <strchr+0x1a>
+
+00000000000001a8 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 1a8: 711d addi sp,sp,-96
+ 1aa: ec86 sd ra,88(sp)
+ 1ac: e8a2 sd s0,80(sp)
+ 1ae: e4a6 sd s1,72(sp)
+ 1b0: e0ca sd s2,64(sp)
+ 1b2: fc4e sd s3,56(sp)
+ 1b4: f852 sd s4,48(sp)
+ 1b6: f456 sd s5,40(sp)
+ 1b8: f05a sd s6,32(sp)
+ 1ba: ec5e sd s7,24(sp)
+ 1bc: e862 sd s8,16(sp)
+ 1be: 1080 addi s0,sp,96
+ 1c0: 8baa mv s7,a0
+ 1c2: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 1c4: 892a mv s2,a0
+ 1c6: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 1c8: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 1cc: 4b29 li s6,10
+ 1ce: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 1d0: 89a6 mv s3,s1
+ 1d2: 2485 addiw s1,s1,1
+ 1d4: 0344d763 bge s1,s4,202 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 1d8: 4605 li a2,1
+ 1da: 85d6 mv a1,s5
+ 1dc: 4501 li a0,0
+ 1de: 00000097 auipc ra,0x0
+ 1e2: 1b8080e7 jalr 440(ra) # 396 <read>
+ if(cc < 1)
+ 1e6: 00a05e63 blez a0,202 <gets+0x5a>
+ buf[i++] = c;
+ 1ea: faf44783 lbu a5,-81(s0)
+ 1ee: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 1f2: 01678763 beq a5,s6,200 <gets+0x58>
+ 1f6: 0905 addi s2,s2,1
+ 1f8: fd879ce3 bne a5,s8,1d0 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 1fc: 89a6 mv s3,s1
+ 1fe: a011 j 202 <gets+0x5a>
+ 200: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 202: 99de add s3,s3,s7
+ 204: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 208: 855e mv a0,s7
+ 20a: 60e6 ld ra,88(sp)
+ 20c: 6446 ld s0,80(sp)
+ 20e: 64a6 ld s1,72(sp)
+ 210: 6906 ld s2,64(sp)
+ 212: 79e2 ld s3,56(sp)
+ 214: 7a42 ld s4,48(sp)
+ 216: 7aa2 ld s5,40(sp)
+ 218: 7b02 ld s6,32(sp)
+ 21a: 6be2 ld s7,24(sp)
+ 21c: 6c42 ld s8,16(sp)
+ 21e: 6125 addi sp,sp,96
+ 220: 8082 ret
+
+0000000000000222 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 222: 1101 addi sp,sp,-32
+ 224: ec06 sd ra,24(sp)
+ 226: e822 sd s0,16(sp)
+ 228: e426 sd s1,8(sp)
+ 22a: e04a sd s2,0(sp)
+ 22c: 1000 addi s0,sp,32
+ 22e: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 230: 4581 li a1,0
+ 232: 00000097 auipc ra,0x0
+ 236: 194080e7 jalr 404(ra) # 3c6 <open>
+ if(fd < 0)
+ 23a: 02054563 bltz a0,264 <stat+0x42>
+ 23e: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 240: 85ca mv a1,s2
+ 242: 00000097 auipc ra,0x0
+ 246: 18e080e7 jalr 398(ra) # 3d0 <fstat>
+ 24a: 892a mv s2,a0
+ close(fd);
+ 24c: 8526 mv a0,s1
+ 24e: 00000097 auipc ra,0x0
+ 252: 15c080e7 jalr 348(ra) # 3aa <close>
+ return r;
+}
+ 256: 854a mv a0,s2
+ 258: 60e2 ld ra,24(sp)
+ 25a: 6442 ld s0,16(sp)
+ 25c: 64a2 ld s1,8(sp)
+ 25e: 6902 ld s2,0(sp)
+ 260: 6105 addi sp,sp,32
+ 262: 8082 ret
+ return -1;
+ 264: 597d li s2,-1
+ 266: bfc5 j 256 <stat+0x34>
+
+0000000000000268 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 268: 1141 addi sp,sp,-16
+ 26a: e422 sd s0,8(sp)
+ 26c: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 26e: 00054703 lbu a4,0(a0)
+ 272: 02d00793 li a5,45
+ int neg = 1;
+ 276: 4585 li a1,1
+ if (*s == '-') {
+ 278: 04f70363 beq a4,a5,2be <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 27c: 00054703 lbu a4,0(a0)
+ 280: fd07079b addiw a5,a4,-48
+ 284: 0ff7f793 zext.b a5,a5
+ 288: 46a5 li a3,9
+ 28a: 02f6ed63 bltu a3,a5,2c4 <atoi+0x5c>
+ n = 0;
+ 28e: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 290: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 292: 0505 addi a0,a0,1
+ 294: 0026979b slliw a5,a3,0x2
+ 298: 9fb5 addw a5,a5,a3
+ 29a: 0017979b slliw a5,a5,0x1
+ 29e: 9fb9 addw a5,a5,a4
+ 2a0: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 2a4: 00054703 lbu a4,0(a0)
+ 2a8: fd07079b addiw a5,a4,-48
+ 2ac: 0ff7f793 zext.b a5,a5
+ 2b0: fef671e3 bgeu a2,a5,292 <atoi+0x2a>
+ return n * neg;
+}
+ 2b4: 02d5853b mulw a0,a1,a3
+ 2b8: 6422 ld s0,8(sp)
+ 2ba: 0141 addi sp,sp,16
+ 2bc: 8082 ret
+ s++;
+ 2be: 0505 addi a0,a0,1
+ neg = -1;
+ 2c0: 55fd li a1,-1
+ 2c2: bf6d j 27c <atoi+0x14>
+ n = 0;
+ 2c4: 4681 li a3,0
+ 2c6: b7fd j 2b4 <atoi+0x4c>
+
+00000000000002c8 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 2c8: 1141 addi sp,sp,-16
+ 2ca: e422 sd s0,8(sp)
+ 2cc: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 2ce: 02b57463 bgeu a0,a1,2f6 <memmove+0x2e>
+ while(n-- > 0)
+ 2d2: 00c05f63 blez a2,2f0 <memmove+0x28>
+ 2d6: 1602 slli a2,a2,0x20
+ 2d8: 9201 srli a2,a2,0x20
+ 2da: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 2de: 872a mv a4,a0
+ *dst++ = *src++;
+ 2e0: 0585 addi a1,a1,1
+ 2e2: 0705 addi a4,a4,1
+ 2e4: fff5c683 lbu a3,-1(a1)
+ 2e8: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 2ec: fee79ae3 bne a5,a4,2e0 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 2f0: 6422 ld s0,8(sp)
+ 2f2: 0141 addi sp,sp,16
+ 2f4: 8082 ret
+ dst += n;
+ 2f6: 00c50733 add a4,a0,a2
+ src += n;
+ 2fa: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 2fc: fec05ae3 blez a2,2f0 <memmove+0x28>
+ 300: fff6079b addiw a5,a2,-1
+ 304: 1782 slli a5,a5,0x20
+ 306: 9381 srli a5,a5,0x20
+ 308: fff7c793 not a5,a5
+ 30c: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 30e: 15fd addi a1,a1,-1
+ 310: 177d addi a4,a4,-1
+ 312: 0005c683 lbu a3,0(a1)
+ 316: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 31a: fee79ae3 bne a5,a4,30e <memmove+0x46>
+ 31e: bfc9 j 2f0 <memmove+0x28>
+
+0000000000000320 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 320: 1141 addi sp,sp,-16
+ 322: e422 sd s0,8(sp)
+ 324: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 326: ca05 beqz a2,356 <memcmp+0x36>
+ 328: fff6069b addiw a3,a2,-1
+ 32c: 1682 slli a3,a3,0x20
+ 32e: 9281 srli a3,a3,0x20
+ 330: 0685 addi a3,a3,1
+ 332: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 334: 00054783 lbu a5,0(a0)
+ 338: 0005c703 lbu a4,0(a1)
+ 33c: 00e79863 bne a5,a4,34c <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 340: 0505 addi a0,a0,1
+ p2++;
+ 342: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 344: fed518e3 bne a0,a3,334 <memcmp+0x14>
+ }
+ return 0;
+ 348: 4501 li a0,0
+ 34a: a019 j 350 <memcmp+0x30>
+ return *p1 - *p2;
+ 34c: 40e7853b subw a0,a5,a4
+}
+ 350: 6422 ld s0,8(sp)
+ 352: 0141 addi sp,sp,16
+ 354: 8082 ret
+ return 0;
+ 356: 4501 li a0,0
+ 358: bfe5 j 350 <memcmp+0x30>
+
+000000000000035a <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 35a: 1141 addi sp,sp,-16
+ 35c: e406 sd ra,8(sp)
+ 35e: e022 sd s0,0(sp)
+ 360: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 362: 00000097 auipc ra,0x0
+ 366: f66080e7 jalr -154(ra) # 2c8 <memmove>
+}
+ 36a: 60a2 ld ra,8(sp)
+ 36c: 6402 ld s0,0(sp)
+ 36e: 0141 addi sp,sp,16
+ 370: 8082 ret
+
+0000000000000372 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 372: 4885 li a7,1
+ ecall
+ 374: 00000073 ecall
+ ret
+ 378: 8082 ret
+
+000000000000037a <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 37a: 05d00893 li a7,93
+ ecall
+ 37e: 00000073 ecall
+ ret
+ 382: 8082 ret
+
+0000000000000384 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 384: 488d li a7,3
+ ecall
+ 386: 00000073 ecall
+ ret
+ 38a: 8082 ret
+
+000000000000038c <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 38c: 03b00893 li a7,59
+ ecall
+ 390: 00000073 ecall
+ ret
+ 394: 8082 ret
+
+0000000000000396 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 396: 03f00893 li a7,63
+ ecall
+ 39a: 00000073 ecall
+ ret
+ 39e: 8082 ret
+
+00000000000003a0 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 3a0: 04000893 li a7,64
+ ecall
+ 3a4: 00000073 ecall
+ ret
+ 3a8: 8082 ret
+
+00000000000003aa <close>:
+.global close
+close:
+ li a7, SYS_close
+ 3aa: 03900893 li a7,57
+ ecall
+ 3ae: 00000073 ecall
+ ret
+ 3b2: 8082 ret
+
+00000000000003b4 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 3b4: 4899 li a7,6
+ ecall
+ 3b6: 00000073 ecall
+ ret
+ 3ba: 8082 ret
+
+00000000000003bc <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 3bc: 0dd00893 li a7,221
+ ecall
+ 3c0: 00000073 ecall
+ ret
+ 3c4: 8082 ret
+
+00000000000003c6 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 3c6: 03800893 li a7,56
+ ecall
+ 3ca: 00000073 ecall
+ ret
+ 3ce: 8082 ret
+
+00000000000003d0 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 3d0: 05000893 li a7,80
+ ecall
+ 3d4: 00000073 ecall
+ ret
+ 3d8: 8082 ret
+
+00000000000003da <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 3da: 02200893 li a7,34
+ ecall
+ 3de: 00000073 ecall
+ ret
+ 3e2: 8082 ret
+
+00000000000003e4 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 3e4: 03100893 li a7,49
+ ecall
+ 3e8: 00000073 ecall
+ ret
+ 3ec: 8082 ret
+
+00000000000003ee <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 3ee: 48dd li a7,23
+ ecall
+ 3f0: 00000073 ecall
+ ret
+ 3f4: 8082 ret
+
+00000000000003f6 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 3f6: 0ac00893 li a7,172
+ ecall
+ 3fa: 00000073 ecall
+ ret
+ 3fe: 8082 ret
+
+0000000000000400 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 400: 48b1 li a7,12
+ ecall
+ 402: 00000073 ecall
+ ret
+ 406: 8082 ret
+
+0000000000000408 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 408: 48b5 li a7,13
+ ecall
+ 40a: 00000073 ecall
+ ret
+ 40e: 8082 ret
+
+0000000000000410 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 410: 48b9 li a7,14
+ ecall
+ 412: 00000073 ecall
+ ret
+ 416: 8082 ret
+
+0000000000000418 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 418: 48d9 li a7,22
+ ecall
+ 41a: 00000073 ecall
+ ret
+ 41e: 8082 ret
+
+0000000000000420 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 420: 03200893 li a7,50
+ ecall
+ 424: 00000073 ecall
+ ret
+ 428: 8082 ret
+
+000000000000042a <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 42a: 48ed li a7,27
+ ecall
+ 42c: 00000073 ecall
+ ret
+ 430: 8082 ret
+
+0000000000000432 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 432: 48c5 li a7,17
+ ecall
+ 434: 00000073 ecall
+ ret
+ 438: 8082 ret
+
+000000000000043a <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 43a: 07500893 li a7,117
+ ecall
+ 43e: 00000073 ecall
+ ret
+ 442: 8082 ret
+
+0000000000000444 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 444: 48c9 li a7,18
+ ecall
+ 446: 00000073 ecall
+ ret
+ 44a: 8082 ret
+
+000000000000044c <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 44c: 48cd li a7,19
+ ecall
+ 44e: 00000073 ecall
+ ret
+ 452: 8082 ret
+
+0000000000000454 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 454: 48e9 li a7,26
+ ecall
+ 456: 00000073 ecall
+ ret
+ 45a: 8082 ret
+
+000000000000045c <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 45c: 0d200893 li a7,210
+ ecall
+ 460: 00000073 ecall
+ ret
+ 464: 8082 ret
+
+0000000000000466 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 466: 1101 addi sp,sp,-32
+ 468: ec06 sd ra,24(sp)
+ 46a: e822 sd s0,16(sp)
+ 46c: 1000 addi s0,sp,32
+ 46e: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 472: 4605 li a2,1
+ 474: fef40593 addi a1,s0,-17
+ 478: 00000097 auipc ra,0x0
+ 47c: f28080e7 jalr -216(ra) # 3a0 <write>
+}
+ 480: 60e2 ld ra,24(sp)
+ 482: 6442 ld s0,16(sp)
+ 484: 6105 addi sp,sp,32
+ 486: 8082 ret
+
+0000000000000488 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 488: 7139 addi sp,sp,-64
+ 48a: fc06 sd ra,56(sp)
+ 48c: f822 sd s0,48(sp)
+ 48e: f426 sd s1,40(sp)
+ 490: f04a sd s2,32(sp)
+ 492: ec4e sd s3,24(sp)
+ 494: 0080 addi s0,sp,64
+ 496: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 498: c299 beqz a3,49e <printint+0x16>
+ 49a: 0805c863 bltz a1,52a <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 49e: 2581 sext.w a1,a1
+ neg = 0;
+ 4a0: 4881 li a7,0
+ }
+
+ i = 0;
+ 4a2: fc040993 addi s3,s0,-64
+ neg = 0;
+ 4a6: 86ce mv a3,s3
+ i = 0;
+ 4a8: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 4aa: 2601 sext.w a2,a2
+ 4ac: 00000517 auipc a0,0x0
+ 4b0: 4dc50513 addi a0,a0,1244 # 988 <digits>
+ 4b4: 883a mv a6,a4
+ 4b6: 2705 addiw a4,a4,1
+ 4b8: 02c5f7bb remuw a5,a1,a2
+ 4bc: 1782 slli a5,a5,0x20
+ 4be: 9381 srli a5,a5,0x20
+ 4c0: 97aa add a5,a5,a0
+ 4c2: 0007c783 lbu a5,0(a5)
+ 4c6: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 4ca: 0005879b sext.w a5,a1
+ 4ce: 02c5d5bb divuw a1,a1,a2
+ 4d2: 0685 addi a3,a3,1
+ 4d4: fec7f0e3 bgeu a5,a2,4b4 <printint+0x2c>
+ if(neg)
+ 4d8: 00088c63 beqz a7,4f0 <printint+0x68>
+ buf[i++] = '-';
+ 4dc: fd070793 addi a5,a4,-48
+ 4e0: 00878733 add a4,a5,s0
+ 4e4: 02d00793 li a5,45
+ 4e8: fef70823 sb a5,-16(a4)
+ 4ec: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 4f0: 02e05663 blez a4,51c <printint+0x94>
+ 4f4: fc040913 addi s2,s0,-64
+ 4f8: 993a add s2,s2,a4
+ 4fa: 19fd addi s3,s3,-1
+ 4fc: 99ba add s3,s3,a4
+ 4fe: 377d addiw a4,a4,-1
+ 500: 1702 slli a4,a4,0x20
+ 502: 9301 srli a4,a4,0x20
+ 504: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 508: fff94583 lbu a1,-1(s2)
+ 50c: 8526 mv a0,s1
+ 50e: 00000097 auipc ra,0x0
+ 512: f58080e7 jalr -168(ra) # 466 <putc>
+ while(--i >= 0)
+ 516: 197d addi s2,s2,-1
+ 518: ff3918e3 bne s2,s3,508 <printint+0x80>
+}
+ 51c: 70e2 ld ra,56(sp)
+ 51e: 7442 ld s0,48(sp)
+ 520: 74a2 ld s1,40(sp)
+ 522: 7902 ld s2,32(sp)
+ 524: 69e2 ld s3,24(sp)
+ 526: 6121 addi sp,sp,64
+ 528: 8082 ret
+ x = -xx;
+ 52a: 40b005bb negw a1,a1
+ neg = 1;
+ 52e: 4885 li a7,1
+ x = -xx;
+ 530: bf8d j 4a2 <printint+0x1a>
+
+0000000000000532 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 532: 7119 addi sp,sp,-128
+ 534: fc86 sd ra,120(sp)
+ 536: f8a2 sd s0,112(sp)
+ 538: f4a6 sd s1,104(sp)
+ 53a: f0ca sd s2,96(sp)
+ 53c: ecce sd s3,88(sp)
+ 53e: e8d2 sd s4,80(sp)
+ 540: e4d6 sd s5,72(sp)
+ 542: e0da sd s6,64(sp)
+ 544: fc5e sd s7,56(sp)
+ 546: f862 sd s8,48(sp)
+ 548: f466 sd s9,40(sp)
+ 54a: f06a sd s10,32(sp)
+ 54c: ec6e sd s11,24(sp)
+ 54e: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 550: 0005c903 lbu s2,0(a1)
+ 554: 18090f63 beqz s2,6f2 <vprintf+0x1c0>
+ 558: 8aaa mv s5,a0
+ 55a: 8b32 mv s6,a2
+ 55c: 00158493 addi s1,a1,1
+ state = 0;
+ 560: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 562: 02500a13 li s4,37
+ 566: 4c55 li s8,21
+ 568: 00000c97 auipc s9,0x0
+ 56c: 3c8c8c93 addi s9,s9,968 # 930 <malloc+0x13a>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 570: 02800d93 li s11,40
+ putc(fd, 'x');
+ 574: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 576: 00000b97 auipc s7,0x0
+ 57a: 412b8b93 addi s7,s7,1042 # 988 <digits>
+ 57e: a839 j 59c <vprintf+0x6a>
+ putc(fd, c);
+ 580: 85ca mv a1,s2
+ 582: 8556 mv a0,s5
+ 584: 00000097 auipc ra,0x0
+ 588: ee2080e7 jalr -286(ra) # 466 <putc>
+ 58c: a019 j 592 <vprintf+0x60>
+ } else if(state == '%'){
+ 58e: 01498d63 beq s3,s4,5a8 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 592: 0485 addi s1,s1,1
+ 594: fff4c903 lbu s2,-1(s1)
+ 598: 14090d63 beqz s2,6f2 <vprintf+0x1c0>
+ if(state == 0){
+ 59c: fe0999e3 bnez s3,58e <vprintf+0x5c>
+ if(c == '%'){
+ 5a0: ff4910e3 bne s2,s4,580 <vprintf+0x4e>
+ state = '%';
+ 5a4: 89d2 mv s3,s4
+ 5a6: b7f5 j 592 <vprintf+0x60>
+ if(c == 'd'){
+ 5a8: 11490c63 beq s2,s4,6c0 <vprintf+0x18e>
+ 5ac: f9d9079b addiw a5,s2,-99
+ 5b0: 0ff7f793 zext.b a5,a5
+ 5b4: 10fc6e63 bltu s8,a5,6d0 <vprintf+0x19e>
+ 5b8: f9d9079b addiw a5,s2,-99
+ 5bc: 0ff7f713 zext.b a4,a5
+ 5c0: 10ec6863 bltu s8,a4,6d0 <vprintf+0x19e>
+ 5c4: 00271793 slli a5,a4,0x2
+ 5c8: 97e6 add a5,a5,s9
+ 5ca: 439c lw a5,0(a5)
+ 5cc: 97e6 add a5,a5,s9
+ 5ce: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 5d0: 008b0913 addi s2,s6,8
+ 5d4: 4685 li a3,1
+ 5d6: 4629 li a2,10
+ 5d8: 000b2583 lw a1,0(s6)
+ 5dc: 8556 mv a0,s5
+ 5de: 00000097 auipc ra,0x0
+ 5e2: eaa080e7 jalr -342(ra) # 488 <printint>
+ 5e6: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 5e8: 4981 li s3,0
+ 5ea: b765 j 592 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 5ec: 008b0913 addi s2,s6,8
+ 5f0: 4681 li a3,0
+ 5f2: 4629 li a2,10
+ 5f4: 000b2583 lw a1,0(s6)
+ 5f8: 8556 mv a0,s5
+ 5fa: 00000097 auipc ra,0x0
+ 5fe: e8e080e7 jalr -370(ra) # 488 <printint>
+ 602: 8b4a mv s6,s2
+ state = 0;
+ 604: 4981 li s3,0
+ 606: b771 j 592 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 608: 008b0913 addi s2,s6,8
+ 60c: 4681 li a3,0
+ 60e: 866a mv a2,s10
+ 610: 000b2583 lw a1,0(s6)
+ 614: 8556 mv a0,s5
+ 616: 00000097 auipc ra,0x0
+ 61a: e72080e7 jalr -398(ra) # 488 <printint>
+ 61e: 8b4a mv s6,s2
+ state = 0;
+ 620: 4981 li s3,0
+ 622: bf85 j 592 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 624: 008b0793 addi a5,s6,8
+ 628: f8f43423 sd a5,-120(s0)
+ 62c: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 630: 03000593 li a1,48
+ 634: 8556 mv a0,s5
+ 636: 00000097 auipc ra,0x0
+ 63a: e30080e7 jalr -464(ra) # 466 <putc>
+ putc(fd, 'x');
+ 63e: 07800593 li a1,120
+ 642: 8556 mv a0,s5
+ 644: 00000097 auipc ra,0x0
+ 648: e22080e7 jalr -478(ra) # 466 <putc>
+ 64c: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 64e: 03c9d793 srli a5,s3,0x3c
+ 652: 97de add a5,a5,s7
+ 654: 0007c583 lbu a1,0(a5)
+ 658: 8556 mv a0,s5
+ 65a: 00000097 auipc ra,0x0
+ 65e: e0c080e7 jalr -500(ra) # 466 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 662: 0992 slli s3,s3,0x4
+ 664: 397d addiw s2,s2,-1
+ 666: fe0914e3 bnez s2,64e <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 66a: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 66e: 4981 li s3,0
+ 670: b70d j 592 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 672: 008b0913 addi s2,s6,8
+ 676: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 67a: 02098163 beqz s3,69c <vprintf+0x16a>
+ while(*s != 0){
+ 67e: 0009c583 lbu a1,0(s3)
+ 682: c5ad beqz a1,6ec <vprintf+0x1ba>
+ putc(fd, *s);
+ 684: 8556 mv a0,s5
+ 686: 00000097 auipc ra,0x0
+ 68a: de0080e7 jalr -544(ra) # 466 <putc>
+ s++;
+ 68e: 0985 addi s3,s3,1
+ while(*s != 0){
+ 690: 0009c583 lbu a1,0(s3)
+ 694: f9e5 bnez a1,684 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 696: 8b4a mv s6,s2
+ state = 0;
+ 698: 4981 li s3,0
+ 69a: bde5 j 592 <vprintf+0x60>
+ s = "(null)";
+ 69c: 00000997 auipc s3,0x0
+ 6a0: 28c98993 addi s3,s3,652 # 928 <malloc+0x132>
+ while(*s != 0){
+ 6a4: 85ee mv a1,s11
+ 6a6: bff9 j 684 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 6a8: 008b0913 addi s2,s6,8
+ 6ac: 000b4583 lbu a1,0(s6)
+ 6b0: 8556 mv a0,s5
+ 6b2: 00000097 auipc ra,0x0
+ 6b6: db4080e7 jalr -588(ra) # 466 <putc>
+ 6ba: 8b4a mv s6,s2
+ state = 0;
+ 6bc: 4981 li s3,0
+ 6be: bdd1 j 592 <vprintf+0x60>
+ putc(fd, c);
+ 6c0: 85d2 mv a1,s4
+ 6c2: 8556 mv a0,s5
+ 6c4: 00000097 auipc ra,0x0
+ 6c8: da2080e7 jalr -606(ra) # 466 <putc>
+ state = 0;
+ 6cc: 4981 li s3,0
+ 6ce: b5d1 j 592 <vprintf+0x60>
+ putc(fd, '%');
+ 6d0: 85d2 mv a1,s4
+ 6d2: 8556 mv a0,s5
+ 6d4: 00000097 auipc ra,0x0
+ 6d8: d92080e7 jalr -622(ra) # 466 <putc>
+ putc(fd, c);
+ 6dc: 85ca mv a1,s2
+ 6de: 8556 mv a0,s5
+ 6e0: 00000097 auipc ra,0x0
+ 6e4: d86080e7 jalr -634(ra) # 466 <putc>
+ state = 0;
+ 6e8: 4981 li s3,0
+ 6ea: b565 j 592 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 6ec: 8b4a mv s6,s2
+ state = 0;
+ 6ee: 4981 li s3,0
+ 6f0: b54d j 592 <vprintf+0x60>
+ }
+ }
+}
+ 6f2: 70e6 ld ra,120(sp)
+ 6f4: 7446 ld s0,112(sp)
+ 6f6: 74a6 ld s1,104(sp)
+ 6f8: 7906 ld s2,96(sp)
+ 6fa: 69e6 ld s3,88(sp)
+ 6fc: 6a46 ld s4,80(sp)
+ 6fe: 6aa6 ld s5,72(sp)
+ 700: 6b06 ld s6,64(sp)
+ 702: 7be2 ld s7,56(sp)
+ 704: 7c42 ld s8,48(sp)
+ 706: 7ca2 ld s9,40(sp)
+ 708: 7d02 ld s10,32(sp)
+ 70a: 6de2 ld s11,24(sp)
+ 70c: 6109 addi sp,sp,128
+ 70e: 8082 ret
+
+0000000000000710 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 710: 715d addi sp,sp,-80
+ 712: ec06 sd ra,24(sp)
+ 714: e822 sd s0,16(sp)
+ 716: 1000 addi s0,sp,32
+ 718: e010 sd a2,0(s0)
+ 71a: e414 sd a3,8(s0)
+ 71c: e818 sd a4,16(s0)
+ 71e: ec1c sd a5,24(s0)
+ 720: 03043023 sd a6,32(s0)
+ 724: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 728: 8622 mv a2,s0
+ 72a: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 72e: 00000097 auipc ra,0x0
+ 732: e04080e7 jalr -508(ra) # 532 <vprintf>
+}
+ 736: 60e2 ld ra,24(sp)
+ 738: 6442 ld s0,16(sp)
+ 73a: 6161 addi sp,sp,80
+ 73c: 8082 ret
+
+000000000000073e <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 73e: 711d addi sp,sp,-96
+ 740: ec06 sd ra,24(sp)
+ 742: e822 sd s0,16(sp)
+ 744: 1000 addi s0,sp,32
+ 746: e40c sd a1,8(s0)
+ 748: e810 sd a2,16(s0)
+ 74a: ec14 sd a3,24(s0)
+ 74c: f018 sd a4,32(s0)
+ 74e: f41c sd a5,40(s0)
+ 750: 03043823 sd a6,48(s0)
+ 754: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 758: 00840613 addi a2,s0,8
+ 75c: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 760: 85aa mv a1,a0
+ 762: 4505 li a0,1
+ 764: 00000097 auipc ra,0x0
+ 768: dce080e7 jalr -562(ra) # 532 <vprintf>
+}
+ 76c: 60e2 ld ra,24(sp)
+ 76e: 6442 ld s0,16(sp)
+ 770: 6125 addi sp,sp,96
+ 772: 8082 ret
+
+0000000000000774 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 774: 1141 addi sp,sp,-16
+ 776: e422 sd s0,8(sp)
+ 778: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 77a: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 77e: 00000797 auipc a5,0x0
+ 782: 2227b783 ld a5,546(a5) # 9a0 <freep>
+ 786: a02d j 7b0 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 788: 4618 lw a4,8(a2)
+ 78a: 9f2d addw a4,a4,a1
+ 78c: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 790: 6398 ld a4,0(a5)
+ 792: 6310 ld a2,0(a4)
+ 794: a83d j 7d2 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 796: ff852703 lw a4,-8(a0)
+ 79a: 9f31 addw a4,a4,a2
+ 79c: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 79e: ff053683 ld a3,-16(a0)
+ 7a2: a091 j 7e6 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 7a4: 6398 ld a4,0(a5)
+ 7a6: 00e7e463 bltu a5,a4,7ae <free+0x3a>
+ 7aa: 00e6ea63 bltu a3,a4,7be <free+0x4a>
+{
+ 7ae: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 7b0: fed7fae3 bgeu a5,a3,7a4 <free+0x30>
+ 7b4: 6398 ld a4,0(a5)
+ 7b6: 00e6e463 bltu a3,a4,7be <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 7ba: fee7eae3 bltu a5,a4,7ae <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 7be: ff852583 lw a1,-8(a0)
+ 7c2: 6390 ld a2,0(a5)
+ 7c4: 02059813 slli a6,a1,0x20
+ 7c8: 01c85713 srli a4,a6,0x1c
+ 7cc: 9736 add a4,a4,a3
+ 7ce: fae60de3 beq a2,a4,788 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 7d2: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 7d6: 4790 lw a2,8(a5)
+ 7d8: 02061593 slli a1,a2,0x20
+ 7dc: 01c5d713 srli a4,a1,0x1c
+ 7e0: 973e add a4,a4,a5
+ 7e2: fae68ae3 beq a3,a4,796 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 7e6: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 7e8: 00000717 auipc a4,0x0
+ 7ec: 1af73c23 sd a5,440(a4) # 9a0 <freep>
+}
+ 7f0: 6422 ld s0,8(sp)
+ 7f2: 0141 addi sp,sp,16
+ 7f4: 8082 ret
+
+00000000000007f6 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 7f6: 7139 addi sp,sp,-64
+ 7f8: fc06 sd ra,56(sp)
+ 7fa: f822 sd s0,48(sp)
+ 7fc: f426 sd s1,40(sp)
+ 7fe: f04a sd s2,32(sp)
+ 800: ec4e sd s3,24(sp)
+ 802: e852 sd s4,16(sp)
+ 804: e456 sd s5,8(sp)
+ 806: e05a sd s6,0(sp)
+ 808: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 80a: 02051493 slli s1,a0,0x20
+ 80e: 9081 srli s1,s1,0x20
+ 810: 04bd addi s1,s1,15
+ 812: 8091 srli s1,s1,0x4
+ 814: 00148a1b addiw s4,s1,1
+ 818: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 81a: 00000517 auipc a0,0x0
+ 81e: 18653503 ld a0,390(a0) # 9a0 <freep>
+ 822: c515 beqz a0,84e <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 824: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 826: 4798 lw a4,8(a5)
+ 828: 04977163 bgeu a4,s1,86a <malloc+0x74>
+ 82c: 89d2 mv s3,s4
+ 82e: 000a071b sext.w a4,s4
+ 832: 6685 lui a3,0x1
+ 834: 00d77363 bgeu a4,a3,83a <malloc+0x44>
+ 838: 6985 lui s3,0x1
+ 83a: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 83e: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 842: 00000917 auipc s2,0x0
+ 846: 15e90913 addi s2,s2,350 # 9a0 <freep>
+ if(p == (char*)-1)
+ 84a: 5afd li s5,-1
+ 84c: a8a5 j 8c4 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 84e: 00000797 auipc a5,0x0
+ 852: 15278793 addi a5,a5,338 # 9a0 <freep>
+ 856: 00000717 auipc a4,0x0
+ 85a: 15270713 addi a4,a4,338 # 9a8 <base>
+ 85e: e398 sd a4,0(a5)
+ 860: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 862: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 866: 87ba mv a5,a4
+ 868: b7d1 j 82c <malloc+0x36>
+ if(p->s.size == nunits)
+ 86a: 02e48c63 beq s1,a4,8a2 <malloc+0xac>
+ p->s.size -= nunits;
+ 86e: 4147073b subw a4,a4,s4
+ 872: c798 sw a4,8(a5)
+ p += p->s.size;
+ 874: 02071693 slli a3,a4,0x20
+ 878: 01c6d713 srli a4,a3,0x1c
+ 87c: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 87e: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 882: 00000717 auipc a4,0x0
+ 886: 10a73f23 sd a0,286(a4) # 9a0 <freep>
+ return (void*)(p + 1);
+ 88a: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 88e: 70e2 ld ra,56(sp)
+ 890: 7442 ld s0,48(sp)
+ 892: 74a2 ld s1,40(sp)
+ 894: 7902 ld s2,32(sp)
+ 896: 69e2 ld s3,24(sp)
+ 898: 6a42 ld s4,16(sp)
+ 89a: 6aa2 ld s5,8(sp)
+ 89c: 6b02 ld s6,0(sp)
+ 89e: 6121 addi sp,sp,64
+ 8a0: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 8a2: 6398 ld a4,0(a5)
+ 8a4: e118 sd a4,0(a0)
+ 8a6: bff1 j 882 <malloc+0x8c>
+ hp->s.size = nu;
+ 8a8: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 8ac: 0541 addi a0,a0,16
+ 8ae: 00000097 auipc ra,0x0
+ 8b2: ec6080e7 jalr -314(ra) # 774 <free>
+ return freep;
+ 8b6: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 8ba: d971 beqz a0,88e <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 8bc: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 8be: 4798 lw a4,8(a5)
+ 8c0: fa9775e3 bgeu a4,s1,86a <malloc+0x74>
+ if(p == freep)
+ 8c4: 00093703 ld a4,0(s2)
+ 8c8: 853e mv a0,a5
+ 8ca: fef719e3 bne a4,a5,8bc <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 8ce: 854e mv a0,s3
+ 8d0: 00000097 auipc ra,0x0
+ 8d4: b30080e7 jalr -1232(ra) # 400 <sbrk>
+ if(p == (char*)-1)
+ 8d8: fd5518e3 bne a0,s5,8a8 <malloc+0xb2>
+ return 0;
+ 8dc: 4501 li a0,0
+ 8de: bf45 j 88e <malloc+0x98>
diff --git a/xv6-user/strace.c b/xv6-user/strace.c
new file mode 100644
index 0000000000000000000000000000000000000000..95db9b7f23c94e013c6b6b43068c2f80fc0ec705
--- /dev/null
+++ b/xv6-user/strace.c
@@ -0,0 +1,28 @@
+#include "kernel/include/param.h"
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+ char *nargv[MAXARG];
+
+ if(argc < 3 /*|| (argv[1][0] < '0' || argv[1][0] > '9')*/){
+ fprintf(2, "usage: %s MASK COMMAND\n", argv[0]);
+ exit(1);
+ }
+
+ if (trace(atoi(argv[1])) < 0) {
+ fprintf(2, "%s: strace failed\n", argv[0]);
+ exit(1);
+ }
+
+ for(i = 2; i < argc && i < MAXARG; i++){
+ nargv[i-2] = argv[i];
+ }
+ exec(nargv[0], nargv);
+ printf("strace: exec %s fail\n", nargv[0]);
+ exit(0);
+}
diff --git a/xv6-user/strace.d b/xv6-user/strace.d
new file mode 100644
index 0000000000000000000000000000000000000000..45b4ee751d0d69a9c4948160bc4ddf6405daab92
--- /dev/null
+++ b/xv6-user/strace.d
@@ -0,0 +1,3 @@
+xv6-user/strace.o: xv6-user/strace.c kernel/include/param.h \
+ kernel/include/types.h kernel/include/stat.h xv6-user/user.h \
+ kernel/include/fcntl.h
diff --git a/xv6-user/strace.o b/xv6-user/strace.o
new file mode 100644
index 0000000000000000000000000000000000000000..a4a69b2504f0110d7678d77ebb8753248bd033a2
Binary files /dev/null and b/xv6-user/strace.o differ
diff --git a/xv6-user/strace.sym b/xv6-user/strace.sym
new file mode 100644
index 0000000000000000000000000000000000000000..83ec1cc8a1e3125025f0c4eb665e214f71ad46c4
--- /dev/null
+++ b/xv6-user/strace.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+00000000000008e0 .rodata
+00000000000009a0 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 strace.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000466 putc
+0000000000000488 printint
+0000000000000988 digits
+0000000000000000 umalloc.c
+00000000000009a0 freep
+00000000000009a8 base
+00000000000000c2 strcpy
+000000000000073e printf
+0000000000001199 __global_pointer$
+0000000000000420 dev
+00000000000002c8 memmove
+0000000000000444 trace
+00000000000001a8 gets
+0000000000000999 __SDATA_BEGIN__
+00000000000003f6 getpid
+000000000000035a memcpy
+00000000000007f6 malloc
+000000000000043a remove
+0000000000000408 sleep
+000000000000044c sysinfo
+000000000000042a readdir
+000000000000038c pipe
+0000000000000454 rename
+00000000000003a0 write
+00000000000003d0 fstat
+0000000000000710 fprintf
+00000000000003b4 kill
+00000000000000de strcat
+0000000000000532 vprintf
+00000000000003e4 chdir
+00000000000003bc exec
+0000000000000384 wait
+0000000000000396 read
+0000000000000320 memcmp
+0000000000000372 fork
+00000000000009b8 __BSS_END__
+0000000000000400 sbrk
+0000000000000418 test_proc
+0000000000000410 uptime
+0000000000000999 __bss_start
+0000000000000162 memset
+0000000000000000 main
+000000000000010c strcmp
+000000000000045c shutdown
+00000000000003ee dup
+0000000000000432 getcwd
+0000000000000999 __DATA_BEGIN__
+0000000000000222 stat
+0000000000000999 _edata
+00000000000009b8 _end
+000000000000037a exit
+0000000000000268 atoi
+0000000000000138 strlen
+00000000000003c6 open
+0000000000000184 strchr
+00000000000003da mkdir
+00000000000003aa close
+0000000000000774 free
diff --git a/xv6-user/stressfs.c b/xv6-user/stressfs.c
new file mode 100644
index 0000000000000000000000000000000000000000..f2c7d99e4b28c3ccd80cf07d9f73ad3f64745301
--- /dev/null
+++ b/xv6-user/stressfs.c
@@ -0,0 +1,49 @@
+// Demonstrate that moving the "acquire" in iderw after the loop that
+// appends to the idequeue results in a race.
+
+// For this to work, you should also add a spin within iderw's
+// idequeue traversal loop. Adding the following demonstrated a panic
+// after about 5 runs of stressfs in QEMU on a 2.1GHz CPU:
+// for (i = 0; i < 40000; i++)
+// asm volatile("");
+
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+#include "kernel/include/fs.h"
+#include "kernel/include/fcntl.h"
+
+int
+main(int argc, char *argv[])
+{
+ int fd, i;
+ char path[] = "stressfs0";
+ char data[512];
+
+ printf("stressfs starting\n");
+ memset(data, 'a', sizeof(data));
+
+ for(i = 0; i < 4; i++)
+ if(fork() > 0)
+ break;
+
+ printf("write %d\n", i);
+
+ path[8] += i;
+ fd = open(path, O_CREATE | O_RDWR);
+ for(i = 0; i < 20; i++)
+// printf(fd, "%d\n", i);
+ write(fd, data, sizeof(data));
+ close(fd);
+
+ printf("read\n");
+
+ fd = open(path, O_RDONLY);
+ for (i = 0; i < 20; i++)
+ read(fd, data, sizeof(data));
+ close(fd);
+
+ wait(0);
+
+ exit(0);
+}
diff --git a/xv6-user/sysinfo.asm b/xv6-user/sysinfo.asm
new file mode 100644
index 0000000000000000000000000000000000000000..641ab432f14938a3b946019edae97f6173008deb
--- /dev/null
+++ b/xv6-user/sysinfo.asm
@@ -0,0 +1,1427 @@
+
+xv6-user/_sysinfo: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/fcntl.h"
+#include "kernel/include/types.h"
+#include "kernel/include/sysinfo.h"
+#include "xv6-user/user.h"
+
+int main() {
+ 0: 1101 addi sp,sp,-32
+ 2: ec06 sd ra,24(sp)
+ 4: e822 sd s0,16(sp)
+ 6: 1000 addi s0,sp,32
+ struct sysinfo info;
+ int a = sysinfo(&info);
+ 8: fe040513 addi a0,s0,-32
+ c: 00000097 auipc ra,0x0
+ 10: 3d6080e7 jalr 982(ra) # 3e2 <sysinfo>
+ 14: 85aa mv a1,a0
+ printf("sysinfo ret code: %d\n", a);
+ 16: 00001517 auipc a0,0x1
+ 1a: 86250513 addi a0,a0,-1950 # 878 <malloc+0xec>
+ 1e: 00000097 auipc ra,0x0
+ 22: 6b6080e7 jalr 1718(ra) # 6d4 <printf>
+ printf("info.freemem: %d\n", info.freemem);
+ 26: fe043583 ld a1,-32(s0)
+ 2a: 00001517 auipc a0,0x1
+ 2e: 86650513 addi a0,a0,-1946 # 890 <malloc+0x104>
+ 32: 00000097 auipc ra,0x0
+ 36: 6a2080e7 jalr 1698(ra) # 6d4 <printf>
+ printf("info.nproc: %d\n", info.nproc);
+ 3a: fe843583 ld a1,-24(s0)
+ 3e: 00001517 auipc a0,0x1
+ 42: 86a50513 addi a0,a0,-1942 # 8a8 <malloc+0x11c>
+ 46: 00000097 auipc ra,0x0
+ 4a: 68e080e7 jalr 1678(ra) # 6d4 <printf>
+ return 0;
+ 4e: 4501 li a0,0
+ 50: 60e2 ld ra,24(sp)
+ 52: 6442 ld s0,16(sp)
+ 54: 6105 addi sp,sp,32
+ 56: 8082 ret
+
+0000000000000058 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 58: 1141 addi sp,sp,-16
+ 5a: e422 sd s0,8(sp)
+ 5c: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 5e: 87aa mv a5,a0
+ 60: 0585 addi a1,a1,1
+ 62: 0785 addi a5,a5,1
+ 64: fff5c703 lbu a4,-1(a1)
+ 68: fee78fa3 sb a4,-1(a5)
+ 6c: fb75 bnez a4,60 <strcpy+0x8>
+ ;
+ return os;
+}
+ 6e: 6422 ld s0,8(sp)
+ 70: 0141 addi sp,sp,16
+ 72: 8082 ret
+
+0000000000000074 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 74: 1141 addi sp,sp,-16
+ 76: e422 sd s0,8(sp)
+ 78: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 7a: 00054783 lbu a5,0(a0)
+ 7e: c385 beqz a5,9e <strcat+0x2a>
+ 80: 87aa mv a5,a0
+ s++;
+ 82: 0785 addi a5,a5,1
+ while(*s)
+ 84: 0007c703 lbu a4,0(a5)
+ 88: ff6d bnez a4,82 <strcat+0xe>
+ while((*s++ = *t++))
+ 8a: 0585 addi a1,a1,1
+ 8c: 0785 addi a5,a5,1
+ 8e: fff5c703 lbu a4,-1(a1)
+ 92: fee78fa3 sb a4,-1(a5)
+ 96: fb75 bnez a4,8a <strcat+0x16>
+ ;
+ return os;
+}
+ 98: 6422 ld s0,8(sp)
+ 9a: 0141 addi sp,sp,16
+ 9c: 8082 ret
+ while(*s)
+ 9e: 87aa mv a5,a0
+ a0: b7ed j 8a <strcat+0x16>
+
+00000000000000a2 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ a2: 1141 addi sp,sp,-16
+ a4: e422 sd s0,8(sp)
+ a6: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ a8: 00054783 lbu a5,0(a0)
+ ac: cb91 beqz a5,c0 <strcmp+0x1e>
+ ae: 0005c703 lbu a4,0(a1)
+ b2: 00f71763 bne a4,a5,c0 <strcmp+0x1e>
+ p++, q++;
+ b6: 0505 addi a0,a0,1
+ b8: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ ba: 00054783 lbu a5,0(a0)
+ be: fbe5 bnez a5,ae <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ c0: 0005c503 lbu a0,0(a1)
+}
+ c4: 40a7853b subw a0,a5,a0
+ c8: 6422 ld s0,8(sp)
+ ca: 0141 addi sp,sp,16
+ cc: 8082 ret
+
+00000000000000ce <strlen>:
+
+uint
+strlen(const char *s)
+{
+ ce: 1141 addi sp,sp,-16
+ d0: e422 sd s0,8(sp)
+ d2: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ d4: 00054783 lbu a5,0(a0)
+ d8: cf91 beqz a5,f4 <strlen+0x26>
+ da: 0505 addi a0,a0,1
+ dc: 87aa mv a5,a0
+ de: 4685 li a3,1
+ e0: 9e89 subw a3,a3,a0
+ e2: 00f6853b addw a0,a3,a5
+ e6: 0785 addi a5,a5,1
+ e8: fff7c703 lbu a4,-1(a5)
+ ec: fb7d bnez a4,e2 <strlen+0x14>
+ ;
+ return n;
+}
+ ee: 6422 ld s0,8(sp)
+ f0: 0141 addi sp,sp,16
+ f2: 8082 ret
+ for(n = 0; s[n]; n++)
+ f4: 4501 li a0,0
+ f6: bfe5 j ee <strlen+0x20>
+
+00000000000000f8 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ f8: 1141 addi sp,sp,-16
+ fa: e422 sd s0,8(sp)
+ fc: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ fe: ca19 beqz a2,114 <memset+0x1c>
+ 100: 87aa mv a5,a0
+ 102: 1602 slli a2,a2,0x20
+ 104: 9201 srli a2,a2,0x20
+ 106: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 10a: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 10e: 0785 addi a5,a5,1
+ 110: fee79de3 bne a5,a4,10a <memset+0x12>
+ }
+ return dst;
+}
+ 114: 6422 ld s0,8(sp)
+ 116: 0141 addi sp,sp,16
+ 118: 8082 ret
+
+000000000000011a <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 11a: 1141 addi sp,sp,-16
+ 11c: e422 sd s0,8(sp)
+ 11e: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 120: 00054783 lbu a5,0(a0)
+ 124: cb99 beqz a5,13a <strchr+0x20>
+ if(*s == c)
+ 126: 00f58763 beq a1,a5,134 <strchr+0x1a>
+ for(; *s; s++)
+ 12a: 0505 addi a0,a0,1
+ 12c: 00054783 lbu a5,0(a0)
+ 130: fbfd bnez a5,126 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 132: 4501 li a0,0
+}
+ 134: 6422 ld s0,8(sp)
+ 136: 0141 addi sp,sp,16
+ 138: 8082 ret
+ return 0;
+ 13a: 4501 li a0,0
+ 13c: bfe5 j 134 <strchr+0x1a>
+
+000000000000013e <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 13e: 711d addi sp,sp,-96
+ 140: ec86 sd ra,88(sp)
+ 142: e8a2 sd s0,80(sp)
+ 144: e4a6 sd s1,72(sp)
+ 146: e0ca sd s2,64(sp)
+ 148: fc4e sd s3,56(sp)
+ 14a: f852 sd s4,48(sp)
+ 14c: f456 sd s5,40(sp)
+ 14e: f05a sd s6,32(sp)
+ 150: ec5e sd s7,24(sp)
+ 152: e862 sd s8,16(sp)
+ 154: 1080 addi s0,sp,96
+ 156: 8baa mv s7,a0
+ 158: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 15a: 892a mv s2,a0
+ 15c: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 15e: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 162: 4b29 li s6,10
+ 164: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 166: 89a6 mv s3,s1
+ 168: 2485 addiw s1,s1,1
+ 16a: 0344d763 bge s1,s4,198 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 16e: 4605 li a2,1
+ 170: 85d6 mv a1,s5
+ 172: 4501 li a0,0
+ 174: 00000097 auipc ra,0x0
+ 178: 1b8080e7 jalr 440(ra) # 32c <read>
+ if(cc < 1)
+ 17c: 00a05e63 blez a0,198 <gets+0x5a>
+ buf[i++] = c;
+ 180: faf44783 lbu a5,-81(s0)
+ 184: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 188: 01678763 beq a5,s6,196 <gets+0x58>
+ 18c: 0905 addi s2,s2,1
+ 18e: fd879ce3 bne a5,s8,166 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 192: 89a6 mv s3,s1
+ 194: a011 j 198 <gets+0x5a>
+ 196: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 198: 99de add s3,s3,s7
+ 19a: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 19e: 855e mv a0,s7
+ 1a0: 60e6 ld ra,88(sp)
+ 1a2: 6446 ld s0,80(sp)
+ 1a4: 64a6 ld s1,72(sp)
+ 1a6: 6906 ld s2,64(sp)
+ 1a8: 79e2 ld s3,56(sp)
+ 1aa: 7a42 ld s4,48(sp)
+ 1ac: 7aa2 ld s5,40(sp)
+ 1ae: 7b02 ld s6,32(sp)
+ 1b0: 6be2 ld s7,24(sp)
+ 1b2: 6c42 ld s8,16(sp)
+ 1b4: 6125 addi sp,sp,96
+ 1b6: 8082 ret
+
+00000000000001b8 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1b8: 1101 addi sp,sp,-32
+ 1ba: ec06 sd ra,24(sp)
+ 1bc: e822 sd s0,16(sp)
+ 1be: e426 sd s1,8(sp)
+ 1c0: e04a sd s2,0(sp)
+ 1c2: 1000 addi s0,sp,32
+ 1c4: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1c6: 4581 li a1,0
+ 1c8: 00000097 auipc ra,0x0
+ 1cc: 194080e7 jalr 404(ra) # 35c <open>
+ if(fd < 0)
+ 1d0: 02054563 bltz a0,1fa <stat+0x42>
+ 1d4: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1d6: 85ca mv a1,s2
+ 1d8: 00000097 auipc ra,0x0
+ 1dc: 18e080e7 jalr 398(ra) # 366 <fstat>
+ 1e0: 892a mv s2,a0
+ close(fd);
+ 1e2: 8526 mv a0,s1
+ 1e4: 00000097 auipc ra,0x0
+ 1e8: 15c080e7 jalr 348(ra) # 340 <close>
+ return r;
+}
+ 1ec: 854a mv a0,s2
+ 1ee: 60e2 ld ra,24(sp)
+ 1f0: 6442 ld s0,16(sp)
+ 1f2: 64a2 ld s1,8(sp)
+ 1f4: 6902 ld s2,0(sp)
+ 1f6: 6105 addi sp,sp,32
+ 1f8: 8082 ret
+ return -1;
+ 1fa: 597d li s2,-1
+ 1fc: bfc5 j 1ec <stat+0x34>
+
+00000000000001fe <atoi>:
+
+int
+atoi(const char *s)
+{
+ 1fe: 1141 addi sp,sp,-16
+ 200: e422 sd s0,8(sp)
+ 202: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 204: 00054703 lbu a4,0(a0)
+ 208: 02d00793 li a5,45
+ int neg = 1;
+ 20c: 4585 li a1,1
+ if (*s == '-') {
+ 20e: 04f70363 beq a4,a5,254 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 212: 00054703 lbu a4,0(a0)
+ 216: fd07079b addiw a5,a4,-48
+ 21a: 0ff7f793 zext.b a5,a5
+ 21e: 46a5 li a3,9
+ 220: 02f6ed63 bltu a3,a5,25a <atoi+0x5c>
+ n = 0;
+ 224: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 226: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 228: 0505 addi a0,a0,1
+ 22a: 0026979b slliw a5,a3,0x2
+ 22e: 9fb5 addw a5,a5,a3
+ 230: 0017979b slliw a5,a5,0x1
+ 234: 9fb9 addw a5,a5,a4
+ 236: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 23a: 00054703 lbu a4,0(a0)
+ 23e: fd07079b addiw a5,a4,-48
+ 242: 0ff7f793 zext.b a5,a5
+ 246: fef671e3 bgeu a2,a5,228 <atoi+0x2a>
+ return n * neg;
+}
+ 24a: 02d5853b mulw a0,a1,a3
+ 24e: 6422 ld s0,8(sp)
+ 250: 0141 addi sp,sp,16
+ 252: 8082 ret
+ s++;
+ 254: 0505 addi a0,a0,1
+ neg = -1;
+ 256: 55fd li a1,-1
+ 258: bf6d j 212 <atoi+0x14>
+ n = 0;
+ 25a: 4681 li a3,0
+ 25c: b7fd j 24a <atoi+0x4c>
+
+000000000000025e <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 25e: 1141 addi sp,sp,-16
+ 260: e422 sd s0,8(sp)
+ 262: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 264: 02b57463 bgeu a0,a1,28c <memmove+0x2e>
+ while(n-- > 0)
+ 268: 00c05f63 blez a2,286 <memmove+0x28>
+ 26c: 1602 slli a2,a2,0x20
+ 26e: 9201 srli a2,a2,0x20
+ 270: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 274: 872a mv a4,a0
+ *dst++ = *src++;
+ 276: 0585 addi a1,a1,1
+ 278: 0705 addi a4,a4,1
+ 27a: fff5c683 lbu a3,-1(a1)
+ 27e: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 282: fee79ae3 bne a5,a4,276 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 286: 6422 ld s0,8(sp)
+ 288: 0141 addi sp,sp,16
+ 28a: 8082 ret
+ dst += n;
+ 28c: 00c50733 add a4,a0,a2
+ src += n;
+ 290: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 292: fec05ae3 blez a2,286 <memmove+0x28>
+ 296: fff6079b addiw a5,a2,-1
+ 29a: 1782 slli a5,a5,0x20
+ 29c: 9381 srli a5,a5,0x20
+ 29e: fff7c793 not a5,a5
+ 2a2: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2a4: 15fd addi a1,a1,-1
+ 2a6: 177d addi a4,a4,-1
+ 2a8: 0005c683 lbu a3,0(a1)
+ 2ac: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2b0: fee79ae3 bne a5,a4,2a4 <memmove+0x46>
+ 2b4: bfc9 j 286 <memmove+0x28>
+
+00000000000002b6 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2b6: 1141 addi sp,sp,-16
+ 2b8: e422 sd s0,8(sp)
+ 2ba: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2bc: ca05 beqz a2,2ec <memcmp+0x36>
+ 2be: fff6069b addiw a3,a2,-1
+ 2c2: 1682 slli a3,a3,0x20
+ 2c4: 9281 srli a3,a3,0x20
+ 2c6: 0685 addi a3,a3,1
+ 2c8: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2ca: 00054783 lbu a5,0(a0)
+ 2ce: 0005c703 lbu a4,0(a1)
+ 2d2: 00e79863 bne a5,a4,2e2 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2d6: 0505 addi a0,a0,1
+ p2++;
+ 2d8: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2da: fed518e3 bne a0,a3,2ca <memcmp+0x14>
+ }
+ return 0;
+ 2de: 4501 li a0,0
+ 2e0: a019 j 2e6 <memcmp+0x30>
+ return *p1 - *p2;
+ 2e2: 40e7853b subw a0,a5,a4
+}
+ 2e6: 6422 ld s0,8(sp)
+ 2e8: 0141 addi sp,sp,16
+ 2ea: 8082 ret
+ return 0;
+ 2ec: 4501 li a0,0
+ 2ee: bfe5 j 2e6 <memcmp+0x30>
+
+00000000000002f0 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 2f0: 1141 addi sp,sp,-16
+ 2f2: e406 sd ra,8(sp)
+ 2f4: e022 sd s0,0(sp)
+ 2f6: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 2f8: 00000097 auipc ra,0x0
+ 2fc: f66080e7 jalr -154(ra) # 25e <memmove>
+}
+ 300: 60a2 ld ra,8(sp)
+ 302: 6402 ld s0,0(sp)
+ 304: 0141 addi sp,sp,16
+ 306: 8082 ret
+
+0000000000000308 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 308: 4885 li a7,1
+ ecall
+ 30a: 00000073 ecall
+ ret
+ 30e: 8082 ret
+
+0000000000000310 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 310: 05d00893 li a7,93
+ ecall
+ 314: 00000073 ecall
+ ret
+ 318: 8082 ret
+
+000000000000031a <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 31a: 488d li a7,3
+ ecall
+ 31c: 00000073 ecall
+ ret
+ 320: 8082 ret
+
+0000000000000322 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 322: 03b00893 li a7,59
+ ecall
+ 326: 00000073 ecall
+ ret
+ 32a: 8082 ret
+
+000000000000032c <read>:
+.global read
+read:
+ li a7, SYS_read
+ 32c: 03f00893 li a7,63
+ ecall
+ 330: 00000073 ecall
+ ret
+ 334: 8082 ret
+
+0000000000000336 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 336: 04000893 li a7,64
+ ecall
+ 33a: 00000073 ecall
+ ret
+ 33e: 8082 ret
+
+0000000000000340 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 340: 03900893 li a7,57
+ ecall
+ 344: 00000073 ecall
+ ret
+ 348: 8082 ret
+
+000000000000034a <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 34a: 4899 li a7,6
+ ecall
+ 34c: 00000073 ecall
+ ret
+ 350: 8082 ret
+
+0000000000000352 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 352: 0dd00893 li a7,221
+ ecall
+ 356: 00000073 ecall
+ ret
+ 35a: 8082 ret
+
+000000000000035c <open>:
+.global open
+open:
+ li a7, SYS_open
+ 35c: 03800893 li a7,56
+ ecall
+ 360: 00000073 ecall
+ ret
+ 364: 8082 ret
+
+0000000000000366 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 366: 05000893 li a7,80
+ ecall
+ 36a: 00000073 ecall
+ ret
+ 36e: 8082 ret
+
+0000000000000370 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 370: 02200893 li a7,34
+ ecall
+ 374: 00000073 ecall
+ ret
+ 378: 8082 ret
+
+000000000000037a <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 37a: 03100893 li a7,49
+ ecall
+ 37e: 00000073 ecall
+ ret
+ 382: 8082 ret
+
+0000000000000384 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 384: 48dd li a7,23
+ ecall
+ 386: 00000073 ecall
+ ret
+ 38a: 8082 ret
+
+000000000000038c <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 38c: 0ac00893 li a7,172
+ ecall
+ 390: 00000073 ecall
+ ret
+ 394: 8082 ret
+
+0000000000000396 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 396: 48b1 li a7,12
+ ecall
+ 398: 00000073 ecall
+ ret
+ 39c: 8082 ret
+
+000000000000039e <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 39e: 48b5 li a7,13
+ ecall
+ 3a0: 00000073 ecall
+ ret
+ 3a4: 8082 ret
+
+00000000000003a6 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3a6: 48b9 li a7,14
+ ecall
+ 3a8: 00000073 ecall
+ ret
+ 3ac: 8082 ret
+
+00000000000003ae <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3ae: 48d9 li a7,22
+ ecall
+ 3b0: 00000073 ecall
+ ret
+ 3b4: 8082 ret
+
+00000000000003b6 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3b6: 03200893 li a7,50
+ ecall
+ 3ba: 00000073 ecall
+ ret
+ 3be: 8082 ret
+
+00000000000003c0 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3c0: 48ed li a7,27
+ ecall
+ 3c2: 00000073 ecall
+ ret
+ 3c6: 8082 ret
+
+00000000000003c8 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3c8: 48c5 li a7,17
+ ecall
+ 3ca: 00000073 ecall
+ ret
+ 3ce: 8082 ret
+
+00000000000003d0 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3d0: 07500893 li a7,117
+ ecall
+ 3d4: 00000073 ecall
+ ret
+ 3d8: 8082 ret
+
+00000000000003da <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3da: 48c9 li a7,18
+ ecall
+ 3dc: 00000073 ecall
+ ret
+ 3e0: 8082 ret
+
+00000000000003e2 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 3e2: 48cd li a7,19
+ ecall
+ 3e4: 00000073 ecall
+ ret
+ 3e8: 8082 ret
+
+00000000000003ea <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 3ea: 48e9 li a7,26
+ ecall
+ 3ec: 00000073 ecall
+ ret
+ 3f0: 8082 ret
+
+00000000000003f2 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 3f2: 0d200893 li a7,210
+ ecall
+ 3f6: 00000073 ecall
+ ret
+ 3fa: 8082 ret
+
+00000000000003fc <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 3fc: 1101 addi sp,sp,-32
+ 3fe: ec06 sd ra,24(sp)
+ 400: e822 sd s0,16(sp)
+ 402: 1000 addi s0,sp,32
+ 404: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 408: 4605 li a2,1
+ 40a: fef40593 addi a1,s0,-17
+ 40e: 00000097 auipc ra,0x0
+ 412: f28080e7 jalr -216(ra) # 336 <write>
+}
+ 416: 60e2 ld ra,24(sp)
+ 418: 6442 ld s0,16(sp)
+ 41a: 6105 addi sp,sp,32
+ 41c: 8082 ret
+
+000000000000041e <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 41e: 7139 addi sp,sp,-64
+ 420: fc06 sd ra,56(sp)
+ 422: f822 sd s0,48(sp)
+ 424: f426 sd s1,40(sp)
+ 426: f04a sd s2,32(sp)
+ 428: ec4e sd s3,24(sp)
+ 42a: 0080 addi s0,sp,64
+ 42c: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 42e: c299 beqz a3,434 <printint+0x16>
+ 430: 0805c863 bltz a1,4c0 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 434: 2581 sext.w a1,a1
+ neg = 0;
+ 436: 4881 li a7,0
+ }
+
+ i = 0;
+ 438: fc040993 addi s3,s0,-64
+ neg = 0;
+ 43c: 86ce mv a3,s3
+ i = 0;
+ 43e: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 440: 2601 sext.w a2,a2
+ 442: 00000517 auipc a0,0x0
+ 446: 4d650513 addi a0,a0,1238 # 918 <digits>
+ 44a: 883a mv a6,a4
+ 44c: 2705 addiw a4,a4,1
+ 44e: 02c5f7bb remuw a5,a1,a2
+ 452: 1782 slli a5,a5,0x20
+ 454: 9381 srli a5,a5,0x20
+ 456: 97aa add a5,a5,a0
+ 458: 0007c783 lbu a5,0(a5)
+ 45c: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 460: 0005879b sext.w a5,a1
+ 464: 02c5d5bb divuw a1,a1,a2
+ 468: 0685 addi a3,a3,1
+ 46a: fec7f0e3 bgeu a5,a2,44a <printint+0x2c>
+ if(neg)
+ 46e: 00088c63 beqz a7,486 <printint+0x68>
+ buf[i++] = '-';
+ 472: fd070793 addi a5,a4,-48
+ 476: 00878733 add a4,a5,s0
+ 47a: 02d00793 li a5,45
+ 47e: fef70823 sb a5,-16(a4)
+ 482: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 486: 02e05663 blez a4,4b2 <printint+0x94>
+ 48a: fc040913 addi s2,s0,-64
+ 48e: 993a add s2,s2,a4
+ 490: 19fd addi s3,s3,-1
+ 492: 99ba add s3,s3,a4
+ 494: 377d addiw a4,a4,-1
+ 496: 1702 slli a4,a4,0x20
+ 498: 9301 srli a4,a4,0x20
+ 49a: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 49e: fff94583 lbu a1,-1(s2)
+ 4a2: 8526 mv a0,s1
+ 4a4: 00000097 auipc ra,0x0
+ 4a8: f58080e7 jalr -168(ra) # 3fc <putc>
+ while(--i >= 0)
+ 4ac: 197d addi s2,s2,-1
+ 4ae: ff3918e3 bne s2,s3,49e <printint+0x80>
+}
+ 4b2: 70e2 ld ra,56(sp)
+ 4b4: 7442 ld s0,48(sp)
+ 4b6: 74a2 ld s1,40(sp)
+ 4b8: 7902 ld s2,32(sp)
+ 4ba: 69e2 ld s3,24(sp)
+ 4bc: 6121 addi sp,sp,64
+ 4be: 8082 ret
+ x = -xx;
+ 4c0: 40b005bb negw a1,a1
+ neg = 1;
+ 4c4: 4885 li a7,1
+ x = -xx;
+ 4c6: bf8d j 438 <printint+0x1a>
+
+00000000000004c8 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4c8: 7119 addi sp,sp,-128
+ 4ca: fc86 sd ra,120(sp)
+ 4cc: f8a2 sd s0,112(sp)
+ 4ce: f4a6 sd s1,104(sp)
+ 4d0: f0ca sd s2,96(sp)
+ 4d2: ecce sd s3,88(sp)
+ 4d4: e8d2 sd s4,80(sp)
+ 4d6: e4d6 sd s5,72(sp)
+ 4d8: e0da sd s6,64(sp)
+ 4da: fc5e sd s7,56(sp)
+ 4dc: f862 sd s8,48(sp)
+ 4de: f466 sd s9,40(sp)
+ 4e0: f06a sd s10,32(sp)
+ 4e2: ec6e sd s11,24(sp)
+ 4e4: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 4e6: 0005c903 lbu s2,0(a1)
+ 4ea: 18090f63 beqz s2,688 <vprintf+0x1c0>
+ 4ee: 8aaa mv s5,a0
+ 4f0: 8b32 mv s6,a2
+ 4f2: 00158493 addi s1,a1,1
+ state = 0;
+ 4f6: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 4f8: 02500a13 li s4,37
+ 4fc: 4c55 li s8,21
+ 4fe: 00000c97 auipc s9,0x0
+ 502: 3c2c8c93 addi s9,s9,962 # 8c0 <malloc+0x134>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 506: 02800d93 li s11,40
+ putc(fd, 'x');
+ 50a: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 50c: 00000b97 auipc s7,0x0
+ 510: 40cb8b93 addi s7,s7,1036 # 918 <digits>
+ 514: a839 j 532 <vprintf+0x6a>
+ putc(fd, c);
+ 516: 85ca mv a1,s2
+ 518: 8556 mv a0,s5
+ 51a: 00000097 auipc ra,0x0
+ 51e: ee2080e7 jalr -286(ra) # 3fc <putc>
+ 522: a019 j 528 <vprintf+0x60>
+ } else if(state == '%'){
+ 524: 01498d63 beq s3,s4,53e <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 528: 0485 addi s1,s1,1
+ 52a: fff4c903 lbu s2,-1(s1)
+ 52e: 14090d63 beqz s2,688 <vprintf+0x1c0>
+ if(state == 0){
+ 532: fe0999e3 bnez s3,524 <vprintf+0x5c>
+ if(c == '%'){
+ 536: ff4910e3 bne s2,s4,516 <vprintf+0x4e>
+ state = '%';
+ 53a: 89d2 mv s3,s4
+ 53c: b7f5 j 528 <vprintf+0x60>
+ if(c == 'd'){
+ 53e: 11490c63 beq s2,s4,656 <vprintf+0x18e>
+ 542: f9d9079b addiw a5,s2,-99
+ 546: 0ff7f793 zext.b a5,a5
+ 54a: 10fc6e63 bltu s8,a5,666 <vprintf+0x19e>
+ 54e: f9d9079b addiw a5,s2,-99
+ 552: 0ff7f713 zext.b a4,a5
+ 556: 10ec6863 bltu s8,a4,666 <vprintf+0x19e>
+ 55a: 00271793 slli a5,a4,0x2
+ 55e: 97e6 add a5,a5,s9
+ 560: 439c lw a5,0(a5)
+ 562: 97e6 add a5,a5,s9
+ 564: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 566: 008b0913 addi s2,s6,8
+ 56a: 4685 li a3,1
+ 56c: 4629 li a2,10
+ 56e: 000b2583 lw a1,0(s6)
+ 572: 8556 mv a0,s5
+ 574: 00000097 auipc ra,0x0
+ 578: eaa080e7 jalr -342(ra) # 41e <printint>
+ 57c: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 57e: 4981 li s3,0
+ 580: b765 j 528 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 582: 008b0913 addi s2,s6,8
+ 586: 4681 li a3,0
+ 588: 4629 li a2,10
+ 58a: 000b2583 lw a1,0(s6)
+ 58e: 8556 mv a0,s5
+ 590: 00000097 auipc ra,0x0
+ 594: e8e080e7 jalr -370(ra) # 41e <printint>
+ 598: 8b4a mv s6,s2
+ state = 0;
+ 59a: 4981 li s3,0
+ 59c: b771 j 528 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 59e: 008b0913 addi s2,s6,8
+ 5a2: 4681 li a3,0
+ 5a4: 866a mv a2,s10
+ 5a6: 000b2583 lw a1,0(s6)
+ 5aa: 8556 mv a0,s5
+ 5ac: 00000097 auipc ra,0x0
+ 5b0: e72080e7 jalr -398(ra) # 41e <printint>
+ 5b4: 8b4a mv s6,s2
+ state = 0;
+ 5b6: 4981 li s3,0
+ 5b8: bf85 j 528 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5ba: 008b0793 addi a5,s6,8
+ 5be: f8f43423 sd a5,-120(s0)
+ 5c2: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5c6: 03000593 li a1,48
+ 5ca: 8556 mv a0,s5
+ 5cc: 00000097 auipc ra,0x0
+ 5d0: e30080e7 jalr -464(ra) # 3fc <putc>
+ putc(fd, 'x');
+ 5d4: 07800593 li a1,120
+ 5d8: 8556 mv a0,s5
+ 5da: 00000097 auipc ra,0x0
+ 5de: e22080e7 jalr -478(ra) # 3fc <putc>
+ 5e2: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5e4: 03c9d793 srli a5,s3,0x3c
+ 5e8: 97de add a5,a5,s7
+ 5ea: 0007c583 lbu a1,0(a5)
+ 5ee: 8556 mv a0,s5
+ 5f0: 00000097 auipc ra,0x0
+ 5f4: e0c080e7 jalr -500(ra) # 3fc <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 5f8: 0992 slli s3,s3,0x4
+ 5fa: 397d addiw s2,s2,-1
+ 5fc: fe0914e3 bnez s2,5e4 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 600: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 604: 4981 li s3,0
+ 606: b70d j 528 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 608: 008b0913 addi s2,s6,8
+ 60c: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 610: 02098163 beqz s3,632 <vprintf+0x16a>
+ while(*s != 0){
+ 614: 0009c583 lbu a1,0(s3)
+ 618: c5ad beqz a1,682 <vprintf+0x1ba>
+ putc(fd, *s);
+ 61a: 8556 mv a0,s5
+ 61c: 00000097 auipc ra,0x0
+ 620: de0080e7 jalr -544(ra) # 3fc <putc>
+ s++;
+ 624: 0985 addi s3,s3,1
+ while(*s != 0){
+ 626: 0009c583 lbu a1,0(s3)
+ 62a: f9e5 bnez a1,61a <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 62c: 8b4a mv s6,s2
+ state = 0;
+ 62e: 4981 li s3,0
+ 630: bde5 j 528 <vprintf+0x60>
+ s = "(null)";
+ 632: 00000997 auipc s3,0x0
+ 636: 28698993 addi s3,s3,646 # 8b8 <malloc+0x12c>
+ while(*s != 0){
+ 63a: 85ee mv a1,s11
+ 63c: bff9 j 61a <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 63e: 008b0913 addi s2,s6,8
+ 642: 000b4583 lbu a1,0(s6)
+ 646: 8556 mv a0,s5
+ 648: 00000097 auipc ra,0x0
+ 64c: db4080e7 jalr -588(ra) # 3fc <putc>
+ 650: 8b4a mv s6,s2
+ state = 0;
+ 652: 4981 li s3,0
+ 654: bdd1 j 528 <vprintf+0x60>
+ putc(fd, c);
+ 656: 85d2 mv a1,s4
+ 658: 8556 mv a0,s5
+ 65a: 00000097 auipc ra,0x0
+ 65e: da2080e7 jalr -606(ra) # 3fc <putc>
+ state = 0;
+ 662: 4981 li s3,0
+ 664: b5d1 j 528 <vprintf+0x60>
+ putc(fd, '%');
+ 666: 85d2 mv a1,s4
+ 668: 8556 mv a0,s5
+ 66a: 00000097 auipc ra,0x0
+ 66e: d92080e7 jalr -622(ra) # 3fc <putc>
+ putc(fd, c);
+ 672: 85ca mv a1,s2
+ 674: 8556 mv a0,s5
+ 676: 00000097 auipc ra,0x0
+ 67a: d86080e7 jalr -634(ra) # 3fc <putc>
+ state = 0;
+ 67e: 4981 li s3,0
+ 680: b565 j 528 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 682: 8b4a mv s6,s2
+ state = 0;
+ 684: 4981 li s3,0
+ 686: b54d j 528 <vprintf+0x60>
+ }
+ }
+}
+ 688: 70e6 ld ra,120(sp)
+ 68a: 7446 ld s0,112(sp)
+ 68c: 74a6 ld s1,104(sp)
+ 68e: 7906 ld s2,96(sp)
+ 690: 69e6 ld s3,88(sp)
+ 692: 6a46 ld s4,80(sp)
+ 694: 6aa6 ld s5,72(sp)
+ 696: 6b06 ld s6,64(sp)
+ 698: 7be2 ld s7,56(sp)
+ 69a: 7c42 ld s8,48(sp)
+ 69c: 7ca2 ld s9,40(sp)
+ 69e: 7d02 ld s10,32(sp)
+ 6a0: 6de2 ld s11,24(sp)
+ 6a2: 6109 addi sp,sp,128
+ 6a4: 8082 ret
+
+00000000000006a6 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6a6: 715d addi sp,sp,-80
+ 6a8: ec06 sd ra,24(sp)
+ 6aa: e822 sd s0,16(sp)
+ 6ac: 1000 addi s0,sp,32
+ 6ae: e010 sd a2,0(s0)
+ 6b0: e414 sd a3,8(s0)
+ 6b2: e818 sd a4,16(s0)
+ 6b4: ec1c sd a5,24(s0)
+ 6b6: 03043023 sd a6,32(s0)
+ 6ba: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6be: 8622 mv a2,s0
+ 6c0: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6c4: 00000097 auipc ra,0x0
+ 6c8: e04080e7 jalr -508(ra) # 4c8 <vprintf>
+}
+ 6cc: 60e2 ld ra,24(sp)
+ 6ce: 6442 ld s0,16(sp)
+ 6d0: 6161 addi sp,sp,80
+ 6d2: 8082 ret
+
+00000000000006d4 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6d4: 711d addi sp,sp,-96
+ 6d6: ec06 sd ra,24(sp)
+ 6d8: e822 sd s0,16(sp)
+ 6da: 1000 addi s0,sp,32
+ 6dc: e40c sd a1,8(s0)
+ 6de: e810 sd a2,16(s0)
+ 6e0: ec14 sd a3,24(s0)
+ 6e2: f018 sd a4,32(s0)
+ 6e4: f41c sd a5,40(s0)
+ 6e6: 03043823 sd a6,48(s0)
+ 6ea: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6ee: 00840613 addi a2,s0,8
+ 6f2: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 6f6: 85aa mv a1,a0
+ 6f8: 4505 li a0,1
+ 6fa: 00000097 auipc ra,0x0
+ 6fe: dce080e7 jalr -562(ra) # 4c8 <vprintf>
+}
+ 702: 60e2 ld ra,24(sp)
+ 704: 6442 ld s0,16(sp)
+ 706: 6125 addi sp,sp,96
+ 708: 8082 ret
+
+000000000000070a <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 70a: 1141 addi sp,sp,-16
+ 70c: e422 sd s0,8(sp)
+ 70e: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 710: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 714: 00000797 auipc a5,0x0
+ 718: 21c7b783 ld a5,540(a5) # 930 <freep>
+ 71c: a02d j 746 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 71e: 4618 lw a4,8(a2)
+ 720: 9f2d addw a4,a4,a1
+ 722: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 726: 6398 ld a4,0(a5)
+ 728: 6310 ld a2,0(a4)
+ 72a: a83d j 768 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 72c: ff852703 lw a4,-8(a0)
+ 730: 9f31 addw a4,a4,a2
+ 732: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 734: ff053683 ld a3,-16(a0)
+ 738: a091 j 77c <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 73a: 6398 ld a4,0(a5)
+ 73c: 00e7e463 bltu a5,a4,744 <free+0x3a>
+ 740: 00e6ea63 bltu a3,a4,754 <free+0x4a>
+{
+ 744: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 746: fed7fae3 bgeu a5,a3,73a <free+0x30>
+ 74a: 6398 ld a4,0(a5)
+ 74c: 00e6e463 bltu a3,a4,754 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 750: fee7eae3 bltu a5,a4,744 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 754: ff852583 lw a1,-8(a0)
+ 758: 6390 ld a2,0(a5)
+ 75a: 02059813 slli a6,a1,0x20
+ 75e: 01c85713 srli a4,a6,0x1c
+ 762: 9736 add a4,a4,a3
+ 764: fae60de3 beq a2,a4,71e <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 768: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 76c: 4790 lw a2,8(a5)
+ 76e: 02061593 slli a1,a2,0x20
+ 772: 01c5d713 srli a4,a1,0x1c
+ 776: 973e add a4,a4,a5
+ 778: fae68ae3 beq a3,a4,72c <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 77c: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 77e: 00000717 auipc a4,0x0
+ 782: 1af73923 sd a5,434(a4) # 930 <freep>
+}
+ 786: 6422 ld s0,8(sp)
+ 788: 0141 addi sp,sp,16
+ 78a: 8082 ret
+
+000000000000078c <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 78c: 7139 addi sp,sp,-64
+ 78e: fc06 sd ra,56(sp)
+ 790: f822 sd s0,48(sp)
+ 792: f426 sd s1,40(sp)
+ 794: f04a sd s2,32(sp)
+ 796: ec4e sd s3,24(sp)
+ 798: e852 sd s4,16(sp)
+ 79a: e456 sd s5,8(sp)
+ 79c: e05a sd s6,0(sp)
+ 79e: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7a0: 02051493 slli s1,a0,0x20
+ 7a4: 9081 srli s1,s1,0x20
+ 7a6: 04bd addi s1,s1,15
+ 7a8: 8091 srli s1,s1,0x4
+ 7aa: 00148a1b addiw s4,s1,1
+ 7ae: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7b0: 00000517 auipc a0,0x0
+ 7b4: 18053503 ld a0,384(a0) # 930 <freep>
+ 7b8: c515 beqz a0,7e4 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7ba: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7bc: 4798 lw a4,8(a5)
+ 7be: 04977163 bgeu a4,s1,800 <malloc+0x74>
+ 7c2: 89d2 mv s3,s4
+ 7c4: 000a071b sext.w a4,s4
+ 7c8: 6685 lui a3,0x1
+ 7ca: 00d77363 bgeu a4,a3,7d0 <malloc+0x44>
+ 7ce: 6985 lui s3,0x1
+ 7d0: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7d4: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7d8: 00000917 auipc s2,0x0
+ 7dc: 15890913 addi s2,s2,344 # 930 <freep>
+ if(p == (char*)-1)
+ 7e0: 5afd li s5,-1
+ 7e2: a8a5 j 85a <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 7e4: 00000797 auipc a5,0x0
+ 7e8: 14c78793 addi a5,a5,332 # 930 <freep>
+ 7ec: 00000717 auipc a4,0x0
+ 7f0: 14c70713 addi a4,a4,332 # 938 <base>
+ 7f4: e398 sd a4,0(a5)
+ 7f6: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 7f8: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7fc: 87ba mv a5,a4
+ 7fe: b7d1 j 7c2 <malloc+0x36>
+ if(p->s.size == nunits)
+ 800: 02e48c63 beq s1,a4,838 <malloc+0xac>
+ p->s.size -= nunits;
+ 804: 4147073b subw a4,a4,s4
+ 808: c798 sw a4,8(a5)
+ p += p->s.size;
+ 80a: 02071693 slli a3,a4,0x20
+ 80e: 01c6d713 srli a4,a3,0x1c
+ 812: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 814: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 818: 00000717 auipc a4,0x0
+ 81c: 10a73c23 sd a0,280(a4) # 930 <freep>
+ return (void*)(p + 1);
+ 820: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 824: 70e2 ld ra,56(sp)
+ 826: 7442 ld s0,48(sp)
+ 828: 74a2 ld s1,40(sp)
+ 82a: 7902 ld s2,32(sp)
+ 82c: 69e2 ld s3,24(sp)
+ 82e: 6a42 ld s4,16(sp)
+ 830: 6aa2 ld s5,8(sp)
+ 832: 6b02 ld s6,0(sp)
+ 834: 6121 addi sp,sp,64
+ 836: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 838: 6398 ld a4,0(a5)
+ 83a: e118 sd a4,0(a0)
+ 83c: bff1 j 818 <malloc+0x8c>
+ hp->s.size = nu;
+ 83e: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 842: 0541 addi a0,a0,16
+ 844: 00000097 auipc ra,0x0
+ 848: ec6080e7 jalr -314(ra) # 70a <free>
+ return freep;
+ 84c: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 850: d971 beqz a0,824 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 852: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 854: 4798 lw a4,8(a5)
+ 856: fa9775e3 bgeu a4,s1,800 <malloc+0x74>
+ if(p == freep)
+ 85a: 00093703 ld a4,0(s2)
+ 85e: 853e mv a0,a5
+ 860: fef719e3 bne a4,a5,852 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 864: 854e mv a0,s3
+ 866: 00000097 auipc ra,0x0
+ 86a: b30080e7 jalr -1232(ra) # 396 <sbrk>
+ if(p == (char*)-1)
+ 86e: fd5518e3 bne a0,s5,83e <malloc+0xb2>
+ return 0;
+ 872: 4501 li a0,0
+ 874: bf45 j 824 <malloc+0x98>
diff --git a/xv6-user/sysinfo.c b/xv6-user/sysinfo.c
new file mode 100644
index 0000000000000000000000000000000000000000..920f7251ccc816a580130beed2c705e67afa9364
--- /dev/null
+++ b/xv6-user/sysinfo.c
@@ -0,0 +1,13 @@
+#include "kernel/include/fcntl.h"
+#include "kernel/include/types.h"
+#include "kernel/include/sysinfo.h"
+#include "xv6-user/user.h"
+
+int main() {
+ struct sysinfo info;
+ int a = sysinfo(&info);
+ printf("sysinfo ret code: %d\n", a);
+ printf("info.freemem: %d\n", info.freemem);
+ printf("info.nproc: %d\n", info.nproc);
+ return 0;
+}
\ No newline at end of file
diff --git a/xv6-user/sysinfo.d b/xv6-user/sysinfo.d
new file mode 100644
index 0000000000000000000000000000000000000000..e8e1d66c2b6419f6f1aac93554d4e310a274d8e9
--- /dev/null
+++ b/xv6-user/sysinfo.d
@@ -0,0 +1,3 @@
+xv6-user/sysinfo.o: xv6-user/sysinfo.c kernel/include/fcntl.h \
+ kernel/include/types.h kernel/include/sysinfo.h kernel/include/types.h \
+ xv6-user/user.h kernel/include/stat.h
diff --git a/xv6-user/sysinfo.o b/xv6-user/sysinfo.o
new file mode 100644
index 0000000000000000000000000000000000000000..cfaaad3a47c2a224f9e280cf7f0ba8760cd09069
Binary files /dev/null and b/xv6-user/sysinfo.o differ
diff --git a/xv6-user/sysinfo.sym b/xv6-user/sysinfo.sym
new file mode 100644
index 0000000000000000000000000000000000000000..de729b0a286c333166b9b9078ec2c1fb8a384a5f
--- /dev/null
+++ b/xv6-user/sysinfo.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+0000000000000878 .rodata
+0000000000000930 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 sysinfo.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000003fc putc
+000000000000041e printint
+0000000000000918 digits
+0000000000000000 umalloc.c
+0000000000000930 freep
+0000000000000938 base
+0000000000000058 strcpy
+00000000000006d4 printf
+0000000000001129 __global_pointer$
+00000000000003b6 dev
+000000000000025e memmove
+00000000000003da trace
+000000000000013e gets
+0000000000000929 __SDATA_BEGIN__
+000000000000038c getpid
+00000000000002f0 memcpy
+000000000000078c malloc
+00000000000003d0 remove
+000000000000039e sleep
+00000000000003e2 sysinfo
+00000000000003c0 readdir
+0000000000000322 pipe
+00000000000003ea rename
+0000000000000336 write
+0000000000000366 fstat
+00000000000006a6 fprintf
+000000000000034a kill
+0000000000000074 strcat
+00000000000004c8 vprintf
+000000000000037a chdir
+0000000000000352 exec
+000000000000031a wait
+000000000000032c read
+00000000000002b6 memcmp
+0000000000000308 fork
+0000000000000948 __BSS_END__
+0000000000000396 sbrk
+00000000000003ae test_proc
+00000000000003a6 uptime
+0000000000000929 __bss_start
+00000000000000f8 memset
+0000000000000000 main
+00000000000000a2 strcmp
+00000000000003f2 shutdown
+0000000000000384 dup
+00000000000003c8 getcwd
+0000000000000929 __DATA_BEGIN__
+00000000000001b8 stat
+0000000000000929 _edata
+0000000000000948 _end
+0000000000000310 exit
+00000000000001fe atoi
+00000000000000ce strlen
+000000000000035c open
+000000000000011a strchr
+0000000000000370 mkdir
+0000000000000340 close
+000000000000070a free
diff --git a/xv6-user/test.asm b/xv6-user/test.asm
new file mode 100644
index 0000000000000000000000000000000000000000..4f2dd1857aa78791af4fe503b094f22c8be663a8
--- /dev/null
+++ b/xv6-user/test.asm
@@ -0,0 +1,1430 @@
+
+xv6-user/_test: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+#include "kernel/include/stat.h"
+#include "kernel/include/sysinfo.h"
+#include "xv6-user/user.h"
+
+int main()
+{
+ 0: 1101 addi sp,sp,-32
+ 2: ec06 sd ra,24(sp)
+ 4: e822 sd s0,16(sp)
+ 6: 1000 addi s0,sp,32
+ struct sysinfo info;
+ if (sysinfo(&info) < 0) {
+ 8: fe040513 addi a0,s0,-32
+ c: 00000097 auipc ra,0x0
+ 10: 3dc080e7 jalr 988(ra) # 3e8 <sysinfo>
+ 14: 02054c63 bltz a0,4c <main+0x4c>
+ printf("sysinfo fail!\n");
+ } else {
+ printf("memory left: %d KB\n", info.freemem >> 10);
+ 18: fe043583 ld a1,-32(s0)
+ 1c: 81a9 srli a1,a1,0xa
+ 1e: 00001517 auipc a0,0x1
+ 22: 87250513 addi a0,a0,-1934 # 890 <malloc+0xfe>
+ 26: 00000097 auipc ra,0x0
+ 2a: 6b4080e7 jalr 1716(ra) # 6da <printf>
+ printf("process amount: %d\n", info.nproc);
+ 2e: fe843583 ld a1,-24(s0)
+ 32: 00001517 auipc a0,0x1
+ 36: 87650513 addi a0,a0,-1930 # 8a8 <malloc+0x116>
+ 3a: 00000097 auipc ra,0x0
+ 3e: 6a0080e7 jalr 1696(ra) # 6da <printf>
+ }
+ exit(0);
+ 42: 4501 li a0,0
+ 44: 00000097 auipc ra,0x0
+ 48: 2d2080e7 jalr 722(ra) # 316 <exit>
+ printf("sysinfo fail!\n");
+ 4c: 00001517 auipc a0,0x1
+ 50: 83450513 addi a0,a0,-1996 # 880 <malloc+0xee>
+ 54: 00000097 auipc ra,0x0
+ 58: 686080e7 jalr 1670(ra) # 6da <printf>
+ 5c: b7dd j 42 <main+0x42>
+
+000000000000005e <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 5e: 1141 addi sp,sp,-16
+ 60: e422 sd s0,8(sp)
+ 62: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 64: 87aa mv a5,a0
+ 66: 0585 addi a1,a1,1
+ 68: 0785 addi a5,a5,1
+ 6a: fff5c703 lbu a4,-1(a1)
+ 6e: fee78fa3 sb a4,-1(a5)
+ 72: fb75 bnez a4,66 <strcpy+0x8>
+ ;
+ return os;
+}
+ 74: 6422 ld s0,8(sp)
+ 76: 0141 addi sp,sp,16
+ 78: 8082 ret
+
+000000000000007a <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 7a: 1141 addi sp,sp,-16
+ 7c: e422 sd s0,8(sp)
+ 7e: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 80: 00054783 lbu a5,0(a0)
+ 84: c385 beqz a5,a4 <strcat+0x2a>
+ 86: 87aa mv a5,a0
+ s++;
+ 88: 0785 addi a5,a5,1
+ while(*s)
+ 8a: 0007c703 lbu a4,0(a5)
+ 8e: ff6d bnez a4,88 <strcat+0xe>
+ while((*s++ = *t++))
+ 90: 0585 addi a1,a1,1
+ 92: 0785 addi a5,a5,1
+ 94: fff5c703 lbu a4,-1(a1)
+ 98: fee78fa3 sb a4,-1(a5)
+ 9c: fb75 bnez a4,90 <strcat+0x16>
+ ;
+ return os;
+}
+ 9e: 6422 ld s0,8(sp)
+ a0: 0141 addi sp,sp,16
+ a2: 8082 ret
+ while(*s)
+ a4: 87aa mv a5,a0
+ a6: b7ed j 90 <strcat+0x16>
+
+00000000000000a8 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ a8: 1141 addi sp,sp,-16
+ aa: e422 sd s0,8(sp)
+ ac: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ ae: 00054783 lbu a5,0(a0)
+ b2: cb91 beqz a5,c6 <strcmp+0x1e>
+ b4: 0005c703 lbu a4,0(a1)
+ b8: 00f71763 bne a4,a5,c6 <strcmp+0x1e>
+ p++, q++;
+ bc: 0505 addi a0,a0,1
+ be: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ c0: 00054783 lbu a5,0(a0)
+ c4: fbe5 bnez a5,b4 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ c6: 0005c503 lbu a0,0(a1)
+}
+ ca: 40a7853b subw a0,a5,a0
+ ce: 6422 ld s0,8(sp)
+ d0: 0141 addi sp,sp,16
+ d2: 8082 ret
+
+00000000000000d4 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ d4: 1141 addi sp,sp,-16
+ d6: e422 sd s0,8(sp)
+ d8: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ da: 00054783 lbu a5,0(a0)
+ de: cf91 beqz a5,fa <strlen+0x26>
+ e0: 0505 addi a0,a0,1
+ e2: 87aa mv a5,a0
+ e4: 4685 li a3,1
+ e6: 9e89 subw a3,a3,a0
+ e8: 00f6853b addw a0,a3,a5
+ ec: 0785 addi a5,a5,1
+ ee: fff7c703 lbu a4,-1(a5)
+ f2: fb7d bnez a4,e8 <strlen+0x14>
+ ;
+ return n;
+}
+ f4: 6422 ld s0,8(sp)
+ f6: 0141 addi sp,sp,16
+ f8: 8082 ret
+ for(n = 0; s[n]; n++)
+ fa: 4501 li a0,0
+ fc: bfe5 j f4 <strlen+0x20>
+
+00000000000000fe <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ fe: 1141 addi sp,sp,-16
+ 100: e422 sd s0,8(sp)
+ 102: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 104: ca19 beqz a2,11a <memset+0x1c>
+ 106: 87aa mv a5,a0
+ 108: 1602 slli a2,a2,0x20
+ 10a: 9201 srli a2,a2,0x20
+ 10c: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 110: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 114: 0785 addi a5,a5,1
+ 116: fee79de3 bne a5,a4,110 <memset+0x12>
+ }
+ return dst;
+}
+ 11a: 6422 ld s0,8(sp)
+ 11c: 0141 addi sp,sp,16
+ 11e: 8082 ret
+
+0000000000000120 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 120: 1141 addi sp,sp,-16
+ 122: e422 sd s0,8(sp)
+ 124: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 126: 00054783 lbu a5,0(a0)
+ 12a: cb99 beqz a5,140 <strchr+0x20>
+ if(*s == c)
+ 12c: 00f58763 beq a1,a5,13a <strchr+0x1a>
+ for(; *s; s++)
+ 130: 0505 addi a0,a0,1
+ 132: 00054783 lbu a5,0(a0)
+ 136: fbfd bnez a5,12c <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 138: 4501 li a0,0
+}
+ 13a: 6422 ld s0,8(sp)
+ 13c: 0141 addi sp,sp,16
+ 13e: 8082 ret
+ return 0;
+ 140: 4501 li a0,0
+ 142: bfe5 j 13a <strchr+0x1a>
+
+0000000000000144 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 144: 711d addi sp,sp,-96
+ 146: ec86 sd ra,88(sp)
+ 148: e8a2 sd s0,80(sp)
+ 14a: e4a6 sd s1,72(sp)
+ 14c: e0ca sd s2,64(sp)
+ 14e: fc4e sd s3,56(sp)
+ 150: f852 sd s4,48(sp)
+ 152: f456 sd s5,40(sp)
+ 154: f05a sd s6,32(sp)
+ 156: ec5e sd s7,24(sp)
+ 158: e862 sd s8,16(sp)
+ 15a: 1080 addi s0,sp,96
+ 15c: 8baa mv s7,a0
+ 15e: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 160: 892a mv s2,a0
+ 162: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 164: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 168: 4b29 li s6,10
+ 16a: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 16c: 89a6 mv s3,s1
+ 16e: 2485 addiw s1,s1,1
+ 170: 0344d763 bge s1,s4,19e <gets+0x5a>
+ cc = read(0, &c, 1);
+ 174: 4605 li a2,1
+ 176: 85d6 mv a1,s5
+ 178: 4501 li a0,0
+ 17a: 00000097 auipc ra,0x0
+ 17e: 1b8080e7 jalr 440(ra) # 332 <read>
+ if(cc < 1)
+ 182: 00a05e63 blez a0,19e <gets+0x5a>
+ buf[i++] = c;
+ 186: faf44783 lbu a5,-81(s0)
+ 18a: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 18e: 01678763 beq a5,s6,19c <gets+0x58>
+ 192: 0905 addi s2,s2,1
+ 194: fd879ce3 bne a5,s8,16c <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 198: 89a6 mv s3,s1
+ 19a: a011 j 19e <gets+0x5a>
+ 19c: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 19e: 99de add s3,s3,s7
+ 1a0: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 1a4: 855e mv a0,s7
+ 1a6: 60e6 ld ra,88(sp)
+ 1a8: 6446 ld s0,80(sp)
+ 1aa: 64a6 ld s1,72(sp)
+ 1ac: 6906 ld s2,64(sp)
+ 1ae: 79e2 ld s3,56(sp)
+ 1b0: 7a42 ld s4,48(sp)
+ 1b2: 7aa2 ld s5,40(sp)
+ 1b4: 7b02 ld s6,32(sp)
+ 1b6: 6be2 ld s7,24(sp)
+ 1b8: 6c42 ld s8,16(sp)
+ 1ba: 6125 addi sp,sp,96
+ 1bc: 8082 ret
+
+00000000000001be <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 1be: 1101 addi sp,sp,-32
+ 1c0: ec06 sd ra,24(sp)
+ 1c2: e822 sd s0,16(sp)
+ 1c4: e426 sd s1,8(sp)
+ 1c6: e04a sd s2,0(sp)
+ 1c8: 1000 addi s0,sp,32
+ 1ca: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 1cc: 4581 li a1,0
+ 1ce: 00000097 auipc ra,0x0
+ 1d2: 194080e7 jalr 404(ra) # 362 <open>
+ if(fd < 0)
+ 1d6: 02054563 bltz a0,200 <stat+0x42>
+ 1da: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 1dc: 85ca mv a1,s2
+ 1de: 00000097 auipc ra,0x0
+ 1e2: 18e080e7 jalr 398(ra) # 36c <fstat>
+ 1e6: 892a mv s2,a0
+ close(fd);
+ 1e8: 8526 mv a0,s1
+ 1ea: 00000097 auipc ra,0x0
+ 1ee: 15c080e7 jalr 348(ra) # 346 <close>
+ return r;
+}
+ 1f2: 854a mv a0,s2
+ 1f4: 60e2 ld ra,24(sp)
+ 1f6: 6442 ld s0,16(sp)
+ 1f8: 64a2 ld s1,8(sp)
+ 1fa: 6902 ld s2,0(sp)
+ 1fc: 6105 addi sp,sp,32
+ 1fe: 8082 ret
+ return -1;
+ 200: 597d li s2,-1
+ 202: bfc5 j 1f2 <stat+0x34>
+
+0000000000000204 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 204: 1141 addi sp,sp,-16
+ 206: e422 sd s0,8(sp)
+ 208: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 20a: 00054703 lbu a4,0(a0)
+ 20e: 02d00793 li a5,45
+ int neg = 1;
+ 212: 4585 li a1,1
+ if (*s == '-') {
+ 214: 04f70363 beq a4,a5,25a <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 218: 00054703 lbu a4,0(a0)
+ 21c: fd07079b addiw a5,a4,-48
+ 220: 0ff7f793 zext.b a5,a5
+ 224: 46a5 li a3,9
+ 226: 02f6ed63 bltu a3,a5,260 <atoi+0x5c>
+ n = 0;
+ 22a: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 22c: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 22e: 0505 addi a0,a0,1
+ 230: 0026979b slliw a5,a3,0x2
+ 234: 9fb5 addw a5,a5,a3
+ 236: 0017979b slliw a5,a5,0x1
+ 23a: 9fb9 addw a5,a5,a4
+ 23c: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 240: 00054703 lbu a4,0(a0)
+ 244: fd07079b addiw a5,a4,-48
+ 248: 0ff7f793 zext.b a5,a5
+ 24c: fef671e3 bgeu a2,a5,22e <atoi+0x2a>
+ return n * neg;
+}
+ 250: 02d5853b mulw a0,a1,a3
+ 254: 6422 ld s0,8(sp)
+ 256: 0141 addi sp,sp,16
+ 258: 8082 ret
+ s++;
+ 25a: 0505 addi a0,a0,1
+ neg = -1;
+ 25c: 55fd li a1,-1
+ 25e: bf6d j 218 <atoi+0x14>
+ n = 0;
+ 260: 4681 li a3,0
+ 262: b7fd j 250 <atoi+0x4c>
+
+0000000000000264 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 264: 1141 addi sp,sp,-16
+ 266: e422 sd s0,8(sp)
+ 268: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 26a: 02b57463 bgeu a0,a1,292 <memmove+0x2e>
+ while(n-- > 0)
+ 26e: 00c05f63 blez a2,28c <memmove+0x28>
+ 272: 1602 slli a2,a2,0x20
+ 274: 9201 srli a2,a2,0x20
+ 276: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 27a: 872a mv a4,a0
+ *dst++ = *src++;
+ 27c: 0585 addi a1,a1,1
+ 27e: 0705 addi a4,a4,1
+ 280: fff5c683 lbu a3,-1(a1)
+ 284: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 288: fee79ae3 bne a5,a4,27c <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 28c: 6422 ld s0,8(sp)
+ 28e: 0141 addi sp,sp,16
+ 290: 8082 ret
+ dst += n;
+ 292: 00c50733 add a4,a0,a2
+ src += n;
+ 296: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 298: fec05ae3 blez a2,28c <memmove+0x28>
+ 29c: fff6079b addiw a5,a2,-1
+ 2a0: 1782 slli a5,a5,0x20
+ 2a2: 9381 srli a5,a5,0x20
+ 2a4: fff7c793 not a5,a5
+ 2a8: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 2aa: 15fd addi a1,a1,-1
+ 2ac: 177d addi a4,a4,-1
+ 2ae: 0005c683 lbu a3,0(a1)
+ 2b2: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 2b6: fee79ae3 bne a5,a4,2aa <memmove+0x46>
+ 2ba: bfc9 j 28c <memmove+0x28>
+
+00000000000002bc <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 2bc: 1141 addi sp,sp,-16
+ 2be: e422 sd s0,8(sp)
+ 2c0: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 2c2: ca05 beqz a2,2f2 <memcmp+0x36>
+ 2c4: fff6069b addiw a3,a2,-1
+ 2c8: 1682 slli a3,a3,0x20
+ 2ca: 9281 srli a3,a3,0x20
+ 2cc: 0685 addi a3,a3,1
+ 2ce: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 2d0: 00054783 lbu a5,0(a0)
+ 2d4: 0005c703 lbu a4,0(a1)
+ 2d8: 00e79863 bne a5,a4,2e8 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 2dc: 0505 addi a0,a0,1
+ p2++;
+ 2de: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 2e0: fed518e3 bne a0,a3,2d0 <memcmp+0x14>
+ }
+ return 0;
+ 2e4: 4501 li a0,0
+ 2e6: a019 j 2ec <memcmp+0x30>
+ return *p1 - *p2;
+ 2e8: 40e7853b subw a0,a5,a4
+}
+ 2ec: 6422 ld s0,8(sp)
+ 2ee: 0141 addi sp,sp,16
+ 2f0: 8082 ret
+ return 0;
+ 2f2: 4501 li a0,0
+ 2f4: bfe5 j 2ec <memcmp+0x30>
+
+00000000000002f6 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 2f6: 1141 addi sp,sp,-16
+ 2f8: e406 sd ra,8(sp)
+ 2fa: e022 sd s0,0(sp)
+ 2fc: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 2fe: 00000097 auipc ra,0x0
+ 302: f66080e7 jalr -154(ra) # 264 <memmove>
+}
+ 306: 60a2 ld ra,8(sp)
+ 308: 6402 ld s0,0(sp)
+ 30a: 0141 addi sp,sp,16
+ 30c: 8082 ret
+
+000000000000030e <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 30e: 4885 li a7,1
+ ecall
+ 310: 00000073 ecall
+ ret
+ 314: 8082 ret
+
+0000000000000316 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 316: 05d00893 li a7,93
+ ecall
+ 31a: 00000073 ecall
+ ret
+ 31e: 8082 ret
+
+0000000000000320 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 320: 488d li a7,3
+ ecall
+ 322: 00000073 ecall
+ ret
+ 326: 8082 ret
+
+0000000000000328 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 328: 03b00893 li a7,59
+ ecall
+ 32c: 00000073 ecall
+ ret
+ 330: 8082 ret
+
+0000000000000332 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 332: 03f00893 li a7,63
+ ecall
+ 336: 00000073 ecall
+ ret
+ 33a: 8082 ret
+
+000000000000033c <write>:
+.global write
+write:
+ li a7, SYS_write
+ 33c: 04000893 li a7,64
+ ecall
+ 340: 00000073 ecall
+ ret
+ 344: 8082 ret
+
+0000000000000346 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 346: 03900893 li a7,57
+ ecall
+ 34a: 00000073 ecall
+ ret
+ 34e: 8082 ret
+
+0000000000000350 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 350: 4899 li a7,6
+ ecall
+ 352: 00000073 ecall
+ ret
+ 356: 8082 ret
+
+0000000000000358 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 358: 0dd00893 li a7,221
+ ecall
+ 35c: 00000073 ecall
+ ret
+ 360: 8082 ret
+
+0000000000000362 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 362: 03800893 li a7,56
+ ecall
+ 366: 00000073 ecall
+ ret
+ 36a: 8082 ret
+
+000000000000036c <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 36c: 05000893 li a7,80
+ ecall
+ 370: 00000073 ecall
+ ret
+ 374: 8082 ret
+
+0000000000000376 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 376: 02200893 li a7,34
+ ecall
+ 37a: 00000073 ecall
+ ret
+ 37e: 8082 ret
+
+0000000000000380 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 380: 03100893 li a7,49
+ ecall
+ 384: 00000073 ecall
+ ret
+ 388: 8082 ret
+
+000000000000038a <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 38a: 48dd li a7,23
+ ecall
+ 38c: 00000073 ecall
+ ret
+ 390: 8082 ret
+
+0000000000000392 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 392: 0ac00893 li a7,172
+ ecall
+ 396: 00000073 ecall
+ ret
+ 39a: 8082 ret
+
+000000000000039c <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 39c: 48b1 li a7,12
+ ecall
+ 39e: 00000073 ecall
+ ret
+ 3a2: 8082 ret
+
+00000000000003a4 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 3a4: 48b5 li a7,13
+ ecall
+ 3a6: 00000073 ecall
+ ret
+ 3aa: 8082 ret
+
+00000000000003ac <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 3ac: 48b9 li a7,14
+ ecall
+ 3ae: 00000073 ecall
+ ret
+ 3b2: 8082 ret
+
+00000000000003b4 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 3b4: 48d9 li a7,22
+ ecall
+ 3b6: 00000073 ecall
+ ret
+ 3ba: 8082 ret
+
+00000000000003bc <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 3bc: 03200893 li a7,50
+ ecall
+ 3c0: 00000073 ecall
+ ret
+ 3c4: 8082 ret
+
+00000000000003c6 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 3c6: 48ed li a7,27
+ ecall
+ 3c8: 00000073 ecall
+ ret
+ 3cc: 8082 ret
+
+00000000000003ce <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 3ce: 48c5 li a7,17
+ ecall
+ 3d0: 00000073 ecall
+ ret
+ 3d4: 8082 ret
+
+00000000000003d6 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 3d6: 07500893 li a7,117
+ ecall
+ 3da: 00000073 ecall
+ ret
+ 3de: 8082 ret
+
+00000000000003e0 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 3e0: 48c9 li a7,18
+ ecall
+ 3e2: 00000073 ecall
+ ret
+ 3e6: 8082 ret
+
+00000000000003e8 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 3e8: 48cd li a7,19
+ ecall
+ 3ea: 00000073 ecall
+ ret
+ 3ee: 8082 ret
+
+00000000000003f0 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 3f0: 48e9 li a7,26
+ ecall
+ 3f2: 00000073 ecall
+ ret
+ 3f6: 8082 ret
+
+00000000000003f8 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 3f8: 0d200893 li a7,210
+ ecall
+ 3fc: 00000073 ecall
+ ret
+ 400: 8082 ret
+
+0000000000000402 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 402: 1101 addi sp,sp,-32
+ 404: ec06 sd ra,24(sp)
+ 406: e822 sd s0,16(sp)
+ 408: 1000 addi s0,sp,32
+ 40a: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 40e: 4605 li a2,1
+ 410: fef40593 addi a1,s0,-17
+ 414: 00000097 auipc ra,0x0
+ 418: f28080e7 jalr -216(ra) # 33c <write>
+}
+ 41c: 60e2 ld ra,24(sp)
+ 41e: 6442 ld s0,16(sp)
+ 420: 6105 addi sp,sp,32
+ 422: 8082 ret
+
+0000000000000424 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 424: 7139 addi sp,sp,-64
+ 426: fc06 sd ra,56(sp)
+ 428: f822 sd s0,48(sp)
+ 42a: f426 sd s1,40(sp)
+ 42c: f04a sd s2,32(sp)
+ 42e: ec4e sd s3,24(sp)
+ 430: 0080 addi s0,sp,64
+ 432: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 434: c299 beqz a3,43a <printint+0x16>
+ 436: 0805c863 bltz a1,4c6 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 43a: 2581 sext.w a1,a1
+ neg = 0;
+ 43c: 4881 li a7,0
+ }
+
+ i = 0;
+ 43e: fc040993 addi s3,s0,-64
+ neg = 0;
+ 442: 86ce mv a3,s3
+ i = 0;
+ 444: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 446: 2601 sext.w a2,a2
+ 448: 00000517 auipc a0,0x0
+ 44c: 4d850513 addi a0,a0,1240 # 920 <digits>
+ 450: 883a mv a6,a4
+ 452: 2705 addiw a4,a4,1
+ 454: 02c5f7bb remuw a5,a1,a2
+ 458: 1782 slli a5,a5,0x20
+ 45a: 9381 srli a5,a5,0x20
+ 45c: 97aa add a5,a5,a0
+ 45e: 0007c783 lbu a5,0(a5)
+ 462: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 466: 0005879b sext.w a5,a1
+ 46a: 02c5d5bb divuw a1,a1,a2
+ 46e: 0685 addi a3,a3,1
+ 470: fec7f0e3 bgeu a5,a2,450 <printint+0x2c>
+ if(neg)
+ 474: 00088c63 beqz a7,48c <printint+0x68>
+ buf[i++] = '-';
+ 478: fd070793 addi a5,a4,-48
+ 47c: 00878733 add a4,a5,s0
+ 480: 02d00793 li a5,45
+ 484: fef70823 sb a5,-16(a4)
+ 488: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 48c: 02e05663 blez a4,4b8 <printint+0x94>
+ 490: fc040913 addi s2,s0,-64
+ 494: 993a add s2,s2,a4
+ 496: 19fd addi s3,s3,-1
+ 498: 99ba add s3,s3,a4
+ 49a: 377d addiw a4,a4,-1
+ 49c: 1702 slli a4,a4,0x20
+ 49e: 9301 srli a4,a4,0x20
+ 4a0: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4a4: fff94583 lbu a1,-1(s2)
+ 4a8: 8526 mv a0,s1
+ 4aa: 00000097 auipc ra,0x0
+ 4ae: f58080e7 jalr -168(ra) # 402 <putc>
+ while(--i >= 0)
+ 4b2: 197d addi s2,s2,-1
+ 4b4: ff3918e3 bne s2,s3,4a4 <printint+0x80>
+}
+ 4b8: 70e2 ld ra,56(sp)
+ 4ba: 7442 ld s0,48(sp)
+ 4bc: 74a2 ld s1,40(sp)
+ 4be: 7902 ld s2,32(sp)
+ 4c0: 69e2 ld s3,24(sp)
+ 4c2: 6121 addi sp,sp,64
+ 4c4: 8082 ret
+ x = -xx;
+ 4c6: 40b005bb negw a1,a1
+ neg = 1;
+ 4ca: 4885 li a7,1
+ x = -xx;
+ 4cc: bf8d j 43e <printint+0x1a>
+
+00000000000004ce <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4ce: 7119 addi sp,sp,-128
+ 4d0: fc86 sd ra,120(sp)
+ 4d2: f8a2 sd s0,112(sp)
+ 4d4: f4a6 sd s1,104(sp)
+ 4d6: f0ca sd s2,96(sp)
+ 4d8: ecce sd s3,88(sp)
+ 4da: e8d2 sd s4,80(sp)
+ 4dc: e4d6 sd s5,72(sp)
+ 4de: e0da sd s6,64(sp)
+ 4e0: fc5e sd s7,56(sp)
+ 4e2: f862 sd s8,48(sp)
+ 4e4: f466 sd s9,40(sp)
+ 4e6: f06a sd s10,32(sp)
+ 4e8: ec6e sd s11,24(sp)
+ 4ea: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 4ec: 0005c903 lbu s2,0(a1)
+ 4f0: 18090f63 beqz s2,68e <vprintf+0x1c0>
+ 4f4: 8aaa mv s5,a0
+ 4f6: 8b32 mv s6,a2
+ 4f8: 00158493 addi s1,a1,1
+ state = 0;
+ 4fc: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 4fe: 02500a13 li s4,37
+ 502: 4c55 li s8,21
+ 504: 00000c97 auipc s9,0x0
+ 508: 3c4c8c93 addi s9,s9,964 # 8c8 <malloc+0x136>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 50c: 02800d93 li s11,40
+ putc(fd, 'x');
+ 510: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 512: 00000b97 auipc s7,0x0
+ 516: 40eb8b93 addi s7,s7,1038 # 920 <digits>
+ 51a: a839 j 538 <vprintf+0x6a>
+ putc(fd, c);
+ 51c: 85ca mv a1,s2
+ 51e: 8556 mv a0,s5
+ 520: 00000097 auipc ra,0x0
+ 524: ee2080e7 jalr -286(ra) # 402 <putc>
+ 528: a019 j 52e <vprintf+0x60>
+ } else if(state == '%'){
+ 52a: 01498d63 beq s3,s4,544 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 52e: 0485 addi s1,s1,1
+ 530: fff4c903 lbu s2,-1(s1)
+ 534: 14090d63 beqz s2,68e <vprintf+0x1c0>
+ if(state == 0){
+ 538: fe0999e3 bnez s3,52a <vprintf+0x5c>
+ if(c == '%'){
+ 53c: ff4910e3 bne s2,s4,51c <vprintf+0x4e>
+ state = '%';
+ 540: 89d2 mv s3,s4
+ 542: b7f5 j 52e <vprintf+0x60>
+ if(c == 'd'){
+ 544: 11490c63 beq s2,s4,65c <vprintf+0x18e>
+ 548: f9d9079b addiw a5,s2,-99
+ 54c: 0ff7f793 zext.b a5,a5
+ 550: 10fc6e63 bltu s8,a5,66c <vprintf+0x19e>
+ 554: f9d9079b addiw a5,s2,-99
+ 558: 0ff7f713 zext.b a4,a5
+ 55c: 10ec6863 bltu s8,a4,66c <vprintf+0x19e>
+ 560: 00271793 slli a5,a4,0x2
+ 564: 97e6 add a5,a5,s9
+ 566: 439c lw a5,0(a5)
+ 568: 97e6 add a5,a5,s9
+ 56a: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 56c: 008b0913 addi s2,s6,8
+ 570: 4685 li a3,1
+ 572: 4629 li a2,10
+ 574: 000b2583 lw a1,0(s6)
+ 578: 8556 mv a0,s5
+ 57a: 00000097 auipc ra,0x0
+ 57e: eaa080e7 jalr -342(ra) # 424 <printint>
+ 582: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 584: 4981 li s3,0
+ 586: b765 j 52e <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 588: 008b0913 addi s2,s6,8
+ 58c: 4681 li a3,0
+ 58e: 4629 li a2,10
+ 590: 000b2583 lw a1,0(s6)
+ 594: 8556 mv a0,s5
+ 596: 00000097 auipc ra,0x0
+ 59a: e8e080e7 jalr -370(ra) # 424 <printint>
+ 59e: 8b4a mv s6,s2
+ state = 0;
+ 5a0: 4981 li s3,0
+ 5a2: b771 j 52e <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 5a4: 008b0913 addi s2,s6,8
+ 5a8: 4681 li a3,0
+ 5aa: 866a mv a2,s10
+ 5ac: 000b2583 lw a1,0(s6)
+ 5b0: 8556 mv a0,s5
+ 5b2: 00000097 auipc ra,0x0
+ 5b6: e72080e7 jalr -398(ra) # 424 <printint>
+ 5ba: 8b4a mv s6,s2
+ state = 0;
+ 5bc: 4981 li s3,0
+ 5be: bf85 j 52e <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 5c0: 008b0793 addi a5,s6,8
+ 5c4: f8f43423 sd a5,-120(s0)
+ 5c8: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 5cc: 03000593 li a1,48
+ 5d0: 8556 mv a0,s5
+ 5d2: 00000097 auipc ra,0x0
+ 5d6: e30080e7 jalr -464(ra) # 402 <putc>
+ putc(fd, 'x');
+ 5da: 07800593 li a1,120
+ 5de: 8556 mv a0,s5
+ 5e0: 00000097 auipc ra,0x0
+ 5e4: e22080e7 jalr -478(ra) # 402 <putc>
+ 5e8: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 5ea: 03c9d793 srli a5,s3,0x3c
+ 5ee: 97de add a5,a5,s7
+ 5f0: 0007c583 lbu a1,0(a5)
+ 5f4: 8556 mv a0,s5
+ 5f6: 00000097 auipc ra,0x0
+ 5fa: e0c080e7 jalr -500(ra) # 402 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 5fe: 0992 slli s3,s3,0x4
+ 600: 397d addiw s2,s2,-1
+ 602: fe0914e3 bnez s2,5ea <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 606: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 60a: 4981 li s3,0
+ 60c: b70d j 52e <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 60e: 008b0913 addi s2,s6,8
+ 612: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 616: 02098163 beqz s3,638 <vprintf+0x16a>
+ while(*s != 0){
+ 61a: 0009c583 lbu a1,0(s3)
+ 61e: c5ad beqz a1,688 <vprintf+0x1ba>
+ putc(fd, *s);
+ 620: 8556 mv a0,s5
+ 622: 00000097 auipc ra,0x0
+ 626: de0080e7 jalr -544(ra) # 402 <putc>
+ s++;
+ 62a: 0985 addi s3,s3,1
+ while(*s != 0){
+ 62c: 0009c583 lbu a1,0(s3)
+ 630: f9e5 bnez a1,620 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 632: 8b4a mv s6,s2
+ state = 0;
+ 634: 4981 li s3,0
+ 636: bde5 j 52e <vprintf+0x60>
+ s = "(null)";
+ 638: 00000997 auipc s3,0x0
+ 63c: 28898993 addi s3,s3,648 # 8c0 <malloc+0x12e>
+ while(*s != 0){
+ 640: 85ee mv a1,s11
+ 642: bff9 j 620 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 644: 008b0913 addi s2,s6,8
+ 648: 000b4583 lbu a1,0(s6)
+ 64c: 8556 mv a0,s5
+ 64e: 00000097 auipc ra,0x0
+ 652: db4080e7 jalr -588(ra) # 402 <putc>
+ 656: 8b4a mv s6,s2
+ state = 0;
+ 658: 4981 li s3,0
+ 65a: bdd1 j 52e <vprintf+0x60>
+ putc(fd, c);
+ 65c: 85d2 mv a1,s4
+ 65e: 8556 mv a0,s5
+ 660: 00000097 auipc ra,0x0
+ 664: da2080e7 jalr -606(ra) # 402 <putc>
+ state = 0;
+ 668: 4981 li s3,0
+ 66a: b5d1 j 52e <vprintf+0x60>
+ putc(fd, '%');
+ 66c: 85d2 mv a1,s4
+ 66e: 8556 mv a0,s5
+ 670: 00000097 auipc ra,0x0
+ 674: d92080e7 jalr -622(ra) # 402 <putc>
+ putc(fd, c);
+ 678: 85ca mv a1,s2
+ 67a: 8556 mv a0,s5
+ 67c: 00000097 auipc ra,0x0
+ 680: d86080e7 jalr -634(ra) # 402 <putc>
+ state = 0;
+ 684: 4981 li s3,0
+ 686: b565 j 52e <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 688: 8b4a mv s6,s2
+ state = 0;
+ 68a: 4981 li s3,0
+ 68c: b54d j 52e <vprintf+0x60>
+ }
+ }
+}
+ 68e: 70e6 ld ra,120(sp)
+ 690: 7446 ld s0,112(sp)
+ 692: 74a6 ld s1,104(sp)
+ 694: 7906 ld s2,96(sp)
+ 696: 69e6 ld s3,88(sp)
+ 698: 6a46 ld s4,80(sp)
+ 69a: 6aa6 ld s5,72(sp)
+ 69c: 6b06 ld s6,64(sp)
+ 69e: 7be2 ld s7,56(sp)
+ 6a0: 7c42 ld s8,48(sp)
+ 6a2: 7ca2 ld s9,40(sp)
+ 6a4: 7d02 ld s10,32(sp)
+ 6a6: 6de2 ld s11,24(sp)
+ 6a8: 6109 addi sp,sp,128
+ 6aa: 8082 ret
+
+00000000000006ac <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 6ac: 715d addi sp,sp,-80
+ 6ae: ec06 sd ra,24(sp)
+ 6b0: e822 sd s0,16(sp)
+ 6b2: 1000 addi s0,sp,32
+ 6b4: e010 sd a2,0(s0)
+ 6b6: e414 sd a3,8(s0)
+ 6b8: e818 sd a4,16(s0)
+ 6ba: ec1c sd a5,24(s0)
+ 6bc: 03043023 sd a6,32(s0)
+ 6c0: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6c4: 8622 mv a2,s0
+ 6c6: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 6ca: 00000097 auipc ra,0x0
+ 6ce: e04080e7 jalr -508(ra) # 4ce <vprintf>
+}
+ 6d2: 60e2 ld ra,24(sp)
+ 6d4: 6442 ld s0,16(sp)
+ 6d6: 6161 addi sp,sp,80
+ 6d8: 8082 ret
+
+00000000000006da <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 6da: 711d addi sp,sp,-96
+ 6dc: ec06 sd ra,24(sp)
+ 6de: e822 sd s0,16(sp)
+ 6e0: 1000 addi s0,sp,32
+ 6e2: e40c sd a1,8(s0)
+ 6e4: e810 sd a2,16(s0)
+ 6e6: ec14 sd a3,24(s0)
+ 6e8: f018 sd a4,32(s0)
+ 6ea: f41c sd a5,40(s0)
+ 6ec: 03043823 sd a6,48(s0)
+ 6f0: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 6f4: 00840613 addi a2,s0,8
+ 6f8: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 6fc: 85aa mv a1,a0
+ 6fe: 4505 li a0,1
+ 700: 00000097 auipc ra,0x0
+ 704: dce080e7 jalr -562(ra) # 4ce <vprintf>
+}
+ 708: 60e2 ld ra,24(sp)
+ 70a: 6442 ld s0,16(sp)
+ 70c: 6125 addi sp,sp,96
+ 70e: 8082 ret
+
+0000000000000710 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 710: 1141 addi sp,sp,-16
+ 712: e422 sd s0,8(sp)
+ 714: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 716: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 71a: 00000797 auipc a5,0x0
+ 71e: 21e7b783 ld a5,542(a5) # 938 <freep>
+ 722: a02d j 74c <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 724: 4618 lw a4,8(a2)
+ 726: 9f2d addw a4,a4,a1
+ 728: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 72c: 6398 ld a4,0(a5)
+ 72e: 6310 ld a2,0(a4)
+ 730: a83d j 76e <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 732: ff852703 lw a4,-8(a0)
+ 736: 9f31 addw a4,a4,a2
+ 738: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 73a: ff053683 ld a3,-16(a0)
+ 73e: a091 j 782 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 740: 6398 ld a4,0(a5)
+ 742: 00e7e463 bltu a5,a4,74a <free+0x3a>
+ 746: 00e6ea63 bltu a3,a4,75a <free+0x4a>
+{
+ 74a: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 74c: fed7fae3 bgeu a5,a3,740 <free+0x30>
+ 750: 6398 ld a4,0(a5)
+ 752: 00e6e463 bltu a3,a4,75a <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 756: fee7eae3 bltu a5,a4,74a <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 75a: ff852583 lw a1,-8(a0)
+ 75e: 6390 ld a2,0(a5)
+ 760: 02059813 slli a6,a1,0x20
+ 764: 01c85713 srli a4,a6,0x1c
+ 768: 9736 add a4,a4,a3
+ 76a: fae60de3 beq a2,a4,724 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 76e: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 772: 4790 lw a2,8(a5)
+ 774: 02061593 slli a1,a2,0x20
+ 778: 01c5d713 srli a4,a1,0x1c
+ 77c: 973e add a4,a4,a5
+ 77e: fae68ae3 beq a3,a4,732 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 782: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 784: 00000717 auipc a4,0x0
+ 788: 1af73a23 sd a5,436(a4) # 938 <freep>
+}
+ 78c: 6422 ld s0,8(sp)
+ 78e: 0141 addi sp,sp,16
+ 790: 8082 ret
+
+0000000000000792 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 792: 7139 addi sp,sp,-64
+ 794: fc06 sd ra,56(sp)
+ 796: f822 sd s0,48(sp)
+ 798: f426 sd s1,40(sp)
+ 79a: f04a sd s2,32(sp)
+ 79c: ec4e sd s3,24(sp)
+ 79e: e852 sd s4,16(sp)
+ 7a0: e456 sd s5,8(sp)
+ 7a2: e05a sd s6,0(sp)
+ 7a4: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 7a6: 02051493 slli s1,a0,0x20
+ 7aa: 9081 srli s1,s1,0x20
+ 7ac: 04bd addi s1,s1,15
+ 7ae: 8091 srli s1,s1,0x4
+ 7b0: 00148a1b addiw s4,s1,1
+ 7b4: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 7b6: 00000517 auipc a0,0x0
+ 7ba: 18253503 ld a0,386(a0) # 938 <freep>
+ 7be: c515 beqz a0,7ea <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 7c0: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 7c2: 4798 lw a4,8(a5)
+ 7c4: 04977163 bgeu a4,s1,806 <malloc+0x74>
+ 7c8: 89d2 mv s3,s4
+ 7ca: 000a071b sext.w a4,s4
+ 7ce: 6685 lui a3,0x1
+ 7d0: 00d77363 bgeu a4,a3,7d6 <malloc+0x44>
+ 7d4: 6985 lui s3,0x1
+ 7d6: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 7da: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 7de: 00000917 auipc s2,0x0
+ 7e2: 15a90913 addi s2,s2,346 # 938 <freep>
+ if(p == (char*)-1)
+ 7e6: 5afd li s5,-1
+ 7e8: a8a5 j 860 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 7ea: 00000797 auipc a5,0x0
+ 7ee: 14e78793 addi a5,a5,334 # 938 <freep>
+ 7f2: 00000717 auipc a4,0x0
+ 7f6: 14e70713 addi a4,a4,334 # 940 <base>
+ 7fa: e398 sd a4,0(a5)
+ 7fc: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 7fe: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 802: 87ba mv a5,a4
+ 804: b7d1 j 7c8 <malloc+0x36>
+ if(p->s.size == nunits)
+ 806: 02e48c63 beq s1,a4,83e <malloc+0xac>
+ p->s.size -= nunits;
+ 80a: 4147073b subw a4,a4,s4
+ 80e: c798 sw a4,8(a5)
+ p += p->s.size;
+ 810: 02071693 slli a3,a4,0x20
+ 814: 01c6d713 srli a4,a3,0x1c
+ 818: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 81a: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 81e: 00000717 auipc a4,0x0
+ 822: 10a73d23 sd a0,282(a4) # 938 <freep>
+ return (void*)(p + 1);
+ 826: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 82a: 70e2 ld ra,56(sp)
+ 82c: 7442 ld s0,48(sp)
+ 82e: 74a2 ld s1,40(sp)
+ 830: 7902 ld s2,32(sp)
+ 832: 69e2 ld s3,24(sp)
+ 834: 6a42 ld s4,16(sp)
+ 836: 6aa2 ld s5,8(sp)
+ 838: 6b02 ld s6,0(sp)
+ 83a: 6121 addi sp,sp,64
+ 83c: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 83e: 6398 ld a4,0(a5)
+ 840: e118 sd a4,0(a0)
+ 842: bff1 j 81e <malloc+0x8c>
+ hp->s.size = nu;
+ 844: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 848: 0541 addi a0,a0,16
+ 84a: 00000097 auipc ra,0x0
+ 84e: ec6080e7 jalr -314(ra) # 710 <free>
+ return freep;
+ 852: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 856: d971 beqz a0,82a <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 858: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 85a: 4798 lw a4,8(a5)
+ 85c: fa9775e3 bgeu a4,s1,806 <malloc+0x74>
+ if(p == freep)
+ 860: 00093703 ld a4,0(s2)
+ 864: 853e mv a0,a5
+ 866: fef719e3 bne a4,a5,858 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 86a: 854e mv a0,s3
+ 86c: 00000097 auipc ra,0x0
+ 870: b30080e7 jalr -1232(ra) # 39c <sbrk>
+ if(p == (char*)-1)
+ 874: fd5518e3 bne a0,s5,844 <malloc+0xb2>
+ return 0;
+ 878: 4501 li a0,0
+ 87a: bf45 j 82a <malloc+0x98>
diff --git a/xv6-user/test.c b/xv6-user/test.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e2c0d5265e27229043078e3d187148d553fdf0f
--- /dev/null
+++ b/xv6-user/test.c
@@ -0,0 +1,16 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/sysinfo.h"
+#include "xv6-user/user.h"
+
+int main()
+{
+ struct sysinfo info;
+ if (sysinfo(&info) < 0) {
+ printf("sysinfo fail!\n");
+ } else {
+ printf("memory left: %d KB\n", info.freemem >> 10);
+ printf("process amount: %d\n", info.nproc);
+ }
+ exit(0);
+}
diff --git a/xv6-user/test.d b/xv6-user/test.d
new file mode 100644
index 0000000000000000000000000000000000000000..3f9cdadb35f1002eb019f0a0a08d8dd518f0efee
--- /dev/null
+++ b/xv6-user/test.d
@@ -0,0 +1,3 @@
+xv6-user/test.o: xv6-user/test.c kernel/include/types.h \
+ kernel/include/stat.h kernel/include/sysinfo.h kernel/include/types.h \
+ xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/test.o b/xv6-user/test.o
new file mode 100644
index 0000000000000000000000000000000000000000..5412c1a156554cd05106dea51781fa86b5b093f8
Binary files /dev/null and b/xv6-user/test.o differ
diff --git a/xv6-user/test.sym b/xv6-user/test.sym
new file mode 100644
index 0000000000000000000000000000000000000000..81409ef305f9593fc4d806421ecd2e95759ef7a8
--- /dev/null
+++ b/xv6-user/test.sym
@@ -0,0 +1,76 @@
+0000000000000000 .text
+0000000000000880 .rodata
+0000000000000938 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 test.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+0000000000000402 putc
+0000000000000424 printint
+0000000000000920 digits
+0000000000000000 umalloc.c
+0000000000000938 freep
+0000000000000940 base
+000000000000005e strcpy
+00000000000006da printf
+0000000000001131 __global_pointer$
+00000000000003bc dev
+0000000000000264 memmove
+00000000000003e0 trace
+0000000000000144 gets
+0000000000000931 __SDATA_BEGIN__
+0000000000000392 getpid
+00000000000002f6 memcpy
+0000000000000792 malloc
+00000000000003d6 remove
+00000000000003a4 sleep
+00000000000003e8 sysinfo
+00000000000003c6 readdir
+0000000000000328 pipe
+00000000000003f0 rename
+000000000000033c write
+000000000000036c fstat
+00000000000006ac fprintf
+0000000000000350 kill
+000000000000007a strcat
+00000000000004ce vprintf
+0000000000000380 chdir
+0000000000000358 exec
+0000000000000320 wait
+0000000000000332 read
+00000000000002bc memcmp
+000000000000030e fork
+0000000000000950 __BSS_END__
+000000000000039c sbrk
+00000000000003b4 test_proc
+00000000000003ac uptime
+0000000000000931 __bss_start
+00000000000000fe memset
+0000000000000000 main
+00000000000000a8 strcmp
+00000000000003f8 shutdown
+000000000000038a dup
+00000000000003ce getcwd
+0000000000000931 __DATA_BEGIN__
+00000000000001be stat
+0000000000000931 _edata
+0000000000000950 _end
+0000000000000316 exit
+0000000000000204 atoi
+00000000000000d4 strlen
+0000000000000362 open
+0000000000000120 strchr
+0000000000000376 mkdir
+0000000000000346 close
+0000000000000710 free
diff --git a/xv6-user/ulib.c b/xv6-user/ulib.c
new file mode 100644
index 0000000000000000000000000000000000000000..b1b246936f7cd953614f5f9a3f007d46f41d78bb
--- /dev/null
+++ b/xv6-user/ulib.c
@@ -0,0 +1,152 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ ;
+ return os;
+}
+
+char*
+strcat(char *s, const char *t)
+{
+ char *os = s;
+ while(*s)
+ s++;
+ while((*s++ = *t++))
+ ;
+ return os;
+}
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ while(*p && *p == *q)
+ p++, q++;
+ return (uchar)*p - (uchar)*q;
+}
+
+uint
+strlen(const char *s)
+{
+ int n;
+
+ for(n = 0; s[n]; n++)
+ ;
+ return n;
+}
+
+void*
+memset(void *dst, int c, uint n)
+{
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ cdst[i] = c;
+ }
+ return dst;
+}
+
+char*
+strchr(const char *s, char c)
+{
+ for(; *s; s++)
+ if(*s == c)
+ return (char*)s;
+ return 0;
+}
+
+char*
+gets(char *buf, int max)
+{
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ cc = read(0, &c, 1);
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ break;
+ }
+ buf[i] = '\0';
+ return buf;
+}
+
+int
+stat(const char *n, struct stat *st)
+{
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ if(fd < 0)
+ return -1;
+ r = fstat(fd, st);
+ close(fd);
+ return r;
+}
+
+int
+atoi(const char *s)
+{
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ n = n*10 + *s++ - '0';
+ return n * neg;
+}
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ while(n-- > 0)
+ *dst++ = *src++;
+ } else {
+ dst += n;
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ if (*p1 != *p2) {
+ return *p1 - *p2;
+ }
+ p1++;
+ p2++;
+ }
+ return 0;
+}
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ return memmove(dst, src, n);
+}
diff --git a/xv6-user/ulib.d b/xv6-user/ulib.d
new file mode 100644
index 0000000000000000000000000000000000000000..0f2ffee2af1e115762614b1dbf11a24b1c243b6f
--- /dev/null
+++ b/xv6-user/ulib.d
@@ -0,0 +1,2 @@
+xv6-user/ulib.o: xv6-user/ulib.c kernel/include/types.h \
+ kernel/include/stat.h kernel/include/fcntl.h xv6-user/user.h
diff --git a/xv6-user/ulib.o b/xv6-user/ulib.o
new file mode 100644
index 0000000000000000000000000000000000000000..7bc9baa6c8c63010f1baa331d437cde2013cc1db
Binary files /dev/null and b/xv6-user/ulib.o differ
diff --git a/xv6-user/umalloc.c b/xv6-user/umalloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..66fe86d47be7058a88b4cca3a3d0f2b1890496a0
--- /dev/null
+++ b/xv6-user/umalloc.c
@@ -0,0 +1,90 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+#include "kernel/include/param.h"
+
+// Memory allocator by Kernighan and Ritchie,
+// The C programming Language, 2nd ed. Section 8.7.
+
+typedef long Align;
+
+union header {
+ struct {
+ union header *ptr;
+ uint size;
+ } s;
+ Align x;
+};
+
+typedef union header Header;
+
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ bp->s.ptr = p->s.ptr->s.ptr;
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ p->s.ptr = bp->s.ptr;
+ } else
+ p->s.ptr = bp;
+ freep = p;
+}
+
+static Header*
+morecore(uint nu)
+{
+ char *p;
+ Header *hp;
+
+ if(nu < 4096)
+ nu = 4096;
+ p = sbrk(nu * sizeof(Header));
+ if(p == (char*)-1)
+ return 0;
+ hp = (Header*)p;
+ hp->s.size = nu;
+ free((void*)(hp + 1));
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ if((prevp = freep) == 0){
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ if(p->s.size >= nunits){
+ if(p->s.size == nunits)
+ prevp->s.ptr = p->s.ptr;
+ else {
+ p->s.size -= nunits;
+ p += p->s.size;
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
diff --git a/xv6-user/umalloc.d b/xv6-user/umalloc.d
new file mode 100644
index 0000000000000000000000000000000000000000..c5589c46171c628569cf54f5bf3de0698fb0d25e
--- /dev/null
+++ b/xv6-user/umalloc.d
@@ -0,0 +1,3 @@
+xv6-user/umalloc.o: xv6-user/umalloc.c kernel/include/types.h \
+ kernel/include/stat.h xv6-user/user.h kernel/include/fcntl.h \
+ kernel/include/param.h
diff --git a/xv6-user/umalloc.o b/xv6-user/umalloc.o
new file mode 100644
index 0000000000000000000000000000000000000000..64bbe030d8693b809419ed30bc3c4848a980becd
Binary files /dev/null and b/xv6-user/umalloc.o differ
diff --git a/xv6-user/user.h b/xv6-user/user.h
new file mode 100644
index 0000000000000000000000000000000000000000..71b20c5daad040cc7f3906aa0a8a6436a9c2ee4e
--- /dev/null
+++ b/xv6-user/user.h
@@ -0,0 +1,54 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "kernel/include/fcntl.h"
+
+struct stat;
+struct rtcdate;
+struct sysinfo;
+
+// system calls
+int fork(void);
+int exit(int) __attribute__((noreturn));
+int wait(int*);
+int pipe(int*);
+int write(int fd, const void *buf, int len);
+int read(int fd, void *buf, int len);
+int close(int fd);
+int kill(int pid);
+int exec(char*, char**);
+int open(const char *filename, int mode);
+int fstat(int fd, struct stat*);
+int mkdir(const char *dirname);
+int chdir(const char *dirname);
+int dup(int fd);
+int getpid(void);
+char* sbrk(int size);
+int sleep(int ticks);
+int uptime(void);
+int test_proc(int);
+int dev(int, short, short);
+int readdir(int fd, struct stat*);
+int getcwd(char *buf);
+int remove(char *filename);
+int trace(int mask);
+int sysinfo(struct sysinfo *);
+int rename(char *old, char *new);
+int shutdown(void);
+
+// ulib.c
+int stat(const char*, struct stat*);
+char* strcpy(char*, const char*);
+char* strcat(char*, const char*);
+void *memmove(void*, const void*, int);
+char* strchr(const char*, char c);
+int strcmp(const char*, const char*);
+void fprintf(int, const char*, ...);
+void printf(const char*, ...);
+char* gets(char*, int max);
+uint strlen(const char*);
+void* memset(void*, int, uint);
+void* malloc(uint);
+void free(void*);
+int atoi(const char*);
+int memcmp(const void *, const void *, uint);
+void *memcpy(void *, const void *, uint);
diff --git a/xv6-user/usertests.asm b/xv6-user/usertests.asm
new file mode 100644
index 0000000000000000000000000000000000000000..b7aa1e656bcbd04cc04603212a922bce42bd0ac5
--- /dev/null
+++ b/xv6-user/usertests.asm
@@ -0,0 +1,8696 @@
+
+xv6-user/_usertests: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <copyinstr1>:
+}
+
+// what if you pass ridiculous string pointers to system calls?
+void
+copyinstr1(char *s)
+{
+ 0: 1141 addi sp,sp,-16
+ 2: e406 sd ra,8(sp)
+ 4: e022 sd s0,0(sp)
+ 6: 0800 addi s0,sp,16
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+
+ for(int ai = 0; ai < 2; ai++){
+ uint64 addr = addrs[ai];
+
+ int fd = open((char *)addr, O_CREATE|O_WRONLY);
+ 8: 20100593 li a1,513
+ c: 4505 li a0,1
+ e: 057e slli a0,a0,0x1f
+ 10: 00005097 auipc ra,0x5
+ 14: 940080e7 jalr -1728(ra) # 4950 <open>
+ if(fd >= 0){
+ 18: 02055063 bgez a0,38 <copyinstr1+0x38>
+ int fd = open((char *)addr, O_CREATE|O_WRONLY);
+ 1c: 20100593 li a1,513
+ 20: 557d li a0,-1
+ 22: 00005097 auipc ra,0x5
+ 26: 92e080e7 jalr -1746(ra) # 4950 <open>
+ uint64 addr = addrs[ai];
+ 2a: 55fd li a1,-1
+ if(fd >= 0){
+ 2c: 00055863 bgez a0,3c <copyinstr1+0x3c>
+ printf("open(%p) returned %d, not -1\n", addr, fd);
+ exit(1);
+ }
+ }
+}
+ 30: 60a2 ld ra,8(sp)
+ 32: 6402 ld s0,0(sp)
+ 34: 0141 addi sp,sp,16
+ 36: 8082 ret
+ uint64 addr = addrs[ai];
+ 38: 4585 li a1,1
+ 3a: 05fe slli a1,a1,0x1f
+ printf("open(%p) returned %d, not -1\n", addr, fd);
+ 3c: 862a mv a2,a0
+ 3e: 00005517 auipc a0,0x5
+ 42: e3250513 addi a0,a0,-462 # 4e70 <malloc+0xf0>
+ 46: 00005097 auipc ra,0x5
+ 4a: c82080e7 jalr -894(ra) # 4cc8 <printf>
+ exit(1);
+ 4e: 4505 li a0,1
+ 50: 00005097 auipc ra,0x5
+ 54: 8b4080e7 jalr -1868(ra) # 4904 <exit>
+
+0000000000000058 <validatetest>:
+ }
+}
+
+void
+validatetest(char *s)
+{
+ 58: 7139 addi sp,sp,-64
+ 5a: fc06 sd ra,56(sp)
+ 5c: f822 sd s0,48(sp)
+ 5e: f426 sd s1,40(sp)
+ 60: f04a sd s2,32(sp)
+ 62: ec4e sd s3,24(sp)
+ 64: e852 sd s4,16(sp)
+ 66: e456 sd s5,8(sp)
+ 68: e05a sd s6,0(sp)
+ 6a: 0080 addi s0,sp,64
+ 6c: 8b2a mv s6,a0
+ int hi;
+ uint64 p;
+
+ hi = 1100*1024;
+ for(p = 0; p <= (uint)hi; p += PGSIZE){
+ 6e: 4481 li s1,0
+ // try to crash the kernel by passing in a bad string pointer
+ if(open((char*)p, O_RDONLY) != -1){
+ 70: 597d li s2,-1
+ for(p = 0; p <= (uint)hi; p += PGSIZE){
+ 72: 6a05 lui s4,0x1
+ 74: 001149b7 lui s3,0x114
+ if(open((char*)p, O_RDONLY) != -1){
+ 78: 4581 li a1,0
+ 7a: 8526 mv a0,s1
+ 7c: 00005097 auipc ra,0x5
+ 80: 8d4080e7 jalr -1836(ra) # 4950 <open>
+ 84: 01251f63 bne a0,s2,a2 <validatetest+0x4a>
+ for(p = 0; p <= (uint)hi; p += PGSIZE){
+ 88: 94d2 add s1,s1,s4
+ 8a: ff3497e3 bne s1,s3,78 <validatetest+0x20>
+ printf("%s: link should not succeed\n", s);
+ printf("bad string:[%s]\n", (char*)p);
+ exit(1);
+ }
+ }
+}
+ 8e: 70e2 ld ra,56(sp)
+ 90: 7442 ld s0,48(sp)
+ 92: 74a2 ld s1,40(sp)
+ 94: 7902 ld s2,32(sp)
+ 96: 69e2 ld s3,24(sp)
+ 98: 6a42 ld s4,16(sp)
+ 9a: 6aa2 ld s5,8(sp)
+ 9c: 6b02 ld s6,0(sp)
+ 9e: 6121 addi sp,sp,64
+ a0: 8082 ret
+ printf("%s: link should not succeed\n", s);
+ a2: 85da mv a1,s6
+ a4: 00005517 auipc a0,0x5
+ a8: dec50513 addi a0,a0,-532 # 4e90 <malloc+0x110>
+ ac: 00005097 auipc ra,0x5
+ b0: c1c080e7 jalr -996(ra) # 4cc8 <printf>
+ printf("bad string:[%s]\n", (char*)p);
+ b4: 85a6 mv a1,s1
+ b6: 00005517 auipc a0,0x5
+ ba: dfa50513 addi a0,a0,-518 # 4eb0 <malloc+0x130>
+ be: 00005097 auipc ra,0x5
+ c2: c0a080e7 jalr -1014(ra) # 4cc8 <printf>
+ exit(1);
+ c6: 4505 li a0,1
+ c8: 00005097 auipc ra,0x5
+ cc: 83c080e7 jalr -1988(ra) # 4904 <exit>
+
+00000000000000d0 <bsstest>:
+void
+bsstest(char *s)
+{
+ int i;
+
+ for(i = 0; i < sizeof(uninit); i++){
+ d0: 00008797 auipc a5,0x8
+ d4: 0b878793 addi a5,a5,184 # 8188 <uninit>
+ d8: 0000a697 auipc a3,0xa
+ dc: 7c068693 addi a3,a3,1984 # a898 <buf>
+ if(uninit[i] != '\0'){
+ e0: 0007c703 lbu a4,0(a5)
+ e4: e709 bnez a4,ee <bsstest+0x1e>
+ for(i = 0; i < sizeof(uninit); i++){
+ e6: 0785 addi a5,a5,1
+ e8: fed79ce3 bne a5,a3,e0 <bsstest+0x10>
+ ec: 8082 ret
+{
+ ee: 1141 addi sp,sp,-16
+ f0: e406 sd ra,8(sp)
+ f2: e022 sd s0,0(sp)
+ f4: 0800 addi s0,sp,16
+ printf("%s: bss test failed\n", s);
+ f6: 85aa mv a1,a0
+ f8: 00005517 auipc a0,0x5
+ fc: dd050513 addi a0,a0,-560 # 4ec8 <malloc+0x148>
+ 100: 00005097 auipc ra,0x5
+ 104: bc8080e7 jalr -1080(ra) # 4cc8 <printf>
+ exit(1);
+ 108: 4505 li a0,1
+ 10a: 00004097 auipc ra,0x4
+ 10e: 7fa080e7 jalr 2042(ra) # 4904 <exit>
+
+0000000000000112 <opentest>:
+{
+ 112: 1101 addi sp,sp,-32
+ 114: ec06 sd ra,24(sp)
+ 116: e822 sd s0,16(sp)
+ 118: e426 sd s1,8(sp)
+ 11a: 1000 addi s0,sp,32
+ 11c: 84aa mv s1,a0
+ fd = open("echo", 0);
+ 11e: 4581 li a1,0
+ 120: 00005517 auipc a0,0x5
+ 124: dc050513 addi a0,a0,-576 # 4ee0 <malloc+0x160>
+ 128: 00005097 auipc ra,0x5
+ 12c: 828080e7 jalr -2008(ra) # 4950 <open>
+ if(fd < 0){
+ 130: 02054663 bltz a0,15c <opentest+0x4a>
+ close(fd);
+ 134: 00005097 auipc ra,0x5
+ 138: 800080e7 jalr -2048(ra) # 4934 <close>
+ fd = open("doesnotexist", 0);
+ 13c: 4581 li a1,0
+ 13e: 00005517 auipc a0,0x5
+ 142: dc250513 addi a0,a0,-574 # 4f00 <malloc+0x180>
+ 146: 00005097 auipc ra,0x5
+ 14a: 80a080e7 jalr -2038(ra) # 4950 <open>
+ if(fd >= 0){
+ 14e: 02055563 bgez a0,178 <opentest+0x66>
+}
+ 152: 60e2 ld ra,24(sp)
+ 154: 6442 ld s0,16(sp)
+ 156: 64a2 ld s1,8(sp)
+ 158: 6105 addi sp,sp,32
+ 15a: 8082 ret
+ printf("%s: open echo failed!\n", s);
+ 15c: 85a6 mv a1,s1
+ 15e: 00005517 auipc a0,0x5
+ 162: d8a50513 addi a0,a0,-630 # 4ee8 <malloc+0x168>
+ 166: 00005097 auipc ra,0x5
+ 16a: b62080e7 jalr -1182(ra) # 4cc8 <printf>
+ exit(1);
+ 16e: 4505 li a0,1
+ 170: 00004097 auipc ra,0x4
+ 174: 794080e7 jalr 1940(ra) # 4904 <exit>
+ printf("%s: open doesnotexist succeeded!\n", s);
+ 178: 85a6 mv a1,s1
+ 17a: 00005517 auipc a0,0x5
+ 17e: d9650513 addi a0,a0,-618 # 4f10 <malloc+0x190>
+ 182: 00005097 auipc ra,0x5
+ 186: b46080e7 jalr -1210(ra) # 4cc8 <printf>
+ exit(1);
+ 18a: 4505 li a0,1
+ 18c: 00004097 auipc ra,0x4
+ 190: 778080e7 jalr 1912(ra) # 4904 <exit>
+
+0000000000000194 <truncate2>:
+{
+ 194: 7179 addi sp,sp,-48
+ 196: f406 sd ra,40(sp)
+ 198: f022 sd s0,32(sp)
+ 19a: ec26 sd s1,24(sp)
+ 19c: e84a sd s2,16(sp)
+ 19e: e44e sd s3,8(sp)
+ 1a0: 1800 addi s0,sp,48
+ 1a2: 89aa mv s3,a0
+ remove("truncfile");
+ 1a4: 00005517 auipc a0,0x5
+ 1a8: d9450513 addi a0,a0,-620 # 4f38 <malloc+0x1b8>
+ 1ac: 00005097 auipc ra,0x5
+ 1b0: 818080e7 jalr -2024(ra) # 49c4 <remove>
+ int fd1 = open("truncfile", O_CREATE|O_TRUNC|O_WRONLY);
+ 1b4: 60100593 li a1,1537
+ 1b8: 00005517 auipc a0,0x5
+ 1bc: d8050513 addi a0,a0,-640 # 4f38 <malloc+0x1b8>
+ 1c0: 00004097 auipc ra,0x4
+ 1c4: 790080e7 jalr 1936(ra) # 4950 <open>
+ 1c8: 84aa mv s1,a0
+ write(fd1, "abcd", 4);
+ 1ca: 4611 li a2,4
+ 1cc: 00005597 auipc a1,0x5
+ 1d0: d7c58593 addi a1,a1,-644 # 4f48 <malloc+0x1c8>
+ 1d4: 00004097 auipc ra,0x4
+ 1d8: 756080e7 jalr 1878(ra) # 492a <write>
+ int fd2 = open("truncfile", O_TRUNC|O_WRONLY);
+ 1dc: 40100593 li a1,1025
+ 1e0: 00005517 auipc a0,0x5
+ 1e4: d5850513 addi a0,a0,-680 # 4f38 <malloc+0x1b8>
+ 1e8: 00004097 auipc ra,0x4
+ 1ec: 768080e7 jalr 1896(ra) # 4950 <open>
+ 1f0: 892a mv s2,a0
+ int n = write(fd1, "x", 1);
+ 1f2: 4605 li a2,1
+ 1f4: 00005597 auipc a1,0x5
+ 1f8: d5c58593 addi a1,a1,-676 # 4f50 <malloc+0x1d0>
+ 1fc: 8526 mv a0,s1
+ 1fe: 00004097 auipc ra,0x4
+ 202: 72c080e7 jalr 1836(ra) # 492a <write>
+ if(n != -1){
+ 206: 57fd li a5,-1
+ 208: 02f51b63 bne a0,a5,23e <truncate2+0xaa>
+ remove("truncfile");
+ 20c: 00005517 auipc a0,0x5
+ 210: d2c50513 addi a0,a0,-724 # 4f38 <malloc+0x1b8>
+ 214: 00004097 auipc ra,0x4
+ 218: 7b0080e7 jalr 1968(ra) # 49c4 <remove>
+ close(fd1);
+ 21c: 8526 mv a0,s1
+ 21e: 00004097 auipc ra,0x4
+ 222: 716080e7 jalr 1814(ra) # 4934 <close>
+ close(fd2);
+ 226: 854a mv a0,s2
+ 228: 00004097 auipc ra,0x4
+ 22c: 70c080e7 jalr 1804(ra) # 4934 <close>
+}
+ 230: 70a2 ld ra,40(sp)
+ 232: 7402 ld s0,32(sp)
+ 234: 64e2 ld s1,24(sp)
+ 236: 6942 ld s2,16(sp)
+ 238: 69a2 ld s3,8(sp)
+ 23a: 6145 addi sp,sp,48
+ 23c: 8082 ret
+ printf("%s: write returned %d, expected -1\n", s, n);
+ 23e: 862a mv a2,a0
+ 240: 85ce mv a1,s3
+ 242: 00005517 auipc a0,0x5
+ 246: d1650513 addi a0,a0,-746 # 4f58 <malloc+0x1d8>
+ 24a: 00005097 auipc ra,0x5
+ 24e: a7e080e7 jalr -1410(ra) # 4cc8 <printf>
+ exit(1);
+ 252: 4505 li a0,1
+ 254: 00004097 auipc ra,0x4
+ 258: 6b0080e7 jalr 1712(ra) # 4904 <exit>
+
+000000000000025c <createtest>:
+{
+ 25c: 7179 addi sp,sp,-48
+ 25e: f406 sd ra,40(sp)
+ 260: f022 sd s0,32(sp)
+ 262: ec26 sd s1,24(sp)
+ 264: e84a sd s2,16(sp)
+ 266: e44e sd s3,8(sp)
+ 268: 1800 addi s0,sp,48
+ name[0] = 'a';
+ 26a: 00007797 auipc a5,0x7
+ 26e: e0e78793 addi a5,a5,-498 # 7078 <name>
+ 272: 06100713 li a4,97
+ 276: 00e78023 sb a4,0(a5)
+ name[2] = '\0';
+ 27a: 00078123 sb zero,2(a5)
+ 27e: 03000493 li s1,48
+ name[1] = '0' + i;
+ 282: 893e mv s2,a5
+ for(i = 0; i < N; i++){
+ 284: 06400993 li s3,100
+ name[1] = '0' + i;
+ 288: 009900a3 sb s1,1(s2)
+ fd = open(name, O_CREATE|O_RDWR);
+ 28c: 20200593 li a1,514
+ 290: 854a mv a0,s2
+ 292: 00004097 auipc ra,0x4
+ 296: 6be080e7 jalr 1726(ra) # 4950 <open>
+ close(fd);
+ 29a: 00004097 auipc ra,0x4
+ 29e: 69a080e7 jalr 1690(ra) # 4934 <close>
+ for(i = 0; i < N; i++){
+ 2a2: 2485 addiw s1,s1,1
+ 2a4: 0ff4f493 zext.b s1,s1
+ 2a8: ff3490e3 bne s1,s3,288 <createtest+0x2c>
+ name[0] = 'a';
+ 2ac: 00007797 auipc a5,0x7
+ 2b0: dcc78793 addi a5,a5,-564 # 7078 <name>
+ 2b4: 06100713 li a4,97
+ 2b8: 00e78023 sb a4,0(a5)
+ name[2] = '\0';
+ 2bc: 00078123 sb zero,2(a5)
+ 2c0: 03000493 li s1,48
+ name[1] = '0' + i;
+ 2c4: 893e mv s2,a5
+ for(i = 0; i < N; i++){
+ 2c6: 06400993 li s3,100
+ name[1] = '0' + i;
+ 2ca: 009900a3 sb s1,1(s2)
+ remove(name);
+ 2ce: 854a mv a0,s2
+ 2d0: 00004097 auipc ra,0x4
+ 2d4: 6f4080e7 jalr 1780(ra) # 49c4 <remove>
+ for(i = 0; i < N; i++){
+ 2d8: 2485 addiw s1,s1,1
+ 2da: 0ff4f493 zext.b s1,s1
+ 2de: ff3496e3 bne s1,s3,2ca <createtest+0x6e>
+}
+ 2e2: 70a2 ld ra,40(sp)
+ 2e4: 7402 ld s0,32(sp)
+ 2e6: 64e2 ld s1,24(sp)
+ 2e8: 6942 ld s2,16(sp)
+ 2ea: 69a2 ld s3,8(sp)
+ 2ec: 6145 addi sp,sp,48
+ 2ee: 8082 ret
+
+00000000000002f0 <bigwrite>:
+{
+ 2f0: 715d addi sp,sp,-80
+ 2f2: e486 sd ra,72(sp)
+ 2f4: e0a2 sd s0,64(sp)
+ 2f6: fc26 sd s1,56(sp)
+ 2f8: f84a sd s2,48(sp)
+ 2fa: f44e sd s3,40(sp)
+ 2fc: f052 sd s4,32(sp)
+ 2fe: ec56 sd s5,24(sp)
+ 300: e85a sd s6,16(sp)
+ 302: e45e sd s7,8(sp)
+ 304: 0880 addi s0,sp,80
+ 306: 8baa mv s7,a0
+ remove("bigwrite");
+ 308: 00005517 auipc a0,0x5
+ 30c: c7850513 addi a0,a0,-904 # 4f80 <malloc+0x200>
+ 310: 00004097 auipc ra,0x4
+ 314: 6b4080e7 jalr 1716(ra) # 49c4 <remove>
+ for(sz = 499; sz < (MAXOPBLOCKS+2)*BSIZE; sz += 471){
+ 318: 1f300493 li s1,499
+ fd = open("bigwrite", O_CREATE | O_RDWR);
+ 31c: 00005a97 auipc s5,0x5
+ 320: c64a8a93 addi s5,s5,-924 # 4f80 <malloc+0x200>
+ int cc = write(fd, buf, sz);
+ 324: 0000aa17 auipc s4,0xa
+ 328: 574a0a13 addi s4,s4,1396 # a898 <buf>
+ for(sz = 499; sz < (MAXOPBLOCKS+2)*BSIZE; sz += 471){
+ 32c: 6b09 lui s6,0x2
+ 32e: 807b0b13 addi s6,s6,-2041 # 1807 <forkfork+0x49>
+ fd = open("bigwrite", O_CREATE | O_RDWR);
+ 332: 20200593 li a1,514
+ 336: 8556 mv a0,s5
+ 338: 00004097 auipc ra,0x4
+ 33c: 618080e7 jalr 1560(ra) # 4950 <open>
+ 340: 892a mv s2,a0
+ if(fd < 0){
+ 342: 04054d63 bltz a0,39c <bigwrite+0xac>
+ int cc = write(fd, buf, sz);
+ 346: 8626 mv a2,s1
+ 348: 85d2 mv a1,s4
+ 34a: 00004097 auipc ra,0x4
+ 34e: 5e0080e7 jalr 1504(ra) # 492a <write>
+ 352: 89aa mv s3,a0
+ if(cc != sz){
+ 354: 06a49263 bne s1,a0,3b8 <bigwrite+0xc8>
+ int cc = write(fd, buf, sz);
+ 358: 8626 mv a2,s1
+ 35a: 85d2 mv a1,s4
+ 35c: 854a mv a0,s2
+ 35e: 00004097 auipc ra,0x4
+ 362: 5cc080e7 jalr 1484(ra) # 492a <write>
+ if(cc != sz){
+ 366: 04951a63 bne a0,s1,3ba <bigwrite+0xca>
+ close(fd);
+ 36a: 854a mv a0,s2
+ 36c: 00004097 auipc ra,0x4
+ 370: 5c8080e7 jalr 1480(ra) # 4934 <close>
+ remove("bigwrite");
+ 374: 8556 mv a0,s5
+ 376: 00004097 auipc ra,0x4
+ 37a: 64e080e7 jalr 1614(ra) # 49c4 <remove>
+ for(sz = 499; sz < (MAXOPBLOCKS+2)*BSIZE; sz += 471){
+ 37e: 1d74849b addiw s1,s1,471
+ 382: fb6498e3 bne s1,s6,332 <bigwrite+0x42>
+}
+ 386: 60a6 ld ra,72(sp)
+ 388: 6406 ld s0,64(sp)
+ 38a: 74e2 ld s1,56(sp)
+ 38c: 7942 ld s2,48(sp)
+ 38e: 79a2 ld s3,40(sp)
+ 390: 7a02 ld s4,32(sp)
+ 392: 6ae2 ld s5,24(sp)
+ 394: 6b42 ld s6,16(sp)
+ 396: 6ba2 ld s7,8(sp)
+ 398: 6161 addi sp,sp,80
+ 39a: 8082 ret
+ printf("%s: cannot create bigwrite\n", s);
+ 39c: 85de mv a1,s7
+ 39e: 00005517 auipc a0,0x5
+ 3a2: bf250513 addi a0,a0,-1038 # 4f90 <malloc+0x210>
+ 3a6: 00005097 auipc ra,0x5
+ 3aa: 922080e7 jalr -1758(ra) # 4cc8 <printf>
+ exit(1);
+ 3ae: 4505 li a0,1
+ 3b0: 00004097 auipc ra,0x4
+ 3b4: 554080e7 jalr 1364(ra) # 4904 <exit>
+ if(cc != sz){
+ 3b8: 89a6 mv s3,s1
+ printf("%s: write(%d) ret %d\n", s, sz, cc);
+ 3ba: 86aa mv a3,a0
+ 3bc: 864e mv a2,s3
+ 3be: 85de mv a1,s7
+ 3c0: 00005517 auipc a0,0x5
+ 3c4: bf050513 addi a0,a0,-1040 # 4fb0 <malloc+0x230>
+ 3c8: 00005097 auipc ra,0x5
+ 3cc: 900080e7 jalr -1792(ra) # 4cc8 <printf>
+ exit(1);
+ 3d0: 4505 li a0,1
+ 3d2: 00004097 auipc ra,0x4
+ 3d6: 532080e7 jalr 1330(ra) # 4904 <exit>
+
+00000000000003da <badwrite>:
+// file is deleted? if the kernel has this bug, it will panic: balloc:
+// out of blocks. assumed_free may need to be raised to be more than
+// the number of free blocks. this test takes a long time.
+void
+badwrite(char *s)
+{
+ 3da: 7179 addi sp,sp,-48
+ 3dc: f406 sd ra,40(sp)
+ 3de: f022 sd s0,32(sp)
+ 3e0: ec26 sd s1,24(sp)
+ 3e2: e84a sd s2,16(sp)
+ 3e4: e44e sd s3,8(sp)
+ 3e6: e052 sd s4,0(sp)
+ 3e8: 1800 addi s0,sp,48
+ int assumed_free = 600;
+
+ remove("junk");
+ 3ea: 00005517 auipc a0,0x5
+ 3ee: bde50513 addi a0,a0,-1058 # 4fc8 <malloc+0x248>
+ 3f2: 00004097 auipc ra,0x4
+ 3f6: 5d2080e7 jalr 1490(ra) # 49c4 <remove>
+ 3fa: 25800913 li s2,600
+ for(int i = 0; i < assumed_free; i++){
+ int fd = open("junk", O_CREATE|O_WRONLY);
+ 3fe: 00005997 auipc s3,0x5
+ 402: bca98993 addi s3,s3,-1078 # 4fc8 <malloc+0x248>
+ if(fd < 0){
+ printf("open junk failed\n");
+ exit(1);
+ }
+ write(fd, (char*)0xffffffffffL, 1);
+ 406: 5a7d li s4,-1
+ 408: 018a5a13 srli s4,s4,0x18
+ int fd = open("junk", O_CREATE|O_WRONLY);
+ 40c: 20100593 li a1,513
+ 410: 854e mv a0,s3
+ 412: 00004097 auipc ra,0x4
+ 416: 53e080e7 jalr 1342(ra) # 4950 <open>
+ 41a: 84aa mv s1,a0
+ if(fd < 0){
+ 41c: 06054b63 bltz a0,492 <badwrite+0xb8>
+ write(fd, (char*)0xffffffffffL, 1);
+ 420: 4605 li a2,1
+ 422: 85d2 mv a1,s4
+ 424: 00004097 auipc ra,0x4
+ 428: 506080e7 jalr 1286(ra) # 492a <write>
+ close(fd);
+ 42c: 8526 mv a0,s1
+ 42e: 00004097 auipc ra,0x4
+ 432: 506080e7 jalr 1286(ra) # 4934 <close>
+ remove("junk");
+ 436: 854e mv a0,s3
+ 438: 00004097 auipc ra,0x4
+ 43c: 58c080e7 jalr 1420(ra) # 49c4 <remove>
+ for(int i = 0; i < assumed_free; i++){
+ 440: 397d addiw s2,s2,-1
+ 442: fc0915e3 bnez s2,40c <badwrite+0x32>
+ }
+
+ int fd = open("junk", O_CREATE|O_WRONLY);
+ 446: 20100593 li a1,513
+ 44a: 00005517 auipc a0,0x5
+ 44e: b7e50513 addi a0,a0,-1154 # 4fc8 <malloc+0x248>
+ 452: 00004097 auipc ra,0x4
+ 456: 4fe080e7 jalr 1278(ra) # 4950 <open>
+ 45a: 84aa mv s1,a0
+ if(fd < 0){
+ 45c: 04054863 bltz a0,4ac <badwrite+0xd2>
+ printf("open junk failed\n");
+ exit(1);
+ }
+ if(write(fd, "x", 1) != 1){
+ 460: 4605 li a2,1
+ 462: 00005597 auipc a1,0x5
+ 466: aee58593 addi a1,a1,-1298 # 4f50 <malloc+0x1d0>
+ 46a: 00004097 auipc ra,0x4
+ 46e: 4c0080e7 jalr 1216(ra) # 492a <write>
+ 472: 4785 li a5,1
+ 474: 04f50963 beq a0,a5,4c6 <badwrite+0xec>
+ printf("write failed\n");
+ 478: 00005517 auipc a0,0x5
+ 47c: b7050513 addi a0,a0,-1168 # 4fe8 <malloc+0x268>
+ 480: 00005097 auipc ra,0x5
+ 484: 848080e7 jalr -1976(ra) # 4cc8 <printf>
+ exit(1);
+ 488: 4505 li a0,1
+ 48a: 00004097 auipc ra,0x4
+ 48e: 47a080e7 jalr 1146(ra) # 4904 <exit>
+ printf("open junk failed\n");
+ 492: 00005517 auipc a0,0x5
+ 496: b3e50513 addi a0,a0,-1218 # 4fd0 <malloc+0x250>
+ 49a: 00005097 auipc ra,0x5
+ 49e: 82e080e7 jalr -2002(ra) # 4cc8 <printf>
+ exit(1);
+ 4a2: 4505 li a0,1
+ 4a4: 00004097 auipc ra,0x4
+ 4a8: 460080e7 jalr 1120(ra) # 4904 <exit>
+ printf("open junk failed\n");
+ 4ac: 00005517 auipc a0,0x5
+ 4b0: b2450513 addi a0,a0,-1244 # 4fd0 <malloc+0x250>
+ 4b4: 00005097 auipc ra,0x5
+ 4b8: 814080e7 jalr -2028(ra) # 4cc8 <printf>
+ exit(1);
+ 4bc: 4505 li a0,1
+ 4be: 00004097 auipc ra,0x4
+ 4c2: 446080e7 jalr 1094(ra) # 4904 <exit>
+ }
+ close(fd);
+ 4c6: 8526 mv a0,s1
+ 4c8: 00004097 auipc ra,0x4
+ 4cc: 46c080e7 jalr 1132(ra) # 4934 <close>
+ remove("junk");
+ 4d0: 00005517 auipc a0,0x5
+ 4d4: af850513 addi a0,a0,-1288 # 4fc8 <malloc+0x248>
+ 4d8: 00004097 auipc ra,0x4
+ 4dc: 4ec080e7 jalr 1260(ra) # 49c4 <remove>
+
+ exit(0);
+ 4e0: 4501 li a0,0
+ 4e2: 00004097 auipc ra,0x4
+ 4e6: 422080e7 jalr 1058(ra) # 4904 <exit>
+
+00000000000004ea <copyin>:
+{
+ 4ea: 7159 addi sp,sp,-112
+ 4ec: f486 sd ra,104(sp)
+ 4ee: f0a2 sd s0,96(sp)
+ 4f0: eca6 sd s1,88(sp)
+ 4f2: e8ca sd s2,80(sp)
+ 4f4: e4ce sd s3,72(sp)
+ 4f6: e0d2 sd s4,64(sp)
+ 4f8: fc56 sd s5,56(sp)
+ 4fa: 1880 addi s0,sp,112
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+ 4fc: 4785 li a5,1
+ 4fe: 07fe slli a5,a5,0x1f
+ 500: faf43823 sd a5,-80(s0)
+ 504: 57fd li a5,-1
+ 506: faf43c23 sd a5,-72(s0)
+ for(int ai = 0; ai < 2; ai++){
+ 50a: fb040913 addi s2,s0,-80
+ 50e: fc040793 addi a5,s0,-64
+ 512: f8f43c23 sd a5,-104(s0)
+ int fd = open("copyin1", O_CREATE|O_WRONLY);
+ 516: 00005a17 auipc s4,0x5
+ 51a: ae2a0a13 addi s4,s4,-1310 # 4ff8 <malloc+0x278>
+ if(pipe(fds) < 0){
+ 51e: fa840a93 addi s5,s0,-88
+ uint64 addr = addrs[ai];
+ 522: 00093983 ld s3,0(s2)
+ int fd = open("copyin1", O_CREATE|O_WRONLY);
+ 526: 20100593 li a1,513
+ 52a: 8552 mv a0,s4
+ 52c: 00004097 auipc ra,0x4
+ 530: 424080e7 jalr 1060(ra) # 4950 <open>
+ 534: 84aa mv s1,a0
+ if(fd < 0){
+ 536: 08054863 bltz a0,5c6 <copyin+0xdc>
+ int n = write(fd, (void*)addr, 8192);
+ 53a: 6609 lui a2,0x2
+ 53c: 85ce mv a1,s3
+ 53e: 00004097 auipc ra,0x4
+ 542: 3ec080e7 jalr 1004(ra) # 492a <write>
+ if(n >= 0){
+ 546: 08055d63 bgez a0,5e0 <copyin+0xf6>
+ close(fd);
+ 54a: 8526 mv a0,s1
+ 54c: 00004097 auipc ra,0x4
+ 550: 3e8080e7 jalr 1000(ra) # 4934 <close>
+ remove("copyin1");
+ 554: 8552 mv a0,s4
+ 556: 00004097 auipc ra,0x4
+ 55a: 46e080e7 jalr 1134(ra) # 49c4 <remove>
+ n = write(1, (char*)addr, 8192);
+ 55e: 6609 lui a2,0x2
+ 560: 85ce mv a1,s3
+ 562: 4505 li a0,1
+ 564: 00004097 auipc ra,0x4
+ 568: 3c6080e7 jalr 966(ra) # 492a <write>
+ if(n > 0){
+ 56c: 08a04963 bgtz a0,5fe <copyin+0x114>
+ if(pipe(fds) < 0){
+ 570: 8556 mv a0,s5
+ 572: 00004097 auipc ra,0x4
+ 576: 3a4080e7 jalr 932(ra) # 4916 <pipe>
+ 57a: 0a054163 bltz a0,61c <copyin+0x132>
+ n = write(fds[1], (char*)addr, 8192);
+ 57e: 6609 lui a2,0x2
+ 580: 85ce mv a1,s3
+ 582: fac42503 lw a0,-84(s0)
+ 586: 00004097 auipc ra,0x4
+ 58a: 3a4080e7 jalr 932(ra) # 492a <write>
+ if(n > 0){
+ 58e: 0aa04463 bgtz a0,636 <copyin+0x14c>
+ close(fds[0]);
+ 592: fa842503 lw a0,-88(s0)
+ 596: 00004097 auipc ra,0x4
+ 59a: 39e080e7 jalr 926(ra) # 4934 <close>
+ close(fds[1]);
+ 59e: fac42503 lw a0,-84(s0)
+ 5a2: 00004097 auipc ra,0x4
+ 5a6: 392080e7 jalr 914(ra) # 4934 <close>
+ for(int ai = 0; ai < 2; ai++){
+ 5aa: 0921 addi s2,s2,8
+ 5ac: f9843783 ld a5,-104(s0)
+ 5b0: f6f919e3 bne s2,a5,522 <copyin+0x38>
+}
+ 5b4: 70a6 ld ra,104(sp)
+ 5b6: 7406 ld s0,96(sp)
+ 5b8: 64e6 ld s1,88(sp)
+ 5ba: 6946 ld s2,80(sp)
+ 5bc: 69a6 ld s3,72(sp)
+ 5be: 6a06 ld s4,64(sp)
+ 5c0: 7ae2 ld s5,56(sp)
+ 5c2: 6165 addi sp,sp,112
+ 5c4: 8082 ret
+ printf("open(copyin1) failed\n");
+ 5c6: 00005517 auipc a0,0x5
+ 5ca: a3a50513 addi a0,a0,-1478 # 5000 <malloc+0x280>
+ 5ce: 00004097 auipc ra,0x4
+ 5d2: 6fa080e7 jalr 1786(ra) # 4cc8 <printf>
+ exit(1);
+ 5d6: 4505 li a0,1
+ 5d8: 00004097 auipc ra,0x4
+ 5dc: 32c080e7 jalr 812(ra) # 4904 <exit>
+ printf("write(fd, %p, 8192) returned %d, not -1\n", addr, n);
+ 5e0: 862a mv a2,a0
+ 5e2: 85ce mv a1,s3
+ 5e4: 00005517 auipc a0,0x5
+ 5e8: a3450513 addi a0,a0,-1484 # 5018 <malloc+0x298>
+ 5ec: 00004097 auipc ra,0x4
+ 5f0: 6dc080e7 jalr 1756(ra) # 4cc8 <printf>
+ exit(1);
+ 5f4: 4505 li a0,1
+ 5f6: 00004097 auipc ra,0x4
+ 5fa: 30e080e7 jalr 782(ra) # 4904 <exit>
+ printf("write(1, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ 5fe: 862a mv a2,a0
+ 600: 85ce mv a1,s3
+ 602: 00005517 auipc a0,0x5
+ 606: a4650513 addi a0,a0,-1466 # 5048 <malloc+0x2c8>
+ 60a: 00004097 auipc ra,0x4
+ 60e: 6be080e7 jalr 1726(ra) # 4cc8 <printf>
+ exit(1);
+ 612: 4505 li a0,1
+ 614: 00004097 auipc ra,0x4
+ 618: 2f0080e7 jalr 752(ra) # 4904 <exit>
+ printf("pipe() failed\n");
+ 61c: 00005517 auipc a0,0x5
+ 620: a5c50513 addi a0,a0,-1444 # 5078 <malloc+0x2f8>
+ 624: 00004097 auipc ra,0x4
+ 628: 6a4080e7 jalr 1700(ra) # 4cc8 <printf>
+ exit(1);
+ 62c: 4505 li a0,1
+ 62e: 00004097 auipc ra,0x4
+ 632: 2d6080e7 jalr 726(ra) # 4904 <exit>
+ printf("write(pipe, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ 636: 862a mv a2,a0
+ 638: 85ce mv a1,s3
+ 63a: 00005517 auipc a0,0x5
+ 63e: a4e50513 addi a0,a0,-1458 # 5088 <malloc+0x308>
+ 642: 00004097 auipc ra,0x4
+ 646: 686080e7 jalr 1670(ra) # 4cc8 <printf>
+ exit(1);
+ 64a: 4505 li a0,1
+ 64c: 00004097 auipc ra,0x4
+ 650: 2b8080e7 jalr 696(ra) # 4904 <exit>
+
+0000000000000654 <copyout>:
+{
+ 654: 7159 addi sp,sp,-112
+ 656: f486 sd ra,104(sp)
+ 658: f0a2 sd s0,96(sp)
+ 65a: eca6 sd s1,88(sp)
+ 65c: e8ca sd s2,80(sp)
+ 65e: e4ce sd s3,72(sp)
+ 660: e0d2 sd s4,64(sp)
+ 662: fc56 sd s5,56(sp)
+ 664: f85a sd s6,48(sp)
+ 666: 1880 addi s0,sp,112
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+ 668: 4785 li a5,1
+ 66a: 07fe slli a5,a5,0x1f
+ 66c: faf43823 sd a5,-80(s0)
+ 670: 57fd li a5,-1
+ 672: faf43c23 sd a5,-72(s0)
+ for(int ai = 0; ai < 2; ai++){
+ 676: fb040913 addi s2,s0,-80
+ 67a: fc040793 addi a5,s0,-64
+ 67e: f8f43c23 sd a5,-104(s0)
+ int fd = open("README", 0);
+ 682: 00005a97 auipc s5,0x5
+ 686: a36a8a93 addi s5,s5,-1482 # 50b8 <malloc+0x338>
+ if(pipe(fds) < 0){
+ 68a: fa840a13 addi s4,s0,-88
+ n = write(fds[1], "x", 1);
+ 68e: 00005b17 auipc s6,0x5
+ 692: 8c2b0b13 addi s6,s6,-1854 # 4f50 <malloc+0x1d0>
+ uint64 addr = addrs[ai];
+ 696: 00093983 ld s3,0(s2)
+ int fd = open("README", 0);
+ 69a: 4581 li a1,0
+ 69c: 8556 mv a0,s5
+ 69e: 00004097 auipc ra,0x4
+ 6a2: 2b2080e7 jalr 690(ra) # 4950 <open>
+ 6a6: 84aa mv s1,a0
+ if(fd < 0){
+ 6a8: 08054663 bltz a0,734 <copyout+0xe0>
+ int n = read(fd, (void*)addr, 8192);
+ 6ac: 6609 lui a2,0x2
+ 6ae: 85ce mv a1,s3
+ 6b0: 00004097 auipc ra,0x4
+ 6b4: 270080e7 jalr 624(ra) # 4920 <read>
+ if(n > 0){
+ 6b8: 08a04b63 bgtz a0,74e <copyout+0xfa>
+ close(fd);
+ 6bc: 8526 mv a0,s1
+ 6be: 00004097 auipc ra,0x4
+ 6c2: 276080e7 jalr 630(ra) # 4934 <close>
+ if(pipe(fds) < 0){
+ 6c6: 8552 mv a0,s4
+ 6c8: 00004097 auipc ra,0x4
+ 6cc: 24e080e7 jalr 590(ra) # 4916 <pipe>
+ 6d0: 08054e63 bltz a0,76c <copyout+0x118>
+ n = write(fds[1], "x", 1);
+ 6d4: 4605 li a2,1
+ 6d6: 85da mv a1,s6
+ 6d8: fac42503 lw a0,-84(s0)
+ 6dc: 00004097 auipc ra,0x4
+ 6e0: 24e080e7 jalr 590(ra) # 492a <write>
+ if(n != 1){
+ 6e4: 4785 li a5,1
+ 6e6: 0af51063 bne a0,a5,786 <copyout+0x132>
+ n = read(fds[0], (void*)addr, 8192);
+ 6ea: 6609 lui a2,0x2
+ 6ec: 85ce mv a1,s3
+ 6ee: fa842503 lw a0,-88(s0)
+ 6f2: 00004097 auipc ra,0x4
+ 6f6: 22e080e7 jalr 558(ra) # 4920 <read>
+ if(n > 0){
+ 6fa: 0aa04363 bgtz a0,7a0 <copyout+0x14c>
+ close(fds[0]);
+ 6fe: fa842503 lw a0,-88(s0)
+ 702: 00004097 auipc ra,0x4
+ 706: 232080e7 jalr 562(ra) # 4934 <close>
+ close(fds[1]);
+ 70a: fac42503 lw a0,-84(s0)
+ 70e: 00004097 auipc ra,0x4
+ 712: 226080e7 jalr 550(ra) # 4934 <close>
+ for(int ai = 0; ai < 2; ai++){
+ 716: 0921 addi s2,s2,8
+ 718: f9843783 ld a5,-104(s0)
+ 71c: f6f91de3 bne s2,a5,696 <copyout+0x42>
+}
+ 720: 70a6 ld ra,104(sp)
+ 722: 7406 ld s0,96(sp)
+ 724: 64e6 ld s1,88(sp)
+ 726: 6946 ld s2,80(sp)
+ 728: 69a6 ld s3,72(sp)
+ 72a: 6a06 ld s4,64(sp)
+ 72c: 7ae2 ld s5,56(sp)
+ 72e: 7b42 ld s6,48(sp)
+ 730: 6165 addi sp,sp,112
+ 732: 8082 ret
+ printf("open(README) failed\n");
+ 734: 00005517 auipc a0,0x5
+ 738: 98c50513 addi a0,a0,-1652 # 50c0 <malloc+0x340>
+ 73c: 00004097 auipc ra,0x4
+ 740: 58c080e7 jalr 1420(ra) # 4cc8 <printf>
+ exit(1);
+ 744: 4505 li a0,1
+ 746: 00004097 auipc ra,0x4
+ 74a: 1be080e7 jalr 446(ra) # 4904 <exit>
+ printf("read(fd, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ 74e: 862a mv a2,a0
+ 750: 85ce mv a1,s3
+ 752: 00005517 auipc a0,0x5
+ 756: 98650513 addi a0,a0,-1658 # 50d8 <malloc+0x358>
+ 75a: 00004097 auipc ra,0x4
+ 75e: 56e080e7 jalr 1390(ra) # 4cc8 <printf>
+ exit(1);
+ 762: 4505 li a0,1
+ 764: 00004097 auipc ra,0x4
+ 768: 1a0080e7 jalr 416(ra) # 4904 <exit>
+ printf("pipe() failed\n");
+ 76c: 00005517 auipc a0,0x5
+ 770: 90c50513 addi a0,a0,-1780 # 5078 <malloc+0x2f8>
+ 774: 00004097 auipc ra,0x4
+ 778: 554080e7 jalr 1364(ra) # 4cc8 <printf>
+ exit(1);
+ 77c: 4505 li a0,1
+ 77e: 00004097 auipc ra,0x4
+ 782: 186080e7 jalr 390(ra) # 4904 <exit>
+ printf("pipe write failed\n");
+ 786: 00005517 auipc a0,0x5
+ 78a: 98250513 addi a0,a0,-1662 # 5108 <malloc+0x388>
+ 78e: 00004097 auipc ra,0x4
+ 792: 53a080e7 jalr 1338(ra) # 4cc8 <printf>
+ exit(1);
+ 796: 4505 li a0,1
+ 798: 00004097 auipc ra,0x4
+ 79c: 16c080e7 jalr 364(ra) # 4904 <exit>
+ printf("read(pipe, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ 7a0: 862a mv a2,a0
+ 7a2: 85ce mv a1,s3
+ 7a4: 00005517 auipc a0,0x5
+ 7a8: 97c50513 addi a0,a0,-1668 # 5120 <malloc+0x3a0>
+ 7ac: 00004097 auipc ra,0x4
+ 7b0: 51c080e7 jalr 1308(ra) # 4cc8 <printf>
+ exit(1);
+ 7b4: 4505 li a0,1
+ 7b6: 00004097 auipc ra,0x4
+ 7ba: 14e080e7 jalr 334(ra) # 4904 <exit>
+
+00000000000007be <truncate1>:
+{
+ 7be: 711d addi sp,sp,-96
+ 7c0: ec86 sd ra,88(sp)
+ 7c2: e8a2 sd s0,80(sp)
+ 7c4: e4a6 sd s1,72(sp)
+ 7c6: e0ca sd s2,64(sp)
+ 7c8: fc4e sd s3,56(sp)
+ 7ca: f852 sd s4,48(sp)
+ 7cc: f456 sd s5,40(sp)
+ 7ce: 1080 addi s0,sp,96
+ 7d0: 8aaa mv s5,a0
+ remove("truncfile");
+ 7d2: 00004517 auipc a0,0x4
+ 7d6: 76650513 addi a0,a0,1894 # 4f38 <malloc+0x1b8>
+ 7da: 00004097 auipc ra,0x4
+ 7de: 1ea080e7 jalr 490(ra) # 49c4 <remove>
+ int fd1 = open("truncfile", O_CREATE|O_WRONLY|O_TRUNC);
+ 7e2: 60100593 li a1,1537
+ 7e6: 00004517 auipc a0,0x4
+ 7ea: 75250513 addi a0,a0,1874 # 4f38 <malloc+0x1b8>
+ 7ee: 00004097 auipc ra,0x4
+ 7f2: 162080e7 jalr 354(ra) # 4950 <open>
+ 7f6: 84aa mv s1,a0
+ write(fd1, "abcd", 4);
+ 7f8: 4611 li a2,4
+ 7fa: 00004597 auipc a1,0x4
+ 7fe: 74e58593 addi a1,a1,1870 # 4f48 <malloc+0x1c8>
+ 802: 00004097 auipc ra,0x4
+ 806: 128080e7 jalr 296(ra) # 492a <write>
+ close(fd1);
+ 80a: 8526 mv a0,s1
+ 80c: 00004097 auipc ra,0x4
+ 810: 128080e7 jalr 296(ra) # 4934 <close>
+ int fd2 = open("truncfile", O_RDONLY);
+ 814: 4581 li a1,0
+ 816: 00004517 auipc a0,0x4
+ 81a: 72250513 addi a0,a0,1826 # 4f38 <malloc+0x1b8>
+ 81e: 00004097 auipc ra,0x4
+ 822: 132080e7 jalr 306(ra) # 4950 <open>
+ 826: 84aa mv s1,a0
+ int n = read(fd2, buf, sizeof(buf));
+ 828: 02000613 li a2,32
+ 82c: fa040593 addi a1,s0,-96
+ 830: 00004097 auipc ra,0x4
+ 834: 0f0080e7 jalr 240(ra) # 4920 <read>
+ if(n != 4){
+ 838: 4791 li a5,4
+ 83a: 0cf51e63 bne a0,a5,916 <truncate1+0x158>
+ fd1 = open("truncfile", O_WRONLY|O_TRUNC);
+ 83e: 40100593 li a1,1025
+ 842: 00004517 auipc a0,0x4
+ 846: 6f650513 addi a0,a0,1782 # 4f38 <malloc+0x1b8>
+ 84a: 00004097 auipc ra,0x4
+ 84e: 106080e7 jalr 262(ra) # 4950 <open>
+ 852: 89aa mv s3,a0
+ int fd3 = open("truncfile", O_RDONLY);
+ 854: 4581 li a1,0
+ 856: 00004517 auipc a0,0x4
+ 85a: 6e250513 addi a0,a0,1762 # 4f38 <malloc+0x1b8>
+ 85e: 00004097 auipc ra,0x4
+ 862: 0f2080e7 jalr 242(ra) # 4950 <open>
+ 866: 892a mv s2,a0
+ n = read(fd3, buf, sizeof(buf));
+ 868: 02000613 li a2,32
+ 86c: fa040593 addi a1,s0,-96
+ 870: 00004097 auipc ra,0x4
+ 874: 0b0080e7 jalr 176(ra) # 4920 <read>
+ 878: 8a2a mv s4,a0
+ if(n != 0){
+ 87a: ed4d bnez a0,934 <truncate1+0x176>
+ n = read(fd2, buf, sizeof(buf));
+ 87c: 02000613 li a2,32
+ 880: fa040593 addi a1,s0,-96
+ 884: 8526 mv a0,s1
+ 886: 00004097 auipc ra,0x4
+ 88a: 09a080e7 jalr 154(ra) # 4920 <read>
+ 88e: 8a2a mv s4,a0
+ if(n != 0){
+ 890: e971 bnez a0,964 <truncate1+0x1a6>
+ write(fd1, "abcdef", 6);
+ 892: 4619 li a2,6
+ 894: 00005597 auipc a1,0x5
+ 898: 91c58593 addi a1,a1,-1764 # 51b0 <malloc+0x430>
+ 89c: 854e mv a0,s3
+ 89e: 00004097 auipc ra,0x4
+ 8a2: 08c080e7 jalr 140(ra) # 492a <write>
+ n = read(fd3, buf, sizeof(buf));
+ 8a6: 02000613 li a2,32
+ 8aa: fa040593 addi a1,s0,-96
+ 8ae: 854a mv a0,s2
+ 8b0: 00004097 auipc ra,0x4
+ 8b4: 070080e7 jalr 112(ra) # 4920 <read>
+ if(n != 6){
+ 8b8: 4799 li a5,6
+ 8ba: 0cf51d63 bne a0,a5,994 <truncate1+0x1d6>
+ n = read(fd2, buf, sizeof(buf));
+ 8be: 02000613 li a2,32
+ 8c2: fa040593 addi a1,s0,-96
+ 8c6: 8526 mv a0,s1
+ 8c8: 00004097 auipc ra,0x4
+ 8cc: 058080e7 jalr 88(ra) # 4920 <read>
+ if(n != 2){
+ 8d0: 4789 li a5,2
+ 8d2: 0ef51063 bne a0,a5,9b2 <truncate1+0x1f4>
+ remove("truncfile");
+ 8d6: 00004517 auipc a0,0x4
+ 8da: 66250513 addi a0,a0,1634 # 4f38 <malloc+0x1b8>
+ 8de: 00004097 auipc ra,0x4
+ 8e2: 0e6080e7 jalr 230(ra) # 49c4 <remove>
+ close(fd1);
+ 8e6: 854e mv a0,s3
+ 8e8: 00004097 auipc ra,0x4
+ 8ec: 04c080e7 jalr 76(ra) # 4934 <close>
+ close(fd2);
+ 8f0: 8526 mv a0,s1
+ 8f2: 00004097 auipc ra,0x4
+ 8f6: 042080e7 jalr 66(ra) # 4934 <close>
+ close(fd3);
+ 8fa: 854a mv a0,s2
+ 8fc: 00004097 auipc ra,0x4
+ 900: 038080e7 jalr 56(ra) # 4934 <close>
+}
+ 904: 60e6 ld ra,88(sp)
+ 906: 6446 ld s0,80(sp)
+ 908: 64a6 ld s1,72(sp)
+ 90a: 6906 ld s2,64(sp)
+ 90c: 79e2 ld s3,56(sp)
+ 90e: 7a42 ld s4,48(sp)
+ 910: 7aa2 ld s5,40(sp)
+ 912: 6125 addi sp,sp,96
+ 914: 8082 ret
+ printf("%s: read %d bytes, wanted 4\n", s, n);
+ 916: 862a mv a2,a0
+ 918: 85d6 mv a1,s5
+ 91a: 00005517 auipc a0,0x5
+ 91e: 83650513 addi a0,a0,-1994 # 5150 <malloc+0x3d0>
+ 922: 00004097 auipc ra,0x4
+ 926: 3a6080e7 jalr 934(ra) # 4cc8 <printf>
+ exit(1);
+ 92a: 4505 li a0,1
+ 92c: 00004097 auipc ra,0x4
+ 930: fd8080e7 jalr -40(ra) # 4904 <exit>
+ printf("aaa fd3=%d\n", fd3);
+ 934: 85ca mv a1,s2
+ 936: 00005517 auipc a0,0x5
+ 93a: 83a50513 addi a0,a0,-1990 # 5170 <malloc+0x3f0>
+ 93e: 00004097 auipc ra,0x4
+ 942: 38a080e7 jalr 906(ra) # 4cc8 <printf>
+ printf("%s: read %d bytes, wanted 0\n", s, n);
+ 946: 8652 mv a2,s4
+ 948: 85d6 mv a1,s5
+ 94a: 00005517 auipc a0,0x5
+ 94e: 83650513 addi a0,a0,-1994 # 5180 <malloc+0x400>
+ 952: 00004097 auipc ra,0x4
+ 956: 376080e7 jalr 886(ra) # 4cc8 <printf>
+ exit(1);
+ 95a: 4505 li a0,1
+ 95c: 00004097 auipc ra,0x4
+ 960: fa8080e7 jalr -88(ra) # 4904 <exit>
+ printf("bbb fd2=%d\n", fd2);
+ 964: 85a6 mv a1,s1
+ 966: 00005517 auipc a0,0x5
+ 96a: 83a50513 addi a0,a0,-1990 # 51a0 <malloc+0x420>
+ 96e: 00004097 auipc ra,0x4
+ 972: 35a080e7 jalr 858(ra) # 4cc8 <printf>
+ printf("%s: read %d bytes, wanted 0\n", s, n);
+ 976: 8652 mv a2,s4
+ 978: 85d6 mv a1,s5
+ 97a: 00005517 auipc a0,0x5
+ 97e: 80650513 addi a0,a0,-2042 # 5180 <malloc+0x400>
+ 982: 00004097 auipc ra,0x4
+ 986: 346080e7 jalr 838(ra) # 4cc8 <printf>
+ exit(1);
+ 98a: 4505 li a0,1
+ 98c: 00004097 auipc ra,0x4
+ 990: f78080e7 jalr -136(ra) # 4904 <exit>
+ printf("%s: read %d bytes, wanted 6\n", s, n);
+ 994: 862a mv a2,a0
+ 996: 85d6 mv a1,s5
+ 998: 00005517 auipc a0,0x5
+ 99c: 82050513 addi a0,a0,-2016 # 51b8 <malloc+0x438>
+ 9a0: 00004097 auipc ra,0x4
+ 9a4: 328080e7 jalr 808(ra) # 4cc8 <printf>
+ exit(1);
+ 9a8: 4505 li a0,1
+ 9aa: 00004097 auipc ra,0x4
+ 9ae: f5a080e7 jalr -166(ra) # 4904 <exit>
+ printf("%s: read %d bytes, wanted 2\n", s, n);
+ 9b2: 862a mv a2,a0
+ 9b4: 85d6 mv a1,s5
+ 9b6: 00005517 auipc a0,0x5
+ 9ba: 82250513 addi a0,a0,-2014 # 51d8 <malloc+0x458>
+ 9be: 00004097 auipc ra,0x4
+ 9c2: 30a080e7 jalr 778(ra) # 4cc8 <printf>
+ exit(1);
+ 9c6: 4505 li a0,1
+ 9c8: 00004097 auipc ra,0x4
+ 9cc: f3c080e7 jalr -196(ra) # 4904 <exit>
+
+00000000000009d0 <writetest>:
+{
+ 9d0: 7139 addi sp,sp,-64
+ 9d2: fc06 sd ra,56(sp)
+ 9d4: f822 sd s0,48(sp)
+ 9d6: f426 sd s1,40(sp)
+ 9d8: f04a sd s2,32(sp)
+ 9da: ec4e sd s3,24(sp)
+ 9dc: e852 sd s4,16(sp)
+ 9de: e456 sd s5,8(sp)
+ 9e0: e05a sd s6,0(sp)
+ 9e2: 0080 addi s0,sp,64
+ 9e4: 8b2a mv s6,a0
+ fd = open("small", O_CREATE|O_RDWR);
+ 9e6: 20200593 li a1,514
+ 9ea: 00005517 auipc a0,0x5
+ 9ee: 80e50513 addi a0,a0,-2034 # 51f8 <malloc+0x478>
+ 9f2: 00004097 auipc ra,0x4
+ 9f6: f5e080e7 jalr -162(ra) # 4950 <open>
+ if(fd < 0){
+ 9fa: 0a054d63 bltz a0,ab4 <writetest+0xe4>
+ 9fe: 892a mv s2,a0
+ a00: 4481 li s1,0
+ if(write(fd, "aaaaaaaaaa", SZ) != SZ){
+ a02: 00005997 auipc s3,0x5
+ a06: 81e98993 addi s3,s3,-2018 # 5220 <malloc+0x4a0>
+ if(write(fd, "bbbbbbbbbb", SZ) != SZ){
+ a0a: 00005a97 auipc s5,0x5
+ a0e: 84ea8a93 addi s5,s5,-1970 # 5258 <malloc+0x4d8>
+ for(i = 0; i < N; i++){
+ a12: 06400a13 li s4,100
+ if(write(fd, "aaaaaaaaaa", SZ) != SZ){
+ a16: 4629 li a2,10
+ a18: 85ce mv a1,s3
+ a1a: 854a mv a0,s2
+ a1c: 00004097 auipc ra,0x4
+ a20: f0e080e7 jalr -242(ra) # 492a <write>
+ a24: 47a9 li a5,10
+ a26: 0af51563 bne a0,a5,ad0 <writetest+0x100>
+ if(write(fd, "bbbbbbbbbb", SZ) != SZ){
+ a2a: 4629 li a2,10
+ a2c: 85d6 mv a1,s5
+ a2e: 854a mv a0,s2
+ a30: 00004097 auipc ra,0x4
+ a34: efa080e7 jalr -262(ra) # 492a <write>
+ a38: 47a9 li a5,10
+ a3a: 0af51963 bne a0,a5,aec <writetest+0x11c>
+ for(i = 0; i < N; i++){
+ a3e: 2485 addiw s1,s1,1
+ a40: fd449be3 bne s1,s4,a16 <writetest+0x46>
+ close(fd);
+ a44: 854a mv a0,s2
+ a46: 00004097 auipc ra,0x4
+ a4a: eee080e7 jalr -274(ra) # 4934 <close>
+ fd = open("small", O_RDONLY);
+ a4e: 4581 li a1,0
+ a50: 00004517 auipc a0,0x4
+ a54: 7a850513 addi a0,a0,1960 # 51f8 <malloc+0x478>
+ a58: 00004097 auipc ra,0x4
+ a5c: ef8080e7 jalr -264(ra) # 4950 <open>
+ a60: 84aa mv s1,a0
+ if(fd < 0){
+ a62: 0a054363 bltz a0,b08 <writetest+0x138>
+ i = read(fd, buf, N*SZ*2);
+ a66: 7d000613 li a2,2000
+ a6a: 0000a597 auipc a1,0xa
+ a6e: e2e58593 addi a1,a1,-466 # a898 <buf>
+ a72: 00004097 auipc ra,0x4
+ a76: eae080e7 jalr -338(ra) # 4920 <read>
+ if(i != N*SZ*2){
+ a7a: 7d000793 li a5,2000
+ a7e: 0af51363 bne a0,a5,b24 <writetest+0x154>
+ close(fd);
+ a82: 8526 mv a0,s1
+ a84: 00004097 auipc ra,0x4
+ a88: eb0080e7 jalr -336(ra) # 4934 <close>
+ if(remove("small") < 0){
+ a8c: 00004517 auipc a0,0x4
+ a90: 76c50513 addi a0,a0,1900 # 51f8 <malloc+0x478>
+ a94: 00004097 auipc ra,0x4
+ a98: f30080e7 jalr -208(ra) # 49c4 <remove>
+ a9c: 0a054263 bltz a0,b40 <writetest+0x170>
+}
+ aa0: 70e2 ld ra,56(sp)
+ aa2: 7442 ld s0,48(sp)
+ aa4: 74a2 ld s1,40(sp)
+ aa6: 7902 ld s2,32(sp)
+ aa8: 69e2 ld s3,24(sp)
+ aaa: 6a42 ld s4,16(sp)
+ aac: 6aa2 ld s5,8(sp)
+ aae: 6b02 ld s6,0(sp)
+ ab0: 6121 addi sp,sp,64
+ ab2: 8082 ret
+ printf("%s: error: creat small failed!\n", s);
+ ab4: 85da mv a1,s6
+ ab6: 00004517 auipc a0,0x4
+ aba: 74a50513 addi a0,a0,1866 # 5200 <malloc+0x480>
+ abe: 00004097 auipc ra,0x4
+ ac2: 20a080e7 jalr 522(ra) # 4cc8 <printf>
+ exit(1);
+ ac6: 4505 li a0,1
+ ac8: 00004097 auipc ra,0x4
+ acc: e3c080e7 jalr -452(ra) # 4904 <exit>
+ printf("%s: error: write aa %d new file failed\n", i);
+ ad0: 85a6 mv a1,s1
+ ad2: 00004517 auipc a0,0x4
+ ad6: 75e50513 addi a0,a0,1886 # 5230 <malloc+0x4b0>
+ ada: 00004097 auipc ra,0x4
+ ade: 1ee080e7 jalr 494(ra) # 4cc8 <printf>
+ exit(1);
+ ae2: 4505 li a0,1
+ ae4: 00004097 auipc ra,0x4
+ ae8: e20080e7 jalr -480(ra) # 4904 <exit>
+ printf("%s: error: write bb %d new file failed\n", i);
+ aec: 85a6 mv a1,s1
+ aee: 00004517 auipc a0,0x4
+ af2: 77a50513 addi a0,a0,1914 # 5268 <malloc+0x4e8>
+ af6: 00004097 auipc ra,0x4
+ afa: 1d2080e7 jalr 466(ra) # 4cc8 <printf>
+ exit(1);
+ afe: 4505 li a0,1
+ b00: 00004097 auipc ra,0x4
+ b04: e04080e7 jalr -508(ra) # 4904 <exit>
+ printf("%s: error: open small failed!\n", s);
+ b08: 85da mv a1,s6
+ b0a: 00004517 auipc a0,0x4
+ b0e: 78650513 addi a0,a0,1926 # 5290 <malloc+0x510>
+ b12: 00004097 auipc ra,0x4
+ b16: 1b6080e7 jalr 438(ra) # 4cc8 <printf>
+ exit(1);
+ b1a: 4505 li a0,1
+ b1c: 00004097 auipc ra,0x4
+ b20: de8080e7 jalr -536(ra) # 4904 <exit>
+ printf("%s: read failed\n", s);
+ b24: 85da mv a1,s6
+ b26: 00004517 auipc a0,0x4
+ b2a: 78a50513 addi a0,a0,1930 # 52b0 <malloc+0x530>
+ b2e: 00004097 auipc ra,0x4
+ b32: 19a080e7 jalr 410(ra) # 4cc8 <printf>
+ exit(1);
+ b36: 4505 li a0,1
+ b38: 00004097 auipc ra,0x4
+ b3c: dcc080e7 jalr -564(ra) # 4904 <exit>
+ printf("%s: remove small failed\n", s);
+ b40: 85da mv a1,s6
+ b42: 00004517 auipc a0,0x4
+ b46: 78650513 addi a0,a0,1926 # 52c8 <malloc+0x548>
+ b4a: 00004097 auipc ra,0x4
+ b4e: 17e080e7 jalr 382(ra) # 4cc8 <printf>
+ exit(1);
+ b52: 4505 li a0,1
+ b54: 00004097 auipc ra,0x4
+ b58: db0080e7 jalr -592(ra) # 4904 <exit>
+
+0000000000000b5c <writebig>:
+{
+ b5c: 7179 addi sp,sp,-48
+ b5e: f406 sd ra,40(sp)
+ b60: f022 sd s0,32(sp)
+ b62: ec26 sd s1,24(sp)
+ b64: e84a sd s2,16(sp)
+ b66: e44e sd s3,8(sp)
+ b68: e052 sd s4,0(sp)
+ b6a: 1800 addi s0,sp,48
+ b6c: 8a2a mv s4,a0
+ fd = open("big", O_CREATE|O_RDWR);
+ b6e: 20200593 li a1,514
+ b72: 00004517 auipc a0,0x4
+ b76: 77650513 addi a0,a0,1910 # 52e8 <malloc+0x568>
+ b7a: 00004097 auipc ra,0x4
+ b7e: dd6080e7 jalr -554(ra) # 4950 <open>
+ b82: 89aa mv s3,a0
+ for(i = 0; i < MAXFILE; i++){
+ b84: 4481 li s1,0
+ ((int*)buf)[0] = i;
+ b86: 0000a917 auipc s2,0xa
+ b8a: d1290913 addi s2,s2,-750 # a898 <buf>
+ if(fd < 0){
+ b8e: 06054e63 bltz a0,c0a <writebig+0xae>
+ ((int*)buf)[0] = i;
+ b92: 00992023 sw s1,0(s2)
+ if(write(fd, buf, BSIZE) != BSIZE){
+ b96: 20000613 li a2,512
+ b9a: 85ca mv a1,s2
+ b9c: 854e mv a0,s3
+ b9e: 00004097 auipc ra,0x4
+ ba2: d8c080e7 jalr -628(ra) # 492a <write>
+ ba6: 20000793 li a5,512
+ baa: 06f51e63 bne a0,a5,c26 <writebig+0xca>
+ for(i = 0; i < MAXFILE; i++){
+ bae: 2485 addiw s1,s1,1
+ bb0: 20000793 li a5,512
+ bb4: fcf49fe3 bne s1,a5,b92 <writebig+0x36>
+ close(fd);
+ bb8: 854e mv a0,s3
+ bba: 00004097 auipc ra,0x4
+ bbe: d7a080e7 jalr -646(ra) # 4934 <close>
+ fd = open("big", O_RDONLY);
+ bc2: 4581 li a1,0
+ bc4: 00004517 auipc a0,0x4
+ bc8: 72450513 addi a0,a0,1828 # 52e8 <malloc+0x568>
+ bcc: 00004097 auipc ra,0x4
+ bd0: d84080e7 jalr -636(ra) # 4950 <open>
+ bd4: 89aa mv s3,a0
+ n = 0;
+ bd6: 4481 li s1,0
+ i = read(fd, buf, BSIZE);
+ bd8: 0000a917 auipc s2,0xa
+ bdc: cc090913 addi s2,s2,-832 # a898 <buf>
+ if(fd < 0){
+ be0: 06054163 bltz a0,c42 <writebig+0xe6>
+ i = read(fd, buf, BSIZE);
+ be4: 20000613 li a2,512
+ be8: 85ca mv a1,s2
+ bea: 854e mv a0,s3
+ bec: 00004097 auipc ra,0x4
+ bf0: d34080e7 jalr -716(ra) # 4920 <read>
+ if(i == 0){
+ bf4: c52d beqz a0,c5e <writebig+0x102>
+ } else if(i != BSIZE){
+ bf6: 20000793 li a5,512
+ bfa: 0af51c63 bne a0,a5,cb2 <writebig+0x156>
+ if(((int*)buf)[0] != n){
+ bfe: 00092603 lw a2,0(s2)
+ c02: 0c961663 bne a2,s1,cce <writebig+0x172>
+ n++;
+ c06: 2485 addiw s1,s1,1
+ i = read(fd, buf, BSIZE);
+ c08: bff1 j be4 <writebig+0x88>
+ printf("%s: error: creat big failed!\n", s);
+ c0a: 85d2 mv a1,s4
+ c0c: 00004517 auipc a0,0x4
+ c10: 6e450513 addi a0,a0,1764 # 52f0 <malloc+0x570>
+ c14: 00004097 auipc ra,0x4
+ c18: 0b4080e7 jalr 180(ra) # 4cc8 <printf>
+ exit(1);
+ c1c: 4505 li a0,1
+ c1e: 00004097 auipc ra,0x4
+ c22: ce6080e7 jalr -794(ra) # 4904 <exit>
+ printf("%s: error: write big file failed\n", i);
+ c26: 85a6 mv a1,s1
+ c28: 00004517 auipc a0,0x4
+ c2c: 6e850513 addi a0,a0,1768 # 5310 <malloc+0x590>
+ c30: 00004097 auipc ra,0x4
+ c34: 098080e7 jalr 152(ra) # 4cc8 <printf>
+ exit(1);
+ c38: 4505 li a0,1
+ c3a: 00004097 auipc ra,0x4
+ c3e: cca080e7 jalr -822(ra) # 4904 <exit>
+ printf("%s: error: open big failed!\n", s);
+ c42: 85d2 mv a1,s4
+ c44: 00004517 auipc a0,0x4
+ c48: 6f450513 addi a0,a0,1780 # 5338 <malloc+0x5b8>
+ c4c: 00004097 auipc ra,0x4
+ c50: 07c080e7 jalr 124(ra) # 4cc8 <printf>
+ exit(1);
+ c54: 4505 li a0,1
+ c56: 00004097 auipc ra,0x4
+ c5a: cae080e7 jalr -850(ra) # 4904 <exit>
+ if(n == MAXFILE - 1){
+ c5e: 1ff00793 li a5,511
+ c62: 02f48963 beq s1,a5,c94 <writebig+0x138>
+ close(fd);
+ c66: 854e mv a0,s3
+ c68: 00004097 auipc ra,0x4
+ c6c: ccc080e7 jalr -820(ra) # 4934 <close>
+ if(remove("big") < 0){
+ c70: 00004517 auipc a0,0x4
+ c74: 67850513 addi a0,a0,1656 # 52e8 <malloc+0x568>
+ c78: 00004097 auipc ra,0x4
+ c7c: d4c080e7 jalr -692(ra) # 49c4 <remove>
+ c80: 06054563 bltz a0,cea <writebig+0x18e>
+}
+ c84: 70a2 ld ra,40(sp)
+ c86: 7402 ld s0,32(sp)
+ c88: 64e2 ld s1,24(sp)
+ c8a: 6942 ld s2,16(sp)
+ c8c: 69a2 ld s3,8(sp)
+ c8e: 6a02 ld s4,0(sp)
+ c90: 6145 addi sp,sp,48
+ c92: 8082 ret
+ printf("%s: read only %d blocks from big", n);
+ c94: 1ff00593 li a1,511
+ c98: 00004517 auipc a0,0x4
+ c9c: 6c050513 addi a0,a0,1728 # 5358 <malloc+0x5d8>
+ ca0: 00004097 auipc ra,0x4
+ ca4: 028080e7 jalr 40(ra) # 4cc8 <printf>
+ exit(1);
+ ca8: 4505 li a0,1
+ caa: 00004097 auipc ra,0x4
+ cae: c5a080e7 jalr -934(ra) # 4904 <exit>
+ printf("%s: read failed %d\n", i);
+ cb2: 85aa mv a1,a0
+ cb4: 00004517 auipc a0,0x4
+ cb8: 6cc50513 addi a0,a0,1740 # 5380 <malloc+0x600>
+ cbc: 00004097 auipc ra,0x4
+ cc0: 00c080e7 jalr 12(ra) # 4cc8 <printf>
+ exit(1);
+ cc4: 4505 li a0,1
+ cc6: 00004097 auipc ra,0x4
+ cca: c3e080e7 jalr -962(ra) # 4904 <exit>
+ printf("%s: read content of block %d is %d\n",
+ cce: 85a6 mv a1,s1
+ cd0: 00004517 auipc a0,0x4
+ cd4: 6c850513 addi a0,a0,1736 # 5398 <malloc+0x618>
+ cd8: 00004097 auipc ra,0x4
+ cdc: ff0080e7 jalr -16(ra) # 4cc8 <printf>
+ exit(1);
+ ce0: 4505 li a0,1
+ ce2: 00004097 auipc ra,0x4
+ ce6: c22080e7 jalr -990(ra) # 4904 <exit>
+ printf("%s: remove big failed\n", s);
+ cea: 85d2 mv a1,s4
+ cec: 00004517 auipc a0,0x4
+ cf0: 6d450513 addi a0,a0,1748 # 53c0 <malloc+0x640>
+ cf4: 00004097 auipc ra,0x4
+ cf8: fd4080e7 jalr -44(ra) # 4cc8 <printf>
+ exit(1);
+ cfc: 4505 li a0,1
+ cfe: 00004097 auipc ra,0x4
+ d02: c06080e7 jalr -1018(ra) # 4904 <exit>
+
+0000000000000d06 <removeread>:
+{
+ d06: 7179 addi sp,sp,-48
+ d08: f406 sd ra,40(sp)
+ d0a: f022 sd s0,32(sp)
+ d0c: ec26 sd s1,24(sp)
+ d0e: e84a sd s2,16(sp)
+ d10: e44e sd s3,8(sp)
+ d12: 1800 addi s0,sp,48
+ d14: 89aa mv s3,a0
+ fd = open("removeread", O_CREATE | O_RDWR);
+ d16: 20200593 li a1,514
+ d1a: 00004517 auipc a0,0x4
+ d1e: 6be50513 addi a0,a0,1726 # 53d8 <malloc+0x658>
+ d22: 00004097 auipc ra,0x4
+ d26: c2e080e7 jalr -978(ra) # 4950 <open>
+ if(fd < 0){
+ d2a: 0e054763 bltz a0,e18 <removeread+0x112>
+ d2e: 84aa mv s1,a0
+ write(fd, "hello", SZ);
+ d30: 4615 li a2,5
+ d32: 00004597 auipc a1,0x4
+ d36: 6d658593 addi a1,a1,1750 # 5408 <malloc+0x688>
+ d3a: 00004097 auipc ra,0x4
+ d3e: bf0080e7 jalr -1040(ra) # 492a <write>
+ close(fd);
+ d42: 8526 mv a0,s1
+ d44: 00004097 auipc ra,0x4
+ d48: bf0080e7 jalr -1040(ra) # 4934 <close>
+ fd = open("removeread", O_RDWR);
+ d4c: 4589 li a1,2
+ d4e: 00004517 auipc a0,0x4
+ d52: 68a50513 addi a0,a0,1674 # 53d8 <malloc+0x658>
+ d56: 00004097 auipc ra,0x4
+ d5a: bfa080e7 jalr -1030(ra) # 4950 <open>
+ d5e: 84aa mv s1,a0
+ if(fd < 0){
+ d60: 0c054a63 bltz a0,e34 <removeread+0x12e>
+ if(remove("removeread") != 0){
+ d64: 00004517 auipc a0,0x4
+ d68: 67450513 addi a0,a0,1652 # 53d8 <malloc+0x658>
+ d6c: 00004097 auipc ra,0x4
+ d70: c58080e7 jalr -936(ra) # 49c4 <remove>
+ d74: ed71 bnez a0,e50 <removeread+0x14a>
+ fd1 = open("removeread", O_CREATE | O_RDWR);
+ d76: 20200593 li a1,514
+ d7a: 00004517 auipc a0,0x4
+ d7e: 65e50513 addi a0,a0,1630 # 53d8 <malloc+0x658>
+ d82: 00004097 auipc ra,0x4
+ d86: bce080e7 jalr -1074(ra) # 4950 <open>
+ d8a: 892a mv s2,a0
+ write(fd1, "yyy", 3);
+ d8c: 460d li a2,3
+ d8e: 00004597 auipc a1,0x4
+ d92: 6c258593 addi a1,a1,1730 # 5450 <malloc+0x6d0>
+ d96: 00004097 auipc ra,0x4
+ d9a: b94080e7 jalr -1132(ra) # 492a <write>
+ close(fd1);
+ d9e: 854a mv a0,s2
+ da0: 00004097 auipc ra,0x4
+ da4: b94080e7 jalr -1132(ra) # 4934 <close>
+ if(read(fd, buf, sizeof(buf)) != SZ){
+ da8: 6609 lui a2,0x2
+ daa: 80060613 addi a2,a2,-2048 # 1800 <forkfork+0x42>
+ dae: 0000a597 auipc a1,0xa
+ db2: aea58593 addi a1,a1,-1302 # a898 <buf>
+ db6: 8526 mv a0,s1
+ db8: 00004097 auipc ra,0x4
+ dbc: b68080e7 jalr -1176(ra) # 4920 <read>
+ dc0: 4795 li a5,5
+ dc2: 0af51563 bne a0,a5,e6c <removeread+0x166>
+ if(buf[0] != 'h'){
+ dc6: 0000a717 auipc a4,0xa
+ dca: ad274703 lbu a4,-1326(a4) # a898 <buf>
+ dce: 06800793 li a5,104
+ dd2: 0af71b63 bne a4,a5,e88 <removeread+0x182>
+ if(write(fd, buf, 10) != 10){
+ dd6: 4629 li a2,10
+ dd8: 0000a597 auipc a1,0xa
+ ddc: ac058593 addi a1,a1,-1344 # a898 <buf>
+ de0: 8526 mv a0,s1
+ de2: 00004097 auipc ra,0x4
+ de6: b48080e7 jalr -1208(ra) # 492a <write>
+ dea: 47a9 li a5,10
+ dec: 0af51c63 bne a0,a5,ea4 <removeread+0x19e>
+ close(fd);
+ df0: 8526 mv a0,s1
+ df2: 00004097 auipc ra,0x4
+ df6: b42080e7 jalr -1214(ra) # 4934 <close>
+ remove("removeread");
+ dfa: 00004517 auipc a0,0x4
+ dfe: 5de50513 addi a0,a0,1502 # 53d8 <malloc+0x658>
+ e02: 00004097 auipc ra,0x4
+ e06: bc2080e7 jalr -1086(ra) # 49c4 <remove>
+}
+ e0a: 70a2 ld ra,40(sp)
+ e0c: 7402 ld s0,32(sp)
+ e0e: 64e2 ld s1,24(sp)
+ e10: 6942 ld s2,16(sp)
+ e12: 69a2 ld s3,8(sp)
+ e14: 6145 addi sp,sp,48
+ e16: 8082 ret
+ printf("%s: create removeread failed\n", s);
+ e18: 85ce mv a1,s3
+ e1a: 00004517 auipc a0,0x4
+ e1e: 5ce50513 addi a0,a0,1486 # 53e8 <malloc+0x668>
+ e22: 00004097 auipc ra,0x4
+ e26: ea6080e7 jalr -346(ra) # 4cc8 <printf>
+ exit(1);
+ e2a: 4505 li a0,1
+ e2c: 00004097 auipc ra,0x4
+ e30: ad8080e7 jalr -1320(ra) # 4904 <exit>
+ printf("%s: open removeread failed\n", s);
+ e34: 85ce mv a1,s3
+ e36: 00004517 auipc a0,0x4
+ e3a: 5da50513 addi a0,a0,1498 # 5410 <malloc+0x690>
+ e3e: 00004097 auipc ra,0x4
+ e42: e8a080e7 jalr -374(ra) # 4cc8 <printf>
+ exit(1);
+ e46: 4505 li a0,1
+ e48: 00004097 auipc ra,0x4
+ e4c: abc080e7 jalr -1348(ra) # 4904 <exit>
+ printf("%s: remove removeread failed\n", s);
+ e50: 85ce mv a1,s3
+ e52: 00004517 auipc a0,0x4
+ e56: 5de50513 addi a0,a0,1502 # 5430 <malloc+0x6b0>
+ e5a: 00004097 auipc ra,0x4
+ e5e: e6e080e7 jalr -402(ra) # 4cc8 <printf>
+ exit(1);
+ e62: 4505 li a0,1
+ e64: 00004097 auipc ra,0x4
+ e68: aa0080e7 jalr -1376(ra) # 4904 <exit>
+ printf("%s: removeread read failed", s);
+ e6c: 85ce mv a1,s3
+ e6e: 00004517 auipc a0,0x4
+ e72: 5ea50513 addi a0,a0,1514 # 5458 <malloc+0x6d8>
+ e76: 00004097 auipc ra,0x4
+ e7a: e52080e7 jalr -430(ra) # 4cc8 <printf>
+ exit(1);
+ e7e: 4505 li a0,1
+ e80: 00004097 auipc ra,0x4
+ e84: a84080e7 jalr -1404(ra) # 4904 <exit>
+ printf("%s: removeread wrong data\n", s);
+ e88: 85ce mv a1,s3
+ e8a: 00004517 auipc a0,0x4
+ e8e: 5ee50513 addi a0,a0,1518 # 5478 <malloc+0x6f8>
+ e92: 00004097 auipc ra,0x4
+ e96: e36080e7 jalr -458(ra) # 4cc8 <printf>
+ exit(1);
+ e9a: 4505 li a0,1
+ e9c: 00004097 auipc ra,0x4
+ ea0: a68080e7 jalr -1432(ra) # 4904 <exit>
+ printf("%s: removeread write failed\n", s);
+ ea4: 85ce mv a1,s3
+ ea6: 00004517 auipc a0,0x4
+ eaa: 5f250513 addi a0,a0,1522 # 5498 <malloc+0x718>
+ eae: 00004097 auipc ra,0x4
+ eb2: e1a080e7 jalr -486(ra) # 4cc8 <printf>
+ exit(1);
+ eb6: 4505 li a0,1
+ eb8: 00004097 auipc ra,0x4
+ ebc: a4c080e7 jalr -1460(ra) # 4904 <exit>
+
+0000000000000ec0 <pgbug>:
+{
+ ec0: 7179 addi sp,sp,-48
+ ec2: f406 sd ra,40(sp)
+ ec4: f022 sd s0,32(sp)
+ ec6: ec26 sd s1,24(sp)
+ ec8: 1800 addi s0,sp,48
+ argv[0] = 0;
+ eca: fc043c23 sd zero,-40(s0)
+ exec((char*)0xeaeb0b5b00002f5e, argv);
+ ece: 00006497 auipc s1,0x6
+ ed2: dc24b483 ld s1,-574(s1) # 6c90 <malloc+0x1f10>
+ ed6: fd840593 addi a1,s0,-40
+ eda: 8526 mv a0,s1
+ edc: 00004097 auipc ra,0x4
+ ee0: a6a080e7 jalr -1430(ra) # 4946 <exec>
+ pipe((int*)0xeaeb0b5b00002f5e);
+ ee4: 8526 mv a0,s1
+ ee6: 00004097 auipc ra,0x4
+ eea: a30080e7 jalr -1488(ra) # 4916 <pipe>
+ exit(0);
+ eee: 4501 li a0,0
+ ef0: 00004097 auipc ra,0x4
+ ef4: a14080e7 jalr -1516(ra) # 4904 <exit>
+
+0000000000000ef8 <badarg>:
+
+// regression test. test whether exec() leaks memory if one of the
+// arguments is invalid. the test passes if the kernel doesn't panic.
+void
+badarg(char *s)
+{
+ ef8: 7139 addi sp,sp,-64
+ efa: fc06 sd ra,56(sp)
+ efc: f822 sd s0,48(sp)
+ efe: f426 sd s1,40(sp)
+ f00: f04a sd s2,32(sp)
+ f02: ec4e sd s3,24(sp)
+ f04: e852 sd s4,16(sp)
+ f06: 0080 addi s0,sp,64
+ f08: 64b1 lui s1,0xc
+ f0a: 35048493 addi s1,s1,848 # c350 <__BSS_END__+0x2a0>
+ for(int i = 0; i < 50000; i++){
+ char *argv[2];
+ argv[0] = (char*)0xffffffff;
+ f0e: 597d li s2,-1
+ f10: 02095913 srli s2,s2,0x20
+ argv[1] = 0;
+ exec("echo", argv);
+ f14: fc040a13 addi s4,s0,-64
+ f18: 00004997 auipc s3,0x4
+ f1c: fc898993 addi s3,s3,-56 # 4ee0 <malloc+0x160>
+ argv[0] = (char*)0xffffffff;
+ f20: fd243023 sd s2,-64(s0)
+ argv[1] = 0;
+ f24: fc043423 sd zero,-56(s0)
+ exec("echo", argv);
+ f28: 85d2 mv a1,s4
+ f2a: 854e mv a0,s3
+ f2c: 00004097 auipc ra,0x4
+ f30: a1a080e7 jalr -1510(ra) # 4946 <exec>
+ for(int i = 0; i < 50000; i++){
+ f34: 34fd addiw s1,s1,-1
+ f36: f4ed bnez s1,f20 <badarg+0x28>
+ }
+
+ exit(0);
+ f38: 4501 li a0,0
+ f3a: 00004097 auipc ra,0x4
+ f3e: 9ca080e7 jalr -1590(ra) # 4904 <exit>
+
+0000000000000f42 <copyinstr2>:
+{
+ f42: 714d addi sp,sp,-336
+ f44: e686 sd ra,328(sp)
+ f46: e2a2 sd s0,320(sp)
+ f48: 0a80 addi s0,sp,336
+ for(int i = 0; i < MAXPATH; i++)
+ f4a: ee840793 addi a5,s0,-280
+ f4e: fec40693 addi a3,s0,-20
+ b[i] = 'x';
+ f52: 07800713 li a4,120
+ f56: 00e78023 sb a4,0(a5)
+ for(int i = 0; i < MAXPATH; i++)
+ f5a: 0785 addi a5,a5,1
+ f5c: fed79de3 bne a5,a3,f56 <copyinstr2+0x14>
+ b[MAXPATH] = '\0';
+ f60: fe040623 sb zero,-20(s0)
+ int ret = remove(b);
+ f64: ee840513 addi a0,s0,-280
+ f68: 00004097 auipc ra,0x4
+ f6c: a5c080e7 jalr -1444(ra) # 49c4 <remove>
+ if(ret != -1){
+ f70: 57fd li a5,-1
+ f72: 0cf51663 bne a0,a5,103e <copyinstr2+0xfc>
+ int fd = open(b, O_CREATE | O_WRONLY);
+ f76: 20100593 li a1,513
+ f7a: ee840513 addi a0,s0,-280
+ f7e: 00004097 auipc ra,0x4
+ f82: 9d2080e7 jalr -1582(ra) # 4950 <open>
+ if(fd != -1){
+ f86: 57fd li a5,-1
+ f88: 0cf51b63 bne a0,a5,105e <copyinstr2+0x11c>
+ char *args[] = { "xx", 0 };
+ f8c: 00005797 auipc a5,0x5
+ f90: 14478793 addi a5,a5,324 # 60d0 <malloc+0x1350>
+ f94: ecf43c23 sd a5,-296(s0)
+ f98: ee043023 sd zero,-288(s0)
+ ret = exec(b, args);
+ f9c: ed840593 addi a1,s0,-296
+ fa0: ee840513 addi a0,s0,-280
+ fa4: 00004097 auipc ra,0x4
+ fa8: 9a2080e7 jalr -1630(ra) # 4946 <exec>
+ if(ret != -1){
+ fac: 57fd li a5,-1
+ fae: 0cf51863 bne a0,a5,107e <copyinstr2+0x13c>
+ int pid = fork();
+ fb2: 00004097 auipc ra,0x4
+ fb6: 94a080e7 jalr -1718(ra) # 48fc <fork>
+ if(pid < 0){
+ fba: 0e054263 bltz a0,109e <copyinstr2+0x15c>
+ if(pid == 0){
+ fbe: 10051363 bnez a0,10c4 <copyinstr2+0x182>
+ fc2: 00006797 auipc a5,0x6
+ fc6: 1be78793 addi a5,a5,446 # 7180 <big.0>
+ fca: 00007697 auipc a3,0x7
+ fce: 1b668693 addi a3,a3,438 # 8180 <__global_pointer$+0x908>
+ big[i] = 'x';
+ fd2: 07800713 li a4,120
+ fd6: 00e78023 sb a4,0(a5)
+ for(int i = 0; i < PGSIZE; i++)
+ fda: 0785 addi a5,a5,1
+ fdc: fed79de3 bne a5,a3,fd6 <copyinstr2+0x94>
+ big[PGSIZE] = '\0';
+ fe0: 00007797 auipc a5,0x7
+ fe4: 1a078023 sb zero,416(a5) # 8180 <__global_pointer$+0x908>
+ char *args2[] = { big, big, big, 0 };
+ fe8: 00006797 auipc a5,0x6
+ fec: d2878793 addi a5,a5,-728 # 6d10 <__DATA_BEGIN__>
+ ff0: 6390 ld a2,0(a5)
+ ff2: 6794 ld a3,8(a5)
+ ff4: 6b98 ld a4,16(a5)
+ ff6: 6f9c ld a5,24(a5)
+ ff8: eac43823 sd a2,-336(s0)
+ ffc: ead43c23 sd a3,-328(s0)
+ 1000: ece43023 sd a4,-320(s0)
+ 1004: ecf43423 sd a5,-312(s0)
+ ret = exec("echo", args2);
+ 1008: eb040593 addi a1,s0,-336
+ 100c: 00004517 auipc a0,0x4
+ 1010: ed450513 addi a0,a0,-300 # 4ee0 <malloc+0x160>
+ 1014: 00004097 auipc ra,0x4
+ 1018: 932080e7 jalr -1742(ra) # 4946 <exec>
+ if(ret != -1){
+ 101c: 57fd li a5,-1
+ 101e: 08f50d63 beq a0,a5,10b8 <copyinstr2+0x176>
+ printf("exec(echo, BIG) returned %d, not -1\n", fd);
+ 1022: 55fd li a1,-1
+ 1024: 00004517 auipc a0,0x4
+ 1028: 4f450513 addi a0,a0,1268 # 5518 <malloc+0x798>
+ 102c: 00004097 auipc ra,0x4
+ 1030: c9c080e7 jalr -868(ra) # 4cc8 <printf>
+ exit(1);
+ 1034: 4505 li a0,1
+ 1036: 00004097 auipc ra,0x4
+ 103a: 8ce080e7 jalr -1842(ra) # 4904 <exit>
+ printf("remove(%s) returned %d, not -1\n", b, ret);
+ 103e: 862a mv a2,a0
+ 1040: ee840593 addi a1,s0,-280
+ 1044: 00004517 auipc a0,0x4
+ 1048: 47450513 addi a0,a0,1140 # 54b8 <malloc+0x738>
+ 104c: 00004097 auipc ra,0x4
+ 1050: c7c080e7 jalr -900(ra) # 4cc8 <printf>
+ exit(1);
+ 1054: 4505 li a0,1
+ 1056: 00004097 auipc ra,0x4
+ 105a: 8ae080e7 jalr -1874(ra) # 4904 <exit>
+ printf("open(%s) returned %d, not -1\n", b, fd);
+ 105e: 862a mv a2,a0
+ 1060: ee840593 addi a1,s0,-280
+ 1064: 00004517 auipc a0,0x4
+ 1068: 47450513 addi a0,a0,1140 # 54d8 <malloc+0x758>
+ 106c: 00004097 auipc ra,0x4
+ 1070: c5c080e7 jalr -932(ra) # 4cc8 <printf>
+ exit(1);
+ 1074: 4505 li a0,1
+ 1076: 00004097 auipc ra,0x4
+ 107a: 88e080e7 jalr -1906(ra) # 4904 <exit>
+ printf("exec(%s) returned %d, not -1\n", b, fd);
+ 107e: 567d li a2,-1
+ 1080: ee840593 addi a1,s0,-280
+ 1084: 00004517 auipc a0,0x4
+ 1088: 47450513 addi a0,a0,1140 # 54f8 <malloc+0x778>
+ 108c: 00004097 auipc ra,0x4
+ 1090: c3c080e7 jalr -964(ra) # 4cc8 <printf>
+ exit(1);
+ 1094: 4505 li a0,1
+ 1096: 00004097 auipc ra,0x4
+ 109a: 86e080e7 jalr -1938(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 109e: 00005517 auipc a0,0x5
+ 10a2: 85250513 addi a0,a0,-1966 # 58f0 <malloc+0xb70>
+ 10a6: 00004097 auipc ra,0x4
+ 10aa: c22080e7 jalr -990(ra) # 4cc8 <printf>
+ exit(1);
+ 10ae: 4505 li a0,1
+ 10b0: 00004097 auipc ra,0x4
+ 10b4: 854080e7 jalr -1964(ra) # 4904 <exit>
+ exit(747); // OK
+ 10b8: 2eb00513 li a0,747
+ 10bc: 00004097 auipc ra,0x4
+ 10c0: 848080e7 jalr -1976(ra) # 4904 <exit>
+ int st = 0;
+ 10c4: ec042a23 sw zero,-300(s0)
+ wait(&st);
+ 10c8: ed440513 addi a0,s0,-300
+ 10cc: 00004097 auipc ra,0x4
+ 10d0: 842080e7 jalr -1982(ra) # 490e <wait>
+ if(st != 747){
+ 10d4: ed442703 lw a4,-300(s0)
+ 10d8: 2eb00793 li a5,747
+ 10dc: 00f71663 bne a4,a5,10e8 <copyinstr2+0x1a6>
+}
+ 10e0: 60b6 ld ra,328(sp)
+ 10e2: 6416 ld s0,320(sp)
+ 10e4: 6171 addi sp,sp,336
+ 10e6: 8082 ret
+ printf("exec(echo, BIG) succeeded, should have failed\n");
+ 10e8: 00004517 auipc a0,0x4
+ 10ec: 45850513 addi a0,a0,1112 # 5540 <malloc+0x7c0>
+ 10f0: 00004097 auipc ra,0x4
+ 10f4: bd8080e7 jalr -1064(ra) # 4cc8 <printf>
+ exit(1);
+ 10f8: 4505 li a0,1
+ 10fa: 00004097 auipc ra,0x4
+ 10fe: 80a080e7 jalr -2038(ra) # 4904 <exit>
+
+0000000000001102 <truncate3>:
+{
+ 1102: 7159 addi sp,sp,-112
+ 1104: f486 sd ra,104(sp)
+ 1106: f0a2 sd s0,96(sp)
+ 1108: eca6 sd s1,88(sp)
+ 110a: e8ca sd s2,80(sp)
+ 110c: e4ce sd s3,72(sp)
+ 110e: e0d2 sd s4,64(sp)
+ 1110: fc56 sd s5,56(sp)
+ 1112: f85a sd s6,48(sp)
+ 1114: 1880 addi s0,sp,112
+ 1116: 892a mv s2,a0
+ close(open("truncfile", O_CREATE|O_TRUNC|O_WRONLY));
+ 1118: 60100593 li a1,1537
+ 111c: 00004517 auipc a0,0x4
+ 1120: e1c50513 addi a0,a0,-484 # 4f38 <malloc+0x1b8>
+ 1124: 00004097 auipc ra,0x4
+ 1128: 82c080e7 jalr -2004(ra) # 4950 <open>
+ 112c: 00004097 auipc ra,0x4
+ 1130: 808080e7 jalr -2040(ra) # 4934 <close>
+ pid = fork();
+ 1134: 00003097 auipc ra,0x3
+ 1138: 7c8080e7 jalr 1992(ra) # 48fc <fork>
+ if(pid < 0){
+ 113c: 08054163 bltz a0,11be <truncate3+0xbc>
+ if(pid == 0){
+ 1140: e971 bnez a0,1214 <truncate3+0x112>
+ 1142: 06400993 li s3,100
+ int fd = open("truncfile", O_WRONLY);
+ 1146: 00004a17 auipc s4,0x4
+ 114a: df2a0a13 addi s4,s4,-526 # 4f38 <malloc+0x1b8>
+ int n = write(fd, "1234567890", 10);
+ 114e: 00004a97 auipc s5,0x4
+ 1152: 452a8a93 addi s5,s5,1106 # 55a0 <malloc+0x820>
+ read(fd, buf, sizeof(buf));
+ 1156: f9840b13 addi s6,s0,-104
+ int fd = open("truncfile", O_WRONLY);
+ 115a: 4585 li a1,1
+ 115c: 8552 mv a0,s4
+ 115e: 00003097 auipc ra,0x3
+ 1162: 7f2080e7 jalr 2034(ra) # 4950 <open>
+ 1166: 84aa mv s1,a0
+ if(fd < 0){
+ 1168: 06054963 bltz a0,11da <truncate3+0xd8>
+ int n = write(fd, "1234567890", 10);
+ 116c: 4629 li a2,10
+ 116e: 85d6 mv a1,s5
+ 1170: 00003097 auipc ra,0x3
+ 1174: 7ba080e7 jalr 1978(ra) # 492a <write>
+ if(n != 10){
+ 1178: 47a9 li a5,10
+ 117a: 06f51e63 bne a0,a5,11f6 <truncate3+0xf4>
+ close(fd);
+ 117e: 8526 mv a0,s1
+ 1180: 00003097 auipc ra,0x3
+ 1184: 7b4080e7 jalr 1972(ra) # 4934 <close>
+ fd = open("truncfile", O_RDONLY);
+ 1188: 4581 li a1,0
+ 118a: 8552 mv a0,s4
+ 118c: 00003097 auipc ra,0x3
+ 1190: 7c4080e7 jalr 1988(ra) # 4950 <open>
+ 1194: 84aa mv s1,a0
+ read(fd, buf, sizeof(buf));
+ 1196: 02000613 li a2,32
+ 119a: 85da mv a1,s6
+ 119c: 00003097 auipc ra,0x3
+ 11a0: 784080e7 jalr 1924(ra) # 4920 <read>
+ close(fd);
+ 11a4: 8526 mv a0,s1
+ 11a6: 00003097 auipc ra,0x3
+ 11aa: 78e080e7 jalr 1934(ra) # 4934 <close>
+ for(int i = 0; i < 100; i++){
+ 11ae: 39fd addiw s3,s3,-1
+ 11b0: fa0995e3 bnez s3,115a <truncate3+0x58>
+ exit(0);
+ 11b4: 4501 li a0,0
+ 11b6: 00003097 auipc ra,0x3
+ 11ba: 74e080e7 jalr 1870(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 11be: 85ca mv a1,s2
+ 11c0: 00004517 auipc a0,0x4
+ 11c4: 3b050513 addi a0,a0,944 # 5570 <malloc+0x7f0>
+ 11c8: 00004097 auipc ra,0x4
+ 11cc: b00080e7 jalr -1280(ra) # 4cc8 <printf>
+ exit(1);
+ 11d0: 4505 li a0,1
+ 11d2: 00003097 auipc ra,0x3
+ 11d6: 732080e7 jalr 1842(ra) # 4904 <exit>
+ printf("%s: open failed\n", s);
+ 11da: 85ca mv a1,s2
+ 11dc: 00004517 auipc a0,0x4
+ 11e0: 3ac50513 addi a0,a0,940 # 5588 <malloc+0x808>
+ 11e4: 00004097 auipc ra,0x4
+ 11e8: ae4080e7 jalr -1308(ra) # 4cc8 <printf>
+ exit(1);
+ 11ec: 4505 li a0,1
+ 11ee: 00003097 auipc ra,0x3
+ 11f2: 716080e7 jalr 1814(ra) # 4904 <exit>
+ printf("%s: write got %d, expected 10\n", s, n);
+ 11f6: 862a mv a2,a0
+ 11f8: 85ca mv a1,s2
+ 11fa: 00004517 auipc a0,0x4
+ 11fe: 3b650513 addi a0,a0,950 # 55b0 <malloc+0x830>
+ 1202: 00004097 auipc ra,0x4
+ 1206: ac6080e7 jalr -1338(ra) # 4cc8 <printf>
+ exit(1);
+ 120a: 4505 li a0,1
+ 120c: 00003097 auipc ra,0x3
+ 1210: 6f8080e7 jalr 1784(ra) # 4904 <exit>
+ 1214: 09600993 li s3,150
+ int fd = open("truncfile", O_CREATE|O_WRONLY|O_TRUNC);
+ 1218: 00004a17 auipc s4,0x4
+ 121c: d20a0a13 addi s4,s4,-736 # 4f38 <malloc+0x1b8>
+ int n = write(fd, "xxx", 3);
+ 1220: 00004a97 auipc s5,0x4
+ 1224: 3b0a8a93 addi s5,s5,944 # 55d0 <malloc+0x850>
+ int fd = open("truncfile", O_CREATE|O_WRONLY|O_TRUNC);
+ 1228: 60100593 li a1,1537
+ 122c: 8552 mv a0,s4
+ 122e: 00003097 auipc ra,0x3
+ 1232: 722080e7 jalr 1826(ra) # 4950 <open>
+ 1236: 84aa mv s1,a0
+ if(fd < 0){
+ 1238: 04054763 bltz a0,1286 <truncate3+0x184>
+ int n = write(fd, "xxx", 3);
+ 123c: 460d li a2,3
+ 123e: 85d6 mv a1,s5
+ 1240: 00003097 auipc ra,0x3
+ 1244: 6ea080e7 jalr 1770(ra) # 492a <write>
+ if(n != 3){
+ 1248: 478d li a5,3
+ 124a: 04f51c63 bne a0,a5,12a2 <truncate3+0x1a0>
+ close(fd);
+ 124e: 8526 mv a0,s1
+ 1250: 00003097 auipc ra,0x3
+ 1254: 6e4080e7 jalr 1764(ra) # 4934 <close>
+ for(int i = 0; i < 150; i++){
+ 1258: 39fd addiw s3,s3,-1
+ 125a: fc0997e3 bnez s3,1228 <truncate3+0x126>
+ wait(&xstatus);
+ 125e: fbc40513 addi a0,s0,-68
+ 1262: 00003097 auipc ra,0x3
+ 1266: 6ac080e7 jalr 1708(ra) # 490e <wait>
+ remove("truncfile");
+ 126a: 00004517 auipc a0,0x4
+ 126e: cce50513 addi a0,a0,-818 # 4f38 <malloc+0x1b8>
+ 1272: 00003097 auipc ra,0x3
+ 1276: 752080e7 jalr 1874(ra) # 49c4 <remove>
+ exit(xstatus);
+ 127a: fbc42503 lw a0,-68(s0)
+ 127e: 00003097 auipc ra,0x3
+ 1282: 686080e7 jalr 1670(ra) # 4904 <exit>
+ printf("%s: open failed\n", s);
+ 1286: 85ca mv a1,s2
+ 1288: 00004517 auipc a0,0x4
+ 128c: 30050513 addi a0,a0,768 # 5588 <malloc+0x808>
+ 1290: 00004097 auipc ra,0x4
+ 1294: a38080e7 jalr -1480(ra) # 4cc8 <printf>
+ exit(1);
+ 1298: 4505 li a0,1
+ 129a: 00003097 auipc ra,0x3
+ 129e: 66a080e7 jalr 1642(ra) # 4904 <exit>
+ printf("%s: write got %d, expected 3\n", s, n);
+ 12a2: 862a mv a2,a0
+ 12a4: 85ca mv a1,s2
+ 12a6: 00004517 auipc a0,0x4
+ 12aa: 33250513 addi a0,a0,818 # 55d8 <malloc+0x858>
+ 12ae: 00004097 auipc ra,0x4
+ 12b2: a1a080e7 jalr -1510(ra) # 4cc8 <printf>
+ exit(1);
+ 12b6: 4505 li a0,1
+ 12b8: 00003097 auipc ra,0x3
+ 12bc: 64c080e7 jalr 1612(ra) # 4904 <exit>
+
+00000000000012c0 <exectest>:
+{
+ 12c0: 715d addi sp,sp,-80
+ 12c2: e486 sd ra,72(sp)
+ 12c4: e0a2 sd s0,64(sp)
+ 12c6: fc26 sd s1,56(sp)
+ 12c8: f84a sd s2,48(sp)
+ 12ca: 0880 addi s0,sp,80
+ 12cc: 892a mv s2,a0
+ char *echoargv[] = { "echo", "OK", 0 };
+ 12ce: 00004797 auipc a5,0x4
+ 12d2: c1278793 addi a5,a5,-1006 # 4ee0 <malloc+0x160>
+ 12d6: fcf43023 sd a5,-64(s0)
+ 12da: 00004797 auipc a5,0x4
+ 12de: 31e78793 addi a5,a5,798 # 55f8 <malloc+0x878>
+ 12e2: fcf43423 sd a5,-56(s0)
+ 12e6: fc043823 sd zero,-48(s0)
+ remove("echo-ok");
+ 12ea: 00004517 auipc a0,0x4
+ 12ee: 31650513 addi a0,a0,790 # 5600 <malloc+0x880>
+ 12f2: 00003097 auipc ra,0x3
+ 12f6: 6d2080e7 jalr 1746(ra) # 49c4 <remove>
+ pid = fork();
+ 12fa: 00003097 auipc ra,0x3
+ 12fe: 602080e7 jalr 1538(ra) # 48fc <fork>
+ if(pid < 0) {
+ 1302: 04054663 bltz a0,134e <exectest+0x8e>
+ 1306: 84aa mv s1,a0
+ if(pid == 0) {
+ 1308: e959 bnez a0,139e <exectest+0xde>
+ close(1);
+ 130a: 4505 li a0,1
+ 130c: 00003097 auipc ra,0x3
+ 1310: 628080e7 jalr 1576(ra) # 4934 <close>
+ fd = open("echo-ok", O_CREATE|O_WRONLY);
+ 1314: 20100593 li a1,513
+ 1318: 00004517 auipc a0,0x4
+ 131c: 2e850513 addi a0,a0,744 # 5600 <malloc+0x880>
+ 1320: 00003097 auipc ra,0x3
+ 1324: 630080e7 jalr 1584(ra) # 4950 <open>
+ if(fd < 0) {
+ 1328: 04054163 bltz a0,136a <exectest+0xaa>
+ if(fd != 1) {
+ 132c: 4785 li a5,1
+ 132e: 04f50c63 beq a0,a5,1386 <exectest+0xc6>
+ printf("%s: wrong fd\n", s);
+ 1332: 85ca mv a1,s2
+ 1334: 00004517 auipc a0,0x4
+ 1338: 2ec50513 addi a0,a0,748 # 5620 <malloc+0x8a0>
+ 133c: 00004097 auipc ra,0x4
+ 1340: 98c080e7 jalr -1652(ra) # 4cc8 <printf>
+ exit(1);
+ 1344: 4505 li a0,1
+ 1346: 00003097 auipc ra,0x3
+ 134a: 5be080e7 jalr 1470(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 134e: 85ca mv a1,s2
+ 1350: 00004517 auipc a0,0x4
+ 1354: 22050513 addi a0,a0,544 # 5570 <malloc+0x7f0>
+ 1358: 00004097 auipc ra,0x4
+ 135c: 970080e7 jalr -1680(ra) # 4cc8 <printf>
+ exit(1);
+ 1360: 4505 li a0,1
+ 1362: 00003097 auipc ra,0x3
+ 1366: 5a2080e7 jalr 1442(ra) # 4904 <exit>
+ printf("%s: create failed\n", s);
+ 136a: 85ca mv a1,s2
+ 136c: 00004517 auipc a0,0x4
+ 1370: 29c50513 addi a0,a0,668 # 5608 <malloc+0x888>
+ 1374: 00004097 auipc ra,0x4
+ 1378: 954080e7 jalr -1708(ra) # 4cc8 <printf>
+ exit(1);
+ 137c: 4505 li a0,1
+ 137e: 00003097 auipc ra,0x3
+ 1382: 586080e7 jalr 1414(ra) # 4904 <exit>
+ if(exec("echo", echoargv) < 0){
+ 1386: fc040593 addi a1,s0,-64
+ 138a: 00004517 auipc a0,0x4
+ 138e: b5650513 addi a0,a0,-1194 # 4ee0 <malloc+0x160>
+ 1392: 00003097 auipc ra,0x3
+ 1396: 5b4080e7 jalr 1460(ra) # 4946 <exec>
+ 139a: 02054163 bltz a0,13bc <exectest+0xfc>
+ if (wait(&xstatus) != pid) {
+ 139e: fdc40513 addi a0,s0,-36
+ 13a2: 00003097 auipc ra,0x3
+ 13a6: 56c080e7 jalr 1388(ra) # 490e <wait>
+ 13aa: 02951763 bne a0,s1,13d8 <exectest+0x118>
+ if(xstatus != 0)
+ 13ae: fdc42503 lw a0,-36(s0)
+ 13b2: cd0d beqz a0,13ec <exectest+0x12c>
+ exit(xstatus);
+ 13b4: 00003097 auipc ra,0x3
+ 13b8: 550080e7 jalr 1360(ra) # 4904 <exit>
+ printf("%s: exec echo failed\n", s);
+ 13bc: 85ca mv a1,s2
+ 13be: 00004517 auipc a0,0x4
+ 13c2: 27250513 addi a0,a0,626 # 5630 <malloc+0x8b0>
+ 13c6: 00004097 auipc ra,0x4
+ 13ca: 902080e7 jalr -1790(ra) # 4cc8 <printf>
+ exit(1);
+ 13ce: 4505 li a0,1
+ 13d0: 00003097 auipc ra,0x3
+ 13d4: 534080e7 jalr 1332(ra) # 4904 <exit>
+ printf("%s: wait failed!\n", s);
+ 13d8: 85ca mv a1,s2
+ 13da: 00004517 auipc a0,0x4
+ 13de: 26e50513 addi a0,a0,622 # 5648 <malloc+0x8c8>
+ 13e2: 00004097 auipc ra,0x4
+ 13e6: 8e6080e7 jalr -1818(ra) # 4cc8 <printf>
+ 13ea: b7d1 j 13ae <exectest+0xee>
+ fd = open("echo-ok", O_RDONLY);
+ 13ec: 4581 li a1,0
+ 13ee: 00004517 auipc a0,0x4
+ 13f2: 21250513 addi a0,a0,530 # 5600 <malloc+0x880>
+ 13f6: 00003097 auipc ra,0x3
+ 13fa: 55a080e7 jalr 1370(ra) # 4950 <open>
+ if(fd < 0) {
+ 13fe: 02054a63 bltz a0,1432 <exectest+0x172>
+ if (read(fd, buf, 2) != 2) {
+ 1402: 4609 li a2,2
+ 1404: fb840593 addi a1,s0,-72
+ 1408: 00003097 auipc ra,0x3
+ 140c: 518080e7 jalr 1304(ra) # 4920 <read>
+ 1410: 4789 li a5,2
+ 1412: 02f50e63 beq a0,a5,144e <exectest+0x18e>
+ printf("%s: read failed\n", s);
+ 1416: 85ca mv a1,s2
+ 1418: 00004517 auipc a0,0x4
+ 141c: e9850513 addi a0,a0,-360 # 52b0 <malloc+0x530>
+ 1420: 00004097 auipc ra,0x4
+ 1424: 8a8080e7 jalr -1880(ra) # 4cc8 <printf>
+ exit(1);
+ 1428: 4505 li a0,1
+ 142a: 00003097 auipc ra,0x3
+ 142e: 4da080e7 jalr 1242(ra) # 4904 <exit>
+ printf("%s: open failed\n", s);
+ 1432: 85ca mv a1,s2
+ 1434: 00004517 auipc a0,0x4
+ 1438: 15450513 addi a0,a0,340 # 5588 <malloc+0x808>
+ 143c: 00004097 auipc ra,0x4
+ 1440: 88c080e7 jalr -1908(ra) # 4cc8 <printf>
+ exit(1);
+ 1444: 4505 li a0,1
+ 1446: 00003097 auipc ra,0x3
+ 144a: 4be080e7 jalr 1214(ra) # 4904 <exit>
+ remove("echo-ok");
+ 144e: 00004517 auipc a0,0x4
+ 1452: 1b250513 addi a0,a0,434 # 5600 <malloc+0x880>
+ 1456: 00003097 auipc ra,0x3
+ 145a: 56e080e7 jalr 1390(ra) # 49c4 <remove>
+ if(buf[0] == 'O' && buf[1] == 'K')
+ 145e: fb844703 lbu a4,-72(s0)
+ 1462: 04f00793 li a5,79
+ 1466: 00f71863 bne a4,a5,1476 <exectest+0x1b6>
+ 146a: fb944703 lbu a4,-71(s0)
+ 146e: 04b00793 li a5,75
+ 1472: 02f70063 beq a4,a5,1492 <exectest+0x1d2>
+ printf("%s: wrong output\n", s);
+ 1476: 85ca mv a1,s2
+ 1478: 00004517 auipc a0,0x4
+ 147c: 1e850513 addi a0,a0,488 # 5660 <malloc+0x8e0>
+ 1480: 00004097 auipc ra,0x4
+ 1484: 848080e7 jalr -1976(ra) # 4cc8 <printf>
+ exit(1);
+ 1488: 4505 li a0,1
+ 148a: 00003097 auipc ra,0x3
+ 148e: 47a080e7 jalr 1146(ra) # 4904 <exit>
+ exit(0);
+ 1492: 4501 li a0,0
+ 1494: 00003097 auipc ra,0x3
+ 1498: 470080e7 jalr 1136(ra) # 4904 <exit>
+
+000000000000149c <pipe1>:
+{
+ 149c: 711d addi sp,sp,-96
+ 149e: ec86 sd ra,88(sp)
+ 14a0: e8a2 sd s0,80(sp)
+ 14a2: e4a6 sd s1,72(sp)
+ 14a4: e0ca sd s2,64(sp)
+ 14a6: fc4e sd s3,56(sp)
+ 14a8: f852 sd s4,48(sp)
+ 14aa: f456 sd s5,40(sp)
+ 14ac: f05a sd s6,32(sp)
+ 14ae: ec5e sd s7,24(sp)
+ 14b0: 1080 addi s0,sp,96
+ 14b2: 892a mv s2,a0
+ if(pipe(fds) != 0){
+ 14b4: fa840513 addi a0,s0,-88
+ 14b8: 00003097 auipc ra,0x3
+ 14bc: 45e080e7 jalr 1118(ra) # 4916 <pipe>
+ 14c0: ed2d bnez a0,153a <pipe1+0x9e>
+ 14c2: 84aa mv s1,a0
+ pid = fork();
+ 14c4: 00003097 auipc ra,0x3
+ 14c8: 438080e7 jalr 1080(ra) # 48fc <fork>
+ 14cc: 8a2a mv s4,a0
+ if(pid == 0){
+ 14ce: c541 beqz a0,1556 <pipe1+0xba>
+ } else if(pid > 0){
+ 14d0: 16a05f63 blez a0,164e <pipe1+0x1b2>
+ close(fds[1]);
+ 14d4: fac42503 lw a0,-84(s0)
+ 14d8: 00003097 auipc ra,0x3
+ 14dc: 45c080e7 jalr 1116(ra) # 4934 <close>
+ total = 0;
+ 14e0: 8aa6 mv s5,s1
+ cc = 1;
+ 14e2: 4985 li s3,1
+ while((n = read(fds[0], buf, cc)) > 0){
+ 14e4: 00009b17 auipc s6,0x9
+ 14e8: 3b4b0b13 addi s6,s6,948 # a898 <buf>
+ if(cc > sizeof(buf))
+ 14ec: 6a09 lui s4,0x2
+ 14ee: 800a0a13 addi s4,s4,-2048 # 1800 <forkfork+0x42>
+ while((n = read(fds[0], buf, cc)) > 0){
+ 14f2: 864e mv a2,s3
+ 14f4: 85da mv a1,s6
+ 14f6: fa842503 lw a0,-88(s0)
+ 14fa: 00003097 auipc ra,0x3
+ 14fe: 426080e7 jalr 1062(ra) # 4920 <read>
+ 1502: 10a05163 blez a0,1604 <pipe1+0x168>
+ for(i = 0; i < n; i++){
+ 1506: 00009717 auipc a4,0x9
+ 150a: 39270713 addi a4,a4,914 # a898 <buf>
+ 150e: 00a4863b addw a2,s1,a0
+ if((buf[i] & 0xff) != (seq++ & 0xff)){
+ 1512: 00074683 lbu a3,0(a4)
+ 1516: 0ff4f793 zext.b a5,s1
+ 151a: 2485 addiw s1,s1,1
+ 151c: 0cf69063 bne a3,a5,15dc <pipe1+0x140>
+ for(i = 0; i < n; i++){
+ 1520: 0705 addi a4,a4,1
+ 1522: fec498e3 bne s1,a2,1512 <pipe1+0x76>
+ total += n;
+ 1526: 00aa8abb addw s5,s5,a0
+ cc = cc * 2;
+ 152a: 0019979b slliw a5,s3,0x1
+ 152e: 0007899b sext.w s3,a5
+ if(cc > sizeof(buf))
+ 1532: fd3a70e3 bgeu s4,s3,14f2 <pipe1+0x56>
+ cc = sizeof(buf);
+ 1536: 89d2 mv s3,s4
+ 1538: bf6d j 14f2 <pipe1+0x56>
+ printf("%s: pipe() failed\n", s);
+ 153a: 85ca mv a1,s2
+ 153c: 00004517 auipc a0,0x4
+ 1540: 13c50513 addi a0,a0,316 # 5678 <malloc+0x8f8>
+ 1544: 00003097 auipc ra,0x3
+ 1548: 784080e7 jalr 1924(ra) # 4cc8 <printf>
+ exit(1);
+ 154c: 4505 li a0,1
+ 154e: 00003097 auipc ra,0x3
+ 1552: 3b6080e7 jalr 950(ra) # 4904 <exit>
+ close(fds[0]);
+ 1556: fa842503 lw a0,-88(s0)
+ 155a: 00003097 auipc ra,0x3
+ 155e: 3da080e7 jalr 986(ra) # 4934 <close>
+ for(n = 0; n < N; n++){
+ 1562: 00009b17 auipc s6,0x9
+ 1566: 336b0b13 addi s6,s6,822 # a898 <buf>
+ 156a: 416004bb negw s1,s6
+ 156e: 0ff4f493 zext.b s1,s1
+ 1572: 409b0993 addi s3,s6,1033
+ if(write(fds[1], buf, SZ) != SZ){
+ 1576: 8bda mv s7,s6
+ for(n = 0; n < N; n++){
+ 1578: 6a85 lui s5,0x1
+ 157a: 42da8a93 addi s5,s5,1069 # 142d <exectest+0x16d>
+{
+ 157e: 87da mv a5,s6
+ buf[i] = seq++;
+ 1580: 0097873b addw a4,a5,s1
+ 1584: 00e78023 sb a4,0(a5)
+ for(i = 0; i < SZ; i++)
+ 1588: 0785 addi a5,a5,1
+ 158a: fef99be3 bne s3,a5,1580 <pipe1+0xe4>
+ buf[i] = seq++;
+ 158e: 409a0a1b addiw s4,s4,1033
+ if(write(fds[1], buf, SZ) != SZ){
+ 1592: 40900613 li a2,1033
+ 1596: 85de mv a1,s7
+ 1598: fac42503 lw a0,-84(s0)
+ 159c: 00003097 auipc ra,0x3
+ 15a0: 38e080e7 jalr 910(ra) # 492a <write>
+ 15a4: 40900793 li a5,1033
+ 15a8: 00f51c63 bne a0,a5,15c0 <pipe1+0x124>
+ for(n = 0; n < N; n++){
+ 15ac: 24a5 addiw s1,s1,9
+ 15ae: 0ff4f493 zext.b s1,s1
+ 15b2: fd5a16e3 bne s4,s5,157e <pipe1+0xe2>
+ exit(0);
+ 15b6: 4501 li a0,0
+ 15b8: 00003097 auipc ra,0x3
+ 15bc: 34c080e7 jalr 844(ra) # 4904 <exit>
+ printf("%s: pipe1 oops 1\n", s);
+ 15c0: 85ca mv a1,s2
+ 15c2: 00004517 auipc a0,0x4
+ 15c6: 0ce50513 addi a0,a0,206 # 5690 <malloc+0x910>
+ 15ca: 00003097 auipc ra,0x3
+ 15ce: 6fe080e7 jalr 1790(ra) # 4cc8 <printf>
+ exit(1);
+ 15d2: 4505 li a0,1
+ 15d4: 00003097 auipc ra,0x3
+ 15d8: 330080e7 jalr 816(ra) # 4904 <exit>
+ printf("%s: pipe1 oops 2\n", s);
+ 15dc: 85ca mv a1,s2
+ 15de: 00004517 auipc a0,0x4
+ 15e2: 0ca50513 addi a0,a0,202 # 56a8 <malloc+0x928>
+ 15e6: 00003097 auipc ra,0x3
+ 15ea: 6e2080e7 jalr 1762(ra) # 4cc8 <printf>
+}
+ 15ee: 60e6 ld ra,88(sp)
+ 15f0: 6446 ld s0,80(sp)
+ 15f2: 64a6 ld s1,72(sp)
+ 15f4: 6906 ld s2,64(sp)
+ 15f6: 79e2 ld s3,56(sp)
+ 15f8: 7a42 ld s4,48(sp)
+ 15fa: 7aa2 ld s5,40(sp)
+ 15fc: 7b02 ld s6,32(sp)
+ 15fe: 6be2 ld s7,24(sp)
+ 1600: 6125 addi sp,sp,96
+ 1602: 8082 ret
+ if(total != N * SZ){
+ 1604: 6785 lui a5,0x1
+ 1606: 42d78793 addi a5,a5,1069 # 142d <exectest+0x16d>
+ 160a: 02fa8063 beq s5,a5,162a <pipe1+0x18e>
+ printf("%s: pipe1 oops 3 total %d\n", total);
+ 160e: 85d6 mv a1,s5
+ 1610: 00004517 auipc a0,0x4
+ 1614: 0b050513 addi a0,a0,176 # 56c0 <malloc+0x940>
+ 1618: 00003097 auipc ra,0x3
+ 161c: 6b0080e7 jalr 1712(ra) # 4cc8 <printf>
+ exit(1);
+ 1620: 4505 li a0,1
+ 1622: 00003097 auipc ra,0x3
+ 1626: 2e2080e7 jalr 738(ra) # 4904 <exit>
+ close(fds[0]);
+ 162a: fa842503 lw a0,-88(s0)
+ 162e: 00003097 auipc ra,0x3
+ 1632: 306080e7 jalr 774(ra) # 4934 <close>
+ wait(&xstatus);
+ 1636: fa440513 addi a0,s0,-92
+ 163a: 00003097 auipc ra,0x3
+ 163e: 2d4080e7 jalr 724(ra) # 490e <wait>
+ exit(xstatus);
+ 1642: fa442503 lw a0,-92(s0)
+ 1646: 00003097 auipc ra,0x3
+ 164a: 2be080e7 jalr 702(ra) # 4904 <exit>
+ printf("%s: fork() failed\n", s);
+ 164e: 85ca mv a1,s2
+ 1650: 00004517 auipc a0,0x4
+ 1654: 09050513 addi a0,a0,144 # 56e0 <malloc+0x960>
+ 1658: 00003097 auipc ra,0x3
+ 165c: 670080e7 jalr 1648(ra) # 4cc8 <printf>
+ exit(1);
+ 1660: 4505 li a0,1
+ 1662: 00003097 auipc ra,0x3
+ 1666: 2a2080e7 jalr 674(ra) # 4904 <exit>
+
+000000000000166a <exitwait>:
+{
+ 166a: 715d addi sp,sp,-80
+ 166c: e486 sd ra,72(sp)
+ 166e: e0a2 sd s0,64(sp)
+ 1670: fc26 sd s1,56(sp)
+ 1672: f84a sd s2,48(sp)
+ 1674: f44e sd s3,40(sp)
+ 1676: f052 sd s4,32(sp)
+ 1678: ec56 sd s5,24(sp)
+ 167a: 0880 addi s0,sp,80
+ 167c: 8aaa mv s5,a0
+ for(i = 0; i < 100; i++){
+ 167e: 4901 li s2,0
+ if(wait(&xstate) != pid){
+ 1680: fbc40993 addi s3,s0,-68
+ for(i = 0; i < 100; i++){
+ 1684: 06400a13 li s4,100
+ pid = fork();
+ 1688: 00003097 auipc ra,0x3
+ 168c: 274080e7 jalr 628(ra) # 48fc <fork>
+ 1690: 84aa mv s1,a0
+ if(pid < 0){
+ 1692: 02054a63 bltz a0,16c6 <exitwait+0x5c>
+ if(pid){
+ 1696: c151 beqz a0,171a <exitwait+0xb0>
+ if(wait(&xstate) != pid){
+ 1698: 854e mv a0,s3
+ 169a: 00003097 auipc ra,0x3
+ 169e: 274080e7 jalr 628(ra) # 490e <wait>
+ 16a2: 04951063 bne a0,s1,16e2 <exitwait+0x78>
+ if(i != xstate) {
+ 16a6: fbc42783 lw a5,-68(s0)
+ 16aa: 05279a63 bne a5,s2,16fe <exitwait+0x94>
+ for(i = 0; i < 100; i++){
+ 16ae: 2905 addiw s2,s2,1
+ 16b0: fd491ce3 bne s2,s4,1688 <exitwait+0x1e>
+}
+ 16b4: 60a6 ld ra,72(sp)
+ 16b6: 6406 ld s0,64(sp)
+ 16b8: 74e2 ld s1,56(sp)
+ 16ba: 7942 ld s2,48(sp)
+ 16bc: 79a2 ld s3,40(sp)
+ 16be: 7a02 ld s4,32(sp)
+ 16c0: 6ae2 ld s5,24(sp)
+ 16c2: 6161 addi sp,sp,80
+ 16c4: 8082 ret
+ printf("%s: fork failed\n", s);
+ 16c6: 85d6 mv a1,s5
+ 16c8: 00004517 auipc a0,0x4
+ 16cc: ea850513 addi a0,a0,-344 # 5570 <malloc+0x7f0>
+ 16d0: 00003097 auipc ra,0x3
+ 16d4: 5f8080e7 jalr 1528(ra) # 4cc8 <printf>
+ exit(1);
+ 16d8: 4505 li a0,1
+ 16da: 00003097 auipc ra,0x3
+ 16de: 22a080e7 jalr 554(ra) # 4904 <exit>
+ printf("%s: wait wrong pid\n", s);
+ 16e2: 85d6 mv a1,s5
+ 16e4: 00004517 auipc a0,0x4
+ 16e8: 01450513 addi a0,a0,20 # 56f8 <malloc+0x978>
+ 16ec: 00003097 auipc ra,0x3
+ 16f0: 5dc080e7 jalr 1500(ra) # 4cc8 <printf>
+ exit(1);
+ 16f4: 4505 li a0,1
+ 16f6: 00003097 auipc ra,0x3
+ 16fa: 20e080e7 jalr 526(ra) # 4904 <exit>
+ printf("%s: wait wrong exit status\n", s);
+ 16fe: 85d6 mv a1,s5
+ 1700: 00004517 auipc a0,0x4
+ 1704: 01050513 addi a0,a0,16 # 5710 <malloc+0x990>
+ 1708: 00003097 auipc ra,0x3
+ 170c: 5c0080e7 jalr 1472(ra) # 4cc8 <printf>
+ exit(1);
+ 1710: 4505 li a0,1
+ 1712: 00003097 auipc ra,0x3
+ 1716: 1f2080e7 jalr 498(ra) # 4904 <exit>
+ exit(i);
+ 171a: 854a mv a0,s2
+ 171c: 00003097 auipc ra,0x3
+ 1720: 1e8080e7 jalr 488(ra) # 4904 <exit>
+
+0000000000001724 <twochildren>:
+{
+ 1724: 1101 addi sp,sp,-32
+ 1726: ec06 sd ra,24(sp)
+ 1728: e822 sd s0,16(sp)
+ 172a: e426 sd s1,8(sp)
+ 172c: e04a sd s2,0(sp)
+ 172e: 1000 addi s0,sp,32
+ 1730: 892a mv s2,a0
+ 1732: 3e800493 li s1,1000
+ int pid1 = fork();
+ 1736: 00003097 auipc ra,0x3
+ 173a: 1c6080e7 jalr 454(ra) # 48fc <fork>
+ if(pid1 < 0){
+ 173e: 02054c63 bltz a0,1776 <twochildren+0x52>
+ if(pid1 == 0){
+ 1742: c921 beqz a0,1792 <twochildren+0x6e>
+ int pid2 = fork();
+ 1744: 00003097 auipc ra,0x3
+ 1748: 1b8080e7 jalr 440(ra) # 48fc <fork>
+ if(pid2 < 0){
+ 174c: 04054763 bltz a0,179a <twochildren+0x76>
+ if(pid2 == 0){
+ 1750: c13d beqz a0,17b6 <twochildren+0x92>
+ wait(0);
+ 1752: 4501 li a0,0
+ 1754: 00003097 auipc ra,0x3
+ 1758: 1ba080e7 jalr 442(ra) # 490e <wait>
+ wait(0);
+ 175c: 4501 li a0,0
+ 175e: 00003097 auipc ra,0x3
+ 1762: 1b0080e7 jalr 432(ra) # 490e <wait>
+ for(int i = 0; i < 1000; i++){
+ 1766: 34fd addiw s1,s1,-1
+ 1768: f4f9 bnez s1,1736 <twochildren+0x12>
+}
+ 176a: 60e2 ld ra,24(sp)
+ 176c: 6442 ld s0,16(sp)
+ 176e: 64a2 ld s1,8(sp)
+ 1770: 6902 ld s2,0(sp)
+ 1772: 6105 addi sp,sp,32
+ 1774: 8082 ret
+ printf("%s: fork failed\n", s);
+ 1776: 85ca mv a1,s2
+ 1778: 00004517 auipc a0,0x4
+ 177c: df850513 addi a0,a0,-520 # 5570 <malloc+0x7f0>
+ 1780: 00003097 auipc ra,0x3
+ 1784: 548080e7 jalr 1352(ra) # 4cc8 <printf>
+ exit(1);
+ 1788: 4505 li a0,1
+ 178a: 00003097 auipc ra,0x3
+ 178e: 17a080e7 jalr 378(ra) # 4904 <exit>
+ exit(0);
+ 1792: 00003097 auipc ra,0x3
+ 1796: 172080e7 jalr 370(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 179a: 85ca mv a1,s2
+ 179c: 00004517 auipc a0,0x4
+ 17a0: dd450513 addi a0,a0,-556 # 5570 <malloc+0x7f0>
+ 17a4: 00003097 auipc ra,0x3
+ 17a8: 524080e7 jalr 1316(ra) # 4cc8 <printf>
+ exit(1);
+ 17ac: 4505 li a0,1
+ 17ae: 00003097 auipc ra,0x3
+ 17b2: 156080e7 jalr 342(ra) # 4904 <exit>
+ exit(0);
+ 17b6: 00003097 auipc ra,0x3
+ 17ba: 14e080e7 jalr 334(ra) # 4904 <exit>
+
+00000000000017be <forkfork>:
+{
+ 17be: 7179 addi sp,sp,-48
+ 17c0: f406 sd ra,40(sp)
+ 17c2: f022 sd s0,32(sp)
+ 17c4: ec26 sd s1,24(sp)
+ 17c6: 1800 addi s0,sp,48
+ 17c8: 84aa mv s1,a0
+ int pid = fork();
+ 17ca: 00003097 auipc ra,0x3
+ 17ce: 132080e7 jalr 306(ra) # 48fc <fork>
+ if(pid < 0){
+ 17d2: 04054163 bltz a0,1814 <forkfork+0x56>
+ if(pid == 0){
+ 17d6: cd29 beqz a0,1830 <forkfork+0x72>
+ int pid = fork();
+ 17d8: 00003097 auipc ra,0x3
+ 17dc: 124080e7 jalr 292(ra) # 48fc <fork>
+ if(pid < 0){
+ 17e0: 02054a63 bltz a0,1814 <forkfork+0x56>
+ if(pid == 0){
+ 17e4: c531 beqz a0,1830 <forkfork+0x72>
+ wait(&xstatus);
+ 17e6: fdc40513 addi a0,s0,-36
+ 17ea: 00003097 auipc ra,0x3
+ 17ee: 124080e7 jalr 292(ra) # 490e <wait>
+ if(xstatus != 0) {
+ 17f2: fdc42783 lw a5,-36(s0)
+ 17f6: ebbd bnez a5,186c <forkfork+0xae>
+ wait(&xstatus);
+ 17f8: fdc40513 addi a0,s0,-36
+ 17fc: 00003097 auipc ra,0x3
+ 1800: 112080e7 jalr 274(ra) # 490e <wait>
+ if(xstatus != 0) {
+ 1804: fdc42783 lw a5,-36(s0)
+ 1808: e3b5 bnez a5,186c <forkfork+0xae>
+}
+ 180a: 70a2 ld ra,40(sp)
+ 180c: 7402 ld s0,32(sp)
+ 180e: 64e2 ld s1,24(sp)
+ 1810: 6145 addi sp,sp,48
+ 1812: 8082 ret
+ printf("%s: fork failed", s);
+ 1814: 85a6 mv a1,s1
+ 1816: 00004517 auipc a0,0x4
+ 181a: f1a50513 addi a0,a0,-230 # 5730 <malloc+0x9b0>
+ 181e: 00003097 auipc ra,0x3
+ 1822: 4aa080e7 jalr 1194(ra) # 4cc8 <printf>
+ exit(1);
+ 1826: 4505 li a0,1
+ 1828: 00003097 auipc ra,0x3
+ 182c: 0dc080e7 jalr 220(ra) # 4904 <exit>
+{
+ 1830: 0c800493 li s1,200
+ int pid1 = fork();
+ 1834: 00003097 auipc ra,0x3
+ 1838: 0c8080e7 jalr 200(ra) # 48fc <fork>
+ if(pid1 < 0){
+ 183c: 00054f63 bltz a0,185a <forkfork+0x9c>
+ if(pid1 == 0){
+ 1840: c115 beqz a0,1864 <forkfork+0xa6>
+ wait(0);
+ 1842: 4501 li a0,0
+ 1844: 00003097 auipc ra,0x3
+ 1848: 0ca080e7 jalr 202(ra) # 490e <wait>
+ for(int j = 0; j < 200; j++){
+ 184c: 34fd addiw s1,s1,-1
+ 184e: f0fd bnez s1,1834 <forkfork+0x76>
+ exit(0);
+ 1850: 4501 li a0,0
+ 1852: 00003097 auipc ra,0x3
+ 1856: 0b2080e7 jalr 178(ra) # 4904 <exit>
+ exit(1);
+ 185a: 4505 li a0,1
+ 185c: 00003097 auipc ra,0x3
+ 1860: 0a8080e7 jalr 168(ra) # 4904 <exit>
+ exit(0);
+ 1864: 00003097 auipc ra,0x3
+ 1868: 0a0080e7 jalr 160(ra) # 4904 <exit>
+ printf("%s: fork in child failed", s);
+ 186c: 85a6 mv a1,s1
+ 186e: 00004517 auipc a0,0x4
+ 1872: ed250513 addi a0,a0,-302 # 5740 <malloc+0x9c0>
+ 1876: 00003097 auipc ra,0x3
+ 187a: 452080e7 jalr 1106(ra) # 4cc8 <printf>
+ exit(1);
+ 187e: 4505 li a0,1
+ 1880: 00003097 auipc ra,0x3
+ 1884: 084080e7 jalr 132(ra) # 4904 <exit>
+
+0000000000001888 <reparent2>:
+{
+ 1888: 1101 addi sp,sp,-32
+ 188a: ec06 sd ra,24(sp)
+ 188c: e822 sd s0,16(sp)
+ 188e: e426 sd s1,8(sp)
+ 1890: 1000 addi s0,sp,32
+ 1892: 32000493 li s1,800
+ int pid1 = fork();
+ 1896: 00003097 auipc ra,0x3
+ 189a: 066080e7 jalr 102(ra) # 48fc <fork>
+ if(pid1 < 0){
+ 189e: 00054f63 bltz a0,18bc <reparent2+0x34>
+ if(pid1 == 0){
+ 18a2: c915 beqz a0,18d6 <reparent2+0x4e>
+ wait(0);
+ 18a4: 4501 li a0,0
+ 18a6: 00003097 auipc ra,0x3
+ 18aa: 068080e7 jalr 104(ra) # 490e <wait>
+ for(int i = 0; i < 800; i++){
+ 18ae: 34fd addiw s1,s1,-1
+ 18b0: f0fd bnez s1,1896 <reparent2+0xe>
+ exit(0);
+ 18b2: 4501 li a0,0
+ 18b4: 00003097 auipc ra,0x3
+ 18b8: 050080e7 jalr 80(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 18bc: 00004517 auipc a0,0x4
+ 18c0: 03450513 addi a0,a0,52 # 58f0 <malloc+0xb70>
+ 18c4: 00003097 auipc ra,0x3
+ 18c8: 404080e7 jalr 1028(ra) # 4cc8 <printf>
+ exit(1);
+ 18cc: 4505 li a0,1
+ 18ce: 00003097 auipc ra,0x3
+ 18d2: 036080e7 jalr 54(ra) # 4904 <exit>
+ fork();
+ 18d6: 00003097 auipc ra,0x3
+ 18da: 026080e7 jalr 38(ra) # 48fc <fork>
+ fork();
+ 18de: 00003097 auipc ra,0x3
+ 18e2: 01e080e7 jalr 30(ra) # 48fc <fork>
+ exit(0);
+ 18e6: 4501 li a0,0
+ 18e8: 00003097 auipc ra,0x3
+ 18ec: 01c080e7 jalr 28(ra) # 4904 <exit>
+
+00000000000018f0 <forktest>:
+{
+ 18f0: 7179 addi sp,sp,-48
+ 18f2: f406 sd ra,40(sp)
+ 18f4: f022 sd s0,32(sp)
+ 18f6: ec26 sd s1,24(sp)
+ 18f8: e84a sd s2,16(sp)
+ 18fa: e44e sd s3,8(sp)
+ 18fc: 1800 addi s0,sp,48
+ 18fe: 89aa mv s3,a0
+ for(n=0; n<N; n++){
+ 1900: 4481 li s1,0
+ 1902: 3e800913 li s2,1000
+ pid = fork();
+ 1906: 00003097 auipc ra,0x3
+ 190a: ff6080e7 jalr -10(ra) # 48fc <fork>
+ if(pid < 0)
+ 190e: 02054863 bltz a0,193e <forktest+0x4e>
+ if(pid == 0)
+ 1912: c115 beqz a0,1936 <forktest+0x46>
+ for(n=0; n<N; n++){
+ 1914: 2485 addiw s1,s1,1
+ 1916: ff2498e3 bne s1,s2,1906 <forktest+0x16>
+ printf("%s: fork claimed to work 1000 times!\n", s);
+ 191a: 85ce mv a1,s3
+ 191c: 00004517 auipc a0,0x4
+ 1920: e5c50513 addi a0,a0,-420 # 5778 <malloc+0x9f8>
+ 1924: 00003097 auipc ra,0x3
+ 1928: 3a4080e7 jalr 932(ra) # 4cc8 <printf>
+ exit(1);
+ 192c: 4505 li a0,1
+ 192e: 00003097 auipc ra,0x3
+ 1932: fd6080e7 jalr -42(ra) # 4904 <exit>
+ exit(0);
+ 1936: 00003097 auipc ra,0x3
+ 193a: fce080e7 jalr -50(ra) # 4904 <exit>
+ if (n == 0) {
+ 193e: cc9d beqz s1,197c <forktest+0x8c>
+ if(n == N){
+ 1940: 3e800793 li a5,1000
+ 1944: fcf48be3 beq s1,a5,191a <forktest+0x2a>
+ for(; n > 0; n--){
+ 1948: 00905b63 blez s1,195e <forktest+0x6e>
+ if(wait(0) < 0){
+ 194c: 4501 li a0,0
+ 194e: 00003097 auipc ra,0x3
+ 1952: fc0080e7 jalr -64(ra) # 490e <wait>
+ 1956: 04054163 bltz a0,1998 <forktest+0xa8>
+ for(; n > 0; n--){
+ 195a: 34fd addiw s1,s1,-1
+ 195c: f8e5 bnez s1,194c <forktest+0x5c>
+ if(wait(0) != -1){
+ 195e: 4501 li a0,0
+ 1960: 00003097 auipc ra,0x3
+ 1964: fae080e7 jalr -82(ra) # 490e <wait>
+ 1968: 57fd li a5,-1
+ 196a: 04f51563 bne a0,a5,19b4 <forktest+0xc4>
+}
+ 196e: 70a2 ld ra,40(sp)
+ 1970: 7402 ld s0,32(sp)
+ 1972: 64e2 ld s1,24(sp)
+ 1974: 6942 ld s2,16(sp)
+ 1976: 69a2 ld s3,8(sp)
+ 1978: 6145 addi sp,sp,48
+ 197a: 8082 ret
+ printf("%s: no fork at all!\n", s);
+ 197c: 85ce mv a1,s3
+ 197e: 00004517 auipc a0,0x4
+ 1982: de250513 addi a0,a0,-542 # 5760 <malloc+0x9e0>
+ 1986: 00003097 auipc ra,0x3
+ 198a: 342080e7 jalr 834(ra) # 4cc8 <printf>
+ exit(1);
+ 198e: 4505 li a0,1
+ 1990: 00003097 auipc ra,0x3
+ 1994: f74080e7 jalr -140(ra) # 4904 <exit>
+ printf("%s: wait stopped early\n", s);
+ 1998: 85ce mv a1,s3
+ 199a: 00004517 auipc a0,0x4
+ 199e: e0650513 addi a0,a0,-506 # 57a0 <malloc+0xa20>
+ 19a2: 00003097 auipc ra,0x3
+ 19a6: 326080e7 jalr 806(ra) # 4cc8 <printf>
+ exit(1);
+ 19aa: 4505 li a0,1
+ 19ac: 00003097 auipc ra,0x3
+ 19b0: f58080e7 jalr -168(ra) # 4904 <exit>
+ printf("%s: wait got too many\n", s);
+ 19b4: 85ce mv a1,s3
+ 19b6: 00004517 auipc a0,0x4
+ 19ba: e0250513 addi a0,a0,-510 # 57b8 <malloc+0xa38>
+ 19be: 00003097 auipc ra,0x3
+ 19c2: 30a080e7 jalr 778(ra) # 4cc8 <printf>
+ exit(1);
+ 19c6: 4505 li a0,1
+ 19c8: 00003097 auipc ra,0x3
+ 19cc: f3c080e7 jalr -196(ra) # 4904 <exit>
+
+00000000000019d0 <kernmem>:
+{
+ 19d0: 715d addi sp,sp,-80
+ 19d2: e486 sd ra,72(sp)
+ 19d4: e0a2 sd s0,64(sp)
+ 19d6: fc26 sd s1,56(sp)
+ 19d8: f84a sd s2,48(sp)
+ 19da: f44e sd s3,40(sp)
+ 19dc: f052 sd s4,32(sp)
+ 19de: ec56 sd s5,24(sp)
+ 19e0: e85a sd s6,16(sp)
+ 19e2: 0880 addi s0,sp,80
+ 19e4: 8b2a mv s6,a0
+ for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
+ 19e6: 40100493 li s1,1025
+ 19ea: 04d6 slli s1,s1,0x15
+ wait(&xstatus);
+ 19ec: fbc40a93 addi s5,s0,-68
+ if(xstatus != -1) // did kernel kill child?
+ 19f0: 5a7d li s4,-1
+ for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
+ 19f2: 69b1 lui s3,0xc
+ 19f4: 35098993 addi s3,s3,848 # c350 <__BSS_END__+0x2a0>
+ 19f8: 1007d937 lui s2,0x1007d
+ 19fc: 090e slli s2,s2,0x3
+ 19fe: 48090913 addi s2,s2,1152 # 1007d480 <__BSS_END__+0x100713d0>
+ pid = fork();
+ 1a02: 00003097 auipc ra,0x3
+ 1a06: efa080e7 jalr -262(ra) # 48fc <fork>
+ if(pid < 0){
+ 1a0a: 02054963 bltz a0,1a3c <kernmem+0x6c>
+ if(pid == 0){
+ 1a0e: c529 beqz a0,1a58 <kernmem+0x88>
+ wait(&xstatus);
+ 1a10: 8556 mv a0,s5
+ 1a12: 00003097 auipc ra,0x3
+ 1a16: efc080e7 jalr -260(ra) # 490e <wait>
+ if(xstatus != -1) // did kernel kill child?
+ 1a1a: fbc42783 lw a5,-68(s0)
+ 1a1e: 05479d63 bne a5,s4,1a78 <kernmem+0xa8>
+ for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
+ 1a22: 94ce add s1,s1,s3
+ 1a24: fd249fe3 bne s1,s2,1a02 <kernmem+0x32>
+}
+ 1a28: 60a6 ld ra,72(sp)
+ 1a2a: 6406 ld s0,64(sp)
+ 1a2c: 74e2 ld s1,56(sp)
+ 1a2e: 7942 ld s2,48(sp)
+ 1a30: 79a2 ld s3,40(sp)
+ 1a32: 7a02 ld s4,32(sp)
+ 1a34: 6ae2 ld s5,24(sp)
+ 1a36: 6b42 ld s6,16(sp)
+ 1a38: 6161 addi sp,sp,80
+ 1a3a: 8082 ret
+ printf("%s: fork failed\n", s);
+ 1a3c: 85da mv a1,s6
+ 1a3e: 00004517 auipc a0,0x4
+ 1a42: b3250513 addi a0,a0,-1230 # 5570 <malloc+0x7f0>
+ 1a46: 00003097 auipc ra,0x3
+ 1a4a: 282080e7 jalr 642(ra) # 4cc8 <printf>
+ exit(1);
+ 1a4e: 4505 li a0,1
+ 1a50: 00003097 auipc ra,0x3
+ 1a54: eb4080e7 jalr -332(ra) # 4904 <exit>
+ printf("%s: oops could read %x = %x\n", a, *a);
+ 1a58: 0004c603 lbu a2,0(s1)
+ 1a5c: 85a6 mv a1,s1
+ 1a5e: 00004517 auipc a0,0x4
+ 1a62: d7250513 addi a0,a0,-654 # 57d0 <malloc+0xa50>
+ 1a66: 00003097 auipc ra,0x3
+ 1a6a: 262080e7 jalr 610(ra) # 4cc8 <printf>
+ exit(1);
+ 1a6e: 4505 li a0,1
+ 1a70: 00003097 auipc ra,0x3
+ 1a74: e94080e7 jalr -364(ra) # 4904 <exit>
+ exit(1);
+ 1a78: 4505 li a0,1
+ 1a7a: 00003097 auipc ra,0x3
+ 1a7e: e8a080e7 jalr -374(ra) # 4904 <exit>
+
+0000000000001a82 <bigargtest>:
+{
+ 1a82: 7179 addi sp,sp,-48
+ 1a84: f406 sd ra,40(sp)
+ 1a86: f022 sd s0,32(sp)
+ 1a88: ec26 sd s1,24(sp)
+ 1a8a: 1800 addi s0,sp,48
+ 1a8c: 84aa mv s1,a0
+ remove("bigarg-ok");
+ 1a8e: 00004517 auipc a0,0x4
+ 1a92: d6250513 addi a0,a0,-670 # 57f0 <malloc+0xa70>
+ 1a96: 00003097 auipc ra,0x3
+ 1a9a: f2e080e7 jalr -210(ra) # 49c4 <remove>
+ pid = fork();
+ 1a9e: 00003097 auipc ra,0x3
+ 1aa2: e5e080e7 jalr -418(ra) # 48fc <fork>
+ if(pid == 0){
+ 1aa6: c921 beqz a0,1af6 <bigargtest+0x74>
+ } else if(pid < 0){
+ 1aa8: 0a054a63 bltz a0,1b5c <bigargtest+0xda>
+ wait(&xstatus);
+ 1aac: fdc40513 addi a0,s0,-36
+ 1ab0: 00003097 auipc ra,0x3
+ 1ab4: e5e080e7 jalr -418(ra) # 490e <wait>
+ if(xstatus != 0)
+ 1ab8: fdc42503 lw a0,-36(s0)
+ 1abc: ed55 bnez a0,1b78 <bigargtest+0xf6>
+ fd = open("bigarg-ok", 0);
+ 1abe: 4581 li a1,0
+ 1ac0: 00004517 auipc a0,0x4
+ 1ac4: d3050513 addi a0,a0,-720 # 57f0 <malloc+0xa70>
+ 1ac8: 00003097 auipc ra,0x3
+ 1acc: e88080e7 jalr -376(ra) # 4950 <open>
+ if(fd < 0){
+ 1ad0: 0a054863 bltz a0,1b80 <bigargtest+0xfe>
+ close(fd);
+ 1ad4: 00003097 auipc ra,0x3
+ 1ad8: e60080e7 jalr -416(ra) # 4934 <close>
+ remove("bigarg-ok");
+ 1adc: 00004517 auipc a0,0x4
+ 1ae0: d1450513 addi a0,a0,-748 # 57f0 <malloc+0xa70>
+ 1ae4: 00003097 auipc ra,0x3
+ 1ae8: ee0080e7 jalr -288(ra) # 49c4 <remove>
+}
+ 1aec: 70a2 ld ra,40(sp)
+ 1aee: 7402 ld s0,32(sp)
+ 1af0: 64e2 ld s1,24(sp)
+ 1af2: 6145 addi sp,sp,48
+ 1af4: 8082 ret
+ 1af6: 00005797 auipc a5,0x5
+ 1afa: 58a78793 addi a5,a5,1418 # 7080 <args.1>
+ 1afe: 00005697 auipc a3,0x5
+ 1b02: 67a68693 addi a3,a3,1658 # 7178 <args.1+0xf8>
+ args[i] = "bigargs test: failed\n ";
+ 1b06: 00004717 auipc a4,0x4
+ 1b0a: cfa70713 addi a4,a4,-774 # 5800 <malloc+0xa80>
+ 1b0e: e398 sd a4,0(a5)
+ for(i = 0; i < MAXARG-1; i++)
+ 1b10: 07a1 addi a5,a5,8
+ 1b12: fed79ee3 bne a5,a3,1b0e <bigargtest+0x8c>
+ args[MAXARG-1] = 0;
+ 1b16: 00005797 auipc a5,0x5
+ 1b1a: 6607b123 sd zero,1634(a5) # 7178 <args.1+0xf8>
+ exec("echo", args);
+ 1b1e: 00005597 auipc a1,0x5
+ 1b22: 56258593 addi a1,a1,1378 # 7080 <args.1>
+ 1b26: 00003517 auipc a0,0x3
+ 1b2a: 3ba50513 addi a0,a0,954 # 4ee0 <malloc+0x160>
+ 1b2e: 00003097 auipc ra,0x3
+ 1b32: e18080e7 jalr -488(ra) # 4946 <exec>
+ fd = open("bigarg-ok", O_CREATE);
+ 1b36: 20000593 li a1,512
+ 1b3a: 00004517 auipc a0,0x4
+ 1b3e: cb650513 addi a0,a0,-842 # 57f0 <malloc+0xa70>
+ 1b42: 00003097 auipc ra,0x3
+ 1b46: e0e080e7 jalr -498(ra) # 4950 <open>
+ close(fd);
+ 1b4a: 00003097 auipc ra,0x3
+ 1b4e: dea080e7 jalr -534(ra) # 4934 <close>
+ exit(0);
+ 1b52: 4501 li a0,0
+ 1b54: 00003097 auipc ra,0x3
+ 1b58: db0080e7 jalr -592(ra) # 4904 <exit>
+ printf("%s: bigargtest: fork failed\n", s);
+ 1b5c: 85a6 mv a1,s1
+ 1b5e: 00004517 auipc a0,0x4
+ 1b62: d8250513 addi a0,a0,-638 # 58e0 <malloc+0xb60>
+ 1b66: 00003097 auipc ra,0x3
+ 1b6a: 162080e7 jalr 354(ra) # 4cc8 <printf>
+ exit(1);
+ 1b6e: 4505 li a0,1
+ 1b70: 00003097 auipc ra,0x3
+ 1b74: d94080e7 jalr -620(ra) # 4904 <exit>
+ exit(xstatus);
+ 1b78: 00003097 auipc ra,0x3
+ 1b7c: d8c080e7 jalr -628(ra) # 4904 <exit>
+ printf("%s: bigarg test failed!\n", s);
+ 1b80: 85a6 mv a1,s1
+ 1b82: 00004517 auipc a0,0x4
+ 1b86: d7e50513 addi a0,a0,-642 # 5900 <malloc+0xb80>
+ 1b8a: 00003097 auipc ra,0x3
+ 1b8e: 13e080e7 jalr 318(ra) # 4cc8 <printf>
+ exit(1);
+ 1b92: 4505 li a0,1
+ 1b94: 00003097 auipc ra,0x3
+ 1b98: d70080e7 jalr -656(ra) # 4904 <exit>
+
+0000000000001b9c <stacktest>:
+{
+ 1b9c: 7179 addi sp,sp,-48
+ 1b9e: f406 sd ra,40(sp)
+ 1ba0: f022 sd s0,32(sp)
+ 1ba2: ec26 sd s1,24(sp)
+ 1ba4: 1800 addi s0,sp,48
+ 1ba6: 84aa mv s1,a0
+ pid = fork();
+ 1ba8: 00003097 auipc ra,0x3
+ 1bac: d54080e7 jalr -684(ra) # 48fc <fork>
+ if(pid == 0) {
+ 1bb0: c115 beqz a0,1bd4 <stacktest+0x38>
+ } else if(pid < 0){
+ 1bb2: 04054363 bltz a0,1bf8 <stacktest+0x5c>
+ wait(&xstatus);
+ 1bb6: fdc40513 addi a0,s0,-36
+ 1bba: 00003097 auipc ra,0x3
+ 1bbe: d54080e7 jalr -684(ra) # 490e <wait>
+ if(xstatus == -1) // kernel killed child?
+ 1bc2: fdc42503 lw a0,-36(s0)
+ 1bc6: 57fd li a5,-1
+ 1bc8: 04f50663 beq a0,a5,1c14 <stacktest+0x78>
+ exit(xstatus);
+ 1bcc: 00003097 auipc ra,0x3
+ 1bd0: d38080e7 jalr -712(ra) # 4904 <exit>
+
+static inline uint64
+r_sp()
+{
+ uint64 x;
+ asm volatile("mv %0, sp" : "=r" (x) );
+ 1bd4: 870a mv a4,sp
+ printf("%s: stacktest: read below stack %p\n", *sp);
+ 1bd6: 77fd lui a5,0xfffff
+ 1bd8: 97ba add a5,a5,a4
+ 1bda: 0007c583 lbu a1,0(a5) # fffffffffffff000 <__BSS_END__+0xffffffffffff2f50>
+ 1bde: 00004517 auipc a0,0x4
+ 1be2: d4250513 addi a0,a0,-702 # 5920 <malloc+0xba0>
+ 1be6: 00003097 auipc ra,0x3
+ 1bea: 0e2080e7 jalr 226(ra) # 4cc8 <printf>
+ exit(1);
+ 1bee: 4505 li a0,1
+ 1bf0: 00003097 auipc ra,0x3
+ 1bf4: d14080e7 jalr -748(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 1bf8: 85a6 mv a1,s1
+ 1bfa: 00004517 auipc a0,0x4
+ 1bfe: 97650513 addi a0,a0,-1674 # 5570 <malloc+0x7f0>
+ 1c02: 00003097 auipc ra,0x3
+ 1c06: 0c6080e7 jalr 198(ra) # 4cc8 <printf>
+ exit(1);
+ 1c0a: 4505 li a0,1
+ 1c0c: 00003097 auipc ra,0x3
+ 1c10: cf8080e7 jalr -776(ra) # 4904 <exit>
+ exit(0);
+ 1c14: 4501 li a0,0
+ 1c16: 00003097 auipc ra,0x3
+ 1c1a: cee080e7 jalr -786(ra) # 4904 <exit>
+
+0000000000001c1e <copyinstr3>:
+{
+ 1c1e: 7179 addi sp,sp,-48
+ 1c20: f406 sd ra,40(sp)
+ 1c22: f022 sd s0,32(sp)
+ 1c24: ec26 sd s1,24(sp)
+ 1c26: 1800 addi s0,sp,48
+ sbrk(8192);
+ 1c28: 6509 lui a0,0x2
+ 1c2a: 00003097 auipc ra,0x3
+ 1c2e: d60080e7 jalr -672(ra) # 498a <sbrk>
+ uint64 top = (uint64) sbrk(0);
+ 1c32: 4501 li a0,0
+ 1c34: 00003097 auipc ra,0x3
+ 1c38: d56080e7 jalr -682(ra) # 498a <sbrk>
+ if((top % PGSIZE) != 0){
+ 1c3c: 03451793 slli a5,a0,0x34
+ 1c40: eba5 bnez a5,1cb0 <copyinstr3+0x92>
+ top = (uint64) sbrk(0);
+ 1c42: 4501 li a0,0
+ 1c44: 00003097 auipc ra,0x3
+ 1c48: d46080e7 jalr -698(ra) # 498a <sbrk>
+ if(top % PGSIZE){
+ 1c4c: 03451793 slli a5,a0,0x34
+ 1c50: ebb5 bnez a5,1cc4 <copyinstr3+0xa6>
+ char *b = (char *) (top - 1);
+ 1c52: fff50493 addi s1,a0,-1 # 1fff <sbrkmuch+0x143>
+ *b = 'x';
+ 1c56: 07800793 li a5,120
+ 1c5a: fef50fa3 sb a5,-1(a0)
+ int ret = remove(b);
+ 1c5e: 8526 mv a0,s1
+ 1c60: 00003097 auipc ra,0x3
+ 1c64: d64080e7 jalr -668(ra) # 49c4 <remove>
+ if(ret != -1){
+ 1c68: 57fd li a5,-1
+ 1c6a: 06f51a63 bne a0,a5,1cde <copyinstr3+0xc0>
+ int fd = open(b, O_CREATE | O_WRONLY);
+ 1c6e: 20100593 li a1,513
+ 1c72: 8526 mv a0,s1
+ 1c74: 00003097 auipc ra,0x3
+ 1c78: cdc080e7 jalr -804(ra) # 4950 <open>
+ if(fd != -1){
+ 1c7c: 57fd li a5,-1
+ 1c7e: 06f51f63 bne a0,a5,1cfc <copyinstr3+0xde>
+ char *args[] = { "xx", 0 };
+ 1c82: 00004797 auipc a5,0x4
+ 1c86: 44e78793 addi a5,a5,1102 # 60d0 <malloc+0x1350>
+ 1c8a: fcf43823 sd a5,-48(s0)
+ 1c8e: fc043c23 sd zero,-40(s0)
+ ret = exec(b, args);
+ 1c92: fd040593 addi a1,s0,-48
+ 1c96: 8526 mv a0,s1
+ 1c98: 00003097 auipc ra,0x3
+ 1c9c: cae080e7 jalr -850(ra) # 4946 <exec>
+ if(ret != -1){
+ 1ca0: 57fd li a5,-1
+ 1ca2: 06f51c63 bne a0,a5,1d1a <copyinstr3+0xfc>
+}
+ 1ca6: 70a2 ld ra,40(sp)
+ 1ca8: 7402 ld s0,32(sp)
+ 1caa: 64e2 ld s1,24(sp)
+ 1cac: 6145 addi sp,sp,48
+ 1cae: 8082 ret
+ sbrk(PGSIZE - (top % PGSIZE));
+ 1cb0: 0347d513 srli a0,a5,0x34
+ 1cb4: 6785 lui a5,0x1
+ 1cb6: 40a7853b subw a0,a5,a0
+ 1cba: 00003097 auipc ra,0x3
+ 1cbe: cd0080e7 jalr -816(ra) # 498a <sbrk>
+ 1cc2: b741 j 1c42 <copyinstr3+0x24>
+ printf("oops\n");
+ 1cc4: 00004517 auipc a0,0x4
+ 1cc8: c8450513 addi a0,a0,-892 # 5948 <malloc+0xbc8>
+ 1ccc: 00003097 auipc ra,0x3
+ 1cd0: ffc080e7 jalr -4(ra) # 4cc8 <printf>
+ exit(1);
+ 1cd4: 4505 li a0,1
+ 1cd6: 00003097 auipc ra,0x3
+ 1cda: c2e080e7 jalr -978(ra) # 4904 <exit>
+ printf("remove(%s) returned %d, not -1\n", b, ret);
+ 1cde: 862a mv a2,a0
+ 1ce0: 85a6 mv a1,s1
+ 1ce2: 00003517 auipc a0,0x3
+ 1ce6: 7d650513 addi a0,a0,2006 # 54b8 <malloc+0x738>
+ 1cea: 00003097 auipc ra,0x3
+ 1cee: fde080e7 jalr -34(ra) # 4cc8 <printf>
+ exit(1);
+ 1cf2: 4505 li a0,1
+ 1cf4: 00003097 auipc ra,0x3
+ 1cf8: c10080e7 jalr -1008(ra) # 4904 <exit>
+ printf("open(%s) returned %d, not -1\n", b, fd);
+ 1cfc: 862a mv a2,a0
+ 1cfe: 85a6 mv a1,s1
+ 1d00: 00003517 auipc a0,0x3
+ 1d04: 7d850513 addi a0,a0,2008 # 54d8 <malloc+0x758>
+ 1d08: 00003097 auipc ra,0x3
+ 1d0c: fc0080e7 jalr -64(ra) # 4cc8 <printf>
+ exit(1);
+ 1d10: 4505 li a0,1
+ 1d12: 00003097 auipc ra,0x3
+ 1d16: bf2080e7 jalr -1038(ra) # 4904 <exit>
+ printf("exec(%s) returned %d, not -1\n", b, fd);
+ 1d1a: 567d li a2,-1
+ 1d1c: 85a6 mv a1,s1
+ 1d1e: 00003517 auipc a0,0x3
+ 1d22: 7da50513 addi a0,a0,2010 # 54f8 <malloc+0x778>
+ 1d26: 00003097 auipc ra,0x3
+ 1d2a: fa2080e7 jalr -94(ra) # 4cc8 <printf>
+ exit(1);
+ 1d2e: 4505 li a0,1
+ 1d30: 00003097 auipc ra,0x3
+ 1d34: bd4080e7 jalr -1068(ra) # 4904 <exit>
+
+0000000000001d38 <sbrkbasic>:
+{
+ 1d38: 7139 addi sp,sp,-64
+ 1d3a: fc06 sd ra,56(sp)
+ 1d3c: f822 sd s0,48(sp)
+ 1d3e: f426 sd s1,40(sp)
+ 1d40: f04a sd s2,32(sp)
+ 1d42: ec4e sd s3,24(sp)
+ 1d44: e852 sd s4,16(sp)
+ 1d46: 0080 addi s0,sp,64
+ 1d48: 8a2a mv s4,a0
+ pid = fork();
+ 1d4a: 00003097 auipc ra,0x3
+ 1d4e: bb2080e7 jalr -1102(ra) # 48fc <fork>
+ if(pid < 0){
+ 1d52: 02054c63 bltz a0,1d8a <sbrkbasic+0x52>
+ if(pid == 0){
+ 1d56: ed21 bnez a0,1dae <sbrkbasic+0x76>
+ a = sbrk(TOOMUCH);
+ 1d58: 40000537 lui a0,0x40000
+ 1d5c: 00003097 auipc ra,0x3
+ 1d60: c2e080e7 jalr -978(ra) # 498a <sbrk>
+ if(a == (char*)0xffffffffffffffffL){
+ 1d64: 57fd li a5,-1
+ 1d66: 02f50f63 beq a0,a5,1da4 <sbrkbasic+0x6c>
+ for(b = a; b < a+TOOMUCH; b += 4096){
+ 1d6a: 400007b7 lui a5,0x40000
+ 1d6e: 97aa add a5,a5,a0
+ *b = 99;
+ 1d70: 06300693 li a3,99
+ for(b = a; b < a+TOOMUCH; b += 4096){
+ 1d74: 6705 lui a4,0x1
+ *b = 99;
+ 1d76: 00d50023 sb a3,0(a0) # 40000000 <__BSS_END__+0x3fff3f50>
+ for(b = a; b < a+TOOMUCH; b += 4096){
+ 1d7a: 953a add a0,a0,a4
+ 1d7c: fef51de3 bne a0,a5,1d76 <sbrkbasic+0x3e>
+ exit(1);
+ 1d80: 4505 li a0,1
+ 1d82: 00003097 auipc ra,0x3
+ 1d86: b82080e7 jalr -1150(ra) # 4904 <exit>
+ printf("fork failed in sbrkbasic\n");
+ 1d8a: 00004517 auipc a0,0x4
+ 1d8e: bc650513 addi a0,a0,-1082 # 5950 <malloc+0xbd0>
+ 1d92: 00003097 auipc ra,0x3
+ 1d96: f36080e7 jalr -202(ra) # 4cc8 <printf>
+ exit(1);
+ 1d9a: 4505 li a0,1
+ 1d9c: 00003097 auipc ra,0x3
+ 1da0: b68080e7 jalr -1176(ra) # 4904 <exit>
+ exit(0);
+ 1da4: 4501 li a0,0
+ 1da6: 00003097 auipc ra,0x3
+ 1daa: b5e080e7 jalr -1186(ra) # 4904 <exit>
+ wait(&xstatus);
+ 1dae: fcc40513 addi a0,s0,-52
+ 1db2: 00003097 auipc ra,0x3
+ 1db6: b5c080e7 jalr -1188(ra) # 490e <wait>
+ if(xstatus == 1){
+ 1dba: fcc42703 lw a4,-52(s0)
+ 1dbe: 4785 li a5,1
+ 1dc0: 00f70d63 beq a4,a5,1dda <sbrkbasic+0xa2>
+ a = sbrk(0);
+ 1dc4: 4501 li a0,0
+ 1dc6: 00003097 auipc ra,0x3
+ 1dca: bc4080e7 jalr -1084(ra) # 498a <sbrk>
+ 1dce: 84aa mv s1,a0
+ for(i = 0; i < 5000; i++){
+ 1dd0: 4901 li s2,0
+ 1dd2: 6985 lui s3,0x1
+ 1dd4: 38898993 addi s3,s3,904 # 1388 <exectest+0xc8>
+ 1dd8: a005 j 1df8 <sbrkbasic+0xc0>
+ printf("%s: too much memory allocated!\n", s);
+ 1dda: 85d2 mv a1,s4
+ 1ddc: 00004517 auipc a0,0x4
+ 1de0: b9450513 addi a0,a0,-1132 # 5970 <malloc+0xbf0>
+ 1de4: 00003097 auipc ra,0x3
+ 1de8: ee4080e7 jalr -284(ra) # 4cc8 <printf>
+ exit(1);
+ 1dec: 4505 li a0,1
+ 1dee: 00003097 auipc ra,0x3
+ 1df2: b16080e7 jalr -1258(ra) # 4904 <exit>
+ a = b + 1;
+ 1df6: 84be mv s1,a5
+ b = sbrk(1);
+ 1df8: 4505 li a0,1
+ 1dfa: 00003097 auipc ra,0x3
+ 1dfe: b90080e7 jalr -1136(ra) # 498a <sbrk>
+ if(b != a){
+ 1e02: 04951c63 bne a0,s1,1e5a <sbrkbasic+0x122>
+ *b = 1;
+ 1e06: 4785 li a5,1
+ 1e08: 00f48023 sb a5,0(s1)
+ a = b + 1;
+ 1e0c: 00148793 addi a5,s1,1
+ for(i = 0; i < 5000; i++){
+ 1e10: 2905 addiw s2,s2,1
+ 1e12: ff3912e3 bne s2,s3,1df6 <sbrkbasic+0xbe>
+ pid = fork();
+ 1e16: 00003097 auipc ra,0x3
+ 1e1a: ae6080e7 jalr -1306(ra) # 48fc <fork>
+ 1e1e: 892a mv s2,a0
+ if(pid < 0){
+ 1e20: 04054d63 bltz a0,1e7a <sbrkbasic+0x142>
+ c = sbrk(1);
+ 1e24: 4505 li a0,1
+ 1e26: 00003097 auipc ra,0x3
+ 1e2a: b64080e7 jalr -1180(ra) # 498a <sbrk>
+ c = sbrk(1);
+ 1e2e: 4505 li a0,1
+ 1e30: 00003097 auipc ra,0x3
+ 1e34: b5a080e7 jalr -1190(ra) # 498a <sbrk>
+ if(c != a + 1){
+ 1e38: 0489 addi s1,s1,2
+ 1e3a: 04a48e63 beq s1,a0,1e96 <sbrkbasic+0x15e>
+ printf("%s: sbrk test failed post-fork\n", s);
+ 1e3e: 85d2 mv a1,s4
+ 1e40: 00004517 auipc a0,0x4
+ 1e44: b9050513 addi a0,a0,-1136 # 59d0 <malloc+0xc50>
+ 1e48: 00003097 auipc ra,0x3
+ 1e4c: e80080e7 jalr -384(ra) # 4cc8 <printf>
+ exit(1);
+ 1e50: 4505 li a0,1
+ 1e52: 00003097 auipc ra,0x3
+ 1e56: ab2080e7 jalr -1358(ra) # 4904 <exit>
+ printf("%s: sbrk test failed %d %x %x\n", i, a, b);
+ 1e5a: 86aa mv a3,a0
+ 1e5c: 8626 mv a2,s1
+ 1e5e: 85ca mv a1,s2
+ 1e60: 00004517 auipc a0,0x4
+ 1e64: b3050513 addi a0,a0,-1232 # 5990 <malloc+0xc10>
+ 1e68: 00003097 auipc ra,0x3
+ 1e6c: e60080e7 jalr -416(ra) # 4cc8 <printf>
+ exit(1);
+ 1e70: 4505 li a0,1
+ 1e72: 00003097 auipc ra,0x3
+ 1e76: a92080e7 jalr -1390(ra) # 4904 <exit>
+ printf("%s: sbrk test fork failed\n", s);
+ 1e7a: 85d2 mv a1,s4
+ 1e7c: 00004517 auipc a0,0x4
+ 1e80: b3450513 addi a0,a0,-1228 # 59b0 <malloc+0xc30>
+ 1e84: 00003097 auipc ra,0x3
+ 1e88: e44080e7 jalr -444(ra) # 4cc8 <printf>
+ exit(1);
+ 1e8c: 4505 li a0,1
+ 1e8e: 00003097 auipc ra,0x3
+ 1e92: a76080e7 jalr -1418(ra) # 4904 <exit>
+ if(pid == 0)
+ 1e96: 00091763 bnez s2,1ea4 <sbrkbasic+0x16c>
+ exit(0);
+ 1e9a: 4501 li a0,0
+ 1e9c: 00003097 auipc ra,0x3
+ 1ea0: a68080e7 jalr -1432(ra) # 4904 <exit>
+ wait(&xstatus);
+ 1ea4: fcc40513 addi a0,s0,-52
+ 1ea8: 00003097 auipc ra,0x3
+ 1eac: a66080e7 jalr -1434(ra) # 490e <wait>
+ exit(xstatus);
+ 1eb0: fcc42503 lw a0,-52(s0)
+ 1eb4: 00003097 auipc ra,0x3
+ 1eb8: a50080e7 jalr -1456(ra) # 4904 <exit>
+
+0000000000001ebc <sbrkmuch>:
+{
+ 1ebc: 7179 addi sp,sp,-48
+ 1ebe: f406 sd ra,40(sp)
+ 1ec0: f022 sd s0,32(sp)
+ 1ec2: ec26 sd s1,24(sp)
+ 1ec4: e84a sd s2,16(sp)
+ 1ec6: e44e sd s3,8(sp)
+ 1ec8: e052 sd s4,0(sp)
+ 1eca: 1800 addi s0,sp,48
+ 1ecc: 89aa mv s3,a0
+ oldbrk = sbrk(0);
+ 1ece: 4501 li a0,0
+ 1ed0: 00003097 auipc ra,0x3
+ 1ed4: aba080e7 jalr -1350(ra) # 498a <sbrk>
+ 1ed8: 892a mv s2,a0
+ a = sbrk(0);
+ 1eda: 4501 li a0,0
+ 1edc: 00003097 auipc ra,0x3
+ 1ee0: aae080e7 jalr -1362(ra) # 498a <sbrk>
+ 1ee4: 84aa mv s1,a0
+ p = sbrk(amt);
+ 1ee6: 00300537 lui a0,0x300
+ 1eea: 9d05 subw a0,a0,s1
+ 1eec: 00003097 auipc ra,0x3
+ 1ef0: a9e080e7 jalr -1378(ra) # 498a <sbrk>
+ if (p != a) {
+ 1ef4: 0ca49863 bne s1,a0,1fc4 <sbrkmuch+0x108>
+ char *eee = sbrk(0);
+ 1ef8: 4501 li a0,0
+ 1efa: 00003097 auipc ra,0x3
+ 1efe: a90080e7 jalr -1392(ra) # 498a <sbrk>
+ 1f02: 87aa mv a5,a0
+ for(char *pp = a; pp < eee; pp += 4096)
+ 1f04: 00a4f963 bgeu s1,a0,1f16 <sbrkmuch+0x5a>
+ *pp = 1;
+ 1f08: 4685 li a3,1
+ for(char *pp = a; pp < eee; pp += 4096)
+ 1f0a: 6705 lui a4,0x1
+ *pp = 1;
+ 1f0c: 00d48023 sb a3,0(s1)
+ for(char *pp = a; pp < eee; pp += 4096)
+ 1f10: 94ba add s1,s1,a4
+ 1f12: fef4ede3 bltu s1,a5,1f0c <sbrkmuch+0x50>
+ *lastaddr = 99;
+ 1f16: 003007b7 lui a5,0x300
+ 1f1a: 06300713 li a4,99
+ 1f1e: fee78fa3 sb a4,-1(a5) # 2fffff <__BSS_END__+0x2f3f4f>
+ a = sbrk(0);
+ 1f22: 4501 li a0,0
+ 1f24: 00003097 auipc ra,0x3
+ 1f28: a66080e7 jalr -1434(ra) # 498a <sbrk>
+ 1f2c: 84aa mv s1,a0
+ c = sbrk(-PGSIZE);
+ 1f2e: 757d lui a0,0xfffff
+ 1f30: 00003097 auipc ra,0x3
+ 1f34: a5a080e7 jalr -1446(ra) # 498a <sbrk>
+ if(c == (char*)0xffffffffffffffffL){
+ 1f38: 57fd li a5,-1
+ 1f3a: 0af50363 beq a0,a5,1fe0 <sbrkmuch+0x124>
+ c = sbrk(0);
+ 1f3e: 4501 li a0,0
+ 1f40: 00003097 auipc ra,0x3
+ 1f44: a4a080e7 jalr -1462(ra) # 498a <sbrk>
+ if(c != a - PGSIZE){
+ 1f48: 77fd lui a5,0xfffff
+ 1f4a: 97a6 add a5,a5,s1
+ 1f4c: 0af51863 bne a0,a5,1ffc <sbrkmuch+0x140>
+ a = sbrk(0);
+ 1f50: 4501 li a0,0
+ 1f52: 00003097 auipc ra,0x3
+ 1f56: a38080e7 jalr -1480(ra) # 498a <sbrk>
+ 1f5a: 84aa mv s1,a0
+ c = sbrk(PGSIZE);
+ 1f5c: 6505 lui a0,0x1
+ 1f5e: 00003097 auipc ra,0x3
+ 1f62: a2c080e7 jalr -1492(ra) # 498a <sbrk>
+ 1f66: 8a2a mv s4,a0
+ if(c != a || sbrk(0) != a + PGSIZE){
+ 1f68: 0aa49963 bne s1,a0,201a <sbrkmuch+0x15e>
+ 1f6c: 4501 li a0,0
+ 1f6e: 00003097 auipc ra,0x3
+ 1f72: a1c080e7 jalr -1508(ra) # 498a <sbrk>
+ 1f76: 6785 lui a5,0x1
+ 1f78: 97a6 add a5,a5,s1
+ 1f7a: 0af51063 bne a0,a5,201a <sbrkmuch+0x15e>
+ if(*lastaddr == 99){
+ 1f7e: 003007b7 lui a5,0x300
+ 1f82: fff7c703 lbu a4,-1(a5) # 2fffff <__BSS_END__+0x2f3f4f>
+ 1f86: 06300793 li a5,99
+ 1f8a: 0af70763 beq a4,a5,2038 <sbrkmuch+0x17c>
+ a = sbrk(0);
+ 1f8e: 4501 li a0,0
+ 1f90: 00003097 auipc ra,0x3
+ 1f94: 9fa080e7 jalr -1542(ra) # 498a <sbrk>
+ 1f98: 84aa mv s1,a0
+ c = sbrk(-(sbrk(0) - oldbrk));
+ 1f9a: 4501 li a0,0
+ 1f9c: 00003097 auipc ra,0x3
+ 1fa0: 9ee080e7 jalr -1554(ra) # 498a <sbrk>
+ 1fa4: 40a9053b subw a0,s2,a0
+ 1fa8: 00003097 auipc ra,0x3
+ 1fac: 9e2080e7 jalr -1566(ra) # 498a <sbrk>
+ if(c != a){
+ 1fb0: 0aa49263 bne s1,a0,2054 <sbrkmuch+0x198>
+}
+ 1fb4: 70a2 ld ra,40(sp)
+ 1fb6: 7402 ld s0,32(sp)
+ 1fb8: 64e2 ld s1,24(sp)
+ 1fba: 6942 ld s2,16(sp)
+ 1fbc: 69a2 ld s3,8(sp)
+ 1fbe: 6a02 ld s4,0(sp)
+ 1fc0: 6145 addi sp,sp,48
+ 1fc2: 8082 ret
+ printf("%s: sbrk test failed to grow big address space; enough phys mem?\n", s);
+ 1fc4: 85ce mv a1,s3
+ 1fc6: 00004517 auipc a0,0x4
+ 1fca: a2a50513 addi a0,a0,-1494 # 59f0 <malloc+0xc70>
+ 1fce: 00003097 auipc ra,0x3
+ 1fd2: cfa080e7 jalr -774(ra) # 4cc8 <printf>
+ exit(1);
+ 1fd6: 4505 li a0,1
+ 1fd8: 00003097 auipc ra,0x3
+ 1fdc: 92c080e7 jalr -1748(ra) # 4904 <exit>
+ printf("%s: sbrk could not deallocate\n", s);
+ 1fe0: 85ce mv a1,s3
+ 1fe2: 00004517 auipc a0,0x4
+ 1fe6: a5650513 addi a0,a0,-1450 # 5a38 <malloc+0xcb8>
+ 1fea: 00003097 auipc ra,0x3
+ 1fee: cde080e7 jalr -802(ra) # 4cc8 <printf>
+ exit(1);
+ 1ff2: 4505 li a0,1
+ 1ff4: 00003097 auipc ra,0x3
+ 1ff8: 910080e7 jalr -1776(ra) # 4904 <exit>
+ printf("%s: sbrk deallocation produced wrong address, a %x c %x\n", a, c);
+ 1ffc: 862a mv a2,a0
+ 1ffe: 85a6 mv a1,s1
+ 2000: 00004517 auipc a0,0x4
+ 2004: a5850513 addi a0,a0,-1448 # 5a58 <malloc+0xcd8>
+ 2008: 00003097 auipc ra,0x3
+ 200c: cc0080e7 jalr -832(ra) # 4cc8 <printf>
+ exit(1);
+ 2010: 4505 li a0,1
+ 2012: 00003097 auipc ra,0x3
+ 2016: 8f2080e7 jalr -1806(ra) # 4904 <exit>
+ printf("%s: sbrk re-allocation failed, a %x c %x\n", a, c);
+ 201a: 8652 mv a2,s4
+ 201c: 85a6 mv a1,s1
+ 201e: 00004517 auipc a0,0x4
+ 2022: a7a50513 addi a0,a0,-1414 # 5a98 <malloc+0xd18>
+ 2026: 00003097 auipc ra,0x3
+ 202a: ca2080e7 jalr -862(ra) # 4cc8 <printf>
+ exit(1);
+ 202e: 4505 li a0,1
+ 2030: 00003097 auipc ra,0x3
+ 2034: 8d4080e7 jalr -1836(ra) # 4904 <exit>
+ printf("%s: sbrk de-allocation didn't really deallocate\n", s);
+ 2038: 85ce mv a1,s3
+ 203a: 00004517 auipc a0,0x4
+ 203e: a8e50513 addi a0,a0,-1394 # 5ac8 <malloc+0xd48>
+ 2042: 00003097 auipc ra,0x3
+ 2046: c86080e7 jalr -890(ra) # 4cc8 <printf>
+ exit(1);
+ 204a: 4505 li a0,1
+ 204c: 00003097 auipc ra,0x3
+ 2050: 8b8080e7 jalr -1864(ra) # 4904 <exit>
+ printf("%s: sbrk downsize failed, a %x c %x\n", a, c);
+ 2054: 862a mv a2,a0
+ 2056: 85a6 mv a1,s1
+ 2058: 00004517 auipc a0,0x4
+ 205c: aa850513 addi a0,a0,-1368 # 5b00 <malloc+0xd80>
+ 2060: 00003097 auipc ra,0x3
+ 2064: c68080e7 jalr -920(ra) # 4cc8 <printf>
+ exit(1);
+ 2068: 4505 li a0,1
+ 206a: 00003097 auipc ra,0x3
+ 206e: 89a080e7 jalr -1894(ra) # 4904 <exit>
+
+0000000000002072 <sbrkarg>:
+{
+ 2072: 7179 addi sp,sp,-48
+ 2074: f406 sd ra,40(sp)
+ 2076: f022 sd s0,32(sp)
+ 2078: ec26 sd s1,24(sp)
+ 207a: e84a sd s2,16(sp)
+ 207c: e44e sd s3,8(sp)
+ 207e: 1800 addi s0,sp,48
+ 2080: 89aa mv s3,a0
+ a = sbrk(PGSIZE);
+ 2082: 6505 lui a0,0x1
+ 2084: 00003097 auipc ra,0x3
+ 2088: 906080e7 jalr -1786(ra) # 498a <sbrk>
+ 208c: 892a mv s2,a0
+ fd = open("sbrk", O_CREATE|O_WRONLY);
+ 208e: 20100593 li a1,513
+ 2092: 00004517 auipc a0,0x4
+ 2096: a9650513 addi a0,a0,-1386 # 5b28 <malloc+0xda8>
+ 209a: 00003097 auipc ra,0x3
+ 209e: 8b6080e7 jalr -1866(ra) # 4950 <open>
+ 20a2: 84aa mv s1,a0
+ remove("sbrk");
+ 20a4: 00004517 auipc a0,0x4
+ 20a8: a8450513 addi a0,a0,-1404 # 5b28 <malloc+0xda8>
+ 20ac: 00003097 auipc ra,0x3
+ 20b0: 918080e7 jalr -1768(ra) # 49c4 <remove>
+ if(fd < 0) {
+ 20b4: 0404c163 bltz s1,20f6 <sbrkarg+0x84>
+ if ((n = write(fd, a, PGSIZE)) < 0) {
+ 20b8: 6605 lui a2,0x1
+ 20ba: 85ca mv a1,s2
+ 20bc: 8526 mv a0,s1
+ 20be: 00003097 auipc ra,0x3
+ 20c2: 86c080e7 jalr -1940(ra) # 492a <write>
+ 20c6: 04054663 bltz a0,2112 <sbrkarg+0xa0>
+ close(fd);
+ 20ca: 8526 mv a0,s1
+ 20cc: 00003097 auipc ra,0x3
+ 20d0: 868080e7 jalr -1944(ra) # 4934 <close>
+ a = sbrk(PGSIZE);
+ 20d4: 6505 lui a0,0x1
+ 20d6: 00003097 auipc ra,0x3
+ 20da: 8b4080e7 jalr -1868(ra) # 498a <sbrk>
+ if(pipe((int *) a) != 0){
+ 20de: 00003097 auipc ra,0x3
+ 20e2: 838080e7 jalr -1992(ra) # 4916 <pipe>
+ 20e6: e521 bnez a0,212e <sbrkarg+0xbc>
+}
+ 20e8: 70a2 ld ra,40(sp)
+ 20ea: 7402 ld s0,32(sp)
+ 20ec: 64e2 ld s1,24(sp)
+ 20ee: 6942 ld s2,16(sp)
+ 20f0: 69a2 ld s3,8(sp)
+ 20f2: 6145 addi sp,sp,48
+ 20f4: 8082 ret
+ printf("%s: open sbrk failed\n", s);
+ 20f6: 85ce mv a1,s3
+ 20f8: 00004517 auipc a0,0x4
+ 20fc: a3850513 addi a0,a0,-1480 # 5b30 <malloc+0xdb0>
+ 2100: 00003097 auipc ra,0x3
+ 2104: bc8080e7 jalr -1080(ra) # 4cc8 <printf>
+ exit(1);
+ 2108: 4505 li a0,1
+ 210a: 00002097 auipc ra,0x2
+ 210e: 7fa080e7 jalr 2042(ra) # 4904 <exit>
+ printf("%s: write sbrk failed\n", s);
+ 2112: 85ce mv a1,s3
+ 2114: 00004517 auipc a0,0x4
+ 2118: a3450513 addi a0,a0,-1484 # 5b48 <malloc+0xdc8>
+ 211c: 00003097 auipc ra,0x3
+ 2120: bac080e7 jalr -1108(ra) # 4cc8 <printf>
+ exit(1);
+ 2124: 4505 li a0,1
+ 2126: 00002097 auipc ra,0x2
+ 212a: 7de080e7 jalr 2014(ra) # 4904 <exit>
+ printf("%s: pipe() failed\n", s);
+ 212e: 85ce mv a1,s3
+ 2130: 00003517 auipc a0,0x3
+ 2134: 54850513 addi a0,a0,1352 # 5678 <malloc+0x8f8>
+ 2138: 00003097 auipc ra,0x3
+ 213c: b90080e7 jalr -1136(ra) # 4cc8 <printf>
+ exit(1);
+ 2140: 4505 li a0,1
+ 2142: 00002097 auipc ra,0x2
+ 2146: 7c2080e7 jalr 1986(ra) # 4904 <exit>
+
+000000000000214a <argptest>:
+{
+ 214a: 1101 addi sp,sp,-32
+ 214c: ec06 sd ra,24(sp)
+ 214e: e822 sd s0,16(sp)
+ 2150: e426 sd s1,8(sp)
+ 2152: e04a sd s2,0(sp)
+ 2154: 1000 addi s0,sp,32
+ 2156: 892a mv s2,a0
+ fd = open("init", O_RDONLY);
+ 2158: 4581 li a1,0
+ 215a: 00004517 auipc a0,0x4
+ 215e: a0650513 addi a0,a0,-1530 # 5b60 <malloc+0xde0>
+ 2162: 00002097 auipc ra,0x2
+ 2166: 7ee080e7 jalr 2030(ra) # 4950 <open>
+ if (fd < 0) {
+ 216a: 02054b63 bltz a0,21a0 <argptest+0x56>
+ 216e: 84aa mv s1,a0
+ read(fd, sbrk(0) - 1, -1);
+ 2170: 4501 li a0,0
+ 2172: 00003097 auipc ra,0x3
+ 2176: 818080e7 jalr -2024(ra) # 498a <sbrk>
+ 217a: 567d li a2,-1
+ 217c: fff50593 addi a1,a0,-1
+ 2180: 8526 mv a0,s1
+ 2182: 00002097 auipc ra,0x2
+ 2186: 79e080e7 jalr 1950(ra) # 4920 <read>
+ close(fd);
+ 218a: 8526 mv a0,s1
+ 218c: 00002097 auipc ra,0x2
+ 2190: 7a8080e7 jalr 1960(ra) # 4934 <close>
+}
+ 2194: 60e2 ld ra,24(sp)
+ 2196: 6442 ld s0,16(sp)
+ 2198: 64a2 ld s1,8(sp)
+ 219a: 6902 ld s2,0(sp)
+ 219c: 6105 addi sp,sp,32
+ 219e: 8082 ret
+ printf("%s: open failed\n", s);
+ 21a0: 85ca mv a1,s2
+ 21a2: 00003517 auipc a0,0x3
+ 21a6: 3e650513 addi a0,a0,998 # 5588 <malloc+0x808>
+ 21aa: 00003097 auipc ra,0x3
+ 21ae: b1e080e7 jalr -1250(ra) # 4cc8 <printf>
+ exit(1);
+ 21b2: 4505 li a0,1
+ 21b4: 00002097 auipc ra,0x2
+ 21b8: 750080e7 jalr 1872(ra) # 4904 <exit>
+
+00000000000021bc <sbrkbugs>:
+{
+ 21bc: 1141 addi sp,sp,-16
+ 21be: e406 sd ra,8(sp)
+ 21c0: e022 sd s0,0(sp)
+ 21c2: 0800 addi s0,sp,16
+ int pid = fork();
+ 21c4: 00002097 auipc ra,0x2
+ 21c8: 738080e7 jalr 1848(ra) # 48fc <fork>
+ if(pid < 0){
+ 21cc: 02054263 bltz a0,21f0 <sbrkbugs+0x34>
+ if(pid == 0){
+ 21d0: ed0d bnez a0,220a <sbrkbugs+0x4e>
+ int sz = (uint64) sbrk(0);
+ 21d2: 00002097 auipc ra,0x2
+ 21d6: 7b8080e7 jalr 1976(ra) # 498a <sbrk>
+ sbrk(-sz);
+ 21da: 40a0053b negw a0,a0
+ 21de: 00002097 auipc ra,0x2
+ 21e2: 7ac080e7 jalr 1964(ra) # 498a <sbrk>
+ exit(0);
+ 21e6: 4501 li a0,0
+ 21e8: 00002097 auipc ra,0x2
+ 21ec: 71c080e7 jalr 1820(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 21f0: 00003517 auipc a0,0x3
+ 21f4: 70050513 addi a0,a0,1792 # 58f0 <malloc+0xb70>
+ 21f8: 00003097 auipc ra,0x3
+ 21fc: ad0080e7 jalr -1328(ra) # 4cc8 <printf>
+ exit(1);
+ 2200: 4505 li a0,1
+ 2202: 00002097 auipc ra,0x2
+ 2206: 702080e7 jalr 1794(ra) # 4904 <exit>
+ wait(0);
+ 220a: 4501 li a0,0
+ 220c: 00002097 auipc ra,0x2
+ 2210: 702080e7 jalr 1794(ra) # 490e <wait>
+ pid = fork();
+ 2214: 00002097 auipc ra,0x2
+ 2218: 6e8080e7 jalr 1768(ra) # 48fc <fork>
+ if(pid < 0){
+ 221c: 02054563 bltz a0,2246 <sbrkbugs+0x8a>
+ if(pid == 0){
+ 2220: e121 bnez a0,2260 <sbrkbugs+0xa4>
+ int sz = (uint64) sbrk(0);
+ 2222: 00002097 auipc ra,0x2
+ 2226: 768080e7 jalr 1896(ra) # 498a <sbrk>
+ sbrk(-(sz - 3500));
+ 222a: 6785 lui a5,0x1
+ 222c: dac7879b addiw a5,a5,-596 # dac <removeread+0xa6>
+ 2230: 40a7853b subw a0,a5,a0
+ 2234: 00002097 auipc ra,0x2
+ 2238: 756080e7 jalr 1878(ra) # 498a <sbrk>
+ exit(0);
+ 223c: 4501 li a0,0
+ 223e: 00002097 auipc ra,0x2
+ 2242: 6c6080e7 jalr 1734(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 2246: 00003517 auipc a0,0x3
+ 224a: 6aa50513 addi a0,a0,1706 # 58f0 <malloc+0xb70>
+ 224e: 00003097 auipc ra,0x3
+ 2252: a7a080e7 jalr -1414(ra) # 4cc8 <printf>
+ exit(1);
+ 2256: 4505 li a0,1
+ 2258: 00002097 auipc ra,0x2
+ 225c: 6ac080e7 jalr 1708(ra) # 4904 <exit>
+ wait(0);
+ 2260: 4501 li a0,0
+ 2262: 00002097 auipc ra,0x2
+ 2266: 6ac080e7 jalr 1708(ra) # 490e <wait>
+ pid = fork();
+ 226a: 00002097 auipc ra,0x2
+ 226e: 692080e7 jalr 1682(ra) # 48fc <fork>
+ if(pid < 0){
+ 2272: 02054a63 bltz a0,22a6 <sbrkbugs+0xea>
+ if(pid == 0){
+ 2276: e529 bnez a0,22c0 <sbrkbugs+0x104>
+ sbrk((10*4096 + 2048) - (uint64)sbrk(0));
+ 2278: 00002097 auipc ra,0x2
+ 227c: 712080e7 jalr 1810(ra) # 498a <sbrk>
+ 2280: 67ad lui a5,0xb
+ 2282: 8007879b addiw a5,a5,-2048 # a800 <uninit+0x2678>
+ 2286: 40a7853b subw a0,a5,a0
+ 228a: 00002097 auipc ra,0x2
+ 228e: 700080e7 jalr 1792(ra) # 498a <sbrk>
+ sbrk(-10);
+ 2292: 5559 li a0,-10
+ 2294: 00002097 auipc ra,0x2
+ 2298: 6f6080e7 jalr 1782(ra) # 498a <sbrk>
+ exit(0);
+ 229c: 4501 li a0,0
+ 229e: 00002097 auipc ra,0x2
+ 22a2: 666080e7 jalr 1638(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 22a6: 00003517 auipc a0,0x3
+ 22aa: 64a50513 addi a0,a0,1610 # 58f0 <malloc+0xb70>
+ 22ae: 00003097 auipc ra,0x3
+ 22b2: a1a080e7 jalr -1510(ra) # 4cc8 <printf>
+ exit(1);
+ 22b6: 4505 li a0,1
+ 22b8: 00002097 auipc ra,0x2
+ 22bc: 64c080e7 jalr 1612(ra) # 4904 <exit>
+ wait(0);
+ 22c0: 4501 li a0,0
+ 22c2: 00002097 auipc ra,0x2
+ 22c6: 64c080e7 jalr 1612(ra) # 490e <wait>
+ exit(0);
+ 22ca: 4501 li a0,0
+ 22cc: 00002097 auipc ra,0x2
+ 22d0: 638080e7 jalr 1592(ra) # 4904 <exit>
+
+00000000000022d4 <execout>:
+// test the exec() code that cleans up if it runs out
+// of memory. it's really a test that such a condition
+// doesn't cause a panic.
+void
+execout(char *s)
+{
+ 22d4: 715d addi sp,sp,-80
+ 22d6: e486 sd ra,72(sp)
+ 22d8: e0a2 sd s0,64(sp)
+ 22da: fc26 sd s1,56(sp)
+ 22dc: f84a sd s2,48(sp)
+ 22de: f44e sd s3,40(sp)
+ 22e0: f052 sd s4,32(sp)
+ 22e2: 0880 addi s0,sp,80
+ for(int avail = 0; avail < 15; avail++){
+ 22e4: 4901 li s2,0
+ 22e6: 49bd li s3,15
+ int pid = fork();
+ 22e8: 00002097 auipc ra,0x2
+ 22ec: 614080e7 jalr 1556(ra) # 48fc <fork>
+ 22f0: 84aa mv s1,a0
+ if(pid < 0){
+ 22f2: 02054063 bltz a0,2312 <execout+0x3e>
+ printf("fork failed\n");
+ exit(1);
+ } else if(pid == 0){
+ 22f6: c91d beqz a0,232c <execout+0x58>
+ close(1);
+ char *args[] = { "echo", "x", 0 };
+ exec("echo", args);
+ exit(0);
+ } else {
+ wait((int*)0);
+ 22f8: 4501 li a0,0
+ 22fa: 00002097 auipc ra,0x2
+ 22fe: 614080e7 jalr 1556(ra) # 490e <wait>
+ for(int avail = 0; avail < 15; avail++){
+ 2302: 2905 addiw s2,s2,1
+ 2304: ff3912e3 bne s2,s3,22e8 <execout+0x14>
+ }
+ }
+
+ exit(0);
+ 2308: 4501 li a0,0
+ 230a: 00002097 auipc ra,0x2
+ 230e: 5fa080e7 jalr 1530(ra) # 4904 <exit>
+ printf("fork failed\n");
+ 2312: 00003517 auipc a0,0x3
+ 2316: 5de50513 addi a0,a0,1502 # 58f0 <malloc+0xb70>
+ 231a: 00003097 auipc ra,0x3
+ 231e: 9ae080e7 jalr -1618(ra) # 4cc8 <printf>
+ exit(1);
+ 2322: 4505 li a0,1
+ 2324: 00002097 auipc ra,0x2
+ 2328: 5e0080e7 jalr 1504(ra) # 4904 <exit>
+ if(a == 0xffffffffffffffffLL)
+ 232c: 59fd li s3,-1
+ *(char*)(a + 4096 - 1) = 1;
+ 232e: 4a05 li s4,1
+ uint64 a = (uint64) sbrk(4096);
+ 2330: 6505 lui a0,0x1
+ 2332: 00002097 auipc ra,0x2
+ 2336: 658080e7 jalr 1624(ra) # 498a <sbrk>
+ if(a == 0xffffffffffffffffLL)
+ 233a: 01350763 beq a0,s3,2348 <execout+0x74>
+ *(char*)(a + 4096 - 1) = 1;
+ 233e: 6785 lui a5,0x1
+ 2340: 97aa add a5,a5,a0
+ 2342: ff478fa3 sb s4,-1(a5) # fff <copyinstr2+0xbd>
+ while(1){
+ 2346: b7ed j 2330 <execout+0x5c>
+ for(int i = 0; i < avail; i++)
+ 2348: 01205a63 blez s2,235c <execout+0x88>
+ sbrk(-4096);
+ 234c: 757d lui a0,0xfffff
+ 234e: 00002097 auipc ra,0x2
+ 2352: 63c080e7 jalr 1596(ra) # 498a <sbrk>
+ for(int i = 0; i < avail; i++)
+ 2356: 2485 addiw s1,s1,1
+ 2358: ff249ae3 bne s1,s2,234c <execout+0x78>
+ close(1);
+ 235c: 4505 li a0,1
+ 235e: 00002097 auipc ra,0x2
+ 2362: 5d6080e7 jalr 1494(ra) # 4934 <close>
+ char *args[] = { "echo", "x", 0 };
+ 2366: 00003517 auipc a0,0x3
+ 236a: b7a50513 addi a0,a0,-1158 # 4ee0 <malloc+0x160>
+ 236e: faa43c23 sd a0,-72(s0)
+ 2372: 00003797 auipc a5,0x3
+ 2376: bde78793 addi a5,a5,-1058 # 4f50 <malloc+0x1d0>
+ 237a: fcf43023 sd a5,-64(s0)
+ 237e: fc043423 sd zero,-56(s0)
+ exec("echo", args);
+ 2382: fb840593 addi a1,s0,-72
+ 2386: 00002097 auipc ra,0x2
+ 238a: 5c0080e7 jalr 1472(ra) # 4946 <exec>
+ exit(0);
+ 238e: 4501 li a0,0
+ 2390: 00002097 auipc ra,0x2
+ 2394: 574080e7 jalr 1396(ra) # 4904 <exit>
+
+0000000000002398 <iputtest>:
+{
+ 2398: 1101 addi sp,sp,-32
+ 239a: ec06 sd ra,24(sp)
+ 239c: e822 sd s0,16(sp)
+ 239e: e426 sd s1,8(sp)
+ 23a0: 1000 addi s0,sp,32
+ 23a2: 84aa mv s1,a0
+ if(mkdir("iputdir") < 0){
+ 23a4: 00003517 auipc a0,0x3
+ 23a8: 7c450513 addi a0,a0,1988 # 5b68 <malloc+0xde8>
+ 23ac: 00002097 auipc ra,0x2
+ 23b0: 5b8080e7 jalr 1464(ra) # 4964 <mkdir>
+ 23b4: 04054563 bltz a0,23fe <iputtest+0x66>
+ if(chdir("iputdir") < 0){
+ 23b8: 00003517 auipc a0,0x3
+ 23bc: 7b050513 addi a0,a0,1968 # 5b68 <malloc+0xde8>
+ 23c0: 00002097 auipc ra,0x2
+ 23c4: 5ae080e7 jalr 1454(ra) # 496e <chdir>
+ 23c8: 04054963 bltz a0,241a <iputtest+0x82>
+ if(remove("../iputdir") < 0){
+ 23cc: 00003517 auipc a0,0x3
+ 23d0: 7dc50513 addi a0,a0,2012 # 5ba8 <malloc+0xe28>
+ 23d4: 00002097 auipc ra,0x2
+ 23d8: 5f0080e7 jalr 1520(ra) # 49c4 <remove>
+ 23dc: 04054d63 bltz a0,2436 <iputtest+0x9e>
+ if(chdir("/") < 0){
+ 23e0: 00003517 auipc a0,0x3
+ 23e4: 7f850513 addi a0,a0,2040 # 5bd8 <malloc+0xe58>
+ 23e8: 00002097 auipc ra,0x2
+ 23ec: 586080e7 jalr 1414(ra) # 496e <chdir>
+ 23f0: 06054163 bltz a0,2452 <iputtest+0xba>
+}
+ 23f4: 60e2 ld ra,24(sp)
+ 23f6: 6442 ld s0,16(sp)
+ 23f8: 64a2 ld s1,8(sp)
+ 23fa: 6105 addi sp,sp,32
+ 23fc: 8082 ret
+ printf("%s: mkdir failed\n", s);
+ 23fe: 85a6 mv a1,s1
+ 2400: 00003517 auipc a0,0x3
+ 2404: 77050513 addi a0,a0,1904 # 5b70 <malloc+0xdf0>
+ 2408: 00003097 auipc ra,0x3
+ 240c: 8c0080e7 jalr -1856(ra) # 4cc8 <printf>
+ exit(1);
+ 2410: 4505 li a0,1
+ 2412: 00002097 auipc ra,0x2
+ 2416: 4f2080e7 jalr 1266(ra) # 4904 <exit>
+ printf("%s: chdir iputdir failed\n", s);
+ 241a: 85a6 mv a1,s1
+ 241c: 00003517 auipc a0,0x3
+ 2420: 76c50513 addi a0,a0,1900 # 5b88 <malloc+0xe08>
+ 2424: 00003097 auipc ra,0x3
+ 2428: 8a4080e7 jalr -1884(ra) # 4cc8 <printf>
+ exit(1);
+ 242c: 4505 li a0,1
+ 242e: 00002097 auipc ra,0x2
+ 2432: 4d6080e7 jalr 1238(ra) # 4904 <exit>
+ printf("%s: remove ../iputdir failed\n", s);
+ 2436: 85a6 mv a1,s1
+ 2438: 00003517 auipc a0,0x3
+ 243c: 78050513 addi a0,a0,1920 # 5bb8 <malloc+0xe38>
+ 2440: 00003097 auipc ra,0x3
+ 2444: 888080e7 jalr -1912(ra) # 4cc8 <printf>
+ exit(1);
+ 2448: 4505 li a0,1
+ 244a: 00002097 auipc ra,0x2
+ 244e: 4ba080e7 jalr 1210(ra) # 4904 <exit>
+ printf("%s: chdir / failed\n", s);
+ 2452: 85a6 mv a1,s1
+ 2454: 00003517 auipc a0,0x3
+ 2458: 78c50513 addi a0,a0,1932 # 5be0 <malloc+0xe60>
+ 245c: 00003097 auipc ra,0x3
+ 2460: 86c080e7 jalr -1940(ra) # 4cc8 <printf>
+ exit(1);
+ 2464: 4505 li a0,1
+ 2466: 00002097 auipc ra,0x2
+ 246a: 49e080e7 jalr 1182(ra) # 4904 <exit>
+
+000000000000246e <exitiputtest>:
+{
+ 246e: 7179 addi sp,sp,-48
+ 2470: f406 sd ra,40(sp)
+ 2472: f022 sd s0,32(sp)
+ 2474: ec26 sd s1,24(sp)
+ 2476: 1800 addi s0,sp,48
+ 2478: 84aa mv s1,a0
+ pid = fork();
+ 247a: 00002097 auipc ra,0x2
+ 247e: 482080e7 jalr 1154(ra) # 48fc <fork>
+ if(pid < 0){
+ 2482: 04054663 bltz a0,24ce <exitiputtest+0x60>
+ if(pid == 0){
+ 2486: ed45 bnez a0,253e <exitiputtest+0xd0>
+ if(mkdir("iputdir") < 0){
+ 2488: 00003517 auipc a0,0x3
+ 248c: 6e050513 addi a0,a0,1760 # 5b68 <malloc+0xde8>
+ 2490: 00002097 auipc ra,0x2
+ 2494: 4d4080e7 jalr 1236(ra) # 4964 <mkdir>
+ 2498: 04054963 bltz a0,24ea <exitiputtest+0x7c>
+ if(chdir("iputdir") < 0){
+ 249c: 00003517 auipc a0,0x3
+ 24a0: 6cc50513 addi a0,a0,1740 # 5b68 <malloc+0xde8>
+ 24a4: 00002097 auipc ra,0x2
+ 24a8: 4ca080e7 jalr 1226(ra) # 496e <chdir>
+ 24ac: 04054d63 bltz a0,2506 <exitiputtest+0x98>
+ if(remove("../iputdir") < 0){
+ 24b0: 00003517 auipc a0,0x3
+ 24b4: 6f850513 addi a0,a0,1784 # 5ba8 <malloc+0xe28>
+ 24b8: 00002097 auipc ra,0x2
+ 24bc: 50c080e7 jalr 1292(ra) # 49c4 <remove>
+ 24c0: 06054163 bltz a0,2522 <exitiputtest+0xb4>
+ exit(0);
+ 24c4: 4501 li a0,0
+ 24c6: 00002097 auipc ra,0x2
+ 24ca: 43e080e7 jalr 1086(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 24ce: 85a6 mv a1,s1
+ 24d0: 00003517 auipc a0,0x3
+ 24d4: 0a050513 addi a0,a0,160 # 5570 <malloc+0x7f0>
+ 24d8: 00002097 auipc ra,0x2
+ 24dc: 7f0080e7 jalr 2032(ra) # 4cc8 <printf>
+ exit(1);
+ 24e0: 4505 li a0,1
+ 24e2: 00002097 auipc ra,0x2
+ 24e6: 422080e7 jalr 1058(ra) # 4904 <exit>
+ printf("%s: mkdir failed\n", s);
+ 24ea: 85a6 mv a1,s1
+ 24ec: 00003517 auipc a0,0x3
+ 24f0: 68450513 addi a0,a0,1668 # 5b70 <malloc+0xdf0>
+ 24f4: 00002097 auipc ra,0x2
+ 24f8: 7d4080e7 jalr 2004(ra) # 4cc8 <printf>
+ exit(1);
+ 24fc: 4505 li a0,1
+ 24fe: 00002097 auipc ra,0x2
+ 2502: 406080e7 jalr 1030(ra) # 4904 <exit>
+ printf("%s: child chdir failed\n", s);
+ 2506: 85a6 mv a1,s1
+ 2508: 00003517 auipc a0,0x3
+ 250c: 6f050513 addi a0,a0,1776 # 5bf8 <malloc+0xe78>
+ 2510: 00002097 auipc ra,0x2
+ 2514: 7b8080e7 jalr 1976(ra) # 4cc8 <printf>
+ exit(1);
+ 2518: 4505 li a0,1
+ 251a: 00002097 auipc ra,0x2
+ 251e: 3ea080e7 jalr 1002(ra) # 4904 <exit>
+ printf("%s: remove ../iputdir failed\n", s);
+ 2522: 85a6 mv a1,s1
+ 2524: 00003517 auipc a0,0x3
+ 2528: 69450513 addi a0,a0,1684 # 5bb8 <malloc+0xe38>
+ 252c: 00002097 auipc ra,0x2
+ 2530: 79c080e7 jalr 1948(ra) # 4cc8 <printf>
+ exit(1);
+ 2534: 4505 li a0,1
+ 2536: 00002097 auipc ra,0x2
+ 253a: 3ce080e7 jalr 974(ra) # 4904 <exit>
+ wait(&xstatus);
+ 253e: fdc40513 addi a0,s0,-36
+ 2542: 00002097 auipc ra,0x2
+ 2546: 3cc080e7 jalr 972(ra) # 490e <wait>
+ exit(xstatus);
+ 254a: fdc42503 lw a0,-36(s0)
+ 254e: 00002097 auipc ra,0x2
+ 2552: 3b6080e7 jalr 950(ra) # 4904 <exit>
+
+0000000000002556 <subdir>:
+{
+ 2556: 1101 addi sp,sp,-32
+ 2558: ec06 sd ra,24(sp)
+ 255a: e822 sd s0,16(sp)
+ 255c: e426 sd s1,8(sp)
+ 255e: e04a sd s2,0(sp)
+ 2560: 1000 addi s0,sp,32
+ 2562: 892a mv s2,a0
+ remove("ff");
+ 2564: 00003517 auipc a0,0x3
+ 2568: 6ac50513 addi a0,a0,1708 # 5c10 <malloc+0xe90>
+ 256c: 00002097 auipc ra,0x2
+ 2570: 458080e7 jalr 1112(ra) # 49c4 <remove>
+ if(mkdir("dd") != 0){
+ 2574: 00003517 auipc a0,0x3
+ 2578: 6a450513 addi a0,a0,1700 # 5c18 <malloc+0xe98>
+ 257c: 00002097 auipc ra,0x2
+ 2580: 3e8080e7 jalr 1000(ra) # 4964 <mkdir>
+ 2584: 24051363 bnez a0,27ca <subdir+0x274>
+ fd = open("dd/ff", O_CREATE | O_RDWR);
+ 2588: 20200593 li a1,514
+ 258c: 00003517 auipc a0,0x3
+ 2590: 6ac50513 addi a0,a0,1708 # 5c38 <malloc+0xeb8>
+ 2594: 00002097 auipc ra,0x2
+ 2598: 3bc080e7 jalr 956(ra) # 4950 <open>
+ 259c: 84aa mv s1,a0
+ if(fd < 0){
+ 259e: 24054463 bltz a0,27e6 <subdir+0x290>
+ write(fd, "ff", 2);
+ 25a2: 4609 li a2,2
+ 25a4: 00003597 auipc a1,0x3
+ 25a8: 66c58593 addi a1,a1,1644 # 5c10 <malloc+0xe90>
+ 25ac: 00002097 auipc ra,0x2
+ 25b0: 37e080e7 jalr 894(ra) # 492a <write>
+ close(fd);
+ 25b4: 8526 mv a0,s1
+ 25b6: 00002097 auipc ra,0x2
+ 25ba: 37e080e7 jalr 894(ra) # 4934 <close>
+ if(remove("dd") >= 0){
+ 25be: 00003517 auipc a0,0x3
+ 25c2: 65a50513 addi a0,a0,1626 # 5c18 <malloc+0xe98>
+ 25c6: 00002097 auipc ra,0x2
+ 25ca: 3fe080e7 jalr 1022(ra) # 49c4 <remove>
+ 25ce: 22055a63 bgez a0,2802 <subdir+0x2ac>
+ if(mkdir("/dd/dd") != 0){
+ 25d2: 00003517 auipc a0,0x3
+ 25d6: 6be50513 addi a0,a0,1726 # 5c90 <malloc+0xf10>
+ 25da: 00002097 auipc ra,0x2
+ 25de: 38a080e7 jalr 906(ra) # 4964 <mkdir>
+ 25e2: 22051e63 bnez a0,281e <subdir+0x2c8>
+ fd = open("dd/dd/ff", O_CREATE | O_RDWR);
+ 25e6: 20200593 li a1,514
+ 25ea: 00003517 auipc a0,0x3
+ 25ee: 6ce50513 addi a0,a0,1742 # 5cb8 <malloc+0xf38>
+ 25f2: 00002097 auipc ra,0x2
+ 25f6: 35e080e7 jalr 862(ra) # 4950 <open>
+ 25fa: 84aa mv s1,a0
+ if(fd < 0){
+ 25fc: 22054f63 bltz a0,283a <subdir+0x2e4>
+ write(fd, "FF", 2);
+ 2600: 4609 li a2,2
+ 2602: 00003597 auipc a1,0x3
+ 2606: 6e658593 addi a1,a1,1766 # 5ce8 <malloc+0xf68>
+ 260a: 00002097 auipc ra,0x2
+ 260e: 320080e7 jalr 800(ra) # 492a <write>
+ close(fd);
+ 2612: 8526 mv a0,s1
+ 2614: 00002097 auipc ra,0x2
+ 2618: 320080e7 jalr 800(ra) # 4934 <close>
+ fd = open("dd/dd/../ff", 0);
+ 261c: 4581 li a1,0
+ 261e: 00003517 auipc a0,0x3
+ 2622: 6d250513 addi a0,a0,1746 # 5cf0 <malloc+0xf70>
+ 2626: 00002097 auipc ra,0x2
+ 262a: 32a080e7 jalr 810(ra) # 4950 <open>
+ 262e: 84aa mv s1,a0
+ if(fd < 0){
+ 2630: 22054363 bltz a0,2856 <subdir+0x300>
+ cc = read(fd, buf, sizeof(buf));
+ 2634: 6609 lui a2,0x2
+ 2636: 80060613 addi a2,a2,-2048 # 1800 <forkfork+0x42>
+ 263a: 00008597 auipc a1,0x8
+ 263e: 25e58593 addi a1,a1,606 # a898 <buf>
+ 2642: 00002097 auipc ra,0x2
+ 2646: 2de080e7 jalr 734(ra) # 4920 <read>
+ if(cc != 2 || buf[0] != 'f'){
+ 264a: 4789 li a5,2
+ 264c: 22f51363 bne a0,a5,2872 <subdir+0x31c>
+ 2650: 00008717 auipc a4,0x8
+ 2654: 24874703 lbu a4,584(a4) # a898 <buf>
+ 2658: 06600793 li a5,102
+ 265c: 20f71b63 bne a4,a5,2872 <subdir+0x31c>
+ close(fd);
+ 2660: 8526 mv a0,s1
+ 2662: 00002097 auipc ra,0x2
+ 2666: 2d2080e7 jalr 722(ra) # 4934 <close>
+ if(remove("dd/dd/ff") != 0){
+ 266a: 00003517 auipc a0,0x3
+ 266e: 64e50513 addi a0,a0,1614 # 5cb8 <malloc+0xf38>
+ 2672: 00002097 auipc ra,0x2
+ 2676: 352080e7 jalr 850(ra) # 49c4 <remove>
+ 267a: 20051a63 bnez a0,288e <subdir+0x338>
+ if(open("dd/dd/ff", O_RDONLY) >= 0){
+ 267e: 4581 li a1,0
+ 2680: 00003517 auipc a0,0x3
+ 2684: 63850513 addi a0,a0,1592 # 5cb8 <malloc+0xf38>
+ 2688: 00002097 auipc ra,0x2
+ 268c: 2c8080e7 jalr 712(ra) # 4950 <open>
+ 2690: 20055d63 bgez a0,28aa <subdir+0x354>
+ if(chdir("dd") != 0){
+ 2694: 00003517 auipc a0,0x3
+ 2698: 58450513 addi a0,a0,1412 # 5c18 <malloc+0xe98>
+ 269c: 00002097 auipc ra,0x2
+ 26a0: 2d2080e7 jalr 722(ra) # 496e <chdir>
+ 26a4: 22051163 bnez a0,28c6 <subdir+0x370>
+ if(chdir("dd/../../dd") != 0){
+ 26a8: 00003517 auipc a0,0x3
+ 26ac: 6f850513 addi a0,a0,1784 # 5da0 <malloc+0x1020>
+ 26b0: 00002097 auipc ra,0x2
+ 26b4: 2be080e7 jalr 702(ra) # 496e <chdir>
+ 26b8: 22051563 bnez a0,28e2 <subdir+0x38c>
+ if(chdir("dd/../../../dd") != 0){
+ 26bc: 00003517 auipc a0,0x3
+ 26c0: 71450513 addi a0,a0,1812 # 5dd0 <malloc+0x1050>
+ 26c4: 00002097 auipc ra,0x2
+ 26c8: 2aa080e7 jalr 682(ra) # 496e <chdir>
+ 26cc: 22051963 bnez a0,28fe <subdir+0x3a8>
+ if(chdir("./..") != 0){
+ 26d0: 00003517 auipc a0,0x3
+ 26d4: 73050513 addi a0,a0,1840 # 5e00 <malloc+0x1080>
+ 26d8: 00002097 auipc ra,0x2
+ 26dc: 296080e7 jalr 662(ra) # 496e <chdir>
+ 26e0: 22051d63 bnez a0,291a <subdir+0x3c4>
+ if(open("dd/dd/ff", O_RDONLY) >= 0){
+ 26e4: 4581 li a1,0
+ 26e6: 00003517 auipc a0,0x3
+ 26ea: 5d250513 addi a0,a0,1490 # 5cb8 <malloc+0xf38>
+ 26ee: 00002097 auipc ra,0x2
+ 26f2: 262080e7 jalr 610(ra) # 4950 <open>
+ 26f6: 24055063 bgez a0,2936 <subdir+0x3e0>
+ if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
+ 26fa: 20200593 li a1,514
+ 26fe: 00003517 auipc a0,0x3
+ 2702: 75250513 addi a0,a0,1874 # 5e50 <malloc+0x10d0>
+ 2706: 00002097 auipc ra,0x2
+ 270a: 24a080e7 jalr 586(ra) # 4950 <open>
+ 270e: 24055263 bgez a0,2952 <subdir+0x3fc>
+ if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
+ 2712: 20200593 li a1,514
+ 2716: 00003517 auipc a0,0x3
+ 271a: 76a50513 addi a0,a0,1898 # 5e80 <malloc+0x1100>
+ 271e: 00002097 auipc ra,0x2
+ 2722: 232080e7 jalr 562(ra) # 4950 <open>
+ 2726: 24055463 bgez a0,296e <subdir+0x418>
+ if(open("dd", O_CREATE) >= 0){
+ 272a: 20000593 li a1,512
+ 272e: 00003517 auipc a0,0x3
+ 2732: 4ea50513 addi a0,a0,1258 # 5c18 <malloc+0xe98>
+ 2736: 00002097 auipc ra,0x2
+ 273a: 21a080e7 jalr 538(ra) # 4950 <open>
+ 273e: 24055663 bgez a0,298a <subdir+0x434>
+ if(open("dd", O_RDWR) >= 0){
+ 2742: 4589 li a1,2
+ 2744: 00003517 auipc a0,0x3
+ 2748: 4d450513 addi a0,a0,1236 # 5c18 <malloc+0xe98>
+ 274c: 00002097 auipc ra,0x2
+ 2750: 204080e7 jalr 516(ra) # 4950 <open>
+ 2754: 24055963 bgez a0,29a6 <subdir+0x450>
+ if(open("dd", O_WRONLY) >= 0){
+ 2758: 4585 li a1,1
+ 275a: 00003517 auipc a0,0x3
+ 275e: 4be50513 addi a0,a0,1214 # 5c18 <malloc+0xe98>
+ 2762: 00002097 auipc ra,0x2
+ 2766: 1ee080e7 jalr 494(ra) # 4950 <open>
+ 276a: 24055c63 bgez a0,29c2 <subdir+0x46c>
+ if(remove("dd/ff") != 0){
+ 276e: 00003517 auipc a0,0x3
+ 2772: 4ca50513 addi a0,a0,1226 # 5c38 <malloc+0xeb8>
+ 2776: 00002097 auipc ra,0x2
+ 277a: 24e080e7 jalr 590(ra) # 49c4 <remove>
+ 277e: 26051063 bnez a0,29de <subdir+0x488>
+ if(remove("dd") == 0){
+ 2782: 00003517 auipc a0,0x3
+ 2786: 49650513 addi a0,a0,1174 # 5c18 <malloc+0xe98>
+ 278a: 00002097 auipc ra,0x2
+ 278e: 23a080e7 jalr 570(ra) # 49c4 <remove>
+ 2792: 26050463 beqz a0,29fa <subdir+0x4a4>
+ if(remove("dd/dd") < 0){
+ 2796: 00003517 auipc a0,0x3
+ 279a: 7c250513 addi a0,a0,1986 # 5f58 <malloc+0x11d8>
+ 279e: 00002097 auipc ra,0x2
+ 27a2: 226080e7 jalr 550(ra) # 49c4 <remove>
+ 27a6: 26054863 bltz a0,2a16 <subdir+0x4c0>
+ if(remove("dd") < 0){
+ 27aa: 00003517 auipc a0,0x3
+ 27ae: 46e50513 addi a0,a0,1134 # 5c18 <malloc+0xe98>
+ 27b2: 00002097 auipc ra,0x2
+ 27b6: 212080e7 jalr 530(ra) # 49c4 <remove>
+ 27ba: 26054c63 bltz a0,2a32 <subdir+0x4dc>
+}
+ 27be: 60e2 ld ra,24(sp)
+ 27c0: 6442 ld s0,16(sp)
+ 27c2: 64a2 ld s1,8(sp)
+ 27c4: 6902 ld s2,0(sp)
+ 27c6: 6105 addi sp,sp,32
+ 27c8: 8082 ret
+ printf("%s: mkdir dd failed\n", s);
+ 27ca: 85ca mv a1,s2
+ 27cc: 00003517 auipc a0,0x3
+ 27d0: 45450513 addi a0,a0,1108 # 5c20 <malloc+0xea0>
+ 27d4: 00002097 auipc ra,0x2
+ 27d8: 4f4080e7 jalr 1268(ra) # 4cc8 <printf>
+ exit(1);
+ 27dc: 4505 li a0,1
+ 27de: 00002097 auipc ra,0x2
+ 27e2: 126080e7 jalr 294(ra) # 4904 <exit>
+ printf("%s: create dd/ff failed\n", s);
+ 27e6: 85ca mv a1,s2
+ 27e8: 00003517 auipc a0,0x3
+ 27ec: 45850513 addi a0,a0,1112 # 5c40 <malloc+0xec0>
+ 27f0: 00002097 auipc ra,0x2
+ 27f4: 4d8080e7 jalr 1240(ra) # 4cc8 <printf>
+ exit(1);
+ 27f8: 4505 li a0,1
+ 27fa: 00002097 auipc ra,0x2
+ 27fe: 10a080e7 jalr 266(ra) # 4904 <exit>
+ printf("%s: remove dd (non-empty dir) succeeded!\n", s);
+ 2802: 85ca mv a1,s2
+ 2804: 00003517 auipc a0,0x3
+ 2808: 45c50513 addi a0,a0,1116 # 5c60 <malloc+0xee0>
+ 280c: 00002097 auipc ra,0x2
+ 2810: 4bc080e7 jalr 1212(ra) # 4cc8 <printf>
+ exit(1);
+ 2814: 4505 li a0,1
+ 2816: 00002097 auipc ra,0x2
+ 281a: 0ee080e7 jalr 238(ra) # 4904 <exit>
+ printf("subdir mkdir dd/dd failed\n", s);
+ 281e: 85ca mv a1,s2
+ 2820: 00003517 auipc a0,0x3
+ 2824: 47850513 addi a0,a0,1144 # 5c98 <malloc+0xf18>
+ 2828: 00002097 auipc ra,0x2
+ 282c: 4a0080e7 jalr 1184(ra) # 4cc8 <printf>
+ exit(1);
+ 2830: 4505 li a0,1
+ 2832: 00002097 auipc ra,0x2
+ 2836: 0d2080e7 jalr 210(ra) # 4904 <exit>
+ printf("%s: create dd/dd/ff failed\n", s);
+ 283a: 85ca mv a1,s2
+ 283c: 00003517 auipc a0,0x3
+ 2840: 48c50513 addi a0,a0,1164 # 5cc8 <malloc+0xf48>
+ 2844: 00002097 auipc ra,0x2
+ 2848: 484080e7 jalr 1156(ra) # 4cc8 <printf>
+ exit(1);
+ 284c: 4505 li a0,1
+ 284e: 00002097 auipc ra,0x2
+ 2852: 0b6080e7 jalr 182(ra) # 4904 <exit>
+ printf("%s: open dd/dd/../ff failed\n", s);
+ 2856: 85ca mv a1,s2
+ 2858: 00003517 auipc a0,0x3
+ 285c: 4a850513 addi a0,a0,1192 # 5d00 <malloc+0xf80>
+ 2860: 00002097 auipc ra,0x2
+ 2864: 468080e7 jalr 1128(ra) # 4cc8 <printf>
+ exit(1);
+ 2868: 4505 li a0,1
+ 286a: 00002097 auipc ra,0x2
+ 286e: 09a080e7 jalr 154(ra) # 4904 <exit>
+ printf("%s: dd/dd/../ff wrong content\n", s);
+ 2872: 85ca mv a1,s2
+ 2874: 00003517 auipc a0,0x3
+ 2878: 4ac50513 addi a0,a0,1196 # 5d20 <malloc+0xfa0>
+ 287c: 00002097 auipc ra,0x2
+ 2880: 44c080e7 jalr 1100(ra) # 4cc8 <printf>
+ exit(1);
+ 2884: 4505 li a0,1
+ 2886: 00002097 auipc ra,0x2
+ 288a: 07e080e7 jalr 126(ra) # 4904 <exit>
+ printf("%s: remove dd/dd/ff failed\n", s);
+ 288e: 85ca mv a1,s2
+ 2890: 00003517 auipc a0,0x3
+ 2894: 4b050513 addi a0,a0,1200 # 5d40 <malloc+0xfc0>
+ 2898: 00002097 auipc ra,0x2
+ 289c: 430080e7 jalr 1072(ra) # 4cc8 <printf>
+ exit(1);
+ 28a0: 4505 li a0,1
+ 28a2: 00002097 auipc ra,0x2
+ 28a6: 062080e7 jalr 98(ra) # 4904 <exit>
+ printf("%s: open (removeed) dd/dd/ff succeeded\n", s);
+ 28aa: 85ca mv a1,s2
+ 28ac: 00003517 auipc a0,0x3
+ 28b0: 4b450513 addi a0,a0,1204 # 5d60 <malloc+0xfe0>
+ 28b4: 00002097 auipc ra,0x2
+ 28b8: 414080e7 jalr 1044(ra) # 4cc8 <printf>
+ exit(1);
+ 28bc: 4505 li a0,1
+ 28be: 00002097 auipc ra,0x2
+ 28c2: 046080e7 jalr 70(ra) # 4904 <exit>
+ printf("%s: chdir dd failed\n", s);
+ 28c6: 85ca mv a1,s2
+ 28c8: 00003517 auipc a0,0x3
+ 28cc: 4c050513 addi a0,a0,1216 # 5d88 <malloc+0x1008>
+ 28d0: 00002097 auipc ra,0x2
+ 28d4: 3f8080e7 jalr 1016(ra) # 4cc8 <printf>
+ exit(1);
+ 28d8: 4505 li a0,1
+ 28da: 00002097 auipc ra,0x2
+ 28de: 02a080e7 jalr 42(ra) # 4904 <exit>
+ printf("%s: chdir dd/../../dd failed\n", s);
+ 28e2: 85ca mv a1,s2
+ 28e4: 00003517 auipc a0,0x3
+ 28e8: 4cc50513 addi a0,a0,1228 # 5db0 <malloc+0x1030>
+ 28ec: 00002097 auipc ra,0x2
+ 28f0: 3dc080e7 jalr 988(ra) # 4cc8 <printf>
+ exit(1);
+ 28f4: 4505 li a0,1
+ 28f6: 00002097 auipc ra,0x2
+ 28fa: 00e080e7 jalr 14(ra) # 4904 <exit>
+ printf("chdir dd/../../dd failed\n", s);
+ 28fe: 85ca mv a1,s2
+ 2900: 00003517 auipc a0,0x3
+ 2904: 4e050513 addi a0,a0,1248 # 5de0 <malloc+0x1060>
+ 2908: 00002097 auipc ra,0x2
+ 290c: 3c0080e7 jalr 960(ra) # 4cc8 <printf>
+ exit(1);
+ 2910: 4505 li a0,1
+ 2912: 00002097 auipc ra,0x2
+ 2916: ff2080e7 jalr -14(ra) # 4904 <exit>
+ printf("%s: chdir ./.. failed\n", s);
+ 291a: 85ca mv a1,s2
+ 291c: 00003517 auipc a0,0x3
+ 2920: 4ec50513 addi a0,a0,1260 # 5e08 <malloc+0x1088>
+ 2924: 00002097 auipc ra,0x2
+ 2928: 3a4080e7 jalr 932(ra) # 4cc8 <printf>
+ exit(1);
+ 292c: 4505 li a0,1
+ 292e: 00002097 auipc ra,0x2
+ 2932: fd6080e7 jalr -42(ra) # 4904 <exit>
+ printf("%s: open (removeed) dd/dd/ff succeeded!\n", s);
+ 2936: 85ca mv a1,s2
+ 2938: 00003517 auipc a0,0x3
+ 293c: 4e850513 addi a0,a0,1256 # 5e20 <malloc+0x10a0>
+ 2940: 00002097 auipc ra,0x2
+ 2944: 388080e7 jalr 904(ra) # 4cc8 <printf>
+ exit(1);
+ 2948: 4505 li a0,1
+ 294a: 00002097 auipc ra,0x2
+ 294e: fba080e7 jalr -70(ra) # 4904 <exit>
+ printf("%s: create dd/ff/ff succeeded!\n", s);
+ 2952: 85ca mv a1,s2
+ 2954: 00003517 auipc a0,0x3
+ 2958: 50c50513 addi a0,a0,1292 # 5e60 <malloc+0x10e0>
+ 295c: 00002097 auipc ra,0x2
+ 2960: 36c080e7 jalr 876(ra) # 4cc8 <printf>
+ exit(1);
+ 2964: 4505 li a0,1
+ 2966: 00002097 auipc ra,0x2
+ 296a: f9e080e7 jalr -98(ra) # 4904 <exit>
+ printf("%s: create dd/xx/ff succeeded!\n", s);
+ 296e: 85ca mv a1,s2
+ 2970: 00003517 auipc a0,0x3
+ 2974: 52050513 addi a0,a0,1312 # 5e90 <malloc+0x1110>
+ 2978: 00002097 auipc ra,0x2
+ 297c: 350080e7 jalr 848(ra) # 4cc8 <printf>
+ exit(1);
+ 2980: 4505 li a0,1
+ 2982: 00002097 auipc ra,0x2
+ 2986: f82080e7 jalr -126(ra) # 4904 <exit>
+ printf("%s: create dd succeeded!\n", s);
+ 298a: 85ca mv a1,s2
+ 298c: 00003517 auipc a0,0x3
+ 2990: 52450513 addi a0,a0,1316 # 5eb0 <malloc+0x1130>
+ 2994: 00002097 auipc ra,0x2
+ 2998: 334080e7 jalr 820(ra) # 4cc8 <printf>
+ exit(1);
+ 299c: 4505 li a0,1
+ 299e: 00002097 auipc ra,0x2
+ 29a2: f66080e7 jalr -154(ra) # 4904 <exit>
+ printf("%s: open dd rdwr succeeded!\n", s);
+ 29a6: 85ca mv a1,s2
+ 29a8: 00003517 auipc a0,0x3
+ 29ac: 52850513 addi a0,a0,1320 # 5ed0 <malloc+0x1150>
+ 29b0: 00002097 auipc ra,0x2
+ 29b4: 318080e7 jalr 792(ra) # 4cc8 <printf>
+ exit(1);
+ 29b8: 4505 li a0,1
+ 29ba: 00002097 auipc ra,0x2
+ 29be: f4a080e7 jalr -182(ra) # 4904 <exit>
+ printf("%s: open dd wronly succeeded!\n", s);
+ 29c2: 85ca mv a1,s2
+ 29c4: 00003517 auipc a0,0x3
+ 29c8: 52c50513 addi a0,a0,1324 # 5ef0 <malloc+0x1170>
+ 29cc: 00002097 auipc ra,0x2
+ 29d0: 2fc080e7 jalr 764(ra) # 4cc8 <printf>
+ exit(1);
+ 29d4: 4505 li a0,1
+ 29d6: 00002097 auipc ra,0x2
+ 29da: f2e080e7 jalr -210(ra) # 4904 <exit>
+ printf("%s: remove dd/ff failed\n", s);
+ 29de: 85ca mv a1,s2
+ 29e0: 00003517 auipc a0,0x3
+ 29e4: 53050513 addi a0,a0,1328 # 5f10 <malloc+0x1190>
+ 29e8: 00002097 auipc ra,0x2
+ 29ec: 2e0080e7 jalr 736(ra) # 4cc8 <printf>
+ exit(1);
+ 29f0: 4505 li a0,1
+ 29f2: 00002097 auipc ra,0x2
+ 29f6: f12080e7 jalr -238(ra) # 4904 <exit>
+ printf("%s: remove non-empty dd succeeded!\n", s);
+ 29fa: 85ca mv a1,s2
+ 29fc: 00003517 auipc a0,0x3
+ 2a00: 53450513 addi a0,a0,1332 # 5f30 <malloc+0x11b0>
+ 2a04: 00002097 auipc ra,0x2
+ 2a08: 2c4080e7 jalr 708(ra) # 4cc8 <printf>
+ exit(1);
+ 2a0c: 4505 li a0,1
+ 2a0e: 00002097 auipc ra,0x2
+ 2a12: ef6080e7 jalr -266(ra) # 4904 <exit>
+ printf("%s: remove dd/dd failed\n", s);
+ 2a16: 85ca mv a1,s2
+ 2a18: 00003517 auipc a0,0x3
+ 2a1c: 54850513 addi a0,a0,1352 # 5f60 <malloc+0x11e0>
+ 2a20: 00002097 auipc ra,0x2
+ 2a24: 2a8080e7 jalr 680(ra) # 4cc8 <printf>
+ exit(1);
+ 2a28: 4505 li a0,1
+ 2a2a: 00002097 auipc ra,0x2
+ 2a2e: eda080e7 jalr -294(ra) # 4904 <exit>
+ printf("%s: remove dd failed\n", s);
+ 2a32: 85ca mv a1,s2
+ 2a34: 00003517 auipc a0,0x3
+ 2a38: 54c50513 addi a0,a0,1356 # 5f80 <malloc+0x1200>
+ 2a3c: 00002097 auipc ra,0x2
+ 2a40: 28c080e7 jalr 652(ra) # 4cc8 <printf>
+ exit(1);
+ 2a44: 4505 li a0,1
+ 2a46: 00002097 auipc ra,0x2
+ 2a4a: ebe080e7 jalr -322(ra) # 4904 <exit>
+
+0000000000002a4e <rmdot>:
+{
+ 2a4e: 1101 addi sp,sp,-32
+ 2a50: ec06 sd ra,24(sp)
+ 2a52: e822 sd s0,16(sp)
+ 2a54: e426 sd s1,8(sp)
+ 2a56: 1000 addi s0,sp,32
+ 2a58: 84aa mv s1,a0
+ if(mkdir("dots") != 0){
+ 2a5a: 00003517 auipc a0,0x3
+ 2a5e: 53e50513 addi a0,a0,1342 # 5f98 <malloc+0x1218>
+ 2a62: 00002097 auipc ra,0x2
+ 2a66: f02080e7 jalr -254(ra) # 4964 <mkdir>
+ 2a6a: e549 bnez a0,2af4 <rmdot+0xa6>
+ if(chdir("dots") != 0){
+ 2a6c: 00003517 auipc a0,0x3
+ 2a70: 52c50513 addi a0,a0,1324 # 5f98 <malloc+0x1218>
+ 2a74: 00002097 auipc ra,0x2
+ 2a78: efa080e7 jalr -262(ra) # 496e <chdir>
+ 2a7c: e951 bnez a0,2b10 <rmdot+0xc2>
+ if(remove(".") == 0){
+ 2a7e: 00003517 auipc a0,0x3
+ 2a82: 55250513 addi a0,a0,1362 # 5fd0 <malloc+0x1250>
+ 2a86: 00002097 auipc ra,0x2
+ 2a8a: f3e080e7 jalr -194(ra) # 49c4 <remove>
+ 2a8e: cd59 beqz a0,2b2c <rmdot+0xde>
+ if(remove("..") == 0){
+ 2a90: 00003517 auipc a0,0x3
+ 2a94: 56050513 addi a0,a0,1376 # 5ff0 <malloc+0x1270>
+ 2a98: 00002097 auipc ra,0x2
+ 2a9c: f2c080e7 jalr -212(ra) # 49c4 <remove>
+ 2aa0: c545 beqz a0,2b48 <rmdot+0xfa>
+ if(chdir("/") != 0){
+ 2aa2: 00003517 auipc a0,0x3
+ 2aa6: 13650513 addi a0,a0,310 # 5bd8 <malloc+0xe58>
+ 2aaa: 00002097 auipc ra,0x2
+ 2aae: ec4080e7 jalr -316(ra) # 496e <chdir>
+ 2ab2: e94d bnez a0,2b64 <rmdot+0x116>
+ if(remove("dots/.") == 0){
+ 2ab4: 00003517 auipc a0,0x3
+ 2ab8: 55c50513 addi a0,a0,1372 # 6010 <malloc+0x1290>
+ 2abc: 00002097 auipc ra,0x2
+ 2ac0: f08080e7 jalr -248(ra) # 49c4 <remove>
+ 2ac4: cd55 beqz a0,2b80 <rmdot+0x132>
+ if(remove("dots/..") == 0){
+ 2ac6: 00003517 auipc a0,0x3
+ 2aca: 57250513 addi a0,a0,1394 # 6038 <malloc+0x12b8>
+ 2ace: 00002097 auipc ra,0x2
+ 2ad2: ef6080e7 jalr -266(ra) # 49c4 <remove>
+ 2ad6: c179 beqz a0,2b9c <rmdot+0x14e>
+ if(remove("dots") != 0){
+ 2ad8: 00003517 auipc a0,0x3
+ 2adc: 4c050513 addi a0,a0,1216 # 5f98 <malloc+0x1218>
+ 2ae0: 00002097 auipc ra,0x2
+ 2ae4: ee4080e7 jalr -284(ra) # 49c4 <remove>
+ 2ae8: e961 bnez a0,2bb8 <rmdot+0x16a>
+}
+ 2aea: 60e2 ld ra,24(sp)
+ 2aec: 6442 ld s0,16(sp)
+ 2aee: 64a2 ld s1,8(sp)
+ 2af0: 6105 addi sp,sp,32
+ 2af2: 8082 ret
+ printf("%s: mkdir dots failed\n", s);
+ 2af4: 85a6 mv a1,s1
+ 2af6: 00003517 auipc a0,0x3
+ 2afa: 4aa50513 addi a0,a0,1194 # 5fa0 <malloc+0x1220>
+ 2afe: 00002097 auipc ra,0x2
+ 2b02: 1ca080e7 jalr 458(ra) # 4cc8 <printf>
+ exit(1);
+ 2b06: 4505 li a0,1
+ 2b08: 00002097 auipc ra,0x2
+ 2b0c: dfc080e7 jalr -516(ra) # 4904 <exit>
+ printf("%s: chdir dots failed\n", s);
+ 2b10: 85a6 mv a1,s1
+ 2b12: 00003517 auipc a0,0x3
+ 2b16: 4a650513 addi a0,a0,1190 # 5fb8 <malloc+0x1238>
+ 2b1a: 00002097 auipc ra,0x2
+ 2b1e: 1ae080e7 jalr 430(ra) # 4cc8 <printf>
+ exit(1);
+ 2b22: 4505 li a0,1
+ 2b24: 00002097 auipc ra,0x2
+ 2b28: de0080e7 jalr -544(ra) # 4904 <exit>
+ printf("%s: rm . worked!\n", s);
+ 2b2c: 85a6 mv a1,s1
+ 2b2e: 00003517 auipc a0,0x3
+ 2b32: 4aa50513 addi a0,a0,1194 # 5fd8 <malloc+0x1258>
+ 2b36: 00002097 auipc ra,0x2
+ 2b3a: 192080e7 jalr 402(ra) # 4cc8 <printf>
+ exit(1);
+ 2b3e: 4505 li a0,1
+ 2b40: 00002097 auipc ra,0x2
+ 2b44: dc4080e7 jalr -572(ra) # 4904 <exit>
+ printf("%s: rm .. worked!\n", s);
+ 2b48: 85a6 mv a1,s1
+ 2b4a: 00003517 auipc a0,0x3
+ 2b4e: 4ae50513 addi a0,a0,1198 # 5ff8 <malloc+0x1278>
+ 2b52: 00002097 auipc ra,0x2
+ 2b56: 176080e7 jalr 374(ra) # 4cc8 <printf>
+ exit(1);
+ 2b5a: 4505 li a0,1
+ 2b5c: 00002097 auipc ra,0x2
+ 2b60: da8080e7 jalr -600(ra) # 4904 <exit>
+ printf("%s: chdir / failed\n", s);
+ 2b64: 85a6 mv a1,s1
+ 2b66: 00003517 auipc a0,0x3
+ 2b6a: 07a50513 addi a0,a0,122 # 5be0 <malloc+0xe60>
+ 2b6e: 00002097 auipc ra,0x2
+ 2b72: 15a080e7 jalr 346(ra) # 4cc8 <printf>
+ exit(1);
+ 2b76: 4505 li a0,1
+ 2b78: 00002097 auipc ra,0x2
+ 2b7c: d8c080e7 jalr -628(ra) # 4904 <exit>
+ printf("%s: remove dots/. worked!\n", s);
+ 2b80: 85a6 mv a1,s1
+ 2b82: 00003517 auipc a0,0x3
+ 2b86: 49650513 addi a0,a0,1174 # 6018 <malloc+0x1298>
+ 2b8a: 00002097 auipc ra,0x2
+ 2b8e: 13e080e7 jalr 318(ra) # 4cc8 <printf>
+ exit(1);
+ 2b92: 4505 li a0,1
+ 2b94: 00002097 auipc ra,0x2
+ 2b98: d70080e7 jalr -656(ra) # 4904 <exit>
+ printf("%s: remove dots/.. worked!\n", s);
+ 2b9c: 85a6 mv a1,s1
+ 2b9e: 00003517 auipc a0,0x3
+ 2ba2: 4a250513 addi a0,a0,1186 # 6040 <malloc+0x12c0>
+ 2ba6: 00002097 auipc ra,0x2
+ 2baa: 122080e7 jalr 290(ra) # 4cc8 <printf>
+ exit(1);
+ 2bae: 4505 li a0,1
+ 2bb0: 00002097 auipc ra,0x2
+ 2bb4: d54080e7 jalr -684(ra) # 4904 <exit>
+ printf("%s: remove dots failed!\n", s);
+ 2bb8: 85a6 mv a1,s1
+ 2bba: 00003517 auipc a0,0x3
+ 2bbe: 4a650513 addi a0,a0,1190 # 6060 <malloc+0x12e0>
+ 2bc2: 00002097 auipc ra,0x2
+ 2bc6: 106080e7 jalr 262(ra) # 4cc8 <printf>
+ exit(1);
+ 2bca: 4505 li a0,1
+ 2bcc: 00002097 auipc ra,0x2
+ 2bd0: d38080e7 jalr -712(ra) # 4904 <exit>
+
+0000000000002bd4 <dirfile>:
+{
+ 2bd4: 1101 addi sp,sp,-32
+ 2bd6: ec06 sd ra,24(sp)
+ 2bd8: e822 sd s0,16(sp)
+ 2bda: e426 sd s1,8(sp)
+ 2bdc: e04a sd s2,0(sp)
+ 2bde: 1000 addi s0,sp,32
+ 2be0: 892a mv s2,a0
+ fd = open("dirfile", O_CREATE);
+ 2be2: 20000593 li a1,512
+ 2be6: 00003517 auipc a0,0x3
+ 2bea: 49a50513 addi a0,a0,1178 # 6080 <malloc+0x1300>
+ 2bee: 00002097 auipc ra,0x2
+ 2bf2: d62080e7 jalr -670(ra) # 4950 <open>
+ if(fd < 0){
+ 2bf6: 0c054d63 bltz a0,2cd0 <dirfile+0xfc>
+ close(fd);
+ 2bfa: 00002097 auipc ra,0x2
+ 2bfe: d3a080e7 jalr -710(ra) # 4934 <close>
+ if(chdir("dirfile") == 0){
+ 2c02: 00003517 auipc a0,0x3
+ 2c06: 47e50513 addi a0,a0,1150 # 6080 <malloc+0x1300>
+ 2c0a: 00002097 auipc ra,0x2
+ 2c0e: d64080e7 jalr -668(ra) # 496e <chdir>
+ 2c12: cd69 beqz a0,2cec <dirfile+0x118>
+ fd = open("dirfile/xx", 0);
+ 2c14: 4581 li a1,0
+ 2c16: 00003517 auipc a0,0x3
+ 2c1a: 4b250513 addi a0,a0,1202 # 60c8 <malloc+0x1348>
+ 2c1e: 00002097 auipc ra,0x2
+ 2c22: d32080e7 jalr -718(ra) # 4950 <open>
+ if(fd >= 0){
+ 2c26: 0e055163 bgez a0,2d08 <dirfile+0x134>
+ fd = open("dirfile/xx", O_CREATE);
+ 2c2a: 20000593 li a1,512
+ 2c2e: 00003517 auipc a0,0x3
+ 2c32: 49a50513 addi a0,a0,1178 # 60c8 <malloc+0x1348>
+ 2c36: 00002097 auipc ra,0x2
+ 2c3a: d1a080e7 jalr -742(ra) # 4950 <open>
+ if(fd >= 0){
+ 2c3e: 0e055363 bgez a0,2d24 <dirfile+0x150>
+ if(mkdir("dirfile/xx") == 0){
+ 2c42: 00003517 auipc a0,0x3
+ 2c46: 48650513 addi a0,a0,1158 # 60c8 <malloc+0x1348>
+ 2c4a: 00002097 auipc ra,0x2
+ 2c4e: d1a080e7 jalr -742(ra) # 4964 <mkdir>
+ 2c52: c57d beqz a0,2d40 <dirfile+0x16c>
+ if(remove("dirfile/xx") == 0){
+ 2c54: 00003517 auipc a0,0x3
+ 2c58: 47450513 addi a0,a0,1140 # 60c8 <malloc+0x1348>
+ 2c5c: 00002097 auipc ra,0x2
+ 2c60: d68080e7 jalr -664(ra) # 49c4 <remove>
+ 2c64: cd65 beqz a0,2d5c <dirfile+0x188>
+ if(remove("dirfile") != 0){
+ 2c66: 00003517 auipc a0,0x3
+ 2c6a: 41a50513 addi a0,a0,1050 # 6080 <malloc+0x1300>
+ 2c6e: 00002097 auipc ra,0x2
+ 2c72: d56080e7 jalr -682(ra) # 49c4 <remove>
+ 2c76: 10051163 bnez a0,2d78 <dirfile+0x1a4>
+ fd = open(".", O_RDWR);
+ 2c7a: 4589 li a1,2
+ 2c7c: 00003517 auipc a0,0x3
+ 2c80: 35450513 addi a0,a0,852 # 5fd0 <malloc+0x1250>
+ 2c84: 00002097 auipc ra,0x2
+ 2c88: ccc080e7 jalr -820(ra) # 4950 <open>
+ if(fd >= 0){
+ 2c8c: 10055463 bgez a0,2d94 <dirfile+0x1c0>
+ fd = open(".", 0);
+ 2c90: 4581 li a1,0
+ 2c92: 00003517 auipc a0,0x3
+ 2c96: 33e50513 addi a0,a0,830 # 5fd0 <malloc+0x1250>
+ 2c9a: 00002097 auipc ra,0x2
+ 2c9e: cb6080e7 jalr -842(ra) # 4950 <open>
+ 2ca2: 84aa mv s1,a0
+ if(write(fd, "x", 1) > 0){
+ 2ca4: 4605 li a2,1
+ 2ca6: 00002597 auipc a1,0x2
+ 2caa: 2aa58593 addi a1,a1,682 # 4f50 <malloc+0x1d0>
+ 2cae: 00002097 auipc ra,0x2
+ 2cb2: c7c080e7 jalr -900(ra) # 492a <write>
+ 2cb6: 0ea04d63 bgtz a0,2db0 <dirfile+0x1dc>
+ close(fd);
+ 2cba: 8526 mv a0,s1
+ 2cbc: 00002097 auipc ra,0x2
+ 2cc0: c78080e7 jalr -904(ra) # 4934 <close>
+}
+ 2cc4: 60e2 ld ra,24(sp)
+ 2cc6: 6442 ld s0,16(sp)
+ 2cc8: 64a2 ld s1,8(sp)
+ 2cca: 6902 ld s2,0(sp)
+ 2ccc: 6105 addi sp,sp,32
+ 2cce: 8082 ret
+ printf("%s: create dirfile failed\n", s);
+ 2cd0: 85ca mv a1,s2
+ 2cd2: 00003517 auipc a0,0x3
+ 2cd6: 3b650513 addi a0,a0,950 # 6088 <malloc+0x1308>
+ 2cda: 00002097 auipc ra,0x2
+ 2cde: fee080e7 jalr -18(ra) # 4cc8 <printf>
+ exit(1);
+ 2ce2: 4505 li a0,1
+ 2ce4: 00002097 auipc ra,0x2
+ 2ce8: c20080e7 jalr -992(ra) # 4904 <exit>
+ printf("%s: chdir dirfile succeeded!\n", s);
+ 2cec: 85ca mv a1,s2
+ 2cee: 00003517 auipc a0,0x3
+ 2cf2: 3ba50513 addi a0,a0,954 # 60a8 <malloc+0x1328>
+ 2cf6: 00002097 auipc ra,0x2
+ 2cfa: fd2080e7 jalr -46(ra) # 4cc8 <printf>
+ exit(1);
+ 2cfe: 4505 li a0,1
+ 2d00: 00002097 auipc ra,0x2
+ 2d04: c04080e7 jalr -1020(ra) # 4904 <exit>
+ printf("%s: create dirfile/xx succeeded!\n", s);
+ 2d08: 85ca mv a1,s2
+ 2d0a: 00003517 auipc a0,0x3
+ 2d0e: 3ce50513 addi a0,a0,974 # 60d8 <malloc+0x1358>
+ 2d12: 00002097 auipc ra,0x2
+ 2d16: fb6080e7 jalr -74(ra) # 4cc8 <printf>
+ exit(1);
+ 2d1a: 4505 li a0,1
+ 2d1c: 00002097 auipc ra,0x2
+ 2d20: be8080e7 jalr -1048(ra) # 4904 <exit>
+ printf("%s: create dirfile/xx succeeded!\n", s);
+ 2d24: 85ca mv a1,s2
+ 2d26: 00003517 auipc a0,0x3
+ 2d2a: 3b250513 addi a0,a0,946 # 60d8 <malloc+0x1358>
+ 2d2e: 00002097 auipc ra,0x2
+ 2d32: f9a080e7 jalr -102(ra) # 4cc8 <printf>
+ exit(1);
+ 2d36: 4505 li a0,1
+ 2d38: 00002097 auipc ra,0x2
+ 2d3c: bcc080e7 jalr -1076(ra) # 4904 <exit>
+ printf("%s: mkdir dirfile/xx succeeded!\n", s);
+ 2d40: 85ca mv a1,s2
+ 2d42: 00003517 auipc a0,0x3
+ 2d46: 3be50513 addi a0,a0,958 # 6100 <malloc+0x1380>
+ 2d4a: 00002097 auipc ra,0x2
+ 2d4e: f7e080e7 jalr -130(ra) # 4cc8 <printf>
+ exit(1);
+ 2d52: 4505 li a0,1
+ 2d54: 00002097 auipc ra,0x2
+ 2d58: bb0080e7 jalr -1104(ra) # 4904 <exit>
+ printf("%s: remove dirfile/xx succeeded!\n", s);
+ 2d5c: 85ca mv a1,s2
+ 2d5e: 00003517 auipc a0,0x3
+ 2d62: 3ca50513 addi a0,a0,970 # 6128 <malloc+0x13a8>
+ 2d66: 00002097 auipc ra,0x2
+ 2d6a: f62080e7 jalr -158(ra) # 4cc8 <printf>
+ exit(1);
+ 2d6e: 4505 li a0,1
+ 2d70: 00002097 auipc ra,0x2
+ 2d74: b94080e7 jalr -1132(ra) # 4904 <exit>
+ printf("%s: remove dirfile failed!\n", s);
+ 2d78: 85ca mv a1,s2
+ 2d7a: 00003517 auipc a0,0x3
+ 2d7e: 3d650513 addi a0,a0,982 # 6150 <malloc+0x13d0>
+ 2d82: 00002097 auipc ra,0x2
+ 2d86: f46080e7 jalr -186(ra) # 4cc8 <printf>
+ exit(1);
+ 2d8a: 4505 li a0,1
+ 2d8c: 00002097 auipc ra,0x2
+ 2d90: b78080e7 jalr -1160(ra) # 4904 <exit>
+ printf("%s: open . for writing succeeded!\n", s);
+ 2d94: 85ca mv a1,s2
+ 2d96: 00003517 auipc a0,0x3
+ 2d9a: 3da50513 addi a0,a0,986 # 6170 <malloc+0x13f0>
+ 2d9e: 00002097 auipc ra,0x2
+ 2da2: f2a080e7 jalr -214(ra) # 4cc8 <printf>
+ exit(1);
+ 2da6: 4505 li a0,1
+ 2da8: 00002097 auipc ra,0x2
+ 2dac: b5c080e7 jalr -1188(ra) # 4904 <exit>
+ printf("%s: write . succeeded!\n", s);
+ 2db0: 85ca mv a1,s2
+ 2db2: 00003517 auipc a0,0x3
+ 2db6: 3e650513 addi a0,a0,998 # 6198 <malloc+0x1418>
+ 2dba: 00002097 auipc ra,0x2
+ 2dbe: f0e080e7 jalr -242(ra) # 4cc8 <printf>
+ exit(1);
+ 2dc2: 4505 li a0,1
+ 2dc4: 00002097 auipc ra,0x2
+ 2dc8: b40080e7 jalr -1216(ra) # 4904 <exit>
+
+0000000000002dcc <iref>:
+{
+ 2dcc: 7139 addi sp,sp,-64
+ 2dce: fc06 sd ra,56(sp)
+ 2dd0: f822 sd s0,48(sp)
+ 2dd2: f426 sd s1,40(sp)
+ 2dd4: f04a sd s2,32(sp)
+ 2dd6: ec4e sd s3,24(sp)
+ 2dd8: e852 sd s4,16(sp)
+ 2dda: e456 sd s5,8(sp)
+ 2ddc: 0080 addi s0,sp,64
+ 2dde: 8aaa mv s5,a0
+ 2de0: 02e00493 li s1,46
+ if(mkdir("irefd") != 0){
+ 2de4: 00003917 auipc s2,0x3
+ 2de8: 3cc90913 addi s2,s2,972 # 61b0 <malloc+0x1430>
+ mkdir("");
+ 2dec: 00003a17 auipc s4,0x3
+ 2df0: 05ca0a13 addi s4,s4,92 # 5e48 <malloc+0x10c8>
+ fd = open("xx", O_CREATE);
+ 2df4: 00003997 auipc s3,0x3
+ 2df8: 2dc98993 addi s3,s3,732 # 60d0 <malloc+0x1350>
+ 2dfc: a889 j 2e4e <iref+0x82>
+ printf("%s: mkdir irefd failed\n", s);
+ 2dfe: 85d6 mv a1,s5
+ 2e00: 00003517 auipc a0,0x3
+ 2e04: 3b850513 addi a0,a0,952 # 61b8 <malloc+0x1438>
+ 2e08: 00002097 auipc ra,0x2
+ 2e0c: ec0080e7 jalr -320(ra) # 4cc8 <printf>
+ exit(1);
+ 2e10: 4505 li a0,1
+ 2e12: 00002097 auipc ra,0x2
+ 2e16: af2080e7 jalr -1294(ra) # 4904 <exit>
+ printf("%s: chdir irefd failed\n", s);
+ 2e1a: 85d6 mv a1,s5
+ 2e1c: 00003517 auipc a0,0x3
+ 2e20: 3b450513 addi a0,a0,948 # 61d0 <malloc+0x1450>
+ 2e24: 00002097 auipc ra,0x2
+ 2e28: ea4080e7 jalr -348(ra) # 4cc8 <printf>
+ exit(1);
+ 2e2c: 4505 li a0,1
+ 2e2e: 00002097 auipc ra,0x2
+ 2e32: ad6080e7 jalr -1322(ra) # 4904 <exit>
+ close(fd);
+ 2e36: 00002097 auipc ra,0x2
+ 2e3a: afe080e7 jalr -1282(ra) # 4934 <close>
+ 2e3e: a091 j 2e82 <iref+0xb6>
+ remove("xx");
+ 2e40: 854e mv a0,s3
+ 2e42: 00002097 auipc ra,0x2
+ 2e46: b82080e7 jalr -1150(ra) # 49c4 <remove>
+ for(i = 0; i < NINODE - 4; i++){
+ 2e4a: 34fd addiw s1,s1,-1
+ 2e4c: c8a9 beqz s1,2e9e <iref+0xd2>
+ if(mkdir("irefd") != 0){
+ 2e4e: 854a mv a0,s2
+ 2e50: 00002097 auipc ra,0x2
+ 2e54: b14080e7 jalr -1260(ra) # 4964 <mkdir>
+ 2e58: f15d bnez a0,2dfe <iref+0x32>
+ if(chdir("irefd") != 0){
+ 2e5a: 854a mv a0,s2
+ 2e5c: 00002097 auipc ra,0x2
+ 2e60: b12080e7 jalr -1262(ra) # 496e <chdir>
+ 2e64: f95d bnez a0,2e1a <iref+0x4e>
+ mkdir("");
+ 2e66: 8552 mv a0,s4
+ 2e68: 00002097 auipc ra,0x2
+ 2e6c: afc080e7 jalr -1284(ra) # 4964 <mkdir>
+ fd = open("", O_CREATE);
+ 2e70: 20000593 li a1,512
+ 2e74: 8552 mv a0,s4
+ 2e76: 00002097 auipc ra,0x2
+ 2e7a: ada080e7 jalr -1318(ra) # 4950 <open>
+ if(fd >= 0)
+ 2e7e: fa055ce3 bgez a0,2e36 <iref+0x6a>
+ fd = open("xx", O_CREATE);
+ 2e82: 20000593 li a1,512
+ 2e86: 854e mv a0,s3
+ 2e88: 00002097 auipc ra,0x2
+ 2e8c: ac8080e7 jalr -1336(ra) # 4950 <open>
+ if(fd >= 0)
+ 2e90: fa0548e3 bltz a0,2e40 <iref+0x74>
+ close(fd);
+ 2e94: 00002097 auipc ra,0x2
+ 2e98: aa0080e7 jalr -1376(ra) # 4934 <close>
+ 2e9c: b755 j 2e40 <iref+0x74>
+ 2e9e: 03300493 li s1,51
+ chdir("..");
+ 2ea2: 00003997 auipc s3,0x3
+ 2ea6: 14e98993 addi s3,s3,334 # 5ff0 <malloc+0x1270>
+ remove("irefd");
+ 2eaa: 00003917 auipc s2,0x3
+ 2eae: 30690913 addi s2,s2,774 # 61b0 <malloc+0x1430>
+ chdir("..");
+ 2eb2: 854e mv a0,s3
+ 2eb4: 00002097 auipc ra,0x2
+ 2eb8: aba080e7 jalr -1350(ra) # 496e <chdir>
+ remove("irefd");
+ 2ebc: 854a mv a0,s2
+ 2ebe: 00002097 auipc ra,0x2
+ 2ec2: b06080e7 jalr -1274(ra) # 49c4 <remove>
+ for(i = 0; i < NINODE + 1; i++){
+ 2ec6: 34fd addiw s1,s1,-1
+ 2ec8: f4ed bnez s1,2eb2 <iref+0xe6>
+ chdir("/");
+ 2eca: 00003517 auipc a0,0x3
+ 2ece: d0e50513 addi a0,a0,-754 # 5bd8 <malloc+0xe58>
+ 2ed2: 00002097 auipc ra,0x2
+ 2ed6: a9c080e7 jalr -1380(ra) # 496e <chdir>
+}
+ 2eda: 70e2 ld ra,56(sp)
+ 2edc: 7442 ld s0,48(sp)
+ 2ede: 74a2 ld s1,40(sp)
+ 2ee0: 7902 ld s2,32(sp)
+ 2ee2: 69e2 ld s3,24(sp)
+ 2ee4: 6a42 ld s4,16(sp)
+ 2ee6: 6aa2 ld s5,8(sp)
+ 2ee8: 6121 addi sp,sp,64
+ 2eea: 8082 ret
+
+0000000000002eec <openiputtest>:
+{
+ 2eec: 7179 addi sp,sp,-48
+ 2eee: f406 sd ra,40(sp)
+ 2ef0: f022 sd s0,32(sp)
+ 2ef2: ec26 sd s1,24(sp)
+ 2ef4: 1800 addi s0,sp,48
+ 2ef6: 84aa mv s1,a0
+ if(mkdir("oidir") < 0){
+ 2ef8: 00003517 auipc a0,0x3
+ 2efc: 2f050513 addi a0,a0,752 # 61e8 <malloc+0x1468>
+ 2f00: 00002097 auipc ra,0x2
+ 2f04: a64080e7 jalr -1436(ra) # 4964 <mkdir>
+ 2f08: 04054263 bltz a0,2f4c <openiputtest+0x60>
+ pid = fork();
+ 2f0c: 00002097 auipc ra,0x2
+ 2f10: 9f0080e7 jalr -1552(ra) # 48fc <fork>
+ if(pid < 0){
+ 2f14: 04054a63 bltz a0,2f68 <openiputtest+0x7c>
+ if(pid == 0){
+ 2f18: e93d bnez a0,2f8e <openiputtest+0xa2>
+ int fd = open("oidir", O_RDWR);
+ 2f1a: 4589 li a1,2
+ 2f1c: 00003517 auipc a0,0x3
+ 2f20: 2cc50513 addi a0,a0,716 # 61e8 <malloc+0x1468>
+ 2f24: 00002097 auipc ra,0x2
+ 2f28: a2c080e7 jalr -1492(ra) # 4950 <open>
+ if(fd >= 0){
+ 2f2c: 04054c63 bltz a0,2f84 <openiputtest+0x98>
+ printf("%s: open directory for write succeeded\n", s);
+ 2f30: 85a6 mv a1,s1
+ 2f32: 00003517 auipc a0,0x3
+ 2f36: 2d650513 addi a0,a0,726 # 6208 <malloc+0x1488>
+ 2f3a: 00002097 auipc ra,0x2
+ 2f3e: d8e080e7 jalr -626(ra) # 4cc8 <printf>
+ exit(1);
+ 2f42: 4505 li a0,1
+ 2f44: 00002097 auipc ra,0x2
+ 2f48: 9c0080e7 jalr -1600(ra) # 4904 <exit>
+ printf("%s: mkdir oidir failed\n", s);
+ 2f4c: 85a6 mv a1,s1
+ 2f4e: 00003517 auipc a0,0x3
+ 2f52: 2a250513 addi a0,a0,674 # 61f0 <malloc+0x1470>
+ 2f56: 00002097 auipc ra,0x2
+ 2f5a: d72080e7 jalr -654(ra) # 4cc8 <printf>
+ exit(1);
+ 2f5e: 4505 li a0,1
+ 2f60: 00002097 auipc ra,0x2
+ 2f64: 9a4080e7 jalr -1628(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 2f68: 85a6 mv a1,s1
+ 2f6a: 00002517 auipc a0,0x2
+ 2f6e: 60650513 addi a0,a0,1542 # 5570 <malloc+0x7f0>
+ 2f72: 00002097 auipc ra,0x2
+ 2f76: d56080e7 jalr -682(ra) # 4cc8 <printf>
+ exit(1);
+ 2f7a: 4505 li a0,1
+ 2f7c: 00002097 auipc ra,0x2
+ 2f80: 988080e7 jalr -1656(ra) # 4904 <exit>
+ exit(0);
+ 2f84: 4501 li a0,0
+ 2f86: 00002097 auipc ra,0x2
+ 2f8a: 97e080e7 jalr -1666(ra) # 4904 <exit>
+ sleep(1);
+ 2f8e: 4505 li a0,1
+ 2f90: 00002097 auipc ra,0x2
+ 2f94: a02080e7 jalr -1534(ra) # 4992 <sleep>
+ if(remove("oidir") != 0){
+ 2f98: 00003517 auipc a0,0x3
+ 2f9c: 25050513 addi a0,a0,592 # 61e8 <malloc+0x1468>
+ 2fa0: 00002097 auipc ra,0x2
+ 2fa4: a24080e7 jalr -1500(ra) # 49c4 <remove>
+ 2fa8: cd19 beqz a0,2fc6 <openiputtest+0xda>
+ printf("%s: remove failed\n", s);
+ 2faa: 85a6 mv a1,s1
+ 2fac: 00003517 auipc a0,0x3
+ 2fb0: 28450513 addi a0,a0,644 # 6230 <malloc+0x14b0>
+ 2fb4: 00002097 auipc ra,0x2
+ 2fb8: d14080e7 jalr -748(ra) # 4cc8 <printf>
+ exit(1);
+ 2fbc: 4505 li a0,1
+ 2fbe: 00002097 auipc ra,0x2
+ 2fc2: 946080e7 jalr -1722(ra) # 4904 <exit>
+ wait(&xstatus);
+ 2fc6: fdc40513 addi a0,s0,-36
+ 2fca: 00002097 auipc ra,0x2
+ 2fce: 944080e7 jalr -1724(ra) # 490e <wait>
+ exit(xstatus);
+ 2fd2: fdc42503 lw a0,-36(s0)
+ 2fd6: 00002097 auipc ra,0x2
+ 2fda: 92e080e7 jalr -1746(ra) # 4904 <exit>
+
+0000000000002fde <forkforkfork>:
+{
+ 2fde: 1101 addi sp,sp,-32
+ 2fe0: ec06 sd ra,24(sp)
+ 2fe2: e822 sd s0,16(sp)
+ 2fe4: e426 sd s1,8(sp)
+ 2fe6: 1000 addi s0,sp,32
+ 2fe8: 84aa mv s1,a0
+ remove("stopforking");
+ 2fea: 00003517 auipc a0,0x3
+ 2fee: 25e50513 addi a0,a0,606 # 6248 <malloc+0x14c8>
+ 2ff2: 00002097 auipc ra,0x2
+ 2ff6: 9d2080e7 jalr -1582(ra) # 49c4 <remove>
+ int pid = fork();
+ 2ffa: 00002097 auipc ra,0x2
+ 2ffe: 902080e7 jalr -1790(ra) # 48fc <fork>
+ if(pid < 0){
+ 3002: 04054d63 bltz a0,305c <forkforkfork+0x7e>
+ if(pid == 0){
+ 3006: c92d beqz a0,3078 <forkforkfork+0x9a>
+ sleep(20); // two seconds
+ 3008: 4551 li a0,20
+ 300a: 00002097 auipc ra,0x2
+ 300e: 988080e7 jalr -1656(ra) # 4992 <sleep>
+ close(open("stopforking", O_CREATE|O_RDWR));
+ 3012: 20200593 li a1,514
+ 3016: 00003517 auipc a0,0x3
+ 301a: 23250513 addi a0,a0,562 # 6248 <malloc+0x14c8>
+ 301e: 00002097 auipc ra,0x2
+ 3022: 932080e7 jalr -1742(ra) # 4950 <open>
+ 3026: 00002097 auipc ra,0x2
+ 302a: 90e080e7 jalr -1778(ra) # 4934 <close>
+ wait(0);
+ 302e: 4501 li a0,0
+ 3030: 00002097 auipc ra,0x2
+ 3034: 8de080e7 jalr -1826(ra) # 490e <wait>
+ sleep(10); // one second
+ 3038: 4529 li a0,10
+ 303a: 00002097 auipc ra,0x2
+ 303e: 958080e7 jalr -1704(ra) # 4992 <sleep>
+ remove("stopforking");
+ 3042: 00003517 auipc a0,0x3
+ 3046: 20650513 addi a0,a0,518 # 6248 <malloc+0x14c8>
+ 304a: 00002097 auipc ra,0x2
+ 304e: 97a080e7 jalr -1670(ra) # 49c4 <remove>
+}
+ 3052: 60e2 ld ra,24(sp)
+ 3054: 6442 ld s0,16(sp)
+ 3056: 64a2 ld s1,8(sp)
+ 3058: 6105 addi sp,sp,32
+ 305a: 8082 ret
+ printf("%s: fork failed", s);
+ 305c: 85a6 mv a1,s1
+ 305e: 00002517 auipc a0,0x2
+ 3062: 6d250513 addi a0,a0,1746 # 5730 <malloc+0x9b0>
+ 3066: 00002097 auipc ra,0x2
+ 306a: c62080e7 jalr -926(ra) # 4cc8 <printf>
+ exit(1);
+ 306e: 4505 li a0,1
+ 3070: 00002097 auipc ra,0x2
+ 3074: 894080e7 jalr -1900(ra) # 4904 <exit>
+ int fd = open("stopforking", 0);
+ 3078: 00003497 auipc s1,0x3
+ 307c: 1d048493 addi s1,s1,464 # 6248 <malloc+0x14c8>
+ 3080: 4581 li a1,0
+ 3082: 8526 mv a0,s1
+ 3084: 00002097 auipc ra,0x2
+ 3088: 8cc080e7 jalr -1844(ra) # 4950 <open>
+ if(fd >= 0){
+ 308c: 02055463 bgez a0,30b4 <forkforkfork+0xd6>
+ if(fork() < 0){
+ 3090: 00002097 auipc ra,0x2
+ 3094: 86c080e7 jalr -1940(ra) # 48fc <fork>
+ 3098: fe0554e3 bgez a0,3080 <forkforkfork+0xa2>
+ close(open("stopforking", O_CREATE|O_RDWR));
+ 309c: 20200593 li a1,514
+ 30a0: 8526 mv a0,s1
+ 30a2: 00002097 auipc ra,0x2
+ 30a6: 8ae080e7 jalr -1874(ra) # 4950 <open>
+ 30aa: 00002097 auipc ra,0x2
+ 30ae: 88a080e7 jalr -1910(ra) # 4934 <close>
+ 30b2: b7f9 j 3080 <forkforkfork+0xa2>
+ exit(0);
+ 30b4: 4501 li a0,0
+ 30b6: 00002097 auipc ra,0x2
+ 30ba: 84e080e7 jalr -1970(ra) # 4904 <exit>
+
+00000000000030be <preempt>:
+{
+ 30be: 7139 addi sp,sp,-64
+ 30c0: fc06 sd ra,56(sp)
+ 30c2: f822 sd s0,48(sp)
+ 30c4: f426 sd s1,40(sp)
+ 30c6: f04a sd s2,32(sp)
+ 30c8: ec4e sd s3,24(sp)
+ 30ca: e852 sd s4,16(sp)
+ 30cc: 0080 addi s0,sp,64
+ 30ce: 892a mv s2,a0
+ pid1 = fork();
+ 30d0: 00002097 auipc ra,0x2
+ 30d4: 82c080e7 jalr -2004(ra) # 48fc <fork>
+ if(pid1 < 0) {
+ 30d8: 00054563 bltz a0,30e2 <preempt+0x24>
+ 30dc: 84aa mv s1,a0
+ if(pid1 == 0)
+ 30de: ed19 bnez a0,30fc <preempt+0x3e>
+ for(;;)
+ 30e0: a001 j 30e0 <preempt+0x22>
+ printf("%s: fork failed");
+ 30e2: 00002517 auipc a0,0x2
+ 30e6: 64e50513 addi a0,a0,1614 # 5730 <malloc+0x9b0>
+ 30ea: 00002097 auipc ra,0x2
+ 30ee: bde080e7 jalr -1058(ra) # 4cc8 <printf>
+ exit(1);
+ 30f2: 4505 li a0,1
+ 30f4: 00002097 auipc ra,0x2
+ 30f8: 810080e7 jalr -2032(ra) # 4904 <exit>
+ pid2 = fork();
+ 30fc: 00002097 auipc ra,0x2
+ 3100: 800080e7 jalr -2048(ra) # 48fc <fork>
+ 3104: 89aa mv s3,a0
+ if(pid2 < 0) {
+ 3106: 00054463 bltz a0,310e <preempt+0x50>
+ if(pid2 == 0)
+ 310a: e105 bnez a0,312a <preempt+0x6c>
+ for(;;)
+ 310c: a001 j 310c <preempt+0x4e>
+ printf("%s: fork failed\n", s);
+ 310e: 85ca mv a1,s2
+ 3110: 00002517 auipc a0,0x2
+ 3114: 46050513 addi a0,a0,1120 # 5570 <malloc+0x7f0>
+ 3118: 00002097 auipc ra,0x2
+ 311c: bb0080e7 jalr -1104(ra) # 4cc8 <printf>
+ exit(1);
+ 3120: 4505 li a0,1
+ 3122: 00001097 auipc ra,0x1
+ 3126: 7e2080e7 jalr 2018(ra) # 4904 <exit>
+ pipe(pfds);
+ 312a: fc840513 addi a0,s0,-56
+ 312e: 00001097 auipc ra,0x1
+ 3132: 7e8080e7 jalr 2024(ra) # 4916 <pipe>
+ pid3 = fork();
+ 3136: 00001097 auipc ra,0x1
+ 313a: 7c6080e7 jalr 1990(ra) # 48fc <fork>
+ 313e: 8a2a mv s4,a0
+ if(pid3 < 0) {
+ 3140: 02054e63 bltz a0,317c <preempt+0xbe>
+ if(pid3 == 0){
+ 3144: e13d bnez a0,31aa <preempt+0xec>
+ close(pfds[0]);
+ 3146: fc842503 lw a0,-56(s0)
+ 314a: 00001097 auipc ra,0x1
+ 314e: 7ea080e7 jalr 2026(ra) # 4934 <close>
+ if(write(pfds[1], "x", 1) != 1)
+ 3152: 4605 li a2,1
+ 3154: 00002597 auipc a1,0x2
+ 3158: dfc58593 addi a1,a1,-516 # 4f50 <malloc+0x1d0>
+ 315c: fcc42503 lw a0,-52(s0)
+ 3160: 00001097 auipc ra,0x1
+ 3164: 7ca080e7 jalr 1994(ra) # 492a <write>
+ 3168: 4785 li a5,1
+ 316a: 02f51763 bne a0,a5,3198 <preempt+0xda>
+ close(pfds[1]);
+ 316e: fcc42503 lw a0,-52(s0)
+ 3172: 00001097 auipc ra,0x1
+ 3176: 7c2080e7 jalr 1986(ra) # 4934 <close>
+ for(;;)
+ 317a: a001 j 317a <preempt+0xbc>
+ printf("%s: fork failed\n", s);
+ 317c: 85ca mv a1,s2
+ 317e: 00002517 auipc a0,0x2
+ 3182: 3f250513 addi a0,a0,1010 # 5570 <malloc+0x7f0>
+ 3186: 00002097 auipc ra,0x2
+ 318a: b42080e7 jalr -1214(ra) # 4cc8 <printf>
+ exit(1);
+ 318e: 4505 li a0,1
+ 3190: 00001097 auipc ra,0x1
+ 3194: 774080e7 jalr 1908(ra) # 4904 <exit>
+ printf("%s: preempt write error");
+ 3198: 00003517 auipc a0,0x3
+ 319c: 0c050513 addi a0,a0,192 # 6258 <malloc+0x14d8>
+ 31a0: 00002097 auipc ra,0x2
+ 31a4: b28080e7 jalr -1240(ra) # 4cc8 <printf>
+ 31a8: b7d9 j 316e <preempt+0xb0>
+ close(pfds[1]);
+ 31aa: fcc42503 lw a0,-52(s0)
+ 31ae: 00001097 auipc ra,0x1
+ 31b2: 786080e7 jalr 1926(ra) # 4934 <close>
+ if(read(pfds[0], buf, sizeof(buf)) != 1){
+ 31b6: 6609 lui a2,0x2
+ 31b8: 80060613 addi a2,a2,-2048 # 1800 <forkfork+0x42>
+ 31bc: 00007597 auipc a1,0x7
+ 31c0: 6dc58593 addi a1,a1,1756 # a898 <buf>
+ 31c4: fc842503 lw a0,-56(s0)
+ 31c8: 00001097 auipc ra,0x1
+ 31cc: 758080e7 jalr 1880(ra) # 4920 <read>
+ 31d0: 4785 li a5,1
+ 31d2: 02f50263 beq a0,a5,31f6 <preempt+0x138>
+ printf("%s: preempt read error");
+ 31d6: 00003517 auipc a0,0x3
+ 31da: 09a50513 addi a0,a0,154 # 6270 <malloc+0x14f0>
+ 31de: 00002097 auipc ra,0x2
+ 31e2: aea080e7 jalr -1302(ra) # 4cc8 <printf>
+}
+ 31e6: 70e2 ld ra,56(sp)
+ 31e8: 7442 ld s0,48(sp)
+ 31ea: 74a2 ld s1,40(sp)
+ 31ec: 7902 ld s2,32(sp)
+ 31ee: 69e2 ld s3,24(sp)
+ 31f0: 6a42 ld s4,16(sp)
+ 31f2: 6121 addi sp,sp,64
+ 31f4: 8082 ret
+ close(pfds[0]);
+ 31f6: fc842503 lw a0,-56(s0)
+ 31fa: 00001097 auipc ra,0x1
+ 31fe: 73a080e7 jalr 1850(ra) # 4934 <close>
+ printf("kill... ");
+ 3202: 00003517 auipc a0,0x3
+ 3206: 08650513 addi a0,a0,134 # 6288 <malloc+0x1508>
+ 320a: 00002097 auipc ra,0x2
+ 320e: abe080e7 jalr -1346(ra) # 4cc8 <printf>
+ kill(pid1);
+ 3212: 8526 mv a0,s1
+ 3214: 00001097 auipc ra,0x1
+ 3218: 72a080e7 jalr 1834(ra) # 493e <kill>
+ kill(pid2);
+ 321c: 854e mv a0,s3
+ 321e: 00001097 auipc ra,0x1
+ 3222: 720080e7 jalr 1824(ra) # 493e <kill>
+ kill(pid3);
+ 3226: 8552 mv a0,s4
+ 3228: 00001097 auipc ra,0x1
+ 322c: 716080e7 jalr 1814(ra) # 493e <kill>
+ printf("wait... ");
+ 3230: 00003517 auipc a0,0x3
+ 3234: 06850513 addi a0,a0,104 # 6298 <malloc+0x1518>
+ 3238: 00002097 auipc ra,0x2
+ 323c: a90080e7 jalr -1392(ra) # 4cc8 <printf>
+ wait(0);
+ 3240: 4501 li a0,0
+ 3242: 00001097 auipc ra,0x1
+ 3246: 6cc080e7 jalr 1740(ra) # 490e <wait>
+ wait(0);
+ 324a: 4501 li a0,0
+ 324c: 00001097 auipc ra,0x1
+ 3250: 6c2080e7 jalr 1730(ra) # 490e <wait>
+ wait(0);
+ 3254: 4501 li a0,0
+ 3256: 00001097 auipc ra,0x1
+ 325a: 6b8080e7 jalr 1720(ra) # 490e <wait>
+ 325e: b761 j 31e6 <preempt+0x128>
+
+0000000000003260 <sbrkfail>:
+{
+ 3260: 7119 addi sp,sp,-128
+ 3262: fc86 sd ra,120(sp)
+ 3264: f8a2 sd s0,112(sp)
+ 3266: f4a6 sd s1,104(sp)
+ 3268: f0ca sd s2,96(sp)
+ 326a: ecce sd s3,88(sp)
+ 326c: e8d2 sd s4,80(sp)
+ 326e: e4d6 sd s5,72(sp)
+ 3270: e0da sd s6,64(sp)
+ 3272: 0100 addi s0,sp,128
+ 3274: 8b2a mv s6,a0
+ if(pipe(fds) != 0){
+ 3276: fb040513 addi a0,s0,-80
+ 327a: 00001097 auipc ra,0x1
+ 327e: 69c080e7 jalr 1692(ra) # 4916 <pipe>
+ 3282: e911 bnez a0,3296 <sbrkfail+0x36>
+ 3284: f8040493 addi s1,s0,-128
+ 3288: fa840993 addi s3,s0,-88
+ 328c: 8926 mv s2,s1
+ if(pids[i] != -1)
+ 328e: 5a7d li s4,-1
+ read(fds[0], &scratch, 1);
+ 3290: faf40a93 addi s5,s0,-81
+ 3294: a085 j 32f4 <sbrkfail+0x94>
+ printf("%s: pipe() failed\n", s);
+ 3296: 85da mv a1,s6
+ 3298: 00002517 auipc a0,0x2
+ 329c: 3e050513 addi a0,a0,992 # 5678 <malloc+0x8f8>
+ 32a0: 00002097 auipc ra,0x2
+ 32a4: a28080e7 jalr -1496(ra) # 4cc8 <printf>
+ exit(1);
+ 32a8: 4505 li a0,1
+ 32aa: 00001097 auipc ra,0x1
+ 32ae: 65a080e7 jalr 1626(ra) # 4904 <exit>
+ sbrk(BIG - (uint64)sbrk(0));
+ 32b2: 00001097 auipc ra,0x1
+ 32b6: 6d8080e7 jalr 1752(ra) # 498a <sbrk>
+ 32ba: 064007b7 lui a5,0x6400
+ 32be: 40a7853b subw a0,a5,a0
+ 32c2: 00001097 auipc ra,0x1
+ 32c6: 6c8080e7 jalr 1736(ra) # 498a <sbrk>
+ write(fds[1], "x", 1);
+ 32ca: 4605 li a2,1
+ 32cc: 00002597 auipc a1,0x2
+ 32d0: c8458593 addi a1,a1,-892 # 4f50 <malloc+0x1d0>
+ 32d4: fb442503 lw a0,-76(s0)
+ 32d8: 00001097 auipc ra,0x1
+ 32dc: 652080e7 jalr 1618(ra) # 492a <write>
+ for(;;) sleep(1000);
+ 32e0: 3e800513 li a0,1000
+ 32e4: 00001097 auipc ra,0x1
+ 32e8: 6ae080e7 jalr 1710(ra) # 4992 <sleep>
+ 32ec: bfd5 j 32e0 <sbrkfail+0x80>
+ for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
+ 32ee: 0911 addi s2,s2,4
+ 32f0: 03390463 beq s2,s3,3318 <sbrkfail+0xb8>
+ if((pids[i] = fork()) == 0){
+ 32f4: 00001097 auipc ra,0x1
+ 32f8: 608080e7 jalr 1544(ra) # 48fc <fork>
+ 32fc: 00a92023 sw a0,0(s2)
+ 3300: d94d beqz a0,32b2 <sbrkfail+0x52>
+ if(pids[i] != -1)
+ 3302: ff4506e3 beq a0,s4,32ee <sbrkfail+0x8e>
+ read(fds[0], &scratch, 1);
+ 3306: 4605 li a2,1
+ 3308: 85d6 mv a1,s5
+ 330a: fb042503 lw a0,-80(s0)
+ 330e: 00001097 auipc ra,0x1
+ 3312: 612080e7 jalr 1554(ra) # 4920 <read>
+ 3316: bfe1 j 32ee <sbrkfail+0x8e>
+ c = sbrk(PGSIZE);
+ 3318: 6505 lui a0,0x1
+ 331a: 00001097 auipc ra,0x1
+ 331e: 670080e7 jalr 1648(ra) # 498a <sbrk>
+ 3322: 8a2a mv s4,a0
+ if(pids[i] == -1)
+ 3324: 597d li s2,-1
+ 3326: a021 j 332e <sbrkfail+0xce>
+ for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
+ 3328: 0491 addi s1,s1,4
+ 332a: 01348f63 beq s1,s3,3348 <sbrkfail+0xe8>
+ if(pids[i] == -1)
+ 332e: 4088 lw a0,0(s1)
+ 3330: ff250ce3 beq a0,s2,3328 <sbrkfail+0xc8>
+ kill(pids[i]);
+ 3334: 00001097 auipc ra,0x1
+ 3338: 60a080e7 jalr 1546(ra) # 493e <kill>
+ wait(0);
+ 333c: 4501 li a0,0
+ 333e: 00001097 auipc ra,0x1
+ 3342: 5d0080e7 jalr 1488(ra) # 490e <wait>
+ 3346: b7cd j 3328 <sbrkfail+0xc8>
+ if(c == (char*)0xffffffffffffffffL){
+ 3348: 57fd li a5,-1
+ 334a: 04fa0263 beq s4,a5,338e <sbrkfail+0x12e>
+ pid = fork();
+ 334e: 00001097 auipc ra,0x1
+ 3352: 5ae080e7 jalr 1454(ra) # 48fc <fork>
+ 3356: 84aa mv s1,a0
+ if(pid < 0){
+ 3358: 04054963 bltz a0,33aa <sbrkfail+0x14a>
+ if(pid == 0){
+ 335c: c52d beqz a0,33c6 <sbrkfail+0x166>
+ wait(&xstatus);
+ 335e: fbc40513 addi a0,s0,-68
+ 3362: 00001097 auipc ra,0x1
+ 3366: 5ac080e7 jalr 1452(ra) # 490e <wait>
+ if(xstatus != -1 && xstatus != 2)
+ 336a: fbc42783 lw a5,-68(s0)
+ 336e: 577d li a4,-1
+ 3370: 00e78563 beq a5,a4,337a <sbrkfail+0x11a>
+ 3374: 4709 li a4,2
+ 3376: 08e79d63 bne a5,a4,3410 <sbrkfail+0x1b0>
+}
+ 337a: 70e6 ld ra,120(sp)
+ 337c: 7446 ld s0,112(sp)
+ 337e: 74a6 ld s1,104(sp)
+ 3380: 7906 ld s2,96(sp)
+ 3382: 69e6 ld s3,88(sp)
+ 3384: 6a46 ld s4,80(sp)
+ 3386: 6aa6 ld s5,72(sp)
+ 3388: 6b06 ld s6,64(sp)
+ 338a: 6109 addi sp,sp,128
+ 338c: 8082 ret
+ printf("%s: failed sbrk leaked memory\n", s);
+ 338e: 85da mv a1,s6
+ 3390: 00003517 auipc a0,0x3
+ 3394: f1850513 addi a0,a0,-232 # 62a8 <malloc+0x1528>
+ 3398: 00002097 auipc ra,0x2
+ 339c: 930080e7 jalr -1744(ra) # 4cc8 <printf>
+ exit(1);
+ 33a0: 4505 li a0,1
+ 33a2: 00001097 auipc ra,0x1
+ 33a6: 562080e7 jalr 1378(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 33aa: 85da mv a1,s6
+ 33ac: 00002517 auipc a0,0x2
+ 33b0: 1c450513 addi a0,a0,452 # 5570 <malloc+0x7f0>
+ 33b4: 00002097 auipc ra,0x2
+ 33b8: 914080e7 jalr -1772(ra) # 4cc8 <printf>
+ exit(1);
+ 33bc: 4505 li a0,1
+ 33be: 00001097 auipc ra,0x1
+ 33c2: 546080e7 jalr 1350(ra) # 4904 <exit>
+ a = sbrk(0);
+ 33c6: 4501 li a0,0
+ 33c8: 00001097 auipc ra,0x1
+ 33cc: 5c2080e7 jalr 1474(ra) # 498a <sbrk>
+ 33d0: 892a mv s2,a0
+ sbrk(10*BIG);
+ 33d2: 3e800537 lui a0,0x3e800
+ 33d6: 00001097 auipc ra,0x1
+ 33da: 5b4080e7 jalr 1460(ra) # 498a <sbrk>
+ for (i = 0; i < 10*BIG; i += PGSIZE) {
+ 33de: 87ca mv a5,s2
+ 33e0: 3e800737 lui a4,0x3e800
+ 33e4: 993a add s2,s2,a4
+ 33e6: 6705 lui a4,0x1
+ n += *(a+i);
+ 33e8: 0007c683 lbu a3,0(a5) # 6400000 <__BSS_END__+0x63f3f50>
+ 33ec: 9cb5 addw s1,s1,a3
+ for (i = 0; i < 10*BIG; i += PGSIZE) {
+ 33ee: 97ba add a5,a5,a4
+ 33f0: ff279ce3 bne a5,s2,33e8 <sbrkfail+0x188>
+ printf("%s: allocate a lot of memory succeeded %d\n", n);
+ 33f4: 85a6 mv a1,s1
+ 33f6: 00003517 auipc a0,0x3
+ 33fa: ed250513 addi a0,a0,-302 # 62c8 <malloc+0x1548>
+ 33fe: 00002097 auipc ra,0x2
+ 3402: 8ca080e7 jalr -1846(ra) # 4cc8 <printf>
+ exit(1);
+ 3406: 4505 li a0,1
+ 3408: 00001097 auipc ra,0x1
+ 340c: 4fc080e7 jalr 1276(ra) # 4904 <exit>
+ exit(1);
+ 3410: 4505 li a0,1
+ 3412: 00001097 auipc ra,0x1
+ 3416: 4f2080e7 jalr 1266(ra) # 4904 <exit>
+
+000000000000341a <reparent>:
+{
+ 341a: 7179 addi sp,sp,-48
+ 341c: f406 sd ra,40(sp)
+ 341e: f022 sd s0,32(sp)
+ 3420: ec26 sd s1,24(sp)
+ 3422: e84a sd s2,16(sp)
+ 3424: e44e sd s3,8(sp)
+ 3426: e052 sd s4,0(sp)
+ 3428: 1800 addi s0,sp,48
+ 342a: 89aa mv s3,a0
+ int master_pid = getpid();
+ 342c: 00001097 auipc ra,0x1
+ 3430: 554080e7 jalr 1364(ra) # 4980 <getpid>
+ 3434: 8a2a mv s4,a0
+ 3436: 0c800913 li s2,200
+ int pid = fork();
+ 343a: 00001097 auipc ra,0x1
+ 343e: 4c2080e7 jalr 1218(ra) # 48fc <fork>
+ 3442: 84aa mv s1,a0
+ if(pid < 0){
+ 3444: 02054263 bltz a0,3468 <reparent+0x4e>
+ if(pid){
+ 3448: cd21 beqz a0,34a0 <reparent+0x86>
+ if(wait(0) != pid){
+ 344a: 4501 li a0,0
+ 344c: 00001097 auipc ra,0x1
+ 3450: 4c2080e7 jalr 1218(ra) # 490e <wait>
+ 3454: 02951863 bne a0,s1,3484 <reparent+0x6a>
+ for(int i = 0; i < 200; i++){
+ 3458: 397d addiw s2,s2,-1
+ 345a: fe0910e3 bnez s2,343a <reparent+0x20>
+ exit(0);
+ 345e: 4501 li a0,0
+ 3460: 00001097 auipc ra,0x1
+ 3464: 4a4080e7 jalr 1188(ra) # 4904 <exit>
+ printf("%s: fork failed\n", s);
+ 3468: 85ce mv a1,s3
+ 346a: 00002517 auipc a0,0x2
+ 346e: 10650513 addi a0,a0,262 # 5570 <malloc+0x7f0>
+ 3472: 00002097 auipc ra,0x2
+ 3476: 856080e7 jalr -1962(ra) # 4cc8 <printf>
+ exit(1);
+ 347a: 4505 li a0,1
+ 347c: 00001097 auipc ra,0x1
+ 3480: 488080e7 jalr 1160(ra) # 4904 <exit>
+ printf("%s: wait wrong pid\n", s);
+ 3484: 85ce mv a1,s3
+ 3486: 00002517 auipc a0,0x2
+ 348a: 27250513 addi a0,a0,626 # 56f8 <malloc+0x978>
+ 348e: 00002097 auipc ra,0x2
+ 3492: 83a080e7 jalr -1990(ra) # 4cc8 <printf>
+ exit(1);
+ 3496: 4505 li a0,1
+ 3498: 00001097 auipc ra,0x1
+ 349c: 46c080e7 jalr 1132(ra) # 4904 <exit>
+ int pid2 = fork();
+ 34a0: 00001097 auipc ra,0x1
+ 34a4: 45c080e7 jalr 1116(ra) # 48fc <fork>
+ if(pid2 < 0){
+ 34a8: 00054763 bltz a0,34b6 <reparent+0x9c>
+ exit(0);
+ 34ac: 4501 li a0,0
+ 34ae: 00001097 auipc ra,0x1
+ 34b2: 456080e7 jalr 1110(ra) # 4904 <exit>
+ kill(master_pid);
+ 34b6: 8552 mv a0,s4
+ 34b8: 00001097 auipc ra,0x1
+ 34bc: 486080e7 jalr 1158(ra) # 493e <kill>
+ exit(1);
+ 34c0: 4505 li a0,1
+ 34c2: 00001097 auipc ra,0x1
+ 34c6: 442080e7 jalr 1090(ra) # 4904 <exit>
+
+00000000000034ca <mem>:
+{
+ 34ca: 7139 addi sp,sp,-64
+ 34cc: fc06 sd ra,56(sp)
+ 34ce: f822 sd s0,48(sp)
+ 34d0: f426 sd s1,40(sp)
+ 34d2: f04a sd s2,32(sp)
+ 34d4: ec4e sd s3,24(sp)
+ 34d6: 0080 addi s0,sp,64
+ 34d8: 89aa mv s3,a0
+ if((pid = fork()) == 0){
+ 34da: 00001097 auipc ra,0x1
+ 34de: 422080e7 jalr 1058(ra) # 48fc <fork>
+ m1 = 0;
+ 34e2: 4481 li s1,0
+ while((m2 = malloc(10001)) != 0){
+ 34e4: 6909 lui s2,0x2
+ 34e6: 71190913 addi s2,s2,1809 # 2711 <subdir+0x1bb>
+ if((pid = fork()) == 0){
+ 34ea: c115 beqz a0,350e <mem+0x44>
+ wait(&xstatus);
+ 34ec: fcc40513 addi a0,s0,-52
+ 34f0: 00001097 auipc ra,0x1
+ 34f4: 41e080e7 jalr 1054(ra) # 490e <wait>
+ if(xstatus == -1){
+ 34f8: fcc42503 lw a0,-52(s0)
+ 34fc: 57fd li a5,-1
+ 34fe: 06f50363 beq a0,a5,3564 <mem+0x9a>
+ exit(xstatus);
+ 3502: 00001097 auipc ra,0x1
+ 3506: 402080e7 jalr 1026(ra) # 4904 <exit>
+ *(char**)m2 = m1;
+ 350a: e104 sd s1,0(a0)
+ m1 = m2;
+ 350c: 84aa mv s1,a0
+ while((m2 = malloc(10001)) != 0){
+ 350e: 854a mv a0,s2
+ 3510: 00002097 auipc ra,0x2
+ 3514: 870080e7 jalr -1936(ra) # 4d80 <malloc>
+ 3518: f96d bnez a0,350a <mem+0x40>
+ while(m1){
+ 351a: c881 beqz s1,352a <mem+0x60>
+ m2 = *(char**)m1;
+ 351c: 8526 mv a0,s1
+ 351e: 6084 ld s1,0(s1)
+ free(m1);
+ 3520: 00001097 auipc ra,0x1
+ 3524: 7de080e7 jalr 2014(ra) # 4cfe <free>
+ while(m1){
+ 3528: f8f5 bnez s1,351c <mem+0x52>
+ m1 = malloc(1024*20);
+ 352a: 6515 lui a0,0x5
+ 352c: 00002097 auipc ra,0x2
+ 3530: 854080e7 jalr -1964(ra) # 4d80 <malloc>
+ if(m1 == 0){
+ 3534: c911 beqz a0,3548 <mem+0x7e>
+ free(m1);
+ 3536: 00001097 auipc ra,0x1
+ 353a: 7c8080e7 jalr 1992(ra) # 4cfe <free>
+ exit(0);
+ 353e: 4501 li a0,0
+ 3540: 00001097 auipc ra,0x1
+ 3544: 3c4080e7 jalr 964(ra) # 4904 <exit>
+ printf("couldn't allocate mem?!!\n", s);
+ 3548: 85ce mv a1,s3
+ 354a: 00003517 auipc a0,0x3
+ 354e: dae50513 addi a0,a0,-594 # 62f8 <malloc+0x1578>
+ 3552: 00001097 auipc ra,0x1
+ 3556: 776080e7 jalr 1910(ra) # 4cc8 <printf>
+ exit(1);
+ 355a: 4505 li a0,1
+ 355c: 00001097 auipc ra,0x1
+ 3560: 3a8080e7 jalr 936(ra) # 4904 <exit>
+ exit(0);
+ 3564: 4501 li a0,0
+ 3566: 00001097 auipc ra,0x1
+ 356a: 39e080e7 jalr 926(ra) # 4904 <exit>
+
+000000000000356e <sharedfd>:
+{
+ 356e: 7159 addi sp,sp,-112
+ 3570: f486 sd ra,104(sp)
+ 3572: f0a2 sd s0,96(sp)
+ 3574: eca6 sd s1,88(sp)
+ 3576: e8ca sd s2,80(sp)
+ 3578: e4ce sd s3,72(sp)
+ 357a: e0d2 sd s4,64(sp)
+ 357c: fc56 sd s5,56(sp)
+ 357e: f85a sd s6,48(sp)
+ 3580: f45e sd s7,40(sp)
+ 3582: f062 sd s8,32(sp)
+ 3584: 1880 addi s0,sp,112
+ 3586: 8aaa mv s5,a0
+ remove("sharedfd");
+ 3588: 00003517 auipc a0,0x3
+ 358c: d9050513 addi a0,a0,-624 # 6318 <malloc+0x1598>
+ 3590: 00001097 auipc ra,0x1
+ 3594: 434080e7 jalr 1076(ra) # 49c4 <remove>
+ fd = open("sharedfd", O_CREATE|O_RDWR);
+ 3598: 20200593 li a1,514
+ 359c: 00003517 auipc a0,0x3
+ 35a0: d7c50513 addi a0,a0,-644 # 6318 <malloc+0x1598>
+ 35a4: 00001097 auipc ra,0x1
+ 35a8: 3ac080e7 jalr 940(ra) # 4950 <open>
+ if(fd < 0){
+ 35ac: 04054b63 bltz a0,3602 <sharedfd+0x94>
+ 35b0: 892a mv s2,a0
+ pid = fork();
+ 35b2: 00001097 auipc ra,0x1
+ 35b6: 34a080e7 jalr 842(ra) # 48fc <fork>
+ 35ba: 8a2a mv s4,a0
+ memset(buf, pid==0?'c':'p', sizeof(buf));
+ 35bc: 06300593 li a1,99
+ 35c0: c119 beqz a0,35c6 <sharedfd+0x58>
+ 35c2: 07000593 li a1,112
+ 35c6: 4629 li a2,10
+ 35c8: fa040513 addi a0,s0,-96
+ 35cc: 00001097 auipc ra,0x1
+ 35d0: 120080e7 jalr 288(ra) # 46ec <memset>
+ 35d4: 3e800493 li s1,1000
+ if(write(fd, buf, sizeof(buf)) != sizeof(buf)){
+ 35d8: fa040993 addi s3,s0,-96
+ 35dc: 4629 li a2,10
+ 35de: 85ce mv a1,s3
+ 35e0: 854a mv a0,s2
+ 35e2: 00001097 auipc ra,0x1
+ 35e6: 348080e7 jalr 840(ra) # 492a <write>
+ 35ea: 47a9 li a5,10
+ 35ec: 02f51963 bne a0,a5,361e <sharedfd+0xb0>
+ for(i = 0; i < N; i++){
+ 35f0: 34fd addiw s1,s1,-1
+ 35f2: f4ed bnez s1,35dc <sharedfd+0x6e>
+ if(pid == 0) {
+ 35f4: 040a1363 bnez s4,363a <sharedfd+0xcc>
+ exit(0);
+ 35f8: 4501 li a0,0
+ 35fa: 00001097 auipc ra,0x1
+ 35fe: 30a080e7 jalr 778(ra) # 4904 <exit>
+ printf("%s: cannot open sharedfd for writing", s);
+ 3602: 85d6 mv a1,s5
+ 3604: 00003517 auipc a0,0x3
+ 3608: d2450513 addi a0,a0,-732 # 6328 <malloc+0x15a8>
+ 360c: 00001097 auipc ra,0x1
+ 3610: 6bc080e7 jalr 1724(ra) # 4cc8 <printf>
+ exit(1);
+ 3614: 4505 li a0,1
+ 3616: 00001097 auipc ra,0x1
+ 361a: 2ee080e7 jalr 750(ra) # 4904 <exit>
+ printf("%s: write sharedfd failed\n", s);
+ 361e: 85d6 mv a1,s5
+ 3620: 00003517 auipc a0,0x3
+ 3624: d3050513 addi a0,a0,-720 # 6350 <malloc+0x15d0>
+ 3628: 00001097 auipc ra,0x1
+ 362c: 6a0080e7 jalr 1696(ra) # 4cc8 <printf>
+ exit(1);
+ 3630: 4505 li a0,1
+ 3632: 00001097 auipc ra,0x1
+ 3636: 2d2080e7 jalr 722(ra) # 4904 <exit>
+ wait(&xstatus);
+ 363a: f9c40513 addi a0,s0,-100
+ 363e: 00001097 auipc ra,0x1
+ 3642: 2d0080e7 jalr 720(ra) # 490e <wait>
+ if(xstatus != 0)
+ 3646: f9c42983 lw s3,-100(s0)
+ 364a: 00098763 beqz s3,3658 <sharedfd+0xea>
+ exit(xstatus);
+ 364e: 854e mv a0,s3
+ 3650: 00001097 auipc ra,0x1
+ 3654: 2b4080e7 jalr 692(ra) # 4904 <exit>
+ close(fd);
+ 3658: 854a mv a0,s2
+ 365a: 00001097 auipc ra,0x1
+ 365e: 2da080e7 jalr 730(ra) # 4934 <close>
+ fd = open("sharedfd", 0);
+ 3662: 4581 li a1,0
+ 3664: 00003517 auipc a0,0x3
+ 3668: cb450513 addi a0,a0,-844 # 6318 <malloc+0x1598>
+ 366c: 00001097 auipc ra,0x1
+ 3670: 2e4080e7 jalr 740(ra) # 4950 <open>
+ 3674: 8baa mv s7,a0
+ nc = np = 0;
+ 3676: 8a4e mv s4,s3
+ if(fd < 0){
+ 3678: 02054663 bltz a0,36a4 <sharedfd+0x136>
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 367c: fa040c13 addi s8,s0,-96
+ 3680: faa40913 addi s2,s0,-86
+ if(buf[i] == 'c')
+ 3684: 06300493 li s1,99
+ if(buf[i] == 'p')
+ 3688: 07000b13 li s6,112
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 368c: 4629 li a2,10
+ 368e: 85e2 mv a1,s8
+ 3690: 855e mv a0,s7
+ 3692: 00001097 auipc ra,0x1
+ 3696: 28e080e7 jalr 654(ra) # 4920 <read>
+ 369a: 02a05f63 blez a0,36d8 <sharedfd+0x16a>
+ 369e: fa040793 addi a5,s0,-96
+ 36a2: a01d j 36c8 <sharedfd+0x15a>
+ printf("%s: cannot open sharedfd for reading\n", s);
+ 36a4: 85d6 mv a1,s5
+ 36a6: 00003517 auipc a0,0x3
+ 36aa: cca50513 addi a0,a0,-822 # 6370 <malloc+0x15f0>
+ 36ae: 00001097 auipc ra,0x1
+ 36b2: 61a080e7 jalr 1562(ra) # 4cc8 <printf>
+ exit(1);
+ 36b6: 4505 li a0,1
+ 36b8: 00001097 auipc ra,0x1
+ 36bc: 24c080e7 jalr 588(ra) # 4904 <exit>
+ nc++;
+ 36c0: 2985 addiw s3,s3,1
+ for(i = 0; i < sizeof(buf); i++){
+ 36c2: 0785 addi a5,a5,1
+ 36c4: fd2784e3 beq a5,s2,368c <sharedfd+0x11e>
+ if(buf[i] == 'c')
+ 36c8: 0007c703 lbu a4,0(a5)
+ 36cc: fe970ae3 beq a4,s1,36c0 <sharedfd+0x152>
+ if(buf[i] == 'p')
+ 36d0: ff6719e3 bne a4,s6,36c2 <sharedfd+0x154>
+ np++;
+ 36d4: 2a05 addiw s4,s4,1
+ 36d6: b7f5 j 36c2 <sharedfd+0x154>
+ close(fd);
+ 36d8: 855e mv a0,s7
+ 36da: 00001097 auipc ra,0x1
+ 36de: 25a080e7 jalr 602(ra) # 4934 <close>
+ remove("sharedfd");
+ 36e2: 00003517 auipc a0,0x3
+ 36e6: c3650513 addi a0,a0,-970 # 6318 <malloc+0x1598>
+ 36ea: 00001097 auipc ra,0x1
+ 36ee: 2da080e7 jalr 730(ra) # 49c4 <remove>
+ if(nc == N*SZ && np == N*SZ){
+ 36f2: 6789 lui a5,0x2
+ 36f4: 71078793 addi a5,a5,1808 # 2710 <subdir+0x1ba>
+ 36f8: 00f99763 bne s3,a5,3706 <sharedfd+0x198>
+ 36fc: 6789 lui a5,0x2
+ 36fe: 71078793 addi a5,a5,1808 # 2710 <subdir+0x1ba>
+ 3702: 02fa0063 beq s4,a5,3722 <sharedfd+0x1b4>
+ printf("%s: nc/np test fails\n", s);
+ 3706: 85d6 mv a1,s5
+ 3708: 00003517 auipc a0,0x3
+ 370c: c9050513 addi a0,a0,-880 # 6398 <malloc+0x1618>
+ 3710: 00001097 auipc ra,0x1
+ 3714: 5b8080e7 jalr 1464(ra) # 4cc8 <printf>
+ exit(1);
+ 3718: 4505 li a0,1
+ 371a: 00001097 auipc ra,0x1
+ 371e: 1ea080e7 jalr 490(ra) # 4904 <exit>
+ exit(0);
+ 3722: 4501 li a0,0
+ 3724: 00001097 auipc ra,0x1
+ 3728: 1e0080e7 jalr 480(ra) # 4904 <exit>
+
+000000000000372c <fourfiles>:
+{
+ 372c: 7171 addi sp,sp,-176
+ 372e: f506 sd ra,168(sp)
+ 3730: f122 sd s0,160(sp)
+ 3732: ed26 sd s1,152(sp)
+ 3734: e94a sd s2,144(sp)
+ 3736: e54e sd s3,136(sp)
+ 3738: e152 sd s4,128(sp)
+ 373a: fcd6 sd s5,120(sp)
+ 373c: f8da sd s6,112(sp)
+ 373e: f4de sd s7,104(sp)
+ 3740: f0e2 sd s8,96(sp)
+ 3742: ece6 sd s9,88(sp)
+ 3744: e8ea sd s10,80(sp)
+ 3746: e4ee sd s11,72(sp)
+ 3748: 1900 addi s0,sp,176
+ 374a: f4a43c23 sd a0,-168(s0)
+ char *names[] = { "f0", "f1", "f2", "f3" };
+ 374e: 00003797 auipc a5,0x3
+ 3752: c6278793 addi a5,a5,-926 # 63b0 <malloc+0x1630>
+ 3756: f6f43823 sd a5,-144(s0)
+ 375a: 00003797 auipc a5,0x3
+ 375e: c5e78793 addi a5,a5,-930 # 63b8 <malloc+0x1638>
+ 3762: f6f43c23 sd a5,-136(s0)
+ 3766: 00003797 auipc a5,0x3
+ 376a: c5a78793 addi a5,a5,-934 # 63c0 <malloc+0x1640>
+ 376e: f8f43023 sd a5,-128(s0)
+ 3772: 00003797 auipc a5,0x3
+ 3776: c5678793 addi a5,a5,-938 # 63c8 <malloc+0x1648>
+ 377a: f8f43423 sd a5,-120(s0)
+ for(pi = 0; pi < NCHILD; pi++){
+ 377e: f7040c93 addi s9,s0,-144
+ char *names[] = { "f0", "f1", "f2", "f3" };
+ 3782: 8966 mv s2,s9
+ for(pi = 0; pi < NCHILD; pi++){
+ 3784: 4481 li s1,0
+ 3786: 4a11 li s4,4
+ fname = names[pi];
+ 3788: 00093983 ld s3,0(s2)
+ remove(fname);
+ 378c: 854e mv a0,s3
+ 378e: 00001097 auipc ra,0x1
+ 3792: 236080e7 jalr 566(ra) # 49c4 <remove>
+ pid = fork();
+ 3796: 00001097 auipc ra,0x1
+ 379a: 166080e7 jalr 358(ra) # 48fc <fork>
+ if(pid < 0){
+ 379e: 04054a63 bltz a0,37f2 <fourfiles+0xc6>
+ if(pid == 0){
+ 37a2: c53d beqz a0,3810 <fourfiles+0xe4>
+ for(pi = 0; pi < NCHILD; pi++){
+ 37a4: 2485 addiw s1,s1,1
+ 37a6: 0921 addi s2,s2,8
+ 37a8: ff4490e3 bne s1,s4,3788 <fourfiles+0x5c>
+ 37ac: 4491 li s1,4
+ wait(&xstatus);
+ 37ae: f6c40913 addi s2,s0,-148
+ 37b2: 854a mv a0,s2
+ 37b4: 00001097 auipc ra,0x1
+ 37b8: 15a080e7 jalr 346(ra) # 490e <wait>
+ if(xstatus != 0)
+ 37bc: f6c42b83 lw s7,-148(s0)
+ 37c0: 0e0b9363 bnez s7,38a6 <fourfiles+0x17a>
+ for(pi = 0; pi < NCHILD; pi++){
+ 37c4: 34fd addiw s1,s1,-1
+ 37c6: f4f5 bnez s1,37b2 <fourfiles+0x86>
+ 37c8: 03000c13 li s8,48
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 37cc: 6a09 lui s4,0x2
+ 37ce: 800a0a13 addi s4,s4,-2048 # 1800 <forkfork+0x42>
+ 37d2: 00007a97 auipc s5,0x7
+ 37d6: 0c6a8a93 addi s5,s5,198 # a898 <buf>
+ 37da: 00007b17 auipc s6,0x7
+ 37de: 0bfb0b13 addi s6,s6,191 # a899 <buf+0x1>
+ if(total != N*SZ){
+ 37e2: 6785 lui a5,0x1
+ 37e4: 77078793 addi a5,a5,1904 # 1770 <twochildren+0x4c>
+ 37e8: f4f43823 sd a5,-176(s0)
+ for(i = 0; i < NCHILD; i++){
+ 37ec: 03400d93 li s11,52
+ 37f0: aa2d j 392a <fourfiles+0x1fe>
+ printf("fork failed\n", s);
+ 37f2: f5843583 ld a1,-168(s0)
+ 37f6: 00002517 auipc a0,0x2
+ 37fa: 0fa50513 addi a0,a0,250 # 58f0 <malloc+0xb70>
+ 37fe: 00001097 auipc ra,0x1
+ 3802: 4ca080e7 jalr 1226(ra) # 4cc8 <printf>
+ exit(1);
+ 3806: 4505 li a0,1
+ 3808: 00001097 auipc ra,0x1
+ 380c: 0fc080e7 jalr 252(ra) # 4904 <exit>
+ fd = open(fname, O_CREATE | O_RDWR);
+ 3810: 20200593 li a1,514
+ 3814: 854e mv a0,s3
+ 3816: 00001097 auipc ra,0x1
+ 381a: 13a080e7 jalr 314(ra) # 4950 <open>
+ 381e: 892a mv s2,a0
+ if(fd < 0){
+ 3820: 04054763 bltz a0,386e <fourfiles+0x142>
+ memset(buf, '0'+pi, SZ);
+ 3824: 1f400613 li a2,500
+ 3828: 0304859b addiw a1,s1,48
+ 382c: 00007517 auipc a0,0x7
+ 3830: 06c50513 addi a0,a0,108 # a898 <buf>
+ 3834: 00001097 auipc ra,0x1
+ 3838: eb8080e7 jalr -328(ra) # 46ec <memset>
+ 383c: 44b1 li s1,12
+ if((n = write(fd, buf, SZ)) != SZ){
+ 383e: 00007997 auipc s3,0x7
+ 3842: 05a98993 addi s3,s3,90 # a898 <buf>
+ 3846: 1f400613 li a2,500
+ 384a: 85ce mv a1,s3
+ 384c: 854a mv a0,s2
+ 384e: 00001097 auipc ra,0x1
+ 3852: 0dc080e7 jalr 220(ra) # 492a <write>
+ 3856: 85aa mv a1,a0
+ 3858: 1f400793 li a5,500
+ 385c: 02f51863 bne a0,a5,388c <fourfiles+0x160>
+ for(i = 0; i < N; i++){
+ 3860: 34fd addiw s1,s1,-1
+ 3862: f0f5 bnez s1,3846 <fourfiles+0x11a>
+ exit(0);
+ 3864: 4501 li a0,0
+ 3866: 00001097 auipc ra,0x1
+ 386a: 09e080e7 jalr 158(ra) # 4904 <exit>
+ printf("create failed\n", s);
+ 386e: f5843583 ld a1,-168(s0)
+ 3872: 00003517 auipc a0,0x3
+ 3876: b5e50513 addi a0,a0,-1186 # 63d0 <malloc+0x1650>
+ 387a: 00001097 auipc ra,0x1
+ 387e: 44e080e7 jalr 1102(ra) # 4cc8 <printf>
+ exit(1);
+ 3882: 4505 li a0,1
+ 3884: 00001097 auipc ra,0x1
+ 3888: 080080e7 jalr 128(ra) # 4904 <exit>
+ printf("write failed %d\n", n);
+ 388c: 00003517 auipc a0,0x3
+ 3890: b5450513 addi a0,a0,-1196 # 63e0 <malloc+0x1660>
+ 3894: 00001097 auipc ra,0x1
+ 3898: 434080e7 jalr 1076(ra) # 4cc8 <printf>
+ exit(1);
+ 389c: 4505 li a0,1
+ 389e: 00001097 auipc ra,0x1
+ 38a2: 066080e7 jalr 102(ra) # 4904 <exit>
+ exit(xstatus);
+ 38a6: 855e mv a0,s7
+ 38a8: 00001097 auipc ra,0x1
+ 38ac: 05c080e7 jalr 92(ra) # 4904 <exit>
+ printf("wrong char\n", s);
+ 38b0: f5843583 ld a1,-168(s0)
+ 38b4: 00003517 auipc a0,0x3
+ 38b8: b4450513 addi a0,a0,-1212 # 63f8 <malloc+0x1678>
+ 38bc: 00001097 auipc ra,0x1
+ 38c0: 40c080e7 jalr 1036(ra) # 4cc8 <printf>
+ exit(1);
+ 38c4: 4505 li a0,1
+ 38c6: 00001097 auipc ra,0x1
+ 38ca: 03e080e7 jalr 62(ra) # 4904 <exit>
+ total += n;
+ 38ce: 00a9093b addw s2,s2,a0
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 38d2: 8652 mv a2,s4
+ 38d4: 85d6 mv a1,s5
+ 38d6: 854e mv a0,s3
+ 38d8: 00001097 auipc ra,0x1
+ 38dc: 048080e7 jalr 72(ra) # 4920 <read>
+ 38e0: 02a05363 blez a0,3906 <fourfiles+0x1da>
+ 38e4: 00007797 auipc a5,0x7
+ 38e8: fb478793 addi a5,a5,-76 # a898 <buf>
+ 38ec: fff5069b addiw a3,a0,-1
+ 38f0: 1682 slli a3,a3,0x20
+ 38f2: 9281 srli a3,a3,0x20
+ 38f4: 96da add a3,a3,s6
+ if(buf[j] != '0'+i){
+ 38f6: 0007c703 lbu a4,0(a5)
+ 38fa: fa971be3 bne a4,s1,38b0 <fourfiles+0x184>
+ for(j = 0; j < n; j++){
+ 38fe: 0785 addi a5,a5,1
+ 3900: fed79be3 bne a5,a3,38f6 <fourfiles+0x1ca>
+ 3904: b7e9 j 38ce <fourfiles+0x1a2>
+ close(fd);
+ 3906: 854e mv a0,s3
+ 3908: 00001097 auipc ra,0x1
+ 390c: 02c080e7 jalr 44(ra) # 4934 <close>
+ if(total != N*SZ){
+ 3910: f5043783 ld a5,-176(s0)
+ 3914: 02f91863 bne s2,a5,3944 <fourfiles+0x218>
+ remove(fname);
+ 3918: 856a mv a0,s10
+ 391a: 00001097 auipc ra,0x1
+ 391e: 0aa080e7 jalr 170(ra) # 49c4 <remove>
+ for(i = 0; i < NCHILD; i++){
+ 3922: 0ca1 addi s9,s9,8
+ 3924: 2c05 addiw s8,s8,1
+ 3926: 03bc0d63 beq s8,s11,3960 <fourfiles+0x234>
+ fname = names[i];
+ 392a: 000cbd03 ld s10,0(s9)
+ fd = open(fname, 0);
+ 392e: 4581 li a1,0
+ 3930: 856a mv a0,s10
+ 3932: 00001097 auipc ra,0x1
+ 3936: 01e080e7 jalr 30(ra) # 4950 <open>
+ 393a: 89aa mv s3,a0
+ total = 0;
+ 393c: 895e mv s2,s7
+ if(buf[j] != '0'+i){
+ 393e: 000c049b sext.w s1,s8
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 3942: bf41 j 38d2 <fourfiles+0x1a6>
+ printf("wrong length %d\n", total);
+ 3944: 85ca mv a1,s2
+ 3946: 00003517 auipc a0,0x3
+ 394a: ac250513 addi a0,a0,-1342 # 6408 <malloc+0x1688>
+ 394e: 00001097 auipc ra,0x1
+ 3952: 37a080e7 jalr 890(ra) # 4cc8 <printf>
+ exit(1);
+ 3956: 4505 li a0,1
+ 3958: 00001097 auipc ra,0x1
+ 395c: fac080e7 jalr -84(ra) # 4904 <exit>
+}
+ 3960: 70aa ld ra,168(sp)
+ 3962: 740a ld s0,160(sp)
+ 3964: 64ea ld s1,152(sp)
+ 3966: 694a ld s2,144(sp)
+ 3968: 69aa ld s3,136(sp)
+ 396a: 6a0a ld s4,128(sp)
+ 396c: 7ae6 ld s5,120(sp)
+ 396e: 7b46 ld s6,112(sp)
+ 3970: 7ba6 ld s7,104(sp)
+ 3972: 7c06 ld s8,96(sp)
+ 3974: 6ce6 ld s9,88(sp)
+ 3976: 6d46 ld s10,80(sp)
+ 3978: 6da6 ld s11,72(sp)
+ 397a: 614d addi sp,sp,176
+ 397c: 8082 ret
+
+000000000000397e <bigfile>:
+{
+ 397e: 7139 addi sp,sp,-64
+ 3980: fc06 sd ra,56(sp)
+ 3982: f822 sd s0,48(sp)
+ 3984: f426 sd s1,40(sp)
+ 3986: f04a sd s2,32(sp)
+ 3988: ec4e sd s3,24(sp)
+ 398a: e852 sd s4,16(sp)
+ 398c: e456 sd s5,8(sp)
+ 398e: 0080 addi s0,sp,64
+ 3990: 8aaa mv s5,a0
+ remove("bigfile.dat");
+ 3992: 00003517 auipc a0,0x3
+ 3996: a8e50513 addi a0,a0,-1394 # 6420 <malloc+0x16a0>
+ 399a: 00001097 auipc ra,0x1
+ 399e: 02a080e7 jalr 42(ra) # 49c4 <remove>
+ fd = open("bigfile.dat", O_CREATE | O_RDWR);
+ 39a2: 20200593 li a1,514
+ 39a6: 00003517 auipc a0,0x3
+ 39aa: a7a50513 addi a0,a0,-1414 # 6420 <malloc+0x16a0>
+ 39ae: 00001097 auipc ra,0x1
+ 39b2: fa2080e7 jalr -94(ra) # 4950 <open>
+ 39b6: 89aa mv s3,a0
+ for(i = 0; i < N; i++){
+ 39b8: 4481 li s1,0
+ memset(buf, i, SZ);
+ 39ba: 00007917 auipc s2,0x7
+ 39be: ede90913 addi s2,s2,-290 # a898 <buf>
+ for(i = 0; i < N; i++){
+ 39c2: 4a51 li s4,20
+ if(fd < 0){
+ 39c4: 0a054063 bltz a0,3a64 <bigfile+0xe6>
+ memset(buf, i, SZ);
+ 39c8: 25800613 li a2,600
+ 39cc: 85a6 mv a1,s1
+ 39ce: 854a mv a0,s2
+ 39d0: 00001097 auipc ra,0x1
+ 39d4: d1c080e7 jalr -740(ra) # 46ec <memset>
+ if(write(fd, buf, SZ) != SZ){
+ 39d8: 25800613 li a2,600
+ 39dc: 85ca mv a1,s2
+ 39de: 854e mv a0,s3
+ 39e0: 00001097 auipc ra,0x1
+ 39e4: f4a080e7 jalr -182(ra) # 492a <write>
+ 39e8: 25800793 li a5,600
+ 39ec: 08f51a63 bne a0,a5,3a80 <bigfile+0x102>
+ for(i = 0; i < N; i++){
+ 39f0: 2485 addiw s1,s1,1
+ 39f2: fd449be3 bne s1,s4,39c8 <bigfile+0x4a>
+ close(fd);
+ 39f6: 854e mv a0,s3
+ 39f8: 00001097 auipc ra,0x1
+ 39fc: f3c080e7 jalr -196(ra) # 4934 <close>
+ fd = open("bigfile.dat", 0);
+ 3a00: 4581 li a1,0
+ 3a02: 00003517 auipc a0,0x3
+ 3a06: a1e50513 addi a0,a0,-1506 # 6420 <malloc+0x16a0>
+ 3a0a: 00001097 auipc ra,0x1
+ 3a0e: f46080e7 jalr -186(ra) # 4950 <open>
+ 3a12: 8a2a mv s4,a0
+ total = 0;
+ 3a14: 4981 li s3,0
+ for(i = 0; ; i++){
+ 3a16: 4481 li s1,0
+ cc = read(fd, buf, SZ/2);
+ 3a18: 00007917 auipc s2,0x7
+ 3a1c: e8090913 addi s2,s2,-384 # a898 <buf>
+ if(fd < 0){
+ 3a20: 06054e63 bltz a0,3a9c <bigfile+0x11e>
+ cc = read(fd, buf, SZ/2);
+ 3a24: 12c00613 li a2,300
+ 3a28: 85ca mv a1,s2
+ 3a2a: 8552 mv a0,s4
+ 3a2c: 00001097 auipc ra,0x1
+ 3a30: ef4080e7 jalr -268(ra) # 4920 <read>
+ if(cc < 0){
+ 3a34: 08054263 bltz a0,3ab8 <bigfile+0x13a>
+ if(cc == 0)
+ 3a38: c971 beqz a0,3b0c <bigfile+0x18e>
+ if(cc != SZ/2){
+ 3a3a: 12c00793 li a5,300
+ 3a3e: 08f51b63 bne a0,a5,3ad4 <bigfile+0x156>
+ if(buf[0] != i/2 || buf[SZ/2-1] != i/2){
+ 3a42: 01f4d79b srliw a5,s1,0x1f
+ 3a46: 9fa5 addw a5,a5,s1
+ 3a48: 4017d79b sraiw a5,a5,0x1
+ 3a4c: 00094703 lbu a4,0(s2)
+ 3a50: 0af71063 bne a4,a5,3af0 <bigfile+0x172>
+ 3a54: 12b94703 lbu a4,299(s2)
+ 3a58: 08f71c63 bne a4,a5,3af0 <bigfile+0x172>
+ total += cc;
+ 3a5c: 12c9899b addiw s3,s3,300
+ for(i = 0; ; i++){
+ 3a60: 2485 addiw s1,s1,1
+ cc = read(fd, buf, SZ/2);
+ 3a62: b7c9 j 3a24 <bigfile+0xa6>
+ printf("%s: cannot create bigfile", s);
+ 3a64: 85d6 mv a1,s5
+ 3a66: 00003517 auipc a0,0x3
+ 3a6a: 9ca50513 addi a0,a0,-1590 # 6430 <malloc+0x16b0>
+ 3a6e: 00001097 auipc ra,0x1
+ 3a72: 25a080e7 jalr 602(ra) # 4cc8 <printf>
+ exit(1);
+ 3a76: 4505 li a0,1
+ 3a78: 00001097 auipc ra,0x1
+ 3a7c: e8c080e7 jalr -372(ra) # 4904 <exit>
+ printf("%s: write bigfile failed\n", s);
+ 3a80: 85d6 mv a1,s5
+ 3a82: 00003517 auipc a0,0x3
+ 3a86: 9ce50513 addi a0,a0,-1586 # 6450 <malloc+0x16d0>
+ 3a8a: 00001097 auipc ra,0x1
+ 3a8e: 23e080e7 jalr 574(ra) # 4cc8 <printf>
+ exit(1);
+ 3a92: 4505 li a0,1
+ 3a94: 00001097 auipc ra,0x1
+ 3a98: e70080e7 jalr -400(ra) # 4904 <exit>
+ printf("%s: cannot open bigfile\n", s);
+ 3a9c: 85d6 mv a1,s5
+ 3a9e: 00003517 auipc a0,0x3
+ 3aa2: 9d250513 addi a0,a0,-1582 # 6470 <malloc+0x16f0>
+ 3aa6: 00001097 auipc ra,0x1
+ 3aaa: 222080e7 jalr 546(ra) # 4cc8 <printf>
+ exit(1);
+ 3aae: 4505 li a0,1
+ 3ab0: 00001097 auipc ra,0x1
+ 3ab4: e54080e7 jalr -428(ra) # 4904 <exit>
+ printf("%s: read bigfile failed\n", s);
+ 3ab8: 85d6 mv a1,s5
+ 3aba: 00003517 auipc a0,0x3
+ 3abe: 9d650513 addi a0,a0,-1578 # 6490 <malloc+0x1710>
+ 3ac2: 00001097 auipc ra,0x1
+ 3ac6: 206080e7 jalr 518(ra) # 4cc8 <printf>
+ exit(1);
+ 3aca: 4505 li a0,1
+ 3acc: 00001097 auipc ra,0x1
+ 3ad0: e38080e7 jalr -456(ra) # 4904 <exit>
+ printf("%s: short read bigfile\n", s);
+ 3ad4: 85d6 mv a1,s5
+ 3ad6: 00003517 auipc a0,0x3
+ 3ada: 9da50513 addi a0,a0,-1574 # 64b0 <malloc+0x1730>
+ 3ade: 00001097 auipc ra,0x1
+ 3ae2: 1ea080e7 jalr 490(ra) # 4cc8 <printf>
+ exit(1);
+ 3ae6: 4505 li a0,1
+ 3ae8: 00001097 auipc ra,0x1
+ 3aec: e1c080e7 jalr -484(ra) # 4904 <exit>
+ printf("%s: read bigfile wrong data\n", s);
+ 3af0: 85d6 mv a1,s5
+ 3af2: 00003517 auipc a0,0x3
+ 3af6: 9d650513 addi a0,a0,-1578 # 64c8 <malloc+0x1748>
+ 3afa: 00001097 auipc ra,0x1
+ 3afe: 1ce080e7 jalr 462(ra) # 4cc8 <printf>
+ exit(1);
+ 3b02: 4505 li a0,1
+ 3b04: 00001097 auipc ra,0x1
+ 3b08: e00080e7 jalr -512(ra) # 4904 <exit>
+ close(fd);
+ 3b0c: 8552 mv a0,s4
+ 3b0e: 00001097 auipc ra,0x1
+ 3b12: e26080e7 jalr -474(ra) # 4934 <close>
+ if(total != N*SZ){
+ 3b16: 678d lui a5,0x3
+ 3b18: ee078793 addi a5,a5,-288 # 2ee0 <iref+0x114>
+ 3b1c: 02f99363 bne s3,a5,3b42 <bigfile+0x1c4>
+ remove("bigfile.dat");
+ 3b20: 00003517 auipc a0,0x3
+ 3b24: 90050513 addi a0,a0,-1792 # 6420 <malloc+0x16a0>
+ 3b28: 00001097 auipc ra,0x1
+ 3b2c: e9c080e7 jalr -356(ra) # 49c4 <remove>
+}
+ 3b30: 70e2 ld ra,56(sp)
+ 3b32: 7442 ld s0,48(sp)
+ 3b34: 74a2 ld s1,40(sp)
+ 3b36: 7902 ld s2,32(sp)
+ 3b38: 69e2 ld s3,24(sp)
+ 3b3a: 6a42 ld s4,16(sp)
+ 3b3c: 6aa2 ld s5,8(sp)
+ 3b3e: 6121 addi sp,sp,64
+ 3b40: 8082 ret
+ printf("%s: read bigfile wrong total\n", s);
+ 3b42: 85d6 mv a1,s5
+ 3b44: 00003517 auipc a0,0x3
+ 3b48: 9a450513 addi a0,a0,-1628 # 64e8 <malloc+0x1768>
+ 3b4c: 00001097 auipc ra,0x1
+ 3b50: 17c080e7 jalr 380(ra) # 4cc8 <printf>
+ exit(1);
+ 3b54: 4505 li a0,1
+ 3b56: 00001097 auipc ra,0x1
+ 3b5a: dae080e7 jalr -594(ra) # 4904 <exit>
+
+0000000000003b5e <createdelete>:
+{
+ 3b5e: 7171 addi sp,sp,-176
+ 3b60: f506 sd ra,168(sp)
+ 3b62: f122 sd s0,160(sp)
+ 3b64: ed26 sd s1,152(sp)
+ 3b66: e94a sd s2,144(sp)
+ 3b68: e54e sd s3,136(sp)
+ 3b6a: e152 sd s4,128(sp)
+ 3b6c: fcd6 sd s5,120(sp)
+ 3b6e: f8da sd s6,112(sp)
+ 3b70: f4de sd s7,104(sp)
+ 3b72: f0e2 sd s8,96(sp)
+ 3b74: ece6 sd s9,88(sp)
+ 3b76: e8ea sd s10,80(sp)
+ 3b78: e4ee sd s11,72(sp)
+ 3b7a: 1900 addi s0,sp,176
+ 3b7c: 8daa mv s11,a0
+ char illegal[] = { '\"', '*', '/', ':', '<', '>', '?', '\\', '|', 0 };
+ 3b7e: 00003797 auipc a5,0x3
+ 3b82: 9f278793 addi a5,a5,-1550 # 6570 <malloc+0x17f0>
+ 3b86: 6398 ld a4,0(a5)
+ 3b88: f6e43023 sd a4,-160(s0)
+ 3b8c: 0087d783 lhu a5,8(a5)
+ 3b90: f6f41423 sh a5,-152(s0)
+ for(pi = 0; pi < NCHILD; pi++){
+ 3b94: 4901 li s2,0
+ 3b96: 4991 li s3,4
+ pid = fork();
+ 3b98: 00001097 auipc ra,0x1
+ 3b9c: d64080e7 jalr -668(ra) # 48fc <fork>
+ 3ba0: 84aa mv s1,a0
+ if(pid < 0){
+ 3ba2: 04054263 bltz a0,3be6 <createdelete+0x88>
+ if(pid == 0){
+ 3ba6: cd31 beqz a0,3c02 <createdelete+0xa4>
+ for(pi = 0; pi < NCHILD; pi++){
+ 3ba8: 2905 addiw s2,s2,1
+ 3baa: ff3917e3 bne s2,s3,3b98 <createdelete+0x3a>
+ 3bae: 4491 li s1,4
+ wait(&xstatus);
+ 3bb0: f5c40913 addi s2,s0,-164
+ 3bb4: 854a mv a0,s2
+ 3bb6: 00001097 auipc ra,0x1
+ 3bba: d58080e7 jalr -680(ra) # 490e <wait>
+ if(xstatus != 0)
+ 3bbe: f5c42983 lw s3,-164(s0)
+ 3bc2: 10099963 bnez s3,3cd4 <createdelete+0x176>
+ for(pi = 0; pi < NCHILD; pi++){
+ 3bc6: 34fd addiw s1,s1,-1
+ 3bc8: f4f5 bnez s1,3bb4 <createdelete+0x56>
+ name[0] = name[1] = name[2] = 0;
+ 3bca: f6040923 sb zero,-142(s0)
+ 3bce: 03000913 li s2,48
+ 3bd2: 5b7d li s6,-1
+ 3bd4: 07000c93 li s9,112
+ if (strchr(illegal, name[1]) != 0) { continue; }
+ 3bd8: f6040a93 addi s5,s0,-160
+ fd = open(name, 0);
+ 3bdc: f7040c13 addi s8,s0,-144
+ } else if((i >= 1 && i < N/2) && fd >= 0){
+ 3be0: 4ba1 li s7,8
+ if((i == 0 || i >= N/2) && fd < 0){
+ 3be2: 4d25 li s10,9
+ 3be4: aa71 j 3d80 <createdelete+0x222>
+ printf("fork failed\n", s);
+ 3be6: 85ee mv a1,s11
+ 3be8: 00002517 auipc a0,0x2
+ 3bec: d0850513 addi a0,a0,-760 # 58f0 <malloc+0xb70>
+ 3bf0: 00001097 auipc ra,0x1
+ 3bf4: 0d8080e7 jalr 216(ra) # 4cc8 <printf>
+ exit(1);
+ 3bf8: 4505 li a0,1
+ 3bfa: 00001097 auipc ra,0x1
+ 3bfe: d0a080e7 jalr -758(ra) # 4904 <exit>
+ name[0] = 'p' + pi;
+ 3c02: 0709091b addiw s2,s2,112
+ 3c06: f7240823 sb s2,-144(s0)
+ name[2] = '\0';
+ 3c0a: f6040923 sb zero,-142(s0)
+ if (strchr(illegal, name[1]) == 0) {
+ 3c0e: f6040913 addi s2,s0,-160
+ fd = open(name, O_CREATE | O_RDWR);
+ 3c12: f7040a13 addi s4,s0,-144
+ for(i = 0; i < N; i++){
+ 3c16: 49d1 li s3,20
+ 3c18: a091 j 3c5c <createdelete+0xfe>
+ fd = open(name, O_CREATE | O_RDWR);
+ 3c1a: 20200593 li a1,514
+ 3c1e: 8552 mv a0,s4
+ 3c20: 00001097 auipc ra,0x1
+ 3c24: d30080e7 jalr -720(ra) # 4950 <open>
+ if(fd < 0){
+ 3c28: 00054763 bltz a0,3c36 <createdelete+0xd8>
+ close(fd);
+ 3c2c: 00001097 auipc ra,0x1
+ 3c30: d08080e7 jalr -760(ra) # 4934 <close>
+ 3c34: a081 j 3c74 <createdelete+0x116>
+ printf("%s: create %s failed\n", s, name);
+ 3c36: f7040613 addi a2,s0,-144
+ 3c3a: 85ee mv a1,s11
+ 3c3c: 00003517 auipc a0,0x3
+ 3c40: 8cc50513 addi a0,a0,-1844 # 6508 <malloc+0x1788>
+ 3c44: 00001097 auipc ra,0x1
+ 3c48: 084080e7 jalr 132(ra) # 4cc8 <printf>
+ exit(1);
+ 3c4c: 4505 li a0,1
+ 3c4e: 00001097 auipc ra,0x1
+ 3c52: cb6080e7 jalr -842(ra) # 4904 <exit>
+ for(i = 0; i < N; i++){
+ 3c56: 2485 addiw s1,s1,1
+ 3c58: 07348963 beq s1,s3,3cca <createdelete+0x16c>
+ name[1] = '0' + i;
+ 3c5c: 0304859b addiw a1,s1,48
+ 3c60: 0ff5f593 zext.b a1,a1
+ 3c64: f6b408a3 sb a1,-143(s0)
+ if (strchr(illegal, name[1]) == 0) {
+ 3c68: 854a mv a0,s2
+ 3c6a: 00001097 auipc ra,0x1
+ 3c6e: aa4080e7 jalr -1372(ra) # 470e <strchr>
+ 3c72: d545 beqz a0,3c1a <createdelete+0xbc>
+ if(i > 0 && (i % 2 ) == 0){
+ 3c74: fe9051e3 blez s1,3c56 <createdelete+0xf8>
+ 3c78: 0014f793 andi a5,s1,1
+ 3c7c: ffe9 bnez a5,3c56 <createdelete+0xf8>
+ name[1] = '0' + (i / 2);
+ 3c7e: 01f4d59b srliw a1,s1,0x1f
+ 3c82: 9da5 addw a1,a1,s1
+ 3c84: 4015d59b sraiw a1,a1,0x1
+ 3c88: 0305859b addiw a1,a1,48
+ 3c8c: 0ff5f593 zext.b a1,a1
+ 3c90: f6b408a3 sb a1,-143(s0)
+ if (strchr(illegal, name[1]) == 0) {
+ 3c94: 854a mv a0,s2
+ 3c96: 00001097 auipc ra,0x1
+ 3c9a: a78080e7 jalr -1416(ra) # 470e <strchr>
+ 3c9e: fd45 bnez a0,3c56 <createdelete+0xf8>
+ if(remove(name) < 0){
+ 3ca0: 8552 mv a0,s4
+ 3ca2: 00001097 auipc ra,0x1
+ 3ca6: d22080e7 jalr -734(ra) # 49c4 <remove>
+ 3caa: fa0556e3 bgez a0,3c56 <createdelete+0xf8>
+ printf("%s: remove failed\n", s);
+ 3cae: 85ee mv a1,s11
+ 3cb0: 00002517 auipc a0,0x2
+ 3cb4: 58050513 addi a0,a0,1408 # 6230 <malloc+0x14b0>
+ 3cb8: 00001097 auipc ra,0x1
+ 3cbc: 010080e7 jalr 16(ra) # 4cc8 <printf>
+ exit(1);
+ 3cc0: 4505 li a0,1
+ 3cc2: 00001097 auipc ra,0x1
+ 3cc6: c42080e7 jalr -958(ra) # 4904 <exit>
+ exit(0);
+ 3cca: 4501 li a0,0
+ 3ccc: 00001097 auipc ra,0x1
+ 3cd0: c38080e7 jalr -968(ra) # 4904 <exit>
+ exit(1);
+ 3cd4: 4505 li a0,1
+ 3cd6: 00001097 auipc ra,0x1
+ 3cda: c2e080e7 jalr -978(ra) # 4904 <exit>
+ printf("%s: oops createdelete %s didn't exist\n", s, name);
+ 3cde: f7040613 addi a2,s0,-144
+ 3ce2: 85ee mv a1,s11
+ 3ce4: 00003517 auipc a0,0x3
+ 3ce8: 83c50513 addi a0,a0,-1988 # 6520 <malloc+0x17a0>
+ 3cec: 00001097 auipc ra,0x1
+ 3cf0: fdc080e7 jalr -36(ra) # 4cc8 <printf>
+ exit(1);
+ 3cf4: 4505 li a0,1
+ 3cf6: 00001097 auipc ra,0x1
+ 3cfa: c0e080e7 jalr -1010(ra) # 4904 <exit>
+ } else if((i >= 1 && i < N/2) && fd >= 0){
+ 3cfe: 056bf763 bgeu s7,s6,3d4c <createdelete+0x1ee>
+ if(fd >= 0)
+ 3d02: 04055063 bgez a0,3d42 <createdelete+0x1e4>
+ for(pi = 0; pi < NCHILD; pi++){
+ 3d06: 2485 addiw s1,s1,1
+ 3d08: 0ff4f493 zext.b s1,s1
+ 3d0c: 07448263 beq s1,s4,3d70 <createdelete+0x212>
+ name[0] = 'p' + pi;
+ 3d10: f6940823 sb s1,-144(s0)
+ name[1] = '0' + i;
+ 3d14: f72408a3 sb s2,-143(s0)
+ if (strchr(illegal, name[1]) != 0) { continue; }
+ 3d18: 85ca mv a1,s2
+ 3d1a: 8556 mv a0,s5
+ 3d1c: 00001097 auipc ra,0x1
+ 3d20: 9f2080e7 jalr -1550(ra) # 470e <strchr>
+ 3d24: f16d bnez a0,3d06 <createdelete+0x1a8>
+ fd = open(name, 0);
+ 3d26: 4581 li a1,0
+ 3d28: 8562 mv a0,s8
+ 3d2a: 00001097 auipc ra,0x1
+ 3d2e: c26080e7 jalr -986(ra) # 4950 <open>
+ if((i == 0 || i >= N/2) && fd < 0){
+ 3d32: 00098463 beqz s3,3d3a <createdelete+0x1dc>
+ 3d36: fd3d54e3 bge s10,s3,3cfe <createdelete+0x1a0>
+ 3d3a: fa0542e3 bltz a0,3cde <createdelete+0x180>
+ } else if((i >= 1 && i < N/2) && fd >= 0){
+ 3d3e: 016bf963 bgeu s7,s6,3d50 <createdelete+0x1f2>
+ close(fd);
+ 3d42: 00001097 auipc ra,0x1
+ 3d46: bf2080e7 jalr -1038(ra) # 4934 <close>
+ 3d4a: bf75 j 3d06 <createdelete+0x1a8>
+ } else if((i >= 1 && i < N/2) && fd >= 0){
+ 3d4c: fa054de3 bltz a0,3d06 <createdelete+0x1a8>
+ printf("%s: oops createdelete %s did exist\n", s, name);
+ 3d50: f7040613 addi a2,s0,-144
+ 3d54: 85ee mv a1,s11
+ 3d56: 00002517 auipc a0,0x2
+ 3d5a: 7f250513 addi a0,a0,2034 # 6548 <malloc+0x17c8>
+ 3d5e: 00001097 auipc ra,0x1
+ 3d62: f6a080e7 jalr -150(ra) # 4cc8 <printf>
+ exit(1);
+ 3d66: 4505 li a0,1
+ 3d68: 00001097 auipc ra,0x1
+ 3d6c: b9c080e7 jalr -1124(ra) # 4904 <exit>
+ for(i = 0; i < N; i++){
+ 3d70: 2985 addiw s3,s3,1
+ 3d72: 2b05 addiw s6,s6,1
+ 3d74: 2905 addiw s2,s2,1
+ 3d76: 0ff97913 zext.b s2,s2
+ 3d7a: 47d1 li a5,20
+ 3d7c: 02f98b63 beq s3,a5,3db2 <createdelete+0x254>
+ for(pi = 0; pi < NCHILD; pi++){
+ 3d80: 84e6 mv s1,s9
+ 3d82: 07400a13 li s4,116
+ 3d86: b769 j 3d10 <createdelete+0x1b2>
+ for(i = 0; i < N; i++){
+ 3d88: 2905 addiw s2,s2,1
+ 3d8a: 0ff97913 zext.b s2,s2
+ 3d8e: 03590d63 beq s2,s5,3dc8 <createdelete+0x26a>
+ name[0] = name[1] = name[2] = 0;
+ 3d92: 84da mv s1,s6
+ name[0] = 'p' + pi;
+ 3d94: f6940823 sb s1,-144(s0)
+ name[1] = '0' + i;
+ 3d98: f72408a3 sb s2,-143(s0)
+ remove(name);
+ 3d9c: 8552 mv a0,s4
+ 3d9e: 00001097 auipc ra,0x1
+ 3da2: c26080e7 jalr -986(ra) # 49c4 <remove>
+ for(pi = 0; pi < NCHILD; pi++){
+ 3da6: 2485 addiw s1,s1,1
+ 3da8: 0ff4f493 zext.b s1,s1
+ 3dac: ff3494e3 bne s1,s3,3d94 <createdelete+0x236>
+ 3db0: bfe1 j 3d88 <createdelete+0x22a>
+ 3db2: 03000913 li s2,48
+ name[0] = name[1] = name[2] = 0;
+ 3db6: 07000b13 li s6,112
+ remove(name);
+ 3dba: f7040a13 addi s4,s0,-144
+ for(pi = 0; pi < NCHILD; pi++){
+ 3dbe: 07400993 li s3,116
+ for(i = 0; i < N; i++){
+ 3dc2: 04400a93 li s5,68
+ 3dc6: b7f1 j 3d92 <createdelete+0x234>
+}
+ 3dc8: 70aa ld ra,168(sp)
+ 3dca: 740a ld s0,160(sp)
+ 3dcc: 64ea ld s1,152(sp)
+ 3dce: 694a ld s2,144(sp)
+ 3dd0: 69aa ld s3,136(sp)
+ 3dd2: 6a0a ld s4,128(sp)
+ 3dd4: 7ae6 ld s5,120(sp)
+ 3dd6: 7b46 ld s6,112(sp)
+ 3dd8: 7ba6 ld s7,104(sp)
+ 3dda: 7c06 ld s8,96(sp)
+ 3ddc: 6ce6 ld s9,88(sp)
+ 3dde: 6d46 ld s10,80(sp)
+ 3de0: 6da6 ld s11,72(sp)
+ 3de2: 614d addi sp,sp,176
+ 3de4: 8082 ret
+
+0000000000003de6 <dirtest>:
+{
+ 3de6: 1101 addi sp,sp,-32
+ 3de8: ec06 sd ra,24(sp)
+ 3dea: e822 sd s0,16(sp)
+ 3dec: e426 sd s1,8(sp)
+ 3dee: 1000 addi s0,sp,32
+ 3df0: 84aa mv s1,a0
+ printf("mkdir test\n");
+ 3df2: 00002517 auipc a0,0x2
+ 3df6: 78e50513 addi a0,a0,1934 # 6580 <malloc+0x1800>
+ 3dfa: 00001097 auipc ra,0x1
+ 3dfe: ece080e7 jalr -306(ra) # 4cc8 <printf>
+ if(mkdir("dir0") < 0){
+ 3e02: 00002517 auipc a0,0x2
+ 3e06: 78e50513 addi a0,a0,1934 # 6590 <malloc+0x1810>
+ 3e0a: 00001097 auipc ra,0x1
+ 3e0e: b5a080e7 jalr -1190(ra) # 4964 <mkdir>
+ 3e12: 04054d63 bltz a0,3e6c <dirtest+0x86>
+ if(chdir("dir0") < 0){
+ 3e16: 00002517 auipc a0,0x2
+ 3e1a: 77a50513 addi a0,a0,1914 # 6590 <malloc+0x1810>
+ 3e1e: 00001097 auipc ra,0x1
+ 3e22: b50080e7 jalr -1200(ra) # 496e <chdir>
+ 3e26: 06054163 bltz a0,3e88 <dirtest+0xa2>
+ if(chdir("..") < 0){
+ 3e2a: 00002517 auipc a0,0x2
+ 3e2e: 1c650513 addi a0,a0,454 # 5ff0 <malloc+0x1270>
+ 3e32: 00001097 auipc ra,0x1
+ 3e36: b3c080e7 jalr -1220(ra) # 496e <chdir>
+ 3e3a: 06054563 bltz a0,3ea4 <dirtest+0xbe>
+ if(remove("dir0") < 0){
+ 3e3e: 00002517 auipc a0,0x2
+ 3e42: 75250513 addi a0,a0,1874 # 6590 <malloc+0x1810>
+ 3e46: 00001097 auipc ra,0x1
+ 3e4a: b7e080e7 jalr -1154(ra) # 49c4 <remove>
+ 3e4e: 06054963 bltz a0,3ec0 <dirtest+0xda>
+ printf("%s: mkdir test ok\n");
+ 3e52: 00002517 auipc a0,0x2
+ 3e56: 78e50513 addi a0,a0,1934 # 65e0 <malloc+0x1860>
+ 3e5a: 00001097 auipc ra,0x1
+ 3e5e: e6e080e7 jalr -402(ra) # 4cc8 <printf>
+}
+ 3e62: 60e2 ld ra,24(sp)
+ 3e64: 6442 ld s0,16(sp)
+ 3e66: 64a2 ld s1,8(sp)
+ 3e68: 6105 addi sp,sp,32
+ 3e6a: 8082 ret
+ printf("%s: mkdir failed\n", s);
+ 3e6c: 85a6 mv a1,s1
+ 3e6e: 00002517 auipc a0,0x2
+ 3e72: d0250513 addi a0,a0,-766 # 5b70 <malloc+0xdf0>
+ 3e76: 00001097 auipc ra,0x1
+ 3e7a: e52080e7 jalr -430(ra) # 4cc8 <printf>
+ exit(1);
+ 3e7e: 4505 li a0,1
+ 3e80: 00001097 auipc ra,0x1
+ 3e84: a84080e7 jalr -1404(ra) # 4904 <exit>
+ printf("%s: chdir dir0 failed\n", s);
+ 3e88: 85a6 mv a1,s1
+ 3e8a: 00002517 auipc a0,0x2
+ 3e8e: 70e50513 addi a0,a0,1806 # 6598 <malloc+0x1818>
+ 3e92: 00001097 auipc ra,0x1
+ 3e96: e36080e7 jalr -458(ra) # 4cc8 <printf>
+ exit(1);
+ 3e9a: 4505 li a0,1
+ 3e9c: 00001097 auipc ra,0x1
+ 3ea0: a68080e7 jalr -1432(ra) # 4904 <exit>
+ printf("%s: chdir .. failed\n", s);
+ 3ea4: 85a6 mv a1,s1
+ 3ea6: 00002517 auipc a0,0x2
+ 3eaa: 70a50513 addi a0,a0,1802 # 65b0 <malloc+0x1830>
+ 3eae: 00001097 auipc ra,0x1
+ 3eb2: e1a080e7 jalr -486(ra) # 4cc8 <printf>
+ exit(1);
+ 3eb6: 4505 li a0,1
+ 3eb8: 00001097 auipc ra,0x1
+ 3ebc: a4c080e7 jalr -1460(ra) # 4904 <exit>
+ printf("%s: remove dir0 failed\n", s);
+ 3ec0: 85a6 mv a1,s1
+ 3ec2: 00002517 auipc a0,0x2
+ 3ec6: 70650513 addi a0,a0,1798 # 65c8 <malloc+0x1848>
+ 3eca: 00001097 auipc ra,0x1
+ 3ece: dfe080e7 jalr -514(ra) # 4cc8 <printf>
+ exit(1);
+ 3ed2: 4505 li a0,1
+ 3ed4: 00001097 auipc ra,0x1
+ 3ed8: a30080e7 jalr -1488(ra) # 4904 <exit>
+
+0000000000003edc <fourteen>:
+{
+ 3edc: 1101 addi sp,sp,-32
+ 3ede: ec06 sd ra,24(sp)
+ 3ee0: e822 sd s0,16(sp)
+ 3ee2: e426 sd s1,8(sp)
+ 3ee4: 1000 addi s0,sp,32
+ 3ee6: 84aa mv s1,a0
+ if(mkdir("12345678901234") != 0){
+ 3ee8: 00003517 auipc a0,0x3
+ 3eec: 8e050513 addi a0,a0,-1824 # 67c8 <malloc+0x1a48>
+ 3ef0: 00001097 auipc ra,0x1
+ 3ef4: a74080e7 jalr -1420(ra) # 4964 <mkdir>
+ 3ef8: e165 bnez a0,3fd8 <fourteen+0xfc>
+ if(mkdir("12345678901234/123456789012345") != 0){
+ 3efa: 00002517 auipc a0,0x2
+ 3efe: 72650513 addi a0,a0,1830 # 6620 <malloc+0x18a0>
+ 3f02: 00001097 auipc ra,0x1
+ 3f06: a62080e7 jalr -1438(ra) # 4964 <mkdir>
+ 3f0a: e56d bnez a0,3ff4 <fourteen+0x118>
+ fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
+ 3f0c: 20000593 li a1,512
+ 3f10: 00002517 auipc a0,0x2
+ 3f14: 76850513 addi a0,a0,1896 # 6678 <malloc+0x18f8>
+ 3f18: 00001097 auipc ra,0x1
+ 3f1c: a38080e7 jalr -1480(ra) # 4950 <open>
+ if(fd < 0){
+ 3f20: 0e054863 bltz a0,4010 <fourteen+0x134>
+ close(fd);
+ 3f24: 00001097 auipc ra,0x1
+ 3f28: a10080e7 jalr -1520(ra) # 4934 <close>
+ fd = open("12345678901234/12345678901234/12345678901234", 0);
+ 3f2c: 4581 li a1,0
+ 3f2e: 00002517 auipc a0,0x2
+ 3f32: 7c250513 addi a0,a0,1986 # 66f0 <malloc+0x1970>
+ 3f36: 00001097 auipc ra,0x1
+ 3f3a: a1a080e7 jalr -1510(ra) # 4950 <open>
+ if(fd < 0){
+ 3f3e: 0e054763 bltz a0,402c <fourteen+0x150>
+ close(fd);
+ 3f42: 00001097 auipc ra,0x1
+ 3f46: 9f2080e7 jalr -1550(ra) # 4934 <close>
+ if(mkdir("12345678901234/12345678901234") == 0){
+ 3f4a: 00003517 auipc a0,0x3
+ 3f4e: 81650513 addi a0,a0,-2026 # 6760 <malloc+0x19e0>
+ 3f52: 00001097 auipc ra,0x1
+ 3f56: a12080e7 jalr -1518(ra) # 4964 <mkdir>
+ 3f5a: c57d beqz a0,4048 <fourteen+0x16c>
+ if(mkdir("123456789012345/12345678901234") == 0){
+ 3f5c: 00003517 auipc a0,0x3
+ 3f60: 85c50513 addi a0,a0,-1956 # 67b8 <malloc+0x1a38>
+ 3f64: 00001097 auipc ra,0x1
+ 3f68: a00080e7 jalr -1536(ra) # 4964 <mkdir>
+ 3f6c: cd65 beqz a0,4064 <fourteen+0x188>
+ remove("123456789012345/12345678901234");
+ 3f6e: 00003517 auipc a0,0x3
+ 3f72: 84a50513 addi a0,a0,-1974 # 67b8 <malloc+0x1a38>
+ 3f76: 00001097 auipc ra,0x1
+ 3f7a: a4e080e7 jalr -1458(ra) # 49c4 <remove>
+ remove("12345678901234/12345678901234");
+ 3f7e: 00002517 auipc a0,0x2
+ 3f82: 7e250513 addi a0,a0,2018 # 6760 <malloc+0x19e0>
+ 3f86: 00001097 auipc ra,0x1
+ 3f8a: a3e080e7 jalr -1474(ra) # 49c4 <remove>
+ remove("12345678901234/12345678901234/12345678901234");
+ 3f8e: 00002517 auipc a0,0x2
+ 3f92: 76250513 addi a0,a0,1890 # 66f0 <malloc+0x1970>
+ 3f96: 00001097 auipc ra,0x1
+ 3f9a: a2e080e7 jalr -1490(ra) # 49c4 <remove>
+ remove("123456789012345/123456789012345/123456789012345");
+ 3f9e: 00002517 auipc a0,0x2
+ 3fa2: 6da50513 addi a0,a0,1754 # 6678 <malloc+0x18f8>
+ 3fa6: 00001097 auipc ra,0x1
+ 3faa: a1e080e7 jalr -1506(ra) # 49c4 <remove>
+ remove("12345678901234/123456789012345");
+ 3fae: 00002517 auipc a0,0x2
+ 3fb2: 67250513 addi a0,a0,1650 # 6620 <malloc+0x18a0>
+ 3fb6: 00001097 auipc ra,0x1
+ 3fba: a0e080e7 jalr -1522(ra) # 49c4 <remove>
+ remove("12345678901234");
+ 3fbe: 00003517 auipc a0,0x3
+ 3fc2: 80a50513 addi a0,a0,-2038 # 67c8 <malloc+0x1a48>
+ 3fc6: 00001097 auipc ra,0x1
+ 3fca: 9fe080e7 jalr -1538(ra) # 49c4 <remove>
+}
+ 3fce: 60e2 ld ra,24(sp)
+ 3fd0: 6442 ld s0,16(sp)
+ 3fd2: 64a2 ld s1,8(sp)
+ 3fd4: 6105 addi sp,sp,32
+ 3fd6: 8082 ret
+ printf("%s: mkdir 12345678901234 failed\n", s);
+ 3fd8: 85a6 mv a1,s1
+ 3fda: 00002517 auipc a0,0x2
+ 3fde: 61e50513 addi a0,a0,1566 # 65f8 <malloc+0x1878>
+ 3fe2: 00001097 auipc ra,0x1
+ 3fe6: ce6080e7 jalr -794(ra) # 4cc8 <printf>
+ exit(1);
+ 3fea: 4505 li a0,1
+ 3fec: 00001097 auipc ra,0x1
+ 3ff0: 918080e7 jalr -1768(ra) # 4904 <exit>
+ printf("%s: mkdir 12345678901234/123456789012345 failed\n", s);
+ 3ff4: 85a6 mv a1,s1
+ 3ff6: 00002517 auipc a0,0x2
+ 3ffa: 64a50513 addi a0,a0,1610 # 6640 <malloc+0x18c0>
+ 3ffe: 00001097 auipc ra,0x1
+ 4002: cca080e7 jalr -822(ra) # 4cc8 <printf>
+ exit(1);
+ 4006: 4505 li a0,1
+ 4008: 00001097 auipc ra,0x1
+ 400c: 8fc080e7 jalr -1796(ra) # 4904 <exit>
+ printf("%s: create 123456789012345/123456789012345/123456789012345 failed\n", s);
+ 4010: 85a6 mv a1,s1
+ 4012: 00002517 auipc a0,0x2
+ 4016: 69650513 addi a0,a0,1686 # 66a8 <malloc+0x1928>
+ 401a: 00001097 auipc ra,0x1
+ 401e: cae080e7 jalr -850(ra) # 4cc8 <printf>
+ exit(1);
+ 4022: 4505 li a0,1
+ 4024: 00001097 auipc ra,0x1
+ 4028: 8e0080e7 jalr -1824(ra) # 4904 <exit>
+ printf("%s: open 12345678901234/12345678901234/12345678901234 failed\n", s);
+ 402c: 85a6 mv a1,s1
+ 402e: 00002517 auipc a0,0x2
+ 4032: 6f250513 addi a0,a0,1778 # 6720 <malloc+0x19a0>
+ 4036: 00001097 auipc ra,0x1
+ 403a: c92080e7 jalr -878(ra) # 4cc8 <printf>
+ exit(1);
+ 403e: 4505 li a0,1
+ 4040: 00001097 auipc ra,0x1
+ 4044: 8c4080e7 jalr -1852(ra) # 4904 <exit>
+ printf("%s: mkdir 12345678901234/12345678901234 succeeded!\n", s);
+ 4048: 85a6 mv a1,s1
+ 404a: 00002517 auipc a0,0x2
+ 404e: 73650513 addi a0,a0,1846 # 6780 <malloc+0x1a00>
+ 4052: 00001097 auipc ra,0x1
+ 4056: c76080e7 jalr -906(ra) # 4cc8 <printf>
+ exit(1);
+ 405a: 4505 li a0,1
+ 405c: 00001097 auipc ra,0x1
+ 4060: 8a8080e7 jalr -1880(ra) # 4904 <exit>
+ printf("%s: mkdir 12345678901234/123456789012345 succeeded!\n", s);
+ 4064: 85a6 mv a1,s1
+ 4066: 00002517 auipc a0,0x2
+ 406a: 77250513 addi a0,a0,1906 # 67d8 <malloc+0x1a58>
+ 406e: 00001097 auipc ra,0x1
+ 4072: c5a080e7 jalr -934(ra) # 4cc8 <printf>
+ exit(1);
+ 4076: 4505 li a0,1
+ 4078: 00001097 auipc ra,0x1
+ 407c: 88c080e7 jalr -1908(ra) # 4904 <exit>
+
+0000000000004080 <fsfull>:
+{
+ 4080: 7171 addi sp,sp,-176
+ 4082: f506 sd ra,168(sp)
+ 4084: f122 sd s0,160(sp)
+ 4086: ed26 sd s1,152(sp)
+ 4088: e94a sd s2,144(sp)
+ 408a: e54e sd s3,136(sp)
+ 408c: e152 sd s4,128(sp)
+ 408e: fcd6 sd s5,120(sp)
+ 4090: f8da sd s6,112(sp)
+ 4092: f4de sd s7,104(sp)
+ 4094: f0e2 sd s8,96(sp)
+ 4096: ece6 sd s9,88(sp)
+ 4098: e8ea sd s10,80(sp)
+ 409a: e4ee sd s11,72(sp)
+ 409c: 1900 addi s0,sp,176
+ printf("fsfull test\n");
+ 409e: 00002517 auipc a0,0x2
+ 40a2: 77250513 addi a0,a0,1906 # 6810 <malloc+0x1a90>
+ 40a6: 00001097 auipc ra,0x1
+ 40aa: c22080e7 jalr -990(ra) # 4cc8 <printf>
+ for(nfiles = 0; ; nfiles++){
+ 40ae: 4481 li s1,0
+ name[0] = 'f';
+ 40b0: 06600d93 li s11,102
+ name[1] = '0' + nfiles / 1000;
+ 40b4: 3e800c93 li s9,1000
+ name[2] = '0' + (nfiles % 1000) / 100;
+ 40b8: 06400c13 li s8,100
+ name[3] = '0' + (nfiles % 100) / 10;
+ 40bc: 4ba9 li s7,10
+ printf("%s: writing %s\n", name);
+ 40be: f5040b13 addi s6,s0,-176
+ 40c2: 00002d17 auipc s10,0x2
+ 40c6: 75ed0d13 addi s10,s10,1886 # 6820 <malloc+0x1aa0>
+ int cc = write(fd, buf, BSIZE);
+ 40ca: 00006a17 auipc s4,0x6
+ 40ce: 7cea0a13 addi s4,s4,1998 # a898 <buf>
+ name[0] = 'f';
+ 40d2: f5b40823 sb s11,-176(s0)
+ name[1] = '0' + nfiles / 1000;
+ 40d6: 0394c7bb divw a5,s1,s9
+ 40da: 0307879b addiw a5,a5,48
+ 40de: f4f408a3 sb a5,-175(s0)
+ name[2] = '0' + (nfiles % 1000) / 100;
+ 40e2: 0394e7bb remw a5,s1,s9
+ 40e6: 0387c7bb divw a5,a5,s8
+ 40ea: 0307879b addiw a5,a5,48
+ 40ee: f4f40923 sb a5,-174(s0)
+ name[3] = '0' + (nfiles % 100) / 10;
+ 40f2: 0384e7bb remw a5,s1,s8
+ 40f6: 0377c7bb divw a5,a5,s7
+ 40fa: 0307879b addiw a5,a5,48
+ 40fe: f4f409a3 sb a5,-173(s0)
+ name[4] = '0' + (nfiles % 10);
+ 4102: 0374e7bb remw a5,s1,s7
+ 4106: 0307879b addiw a5,a5,48
+ 410a: f4f40a23 sb a5,-172(s0)
+ name[5] = '\0';
+ 410e: f4040aa3 sb zero,-171(s0)
+ printf("%s: writing %s\n", name);
+ 4112: 85da mv a1,s6
+ 4114: 856a mv a0,s10
+ 4116: 00001097 auipc ra,0x1
+ 411a: bb2080e7 jalr -1102(ra) # 4cc8 <printf>
+ int fd = open(name, O_CREATE|O_RDWR);
+ 411e: 20200593 li a1,514
+ 4122: 855a mv a0,s6
+ 4124: 00001097 auipc ra,0x1
+ 4128: 82c080e7 jalr -2004(ra) # 4950 <open>
+ 412c: 892a mv s2,a0
+ if(fd < 0){
+ 412e: 0a055763 bgez a0,41dc <fsfull+0x15c>
+ printf("%s: open %s failed\n", name);
+ 4132: f5040593 addi a1,s0,-176
+ 4136: 00002517 auipc a0,0x2
+ 413a: 6fa50513 addi a0,a0,1786 # 6830 <malloc+0x1ab0>
+ 413e: 00001097 auipc ra,0x1
+ 4142: b8a080e7 jalr -1142(ra) # 4cc8 <printf>
+ while(nfiles >= 0){
+ 4146: 0604c463 bltz s1,41ae <fsfull+0x12e>
+ name[0] = 'f';
+ 414a: 06600b93 li s7,102
+ name[1] = '0' + nfiles / 1000;
+ 414e: 3e800a13 li s4,1000
+ name[2] = '0' + (nfiles % 1000) / 100;
+ 4152: 06400993 li s3,100
+ name[3] = '0' + (nfiles % 100) / 10;
+ 4156: 4929 li s2,10
+ remove(name);
+ 4158: f5040b13 addi s6,s0,-176
+ while(nfiles >= 0){
+ 415c: 5afd li s5,-1
+ name[0] = 'f';
+ 415e: f5740823 sb s7,-176(s0)
+ name[1] = '0' + nfiles / 1000;
+ 4162: 0344c7bb divw a5,s1,s4
+ 4166: 0307879b addiw a5,a5,48
+ 416a: f4f408a3 sb a5,-175(s0)
+ name[2] = '0' + (nfiles % 1000) / 100;
+ 416e: 0344e7bb remw a5,s1,s4
+ 4172: 0337c7bb divw a5,a5,s3
+ 4176: 0307879b addiw a5,a5,48
+ 417a: f4f40923 sb a5,-174(s0)
+ name[3] = '0' + (nfiles % 100) / 10;
+ 417e: 0334e7bb remw a5,s1,s3
+ 4182: 0327c7bb divw a5,a5,s2
+ 4186: 0307879b addiw a5,a5,48
+ 418a: f4f409a3 sb a5,-173(s0)
+ name[4] = '0' + (nfiles % 10);
+ 418e: 0324e7bb remw a5,s1,s2
+ 4192: 0307879b addiw a5,a5,48
+ 4196: f4f40a23 sb a5,-172(s0)
+ name[5] = '\0';
+ 419a: f4040aa3 sb zero,-171(s0)
+ remove(name);
+ 419e: 855a mv a0,s6
+ 41a0: 00001097 auipc ra,0x1
+ 41a4: 824080e7 jalr -2012(ra) # 49c4 <remove>
+ nfiles--;
+ 41a8: 34fd addiw s1,s1,-1
+ while(nfiles >= 0){
+ 41aa: fb549ae3 bne s1,s5,415e <fsfull+0xde>
+ printf("fsfull test finished\n");
+ 41ae: 00002517 auipc a0,0x2
+ 41b2: 6b250513 addi a0,a0,1714 # 6860 <malloc+0x1ae0>
+ 41b6: 00001097 auipc ra,0x1
+ 41ba: b12080e7 jalr -1262(ra) # 4cc8 <printf>
+}
+ 41be: 70aa ld ra,168(sp)
+ 41c0: 740a ld s0,160(sp)
+ 41c2: 64ea ld s1,152(sp)
+ 41c4: 694a ld s2,144(sp)
+ 41c6: 69aa ld s3,136(sp)
+ 41c8: 6a0a ld s4,128(sp)
+ 41ca: 7ae6 ld s5,120(sp)
+ 41cc: 7b46 ld s6,112(sp)
+ 41ce: 7ba6 ld s7,104(sp)
+ 41d0: 7c06 ld s8,96(sp)
+ 41d2: 6ce6 ld s9,88(sp)
+ 41d4: 6d46 ld s10,80(sp)
+ 41d6: 6da6 ld s11,72(sp)
+ 41d8: 614d addi sp,sp,176
+ 41da: 8082 ret
+ int total = 0;
+ 41dc: 4981 li s3,0
+ if(cc < BSIZE)
+ 41de: 1ff00a93 li s5,511
+ int cc = write(fd, buf, BSIZE);
+ 41e2: 20000613 li a2,512
+ 41e6: 85d2 mv a1,s4
+ 41e8: 854a mv a0,s2
+ 41ea: 00000097 auipc ra,0x0
+ 41ee: 740080e7 jalr 1856(ra) # 492a <write>
+ if(cc < BSIZE)
+ 41f2: 00aad563 bge s5,a0,41fc <fsfull+0x17c>
+ total += cc;
+ 41f6: 00a989bb addw s3,s3,a0
+ while(1){
+ 41fa: b7e5 j 41e2 <fsfull+0x162>
+ printf("%s: wrote %d bytes\n", total);
+ 41fc: 85ce mv a1,s3
+ 41fe: 00002517 auipc a0,0x2
+ 4202: 64a50513 addi a0,a0,1610 # 6848 <malloc+0x1ac8>
+ 4206: 00001097 auipc ra,0x1
+ 420a: ac2080e7 jalr -1342(ra) # 4cc8 <printf>
+ close(fd);
+ 420e: 854a mv a0,s2
+ 4210: 00000097 auipc ra,0x0
+ 4214: 724080e7 jalr 1828(ra) # 4934 <close>
+ if(total == 0)
+ 4218: f20987e3 beqz s3,4146 <fsfull+0xc6>
+ for(nfiles = 0; ; nfiles++){
+ 421c: 2485 addiw s1,s1,1
+ 421e: bd55 j 40d2 <fsfull+0x52>
+
+0000000000004220 <rand>:
+{
+ 4220: 1141 addi sp,sp,-16
+ 4222: e422 sd s0,8(sp)
+ 4224: 0800 addi s0,sp,16
+ randstate = randstate * 1664525 + 1013904223;
+ 4226: 00003717 auipc a4,0x3
+ 422a: aea70713 addi a4,a4,-1302 # 6d10 <__DATA_BEGIN__>
+ 422e: 7308 ld a0,32(a4)
+ 4230: 001967b7 lui a5,0x196
+ 4234: 60d78793 addi a5,a5,1549 # 19660d <__BSS_END__+0x18a55d>
+ 4238: 02f50533 mul a0,a0,a5
+ 423c: 3c6ef7b7 lui a5,0x3c6ef
+ 4240: 35f78793 addi a5,a5,863 # 3c6ef35f <__BSS_END__+0x3c6e32af>
+ 4244: 953e add a0,a0,a5
+ 4246: f308 sd a0,32(a4)
+}
+ 4248: 2501 sext.w a0,a0
+ 424a: 6422 ld s0,8(sp)
+ 424c: 0141 addi sp,sp,16
+ 424e: 8082 ret
+
+0000000000004250 <countfree>:
+// because out of memory with lazy allocation results in the process
+// taking a fault and being killed, fork and report back.
+//
+int
+countfree()
+{
+ 4250: 7139 addi sp,sp,-64
+ 4252: fc06 sd ra,56(sp)
+ 4254: f822 sd s0,48(sp)
+ 4256: f426 sd s1,40(sp)
+ 4258: f04a sd s2,32(sp)
+ 425a: ec4e sd s3,24(sp)
+ 425c: 0080 addi s0,sp,64
+ int fds[2];
+
+ if(pipe(fds) < 0){
+ 425e: fc840513 addi a0,s0,-56
+ 4262: 00000097 auipc ra,0x0
+ 4266: 6b4080e7 jalr 1716(ra) # 4916 <pipe>
+ 426a: 06054763 bltz a0,42d8 <countfree+0x88>
+ printf("pipe() failed in countfree()\n");
+ exit(1);
+ }
+
+ int pid = fork();
+ 426e: 00000097 auipc ra,0x0
+ 4272: 68e080e7 jalr 1678(ra) # 48fc <fork>
+
+ if(pid < 0){
+ 4276: 06054e63 bltz a0,42f2 <countfree+0xa2>
+ printf("fork failed in countfree()\n");
+ exit(1);
+ }
+
+ if(pid == 0){
+ 427a: ed51 bnez a0,4316 <countfree+0xc6>
+ close(fds[0]);
+ 427c: fc842503 lw a0,-56(s0)
+ 4280: 00000097 auipc ra,0x0
+ 4284: 6b4080e7 jalr 1716(ra) # 4934 <close>
+
+ while(1){
+ uint64 a = (uint64) sbrk(4096);
+ if(a == 0xffffffffffffffff){
+ 4288: 597d li s2,-1
+ break;
+ }
+
+ // modify the memory to make sure it's really allocated.
+ *(char *)(a + 4096 - 1) = 1;
+ 428a: 4485 li s1,1
+
+ // report back one more page.
+ if(write(fds[1], "x", 1) != 1){
+ 428c: 00001997 auipc s3,0x1
+ 4290: cc498993 addi s3,s3,-828 # 4f50 <malloc+0x1d0>
+ uint64 a = (uint64) sbrk(4096);
+ 4294: 6505 lui a0,0x1
+ 4296: 00000097 auipc ra,0x0
+ 429a: 6f4080e7 jalr 1780(ra) # 498a <sbrk>
+ if(a == 0xffffffffffffffff){
+ 429e: 07250763 beq a0,s2,430c <countfree+0xbc>
+ *(char *)(a + 4096 - 1) = 1;
+ 42a2: 6785 lui a5,0x1
+ 42a4: 97aa add a5,a5,a0
+ 42a6: fe978fa3 sb s1,-1(a5) # fff <copyinstr2+0xbd>
+ if(write(fds[1], "x", 1) != 1){
+ 42aa: 8626 mv a2,s1
+ 42ac: 85ce mv a1,s3
+ 42ae: fcc42503 lw a0,-52(s0)
+ 42b2: 00000097 auipc ra,0x0
+ 42b6: 678080e7 jalr 1656(ra) # 492a <write>
+ 42ba: fc950de3 beq a0,s1,4294 <countfree+0x44>
+ printf("write() failed in countfree()\n");
+ 42be: 00002517 auipc a0,0x2
+ 42c2: 5fa50513 addi a0,a0,1530 # 68b8 <malloc+0x1b38>
+ 42c6: 00001097 auipc ra,0x1
+ 42ca: a02080e7 jalr -1534(ra) # 4cc8 <printf>
+ exit(1);
+ 42ce: 4505 li a0,1
+ 42d0: 00000097 auipc ra,0x0
+ 42d4: 634080e7 jalr 1588(ra) # 4904 <exit>
+ printf("pipe() failed in countfree()\n");
+ 42d8: 00002517 auipc a0,0x2
+ 42dc: 5a050513 addi a0,a0,1440 # 6878 <malloc+0x1af8>
+ 42e0: 00001097 auipc ra,0x1
+ 42e4: 9e8080e7 jalr -1560(ra) # 4cc8 <printf>
+ exit(1);
+ 42e8: 4505 li a0,1
+ 42ea: 00000097 auipc ra,0x0
+ 42ee: 61a080e7 jalr 1562(ra) # 4904 <exit>
+ printf("fork failed in countfree()\n");
+ 42f2: 00002517 auipc a0,0x2
+ 42f6: 5a650513 addi a0,a0,1446 # 6898 <malloc+0x1b18>
+ 42fa: 00001097 auipc ra,0x1
+ 42fe: 9ce080e7 jalr -1586(ra) # 4cc8 <printf>
+ exit(1);
+ 4302: 4505 li a0,1
+ 4304: 00000097 auipc ra,0x0
+ 4308: 600080e7 jalr 1536(ra) # 4904 <exit>
+ }
+ }
+
+ exit(0);
+ 430c: 4501 li a0,0
+ 430e: 00000097 auipc ra,0x0
+ 4312: 5f6080e7 jalr 1526(ra) # 4904 <exit>
+ }
+
+ close(fds[1]);
+ 4316: fcc42503 lw a0,-52(s0)
+ 431a: 00000097 auipc ra,0x0
+ 431e: 61a080e7 jalr 1562(ra) # 4934 <close>
+
+ int n = 0;
+ 4322: 4481 li s1,0
+ while(1){
+ char c;
+ int cc = read(fds[0], &c, 1);
+ 4324: fc740913 addi s2,s0,-57
+ 4328: 4605 li a2,1
+ 432a: 85ca mv a1,s2
+ 432c: fc842503 lw a0,-56(s0)
+ 4330: 00000097 auipc ra,0x0
+ 4334: 5f0080e7 jalr 1520(ra) # 4920 <read>
+ if(cc < 0){
+ 4338: 00054563 bltz a0,4342 <countfree+0xf2>
+ printf("read() failed in countfree()\n");
+ exit(1);
+ }
+ if(cc == 0)
+ 433c: c105 beqz a0,435c <countfree+0x10c>
+ break;
+ n += 1;
+ 433e: 2485 addiw s1,s1,1
+ while(1){
+ 4340: b7e5 j 4328 <countfree+0xd8>
+ printf("read() failed in countfree()\n");
+ 4342: 00002517 auipc a0,0x2
+ 4346: 59650513 addi a0,a0,1430 # 68d8 <malloc+0x1b58>
+ 434a: 00001097 auipc ra,0x1
+ 434e: 97e080e7 jalr -1666(ra) # 4cc8 <printf>
+ exit(1);
+ 4352: 4505 li a0,1
+ 4354: 00000097 auipc ra,0x0
+ 4358: 5b0080e7 jalr 1456(ra) # 4904 <exit>
+ }
+
+ close(fds[0]);
+ 435c: fc842503 lw a0,-56(s0)
+ 4360: 00000097 auipc ra,0x0
+ 4364: 5d4080e7 jalr 1492(ra) # 4934 <close>
+ wait((int*)0);
+ 4368: 4501 li a0,0
+ 436a: 00000097 auipc ra,0x0
+ 436e: 5a4080e7 jalr 1444(ra) # 490e <wait>
+
+ return n;
+}
+ 4372: 8526 mv a0,s1
+ 4374: 70e2 ld ra,56(sp)
+ 4376: 7442 ld s0,48(sp)
+ 4378: 74a2 ld s1,40(sp)
+ 437a: 7902 ld s2,32(sp)
+ 437c: 69e2 ld s3,24(sp)
+ 437e: 6121 addi sp,sp,64
+ 4380: 8082 ret
+
+0000000000004382 <run>:
+
+// run each test in its own process. run returns 1 if child's exit()
+// indicates success.
+int
+run(void f(char *), char *s) {
+ 4382: 7179 addi sp,sp,-48
+ 4384: f406 sd ra,40(sp)
+ 4386: f022 sd s0,32(sp)
+ 4388: ec26 sd s1,24(sp)
+ 438a: e84a sd s2,16(sp)
+ 438c: 1800 addi s0,sp,48
+ 438e: 84aa mv s1,a0
+ 4390: 892e mv s2,a1
+ int pid;
+ int xstatus;
+
+ printf("test %s: ", s);
+ 4392: 00002517 auipc a0,0x2
+ 4396: 56650513 addi a0,a0,1382 # 68f8 <malloc+0x1b78>
+ 439a: 00001097 auipc ra,0x1
+ 439e: 92e080e7 jalr -1746(ra) # 4cc8 <printf>
+ if((pid = fork()) < 0) {
+ 43a2: 00000097 auipc ra,0x0
+ 43a6: 55a080e7 jalr 1370(ra) # 48fc <fork>
+ 43aa: 02054e63 bltz a0,43e6 <run+0x64>
+ printf("runtest: fork error\n");
+ exit(1);
+ }
+ if(pid == 0) {
+ 43ae: c929 beqz a0,4400 <run+0x7e>
+ f(s);
+ exit(0);
+ } else {
+ wait(&xstatus);
+ 43b0: fdc40513 addi a0,s0,-36
+ 43b4: 00000097 auipc ra,0x0
+ 43b8: 55a080e7 jalr 1370(ra) # 490e <wait>
+ if(xstatus != 0)
+ 43bc: fdc42783 lw a5,-36(s0)
+ 43c0: c7b9 beqz a5,440e <run+0x8c>
+ printf("FAILED\n");
+ 43c2: 00002517 auipc a0,0x2
+ 43c6: 55e50513 addi a0,a0,1374 # 6920 <malloc+0x1ba0>
+ 43ca: 00001097 auipc ra,0x1
+ 43ce: 8fe080e7 jalr -1794(ra) # 4cc8 <printf>
+ else
+ printf("OK\n");
+ return xstatus == 0;
+ 43d2: fdc42503 lw a0,-36(s0)
+ }
+}
+ 43d6: 00153513 seqz a0,a0
+ 43da: 70a2 ld ra,40(sp)
+ 43dc: 7402 ld s0,32(sp)
+ 43de: 64e2 ld s1,24(sp)
+ 43e0: 6942 ld s2,16(sp)
+ 43e2: 6145 addi sp,sp,48
+ 43e4: 8082 ret
+ printf("runtest: fork error\n");
+ 43e6: 00002517 auipc a0,0x2
+ 43ea: 52250513 addi a0,a0,1314 # 6908 <malloc+0x1b88>
+ 43ee: 00001097 auipc ra,0x1
+ 43f2: 8da080e7 jalr -1830(ra) # 4cc8 <printf>
+ exit(1);
+ 43f6: 4505 li a0,1
+ 43f8: 00000097 auipc ra,0x0
+ 43fc: 50c080e7 jalr 1292(ra) # 4904 <exit>
+ f(s);
+ 4400: 854a mv a0,s2
+ 4402: 9482 jalr s1
+ exit(0);
+ 4404: 4501 li a0,0
+ 4406: 00000097 auipc ra,0x0
+ 440a: 4fe080e7 jalr 1278(ra) # 4904 <exit>
+ printf("OK\n");
+ 440e: 00002517 auipc a0,0x2
+ 4412: 51a50513 addi a0,a0,1306 # 6928 <malloc+0x1ba8>
+ 4416: 00001097 auipc ra,0x1
+ 441a: 8b2080e7 jalr -1870(ra) # 4cc8 <printf>
+ 441e: bf55 j 43d2 <run+0x50>
+
+0000000000004420 <main>:
+
+int
+main(int argc, char *argv[])
+{
+ 4420: c8010113 addi sp,sp,-896
+ 4424: 36113c23 sd ra,888(sp)
+ 4428: 36813823 sd s0,880(sp)
+ 442c: 36913423 sd s1,872(sp)
+ 4430: 37213023 sd s2,864(sp)
+ 4434: 35313c23 sd s3,856(sp)
+ 4438: 35413823 sd s4,848(sp)
+ 443c: 35513423 sd s5,840(sp)
+ 4440: 35613023 sd s6,832(sp)
+ 4444: 0700 addi s0,sp,896
+ 4446: 89aa mv s3,a0
+ int continuous = 0;
+ char *justone = 0;
+
+ if(argc == 2 && strcmp(argv[1], "-c") == 0){
+ 4448: 4789 li a5,2
+ 444a: 08f50763 beq a0,a5,44d8 <main+0xb8>
+ continuous = 1;
+ } else if(argc == 2 && strcmp(argv[1], "-C") == 0){
+ continuous = 2;
+ } else if(argc == 2 && argv[1][0] != '-'){
+ justone = argv[1];
+ } else if(argc > 1){
+ 444e: 4785 li a5,1
+ char *justone = 0;
+ 4450: 4901 li s2,0
+ } else if(argc > 1){
+ 4452: 0ca7c163 blt a5,a0,4514 <main+0xf4>
+ }
+
+ struct test {
+ void (*f)(char *);
+ char *s;
+ } tests[] = {
+ 4456: 00003797 auipc a5,0x3
+ 445a: 8e278793 addi a5,a5,-1822 # 6d38 <randstate+0x8>
+ 445e: c8040713 addi a4,s0,-896
+ 4462: 00003817 auipc a6,0x3
+ 4466: c1680813 addi a6,a6,-1002 # 7078 <name>
+ 446a: 6388 ld a0,0(a5)
+ 446c: 678c ld a1,8(a5)
+ 446e: 6b90 ld a2,16(a5)
+ 4470: 6f94 ld a3,24(a5)
+ 4472: e308 sd a0,0(a4)
+ 4474: e70c sd a1,8(a4)
+ 4476: eb10 sd a2,16(a4)
+ 4478: ef14 sd a3,24(a4)
+ 447a: 02078793 addi a5,a5,32
+ 447e: 02070713 addi a4,a4,32
+ 4482: ff0794e3 bne a5,a6,446a <main+0x4a>
+ exit(1);
+ }
+ }
+ }
+
+ printf("usertests starting\n");
+ 4486: 00002517 auipc a0,0x2
+ 448a: 55a50513 addi a0,a0,1370 # 69e0 <malloc+0x1c60>
+ 448e: 00001097 auipc ra,0x1
+ 4492: 83a080e7 jalr -1990(ra) # 4cc8 <printf>
+ int free0 = countfree();
+ 4496: 00000097 auipc ra,0x0
+ 449a: dba080e7 jalr -582(ra) # 4250 <countfree>
+ 449e: 8a2a mv s4,a0
+ int free1 = 0;
+ int fail = 0;
+ for (struct test *t = tests; t->s != 0; t++) {
+ 44a0: c8843503 ld a0,-888(s0)
+ 44a4: c8040493 addi s1,s0,-896
+ int fail = 0;
+ 44a8: 4981 li s3,0
+ if((justone == 0) || strcmp(t->s, justone) == 0) {
+ if(!run(t->f, t->s))
+ fail = 1;
+ 44aa: 4a85 li s5,1
+ for (struct test *t = tests; t->s != 0; t++) {
+ 44ac: e55d bnez a0,455a <main+0x13a>
+ }
+
+ if(fail){
+ printf("SOME TESTS FAILED\n");
+ exit(1);
+ } else if((free1 = countfree()) < free0){
+ 44ae: 00000097 auipc ra,0x0
+ 44b2: da2080e7 jalr -606(ra) # 4250 <countfree>
+ 44b6: 85aa mv a1,a0
+ 44b8: 0f455163 bge a0,s4,459a <main+0x17a>
+ printf("FAILED -- lost some free pages %d (out of %d)\n", free1, free0);
+ 44bc: 8652 mv a2,s4
+ 44be: 00002517 auipc a0,0x2
+ 44c2: 4da50513 addi a0,a0,1242 # 6998 <malloc+0x1c18>
+ 44c6: 00001097 auipc ra,0x1
+ 44ca: 802080e7 jalr -2046(ra) # 4cc8 <printf>
+ exit(1);
+ 44ce: 4505 li a0,1
+ 44d0: 00000097 auipc ra,0x0
+ 44d4: 434080e7 jalr 1076(ra) # 4904 <exit>
+ 44d8: 84ae mv s1,a1
+ if(argc == 2 && strcmp(argv[1], "-c") == 0){
+ 44da: 00002597 auipc a1,0x2
+ 44de: 45658593 addi a1,a1,1110 # 6930 <malloc+0x1bb0>
+ 44e2: 6488 ld a0,8(s1)
+ 44e4: 00000097 auipc ra,0x0
+ 44e8: 1b2080e7 jalr 434(ra) # 4696 <strcmp>
+ 44ec: 10050563 beqz a0,45f6 <main+0x1d6>
+ } else if(argc == 2 && strcmp(argv[1], "-C") == 0){
+ 44f0: 00002597 auipc a1,0x2
+ 44f4: 52858593 addi a1,a1,1320 # 6a18 <malloc+0x1c98>
+ 44f8: 6488 ld a0,8(s1)
+ 44fa: 00000097 auipc ra,0x0
+ 44fe: 19c080e7 jalr 412(ra) # 4696 <strcmp>
+ 4502: c97d beqz a0,45f8 <main+0x1d8>
+ } else if(argc == 2 && argv[1][0] != '-'){
+ 4504: 0084b903 ld s2,8(s1)
+ 4508: 00094703 lbu a4,0(s2)
+ 450c: 02d00793 li a5,45
+ 4510: f4f713e3 bne a4,a5,4456 <main+0x36>
+ printf("Usage: usertests [-c] [testname]\n");
+ 4514: 00002517 auipc a0,0x2
+ 4518: 42450513 addi a0,a0,1060 # 6938 <malloc+0x1bb8>
+ 451c: 00000097 auipc ra,0x0
+ 4520: 7ac080e7 jalr 1964(ra) # 4cc8 <printf>
+ exit(1);
+ 4524: 4505 li a0,1
+ 4526: 00000097 auipc ra,0x0
+ 452a: 3de080e7 jalr 990(ra) # 4904 <exit>
+ exit(1);
+ 452e: 4505 li a0,1
+ 4530: 00000097 auipc ra,0x0
+ 4534: 3d4080e7 jalr 980(ra) # 4904 <exit>
+ printf("FAILED -- lost %d free pages\n", free0 - free1);
+ 4538: 40a905bb subw a1,s2,a0
+ 453c: 855a mv a0,s6
+ 453e: 00000097 auipc ra,0x0
+ 4542: 78a080e7 jalr 1930(ra) # 4cc8 <printf>
+ if(continuous != 2)
+ 4546: 09498463 beq s3,s4,45ce <main+0x1ae>
+ exit(1);
+ 454a: 4505 li a0,1
+ 454c: 00000097 auipc ra,0x0
+ 4550: 3b8080e7 jalr 952(ra) # 4904 <exit>
+ for (struct test *t = tests; t->s != 0; t++) {
+ 4554: 04c1 addi s1,s1,16
+ 4556: 6488 ld a0,8(s1)
+ 4558: c115 beqz a0,457c <main+0x15c>
+ if((justone == 0) || strcmp(t->s, justone) == 0) {
+ 455a: 00090863 beqz s2,456a <main+0x14a>
+ 455e: 85ca mv a1,s2
+ 4560: 00000097 auipc ra,0x0
+ 4564: 136080e7 jalr 310(ra) # 4696 <strcmp>
+ 4568: f575 bnez a0,4554 <main+0x134>
+ if(!run(t->f, t->s))
+ 456a: 648c ld a1,8(s1)
+ 456c: 6088 ld a0,0(s1)
+ 456e: 00000097 auipc ra,0x0
+ 4572: e14080e7 jalr -492(ra) # 4382 <run>
+ 4576: fd79 bnez a0,4554 <main+0x134>
+ fail = 1;
+ 4578: 89d6 mv s3,s5
+ 457a: bfe9 j 4554 <main+0x134>
+ if(fail){
+ 457c: f20989e3 beqz s3,44ae <main+0x8e>
+ printf("SOME TESTS FAILED\n");
+ 4580: 00002517 auipc a0,0x2
+ 4584: 40050513 addi a0,a0,1024 # 6980 <malloc+0x1c00>
+ 4588: 00000097 auipc ra,0x0
+ 458c: 740080e7 jalr 1856(ra) # 4cc8 <printf>
+ exit(1);
+ 4590: 4505 li a0,1
+ 4592: 00000097 auipc ra,0x0
+ 4596: 372080e7 jalr 882(ra) # 4904 <exit>
+ } else {
+ printf("ALL TESTS PASSED\n");
+ 459a: 00002517 auipc a0,0x2
+ 459e: 42e50513 addi a0,a0,1070 # 69c8 <malloc+0x1c48>
+ 45a2: 00000097 auipc ra,0x0
+ 45a6: 726080e7 jalr 1830(ra) # 4cc8 <printf>
+ exit(0);
+ 45aa: 4501 li a0,0
+ 45ac: 00000097 auipc ra,0x0
+ 45b0: 358080e7 jalr 856(ra) # 4904 <exit>
+ printf("SOME TESTS FAILED\n");
+ 45b4: 8556 mv a0,s5
+ 45b6: 00000097 auipc ra,0x0
+ 45ba: 712080e7 jalr 1810(ra) # 4cc8 <printf>
+ if(continuous != 2)
+ 45be: f74998e3 bne s3,s4,452e <main+0x10e>
+ int free1 = countfree();
+ 45c2: 00000097 auipc ra,0x0
+ 45c6: c8e080e7 jalr -882(ra) # 4250 <countfree>
+ if(free1 < free0){
+ 45ca: f72547e3 blt a0,s2,4538 <main+0x118>
+ int free0 = countfree();
+ 45ce: 00000097 auipc ra,0x0
+ 45d2: c82080e7 jalr -894(ra) # 4250 <countfree>
+ 45d6: 892a mv s2,a0
+ for (struct test *t = tests; t->s != 0; t++) {
+ 45d8: c8843583 ld a1,-888(s0)
+ 45dc: d1fd beqz a1,45c2 <main+0x1a2>
+ 45de: c8040493 addi s1,s0,-896
+ if(!run(t->f, t->s)){
+ 45e2: 6088 ld a0,0(s1)
+ 45e4: 00000097 auipc ra,0x0
+ 45e8: d9e080e7 jalr -610(ra) # 4382 <run>
+ 45ec: d561 beqz a0,45b4 <main+0x194>
+ for (struct test *t = tests; t->s != 0; t++) {
+ 45ee: 04c1 addi s1,s1,16
+ 45f0: 648c ld a1,8(s1)
+ 45f2: f9e5 bnez a1,45e2 <main+0x1c2>
+ 45f4: b7f9 j 45c2 <main+0x1a2>
+ continuous = 1;
+ 45f6: 4985 li s3,1
+ } tests[] = {
+ 45f8: 00002797 auipc a5,0x2
+ 45fc: 74078793 addi a5,a5,1856 # 6d38 <randstate+0x8>
+ 4600: c8040713 addi a4,s0,-896
+ 4604: 00003817 auipc a6,0x3
+ 4608: a7480813 addi a6,a6,-1420 # 7078 <name>
+ 460c: 6388 ld a0,0(a5)
+ 460e: 678c ld a1,8(a5)
+ 4610: 6b90 ld a2,16(a5)
+ 4612: 6f94 ld a3,24(a5)
+ 4614: e308 sd a0,0(a4)
+ 4616: e70c sd a1,8(a4)
+ 4618: eb10 sd a2,16(a4)
+ 461a: ef14 sd a3,24(a4)
+ 461c: 02078793 addi a5,a5,32
+ 4620: 02070713 addi a4,a4,32
+ 4624: ff0794e3 bne a5,a6,460c <main+0x1ec>
+ printf("continuous usertests starting\n");
+ 4628: 00002517 auipc a0,0x2
+ 462c: 3d050513 addi a0,a0,976 # 69f8 <malloc+0x1c78>
+ 4630: 00000097 auipc ra,0x0
+ 4634: 698080e7 jalr 1688(ra) # 4cc8 <printf>
+ printf("SOME TESTS FAILED\n");
+ 4638: 00002a97 auipc s5,0x2
+ 463c: 348a8a93 addi s5,s5,840 # 6980 <malloc+0x1c00>
+ if(continuous != 2)
+ 4640: 4a09 li s4,2
+ printf("FAILED -- lost %d free pages\n", free0 - free1);
+ 4642: 00002b17 auipc s6,0x2
+ 4646: 31eb0b13 addi s6,s6,798 # 6960 <malloc+0x1be0>
+ 464a: b751 j 45ce <main+0x1ae>
+
+000000000000464c <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 464c: 1141 addi sp,sp,-16
+ 464e: e422 sd s0,8(sp)
+ 4650: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 4652: 87aa mv a5,a0
+ 4654: 0585 addi a1,a1,1
+ 4656: 0785 addi a5,a5,1
+ 4658: fff5c703 lbu a4,-1(a1)
+ 465c: fee78fa3 sb a4,-1(a5)
+ 4660: fb75 bnez a4,4654 <strcpy+0x8>
+ ;
+ return os;
+}
+ 4662: 6422 ld s0,8(sp)
+ 4664: 0141 addi sp,sp,16
+ 4666: 8082 ret
+
+0000000000004668 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 4668: 1141 addi sp,sp,-16
+ 466a: e422 sd s0,8(sp)
+ 466c: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 466e: 00054783 lbu a5,0(a0)
+ 4672: c385 beqz a5,4692 <strcat+0x2a>
+ 4674: 87aa mv a5,a0
+ s++;
+ 4676: 0785 addi a5,a5,1
+ while(*s)
+ 4678: 0007c703 lbu a4,0(a5)
+ 467c: ff6d bnez a4,4676 <strcat+0xe>
+ while((*s++ = *t++))
+ 467e: 0585 addi a1,a1,1
+ 4680: 0785 addi a5,a5,1
+ 4682: fff5c703 lbu a4,-1(a1)
+ 4686: fee78fa3 sb a4,-1(a5)
+ 468a: fb75 bnez a4,467e <strcat+0x16>
+ ;
+ return os;
+}
+ 468c: 6422 ld s0,8(sp)
+ 468e: 0141 addi sp,sp,16
+ 4690: 8082 ret
+ while(*s)
+ 4692: 87aa mv a5,a0
+ 4694: b7ed j 467e <strcat+0x16>
+
+0000000000004696 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 4696: 1141 addi sp,sp,-16
+ 4698: e422 sd s0,8(sp)
+ 469a: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 469c: 00054783 lbu a5,0(a0)
+ 46a0: cb91 beqz a5,46b4 <strcmp+0x1e>
+ 46a2: 0005c703 lbu a4,0(a1)
+ 46a6: 00f71763 bne a4,a5,46b4 <strcmp+0x1e>
+ p++, q++;
+ 46aa: 0505 addi a0,a0,1
+ 46ac: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 46ae: 00054783 lbu a5,0(a0)
+ 46b2: fbe5 bnez a5,46a2 <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 46b4: 0005c503 lbu a0,0(a1)
+}
+ 46b8: 40a7853b subw a0,a5,a0
+ 46bc: 6422 ld s0,8(sp)
+ 46be: 0141 addi sp,sp,16
+ 46c0: 8082 ret
+
+00000000000046c2 <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 46c2: 1141 addi sp,sp,-16
+ 46c4: e422 sd s0,8(sp)
+ 46c6: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 46c8: 00054783 lbu a5,0(a0)
+ 46cc: cf91 beqz a5,46e8 <strlen+0x26>
+ 46ce: 0505 addi a0,a0,1
+ 46d0: 87aa mv a5,a0
+ 46d2: 4685 li a3,1
+ 46d4: 9e89 subw a3,a3,a0
+ 46d6: 00f6853b addw a0,a3,a5
+ 46da: 0785 addi a5,a5,1
+ 46dc: fff7c703 lbu a4,-1(a5)
+ 46e0: fb7d bnez a4,46d6 <strlen+0x14>
+ ;
+ return n;
+}
+ 46e2: 6422 ld s0,8(sp)
+ 46e4: 0141 addi sp,sp,16
+ 46e6: 8082 ret
+ for(n = 0; s[n]; n++)
+ 46e8: 4501 li a0,0
+ 46ea: bfe5 j 46e2 <strlen+0x20>
+
+00000000000046ec <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 46ec: 1141 addi sp,sp,-16
+ 46ee: e422 sd s0,8(sp)
+ 46f0: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 46f2: ca19 beqz a2,4708 <memset+0x1c>
+ 46f4: 87aa mv a5,a0
+ 46f6: 1602 slli a2,a2,0x20
+ 46f8: 9201 srli a2,a2,0x20
+ 46fa: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 46fe: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 4702: 0785 addi a5,a5,1
+ 4704: fee79de3 bne a5,a4,46fe <memset+0x12>
+ }
+ return dst;
+}
+ 4708: 6422 ld s0,8(sp)
+ 470a: 0141 addi sp,sp,16
+ 470c: 8082 ret
+
+000000000000470e <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 470e: 1141 addi sp,sp,-16
+ 4710: e422 sd s0,8(sp)
+ 4712: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 4714: 00054783 lbu a5,0(a0)
+ 4718: cb99 beqz a5,472e <strchr+0x20>
+ if(*s == c)
+ 471a: 00f58763 beq a1,a5,4728 <strchr+0x1a>
+ for(; *s; s++)
+ 471e: 0505 addi a0,a0,1
+ 4720: 00054783 lbu a5,0(a0)
+ 4724: fbfd bnez a5,471a <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 4726: 4501 li a0,0
+}
+ 4728: 6422 ld s0,8(sp)
+ 472a: 0141 addi sp,sp,16
+ 472c: 8082 ret
+ return 0;
+ 472e: 4501 li a0,0
+ 4730: bfe5 j 4728 <strchr+0x1a>
+
+0000000000004732 <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 4732: 711d addi sp,sp,-96
+ 4734: ec86 sd ra,88(sp)
+ 4736: e8a2 sd s0,80(sp)
+ 4738: e4a6 sd s1,72(sp)
+ 473a: e0ca sd s2,64(sp)
+ 473c: fc4e sd s3,56(sp)
+ 473e: f852 sd s4,48(sp)
+ 4740: f456 sd s5,40(sp)
+ 4742: f05a sd s6,32(sp)
+ 4744: ec5e sd s7,24(sp)
+ 4746: e862 sd s8,16(sp)
+ 4748: 1080 addi s0,sp,96
+ 474a: 8baa mv s7,a0
+ 474c: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 474e: 892a mv s2,a0
+ 4750: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 4752: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 4756: 4b29 li s6,10
+ 4758: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 475a: 89a6 mv s3,s1
+ 475c: 2485 addiw s1,s1,1
+ 475e: 0344d763 bge s1,s4,478c <gets+0x5a>
+ cc = read(0, &c, 1);
+ 4762: 4605 li a2,1
+ 4764: 85d6 mv a1,s5
+ 4766: 4501 li a0,0
+ 4768: 00000097 auipc ra,0x0
+ 476c: 1b8080e7 jalr 440(ra) # 4920 <read>
+ if(cc < 1)
+ 4770: 00a05e63 blez a0,478c <gets+0x5a>
+ buf[i++] = c;
+ 4774: faf44783 lbu a5,-81(s0)
+ 4778: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 477c: 01678763 beq a5,s6,478a <gets+0x58>
+ 4780: 0905 addi s2,s2,1
+ 4782: fd879ce3 bne a5,s8,475a <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 4786: 89a6 mv s3,s1
+ 4788: a011 j 478c <gets+0x5a>
+ 478a: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 478c: 99de add s3,s3,s7
+ 478e: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 4792: 855e mv a0,s7
+ 4794: 60e6 ld ra,88(sp)
+ 4796: 6446 ld s0,80(sp)
+ 4798: 64a6 ld s1,72(sp)
+ 479a: 6906 ld s2,64(sp)
+ 479c: 79e2 ld s3,56(sp)
+ 479e: 7a42 ld s4,48(sp)
+ 47a0: 7aa2 ld s5,40(sp)
+ 47a2: 7b02 ld s6,32(sp)
+ 47a4: 6be2 ld s7,24(sp)
+ 47a6: 6c42 ld s8,16(sp)
+ 47a8: 6125 addi sp,sp,96
+ 47aa: 8082 ret
+
+00000000000047ac <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 47ac: 1101 addi sp,sp,-32
+ 47ae: ec06 sd ra,24(sp)
+ 47b0: e822 sd s0,16(sp)
+ 47b2: e426 sd s1,8(sp)
+ 47b4: e04a sd s2,0(sp)
+ 47b6: 1000 addi s0,sp,32
+ 47b8: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 47ba: 4581 li a1,0
+ 47bc: 00000097 auipc ra,0x0
+ 47c0: 194080e7 jalr 404(ra) # 4950 <open>
+ if(fd < 0)
+ 47c4: 02054563 bltz a0,47ee <stat+0x42>
+ 47c8: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 47ca: 85ca mv a1,s2
+ 47cc: 00000097 auipc ra,0x0
+ 47d0: 18e080e7 jalr 398(ra) # 495a <fstat>
+ 47d4: 892a mv s2,a0
+ close(fd);
+ 47d6: 8526 mv a0,s1
+ 47d8: 00000097 auipc ra,0x0
+ 47dc: 15c080e7 jalr 348(ra) # 4934 <close>
+ return r;
+}
+ 47e0: 854a mv a0,s2
+ 47e2: 60e2 ld ra,24(sp)
+ 47e4: 6442 ld s0,16(sp)
+ 47e6: 64a2 ld s1,8(sp)
+ 47e8: 6902 ld s2,0(sp)
+ 47ea: 6105 addi sp,sp,32
+ 47ec: 8082 ret
+ return -1;
+ 47ee: 597d li s2,-1
+ 47f0: bfc5 j 47e0 <stat+0x34>
+
+00000000000047f2 <atoi>:
+
+int
+atoi(const char *s)
+{
+ 47f2: 1141 addi sp,sp,-16
+ 47f4: e422 sd s0,8(sp)
+ 47f6: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 47f8: 00054703 lbu a4,0(a0)
+ 47fc: 02d00793 li a5,45
+ int neg = 1;
+ 4800: 4585 li a1,1
+ if (*s == '-') {
+ 4802: 04f70363 beq a4,a5,4848 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 4806: 00054703 lbu a4,0(a0)
+ 480a: fd07079b addiw a5,a4,-48
+ 480e: 0ff7f793 zext.b a5,a5
+ 4812: 46a5 li a3,9
+ 4814: 02f6ed63 bltu a3,a5,484e <atoi+0x5c>
+ n = 0;
+ 4818: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 481a: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 481c: 0505 addi a0,a0,1
+ 481e: 0026979b slliw a5,a3,0x2
+ 4822: 9fb5 addw a5,a5,a3
+ 4824: 0017979b slliw a5,a5,0x1
+ 4828: 9fb9 addw a5,a5,a4
+ 482a: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 482e: 00054703 lbu a4,0(a0)
+ 4832: fd07079b addiw a5,a4,-48
+ 4836: 0ff7f793 zext.b a5,a5
+ 483a: fef671e3 bgeu a2,a5,481c <atoi+0x2a>
+ return n * neg;
+}
+ 483e: 02d5853b mulw a0,a1,a3
+ 4842: 6422 ld s0,8(sp)
+ 4844: 0141 addi sp,sp,16
+ 4846: 8082 ret
+ s++;
+ 4848: 0505 addi a0,a0,1
+ neg = -1;
+ 484a: 55fd li a1,-1
+ 484c: bf6d j 4806 <atoi+0x14>
+ n = 0;
+ 484e: 4681 li a3,0
+ 4850: b7fd j 483e <atoi+0x4c>
+
+0000000000004852 <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 4852: 1141 addi sp,sp,-16
+ 4854: e422 sd s0,8(sp)
+ 4856: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 4858: 02b57463 bgeu a0,a1,4880 <memmove+0x2e>
+ while(n-- > 0)
+ 485c: 00c05f63 blez a2,487a <memmove+0x28>
+ 4860: 1602 slli a2,a2,0x20
+ 4862: 9201 srli a2,a2,0x20
+ 4864: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 4868: 872a mv a4,a0
+ *dst++ = *src++;
+ 486a: 0585 addi a1,a1,1
+ 486c: 0705 addi a4,a4,1
+ 486e: fff5c683 lbu a3,-1(a1)
+ 4872: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 4876: fee79ae3 bne a5,a4,486a <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 487a: 6422 ld s0,8(sp)
+ 487c: 0141 addi sp,sp,16
+ 487e: 8082 ret
+ dst += n;
+ 4880: 00c50733 add a4,a0,a2
+ src += n;
+ 4884: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 4886: fec05ae3 blez a2,487a <memmove+0x28>
+ 488a: fff6079b addiw a5,a2,-1
+ 488e: 1782 slli a5,a5,0x20
+ 4890: 9381 srli a5,a5,0x20
+ 4892: fff7c793 not a5,a5
+ 4896: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 4898: 15fd addi a1,a1,-1
+ 489a: 177d addi a4,a4,-1
+ 489c: 0005c683 lbu a3,0(a1)
+ 48a0: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 48a4: fee79ae3 bne a5,a4,4898 <memmove+0x46>
+ 48a8: bfc9 j 487a <memmove+0x28>
+
+00000000000048aa <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 48aa: 1141 addi sp,sp,-16
+ 48ac: e422 sd s0,8(sp)
+ 48ae: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 48b0: ca05 beqz a2,48e0 <memcmp+0x36>
+ 48b2: fff6069b addiw a3,a2,-1
+ 48b6: 1682 slli a3,a3,0x20
+ 48b8: 9281 srli a3,a3,0x20
+ 48ba: 0685 addi a3,a3,1
+ 48bc: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 48be: 00054783 lbu a5,0(a0)
+ 48c2: 0005c703 lbu a4,0(a1)
+ 48c6: 00e79863 bne a5,a4,48d6 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 48ca: 0505 addi a0,a0,1
+ p2++;
+ 48cc: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 48ce: fed518e3 bne a0,a3,48be <memcmp+0x14>
+ }
+ return 0;
+ 48d2: 4501 li a0,0
+ 48d4: a019 j 48da <memcmp+0x30>
+ return *p1 - *p2;
+ 48d6: 40e7853b subw a0,a5,a4
+}
+ 48da: 6422 ld s0,8(sp)
+ 48dc: 0141 addi sp,sp,16
+ 48de: 8082 ret
+ return 0;
+ 48e0: 4501 li a0,0
+ 48e2: bfe5 j 48da <memcmp+0x30>
+
+00000000000048e4 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 48e4: 1141 addi sp,sp,-16
+ 48e6: e406 sd ra,8(sp)
+ 48e8: e022 sd s0,0(sp)
+ 48ea: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 48ec: 00000097 auipc ra,0x0
+ 48f0: f66080e7 jalr -154(ra) # 4852 <memmove>
+}
+ 48f4: 60a2 ld ra,8(sp)
+ 48f6: 6402 ld s0,0(sp)
+ 48f8: 0141 addi sp,sp,16
+ 48fa: 8082 ret
+
+00000000000048fc <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 48fc: 4885 li a7,1
+ ecall
+ 48fe: 00000073 ecall
+ ret
+ 4902: 8082 ret
+
+0000000000004904 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 4904: 05d00893 li a7,93
+ ecall
+ 4908: 00000073 ecall
+ ret
+ 490c: 8082 ret
+
+000000000000490e <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 490e: 488d li a7,3
+ ecall
+ 4910: 00000073 ecall
+ ret
+ 4914: 8082 ret
+
+0000000000004916 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 4916: 03b00893 li a7,59
+ ecall
+ 491a: 00000073 ecall
+ ret
+ 491e: 8082 ret
+
+0000000000004920 <read>:
+.global read
+read:
+ li a7, SYS_read
+ 4920: 03f00893 li a7,63
+ ecall
+ 4924: 00000073 ecall
+ ret
+ 4928: 8082 ret
+
+000000000000492a <write>:
+.global write
+write:
+ li a7, SYS_write
+ 492a: 04000893 li a7,64
+ ecall
+ 492e: 00000073 ecall
+ ret
+ 4932: 8082 ret
+
+0000000000004934 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 4934: 03900893 li a7,57
+ ecall
+ 4938: 00000073 ecall
+ ret
+ 493c: 8082 ret
+
+000000000000493e <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 493e: 4899 li a7,6
+ ecall
+ 4940: 00000073 ecall
+ ret
+ 4944: 8082 ret
+
+0000000000004946 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 4946: 0dd00893 li a7,221
+ ecall
+ 494a: 00000073 ecall
+ ret
+ 494e: 8082 ret
+
+0000000000004950 <open>:
+.global open
+open:
+ li a7, SYS_open
+ 4950: 03800893 li a7,56
+ ecall
+ 4954: 00000073 ecall
+ ret
+ 4958: 8082 ret
+
+000000000000495a <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 495a: 05000893 li a7,80
+ ecall
+ 495e: 00000073 ecall
+ ret
+ 4962: 8082 ret
+
+0000000000004964 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 4964: 02200893 li a7,34
+ ecall
+ 4968: 00000073 ecall
+ ret
+ 496c: 8082 ret
+
+000000000000496e <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 496e: 03100893 li a7,49
+ ecall
+ 4972: 00000073 ecall
+ ret
+ 4976: 8082 ret
+
+0000000000004978 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 4978: 48dd li a7,23
+ ecall
+ 497a: 00000073 ecall
+ ret
+ 497e: 8082 ret
+
+0000000000004980 <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 4980: 0ac00893 li a7,172
+ ecall
+ 4984: 00000073 ecall
+ ret
+ 4988: 8082 ret
+
+000000000000498a <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 498a: 48b1 li a7,12
+ ecall
+ 498c: 00000073 ecall
+ ret
+ 4990: 8082 ret
+
+0000000000004992 <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 4992: 48b5 li a7,13
+ ecall
+ 4994: 00000073 ecall
+ ret
+ 4998: 8082 ret
+
+000000000000499a <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 499a: 48b9 li a7,14
+ ecall
+ 499c: 00000073 ecall
+ ret
+ 49a0: 8082 ret
+
+00000000000049a2 <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 49a2: 48d9 li a7,22
+ ecall
+ 49a4: 00000073 ecall
+ ret
+ 49a8: 8082 ret
+
+00000000000049aa <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 49aa: 03200893 li a7,50
+ ecall
+ 49ae: 00000073 ecall
+ ret
+ 49b2: 8082 ret
+
+00000000000049b4 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 49b4: 48ed li a7,27
+ ecall
+ 49b6: 00000073 ecall
+ ret
+ 49ba: 8082 ret
+
+00000000000049bc <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 49bc: 48c5 li a7,17
+ ecall
+ 49be: 00000073 ecall
+ ret
+ 49c2: 8082 ret
+
+00000000000049c4 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 49c4: 07500893 li a7,117
+ ecall
+ 49c8: 00000073 ecall
+ ret
+ 49cc: 8082 ret
+
+00000000000049ce <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 49ce: 48c9 li a7,18
+ ecall
+ 49d0: 00000073 ecall
+ ret
+ 49d4: 8082 ret
+
+00000000000049d6 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 49d6: 48cd li a7,19
+ ecall
+ 49d8: 00000073 ecall
+ ret
+ 49dc: 8082 ret
+
+00000000000049de <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 49de: 48e9 li a7,26
+ ecall
+ 49e0: 00000073 ecall
+ ret
+ 49e4: 8082 ret
+
+00000000000049e6 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 49e6: 0d200893 li a7,210
+ ecall
+ 49ea: 00000073 ecall
+ ret
+ 49ee: 8082 ret
+
+00000000000049f0 <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 49f0: 1101 addi sp,sp,-32
+ 49f2: ec06 sd ra,24(sp)
+ 49f4: e822 sd s0,16(sp)
+ 49f6: 1000 addi s0,sp,32
+ 49f8: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 49fc: 4605 li a2,1
+ 49fe: fef40593 addi a1,s0,-17
+ 4a02: 00000097 auipc ra,0x0
+ 4a06: f28080e7 jalr -216(ra) # 492a <write>
+}
+ 4a0a: 60e2 ld ra,24(sp)
+ 4a0c: 6442 ld s0,16(sp)
+ 4a0e: 6105 addi sp,sp,32
+ 4a10: 8082 ret
+
+0000000000004a12 <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 4a12: 7139 addi sp,sp,-64
+ 4a14: fc06 sd ra,56(sp)
+ 4a16: f822 sd s0,48(sp)
+ 4a18: f426 sd s1,40(sp)
+ 4a1a: f04a sd s2,32(sp)
+ 4a1c: ec4e sd s3,24(sp)
+ 4a1e: 0080 addi s0,sp,64
+ 4a20: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 4a22: c299 beqz a3,4a28 <printint+0x16>
+ 4a24: 0805c863 bltz a1,4ab4 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 4a28: 2581 sext.w a1,a1
+ neg = 0;
+ 4a2a: 4881 li a7,0
+ }
+
+ i = 0;
+ 4a2c: fc040993 addi s3,s0,-64
+ neg = 0;
+ 4a30: 86ce mv a3,s3
+ i = 0;
+ 4a32: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 4a34: 2601 sext.w a2,a2
+ 4a36: 00002517 auipc a0,0x2
+ 4a3a: 2c250513 addi a0,a0,706 # 6cf8 <digits>
+ 4a3e: 883a mv a6,a4
+ 4a40: 2705 addiw a4,a4,1
+ 4a42: 02c5f7bb remuw a5,a1,a2
+ 4a46: 1782 slli a5,a5,0x20
+ 4a48: 9381 srli a5,a5,0x20
+ 4a4a: 97aa add a5,a5,a0
+ 4a4c: 0007c783 lbu a5,0(a5)
+ 4a50: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 4a54: 0005879b sext.w a5,a1
+ 4a58: 02c5d5bb divuw a1,a1,a2
+ 4a5c: 0685 addi a3,a3,1
+ 4a5e: fec7f0e3 bgeu a5,a2,4a3e <printint+0x2c>
+ if(neg)
+ 4a62: 00088c63 beqz a7,4a7a <printint+0x68>
+ buf[i++] = '-';
+ 4a66: fd070793 addi a5,a4,-48
+ 4a6a: 00878733 add a4,a5,s0
+ 4a6e: 02d00793 li a5,45
+ 4a72: fef70823 sb a5,-16(a4)
+ 4a76: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 4a7a: 02e05663 blez a4,4aa6 <printint+0x94>
+ 4a7e: fc040913 addi s2,s0,-64
+ 4a82: 993a add s2,s2,a4
+ 4a84: 19fd addi s3,s3,-1
+ 4a86: 99ba add s3,s3,a4
+ 4a88: 377d addiw a4,a4,-1
+ 4a8a: 1702 slli a4,a4,0x20
+ 4a8c: 9301 srli a4,a4,0x20
+ 4a8e: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 4a92: fff94583 lbu a1,-1(s2)
+ 4a96: 8526 mv a0,s1
+ 4a98: 00000097 auipc ra,0x0
+ 4a9c: f58080e7 jalr -168(ra) # 49f0 <putc>
+ while(--i >= 0)
+ 4aa0: 197d addi s2,s2,-1
+ 4aa2: ff3918e3 bne s2,s3,4a92 <printint+0x80>
+}
+ 4aa6: 70e2 ld ra,56(sp)
+ 4aa8: 7442 ld s0,48(sp)
+ 4aaa: 74a2 ld s1,40(sp)
+ 4aac: 7902 ld s2,32(sp)
+ 4aae: 69e2 ld s3,24(sp)
+ 4ab0: 6121 addi sp,sp,64
+ 4ab2: 8082 ret
+ x = -xx;
+ 4ab4: 40b005bb negw a1,a1
+ neg = 1;
+ 4ab8: 4885 li a7,1
+ x = -xx;
+ 4aba: bf8d j 4a2c <printint+0x1a>
+
+0000000000004abc <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 4abc: 7119 addi sp,sp,-128
+ 4abe: fc86 sd ra,120(sp)
+ 4ac0: f8a2 sd s0,112(sp)
+ 4ac2: f4a6 sd s1,104(sp)
+ 4ac4: f0ca sd s2,96(sp)
+ 4ac6: ecce sd s3,88(sp)
+ 4ac8: e8d2 sd s4,80(sp)
+ 4aca: e4d6 sd s5,72(sp)
+ 4acc: e0da sd s6,64(sp)
+ 4ace: fc5e sd s7,56(sp)
+ 4ad0: f862 sd s8,48(sp)
+ 4ad2: f466 sd s9,40(sp)
+ 4ad4: f06a sd s10,32(sp)
+ 4ad6: ec6e sd s11,24(sp)
+ 4ad8: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 4ada: 0005c903 lbu s2,0(a1)
+ 4ade: 18090f63 beqz s2,4c7c <vprintf+0x1c0>
+ 4ae2: 8aaa mv s5,a0
+ 4ae4: 8b32 mv s6,a2
+ 4ae6: 00158493 addi s1,a1,1
+ state = 0;
+ 4aea: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 4aec: 02500a13 li s4,37
+ 4af0: 4c55 li s8,21
+ 4af2: 00002c97 auipc s9,0x2
+ 4af6: 1aec8c93 addi s9,s9,430 # 6ca0 <malloc+0x1f20>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 4afa: 02800d93 li s11,40
+ putc(fd, 'x');
+ 4afe: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 4b00: 00002b97 auipc s7,0x2
+ 4b04: 1f8b8b93 addi s7,s7,504 # 6cf8 <digits>
+ 4b08: a839 j 4b26 <vprintf+0x6a>
+ putc(fd, c);
+ 4b0a: 85ca mv a1,s2
+ 4b0c: 8556 mv a0,s5
+ 4b0e: 00000097 auipc ra,0x0
+ 4b12: ee2080e7 jalr -286(ra) # 49f0 <putc>
+ 4b16: a019 j 4b1c <vprintf+0x60>
+ } else if(state == '%'){
+ 4b18: 01498d63 beq s3,s4,4b32 <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 4b1c: 0485 addi s1,s1,1
+ 4b1e: fff4c903 lbu s2,-1(s1)
+ 4b22: 14090d63 beqz s2,4c7c <vprintf+0x1c0>
+ if(state == 0){
+ 4b26: fe0999e3 bnez s3,4b18 <vprintf+0x5c>
+ if(c == '%'){
+ 4b2a: ff4910e3 bne s2,s4,4b0a <vprintf+0x4e>
+ state = '%';
+ 4b2e: 89d2 mv s3,s4
+ 4b30: b7f5 j 4b1c <vprintf+0x60>
+ if(c == 'd'){
+ 4b32: 11490c63 beq s2,s4,4c4a <vprintf+0x18e>
+ 4b36: f9d9079b addiw a5,s2,-99
+ 4b3a: 0ff7f793 zext.b a5,a5
+ 4b3e: 10fc6e63 bltu s8,a5,4c5a <vprintf+0x19e>
+ 4b42: f9d9079b addiw a5,s2,-99
+ 4b46: 0ff7f713 zext.b a4,a5
+ 4b4a: 10ec6863 bltu s8,a4,4c5a <vprintf+0x19e>
+ 4b4e: 00271793 slli a5,a4,0x2
+ 4b52: 97e6 add a5,a5,s9
+ 4b54: 439c lw a5,0(a5)
+ 4b56: 97e6 add a5,a5,s9
+ 4b58: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 4b5a: 008b0913 addi s2,s6,8
+ 4b5e: 4685 li a3,1
+ 4b60: 4629 li a2,10
+ 4b62: 000b2583 lw a1,0(s6)
+ 4b66: 8556 mv a0,s5
+ 4b68: 00000097 auipc ra,0x0
+ 4b6c: eaa080e7 jalr -342(ra) # 4a12 <printint>
+ 4b70: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 4b72: 4981 li s3,0
+ 4b74: b765 j 4b1c <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 4b76: 008b0913 addi s2,s6,8
+ 4b7a: 4681 li a3,0
+ 4b7c: 4629 li a2,10
+ 4b7e: 000b2583 lw a1,0(s6)
+ 4b82: 8556 mv a0,s5
+ 4b84: 00000097 auipc ra,0x0
+ 4b88: e8e080e7 jalr -370(ra) # 4a12 <printint>
+ 4b8c: 8b4a mv s6,s2
+ state = 0;
+ 4b8e: 4981 li s3,0
+ 4b90: b771 j 4b1c <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 4b92: 008b0913 addi s2,s6,8
+ 4b96: 4681 li a3,0
+ 4b98: 866a mv a2,s10
+ 4b9a: 000b2583 lw a1,0(s6)
+ 4b9e: 8556 mv a0,s5
+ 4ba0: 00000097 auipc ra,0x0
+ 4ba4: e72080e7 jalr -398(ra) # 4a12 <printint>
+ 4ba8: 8b4a mv s6,s2
+ state = 0;
+ 4baa: 4981 li s3,0
+ 4bac: bf85 j 4b1c <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 4bae: 008b0793 addi a5,s6,8
+ 4bb2: f8f43423 sd a5,-120(s0)
+ 4bb6: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 4bba: 03000593 li a1,48
+ 4bbe: 8556 mv a0,s5
+ 4bc0: 00000097 auipc ra,0x0
+ 4bc4: e30080e7 jalr -464(ra) # 49f0 <putc>
+ putc(fd, 'x');
+ 4bc8: 07800593 li a1,120
+ 4bcc: 8556 mv a0,s5
+ 4bce: 00000097 auipc ra,0x0
+ 4bd2: e22080e7 jalr -478(ra) # 49f0 <putc>
+ 4bd6: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 4bd8: 03c9d793 srli a5,s3,0x3c
+ 4bdc: 97de add a5,a5,s7
+ 4bde: 0007c583 lbu a1,0(a5)
+ 4be2: 8556 mv a0,s5
+ 4be4: 00000097 auipc ra,0x0
+ 4be8: e0c080e7 jalr -500(ra) # 49f0 <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 4bec: 0992 slli s3,s3,0x4
+ 4bee: 397d addiw s2,s2,-1
+ 4bf0: fe0914e3 bnez s2,4bd8 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 4bf4: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 4bf8: 4981 li s3,0
+ 4bfa: b70d j 4b1c <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 4bfc: 008b0913 addi s2,s6,8
+ 4c00: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 4c04: 02098163 beqz s3,4c26 <vprintf+0x16a>
+ while(*s != 0){
+ 4c08: 0009c583 lbu a1,0(s3)
+ 4c0c: c5ad beqz a1,4c76 <vprintf+0x1ba>
+ putc(fd, *s);
+ 4c0e: 8556 mv a0,s5
+ 4c10: 00000097 auipc ra,0x0
+ 4c14: de0080e7 jalr -544(ra) # 49f0 <putc>
+ s++;
+ 4c18: 0985 addi s3,s3,1
+ while(*s != 0){
+ 4c1a: 0009c583 lbu a1,0(s3)
+ 4c1e: f9e5 bnez a1,4c0e <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 4c20: 8b4a mv s6,s2
+ state = 0;
+ 4c22: 4981 li s3,0
+ 4c24: bde5 j 4b1c <vprintf+0x60>
+ s = "(null)";
+ 4c26: 00002997 auipc s3,0x2
+ 4c2a: 07298993 addi s3,s3,114 # 6c98 <malloc+0x1f18>
+ while(*s != 0){
+ 4c2e: 85ee mv a1,s11
+ 4c30: bff9 j 4c0e <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 4c32: 008b0913 addi s2,s6,8
+ 4c36: 000b4583 lbu a1,0(s6)
+ 4c3a: 8556 mv a0,s5
+ 4c3c: 00000097 auipc ra,0x0
+ 4c40: db4080e7 jalr -588(ra) # 49f0 <putc>
+ 4c44: 8b4a mv s6,s2
+ state = 0;
+ 4c46: 4981 li s3,0
+ 4c48: bdd1 j 4b1c <vprintf+0x60>
+ putc(fd, c);
+ 4c4a: 85d2 mv a1,s4
+ 4c4c: 8556 mv a0,s5
+ 4c4e: 00000097 auipc ra,0x0
+ 4c52: da2080e7 jalr -606(ra) # 49f0 <putc>
+ state = 0;
+ 4c56: 4981 li s3,0
+ 4c58: b5d1 j 4b1c <vprintf+0x60>
+ putc(fd, '%');
+ 4c5a: 85d2 mv a1,s4
+ 4c5c: 8556 mv a0,s5
+ 4c5e: 00000097 auipc ra,0x0
+ 4c62: d92080e7 jalr -622(ra) # 49f0 <putc>
+ putc(fd, c);
+ 4c66: 85ca mv a1,s2
+ 4c68: 8556 mv a0,s5
+ 4c6a: 00000097 auipc ra,0x0
+ 4c6e: d86080e7 jalr -634(ra) # 49f0 <putc>
+ state = 0;
+ 4c72: 4981 li s3,0
+ 4c74: b565 j 4b1c <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 4c76: 8b4a mv s6,s2
+ state = 0;
+ 4c78: 4981 li s3,0
+ 4c7a: b54d j 4b1c <vprintf+0x60>
+ }
+ }
+}
+ 4c7c: 70e6 ld ra,120(sp)
+ 4c7e: 7446 ld s0,112(sp)
+ 4c80: 74a6 ld s1,104(sp)
+ 4c82: 7906 ld s2,96(sp)
+ 4c84: 69e6 ld s3,88(sp)
+ 4c86: 6a46 ld s4,80(sp)
+ 4c88: 6aa6 ld s5,72(sp)
+ 4c8a: 6b06 ld s6,64(sp)
+ 4c8c: 7be2 ld s7,56(sp)
+ 4c8e: 7c42 ld s8,48(sp)
+ 4c90: 7ca2 ld s9,40(sp)
+ 4c92: 7d02 ld s10,32(sp)
+ 4c94: 6de2 ld s11,24(sp)
+ 4c96: 6109 addi sp,sp,128
+ 4c98: 8082 ret
+
+0000000000004c9a <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 4c9a: 715d addi sp,sp,-80
+ 4c9c: ec06 sd ra,24(sp)
+ 4c9e: e822 sd s0,16(sp)
+ 4ca0: 1000 addi s0,sp,32
+ 4ca2: e010 sd a2,0(s0)
+ 4ca4: e414 sd a3,8(s0)
+ 4ca6: e818 sd a4,16(s0)
+ 4ca8: ec1c sd a5,24(s0)
+ 4caa: 03043023 sd a6,32(s0)
+ 4cae: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 4cb2: 8622 mv a2,s0
+ 4cb4: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 4cb8: 00000097 auipc ra,0x0
+ 4cbc: e04080e7 jalr -508(ra) # 4abc <vprintf>
+}
+ 4cc0: 60e2 ld ra,24(sp)
+ 4cc2: 6442 ld s0,16(sp)
+ 4cc4: 6161 addi sp,sp,80
+ 4cc6: 8082 ret
+
+0000000000004cc8 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 4cc8: 711d addi sp,sp,-96
+ 4cca: ec06 sd ra,24(sp)
+ 4ccc: e822 sd s0,16(sp)
+ 4cce: 1000 addi s0,sp,32
+ 4cd0: e40c sd a1,8(s0)
+ 4cd2: e810 sd a2,16(s0)
+ 4cd4: ec14 sd a3,24(s0)
+ 4cd6: f018 sd a4,32(s0)
+ 4cd8: f41c sd a5,40(s0)
+ 4cda: 03043823 sd a6,48(s0)
+ 4cde: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 4ce2: 00840613 addi a2,s0,8
+ 4ce6: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 4cea: 85aa mv a1,a0
+ 4cec: 4505 li a0,1
+ 4cee: 00000097 auipc ra,0x0
+ 4cf2: dce080e7 jalr -562(ra) # 4abc <vprintf>
+}
+ 4cf6: 60e2 ld ra,24(sp)
+ 4cf8: 6442 ld s0,16(sp)
+ 4cfa: 6125 addi sp,sp,96
+ 4cfc: 8082 ret
+
+0000000000004cfe <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 4cfe: 1141 addi sp,sp,-16
+ 4d00: e422 sd s0,8(sp)
+ 4d02: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 4d04: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 4d08: 00007797 auipc a5,0x7
+ 4d0c: 3907b783 ld a5,912(a5) # c098 <freep>
+ 4d10: a02d j 4d3a <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 4d12: 4618 lw a4,8(a2)
+ 4d14: 9f2d addw a4,a4,a1
+ 4d16: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 4d1a: 6398 ld a4,0(a5)
+ 4d1c: 6310 ld a2,0(a4)
+ 4d1e: a83d j 4d5c <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 4d20: ff852703 lw a4,-8(a0)
+ 4d24: 9f31 addw a4,a4,a2
+ 4d26: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 4d28: ff053683 ld a3,-16(a0)
+ 4d2c: a091 j 4d70 <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 4d2e: 6398 ld a4,0(a5)
+ 4d30: 00e7e463 bltu a5,a4,4d38 <free+0x3a>
+ 4d34: 00e6ea63 bltu a3,a4,4d48 <free+0x4a>
+{
+ 4d38: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 4d3a: fed7fae3 bgeu a5,a3,4d2e <free+0x30>
+ 4d3e: 6398 ld a4,0(a5)
+ 4d40: 00e6e463 bltu a3,a4,4d48 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 4d44: fee7eae3 bltu a5,a4,4d38 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 4d48: ff852583 lw a1,-8(a0)
+ 4d4c: 6390 ld a2,0(a5)
+ 4d4e: 02059813 slli a6,a1,0x20
+ 4d52: 01c85713 srli a4,a6,0x1c
+ 4d56: 9736 add a4,a4,a3
+ 4d58: fae60de3 beq a2,a4,4d12 <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 4d5c: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 4d60: 4790 lw a2,8(a5)
+ 4d62: 02061593 slli a1,a2,0x20
+ 4d66: 01c5d713 srli a4,a1,0x1c
+ 4d6a: 973e add a4,a4,a5
+ 4d6c: fae68ae3 beq a3,a4,4d20 <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 4d70: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 4d72: 00007717 auipc a4,0x7
+ 4d76: 32f73323 sd a5,806(a4) # c098 <freep>
+}
+ 4d7a: 6422 ld s0,8(sp)
+ 4d7c: 0141 addi sp,sp,16
+ 4d7e: 8082 ret
+
+0000000000004d80 <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 4d80: 7139 addi sp,sp,-64
+ 4d82: fc06 sd ra,56(sp)
+ 4d84: f822 sd s0,48(sp)
+ 4d86: f426 sd s1,40(sp)
+ 4d88: f04a sd s2,32(sp)
+ 4d8a: ec4e sd s3,24(sp)
+ 4d8c: e852 sd s4,16(sp)
+ 4d8e: e456 sd s5,8(sp)
+ 4d90: e05a sd s6,0(sp)
+ 4d92: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 4d94: 02051493 slli s1,a0,0x20
+ 4d98: 9081 srli s1,s1,0x20
+ 4d9a: 04bd addi s1,s1,15
+ 4d9c: 8091 srli s1,s1,0x4
+ 4d9e: 00148a1b addiw s4,s1,1
+ 4da2: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 4da4: 00007517 auipc a0,0x7
+ 4da8: 2f453503 ld a0,756(a0) # c098 <freep>
+ 4dac: c515 beqz a0,4dd8 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 4dae: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 4db0: 4798 lw a4,8(a5)
+ 4db2: 04977163 bgeu a4,s1,4df4 <malloc+0x74>
+ 4db6: 89d2 mv s3,s4
+ 4db8: 000a071b sext.w a4,s4
+ 4dbc: 6685 lui a3,0x1
+ 4dbe: 00d77363 bgeu a4,a3,4dc4 <malloc+0x44>
+ 4dc2: 6985 lui s3,0x1
+ 4dc4: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 4dc8: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 4dcc: 00007917 auipc s2,0x7
+ 4dd0: 2cc90913 addi s2,s2,716 # c098 <freep>
+ if(p == (char*)-1)
+ 4dd4: 5afd li s5,-1
+ 4dd6: a8a5 j 4e4e <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 4dd8: 00007797 auipc a5,0x7
+ 4ddc: 2c078793 addi a5,a5,704 # c098 <freep>
+ 4de0: 00007717 auipc a4,0x7
+ 4de4: 2c070713 addi a4,a4,704 # c0a0 <base>
+ 4de8: e398 sd a4,0(a5)
+ 4dea: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 4dec: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 4df0: 87ba mv a5,a4
+ 4df2: b7d1 j 4db6 <malloc+0x36>
+ if(p->s.size == nunits)
+ 4df4: 02e48c63 beq s1,a4,4e2c <malloc+0xac>
+ p->s.size -= nunits;
+ 4df8: 4147073b subw a4,a4,s4
+ 4dfc: c798 sw a4,8(a5)
+ p += p->s.size;
+ 4dfe: 02071693 slli a3,a4,0x20
+ 4e02: 01c6d713 srli a4,a3,0x1c
+ 4e06: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 4e08: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 4e0c: 00007717 auipc a4,0x7
+ 4e10: 28a73623 sd a0,652(a4) # c098 <freep>
+ return (void*)(p + 1);
+ 4e14: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 4e18: 70e2 ld ra,56(sp)
+ 4e1a: 7442 ld s0,48(sp)
+ 4e1c: 74a2 ld s1,40(sp)
+ 4e1e: 7902 ld s2,32(sp)
+ 4e20: 69e2 ld s3,24(sp)
+ 4e22: 6a42 ld s4,16(sp)
+ 4e24: 6aa2 ld s5,8(sp)
+ 4e26: 6b02 ld s6,0(sp)
+ 4e28: 6121 addi sp,sp,64
+ 4e2a: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 4e2c: 6398 ld a4,0(a5)
+ 4e2e: e118 sd a4,0(a0)
+ 4e30: bff1 j 4e0c <malloc+0x8c>
+ hp->s.size = nu;
+ 4e32: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 4e36: 0541 addi a0,a0,16
+ 4e38: 00000097 auipc ra,0x0
+ 4e3c: ec6080e7 jalr -314(ra) # 4cfe <free>
+ return freep;
+ 4e40: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 4e44: d971 beqz a0,4e18 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 4e46: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 4e48: 4798 lw a4,8(a5)
+ 4e4a: fa9775e3 bgeu a4,s1,4df4 <malloc+0x74>
+ if(p == freep)
+ 4e4e: 00093703 ld a4,0(s2)
+ 4e52: 853e mv a0,a5
+ 4e54: fef719e3 bne a4,a5,4e46 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 4e58: 854e mv a0,s3
+ 4e5a: 00000097 auipc ra,0x0
+ 4e5e: b30080e7 jalr -1232(ra) # 498a <sbrk>
+ if(p == (char*)-1)
+ 4e62: fd5518e3 bne a0,s5,4e32 <malloc+0xb2>
+ return 0;
+ 4e66: 4501 li a0,0
+ 4e68: bf45 j 4e18 <malloc+0x98>
diff --git a/xv6-user/usertests.c b/xv6-user/usertests.c
new file mode 100644
index 0000000000000000000000000000000000000000..de67e6b907ea43947a019882ca091cd2cbff3581
--- /dev/null
+++ b/xv6-user/usertests.c
@@ -0,0 +1,2755 @@
+#include "kernel/include/param.h"
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+#include "kernel/include/fcntl.h"
+#include "kernel/include/syscall.h"
+#include "kernel/include/memlayout.h"
+#include "kernel/include/riscv.h"
+
+//
+// Tests xv6 system calls. usertests without arguments runs them all
+// and usertests <name> runs <name> test. The test runner creates for
+// each test a process and based on the exit status of the process,
+// the test runner reports "OK" or "FAILED". Some tests result in
+// kernel printing usertrap messages, which can be ignored if test
+// prints "OK".
+//
+
+#define BSIZE 512
+#define MAXFILE 512
+#define BUFSZ ((MAXOPBLOCKS+2)*BSIZE)
+
+char buf[BUFSZ];
+char name[3];
+
+// what if you pass ridiculous pointers to system calls
+// that read user memory with copyin?
+void
+copyin(char *s)
+{
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+
+ for(int ai = 0; ai < 2; ai++){
+ uint64 addr = addrs[ai];
+
+ int fd = open("copyin1", O_CREATE|O_WRONLY);
+ if(fd < 0){
+ printf("open(copyin1) failed\n");
+ exit(1);
+ }
+ int n = write(fd, (void*)addr, 8192);
+ if(n >= 0){
+ printf("write(fd, %p, 8192) returned %d, not -1\n", addr, n);
+ exit(1);
+ }
+ close(fd);
+ remove("copyin1");
+
+ n = write(1, (char*)addr, 8192);
+ if(n > 0){
+ printf("write(1, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ exit(1);
+ }
+
+ int fds[2];
+ if(pipe(fds) < 0){
+ printf("pipe() failed\n");
+ exit(1);
+ }
+ n = write(fds[1], (char*)addr, 8192);
+ if(n > 0){
+ printf("write(pipe, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ exit(1);
+ }
+ close(fds[0]);
+ close(fds[1]);
+ }
+}
+
+// what if you pass ridiculous pointers to system calls
+// that write user memory with copyout?
+void
+copyout(char *s)
+{
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+
+ for(int ai = 0; ai < 2; ai++){
+ uint64 addr = addrs[ai];
+
+ int fd = open("README", 0);
+ if(fd < 0){
+ printf("open(README) failed\n");
+ exit(1);
+ }
+ int n = read(fd, (void*)addr, 8192);
+ if(n > 0){
+ printf("read(fd, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ exit(1);
+ }
+ close(fd);
+
+ int fds[2];
+ if(pipe(fds) < 0){
+ printf("pipe() failed\n");
+ exit(1);
+ }
+ n = write(fds[1], "x", 1);
+ if(n != 1){
+ printf("pipe write failed\n");
+ exit(1);
+ }
+ n = read(fds[0], (void*)addr, 8192);
+ if(n > 0){
+ printf("read(pipe, %p, 8192) returned %d, not -1 or 0\n", addr, n);
+ exit(1);
+ }
+ close(fds[0]);
+ close(fds[1]);
+ }
+}
+
+// what if you pass ridiculous string pointers to system calls?
+void
+copyinstr1(char *s)
+{
+ uint64 addrs[] = { 0x80000000LL, 0xffffffffffffffff };
+
+ for(int ai = 0; ai < 2; ai++){
+ uint64 addr = addrs[ai];
+
+ int fd = open((char *)addr, O_CREATE|O_WRONLY);
+ if(fd >= 0){
+ printf("open(%p) returned %d, not -1\n", addr, fd);
+ exit(1);
+ }
+ }
+}
+
+// what if a string system call argument is exactly the size
+// of the kernel buffer it is copied into, so that the null
+// would fall just beyond the end of the kernel buffer?
+void
+copyinstr2(char *s)
+{
+ char b[MAXPATH+1];
+
+ for(int i = 0; i < MAXPATH; i++)
+ b[i] = 'x';
+ b[MAXPATH] = '\0';
+
+ int ret = remove(b);
+ if(ret != -1){
+ printf("remove(%s) returned %d, not -1\n", b, ret);
+ exit(1);
+ }
+
+ int fd = open(b, O_CREATE | O_WRONLY);
+ if(fd != -1){
+ printf("open(%s) returned %d, not -1\n", b, fd);
+ exit(1);
+ }
+
+ // ret = link(b, b);
+ // if(ret != -1){
+ // printf("link(%s, %s) returned %d, not -1\n", b, b, ret);
+ // exit(1);
+ // }
+
+ char *args[] = { "xx", 0 };
+ ret = exec(b, args);
+ if(ret != -1){
+ printf("exec(%s) returned %d, not -1\n", b, fd);
+ exit(1);
+ }
+
+ int pid = fork();
+ if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ if(pid == 0){
+ static char big[PGSIZE+1];
+ for(int i = 0; i < PGSIZE; i++)
+ big[i] = 'x';
+ big[PGSIZE] = '\0';
+ char *args2[] = { big, big, big, 0 };
+ ret = exec("echo", args2);
+ if(ret != -1){
+ printf("exec(echo, BIG) returned %d, not -1\n", fd);
+ exit(1);
+ }
+ exit(747); // OK
+ }
+
+ int st = 0;
+ wait(&st);
+ if(st != 747){
+ printf("exec(echo, BIG) succeeded, should have failed\n");
+ exit(1);
+ }
+}
+
+// what if a string argument crosses over the end of last user page?
+void
+copyinstr3(char *s)
+{
+ sbrk(8192);
+ uint64 top = (uint64) sbrk(0);
+ if((top % PGSIZE) != 0){
+ sbrk(PGSIZE - (top % PGSIZE));
+ }
+ top = (uint64) sbrk(0);
+ if(top % PGSIZE){
+ printf("oops\n");
+ exit(1);
+ }
+
+ char *b = (char *) (top - 1);
+ *b = 'x';
+
+ int ret = remove(b);
+ if(ret != -1){
+ printf("remove(%s) returned %d, not -1\n", b, ret);
+ exit(1);
+ }
+
+ int fd = open(b, O_CREATE | O_WRONLY);
+ if(fd != -1){
+ printf("open(%s) returned %d, not -1\n", b, fd);
+ exit(1);
+ }
+
+ // ret = link(b, b);
+ // if(ret != -1){
+ // printf("link(%s, %s) returned %d, not -1\n", b, b, ret);
+ // exit(1);
+ // }
+
+ char *args[] = { "xx", 0 };
+ ret = exec(b, args);
+ if(ret != -1){
+ printf("exec(%s) returned %d, not -1\n", b, fd);
+ exit(1);
+ }
+}
+
+// // test O_TRUNC.
+void
+truncate1(char *s)
+{
+ char buf[32];
+
+ remove("truncfile");
+ int fd1 = open("truncfile", O_CREATE|O_WRONLY|O_TRUNC);
+ write(fd1, "abcd", 4);
+ close(fd1);
+
+ int fd2 = open("truncfile", O_RDONLY);
+ int n = read(fd2, buf, sizeof(buf));
+ if(n != 4){
+ printf("%s: read %d bytes, wanted 4\n", s, n);
+ exit(1);
+ }
+
+ fd1 = open("truncfile", O_WRONLY|O_TRUNC);
+
+ int fd3 = open("truncfile", O_RDONLY);
+ n = read(fd3, buf, sizeof(buf));
+ if(n != 0){
+ printf("aaa fd3=%d\n", fd3);
+ printf("%s: read %d bytes, wanted 0\n", s, n);
+ exit(1);
+ }
+
+ n = read(fd2, buf, sizeof(buf));
+ if(n != 0){
+ printf("bbb fd2=%d\n", fd2);
+ printf("%s: read %d bytes, wanted 0\n", s, n);
+ exit(1);
+ }
+
+ write(fd1, "abcdef", 6);
+
+ n = read(fd3, buf, sizeof(buf));
+ if(n != 6){
+ printf("%s: read %d bytes, wanted 6\n", s, n);
+ exit(1);
+ }
+
+ n = read(fd2, buf, sizeof(buf));
+ if(n != 2){
+ printf("%s: read %d bytes, wanted 2\n", s, n);
+ exit(1);
+ }
+
+ remove("truncfile");
+
+ close(fd1);
+ close(fd2);
+ close(fd3);
+}
+
+// write to an open FD whose file has just been truncated.
+// this causes a write at an offset beyond the end of the file.
+// such writes fail on xv6 (unlike POSIX) but at least
+// they don't crash.
+void
+truncate2(char *s)
+{
+ remove("truncfile");
+
+ int fd1 = open("truncfile", O_CREATE|O_TRUNC|O_WRONLY);
+ write(fd1, "abcd", 4);
+
+ int fd2 = open("truncfile", O_TRUNC|O_WRONLY);
+
+ int n = write(fd1, "x", 1);
+ if(n != -1){
+ printf("%s: write returned %d, expected -1\n", s, n);
+ exit(1);
+ }
+
+ remove("truncfile");
+ close(fd1);
+ close(fd2);
+}
+
+void
+truncate3(char *s)
+{
+ int pid, xstatus;
+
+ close(open("truncfile", O_CREATE|O_TRUNC|O_WRONLY));
+
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+
+ if(pid == 0){
+ for(int i = 0; i < 100; i++){
+ char buf[32];
+ int fd = open("truncfile", O_WRONLY);
+ if(fd < 0){
+ printf("%s: open failed\n", s);
+ exit(1);
+ }
+ int n = write(fd, "1234567890", 10);
+ if(n != 10){
+ printf("%s: write got %d, expected 10\n", s, n);
+ exit(1);
+ }
+ close(fd);
+ fd = open("truncfile", O_RDONLY);
+ read(fd, buf, sizeof(buf));
+ close(fd);
+ }
+ exit(0);
+ }
+
+ for(int i = 0; i < 150; i++){
+ int fd = open("truncfile", O_CREATE|O_WRONLY|O_TRUNC);
+ if(fd < 0){
+ printf("%s: open failed\n", s);
+ exit(1);
+ }
+ int n = write(fd, "xxx", 3);
+ if(n != 3){
+ printf("%s: write got %d, expected 3\n", s, n);
+ exit(1);
+ }
+ close(fd);
+ }
+
+ wait(&xstatus);
+ remove("truncfile");
+ exit(xstatus);
+}
+
+
+// does chdir() call iput(p->cwd) in a transaction?
+void
+iputtest(char *s)
+{
+ if(mkdir("iputdir") < 0){
+ printf("%s: mkdir failed\n", s);
+ exit(1);
+ }
+ if(chdir("iputdir") < 0){
+ printf("%s: chdir iputdir failed\n", s);
+ exit(1);
+ }
+ if(remove("../iputdir") < 0){
+ printf("%s: remove ../iputdir failed\n", s);
+ exit(1);
+ }
+ if(chdir("/") < 0){
+ printf("%s: chdir / failed\n", s);
+ exit(1);
+ }
+}
+
+// does exit() call iput(p->cwd) in a transaction?
+void
+exitiputtest(char *s)
+{
+ int pid, xstatus;
+
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid == 0){
+ if(mkdir("iputdir") < 0){
+ printf("%s: mkdir failed\n", s);
+ exit(1);
+ }
+ if(chdir("iputdir") < 0){
+ printf("%s: child chdir failed\n", s);
+ exit(1);
+ }
+ if(remove("../iputdir") < 0){
+ printf("%s: remove ../iputdir failed\n", s);
+ exit(1);
+ }
+ exit(0);
+ }
+ wait(&xstatus);
+ exit(xstatus);
+}
+
+// does the error path in open() for attempt to write a
+// directory call iput() in a transaction?
+// needs a hacked kernel that pauses just after the namei()
+// call in sys_open():
+// if((ip = namei(path)) == 0)
+// return -1;
+// {
+// int i;
+// for(i = 0; i < 10000; i++)
+// yield();
+// }
+void
+openiputtest(char *s)
+{
+ int pid, xstatus;
+
+ if(mkdir("oidir") < 0){
+ printf("%s: mkdir oidir failed\n", s);
+ exit(1);
+ }
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid == 0){
+ int fd = open("oidir", O_RDWR);
+ if(fd >= 0){
+ printf("%s: open directory for write succeeded\n", s);
+ exit(1);
+ }
+ exit(0);
+ }
+ sleep(1);
+ if(remove("oidir") != 0){
+ printf("%s: remove failed\n", s);
+ exit(1);
+ }
+ wait(&xstatus);
+ exit(xstatus);
+}
+
+// simple file system tests
+
+void
+opentest(char *s)
+{
+ int fd;
+
+ fd = open("echo", 0);
+ if(fd < 0){
+ printf("%s: open echo failed!\n", s);
+ exit(1);
+ }
+ close(fd);
+ fd = open("doesnotexist", 0);
+ if(fd >= 0){
+ printf("%s: open doesnotexist succeeded!\n", s);
+ exit(1);
+ }
+}
+
+void
+writetest(char *s)
+{
+ int fd;
+ int i;
+ enum { N=100, SZ=10 };
+
+ fd = open("small", O_CREATE|O_RDWR);
+ if(fd < 0){
+ printf("%s: error: creat small failed!\n", s);
+ exit(1);
+ }
+ for(i = 0; i < N; i++){
+ if(write(fd, "aaaaaaaaaa", SZ) != SZ){
+ printf("%s: error: write aa %d new file failed\n", i);
+ exit(1);
+ }
+ if(write(fd, "bbbbbbbbbb", SZ) != SZ){
+ printf("%s: error: write bb %d new file failed\n", i);
+ exit(1);
+ }
+ }
+ close(fd);
+ fd = open("small", O_RDONLY);
+ if(fd < 0){
+ printf("%s: error: open small failed!\n", s);
+ exit(1);
+ }
+ i = read(fd, buf, N*SZ*2);
+ if(i != N*SZ*2){
+ printf("%s: read failed\n", s);
+ exit(1);
+ }
+ close(fd);
+
+ if(remove("small") < 0){
+ printf("%s: remove small failed\n", s);
+ exit(1);
+ }
+}
+
+void
+writebig(char *s)
+{
+ int i, fd, n;
+
+ fd = open("big", O_CREATE|O_RDWR);
+ if(fd < 0){
+ printf("%s: error: creat big failed!\n", s);
+ exit(1);
+ }
+
+ for(i = 0; i < MAXFILE; i++){
+ ((int*)buf)[0] = i;
+ if(write(fd, buf, BSIZE) != BSIZE){
+ printf("%s: error: write big file failed\n", i);
+ exit(1);
+ }
+ }
+
+ close(fd);
+
+ fd = open("big", O_RDONLY);
+ if(fd < 0){
+ printf("%s: error: open big failed!\n", s);
+ exit(1);
+ }
+
+ n = 0;
+ for(;;){
+ i = read(fd, buf, BSIZE);
+ if(i == 0){
+ if(n == MAXFILE - 1){
+ printf("%s: read only %d blocks from big", n);
+ exit(1);
+ }
+ break;
+ } else if(i != BSIZE){
+ printf("%s: read failed %d\n", i);
+ exit(1);
+ }
+ if(((int*)buf)[0] != n){
+ printf("%s: read content of block %d is %d\n",
+ n, ((int*)buf)[0]);
+ exit(1);
+ }
+ n++;
+ }
+ close(fd);
+ if(remove("big") < 0){
+ printf("%s: remove big failed\n", s);
+ exit(1);
+ }
+}
+
+// many creates, followed by remove test
+void
+createtest(char *s)
+{
+ int i, fd;
+ enum { N=52 };
+
+ name[0] = 'a';
+ name[2] = '\0';
+ for(i = 0; i < N; i++){
+ name[1] = '0' + i;
+ fd = open(name, O_CREATE|O_RDWR);
+ close(fd);
+ }
+ name[0] = 'a';
+ name[2] = '\0';
+ for(i = 0; i < N; i++){
+ name[1] = '0' + i;
+ remove(name);
+ }
+}
+
+void dirtest(char *s)
+{
+ printf("mkdir test\n");
+
+ if(mkdir("dir0") < 0){
+ printf("%s: mkdir failed\n", s);
+ exit(1);
+ }
+
+ if(chdir("dir0") < 0){
+ printf("%s: chdir dir0 failed\n", s);
+ exit(1);
+ }
+
+ if(chdir("..") < 0){
+ printf("%s: chdir .. failed\n", s);
+ exit(1);
+ }
+
+ if(remove("dir0") < 0){
+ printf("%s: remove dir0 failed\n", s);
+ exit(1);
+ }
+ printf("%s: mkdir test ok\n");
+}
+
+void
+exectest(char *s)
+{
+ int fd, xstatus, pid;
+ char *echoargv[] = { "echo", "OK", 0 };
+ char buf[3];
+
+ remove("echo-ok");
+ pid = fork();
+ if(pid < 0) {
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid == 0) {
+ close(1);
+ fd = open("echo-ok", O_CREATE|O_WRONLY);
+ if(fd < 0) {
+ printf("%s: create failed\n", s);
+ exit(1);
+ }
+ if(fd != 1) {
+ printf("%s: wrong fd\n", s);
+ exit(1);
+ }
+ if(exec("echo", echoargv) < 0){
+ printf("%s: exec echo failed\n", s);
+ exit(1);
+ }
+ // won't get to here
+ }
+ if (wait(&xstatus) != pid) {
+ printf("%s: wait failed!\n", s);
+ }
+ if(xstatus != 0)
+ exit(xstatus);
+
+ fd = open("echo-ok", O_RDONLY);
+ if(fd < 0) {
+ printf("%s: open failed\n", s);
+ exit(1);
+ }
+ if (read(fd, buf, 2) != 2) {
+ printf("%s: read failed\n", s);
+ exit(1);
+ }
+ remove("echo-ok");
+ if(buf[0] == 'O' && buf[1] == 'K')
+ exit(0);
+ else {
+ printf("%s: wrong output\n", s);
+ exit(1);
+ }
+
+}
+
+// simple fork and pipe read/write
+
+void
+pipe1(char *s)
+{
+ int fds[2], pid, xstatus;
+ int seq, i, n, cc, total;
+ enum { N=5, SZ=1033 };
+
+ if(pipe(fds) != 0){
+ printf("%s: pipe() failed\n", s);
+ exit(1);
+ }
+ pid = fork();
+ seq = 0;
+ if(pid == 0){
+ close(fds[0]);
+ for(n = 0; n < N; n++){
+ for(i = 0; i < SZ; i++)
+ buf[i] = seq++;
+ if(write(fds[1], buf, SZ) != SZ){
+ printf("%s: pipe1 oops 1\n", s);
+ exit(1);
+ }
+ }
+ exit(0);
+ } else if(pid > 0){
+ close(fds[1]);
+ total = 0;
+ cc = 1;
+ while((n = read(fds[0], buf, cc)) > 0){
+ for(i = 0; i < n; i++){
+ if((buf[i] & 0xff) != (seq++ & 0xff)){
+ printf("%s: pipe1 oops 2\n", s);
+ return;
+ }
+ }
+ total += n;
+ cc = cc * 2;
+ if(cc > sizeof(buf))
+ cc = sizeof(buf);
+ }
+ if(total != N * SZ){
+ printf("%s: pipe1 oops 3 total %d\n", total);
+ exit(1);
+ }
+ close(fds[0]);
+ wait(&xstatus);
+ exit(xstatus);
+ } else {
+ printf("%s: fork() failed\n", s);
+ exit(1);
+ }
+}
+
+// meant to be run w/ at most two CPUs
+void
+preempt(char *s)
+{
+ int pid1, pid2, pid3;
+ int pfds[2];
+
+ pid1 = fork();
+ if(pid1 < 0) {
+ printf("%s: fork failed");
+ exit(1);
+ }
+ if(pid1 == 0)
+ for(;;)
+ ;
+
+ pid2 = fork();
+ if(pid2 < 0) {
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid2 == 0)
+ for(;;)
+ ;
+
+ pipe(pfds);
+ pid3 = fork();
+ if(pid3 < 0) {
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid3 == 0){
+ close(pfds[0]);
+ if(write(pfds[1], "x", 1) != 1)
+ printf("%s: preempt write error");
+ close(pfds[1]);
+ for(;;)
+ ;
+ }
+
+ close(pfds[1]);
+ if(read(pfds[0], buf, sizeof(buf)) != 1){
+ printf("%s: preempt read error");
+ return;
+ }
+ close(pfds[0]);
+ printf("kill... ");
+ kill(pid1);
+ kill(pid2);
+ kill(pid3);
+ printf("wait... ");
+ wait(0);
+ wait(0);
+ wait(0);
+}
+
+// try to find any races between exit and wait
+void
+exitwait(char *s)
+{
+ int i, pid;
+
+ for(i = 0; i < 100; i++){
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid){
+ int xstate;
+ if(wait(&xstate) != pid){
+ printf("%s: wait wrong pid\n", s);
+ exit(1);
+ }
+ if(i != xstate) {
+ printf("%s: wait wrong exit status\n", s);
+ exit(1);
+ }
+ } else {
+ exit(i);
+ }
+ }
+}
+
+// try to find races in the reparenting
+// code that handles a parent exiting
+// when it still has live children.
+void
+reparent(char *s)
+{
+ int master_pid = getpid();
+ for(int i = 0; i < 200; i++){
+ int pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid){
+ if(wait(0) != pid){
+ printf("%s: wait wrong pid\n", s);
+ exit(1);
+ }
+ } else {
+ int pid2 = fork();
+ if(pid2 < 0){
+ kill(master_pid);
+ exit(1);
+ }
+ exit(0);
+ }
+ }
+ exit(0);
+}
+
+// what if two children exit() at the same time?
+void
+twochildren(char *s)
+{
+ for(int i = 0; i < 1000; i++){
+ int pid1 = fork();
+ if(pid1 < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid1 == 0){
+ exit(0);
+ } else {
+ int pid2 = fork();
+ if(pid2 < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid2 == 0){
+ exit(0);
+ } else {
+ wait(0);
+ wait(0);
+ }
+ }
+ }
+}
+
+// concurrent forks to try to expose locking bugs.
+void
+forkfork(char *s)
+{
+ enum { N=2 };
+
+ for(int i = 0; i < N; i++){
+ int pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed", s);
+ exit(1);
+ }
+ if(pid == 0){
+ for(int j = 0; j < 200; j++){
+ int pid1 = fork();
+ if(pid1 < 0){
+ exit(1);
+ }
+ if(pid1 == 0){
+ exit(0);
+ }
+ wait(0);
+ }
+ exit(0);
+ }
+ }
+
+ int xstatus;
+ for(int i = 0; i < N; i++){
+ wait(&xstatus);
+ if(xstatus != 0) {
+ printf("%s: fork in child failed", s);
+ exit(1);
+ }
+ }
+}
+
+void
+forkforkfork(char *s)
+{
+ remove("stopforking");
+
+ int pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed", s);
+ exit(1);
+ }
+ if(pid == 0){
+ while(1){
+ int fd = open("stopforking", 0);
+ if(fd >= 0){
+ exit(0);
+ }
+ if(fork() < 0){
+ close(open("stopforking", O_CREATE|O_RDWR));
+ }
+ }
+
+ exit(0);
+ }
+
+ sleep(20); // two seconds
+ close(open("stopforking", O_CREATE|O_RDWR));
+ wait(0);
+ sleep(10); // one second
+ remove("stopforking");
+}
+
+// regression test. does reparent() violate the parent-then-child
+// locking order when giving away a child to init, so that exit()
+// deadlocks against init's wait()? also used to trigger a "panic:
+// release" due to exit() releasing a different p->parent->lock than
+// it acquired.
+void
+reparent2(char *s)
+{
+ for(int i = 0; i < 800; i++){
+ int pid1 = fork();
+ if(pid1 < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ if(pid1 == 0){
+ fork();
+ fork();
+ exit(0);
+ }
+ wait(0);
+ }
+
+ exit(0);
+}
+
+// allocate all mem, free it, and allocate again
+void
+mem(char *s)
+{
+ void *m1, *m2;
+ int pid;
+
+ if((pid = fork()) == 0){
+ m1 = 0;
+ while((m2 = malloc(10001)) != 0){
+ *(char**)m2 = m1;
+ m1 = m2;
+ }
+ while(m1){
+ m2 = *(char**)m1;
+ free(m1);
+ m1 = m2;
+ }
+ m1 = malloc(1024*20);
+ if(m1 == 0){
+ printf("couldn't allocate mem?!!\n", s);
+ exit(1);
+ }
+ free(m1);
+ exit(0);
+ } else {
+ int xstatus;
+ wait(&xstatus);
+ if(xstatus == -1){
+ // probably page fault, so might be lazy lab,
+ // so OK.
+ exit(0);
+ }
+ exit(xstatus);
+ }
+}
+
+// More file system tests
+
+// two processes write to the same file descriptor
+// is the offset shared? does inode locking work?
+void
+sharedfd(char *s)
+{
+ int fd, pid, i, n, nc, np;
+ enum { N = 1000, SZ=10};
+ char buf[SZ];
+
+ remove("sharedfd");
+ fd = open("sharedfd", O_CREATE|O_RDWR);
+ if(fd < 0){
+ printf("%s: cannot open sharedfd for writing", s);
+ exit(1);
+ }
+ pid = fork();
+ memset(buf, pid==0?'c':'p', sizeof(buf));
+ for(i = 0; i < N; i++){
+ if(write(fd, buf, sizeof(buf)) != sizeof(buf)){
+ printf("%s: write sharedfd failed\n", s);
+ exit(1);
+ }
+ }
+ if(pid == 0) {
+ exit(0);
+ } else {
+ int xstatus;
+ wait(&xstatus);
+ if(xstatus != 0)
+ exit(xstatus);
+ }
+
+ close(fd);
+ fd = open("sharedfd", 0);
+ if(fd < 0){
+ printf("%s: cannot open sharedfd for reading\n", s);
+ exit(1);
+ }
+ nc = np = 0;
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ for(i = 0; i < sizeof(buf); i++){
+ if(buf[i] == 'c')
+ nc++;
+ if(buf[i] == 'p')
+ np++;
+ }
+ }
+ close(fd);
+ remove("sharedfd");
+ if(nc == N*SZ && np == N*SZ){
+ exit(0);
+ } else {
+ printf("%s: nc/np test fails\n", s);
+ exit(1);
+ }
+}
+
+// four processes write different files at the same
+// time, to test block allocation.
+void
+fourfiles(char *s)
+{
+ int fd, pid, i, j, n, total, pi;
+ char *names[] = { "f0", "f1", "f2", "f3" };
+ char *fname;
+ enum { N=12, NCHILD=4, SZ=500 };
+
+ for(pi = 0; pi < NCHILD; pi++){
+ fname = names[pi];
+ remove(fname);
+
+ pid = fork();
+ if(pid < 0){
+ printf("fork failed\n", s);
+ exit(1);
+ }
+
+ if(pid == 0){
+ fd = open(fname, O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("create failed\n", s);
+ exit(1);
+ }
+
+ memset(buf, '0'+pi, SZ);
+ for(i = 0; i < N; i++){
+ if((n = write(fd, buf, SZ)) != SZ){
+ printf("write failed %d\n", n);
+ exit(1);
+ }
+ }
+ exit(0);
+ }
+ }
+
+ int xstatus;
+ for(pi = 0; pi < NCHILD; pi++){
+ wait(&xstatus);
+ if(xstatus != 0)
+ exit(xstatus);
+ }
+
+ for(i = 0; i < NCHILD; i++){
+ fname = names[i];
+ fd = open(fname, 0);
+ total = 0;
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ for(j = 0; j < n; j++){
+ if(buf[j] != '0'+i){
+ printf("wrong char\n", s);
+ exit(1);
+ }
+ }
+ total += n;
+ }
+ close(fd);
+ if(total != N*SZ){
+ printf("wrong length %d\n", total);
+ exit(1);
+ }
+ remove(fname);
+ }
+}
+
+// four processes create and delete different files in same directory
+void
+createdelete(char *s)
+{
+ enum { N = 20, NCHILD=4 };
+ int pid, i, fd, pi;
+ char name[32];
+ char illegal[] = { '\"', '*', '/', ':', '<', '>', '?', '\\', '|', 0 };
+ for(pi = 0; pi < NCHILD; pi++){
+ pid = fork();
+ if(pid < 0){
+ printf("fork failed\n", s);
+ exit(1);
+ }
+
+ if(pid == 0){
+ name[0] = 'p' + pi;
+ name[2] = '\0';
+ for(i = 0; i < N; i++){
+ name[1] = '0' + i;
+ if (strchr(illegal, name[1]) == 0) {
+ fd = open(name, O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: create %s failed\n", s, name);
+ exit(1);
+ }
+ close(fd);
+ }
+ if(i > 0 && (i % 2 ) == 0){
+ name[1] = '0' + (i / 2);
+ if (strchr(illegal, name[1]) == 0) {
+ if(remove(name) < 0){
+ printf("%s: remove failed\n", s);
+ exit(1);
+ }
+ }
+ }
+ }
+ exit(0);
+ }
+ }
+
+ int xstatus;
+ for(pi = 0; pi < NCHILD; pi++){
+ wait(&xstatus);
+ if(xstatus != 0)
+ exit(1);
+ }
+
+ name[0] = name[1] = name[2] = 0;
+ for(i = 0; i < N; i++){
+ for(pi = 0; pi < NCHILD; pi++){
+ name[0] = 'p' + pi;
+ name[1] = '0' + i;
+ if (strchr(illegal, name[1]) != 0) { continue; }
+ fd = open(name, 0);
+ if((i == 0 || i >= N/2) && fd < 0){
+ printf("%s: oops createdelete %s didn't exist\n", s, name);
+ exit(1);
+ } else if((i >= 1 && i < N/2) && fd >= 0){
+ printf("%s: oops createdelete %s did exist\n", s, name);
+ exit(1);
+ }
+ if(fd >= 0)
+ close(fd);
+ }
+ }
+
+ for(i = 0; i < N; i++){
+ for(pi = 0; pi < NCHILD; pi++){
+ name[0] = 'p' + pi;
+ name[1] = '0' + i;
+ remove(name);
+ }
+ }
+}
+
+// can I remove a file and still read it?
+void
+removeread(char *s)
+{
+ enum { SZ = 5 };
+ int fd, fd1;
+
+ fd = open("removeread", O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: create removeread failed\n", s);
+ exit(1);
+ }
+ write(fd, "hello", SZ);
+ close(fd);
+
+ fd = open("removeread", O_RDWR);
+ if(fd < 0){
+ printf("%s: open removeread failed\n", s);
+ exit(1);
+ }
+ if(remove("removeread") != 0){
+ printf("%s: remove removeread failed\n", s);
+ exit(1);
+ }
+
+ fd1 = open("removeread", O_CREATE | O_RDWR);
+ write(fd1, "yyy", 3);
+ close(fd1);
+
+ if(read(fd, buf, sizeof(buf)) != SZ){
+ printf("%s: removeread read failed", s);
+ exit(1);
+ }
+ if(buf[0] != 'h'){
+ printf("%s: removeread wrong data\n", s);
+ exit(1);
+ }
+ if(write(fd, buf, 10) != 10){
+ printf("%s: removeread write failed\n", s);
+ exit(1);
+ }
+ close(fd);
+ remove("removeread");
+}
+
+// void
+// linktest(char *s)
+// {
+// enum { SZ = 5 };
+// int fd;
+
+// remove("lf1");
+// remove("lf2");
+
+// fd = open("lf1", O_CREATE|O_RDWR);
+// if(fd < 0){
+// printf("%s: create lf1 failed\n", s);
+// exit(1);
+// }
+// if(write(fd, "hello", SZ) != SZ){
+// printf("%s: write lf1 failed\n", s);
+// exit(1);
+// }
+// close(fd);
+
+// if(link("lf1", "lf2") < 0){
+// printf("%s: link lf1 lf2 failed\n", s);
+// exit(1);
+// }
+// remove("lf1");
+
+// if(open("lf1", 0) >= 0){
+// printf("%s: removeed lf1 but it is still there!\n", s);
+// exit(1);
+// }
+
+// fd = open("lf2", 0);
+// if(fd < 0){
+// printf("%s: open lf2 failed\n", s);
+// exit(1);
+// }
+// if(read(fd, buf, sizeof(buf)) != SZ){
+// printf("%s: read lf2 failed\n", s);
+// exit(1);
+// }
+// close(fd);
+
+// if(link("lf2", "lf2") >= 0){
+// printf("%s: link lf2 lf2 succeeded! oops\n", s);
+// exit(1);
+// }
+
+// remove("lf2");
+// if(link("lf2", "lf1") >= 0){
+// printf("%s: link non-existant succeeded! oops\n", s);
+// exit(1);
+// }
+
+// if(link(".", "lf1") >= 0){
+// printf("%s: link . lf1 succeeded! oops\n", s);
+// exit(1);
+// }
+// }
+
+// // test concurrent create/link/remove of the same file
+// void
+// concreate(char *s)
+// {
+// enum { N = 40 };
+// char file[3];
+// int i, pid, n, fd;
+// char fa[N];
+// struct {
+// ushort inum;
+// char name[DIRSIZ];
+// } de;
+
+// file[0] = 'C';
+// file[2] = '\0';
+// for(i = 0; i < N; i++){
+// file[1] = '0' + i;
+// remove(file);
+// pid = fork();
+// if(pid && (i % 3) == 1){
+// link("C0", file);
+// } else if(pid == 0 && (i % 5) == 1){
+// link("C0", file);
+// } else {
+// fd = open(file, O_CREATE | O_RDWR);
+// if(fd < 0){
+// printf("concreate create %s failed\n", file);
+// exit(1);
+// }
+// close(fd);
+// }
+// if(pid == 0) {
+// exit(0);
+// } else {
+// int xstatus;
+// wait(&xstatus);
+// if(xstatus != 0)
+// exit(1);
+// }
+// }
+
+// memset(fa, 0, sizeof(fa));
+// fd = open(".", 0);
+// n = 0;
+// while(read(fd, &de, sizeof(de)) > 0){
+// if(de.inum == 0)
+// continue;
+// if(de.name[0] == 'C' && de.name[2] == '\0'){
+// i = de.name[1] - '0';
+// if(i < 0 || i >= sizeof(fa)){
+// printf("%s: concreate weird file %s\n", s, de.name);
+// exit(1);
+// }
+// if(fa[i]){
+// printf("%s: concreate duplicate file %s\n", s, de.name);
+// exit(1);
+// }
+// fa[i] = 1;
+// n++;
+// }
+// }
+// close(fd);
+
+// if(n != N){
+// printf("%s: concreate not enough files in directory listing\n", s);
+// exit(1);
+// }
+
+// for(i = 0; i < N; i++){
+// file[1] = '0' + i;
+// pid = fork();
+// if(pid < 0){
+// printf("%s: fork failed\n", s);
+// exit(1);
+// }
+// if(((i % 3) == 0 && pid == 0) ||
+// ((i % 3) == 1 && pid != 0)){
+// close(open(file, 0));
+// close(open(file, 0));
+// close(open(file, 0));
+// close(open(file, 0));
+// close(open(file, 0));
+// close(open(file, 0));
+// } else {
+// remove(file);
+// remove(file);
+// remove(file);
+// remove(file);
+// remove(file);
+// remove(file);
+// }
+// if(pid == 0)
+// exit(0);
+// else
+// wait(0);
+// }
+// }
+
+// // another concurrent link/remove/create test,
+// // to look for deadlocks.
+// void
+// linkremove(char *s)
+// {
+// int pid, i;
+
+// remove("x");
+// pid = fork();
+// if(pid < 0){
+// printf("%s: fork failed\n", s);
+// exit(1);
+// }
+
+// unsigned int x = (pid ? 1 : 97);
+// for(i = 0; i < 100; i++){
+// x = x * 1103515245 + 12345;
+// if((x % 3) == 0){
+// close(open("x", O_RDWR | O_CREATE));
+// } else if((x % 3) == 1){
+// link("cat", "x");
+// } else {
+// remove("x");
+// }
+// }
+
+// if(pid)
+// wait(0);
+// else
+// exit(0);
+// }
+
+// // directory that uses indirect blocks
+// void
+// bigdir(char *s)
+// {
+// enum { N = 500 };
+// int i, fd;
+// char name[10];
+
+// remove("bd");
+
+// fd = open("bd", O_CREATE);
+// if(fd < 0){
+// printf("%s: bigdir create failed\n", s);
+// exit(1);
+// }
+// close(fd);
+
+// for(i = 0; i < N; i++){
+// name[0] = 'x';
+// name[1] = '0' + (i / 64);
+// name[2] = '0' + (i % 64);
+// name[3] = '\0';
+// if(link("bd", name) != 0){
+// printf("%s: bigdir link(bd, %s) failed\n", s, name);
+// exit(1);
+// }
+// }
+
+// remove("bd");
+// for(i = 0; i < N; i++){
+// name[0] = 'x';
+// name[1] = '0' + (i / 64);
+// name[2] = '0' + (i % 64);
+// name[3] = '\0';
+// if(remove(name) != 0){
+// printf("%s: bigdir remove failed", s);
+// exit(1);
+// }
+// }
+// }
+
+void
+subdir(char *s)
+{
+ int fd, cc;
+
+ remove("ff");
+ if(mkdir("dd") != 0){
+ printf("%s: mkdir dd failed\n", s);
+ exit(1);
+ }
+
+ fd = open("dd/ff", O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: create dd/ff failed\n", s);
+ exit(1);
+ }
+ write(fd, "ff", 2);
+ close(fd);
+
+ if(remove("dd") >= 0){
+ printf("%s: remove dd (non-empty dir) succeeded!\n", s);
+ exit(1);
+ }
+
+ if(mkdir("/dd/dd") != 0){
+ printf("subdir mkdir dd/dd failed\n", s);
+ exit(1);
+ }
+
+ fd = open("dd/dd/ff", O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: create dd/dd/ff failed\n", s);
+ exit(1);
+ }
+ write(fd, "FF", 2);
+ close(fd);
+
+ fd = open("dd/dd/../ff", 0);
+ if(fd < 0){
+ printf("%s: open dd/dd/../ff failed\n", s);
+ exit(1);
+ }
+ cc = read(fd, buf, sizeof(buf));
+ if(cc != 2 || buf[0] != 'f'){
+ printf("%s: dd/dd/../ff wrong content\n", s);
+ exit(1);
+ }
+ close(fd);
+
+ // if(link("dd/dd/ff", "dd/dd/ffff") != 0){
+ // printf("link dd/dd/ff dd/dd/ffff failed\n", s);
+ // exit(1);
+ // }
+
+ if(remove("dd/dd/ff") != 0){
+ printf("%s: remove dd/dd/ff failed\n", s);
+ exit(1);
+ }
+ if(open("dd/dd/ff", O_RDONLY) >= 0){
+ printf("%s: open (removeed) dd/dd/ff succeeded\n", s);
+ exit(1);
+ }
+
+ if(chdir("dd") != 0){
+ printf("%s: chdir dd failed\n", s);
+ exit(1);
+ }
+ if(chdir("dd/../../dd") != 0){
+ printf("%s: chdir dd/../../dd failed\n", s);
+ exit(1);
+ }
+ if(chdir("dd/../../../dd") != 0){
+ printf("chdir dd/../../dd failed\n", s);
+ exit(1);
+ }
+ if(chdir("./..") != 0){
+ printf("%s: chdir ./.. failed\n", s);
+ exit(1);
+ }
+
+ // fd = open("dd/dd/ffff", 0);
+ // if(fd < 0){
+ // printf("%s: open dd/dd/ffff failed\n", s);
+ // exit(1);
+ // }
+ // if(read(fd, buf, sizeof(buf)) != 2){
+ // printf("%s: read dd/dd/ffff wrong len\n", s);
+ // exit(1);
+ // }
+ // close(fd);
+
+ if(open("dd/dd/ff", O_RDONLY) >= 0){
+ printf("%s: open (removeed) dd/dd/ff succeeded!\n", s);
+ exit(1);
+ }
+
+ if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
+ printf("%s: create dd/ff/ff succeeded!\n", s);
+ exit(1);
+ }
+ if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
+ printf("%s: create dd/xx/ff succeeded!\n", s);
+ exit(1);
+ }
+ if(open("dd", O_CREATE) >= 0){
+ printf("%s: create dd succeeded!\n", s);
+ exit(1);
+ }
+ if(open("dd", O_RDWR) >= 0){
+ printf("%s: open dd rdwr succeeded!\n", s);
+ exit(1);
+ }
+ if(open("dd", O_WRONLY) >= 0){
+ printf("%s: open dd wronly succeeded!\n", s);
+ exit(1);
+ }
+ // if(link("dd/ff/ff", "dd/dd/xx") == 0){
+ // printf("%s: link dd/ff/ff dd/dd/xx succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(link("dd/xx/ff", "dd/dd/xx") == 0){
+ // printf("%s: link dd/xx/ff dd/dd/xx succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(link("dd/ff", "dd/dd/ffff") == 0){
+ // printf("%s: link dd/ff dd/dd/ffff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(mkdir("dd/ff/ff") == 0){
+ // printf("%s: mkdir dd/ff/ff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(mkdir("dd/xx/ff") == 0){
+ // printf("%s: mkdir dd/xx/ff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(mkdir("dd/dd/ffff") == 0){
+ // printf("%s: mkdir dd/dd/ffff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(remove("dd/xx/ff") == 0){
+ // printf("%s: remove dd/xx/ff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(remove("dd/ff/ff") == 0){
+ // printf("%s: remove dd/ff/ff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(chdir("dd/ff") == 0){
+ // printf("%s: chdir dd/ff succeeded!\n", s);
+ // exit(1);
+ // }
+ // if(chdir("dd/xx") == 0){
+ // printf("%s: chdir dd/xx succeeded!\n", s);
+ // exit(1);
+ // }
+
+ // if(remove("dd/dd/ffff") != 0){
+ // printf("%s: remove dd/dd/ff failed\n", s);
+ // exit(1);
+ // }
+ if(remove("dd/ff") != 0){
+ printf("%s: remove dd/ff failed\n", s);
+ exit(1);
+ }
+ if(remove("dd") == 0){
+ printf("%s: remove non-empty dd succeeded!\n", s);
+ exit(1);
+ }
+ if(remove("dd/dd") < 0){
+ printf("%s: remove dd/dd failed\n", s);
+ exit(1);
+ }
+ if(remove("dd") < 0){
+ printf("%s: remove dd failed\n", s);
+ exit(1);
+ }
+}
+
+// test writes that are larger than the log.
+void
+bigwrite(char *s)
+{
+ int fd, sz;
+
+ remove("bigwrite");
+ for(sz = 499; sz < (MAXOPBLOCKS+2)*BSIZE; sz += 471){
+ fd = open("bigwrite", O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: cannot create bigwrite\n", s);
+ exit(1);
+ }
+ int i;
+ for(i = 0; i < 2; i++){
+ int cc = write(fd, buf, sz);
+ if(cc != sz){
+ printf("%s: write(%d) ret %d\n", s, sz, cc);
+ exit(1);
+ }
+ }
+ close(fd);
+ remove("bigwrite");
+ }
+}
+
+void
+bigfile(char *s)
+{
+ enum { N = 20, SZ=600 };
+ int fd, i, total, cc;
+
+ remove("bigfile.dat");
+ fd = open("bigfile.dat", O_CREATE | O_RDWR);
+ if(fd < 0){
+ printf("%s: cannot create bigfile", s);
+ exit(1);
+ }
+ for(i = 0; i < N; i++){
+ memset(buf, i, SZ);
+ if(write(fd, buf, SZ) != SZ){
+ printf("%s: write bigfile failed\n", s);
+ exit(1);
+ }
+ }
+ close(fd);
+
+ fd = open("bigfile.dat", 0);
+ if(fd < 0){
+ printf("%s: cannot open bigfile\n", s);
+ exit(1);
+ }
+ total = 0;
+ for(i = 0; ; i++){
+ cc = read(fd, buf, SZ/2);
+ if(cc < 0){
+ printf("%s: read bigfile failed\n", s);
+ exit(1);
+ }
+ if(cc == 0)
+ break;
+ if(cc != SZ/2){
+ printf("%s: short read bigfile\n", s);
+ exit(1);
+ }
+ if(buf[0] != i/2 || buf[SZ/2-1] != i/2){
+ printf("%s: read bigfile wrong data\n", s);
+ exit(1);
+ }
+ total += cc;
+ }
+ close(fd);
+ if(total != N*SZ){
+ printf("%s: read bigfile wrong total\n", s);
+ exit(1);
+ }
+ remove("bigfile.dat");
+}
+
+void
+fourteen(char *s)
+{
+ int fd;
+
+ // DIRSIZ is 14.
+
+ if(mkdir("12345678901234") != 0){
+ printf("%s: mkdir 12345678901234 failed\n", s);
+ exit(1);
+ }
+ if(mkdir("12345678901234/123456789012345") != 0){
+ printf("%s: mkdir 12345678901234/123456789012345 failed\n", s);
+ exit(1);
+ }
+ fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
+ if(fd < 0){
+ printf("%s: create 123456789012345/123456789012345/123456789012345 failed\n", s);
+ exit(1);
+ }
+ close(fd);
+ fd = open("12345678901234/12345678901234/12345678901234", 0);
+ if(fd < 0){
+ printf("%s: open 12345678901234/12345678901234/12345678901234 failed\n", s);
+ exit(1);
+ }
+ close(fd);
+
+ if(mkdir("12345678901234/12345678901234") == 0){
+ printf("%s: mkdir 12345678901234/12345678901234 succeeded!\n", s);
+ exit(1);
+ }
+ if(mkdir("123456789012345/12345678901234") == 0){
+ printf("%s: mkdir 12345678901234/123456789012345 succeeded!\n", s);
+ exit(1);
+ }
+
+ // clean up
+ remove("123456789012345/12345678901234");
+ remove("12345678901234/12345678901234");
+ remove("12345678901234/12345678901234/12345678901234");
+ remove("123456789012345/123456789012345/123456789012345");
+ remove("12345678901234/123456789012345");
+ remove("12345678901234");
+}
+
+void
+rmdot(char *s)
+{
+ if(mkdir("dots") != 0){
+ printf("%s: mkdir dots failed\n", s);
+ exit(1);
+ }
+ if(chdir("dots") != 0){
+ printf("%s: chdir dots failed\n", s);
+ exit(1);
+ }
+ if(remove(".") == 0){
+ printf("%s: rm . worked!\n", s);
+ exit(1);
+ }
+ if(remove("..") == 0){
+ printf("%s: rm .. worked!\n", s);
+ exit(1);
+ }
+ if(chdir("/") != 0){
+ printf("%s: chdir / failed\n", s);
+ exit(1);
+ }
+ if(remove("dots/.") == 0){
+ printf("%s: remove dots/. worked!\n", s);
+ exit(1);
+ }
+ if(remove("dots/..") == 0){
+ printf("%s: remove dots/.. worked!\n", s);
+ exit(1);
+ }
+ if(remove("dots") != 0){
+ printf("%s: remove dots failed!\n", s);
+ exit(1);
+ }
+}
+
+void
+dirfile(char *s)
+{
+ int fd;
+
+ fd = open("dirfile", O_CREATE);
+ if(fd < 0){
+ printf("%s: create dirfile failed\n", s);
+ exit(1);
+ }
+ close(fd);
+ if(chdir("dirfile") == 0){
+ printf("%s: chdir dirfile succeeded!\n", s);
+ exit(1);
+ }
+ fd = open("dirfile/xx", 0);
+ if(fd >= 0){
+ printf("%s: create dirfile/xx succeeded!\n", s);
+ exit(1);
+ }
+ fd = open("dirfile/xx", O_CREATE);
+ if(fd >= 0){
+ printf("%s: create dirfile/xx succeeded!\n", s);
+ exit(1);
+ }
+ if(mkdir("dirfile/xx") == 0){
+ printf("%s: mkdir dirfile/xx succeeded!\n", s);
+ exit(1);
+ }
+ if(remove("dirfile/xx") == 0){
+ printf("%s: remove dirfile/xx succeeded!\n", s);
+ exit(1);
+ }
+ // if(link("README", "dirfile/xx") == 0){
+ // printf("%s: link to dirfile/xx succeeded!\n", s);
+ // exit(1);
+ // }
+ if(remove("dirfile") != 0){
+ printf("%s: remove dirfile failed!\n", s);
+ exit(1);
+ }
+
+ fd = open(".", O_RDWR);
+ if(fd >= 0){
+ printf("%s: open . for writing succeeded!\n", s);
+ exit(1);
+ }
+ fd = open(".", 0);
+ if(write(fd, "x", 1) > 0){
+ printf("%s: write . succeeded!\n", s);
+ exit(1);
+ }
+ close(fd);
+}
+
+// test that iput() is called at the end of _namei().
+// also tests empty file names.
+void
+iref(char *s)
+{
+ int i, fd;
+
+ for(i = 0; i < NINODE - 4; i++){
+ if(mkdir("irefd") != 0){
+ printf("%s: mkdir irefd failed\n", s);
+ exit(1);
+ }
+ if(chdir("irefd") != 0){
+ printf("%s: chdir irefd failed\n", s);
+ exit(1);
+ }
+
+ mkdir("");
+ // link("README", "");
+ fd = open("", O_CREATE);
+ if(fd >= 0)
+ close(fd);
+ fd = open("xx", O_CREATE);
+ if(fd >= 0)
+ close(fd);
+ remove("xx");
+ }
+
+ // clean up
+ for(i = 0; i < NINODE + 1; i++){
+ chdir("..");
+ remove("irefd");
+ }
+
+ chdir("/");
+}
+
+// test that fork fails gracefully
+// the forktest binary also does this, but it runs out of proc entries first.
+// inside the bigger usertests binary, we run out of memory first.
+void
+forktest(char *s)
+{
+ enum{ N = 1000 };
+ int n, pid;
+
+ for(n=0; n<N; n++){
+ pid = fork();
+ if(pid < 0)
+ break;
+ if(pid == 0)
+ exit(0);
+ }
+
+ if (n == 0) {
+ printf("%s: no fork at all!\n", s);
+ exit(1);
+ }
+
+ if(n == N){
+ printf("%s: fork claimed to work 1000 times!\n", s);
+ exit(1);
+ }
+
+ for(; n > 0; n--){
+ if(wait(0) < 0){
+ printf("%s: wait stopped early\n", s);
+ exit(1);
+ }
+ }
+
+ if(wait(0) != -1){
+ printf("%s: wait got too many\n", s);
+ exit(1);
+ }
+}
+
+void
+sbrkbasic(char *s)
+{
+ enum { TOOMUCH=1024*1024*1024};
+ int i, pid, xstatus;
+ char *c, *a, *b;
+
+ // does sbrk() return the expected failure value?
+ pid = fork();
+ if(pid < 0){
+ printf("fork failed in sbrkbasic\n");
+ exit(1);
+ }
+ if(pid == 0){
+ a = sbrk(TOOMUCH);
+ if(a == (char*)0xffffffffffffffffL){
+ // it's OK if this fails.
+ exit(0);
+ }
+
+ for(b = a; b < a+TOOMUCH; b += 4096){
+ *b = 99;
+ }
+
+ // we should not get here! either sbrk(TOOMUCH)
+ // should have failed, or (with lazy allocation)
+ // a pagefault should have killed this process.
+ exit(1);
+ }
+
+ wait(&xstatus);
+ if(xstatus == 1){
+ printf("%s: too much memory allocated!\n", s);
+ exit(1);
+ }
+
+ // can one sbrk() less than a page?
+ a = sbrk(0);
+ for(i = 0; i < 5000; i++){
+ b = sbrk(1);
+ if(b != a){
+ printf("%s: sbrk test failed %d %x %x\n", i, a, b);
+ exit(1);
+ }
+ *b = 1;
+ a = b + 1;
+ }
+ pid = fork();
+ if(pid < 0){
+ printf("%s: sbrk test fork failed\n", s);
+ exit(1);
+ }
+ c = sbrk(1);
+ c = sbrk(1);
+ if(c != a + 1){
+ printf("%s: sbrk test failed post-fork\n", s);
+ exit(1);
+ }
+ if(pid == 0)
+ exit(0);
+ wait(&xstatus);
+ exit(xstatus);
+}
+
+void
+sbrkmuch(char *s)
+{
+ enum { BIG=3*1024*1024 };
+ char *c, *oldbrk, *a, *lastaddr, *p;
+ uint64 amt;
+
+ oldbrk = sbrk(0);
+
+ // can one grow address space to something big?
+ a = sbrk(0);
+ amt = BIG - (uint64)a;
+ p = sbrk(amt);
+ if (p != a) {
+ printf("%s: sbrk test failed to grow big address space; enough phys mem?\n", s);
+ exit(1);
+ }
+
+ // touch each page to make sure it exists.
+ char *eee = sbrk(0);
+ for(char *pp = a; pp < eee; pp += 4096)
+ *pp = 1;
+
+ lastaddr = (char*) (BIG-1);
+ *lastaddr = 99;
+
+ // can one de-allocate?
+ a = sbrk(0);
+ c = sbrk(-PGSIZE);
+ if(c == (char*)0xffffffffffffffffL){
+ printf("%s: sbrk could not deallocate\n", s);
+ exit(1);
+ }
+ c = sbrk(0);
+ if(c != a - PGSIZE){
+ printf("%s: sbrk deallocation produced wrong address, a %x c %x\n", a, c);
+ exit(1);
+ }
+
+ // can one re-allocate that page?
+ a = sbrk(0);
+ c = sbrk(PGSIZE);
+ if(c != a || sbrk(0) != a + PGSIZE){
+ printf("%s: sbrk re-allocation failed, a %x c %x\n", a, c);
+ exit(1);
+ }
+ if(*lastaddr == 99){
+ // should be zero
+ printf("%s: sbrk de-allocation didn't really deallocate\n", s);
+ exit(1);
+ }
+
+ a = sbrk(0);
+ c = sbrk(-(sbrk(0) - oldbrk));
+ if(c != a){
+ printf("%s: sbrk downsize failed, a %x c %x\n", a, c);
+ exit(1);
+ }
+}
+
+// can we read the kernel's memory?
+void
+kernmem(char *s)
+{
+ char *a;
+ int pid;
+
+ for(a = (char*)(KERNBASE); a < (char*) (KERNBASE+2000000); a += 50000){
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid == 0){
+ printf("%s: oops could read %x = %x\n", a, *a);
+ exit(1);
+ }
+ int xstatus;
+ wait(&xstatus);
+ if(xstatus != -1) // did kernel kill child?
+ exit(1);
+ }
+}
+
+// if we run the system out of memory, does it clean up the last
+// failed allocation?
+void
+sbrkfail(char *s)
+{
+ enum { BIG=100*1024*1024 };
+ int i, xstatus;
+ int fds[2];
+ char scratch;
+ char *c, *a;
+ int pids[10];
+ int pid;
+
+ if(pipe(fds) != 0){
+ printf("%s: pipe() failed\n", s);
+ exit(1);
+ }
+ for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
+ if((pids[i] = fork()) == 0){
+ // allocate a lot of memory
+ sbrk(BIG - (uint64)sbrk(0));
+ write(fds[1], "x", 1);
+ // sit around until killed
+ for(;;) sleep(1000);
+ }
+ if(pids[i] != -1)
+ read(fds[0], &scratch, 1);
+ }
+
+ // if those failed allocations freed up the pages they did allocate,
+ // we'll be able to allocate here
+ c = sbrk(PGSIZE);
+ for(i = 0; i < sizeof(pids)/sizeof(pids[0]); i++){
+ if(pids[i] == -1)
+ continue;
+ kill(pids[i]);
+ wait(0);
+ }
+ if(c == (char*)0xffffffffffffffffL){
+ printf("%s: failed sbrk leaked memory\n", s);
+ exit(1);
+ }
+
+ // test running fork with the above allocated page
+ pid = fork();
+ if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ if(pid == 0){
+ // allocate a lot of memory.
+ // this should produce a page fault,
+ // and thus not complete.
+ a = sbrk(0);
+ sbrk(10*BIG);
+ int n = 0;
+ for (i = 0; i < 10*BIG; i += PGSIZE) {
+ n += *(a+i);
+ }
+ // print n so the compiler doesn't optimize away
+ // the for loop.
+ printf("%s: allocate a lot of memory succeeded %d\n", n);
+ exit(1);
+ }
+ wait(&xstatus);
+ if(xstatus != -1 && xstatus != 2)
+ exit(1);
+}
+
+
+// test reads/writes from/to allocated memory
+void
+sbrkarg(char *s)
+{
+ char *a;
+ int fd, n;
+
+ a = sbrk(PGSIZE);
+ fd = open("sbrk", O_CREATE|O_WRONLY);
+ remove("sbrk");
+ if(fd < 0) {
+ printf("%s: open sbrk failed\n", s);
+ exit(1);
+ }
+ if ((n = write(fd, a, PGSIZE)) < 0) {
+ printf("%s: write sbrk failed\n", s);
+ exit(1);
+ }
+ close(fd);
+
+ // test writes to allocated memory
+ a = sbrk(PGSIZE);
+ if(pipe((int *) a) != 0){
+ printf("%s: pipe() failed\n", s);
+ exit(1);
+ }
+}
+
+void
+validatetest(char *s)
+{
+ int hi;
+ uint64 p;
+
+ hi = 1100*1024;
+ for(p = 0; p <= (uint)hi; p += PGSIZE){
+ // try to crash the kernel by passing in a bad string pointer
+ if(open((char*)p, O_RDONLY) != -1){
+ printf("%s: link should not succeed\n", s);
+ printf("bad string:[%s]\n", (char*)p);
+ exit(1);
+ }
+ }
+}
+
+// does unintialized data start out zero?
+char uninit[10000];
+void
+bsstest(char *s)
+{
+ int i;
+
+ for(i = 0; i < sizeof(uninit); i++){
+ if(uninit[i] != '\0'){
+ printf("%s: bss test failed\n", s);
+ exit(1);
+ }
+ }
+}
+
+// does exec return an error if the arguments
+// are larger than a page? or does it write
+// below the stack and wreck the instructions/data?
+void
+bigargtest(char *s)
+{
+ int pid, fd, xstatus;
+
+ remove("bigarg-ok");
+ pid = fork();
+ if(pid == 0){
+ static char *args[MAXARG];
+ int i;
+ for(i = 0; i < MAXARG-1; i++)
+ args[i] = "bigargs test: failed\n ";
+ args[MAXARG-1] = 0;
+ exec("echo", args);
+ fd = open("bigarg-ok", O_CREATE);
+ close(fd);
+ exit(0);
+ } else if(pid < 0){
+ printf("%s: bigargtest: fork failed\n", s);
+ exit(1);
+ }
+
+ wait(&xstatus);
+ if(xstatus != 0)
+ exit(xstatus);
+ fd = open("bigarg-ok", 0);
+ if(fd < 0){
+ printf("%s: bigarg test failed!\n", s);
+ exit(1);
+ }
+ close(fd);
+ remove("bigarg-ok");
+}
+
+// what happens when the file system runs out of blocks?
+// answer: balloc panics, so this test is not useful.
+void
+fsfull()
+{
+ int nfiles;
+ int fsblocks = 0;
+
+ printf("fsfull test\n");
+
+ for(nfiles = 0; ; nfiles++){
+ char name[64];
+ name[0] = 'f';
+ name[1] = '0' + nfiles / 1000;
+ name[2] = '0' + (nfiles % 1000) / 100;
+ name[3] = '0' + (nfiles % 100) / 10;
+ name[4] = '0' + (nfiles % 10);
+ name[5] = '\0';
+ printf("%s: writing %s\n", name);
+ int fd = open(name, O_CREATE|O_RDWR);
+ if(fd < 0){
+ printf("%s: open %s failed\n", name);
+ break;
+ }
+ int total = 0;
+ while(1){
+ int cc = write(fd, buf, BSIZE);
+ if(cc < BSIZE)
+ break;
+ total += cc;
+ fsblocks++;
+ }
+ printf("%s: wrote %d bytes\n", total);
+ close(fd);
+ if(total == 0)
+ break;
+ }
+
+ while(nfiles >= 0){
+ char name[64];
+ name[0] = 'f';
+ name[1] = '0' + nfiles / 1000;
+ name[2] = '0' + (nfiles % 1000) / 100;
+ name[3] = '0' + (nfiles % 100) / 10;
+ name[4] = '0' + (nfiles % 10);
+ name[5] = '\0';
+ remove(name);
+ nfiles--;
+ }
+
+ printf("fsfull test finished\n");
+}
+
+void argptest(char *s)
+{
+ int fd;
+ fd = open("init", O_RDONLY);
+ if (fd < 0) {
+ printf("%s: open failed\n", s);
+ exit(1);
+ }
+ read(fd, sbrk(0) - 1, -1);
+ close(fd);
+}
+
+unsigned long randstate = 1;
+unsigned int
+rand()
+{
+ randstate = randstate * 1664525 + 1013904223;
+ return randstate;
+}
+
+// check that there's an invalid page beneath
+// the user stack, to catch stack overflow.
+void
+stacktest(char *s)
+{
+ int pid;
+ int xstatus;
+
+ pid = fork();
+ if(pid == 0) {
+ char *sp = (char *) r_sp();
+ sp -= PGSIZE;
+ // the *sp should cause a trap.
+ printf("%s: stacktest: read below stack %p\n", *sp);
+ exit(1);
+ } else if(pid < 0){
+ printf("%s: fork failed\n", s);
+ exit(1);
+ }
+ wait(&xstatus);
+ if(xstatus == -1) // kernel killed child?
+ exit(0);
+ else
+ exit(xstatus);
+}
+
+// regression test. copyin(), copyout(), and copyinstr() used to cast
+// the virtual page address to uint, which (with certain wild system
+// call arguments) resulted in a kernel page faults.
+void
+pgbug(char *s)
+{
+ char *argv[1];
+ argv[0] = 0;
+ exec((char*)0xeaeb0b5b00002f5e, argv);
+
+ pipe((int*)0xeaeb0b5b00002f5e);
+
+ exit(0);
+}
+
+// regression test. does the kernel panic if a process sbrk()s its
+// size to be less than a page, or zero, or reduces the break by an
+// amount too small to cause a page to be freed?
+void
+sbrkbugs(char *s)
+{
+ int pid = fork();
+ if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ if(pid == 0){
+ int sz = (uint64) sbrk(0);
+ // free all user memory; there used to be a bug that
+ // would not adjust p->sz correctly in this case,
+ // causing exit() to panic.
+ sbrk(-sz);
+ // user page fault here.
+ exit(0);
+ }
+ wait(0);
+
+ pid = fork();
+ if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ if(pid == 0){
+ int sz = (uint64) sbrk(0);
+ // set the break to somewhere in the very first
+ // page; there used to be a bug that would incorrectly
+ // free the first page.
+ sbrk(-(sz - 3500));
+ exit(0);
+ }
+ wait(0);
+
+ pid = fork();
+ if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ }
+ if(pid == 0){
+ // set the break in the middle of a page.
+ sbrk((10*4096 + 2048) - (uint64)sbrk(0));
+
+ // reduce the break a bit, but not enough to
+ // cause a page to be freed. this used to cause
+ // a panic.
+ sbrk(-10);
+
+ exit(0);
+ }
+ wait(0);
+
+ exit(0);
+}
+
+// regression test. does write() with an invalid buffer pointer cause
+// a block to be allocated for a file that is then not freed when the
+// file is deleted? if the kernel has this bug, it will panic: balloc:
+// out of blocks. assumed_free may need to be raised to be more than
+// the number of free blocks. this test takes a long time.
+void
+badwrite(char *s)
+{
+ int assumed_free = 600;
+
+ remove("junk");
+ for(int i = 0; i < assumed_free; i++){
+ int fd = open("junk", O_CREATE|O_WRONLY);
+ if(fd < 0){
+ printf("open junk failed\n");
+ exit(1);
+ }
+ write(fd, (char*)0xffffffffffL, 1);
+ close(fd);
+ remove("junk");
+ }
+
+ int fd = open("junk", O_CREATE|O_WRONLY);
+ if(fd < 0){
+ printf("open junk failed\n");
+ exit(1);
+ }
+ if(write(fd, "x", 1) != 1){
+ printf("write failed\n");
+ exit(1);
+ }
+ close(fd);
+ remove("junk");
+
+ exit(0);
+}
+
+// regression test. test whether exec() leaks memory if one of the
+// arguments is invalid. the test passes if the kernel doesn't panic.
+void
+badarg(char *s)
+{
+ for(int i = 0; i < 50000; i++){
+ char *argv[2];
+ argv[0] = (char*)0xffffffff;
+ argv[1] = 0;
+ exec("echo", argv);
+ }
+
+ exit(0);
+}
+
+// test the exec() code that cleans up if it runs out
+// of memory. it's really a test that such a condition
+// doesn't cause a panic.
+void
+execout(char *s)
+{
+ for(int avail = 0; avail < 15; avail++){
+ int pid = fork();
+ if(pid < 0){
+ printf("fork failed\n");
+ exit(1);
+ } else if(pid == 0){
+ // allocate all of memory.
+ while(1){
+ uint64 a = (uint64) sbrk(4096);
+ if(a == 0xffffffffffffffffLL)
+ break;
+ *(char*)(a + 4096 - 1) = 1;
+ }
+
+ // free a few pages, in order to let exec() make some
+ // progress.
+ for(int i = 0; i < avail; i++)
+ sbrk(-4096);
+
+ close(1);
+ char *args[] = { "echo", "x", 0 };
+ exec("echo", args);
+ exit(0);
+ } else {
+ wait((int*)0);
+ }
+ }
+
+ exit(0);
+}
+
+//
+// use sbrk() to count how many free physical memory pages there are.
+// touches the pages to force allocation.
+// because out of memory with lazy allocation results in the process
+// taking a fault and being killed, fork and report back.
+//
+int
+countfree()
+{
+ int fds[2];
+
+ if(pipe(fds) < 0){
+ printf("pipe() failed in countfree()\n");
+ exit(1);
+ }
+
+ int pid = fork();
+
+ if(pid < 0){
+ printf("fork failed in countfree()\n");
+ exit(1);
+ }
+
+ if(pid == 0){
+ close(fds[0]);
+
+ while(1){
+ uint64 a = (uint64) sbrk(4096);
+ if(a == 0xffffffffffffffff){
+ break;
+ }
+
+ // modify the memory to make sure it's really allocated.
+ *(char *)(a + 4096 - 1) = 1;
+
+ // report back one more page.
+ if(write(fds[1], "x", 1) != 1){
+ printf("write() failed in countfree()\n");
+ exit(1);
+ }
+ }
+
+ exit(0);
+ }
+
+ close(fds[1]);
+
+ int n = 0;
+ while(1){
+ char c;
+ int cc = read(fds[0], &c, 1);
+ if(cc < 0){
+ printf("read() failed in countfree()\n");
+ exit(1);
+ }
+ if(cc == 0)
+ break;
+ n += 1;
+ }
+
+ close(fds[0]);
+ wait((int*)0);
+
+ return n;
+}
+
+// run each test in its own process. run returns 1 if child's exit()
+// indicates success.
+int
+run(void f(char *), char *s) {
+ int pid;
+ int xstatus;
+
+ printf("test %s: ", s);
+ if((pid = fork()) < 0) {
+ printf("runtest: fork error\n");
+ exit(1);
+ }
+ if(pid == 0) {
+ f(s);
+ exit(0);
+ } else {
+ wait(&xstatus);
+ if(xstatus != 0)
+ printf("FAILED\n");
+ else
+ printf("OK\n");
+ return xstatus == 0;
+ }
+}
+
+int
+main(int argc, char *argv[])
+{
+ int continuous = 0;
+ char *justone = 0;
+
+ if(argc == 2 && strcmp(argv[1], "-c") == 0){
+ continuous = 1;
+ } else if(argc == 2 && strcmp(argv[1], "-C") == 0){
+ continuous = 2;
+ } else if(argc == 2 && argv[1][0] != '-'){
+ justone = argv[1];
+ } else if(argc > 1){
+ printf("Usage: usertests [-c] [testname]\n");
+ exit(1);
+ }
+
+ struct test {
+ void (*f)(char *);
+ char *s;
+ } tests[] = {
+ {execout, "execout"},
+ {copyin, "copyin"},
+ {copyout, "copyout"},
+ {copyinstr1, "copyinstr1"},
+ {copyinstr2, "copyinstr2"},
+ {copyinstr3, "copyinstr3"},
+ {truncate1, "truncate1"},
+ {truncate2, "truncate2"},
+ {truncate3, "truncate3"},
+ {reparent2, "reparent2"},
+ {pgbug, "pgbug" },
+ {sbrkbugs, "sbrkbugs" },
+ {badwrite, "badwrite" },
+ {badarg, "badarg" },
+ {reparent, "reparent" },
+ {twochildren, "twochildren"},
+ {forkfork, "forkfork"},
+ {forkforkfork, "forkforkfork"},
+ {argptest, "argptest"},
+ {createdelete, "createdelete"},
+ // {linkremove, "linkremove"},
+ // {linktest, "linktest"},
+ {removeread, "removeread"},
+ // {concreate, "concreate"},
+ {subdir, "subdir"},
+ {fourfiles, "fourfiles"},
+ {sharedfd, "sharedfd"},
+ {exectest, "exectest"},
+ {bigargtest, "bigargtest"},
+ {bigwrite, "bigwrite"},
+ {bsstest, "bsstest"},
+ {sbrkbasic, "sbrkbasic"},
+ {sbrkmuch, "sbrkmuch"},
+ {kernmem, "kernmem"},
+ {sbrkfail, "sbrkfail"},
+ {sbrkarg, "sbrkarg"},
+ {validatetest, "validatetest"},
+ {stacktest, "stacktest"},
+ {opentest, "opentest"},
+ {writetest, "writetest"},
+ {writebig, "writebig"},
+ {createtest, "createtest"},
+ {openiputtest, "openiput"},
+ {exitiputtest, "exitiput"},
+ {iputtest, "iput"},
+ {mem, "mem"},
+ {pipe1, "pipe1"},
+ {preempt, "preempt"},
+ {exitwait, "exitwait"},
+ {rmdot, "rmdot"},
+ // {fourteen, "fourteen"},
+ {bigfile, "bigfile"},
+ {dirfile, "dirfile"},
+ {iref, "iref"},
+ {forktest, "forktest"},
+ // {bigdir, "bigdir"}, // slow
+ { 0, 0},
+ };
+
+ if(continuous){
+ printf("continuous usertests starting\n");
+ while(1){
+ int fail = 0;
+ int free0 = countfree();
+ for (struct test *t = tests; t->s != 0; t++) {
+ if(!run(t->f, t->s)){
+ fail = 1;
+ break;
+ }
+ }
+ if(fail){
+ printf("SOME TESTS FAILED\n");
+ if(continuous != 2)
+ exit(1);
+ }
+ int free1 = countfree();
+ if(free1 < free0){
+ printf("FAILED -- lost %d free pages\n", free0 - free1);
+ if(continuous != 2)
+ exit(1);
+ }
+ }
+ }
+
+ printf("usertests starting\n");
+ int free0 = countfree();
+ int free1 = 0;
+ int fail = 0;
+ for (struct test *t = tests; t->s != 0; t++) {
+ if((justone == 0) || strcmp(t->s, justone) == 0) {
+ if(!run(t->f, t->s))
+ fail = 1;
+ }
+ }
+
+ if(fail){
+ printf("SOME TESTS FAILED\n");
+ exit(1);
+ } else if((free1 = countfree()) < free0){
+ printf("FAILED -- lost some free pages %d (out of %d)\n", free1, free0);
+ exit(1);
+ } else {
+ printf("ALL TESTS PASSED\n");
+ exit(0);
+ }
+}
diff --git a/xv6-user/usertests.d b/xv6-user/usertests.d
new file mode 100644
index 0000000000000000000000000000000000000000..847686ad93cf6b0ef4055bb6523c659c8d5235cd
--- /dev/null
+++ b/xv6-user/usertests.d
@@ -0,0 +1,5 @@
+xv6-user/usertests.o: xv6-user/usertests.c kernel/include/param.h \
+ kernel/include/types.h kernel/include/stat.h xv6-user/user.h \
+ kernel/include/fcntl.h kernel/include/syscall.h kernel/include/types.h \
+ kernel/include/sysnum.h kernel/include/memlayout.h \
+ kernel/include/riscv.h
diff --git a/xv6-user/usertests.o b/xv6-user/usertests.o
new file mode 100644
index 0000000000000000000000000000000000000000..ae3d84aa1f0721bdf769c874ebe170ed7da74448
Binary files /dev/null and b/xv6-user/usertests.o differ
diff --git a/xv6-user/usertests.sym b/xv6-user/usertests.sym
new file mode 100644
index 0000000000000000000000000000000000000000..761050680a8e46d2d554efd366c7ffe59d1dc629
--- /dev/null
+++ b/xv6-user/usertests.sym
@@ -0,0 +1,140 @@
+0000000000000000 .text
+0000000000004e70 .rodata
+0000000000006d10 .data
+0000000000007078 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 usertests.c
+0000000000007180 big.0
+0000000000007080 args.1
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+00000000000049f0 putc
+0000000000004a12 printint
+0000000000006cf8 digits
+0000000000000000 umalloc.c
+000000000000c098 freep
+000000000000c0a0 base
+0000000000000b5c writebig
+000000000000464c strcpy
+000000000000166a exitwait
+0000000000004cc8 printf
+0000000000007878 __global_pointer$
+00000000000049aa dev
+0000000000001a82 bigargtest
+0000000000004852 memmove
+0000000000002eec openiputtest
+00000000000049ce trace
+000000000000341a reparent
+0000000000004732 gets
+0000000000007078 __SDATA_BEGIN__
+0000000000004980 getpid
+000000000000149c pipe1
+00000000000048e4 memcpy
+0000000000002dcc iref
+0000000000000ec0 pgbug
+0000000000004d80 malloc
+00000000000049c4 remove
+0000000000000654 copyout
+0000000000004992 sleep
+0000000000001b9c stacktest
+00000000000049d6 sysinfo
+00000000000022d4 execout
+00000000000021bc sbrkbugs
+000000000000246e exitiputtest
+00000000000049b4 readdir
+0000000000004080 fsfull
+00000000000018f0 forktest
+0000000000001102 truncate3
+00000000000002f0 bigwrite
+000000000000356e sharedfd
+0000000000006d30 randstate
+0000000000004916 pipe
+0000000000008188 uninit
+00000000000049de rename
+0000000000002bd4 dirfile
+000000000000492a write
+00000000000000d0 bsstest
+000000000000495a fstat
+0000000000004c9a fprintf
+000000000000493e kill
+0000000000000058 validatetest
+0000000000004668 strcat
+0000000000002a4e rmdot
+00000000000004ea copyin
+0000000000004abc vprintf
+0000000000000194 truncate2
+000000000000496e chdir
+00000000000012c0 exectest
+0000000000004946 exec
+00000000000003da badwrite
+000000000000490e wait
+0000000000004220 rand
+0000000000004920 read
+00000000000030be preempt
+0000000000000ef8 badarg
+000000000000214a argptest
+00000000000034ca mem
+00000000000048aa memcmp
+00000000000048fc fork
+000000000000c0b0 __BSS_END__
+0000000000001c1e copyinstr3
+00000000000017be forkfork
+000000000000498a sbrk
+00000000000049a2 test_proc
+000000000000499a uptime
+0000000000001724 twochildren
+0000000000007078 __bss_start
+00000000000046ec memset
+00000000000019d0 kernmem
+000000000000025c createtest
+0000000000004420 main
+0000000000003b5e createdelete
+0000000000002fde forkforkfork
+0000000000003260 sbrkfail
+0000000000004696 strcmp
+00000000000049e6 shutdown
+00000000000009d0 writetest
+0000000000004978 dup
+00000000000049bc getcwd
+00000000000007be truncate1
+0000000000000112 opentest
+0000000000004382 run
+0000000000002556 subdir
+0000000000000f42 copyinstr2
+000000000000a898 buf
+0000000000003de6 dirtest
+0000000000002072 sbrkarg
+0000000000002398 iputtest
+0000000000006d10 __DATA_BEGIN__
+00000000000047ac stat
+000000000000397e bigfile
+0000000000007078 _edata
+000000000000c0b0 _end
+0000000000004250 countfree
+0000000000004904 exit
+00000000000047f2 atoi
+0000000000000000 copyinstr1
+0000000000001d38 sbrkbasic
+0000000000007078 name
+00000000000046c2 strlen
+0000000000004950 open
+0000000000000d06 removeread
+000000000000470e strchr
+0000000000003edc fourteen
+000000000000372c fourfiles
+0000000000001ebc sbrkmuch
+0000000000004964 mkdir
+0000000000004934 close
+0000000000001888 reparent2
+0000000000004cfe free
diff --git a/xv6-user/usys.S b/xv6-user/usys.S
new file mode 100644
index 0000000000000000000000000000000000000000..ee106226953e314c1d3c71c95460a4f09bc408d3
--- /dev/null
+++ b/xv6-user/usys.S
@@ -0,0 +1,137 @@
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ ecall
+ ret
+.global exit
+exit:
+ li a7, SYS_exit
+ ecall
+ ret
+.global wait
+wait:
+ li a7, SYS_wait
+ ecall
+ ret
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ ecall
+ ret
+.global read
+read:
+ li a7, SYS_read
+ ecall
+ ret
+.global write
+write:
+ li a7, SYS_write
+ ecall
+ ret
+.global close
+close:
+ li a7, SYS_close
+ ecall
+ ret
+.global kill
+kill:
+ li a7, SYS_kill
+ ecall
+ ret
+.global exec
+exec:
+ li a7, SYS_exec
+ ecall
+ ret
+.global open
+open:
+ li a7, SYS_open
+ ecall
+ ret
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ ecall
+ ret
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ ecall
+ ret
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ ecall
+ ret
+.global dup
+dup:
+ li a7, SYS_dup
+ ecall
+ ret
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ ecall
+ ret
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ ecall
+ ret
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ ecall
+ ret
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ ecall
+ ret
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ ecall
+ ret
+.global dev
+dev:
+ li a7, SYS_dev
+ ecall
+ ret
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ ecall
+ ret
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ ecall
+ ret
+.global remove
+remove:
+ li a7, SYS_remove
+ ecall
+ ret
+.global trace
+trace:
+ li a7, SYS_trace
+ ecall
+ ret
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ ecall
+ ret
+.global rename
+rename:
+ li a7, SYS_rename
+ ecall
+ ret
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ ecall
+ ret
diff --git a/xv6-user/usys.d b/xv6-user/usys.d
new file mode 100644
index 0000000000000000000000000000000000000000..77ec25b3c63aa364b36357677fda1085ed7bc75d
--- /dev/null
+++ b/xv6-user/usys.d
@@ -0,0 +1 @@
+xv6-user/usys.o: xv6-user/usys.S kernel/include/sysnum.h
diff --git a/xv6-user/usys.o b/xv6-user/usys.o
new file mode 100644
index 0000000000000000000000000000000000000000..6c1a89d9ae3ac4378ea9b3febde18ca31846b7d1
Binary files /dev/null and b/xv6-user/usys.o differ
diff --git a/xv6-user/usys.pl b/xv6-user/usys.pl
new file mode 100644
index 0000000000000000000000000000000000000000..6f55cc5ec4da03bfd4dfd363836089ea8a49cb4d
--- /dev/null
+++ b/xv6-user/usys.pl
@@ -0,0 +1,45 @@
+#!/usr/bin/perl -w
+
+# Generate usys.S, the stubs for syscalls.
+
+print "# generated by usys.pl - do not edit\n";
+
+print "#include \"kernel/include/sysnum.h\"\n";
+
+sub entry {
+ my $name = shift;
+ print ".global $name\n";
+ print "${name}:\n";
+ print " li a7, SYS_${name}\n";
+ print " ecall\n";
+ print " ret\n";
+}
+
+entry("fork");
+entry("exit");
+entry("wait");
+entry("pipe");
+entry("read");
+entry("write");
+entry("close");
+entry("kill");
+entry("exec");
+entry("open");
+entry("fstat");
+entry("mkdir");
+entry("chdir");
+entry("dup");
+entry("getpid");
+entry("sbrk");
+entry("sleep");
+entry("uptime");
+entry("test_proc");
+entry("dev");
+entry("readdir");
+entry("getcwd");
+entry("remove");
+entry("trace");
+entry("sysinfo");
+entry("rename");
+entry("shutdown");
+
diff --git a/xv6-user/wc.asm b/xv6-user/wc.asm
new file mode 100644
index 0000000000000000000000000000000000000000..98e76f1d4b6ae7c91e93f40d01979afd59f5fb4c
--- /dev/null
+++ b/xv6-user/wc.asm
@@ -0,0 +1,1603 @@
+
+xv6-user/_wc: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <wc>:
+
+char buf[512];
+
+void
+wc(int fd, char *name)
+{
+ 0: 7119 addi sp,sp,-128
+ 2: fc86 sd ra,120(sp)
+ 4: f8a2 sd s0,112(sp)
+ 6: f4a6 sd s1,104(sp)
+ 8: f0ca sd s2,96(sp)
+ a: ecce sd s3,88(sp)
+ c: e8d2 sd s4,80(sp)
+ e: e4d6 sd s5,72(sp)
+ 10: e0da sd s6,64(sp)
+ 12: fc5e sd s7,56(sp)
+ 14: f862 sd s8,48(sp)
+ 16: f466 sd s9,40(sp)
+ 18: f06a sd s10,32(sp)
+ 1a: ec6e sd s11,24(sp)
+ 1c: 0100 addi s0,sp,128
+ 1e: f8a43423 sd a0,-120(s0)
+ 22: f8b43023 sd a1,-128(s0)
+ int i, n;
+ int l, w, c, inword;
+
+ l = w = c = 0;
+ inword = 0;
+ 26: 4981 li s3,0
+ l = w = c = 0;
+ 28: 4c81 li s9,0
+ 2a: 4c01 li s8,0
+ 2c: 4b81 li s7,0
+ 2e: 00001d97 auipc s11,0x1
+ 32: a73d8d93 addi s11,s11,-1421 # aa1 <buf+0x1>
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ for(i=0; i<n; i++){
+ c++;
+ if(buf[i] == '\n')
+ 36: 4aa9 li s5,10
+ l++;
+ if(strchr(" \r\t\n\v", buf[i]))
+ 38: 00001a17 auipc s4,0x1
+ 3c: 990a0a13 addi s4,s4,-1648 # 9c8 <malloc+0xec>
+ inword = 0;
+ 40: 4b01 li s6,0
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 42: a805 j 72 <wc+0x72>
+ if(strchr(" \r\t\n\v", buf[i]))
+ 44: 8552 mv a0,s4
+ 46: 00000097 auipc ra,0x0
+ 4a: 224080e7 jalr 548(ra) # 26a <strchr>
+ 4e: c919 beqz a0,64 <wc+0x64>
+ inword = 0;
+ 50: 89da mv s3,s6
+ for(i=0; i<n; i++){
+ 52: 0485 addi s1,s1,1
+ 54: 01248d63 beq s1,s2,6e <wc+0x6e>
+ if(buf[i] == '\n')
+ 58: 0004c583 lbu a1,0(s1)
+ 5c: ff5594e3 bne a1,s5,44 <wc+0x44>
+ l++;
+ 60: 2b85 addiw s7,s7,1
+ 62: b7cd j 44 <wc+0x44>
+ else if(!inword){
+ 64: fe0997e3 bnez s3,52 <wc+0x52>
+ w++;
+ 68: 2c05 addiw s8,s8,1
+ inword = 1;
+ 6a: 4985 li s3,1
+ 6c: b7dd j 52 <wc+0x52>
+ c++;
+ 6e: 01ac8cbb addw s9,s9,s10
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ 72: 20000613 li a2,512
+ 76: 00001597 auipc a1,0x1
+ 7a: a2a58593 addi a1,a1,-1494 # aa0 <buf>
+ 7e: f8843503 ld a0,-120(s0)
+ 82: 00000097 auipc ra,0x0
+ 86: 3fa080e7 jalr 1018(ra) # 47c <read>
+ 8a: 00a05f63 blez a0,a8 <wc+0xa8>
+ for(i=0; i<n; i++){
+ 8e: 00001497 auipc s1,0x1
+ 92: a1248493 addi s1,s1,-1518 # aa0 <buf>
+ 96: 00050d1b sext.w s10,a0
+ 9a: fff5091b addiw s2,a0,-1
+ 9e: 1902 slli s2,s2,0x20
+ a0: 02095913 srli s2,s2,0x20
+ a4: 996e add s2,s2,s11
+ a6: bf4d j 58 <wc+0x58>
+ }
+ }
+ }
+ if(n < 0){
+ a8: 02054e63 bltz a0,e4 <wc+0xe4>
+ printf("wc: read error\n");
+ exit(1);
+ }
+ printf("%d\t%d\t%d\t%s\n", l, w, c, name);
+ ac: f8043703 ld a4,-128(s0)
+ b0: 86e6 mv a3,s9
+ b2: 8662 mv a2,s8
+ b4: 85de mv a1,s7
+ b6: 00001517 auipc a0,0x1
+ ba: 92a50513 addi a0,a0,-1750 # 9e0 <malloc+0x104>
+ be: 00000097 auipc ra,0x0
+ c2: 766080e7 jalr 1894(ra) # 824 <printf>
+}
+ c6: 70e6 ld ra,120(sp)
+ c8: 7446 ld s0,112(sp)
+ ca: 74a6 ld s1,104(sp)
+ cc: 7906 ld s2,96(sp)
+ ce: 69e6 ld s3,88(sp)
+ d0: 6a46 ld s4,80(sp)
+ d2: 6aa6 ld s5,72(sp)
+ d4: 6b06 ld s6,64(sp)
+ d6: 7be2 ld s7,56(sp)
+ d8: 7c42 ld s8,48(sp)
+ da: 7ca2 ld s9,40(sp)
+ dc: 7d02 ld s10,32(sp)
+ de: 6de2 ld s11,24(sp)
+ e0: 6109 addi sp,sp,128
+ e2: 8082 ret
+ printf("wc: read error\n");
+ e4: 00001517 auipc a0,0x1
+ e8: 8ec50513 addi a0,a0,-1812 # 9d0 <malloc+0xf4>
+ ec: 00000097 auipc ra,0x0
+ f0: 738080e7 jalr 1848(ra) # 824 <printf>
+ exit(1);
+ f4: 4505 li a0,1
+ f6: 00000097 auipc ra,0x0
+ fa: 36a080e7 jalr 874(ra) # 460 <exit>
+
+00000000000000fe <main>:
+
+int
+main(int argc, char *argv[])
+{
+ fe: 7179 addi sp,sp,-48
+ 100: f406 sd ra,40(sp)
+ 102: f022 sd s0,32(sp)
+ 104: ec26 sd s1,24(sp)
+ 106: e84a sd s2,16(sp)
+ 108: e44e sd s3,8(sp)
+ 10a: e052 sd s4,0(sp)
+ 10c: 1800 addi s0,sp,48
+ int fd, i;
+
+ if(argc <= 1){
+ 10e: 4785 li a5,1
+ 110: 06a7d063 bge a5,a0,170 <main+0x72>
+ 114: 89aa mv s3,a0
+ 116: 892e mv s2,a1
+ wc(0, "");
+ exit(0);
+ }
+
+ printf("LINE\tWORD\tBYTE\tFILE\n");
+ 118: 00001517 auipc a0,0x1
+ 11c: 8e050513 addi a0,a0,-1824 # 9f8 <malloc+0x11c>
+ 120: 00000097 auipc ra,0x0
+ 124: 704080e7 jalr 1796(ra) # 824 <printf>
+ for(i = 1; i < argc; i++){
+ 128: 00890493 addi s1,s2,8
+ 12c: 39f9 addiw s3,s3,-2
+ 12e: 02099793 slli a5,s3,0x20
+ 132: 01d7d993 srli s3,a5,0x1d
+ 136: 0941 addi s2,s2,16
+ 138: 99ca add s3,s3,s2
+ if((fd = open(argv[i], 0)) < 0){
+ 13a: 4581 li a1,0
+ 13c: 6088 ld a0,0(s1)
+ 13e: 00000097 auipc ra,0x0
+ 142: 36e080e7 jalr 878(ra) # 4ac <open>
+ 146: 892a mv s2,a0
+ 148: 04054263 bltz a0,18c <main+0x8e>
+ printf("wc: cannot open %s\n", argv[i]);
+ exit(1);
+ }
+ wc(fd, argv[i]);
+ 14c: 608c ld a1,0(s1)
+ 14e: 00000097 auipc ra,0x0
+ 152: eb2080e7 jalr -334(ra) # 0 <wc>
+ close(fd);
+ 156: 854a mv a0,s2
+ 158: 00000097 auipc ra,0x0
+ 15c: 338080e7 jalr 824(ra) # 490 <close>
+ for(i = 1; i < argc; i++){
+ 160: 04a1 addi s1,s1,8
+ 162: fd349ce3 bne s1,s3,13a <main+0x3c>
+ }
+ exit(0);
+ 166: 4501 li a0,0
+ 168: 00000097 auipc ra,0x0
+ 16c: 2f8080e7 jalr 760(ra) # 460 <exit>
+ wc(0, "");
+ 170: 00001597 auipc a1,0x1
+ 174: 88058593 addi a1,a1,-1920 # 9f0 <malloc+0x114>
+ 178: 4501 li a0,0
+ 17a: 00000097 auipc ra,0x0
+ 17e: e86080e7 jalr -378(ra) # 0 <wc>
+ exit(0);
+ 182: 4501 li a0,0
+ 184: 00000097 auipc ra,0x0
+ 188: 2dc080e7 jalr 732(ra) # 460 <exit>
+ printf("wc: cannot open %s\n", argv[i]);
+ 18c: 608c ld a1,0(s1)
+ 18e: 00001517 auipc a0,0x1
+ 192: 88250513 addi a0,a0,-1918 # a10 <malloc+0x134>
+ 196: 00000097 auipc ra,0x0
+ 19a: 68e080e7 jalr 1678(ra) # 824 <printf>
+ exit(1);
+ 19e: 4505 li a0,1
+ 1a0: 00000097 auipc ra,0x0
+ 1a4: 2c0080e7 jalr 704(ra) # 460 <exit>
+
+00000000000001a8 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 1a8: 1141 addi sp,sp,-16
+ 1aa: e422 sd s0,8(sp)
+ 1ac: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 1ae: 87aa mv a5,a0
+ 1b0: 0585 addi a1,a1,1
+ 1b2: 0785 addi a5,a5,1
+ 1b4: fff5c703 lbu a4,-1(a1)
+ 1b8: fee78fa3 sb a4,-1(a5)
+ 1bc: fb75 bnez a4,1b0 <strcpy+0x8>
+ ;
+ return os;
+}
+ 1be: 6422 ld s0,8(sp)
+ 1c0: 0141 addi sp,sp,16
+ 1c2: 8082 ret
+
+00000000000001c4 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 1c4: 1141 addi sp,sp,-16
+ 1c6: e422 sd s0,8(sp)
+ 1c8: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 1ca: 00054783 lbu a5,0(a0)
+ 1ce: c385 beqz a5,1ee <strcat+0x2a>
+ 1d0: 87aa mv a5,a0
+ s++;
+ 1d2: 0785 addi a5,a5,1
+ while(*s)
+ 1d4: 0007c703 lbu a4,0(a5)
+ 1d8: ff6d bnez a4,1d2 <strcat+0xe>
+ while((*s++ = *t++))
+ 1da: 0585 addi a1,a1,1
+ 1dc: 0785 addi a5,a5,1
+ 1de: fff5c703 lbu a4,-1(a1)
+ 1e2: fee78fa3 sb a4,-1(a5)
+ 1e6: fb75 bnez a4,1da <strcat+0x16>
+ ;
+ return os;
+}
+ 1e8: 6422 ld s0,8(sp)
+ 1ea: 0141 addi sp,sp,16
+ 1ec: 8082 ret
+ while(*s)
+ 1ee: 87aa mv a5,a0
+ 1f0: b7ed j 1da <strcat+0x16>
+
+00000000000001f2 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 1f2: 1141 addi sp,sp,-16
+ 1f4: e422 sd s0,8(sp)
+ 1f6: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 1f8: 00054783 lbu a5,0(a0)
+ 1fc: cb91 beqz a5,210 <strcmp+0x1e>
+ 1fe: 0005c703 lbu a4,0(a1)
+ 202: 00f71763 bne a4,a5,210 <strcmp+0x1e>
+ p++, q++;
+ 206: 0505 addi a0,a0,1
+ 208: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 20a: 00054783 lbu a5,0(a0)
+ 20e: fbe5 bnez a5,1fe <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 210: 0005c503 lbu a0,0(a1)
+}
+ 214: 40a7853b subw a0,a5,a0
+ 218: 6422 ld s0,8(sp)
+ 21a: 0141 addi sp,sp,16
+ 21c: 8082 ret
+
+000000000000021e <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 21e: 1141 addi sp,sp,-16
+ 220: e422 sd s0,8(sp)
+ 222: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 224: 00054783 lbu a5,0(a0)
+ 228: cf91 beqz a5,244 <strlen+0x26>
+ 22a: 0505 addi a0,a0,1
+ 22c: 87aa mv a5,a0
+ 22e: 4685 li a3,1
+ 230: 9e89 subw a3,a3,a0
+ 232: 00f6853b addw a0,a3,a5
+ 236: 0785 addi a5,a5,1
+ 238: fff7c703 lbu a4,-1(a5)
+ 23c: fb7d bnez a4,232 <strlen+0x14>
+ ;
+ return n;
+}
+ 23e: 6422 ld s0,8(sp)
+ 240: 0141 addi sp,sp,16
+ 242: 8082 ret
+ for(n = 0; s[n]; n++)
+ 244: 4501 li a0,0
+ 246: bfe5 j 23e <strlen+0x20>
+
+0000000000000248 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 248: 1141 addi sp,sp,-16
+ 24a: e422 sd s0,8(sp)
+ 24c: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 24e: ca19 beqz a2,264 <memset+0x1c>
+ 250: 87aa mv a5,a0
+ 252: 1602 slli a2,a2,0x20
+ 254: 9201 srli a2,a2,0x20
+ 256: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 25a: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 25e: 0785 addi a5,a5,1
+ 260: fee79de3 bne a5,a4,25a <memset+0x12>
+ }
+ return dst;
+}
+ 264: 6422 ld s0,8(sp)
+ 266: 0141 addi sp,sp,16
+ 268: 8082 ret
+
+000000000000026a <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 26a: 1141 addi sp,sp,-16
+ 26c: e422 sd s0,8(sp)
+ 26e: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 270: 00054783 lbu a5,0(a0)
+ 274: cb99 beqz a5,28a <strchr+0x20>
+ if(*s == c)
+ 276: 00f58763 beq a1,a5,284 <strchr+0x1a>
+ for(; *s; s++)
+ 27a: 0505 addi a0,a0,1
+ 27c: 00054783 lbu a5,0(a0)
+ 280: fbfd bnez a5,276 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 282: 4501 li a0,0
+}
+ 284: 6422 ld s0,8(sp)
+ 286: 0141 addi sp,sp,16
+ 288: 8082 ret
+ return 0;
+ 28a: 4501 li a0,0
+ 28c: bfe5 j 284 <strchr+0x1a>
+
+000000000000028e <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 28e: 711d addi sp,sp,-96
+ 290: ec86 sd ra,88(sp)
+ 292: e8a2 sd s0,80(sp)
+ 294: e4a6 sd s1,72(sp)
+ 296: e0ca sd s2,64(sp)
+ 298: fc4e sd s3,56(sp)
+ 29a: f852 sd s4,48(sp)
+ 29c: f456 sd s5,40(sp)
+ 29e: f05a sd s6,32(sp)
+ 2a0: ec5e sd s7,24(sp)
+ 2a2: e862 sd s8,16(sp)
+ 2a4: 1080 addi s0,sp,96
+ 2a6: 8baa mv s7,a0
+ 2a8: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 2aa: 892a mv s2,a0
+ 2ac: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 2ae: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 2b2: 4b29 li s6,10
+ 2b4: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 2b6: 89a6 mv s3,s1
+ 2b8: 2485 addiw s1,s1,1
+ 2ba: 0344d763 bge s1,s4,2e8 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 2be: 4605 li a2,1
+ 2c0: 85d6 mv a1,s5
+ 2c2: 4501 li a0,0
+ 2c4: 00000097 auipc ra,0x0
+ 2c8: 1b8080e7 jalr 440(ra) # 47c <read>
+ if(cc < 1)
+ 2cc: 00a05e63 blez a0,2e8 <gets+0x5a>
+ buf[i++] = c;
+ 2d0: faf44783 lbu a5,-81(s0)
+ 2d4: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 2d8: 01678763 beq a5,s6,2e6 <gets+0x58>
+ 2dc: 0905 addi s2,s2,1
+ 2de: fd879ce3 bne a5,s8,2b6 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 2e2: 89a6 mv s3,s1
+ 2e4: a011 j 2e8 <gets+0x5a>
+ 2e6: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 2e8: 99de add s3,s3,s7
+ 2ea: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 2ee: 855e mv a0,s7
+ 2f0: 60e6 ld ra,88(sp)
+ 2f2: 6446 ld s0,80(sp)
+ 2f4: 64a6 ld s1,72(sp)
+ 2f6: 6906 ld s2,64(sp)
+ 2f8: 79e2 ld s3,56(sp)
+ 2fa: 7a42 ld s4,48(sp)
+ 2fc: 7aa2 ld s5,40(sp)
+ 2fe: 7b02 ld s6,32(sp)
+ 300: 6be2 ld s7,24(sp)
+ 302: 6c42 ld s8,16(sp)
+ 304: 6125 addi sp,sp,96
+ 306: 8082 ret
+
+0000000000000308 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 308: 1101 addi sp,sp,-32
+ 30a: ec06 sd ra,24(sp)
+ 30c: e822 sd s0,16(sp)
+ 30e: e426 sd s1,8(sp)
+ 310: e04a sd s2,0(sp)
+ 312: 1000 addi s0,sp,32
+ 314: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 316: 4581 li a1,0
+ 318: 00000097 auipc ra,0x0
+ 31c: 194080e7 jalr 404(ra) # 4ac <open>
+ if(fd < 0)
+ 320: 02054563 bltz a0,34a <stat+0x42>
+ 324: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 326: 85ca mv a1,s2
+ 328: 00000097 auipc ra,0x0
+ 32c: 18e080e7 jalr 398(ra) # 4b6 <fstat>
+ 330: 892a mv s2,a0
+ close(fd);
+ 332: 8526 mv a0,s1
+ 334: 00000097 auipc ra,0x0
+ 338: 15c080e7 jalr 348(ra) # 490 <close>
+ return r;
+}
+ 33c: 854a mv a0,s2
+ 33e: 60e2 ld ra,24(sp)
+ 340: 6442 ld s0,16(sp)
+ 342: 64a2 ld s1,8(sp)
+ 344: 6902 ld s2,0(sp)
+ 346: 6105 addi sp,sp,32
+ 348: 8082 ret
+ return -1;
+ 34a: 597d li s2,-1
+ 34c: bfc5 j 33c <stat+0x34>
+
+000000000000034e <atoi>:
+
+int
+atoi(const char *s)
+{
+ 34e: 1141 addi sp,sp,-16
+ 350: e422 sd s0,8(sp)
+ 352: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 354: 00054703 lbu a4,0(a0)
+ 358: 02d00793 li a5,45
+ int neg = 1;
+ 35c: 4585 li a1,1
+ if (*s == '-') {
+ 35e: 04f70363 beq a4,a5,3a4 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 362: 00054703 lbu a4,0(a0)
+ 366: fd07079b addiw a5,a4,-48
+ 36a: 0ff7f793 zext.b a5,a5
+ 36e: 46a5 li a3,9
+ 370: 02f6ed63 bltu a3,a5,3aa <atoi+0x5c>
+ n = 0;
+ 374: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 376: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 378: 0505 addi a0,a0,1
+ 37a: 0026979b slliw a5,a3,0x2
+ 37e: 9fb5 addw a5,a5,a3
+ 380: 0017979b slliw a5,a5,0x1
+ 384: 9fb9 addw a5,a5,a4
+ 386: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 38a: 00054703 lbu a4,0(a0)
+ 38e: fd07079b addiw a5,a4,-48
+ 392: 0ff7f793 zext.b a5,a5
+ 396: fef671e3 bgeu a2,a5,378 <atoi+0x2a>
+ return n * neg;
+}
+ 39a: 02d5853b mulw a0,a1,a3
+ 39e: 6422 ld s0,8(sp)
+ 3a0: 0141 addi sp,sp,16
+ 3a2: 8082 ret
+ s++;
+ 3a4: 0505 addi a0,a0,1
+ neg = -1;
+ 3a6: 55fd li a1,-1
+ 3a8: bf6d j 362 <atoi+0x14>
+ n = 0;
+ 3aa: 4681 li a3,0
+ 3ac: b7fd j 39a <atoi+0x4c>
+
+00000000000003ae <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 3ae: 1141 addi sp,sp,-16
+ 3b0: e422 sd s0,8(sp)
+ 3b2: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 3b4: 02b57463 bgeu a0,a1,3dc <memmove+0x2e>
+ while(n-- > 0)
+ 3b8: 00c05f63 blez a2,3d6 <memmove+0x28>
+ 3bc: 1602 slli a2,a2,0x20
+ 3be: 9201 srli a2,a2,0x20
+ 3c0: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 3c4: 872a mv a4,a0
+ *dst++ = *src++;
+ 3c6: 0585 addi a1,a1,1
+ 3c8: 0705 addi a4,a4,1
+ 3ca: fff5c683 lbu a3,-1(a1)
+ 3ce: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 3d2: fee79ae3 bne a5,a4,3c6 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 3d6: 6422 ld s0,8(sp)
+ 3d8: 0141 addi sp,sp,16
+ 3da: 8082 ret
+ dst += n;
+ 3dc: 00c50733 add a4,a0,a2
+ src += n;
+ 3e0: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 3e2: fec05ae3 blez a2,3d6 <memmove+0x28>
+ 3e6: fff6079b addiw a5,a2,-1
+ 3ea: 1782 slli a5,a5,0x20
+ 3ec: 9381 srli a5,a5,0x20
+ 3ee: fff7c793 not a5,a5
+ 3f2: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 3f4: 15fd addi a1,a1,-1
+ 3f6: 177d addi a4,a4,-1
+ 3f8: 0005c683 lbu a3,0(a1)
+ 3fc: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 400: fee79ae3 bne a5,a4,3f4 <memmove+0x46>
+ 404: bfc9 j 3d6 <memmove+0x28>
+
+0000000000000406 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 406: 1141 addi sp,sp,-16
+ 408: e422 sd s0,8(sp)
+ 40a: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 40c: ca05 beqz a2,43c <memcmp+0x36>
+ 40e: fff6069b addiw a3,a2,-1
+ 412: 1682 slli a3,a3,0x20
+ 414: 9281 srli a3,a3,0x20
+ 416: 0685 addi a3,a3,1
+ 418: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 41a: 00054783 lbu a5,0(a0)
+ 41e: 0005c703 lbu a4,0(a1)
+ 422: 00e79863 bne a5,a4,432 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 426: 0505 addi a0,a0,1
+ p2++;
+ 428: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 42a: fed518e3 bne a0,a3,41a <memcmp+0x14>
+ }
+ return 0;
+ 42e: 4501 li a0,0
+ 430: a019 j 436 <memcmp+0x30>
+ return *p1 - *p2;
+ 432: 40e7853b subw a0,a5,a4
+}
+ 436: 6422 ld s0,8(sp)
+ 438: 0141 addi sp,sp,16
+ 43a: 8082 ret
+ return 0;
+ 43c: 4501 li a0,0
+ 43e: bfe5 j 436 <memcmp+0x30>
+
+0000000000000440 <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 440: 1141 addi sp,sp,-16
+ 442: e406 sd ra,8(sp)
+ 444: e022 sd s0,0(sp)
+ 446: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 448: 00000097 auipc ra,0x0
+ 44c: f66080e7 jalr -154(ra) # 3ae <memmove>
+}
+ 450: 60a2 ld ra,8(sp)
+ 452: 6402 ld s0,0(sp)
+ 454: 0141 addi sp,sp,16
+ 456: 8082 ret
+
+0000000000000458 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 458: 4885 li a7,1
+ ecall
+ 45a: 00000073 ecall
+ ret
+ 45e: 8082 ret
+
+0000000000000460 <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 460: 05d00893 li a7,93
+ ecall
+ 464: 00000073 ecall
+ ret
+ 468: 8082 ret
+
+000000000000046a <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 46a: 488d li a7,3
+ ecall
+ 46c: 00000073 ecall
+ ret
+ 470: 8082 ret
+
+0000000000000472 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 472: 03b00893 li a7,59
+ ecall
+ 476: 00000073 ecall
+ ret
+ 47a: 8082 ret
+
+000000000000047c <read>:
+.global read
+read:
+ li a7, SYS_read
+ 47c: 03f00893 li a7,63
+ ecall
+ 480: 00000073 ecall
+ ret
+ 484: 8082 ret
+
+0000000000000486 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 486: 04000893 li a7,64
+ ecall
+ 48a: 00000073 ecall
+ ret
+ 48e: 8082 ret
+
+0000000000000490 <close>:
+.global close
+close:
+ li a7, SYS_close
+ 490: 03900893 li a7,57
+ ecall
+ 494: 00000073 ecall
+ ret
+ 498: 8082 ret
+
+000000000000049a <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 49a: 4899 li a7,6
+ ecall
+ 49c: 00000073 ecall
+ ret
+ 4a0: 8082 ret
+
+00000000000004a2 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 4a2: 0dd00893 li a7,221
+ ecall
+ 4a6: 00000073 ecall
+ ret
+ 4aa: 8082 ret
+
+00000000000004ac <open>:
+.global open
+open:
+ li a7, SYS_open
+ 4ac: 03800893 li a7,56
+ ecall
+ 4b0: 00000073 ecall
+ ret
+ 4b4: 8082 ret
+
+00000000000004b6 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 4b6: 05000893 li a7,80
+ ecall
+ 4ba: 00000073 ecall
+ ret
+ 4be: 8082 ret
+
+00000000000004c0 <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 4c0: 02200893 li a7,34
+ ecall
+ 4c4: 00000073 ecall
+ ret
+ 4c8: 8082 ret
+
+00000000000004ca <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 4ca: 03100893 li a7,49
+ ecall
+ 4ce: 00000073 ecall
+ ret
+ 4d2: 8082 ret
+
+00000000000004d4 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 4d4: 48dd li a7,23
+ ecall
+ 4d6: 00000073 ecall
+ ret
+ 4da: 8082 ret
+
+00000000000004dc <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 4dc: 0ac00893 li a7,172
+ ecall
+ 4e0: 00000073 ecall
+ ret
+ 4e4: 8082 ret
+
+00000000000004e6 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 4e6: 48b1 li a7,12
+ ecall
+ 4e8: 00000073 ecall
+ ret
+ 4ec: 8082 ret
+
+00000000000004ee <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 4ee: 48b5 li a7,13
+ ecall
+ 4f0: 00000073 ecall
+ ret
+ 4f4: 8082 ret
+
+00000000000004f6 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 4f6: 48b9 li a7,14
+ ecall
+ 4f8: 00000073 ecall
+ ret
+ 4fc: 8082 ret
+
+00000000000004fe <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 4fe: 48d9 li a7,22
+ ecall
+ 500: 00000073 ecall
+ ret
+ 504: 8082 ret
+
+0000000000000506 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 506: 03200893 li a7,50
+ ecall
+ 50a: 00000073 ecall
+ ret
+ 50e: 8082 ret
+
+0000000000000510 <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 510: 48ed li a7,27
+ ecall
+ 512: 00000073 ecall
+ ret
+ 516: 8082 ret
+
+0000000000000518 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 518: 48c5 li a7,17
+ ecall
+ 51a: 00000073 ecall
+ ret
+ 51e: 8082 ret
+
+0000000000000520 <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 520: 07500893 li a7,117
+ ecall
+ 524: 00000073 ecall
+ ret
+ 528: 8082 ret
+
+000000000000052a <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 52a: 48c9 li a7,18
+ ecall
+ 52c: 00000073 ecall
+ ret
+ 530: 8082 ret
+
+0000000000000532 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 532: 48cd li a7,19
+ ecall
+ 534: 00000073 ecall
+ ret
+ 538: 8082 ret
+
+000000000000053a <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 53a: 48e9 li a7,26
+ ecall
+ 53c: 00000073 ecall
+ ret
+ 540: 8082 ret
+
+0000000000000542 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 542: 0d200893 li a7,210
+ ecall
+ 546: 00000073 ecall
+ ret
+ 54a: 8082 ret
+
+000000000000054c <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 54c: 1101 addi sp,sp,-32
+ 54e: ec06 sd ra,24(sp)
+ 550: e822 sd s0,16(sp)
+ 552: 1000 addi s0,sp,32
+ 554: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 558: 4605 li a2,1
+ 55a: fef40593 addi a1,s0,-17
+ 55e: 00000097 auipc ra,0x0
+ 562: f28080e7 jalr -216(ra) # 486 <write>
+}
+ 566: 60e2 ld ra,24(sp)
+ 568: 6442 ld s0,16(sp)
+ 56a: 6105 addi sp,sp,32
+ 56c: 8082 ret
+
+000000000000056e <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 56e: 7139 addi sp,sp,-64
+ 570: fc06 sd ra,56(sp)
+ 572: f822 sd s0,48(sp)
+ 574: f426 sd s1,40(sp)
+ 576: f04a sd s2,32(sp)
+ 578: ec4e sd s3,24(sp)
+ 57a: 0080 addi s0,sp,64
+ 57c: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 57e: c299 beqz a3,584 <printint+0x16>
+ 580: 0805c863 bltz a1,610 <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 584: 2581 sext.w a1,a1
+ neg = 0;
+ 586: 4881 li a7,0
+ }
+
+ i = 0;
+ 588: fc040993 addi s3,s0,-64
+ neg = 0;
+ 58c: 86ce mv a3,s3
+ i = 0;
+ 58e: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 590: 2601 sext.w a2,a2
+ 592: 00000517 auipc a0,0x0
+ 596: 4f650513 addi a0,a0,1270 # a88 <digits>
+ 59a: 883a mv a6,a4
+ 59c: 2705 addiw a4,a4,1
+ 59e: 02c5f7bb remuw a5,a1,a2
+ 5a2: 1782 slli a5,a5,0x20
+ 5a4: 9381 srli a5,a5,0x20
+ 5a6: 97aa add a5,a5,a0
+ 5a8: 0007c783 lbu a5,0(a5)
+ 5ac: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 5b0: 0005879b sext.w a5,a1
+ 5b4: 02c5d5bb divuw a1,a1,a2
+ 5b8: 0685 addi a3,a3,1
+ 5ba: fec7f0e3 bgeu a5,a2,59a <printint+0x2c>
+ if(neg)
+ 5be: 00088c63 beqz a7,5d6 <printint+0x68>
+ buf[i++] = '-';
+ 5c2: fd070793 addi a5,a4,-48
+ 5c6: 00878733 add a4,a5,s0
+ 5ca: 02d00793 li a5,45
+ 5ce: fef70823 sb a5,-16(a4)
+ 5d2: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 5d6: 02e05663 blez a4,602 <printint+0x94>
+ 5da: fc040913 addi s2,s0,-64
+ 5de: 993a add s2,s2,a4
+ 5e0: 19fd addi s3,s3,-1
+ 5e2: 99ba add s3,s3,a4
+ 5e4: 377d addiw a4,a4,-1
+ 5e6: 1702 slli a4,a4,0x20
+ 5e8: 9301 srli a4,a4,0x20
+ 5ea: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 5ee: fff94583 lbu a1,-1(s2)
+ 5f2: 8526 mv a0,s1
+ 5f4: 00000097 auipc ra,0x0
+ 5f8: f58080e7 jalr -168(ra) # 54c <putc>
+ while(--i >= 0)
+ 5fc: 197d addi s2,s2,-1
+ 5fe: ff3918e3 bne s2,s3,5ee <printint+0x80>
+}
+ 602: 70e2 ld ra,56(sp)
+ 604: 7442 ld s0,48(sp)
+ 606: 74a2 ld s1,40(sp)
+ 608: 7902 ld s2,32(sp)
+ 60a: 69e2 ld s3,24(sp)
+ 60c: 6121 addi sp,sp,64
+ 60e: 8082 ret
+ x = -xx;
+ 610: 40b005bb negw a1,a1
+ neg = 1;
+ 614: 4885 li a7,1
+ x = -xx;
+ 616: bf8d j 588 <printint+0x1a>
+
+0000000000000618 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 618: 7119 addi sp,sp,-128
+ 61a: fc86 sd ra,120(sp)
+ 61c: f8a2 sd s0,112(sp)
+ 61e: f4a6 sd s1,104(sp)
+ 620: f0ca sd s2,96(sp)
+ 622: ecce sd s3,88(sp)
+ 624: e8d2 sd s4,80(sp)
+ 626: e4d6 sd s5,72(sp)
+ 628: e0da sd s6,64(sp)
+ 62a: fc5e sd s7,56(sp)
+ 62c: f862 sd s8,48(sp)
+ 62e: f466 sd s9,40(sp)
+ 630: f06a sd s10,32(sp)
+ 632: ec6e sd s11,24(sp)
+ 634: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 636: 0005c903 lbu s2,0(a1)
+ 63a: 18090f63 beqz s2,7d8 <vprintf+0x1c0>
+ 63e: 8aaa mv s5,a0
+ 640: 8b32 mv s6,a2
+ 642: 00158493 addi s1,a1,1
+ state = 0;
+ 646: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 648: 02500a13 li s4,37
+ 64c: 4c55 li s8,21
+ 64e: 00000c97 auipc s9,0x0
+ 652: 3e2c8c93 addi s9,s9,994 # a30 <malloc+0x154>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 656: 02800d93 li s11,40
+ putc(fd, 'x');
+ 65a: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 65c: 00000b97 auipc s7,0x0
+ 660: 42cb8b93 addi s7,s7,1068 # a88 <digits>
+ 664: a839 j 682 <vprintf+0x6a>
+ putc(fd, c);
+ 666: 85ca mv a1,s2
+ 668: 8556 mv a0,s5
+ 66a: 00000097 auipc ra,0x0
+ 66e: ee2080e7 jalr -286(ra) # 54c <putc>
+ 672: a019 j 678 <vprintf+0x60>
+ } else if(state == '%'){
+ 674: 01498d63 beq s3,s4,68e <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 678: 0485 addi s1,s1,1
+ 67a: fff4c903 lbu s2,-1(s1)
+ 67e: 14090d63 beqz s2,7d8 <vprintf+0x1c0>
+ if(state == 0){
+ 682: fe0999e3 bnez s3,674 <vprintf+0x5c>
+ if(c == '%'){
+ 686: ff4910e3 bne s2,s4,666 <vprintf+0x4e>
+ state = '%';
+ 68a: 89d2 mv s3,s4
+ 68c: b7f5 j 678 <vprintf+0x60>
+ if(c == 'd'){
+ 68e: 11490c63 beq s2,s4,7a6 <vprintf+0x18e>
+ 692: f9d9079b addiw a5,s2,-99
+ 696: 0ff7f793 zext.b a5,a5
+ 69a: 10fc6e63 bltu s8,a5,7b6 <vprintf+0x19e>
+ 69e: f9d9079b addiw a5,s2,-99
+ 6a2: 0ff7f713 zext.b a4,a5
+ 6a6: 10ec6863 bltu s8,a4,7b6 <vprintf+0x19e>
+ 6aa: 00271793 slli a5,a4,0x2
+ 6ae: 97e6 add a5,a5,s9
+ 6b0: 439c lw a5,0(a5)
+ 6b2: 97e6 add a5,a5,s9
+ 6b4: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 6b6: 008b0913 addi s2,s6,8
+ 6ba: 4685 li a3,1
+ 6bc: 4629 li a2,10
+ 6be: 000b2583 lw a1,0(s6)
+ 6c2: 8556 mv a0,s5
+ 6c4: 00000097 auipc ra,0x0
+ 6c8: eaa080e7 jalr -342(ra) # 56e <printint>
+ 6cc: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 6ce: 4981 li s3,0
+ 6d0: b765 j 678 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 6d2: 008b0913 addi s2,s6,8
+ 6d6: 4681 li a3,0
+ 6d8: 4629 li a2,10
+ 6da: 000b2583 lw a1,0(s6)
+ 6de: 8556 mv a0,s5
+ 6e0: 00000097 auipc ra,0x0
+ 6e4: e8e080e7 jalr -370(ra) # 56e <printint>
+ 6e8: 8b4a mv s6,s2
+ state = 0;
+ 6ea: 4981 li s3,0
+ 6ec: b771 j 678 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 6ee: 008b0913 addi s2,s6,8
+ 6f2: 4681 li a3,0
+ 6f4: 866a mv a2,s10
+ 6f6: 000b2583 lw a1,0(s6)
+ 6fa: 8556 mv a0,s5
+ 6fc: 00000097 auipc ra,0x0
+ 700: e72080e7 jalr -398(ra) # 56e <printint>
+ 704: 8b4a mv s6,s2
+ state = 0;
+ 706: 4981 li s3,0
+ 708: bf85 j 678 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 70a: 008b0793 addi a5,s6,8
+ 70e: f8f43423 sd a5,-120(s0)
+ 712: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 716: 03000593 li a1,48
+ 71a: 8556 mv a0,s5
+ 71c: 00000097 auipc ra,0x0
+ 720: e30080e7 jalr -464(ra) # 54c <putc>
+ putc(fd, 'x');
+ 724: 07800593 li a1,120
+ 728: 8556 mv a0,s5
+ 72a: 00000097 auipc ra,0x0
+ 72e: e22080e7 jalr -478(ra) # 54c <putc>
+ 732: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 734: 03c9d793 srli a5,s3,0x3c
+ 738: 97de add a5,a5,s7
+ 73a: 0007c583 lbu a1,0(a5)
+ 73e: 8556 mv a0,s5
+ 740: 00000097 auipc ra,0x0
+ 744: e0c080e7 jalr -500(ra) # 54c <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 748: 0992 slli s3,s3,0x4
+ 74a: 397d addiw s2,s2,-1
+ 74c: fe0914e3 bnez s2,734 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 750: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 754: 4981 li s3,0
+ 756: b70d j 678 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 758: 008b0913 addi s2,s6,8
+ 75c: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 760: 02098163 beqz s3,782 <vprintf+0x16a>
+ while(*s != 0){
+ 764: 0009c583 lbu a1,0(s3)
+ 768: c5ad beqz a1,7d2 <vprintf+0x1ba>
+ putc(fd, *s);
+ 76a: 8556 mv a0,s5
+ 76c: 00000097 auipc ra,0x0
+ 770: de0080e7 jalr -544(ra) # 54c <putc>
+ s++;
+ 774: 0985 addi s3,s3,1
+ while(*s != 0){
+ 776: 0009c583 lbu a1,0(s3)
+ 77a: f9e5 bnez a1,76a <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 77c: 8b4a mv s6,s2
+ state = 0;
+ 77e: 4981 li s3,0
+ 780: bde5 j 678 <vprintf+0x60>
+ s = "(null)";
+ 782: 00000997 auipc s3,0x0
+ 786: 2a698993 addi s3,s3,678 # a28 <malloc+0x14c>
+ while(*s != 0){
+ 78a: 85ee mv a1,s11
+ 78c: bff9 j 76a <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 78e: 008b0913 addi s2,s6,8
+ 792: 000b4583 lbu a1,0(s6)
+ 796: 8556 mv a0,s5
+ 798: 00000097 auipc ra,0x0
+ 79c: db4080e7 jalr -588(ra) # 54c <putc>
+ 7a0: 8b4a mv s6,s2
+ state = 0;
+ 7a2: 4981 li s3,0
+ 7a4: bdd1 j 678 <vprintf+0x60>
+ putc(fd, c);
+ 7a6: 85d2 mv a1,s4
+ 7a8: 8556 mv a0,s5
+ 7aa: 00000097 auipc ra,0x0
+ 7ae: da2080e7 jalr -606(ra) # 54c <putc>
+ state = 0;
+ 7b2: 4981 li s3,0
+ 7b4: b5d1 j 678 <vprintf+0x60>
+ putc(fd, '%');
+ 7b6: 85d2 mv a1,s4
+ 7b8: 8556 mv a0,s5
+ 7ba: 00000097 auipc ra,0x0
+ 7be: d92080e7 jalr -622(ra) # 54c <putc>
+ putc(fd, c);
+ 7c2: 85ca mv a1,s2
+ 7c4: 8556 mv a0,s5
+ 7c6: 00000097 auipc ra,0x0
+ 7ca: d86080e7 jalr -634(ra) # 54c <putc>
+ state = 0;
+ 7ce: 4981 li s3,0
+ 7d0: b565 j 678 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 7d2: 8b4a mv s6,s2
+ state = 0;
+ 7d4: 4981 li s3,0
+ 7d6: b54d j 678 <vprintf+0x60>
+ }
+ }
+}
+ 7d8: 70e6 ld ra,120(sp)
+ 7da: 7446 ld s0,112(sp)
+ 7dc: 74a6 ld s1,104(sp)
+ 7de: 7906 ld s2,96(sp)
+ 7e0: 69e6 ld s3,88(sp)
+ 7e2: 6a46 ld s4,80(sp)
+ 7e4: 6aa6 ld s5,72(sp)
+ 7e6: 6b06 ld s6,64(sp)
+ 7e8: 7be2 ld s7,56(sp)
+ 7ea: 7c42 ld s8,48(sp)
+ 7ec: 7ca2 ld s9,40(sp)
+ 7ee: 7d02 ld s10,32(sp)
+ 7f0: 6de2 ld s11,24(sp)
+ 7f2: 6109 addi sp,sp,128
+ 7f4: 8082 ret
+
+00000000000007f6 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 7f6: 715d addi sp,sp,-80
+ 7f8: ec06 sd ra,24(sp)
+ 7fa: e822 sd s0,16(sp)
+ 7fc: 1000 addi s0,sp,32
+ 7fe: e010 sd a2,0(s0)
+ 800: e414 sd a3,8(s0)
+ 802: e818 sd a4,16(s0)
+ 804: ec1c sd a5,24(s0)
+ 806: 03043023 sd a6,32(s0)
+ 80a: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 80e: 8622 mv a2,s0
+ 810: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 814: 00000097 auipc ra,0x0
+ 818: e04080e7 jalr -508(ra) # 618 <vprintf>
+}
+ 81c: 60e2 ld ra,24(sp)
+ 81e: 6442 ld s0,16(sp)
+ 820: 6161 addi sp,sp,80
+ 822: 8082 ret
+
+0000000000000824 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 824: 711d addi sp,sp,-96
+ 826: ec06 sd ra,24(sp)
+ 828: e822 sd s0,16(sp)
+ 82a: 1000 addi s0,sp,32
+ 82c: e40c sd a1,8(s0)
+ 82e: e810 sd a2,16(s0)
+ 830: ec14 sd a3,24(s0)
+ 832: f018 sd a4,32(s0)
+ 834: f41c sd a5,40(s0)
+ 836: 03043823 sd a6,48(s0)
+ 83a: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 83e: 00840613 addi a2,s0,8
+ 842: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 846: 85aa mv a1,a0
+ 848: 4505 li a0,1
+ 84a: 00000097 auipc ra,0x0
+ 84e: dce080e7 jalr -562(ra) # 618 <vprintf>
+}
+ 852: 60e2 ld ra,24(sp)
+ 854: 6442 ld s0,16(sp)
+ 856: 6125 addi sp,sp,96
+ 858: 8082 ret
+
+000000000000085a <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 85a: 1141 addi sp,sp,-16
+ 85c: e422 sd s0,8(sp)
+ 85e: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 860: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 864: 00000797 auipc a5,0x0
+ 868: 43c7b783 ld a5,1084(a5) # ca0 <freep>
+ 86c: a02d j 896 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 86e: 4618 lw a4,8(a2)
+ 870: 9f2d addw a4,a4,a1
+ 872: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 876: 6398 ld a4,0(a5)
+ 878: 6310 ld a2,0(a4)
+ 87a: a83d j 8b8 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 87c: ff852703 lw a4,-8(a0)
+ 880: 9f31 addw a4,a4,a2
+ 882: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 884: ff053683 ld a3,-16(a0)
+ 888: a091 j 8cc <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 88a: 6398 ld a4,0(a5)
+ 88c: 00e7e463 bltu a5,a4,894 <free+0x3a>
+ 890: 00e6ea63 bltu a3,a4,8a4 <free+0x4a>
+{
+ 894: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 896: fed7fae3 bgeu a5,a3,88a <free+0x30>
+ 89a: 6398 ld a4,0(a5)
+ 89c: 00e6e463 bltu a3,a4,8a4 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8a0: fee7eae3 bltu a5,a4,894 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 8a4: ff852583 lw a1,-8(a0)
+ 8a8: 6390 ld a2,0(a5)
+ 8aa: 02059813 slli a6,a1,0x20
+ 8ae: 01c85713 srli a4,a6,0x1c
+ 8b2: 9736 add a4,a4,a3
+ 8b4: fae60de3 beq a2,a4,86e <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8b8: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 8bc: 4790 lw a2,8(a5)
+ 8be: 02061593 slli a1,a2,0x20
+ 8c2: 01c5d713 srli a4,a1,0x1c
+ 8c6: 973e add a4,a4,a5
+ 8c8: fae68ae3 beq a3,a4,87c <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 8cc: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 8ce: 00000717 auipc a4,0x0
+ 8d2: 3cf73923 sd a5,978(a4) # ca0 <freep>
+}
+ 8d6: 6422 ld s0,8(sp)
+ 8d8: 0141 addi sp,sp,16
+ 8da: 8082 ret
+
+00000000000008dc <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 8dc: 7139 addi sp,sp,-64
+ 8de: fc06 sd ra,56(sp)
+ 8e0: f822 sd s0,48(sp)
+ 8e2: f426 sd s1,40(sp)
+ 8e4: f04a sd s2,32(sp)
+ 8e6: ec4e sd s3,24(sp)
+ 8e8: e852 sd s4,16(sp)
+ 8ea: e456 sd s5,8(sp)
+ 8ec: e05a sd s6,0(sp)
+ 8ee: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 8f0: 02051493 slli s1,a0,0x20
+ 8f4: 9081 srli s1,s1,0x20
+ 8f6: 04bd addi s1,s1,15
+ 8f8: 8091 srli s1,s1,0x4
+ 8fa: 00148a1b addiw s4,s1,1
+ 8fe: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 900: 00000517 auipc a0,0x0
+ 904: 3a053503 ld a0,928(a0) # ca0 <freep>
+ 908: c515 beqz a0,934 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 90a: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 90c: 4798 lw a4,8(a5)
+ 90e: 04977163 bgeu a4,s1,950 <malloc+0x74>
+ 912: 89d2 mv s3,s4
+ 914: 000a071b sext.w a4,s4
+ 918: 6685 lui a3,0x1
+ 91a: 00d77363 bgeu a4,a3,920 <malloc+0x44>
+ 91e: 6985 lui s3,0x1
+ 920: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 924: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 928: 00000917 auipc s2,0x0
+ 92c: 37890913 addi s2,s2,888 # ca0 <freep>
+ if(p == (char*)-1)
+ 930: 5afd li s5,-1
+ 932: a8a5 j 9aa <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 934: 00000797 auipc a5,0x0
+ 938: 36c78793 addi a5,a5,876 # ca0 <freep>
+ 93c: 00000717 auipc a4,0x0
+ 940: 36c70713 addi a4,a4,876 # ca8 <base>
+ 944: e398 sd a4,0(a5)
+ 946: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 948: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 94c: 87ba mv a5,a4
+ 94e: b7d1 j 912 <malloc+0x36>
+ if(p->s.size == nunits)
+ 950: 02e48c63 beq s1,a4,988 <malloc+0xac>
+ p->s.size -= nunits;
+ 954: 4147073b subw a4,a4,s4
+ 958: c798 sw a4,8(a5)
+ p += p->s.size;
+ 95a: 02071693 slli a3,a4,0x20
+ 95e: 01c6d713 srli a4,a3,0x1c
+ 962: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 964: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 968: 00000717 auipc a4,0x0
+ 96c: 32a73c23 sd a0,824(a4) # ca0 <freep>
+ return (void*)(p + 1);
+ 970: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 974: 70e2 ld ra,56(sp)
+ 976: 7442 ld s0,48(sp)
+ 978: 74a2 ld s1,40(sp)
+ 97a: 7902 ld s2,32(sp)
+ 97c: 69e2 ld s3,24(sp)
+ 97e: 6a42 ld s4,16(sp)
+ 980: 6aa2 ld s5,8(sp)
+ 982: 6b02 ld s6,0(sp)
+ 984: 6121 addi sp,sp,64
+ 986: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 988: 6398 ld a4,0(a5)
+ 98a: e118 sd a4,0(a0)
+ 98c: bff1 j 968 <malloc+0x8c>
+ hp->s.size = nu;
+ 98e: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 992: 0541 addi a0,a0,16
+ 994: 00000097 auipc ra,0x0
+ 998: ec6080e7 jalr -314(ra) # 85a <free>
+ return freep;
+ 99c: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 9a0: d971 beqz a0,974 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 9a2: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 9a4: 4798 lw a4,8(a5)
+ 9a6: fa9775e3 bgeu a4,s1,950 <malloc+0x74>
+ if(p == freep)
+ 9aa: 00093703 ld a4,0(s2)
+ 9ae: 853e mv a0,a5
+ 9b0: fef719e3 bne a4,a5,9a2 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 9b4: 854e mv a0,s3
+ 9b6: 00000097 auipc ra,0x0
+ 9ba: b30080e7 jalr -1232(ra) # 4e6 <sbrk>
+ if(p == (char*)-1)
+ 9be: fd5518e3 bne a0,s5,98e <malloc+0xb2>
+ return 0;
+ 9c2: 4501 li a0,0
+ 9c4: bf45 j 974 <malloc+0x98>
diff --git a/xv6-user/wc.c b/xv6-user/wc.c
new file mode 100644
index 0000000000000000000000000000000000000000..6e7beb682125056d521be8d06ef9d5effc70f262
--- /dev/null
+++ b/xv6-user/wc.c
@@ -0,0 +1,55 @@
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+char buf[512];
+
+void
+wc(int fd, char *name)
+{
+ int i, n;
+ int l, w, c, inword;
+
+ l = w = c = 0;
+ inword = 0;
+ while((n = read(fd, buf, sizeof(buf))) > 0){
+ for(i=0; i<n; i++){
+ c++;
+ if(buf[i] == '\n')
+ l++;
+ if(strchr(" \r\t\n\v", buf[i]))
+ inword = 0;
+ else if(!inword){
+ w++;
+ inword = 1;
+ }
+ }
+ }
+ if(n < 0){
+ printf("wc: read error\n");
+ exit(1);
+ }
+ printf("%d\t%d\t%d\t%s\n", l, w, c, name);
+}
+
+int
+main(int argc, char *argv[])
+{
+ int fd, i;
+
+ if(argc <= 1){
+ wc(0, "");
+ exit(0);
+ }
+
+ printf("LINE\tWORD\tBYTE\tFILE\n");
+ for(i = 1; i < argc; i++){
+ if((fd = open(argv[i], 0)) < 0){
+ printf("wc: cannot open %s\n", argv[i]);
+ exit(1);
+ }
+ wc(fd, argv[i]);
+ close(fd);
+ }
+ exit(0);
+}
diff --git a/xv6-user/wc.d b/xv6-user/wc.d
new file mode 100644
index 0000000000000000000000000000000000000000..bd3be8c175471e5da8f844b6b402c592b0102506
--- /dev/null
+++ b/xv6-user/wc.d
@@ -0,0 +1,2 @@
+xv6-user/wc.o: xv6-user/wc.c kernel/include/types.h kernel/include/stat.h \
+ xv6-user/user.h kernel/include/fcntl.h
diff --git a/xv6-user/wc.o b/xv6-user/wc.o
new file mode 100644
index 0000000000000000000000000000000000000000..1f6328be04d82e7c96d1a79d292941bb2d9d533d
Binary files /dev/null and b/xv6-user/wc.o differ
diff --git a/xv6-user/wc.sym b/xv6-user/wc.sym
new file mode 100644
index 0000000000000000000000000000000000000000..9b9b452b3f7969378444785287fcbb4fbd5ac501
--- /dev/null
+++ b/xv6-user/wc.sym
@@ -0,0 +1,78 @@
+0000000000000000 .text
+00000000000009c8 .rodata
+0000000000000aa0 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 wc.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+000000000000054c putc
+000000000000056e printint
+0000000000000a88 digits
+0000000000000000 umalloc.c
+0000000000000ca0 freep
+0000000000000ca8 base
+00000000000001a8 strcpy
+0000000000000824 printf
+0000000000001299 __global_pointer$
+0000000000000506 dev
+00000000000003ae memmove
+000000000000052a trace
+000000000000028e gets
+0000000000000a99 __SDATA_BEGIN__
+00000000000004dc getpid
+0000000000000440 memcpy
+00000000000008dc malloc
+0000000000000520 remove
+00000000000004ee sleep
+0000000000000532 sysinfo
+0000000000000510 readdir
+0000000000000472 pipe
+000000000000053a rename
+0000000000000486 write
+00000000000004b6 fstat
+00000000000007f6 fprintf
+000000000000049a kill
+00000000000001c4 strcat
+0000000000000618 vprintf
+00000000000004ca chdir
+00000000000004a2 exec
+000000000000046a wait
+000000000000047c read
+0000000000000000 wc
+0000000000000406 memcmp
+0000000000000458 fork
+0000000000000cb8 __BSS_END__
+00000000000004e6 sbrk
+00000000000004fe test_proc
+00000000000004f6 uptime
+0000000000000a99 __bss_start
+0000000000000248 memset
+00000000000000fe main
+00000000000001f2 strcmp
+0000000000000542 shutdown
+00000000000004d4 dup
+0000000000000518 getcwd
+0000000000000aa0 buf
+0000000000000a99 __DATA_BEGIN__
+0000000000000308 stat
+0000000000000a99 _edata
+0000000000000cb8 _end
+0000000000000460 exit
+000000000000034e atoi
+000000000000021e strlen
+00000000000004ac open
+000000000000026a strchr
+00000000000004c0 mkdir
+0000000000000490 close
+000000000000085a free
diff --git a/xv6-user/xargs.asm b/xv6-user/xargs.asm
new file mode 100644
index 0000000000000000000000000000000000000000..ac596ffb28e26ee22c2c670ff515cee0c2f4e0f5
--- /dev/null
+++ b/xv6-user/xargs.asm
@@ -0,0 +1,1602 @@
+
+xv6-user/_xargs: file format elf64-littleriscv
+
+
+Disassembly of section .text:
+
+0000000000000000 <readline>:
+/**
+ * len: include the 0 in the end.
+ * return: the number of bytes that read successfully (0 in the end is not included)
+ */
+int readline(int fd, char *buf, int len)
+{
+ 0: 7139 addi sp,sp,-64
+ 2: fc06 sd ra,56(sp)
+ 4: f822 sd s0,48(sp)
+ 6: f426 sd s1,40(sp)
+ 8: f04a sd s2,32(sp)
+ a: ec4e sd s3,24(sp)
+ c: e852 sd s4,16(sp)
+ e: e456 sd s5,8(sp)
+ 10: 0080 addi s0,sp,64
+ 12: 89aa mv s3,a0
+ 14: 892e mv s2,a1
+ char *p = buf;
+ 16: 84ae mv s1,a1
+ while (read(fd, p, 1) != 0 && p < buf + len) {
+ 18: 00c58a33 add s4,a1,a2
+ if (*p == '\n') {
+ 1c: 4aa9 li s5,10
+ while (read(fd, p, 1) != 0 && p < buf + len) {
+ 1e: a011 j 22 <readline+0x22>
+ continue;
+ }
+ *p = '\0';
+ break;
+ }
+ p++;
+ 20: 0485 addi s1,s1,1
+ while (read(fd, p, 1) != 0 && p < buf + len) {
+ 22: 4605 li a2,1
+ 24: 85a6 mv a1,s1
+ 26: 854e mv a0,s3
+ 28: 00000097 auipc ra,0x0
+ 2c: 462080e7 jalr 1122(ra) # 48a <read>
+ 30: c905 beqz a0,60 <readline+0x60>
+ 32: 0344f763 bgeu s1,s4,60 <readline+0x60>
+ if (*p == '\n') {
+ 36: 0004c783 lbu a5,0(s1)
+ 3a: ff5793e3 bne a5,s5,20 <readline+0x20>
+ if (p == buf) { // ignore empty line
+ 3e: 01248f63 beq s1,s2,5c <readline+0x5c>
+ *p = '\0';
+ 42: 00048023 sb zero,0(s1)
+ }
+ if (p == buf) {
+ return 0;
+ }
+ return p - buf;
+ 46: 4124853b subw a0,s1,s2
+}
+ 4a: 70e2 ld ra,56(sp)
+ 4c: 7442 ld s0,48(sp)
+ 4e: 74a2 ld s1,40(sp)
+ 50: 7902 ld s2,32(sp)
+ 52: 69e2 ld s3,24(sp)
+ 54: 6a42 ld s4,16(sp)
+ 56: 6aa2 ld s5,8(sp)
+ 58: 6121 addi sp,sp,64
+ 5a: 8082 ret
+ 5c: 84ca mv s1,s2
+ 5e: b7d1 j 22 <readline+0x22>
+ return 0;
+ 60: 4501 li a0,0
+ if (p == buf) {
+ 62: ff2484e3 beq s1,s2,4a <readline+0x4a>
+ 66: b7c5 j 46 <readline+0x46>
+
+0000000000000068 <main>:
+
+int main(int argc, char *argv[])
+{
+ 68: 7161 addi sp,sp,-432
+ 6a: f706 sd ra,424(sp)
+ 6c: f322 sd s0,416(sp)
+ 6e: ef26 sd s1,408(sp)
+ 70: eb4a sd s2,400(sp)
+ 72: e74e sd s3,392(sp)
+ 74: 1b00 addi s0,sp,432
+ if (argc < 2) {
+ 76: 4785 li a5,1
+ 78: 0aa7d063 bge a5,a0,118 <main+0xb0>
+ 7c: 84aa mv s1,a0
+ 7e: 892e mv s2,a1
+ 80: 00858713 addi a4,a1,8
+ 84: ed040793 addi a5,s0,-304
+ 88: 0005059b sext.w a1,a0
+ 8c: ffe5061b addiw a2,a0,-2
+ 90: 02061693 slli a3,a2,0x20
+ 94: 01d6d613 srli a2,a3,0x1d
+ 98: ed840693 addi a3,s0,-296
+ 9c: 9636 add a2,a2,a3
+ }
+ char *argvs[MAXARG];
+ char buf[128];
+ int i;
+ for (i = 1; i < argc; i++) {
+ argvs[i - 1] = argv[i]; // argvs[0] = COMMAND
+ 9e: 6314 ld a3,0(a4)
+ a0: e394 sd a3,0(a5)
+ for (i = 1; i < argc; i++) {
+ a2: 0721 addi a4,a4,8
+ a4: 07a1 addi a5,a5,8
+ a6: fec79ce3 bne a5,a2,9e <main+0x36>
+ aa: fff5899b addiw s3,a1,-1
+ }
+ i--;
+ if (readline(0, buf, 128) == 0) { // if there is no input
+ ae: 08000613 li a2,128
+ b2: e5040593 addi a1,s0,-432
+ b6: 4501 li a0,0
+ b8: 00000097 auipc ra,0x0
+ bc: f48080e7 jalr -184(ra) # 0 <readline>
+ c0: c935 beqz a0,134 <main+0xcc>
+ printf("xargs: exec %s fail\n", argv[1]);
+ exit(0);
+ }
+ wait(0);
+ } else {
+ argvs[i] = buf;
+ c2: 00399593 slli a1,s3,0x3
+ c6: fd058793 addi a5,a1,-48
+ ca: 008785b3 add a1,a5,s0
+ ce: e5040793 addi a5,s0,-432
+ d2: f0f5b023 sd a5,-256(a1)
+ argvs[i + 1] = 0;
+ d6: 048e slli s1,s1,0x3
+ d8: fd048793 addi a5,s1,-48
+ dc: 008784b3 add s1,a5,s0
+ e0: f004b023 sd zero,-256(s1)
+ exec(argv[1], argvs);
+ printf("xargs: exec %s fail\n", argv[1]);
+ exit(0);
+ }
+ wait(0);
+ } while (readline(0, buf, 128) != 0);
+ e4: e5040493 addi s1,s0,-432
+ if (fork() == 0) {
+ e8: 00000097 auipc ra,0x0
+ ec: 37e080e7 jalr 894(ra) # 466 <fork>
+ f0: cd41 beqz a0,188 <main+0x120>
+ wait(0);
+ f2: 4501 li a0,0
+ f4: 00000097 auipc ra,0x0
+ f8: 384080e7 jalr 900(ra) # 478 <wait>
+ } while (readline(0, buf, 128) != 0);
+ fc: 08000613 li a2,128
+ 100: 85a6 mv a1,s1
+ 102: 4501 li a0,0
+ 104: 00000097 auipc ra,0x0
+ 108: efc080e7 jalr -260(ra) # 0 <readline>
+ 10c: fd71 bnez a0,e8 <main+0x80>
+ }
+ exit(0);
+ 10e: 4501 li a0,0
+ 110: 00000097 auipc ra,0x0
+ 114: 35e080e7 jalr 862(ra) # 46e <exit>
+ fprintf(2, "Usage: xargs COMMAND [INITIAL-ARGS]...\n");
+ 118: 00001597 auipc a1,0x1
+ 11c: 8c058593 addi a1,a1,-1856 # 9d8 <malloc+0xee>
+ 120: 4509 li a0,2
+ 122: 00000097 auipc ra,0x0
+ 126: 6e2080e7 jalr 1762(ra) # 804 <fprintf>
+ exit(-1);
+ 12a: 557d li a0,-1
+ 12c: 00000097 auipc ra,0x0
+ 130: 342080e7 jalr 834(ra) # 46e <exit>
+ argvs[i] = 0;
+ 134: 00399593 slli a1,s3,0x3
+ 138: fd058793 addi a5,a1,-48
+ 13c: 008785b3 add a1,a5,s0
+ 140: f005b023 sd zero,-256(a1)
+ if (fork() == 0) {
+ 144: 00000097 auipc ra,0x0
+ 148: 322080e7 jalr 802(ra) # 466 <fork>
+ 14c: e905 bnez a0,17c <main+0x114>
+ exec(argv[1], argvs);
+ 14e: ed040593 addi a1,s0,-304
+ 152: 00893503 ld a0,8(s2)
+ 156: 00000097 auipc ra,0x0
+ 15a: 35a080e7 jalr 858(ra) # 4b0 <exec>
+ printf("xargs: exec %s fail\n", argv[1]);
+ 15e: 00893583 ld a1,8(s2)
+ 162: 00001517 auipc a0,0x1
+ 166: 89e50513 addi a0,a0,-1890 # a00 <malloc+0x116>
+ 16a: 00000097 auipc ra,0x0
+ 16e: 6c8080e7 jalr 1736(ra) # 832 <printf>
+ exit(0);
+ 172: 4501 li a0,0
+ 174: 00000097 auipc ra,0x0
+ 178: 2fa080e7 jalr 762(ra) # 46e <exit>
+ wait(0);
+ 17c: 4501 li a0,0
+ 17e: 00000097 auipc ra,0x0
+ 182: 2fa080e7 jalr 762(ra) # 478 <wait>
+ 186: b761 j 10e <main+0xa6>
+ exec(argv[1], argvs);
+ 188: ed040593 addi a1,s0,-304
+ 18c: 00893503 ld a0,8(s2)
+ 190: 00000097 auipc ra,0x0
+ 194: 320080e7 jalr 800(ra) # 4b0 <exec>
+ printf("xargs: exec %s fail\n", argv[1]);
+ 198: 00893583 ld a1,8(s2)
+ 19c: 00001517 auipc a0,0x1
+ 1a0: 86450513 addi a0,a0,-1948 # a00 <malloc+0x116>
+ 1a4: 00000097 auipc ra,0x0
+ 1a8: 68e080e7 jalr 1678(ra) # 832 <printf>
+ exit(0);
+ 1ac: 4501 li a0,0
+ 1ae: 00000097 auipc ra,0x0
+ 1b2: 2c0080e7 jalr 704(ra) # 46e <exit>
+
+00000000000001b6 <strcpy>:
+#include "kernel/include/fcntl.h"
+#include "xv6-user/user.h"
+
+char*
+strcpy(char *s, const char *t)
+{
+ 1b6: 1141 addi sp,sp,-16
+ 1b8: e422 sd s0,8(sp)
+ 1ba: 0800 addi s0,sp,16
+ char *os;
+
+ os = s;
+ while((*s++ = *t++) != 0)
+ 1bc: 87aa mv a5,a0
+ 1be: 0585 addi a1,a1,1
+ 1c0: 0785 addi a5,a5,1
+ 1c2: fff5c703 lbu a4,-1(a1)
+ 1c6: fee78fa3 sb a4,-1(a5)
+ 1ca: fb75 bnez a4,1be <strcpy+0x8>
+ ;
+ return os;
+}
+ 1cc: 6422 ld s0,8(sp)
+ 1ce: 0141 addi sp,sp,16
+ 1d0: 8082 ret
+
+00000000000001d2 <strcat>:
+
+char*
+strcat(char *s, const char *t)
+{
+ 1d2: 1141 addi sp,sp,-16
+ 1d4: e422 sd s0,8(sp)
+ 1d6: 0800 addi s0,sp,16
+ char *os = s;
+ while(*s)
+ 1d8: 00054783 lbu a5,0(a0)
+ 1dc: c385 beqz a5,1fc <strcat+0x2a>
+ 1de: 87aa mv a5,a0
+ s++;
+ 1e0: 0785 addi a5,a5,1
+ while(*s)
+ 1e2: 0007c703 lbu a4,0(a5)
+ 1e6: ff6d bnez a4,1e0 <strcat+0xe>
+ while((*s++ = *t++))
+ 1e8: 0585 addi a1,a1,1
+ 1ea: 0785 addi a5,a5,1
+ 1ec: fff5c703 lbu a4,-1(a1)
+ 1f0: fee78fa3 sb a4,-1(a5)
+ 1f4: fb75 bnez a4,1e8 <strcat+0x16>
+ ;
+ return os;
+}
+ 1f6: 6422 ld s0,8(sp)
+ 1f8: 0141 addi sp,sp,16
+ 1fa: 8082 ret
+ while(*s)
+ 1fc: 87aa mv a5,a0
+ 1fe: b7ed j 1e8 <strcat+0x16>
+
+0000000000000200 <strcmp>:
+
+
+int
+strcmp(const char *p, const char *q)
+{
+ 200: 1141 addi sp,sp,-16
+ 202: e422 sd s0,8(sp)
+ 204: 0800 addi s0,sp,16
+ while(*p && *p == *q)
+ 206: 00054783 lbu a5,0(a0)
+ 20a: cb91 beqz a5,21e <strcmp+0x1e>
+ 20c: 0005c703 lbu a4,0(a1)
+ 210: 00f71763 bne a4,a5,21e <strcmp+0x1e>
+ p++, q++;
+ 214: 0505 addi a0,a0,1
+ 216: 0585 addi a1,a1,1
+ while(*p && *p == *q)
+ 218: 00054783 lbu a5,0(a0)
+ 21c: fbe5 bnez a5,20c <strcmp+0xc>
+ return (uchar)*p - (uchar)*q;
+ 21e: 0005c503 lbu a0,0(a1)
+}
+ 222: 40a7853b subw a0,a5,a0
+ 226: 6422 ld s0,8(sp)
+ 228: 0141 addi sp,sp,16
+ 22a: 8082 ret
+
+000000000000022c <strlen>:
+
+uint
+strlen(const char *s)
+{
+ 22c: 1141 addi sp,sp,-16
+ 22e: e422 sd s0,8(sp)
+ 230: 0800 addi s0,sp,16
+ int n;
+
+ for(n = 0; s[n]; n++)
+ 232: 00054783 lbu a5,0(a0)
+ 236: cf91 beqz a5,252 <strlen+0x26>
+ 238: 0505 addi a0,a0,1
+ 23a: 87aa mv a5,a0
+ 23c: 4685 li a3,1
+ 23e: 9e89 subw a3,a3,a0
+ 240: 00f6853b addw a0,a3,a5
+ 244: 0785 addi a5,a5,1
+ 246: fff7c703 lbu a4,-1(a5)
+ 24a: fb7d bnez a4,240 <strlen+0x14>
+ ;
+ return n;
+}
+ 24c: 6422 ld s0,8(sp)
+ 24e: 0141 addi sp,sp,16
+ 250: 8082 ret
+ for(n = 0; s[n]; n++)
+ 252: 4501 li a0,0
+ 254: bfe5 j 24c <strlen+0x20>
+
+0000000000000256 <memset>:
+
+void*
+memset(void *dst, int c, uint n)
+{
+ 256: 1141 addi sp,sp,-16
+ 258: e422 sd s0,8(sp)
+ 25a: 0800 addi s0,sp,16
+ char *cdst = (char *) dst;
+ int i;
+ for(i = 0; i < n; i++){
+ 25c: ca19 beqz a2,272 <memset+0x1c>
+ 25e: 87aa mv a5,a0
+ 260: 1602 slli a2,a2,0x20
+ 262: 9201 srli a2,a2,0x20
+ 264: 00a60733 add a4,a2,a0
+ cdst[i] = c;
+ 268: 00b78023 sb a1,0(a5)
+ for(i = 0; i < n; i++){
+ 26c: 0785 addi a5,a5,1
+ 26e: fee79de3 bne a5,a4,268 <memset+0x12>
+ }
+ return dst;
+}
+ 272: 6422 ld s0,8(sp)
+ 274: 0141 addi sp,sp,16
+ 276: 8082 ret
+
+0000000000000278 <strchr>:
+
+char*
+strchr(const char *s, char c)
+{
+ 278: 1141 addi sp,sp,-16
+ 27a: e422 sd s0,8(sp)
+ 27c: 0800 addi s0,sp,16
+ for(; *s; s++)
+ 27e: 00054783 lbu a5,0(a0)
+ 282: cb99 beqz a5,298 <strchr+0x20>
+ if(*s == c)
+ 284: 00f58763 beq a1,a5,292 <strchr+0x1a>
+ for(; *s; s++)
+ 288: 0505 addi a0,a0,1
+ 28a: 00054783 lbu a5,0(a0)
+ 28e: fbfd bnez a5,284 <strchr+0xc>
+ return (char*)s;
+ return 0;
+ 290: 4501 li a0,0
+}
+ 292: 6422 ld s0,8(sp)
+ 294: 0141 addi sp,sp,16
+ 296: 8082 ret
+ return 0;
+ 298: 4501 li a0,0
+ 29a: bfe5 j 292 <strchr+0x1a>
+
+000000000000029c <gets>:
+
+char*
+gets(char *buf, int max)
+{
+ 29c: 711d addi sp,sp,-96
+ 29e: ec86 sd ra,88(sp)
+ 2a0: e8a2 sd s0,80(sp)
+ 2a2: e4a6 sd s1,72(sp)
+ 2a4: e0ca sd s2,64(sp)
+ 2a6: fc4e sd s3,56(sp)
+ 2a8: f852 sd s4,48(sp)
+ 2aa: f456 sd s5,40(sp)
+ 2ac: f05a sd s6,32(sp)
+ 2ae: ec5e sd s7,24(sp)
+ 2b0: e862 sd s8,16(sp)
+ 2b2: 1080 addi s0,sp,96
+ 2b4: 8baa mv s7,a0
+ 2b6: 8a2e mv s4,a1
+ int i, cc;
+ char c;
+
+ for(i=0; i+1 < max; ){
+ 2b8: 892a mv s2,a0
+ 2ba: 4481 li s1,0
+ cc = read(0, &c, 1);
+ 2bc: faf40a93 addi s5,s0,-81
+ if(cc < 1)
+ break;
+ buf[i++] = c;
+ if(c == '\n' || c == '\r')
+ 2c0: 4b29 li s6,10
+ 2c2: 4c35 li s8,13
+ for(i=0; i+1 < max; ){
+ 2c4: 89a6 mv s3,s1
+ 2c6: 2485 addiw s1,s1,1
+ 2c8: 0344d763 bge s1,s4,2f6 <gets+0x5a>
+ cc = read(0, &c, 1);
+ 2cc: 4605 li a2,1
+ 2ce: 85d6 mv a1,s5
+ 2d0: 4501 li a0,0
+ 2d2: 00000097 auipc ra,0x0
+ 2d6: 1b8080e7 jalr 440(ra) # 48a <read>
+ if(cc < 1)
+ 2da: 00a05e63 blez a0,2f6 <gets+0x5a>
+ buf[i++] = c;
+ 2de: faf44783 lbu a5,-81(s0)
+ 2e2: 00f90023 sb a5,0(s2)
+ if(c == '\n' || c == '\r')
+ 2e6: 01678763 beq a5,s6,2f4 <gets+0x58>
+ 2ea: 0905 addi s2,s2,1
+ 2ec: fd879ce3 bne a5,s8,2c4 <gets+0x28>
+ for(i=0; i+1 < max; ){
+ 2f0: 89a6 mv s3,s1
+ 2f2: a011 j 2f6 <gets+0x5a>
+ 2f4: 89a6 mv s3,s1
+ break;
+ }
+ buf[i] = '\0';
+ 2f6: 99de add s3,s3,s7
+ 2f8: 00098023 sb zero,0(s3)
+ return buf;
+}
+ 2fc: 855e mv a0,s7
+ 2fe: 60e6 ld ra,88(sp)
+ 300: 6446 ld s0,80(sp)
+ 302: 64a6 ld s1,72(sp)
+ 304: 6906 ld s2,64(sp)
+ 306: 79e2 ld s3,56(sp)
+ 308: 7a42 ld s4,48(sp)
+ 30a: 7aa2 ld s5,40(sp)
+ 30c: 7b02 ld s6,32(sp)
+ 30e: 6be2 ld s7,24(sp)
+ 310: 6c42 ld s8,16(sp)
+ 312: 6125 addi sp,sp,96
+ 314: 8082 ret
+
+0000000000000316 <stat>:
+
+int
+stat(const char *n, struct stat *st)
+{
+ 316: 1101 addi sp,sp,-32
+ 318: ec06 sd ra,24(sp)
+ 31a: e822 sd s0,16(sp)
+ 31c: e426 sd s1,8(sp)
+ 31e: e04a sd s2,0(sp)
+ 320: 1000 addi s0,sp,32
+ 322: 892e mv s2,a1
+ int fd;
+ int r;
+
+ fd = open(n, O_RDONLY);
+ 324: 4581 li a1,0
+ 326: 00000097 auipc ra,0x0
+ 32a: 194080e7 jalr 404(ra) # 4ba <open>
+ if(fd < 0)
+ 32e: 02054563 bltz a0,358 <stat+0x42>
+ 332: 84aa mv s1,a0
+ return -1;
+ r = fstat(fd, st);
+ 334: 85ca mv a1,s2
+ 336: 00000097 auipc ra,0x0
+ 33a: 18e080e7 jalr 398(ra) # 4c4 <fstat>
+ 33e: 892a mv s2,a0
+ close(fd);
+ 340: 8526 mv a0,s1
+ 342: 00000097 auipc ra,0x0
+ 346: 15c080e7 jalr 348(ra) # 49e <close>
+ return r;
+}
+ 34a: 854a mv a0,s2
+ 34c: 60e2 ld ra,24(sp)
+ 34e: 6442 ld s0,16(sp)
+ 350: 64a2 ld s1,8(sp)
+ 352: 6902 ld s2,0(sp)
+ 354: 6105 addi sp,sp,32
+ 356: 8082 ret
+ return -1;
+ 358: 597d li s2,-1
+ 35a: bfc5 j 34a <stat+0x34>
+
+000000000000035c <atoi>:
+
+int
+atoi(const char *s)
+{
+ 35c: 1141 addi sp,sp,-16
+ 35e: e422 sd s0,8(sp)
+ 360: 0800 addi s0,sp,16
+ int n;
+ int neg = 1;
+ if (*s == '-') {
+ 362: 00054703 lbu a4,0(a0)
+ 366: 02d00793 li a5,45
+ int neg = 1;
+ 36a: 4585 li a1,1
+ if (*s == '-') {
+ 36c: 04f70363 beq a4,a5,3b2 <atoi+0x56>
+ s++;
+ neg = -1;
+ }
+ n = 0;
+ while('0' <= *s && *s <= '9')
+ 370: 00054703 lbu a4,0(a0)
+ 374: fd07079b addiw a5,a4,-48
+ 378: 0ff7f793 zext.b a5,a5
+ 37c: 46a5 li a3,9
+ 37e: 02f6ed63 bltu a3,a5,3b8 <atoi+0x5c>
+ n = 0;
+ 382: 4681 li a3,0
+ while('0' <= *s && *s <= '9')
+ 384: 4625 li a2,9
+ n = n*10 + *s++ - '0';
+ 386: 0505 addi a0,a0,1
+ 388: 0026979b slliw a5,a3,0x2
+ 38c: 9fb5 addw a5,a5,a3
+ 38e: 0017979b slliw a5,a5,0x1
+ 392: 9fb9 addw a5,a5,a4
+ 394: fd07869b addiw a3,a5,-48
+ while('0' <= *s && *s <= '9')
+ 398: 00054703 lbu a4,0(a0)
+ 39c: fd07079b addiw a5,a4,-48
+ 3a0: 0ff7f793 zext.b a5,a5
+ 3a4: fef671e3 bgeu a2,a5,386 <atoi+0x2a>
+ return n * neg;
+}
+ 3a8: 02d5853b mulw a0,a1,a3
+ 3ac: 6422 ld s0,8(sp)
+ 3ae: 0141 addi sp,sp,16
+ 3b0: 8082 ret
+ s++;
+ 3b2: 0505 addi a0,a0,1
+ neg = -1;
+ 3b4: 55fd li a1,-1
+ 3b6: bf6d j 370 <atoi+0x14>
+ n = 0;
+ 3b8: 4681 li a3,0
+ 3ba: b7fd j 3a8 <atoi+0x4c>
+
+00000000000003bc <memmove>:
+
+void*
+memmove(void *vdst, const void *vsrc, int n)
+{
+ 3bc: 1141 addi sp,sp,-16
+ 3be: e422 sd s0,8(sp)
+ 3c0: 0800 addi s0,sp,16
+ char *dst;
+ const char *src;
+
+ dst = vdst;
+ src = vsrc;
+ if (src > dst) {
+ 3c2: 02b57463 bgeu a0,a1,3ea <memmove+0x2e>
+ while(n-- > 0)
+ 3c6: 00c05f63 blez a2,3e4 <memmove+0x28>
+ 3ca: 1602 slli a2,a2,0x20
+ 3cc: 9201 srli a2,a2,0x20
+ 3ce: 00c507b3 add a5,a0,a2
+ dst = vdst;
+ 3d2: 872a mv a4,a0
+ *dst++ = *src++;
+ 3d4: 0585 addi a1,a1,1
+ 3d6: 0705 addi a4,a4,1
+ 3d8: fff5c683 lbu a3,-1(a1)
+ 3dc: fed70fa3 sb a3,-1(a4)
+ while(n-- > 0)
+ 3e0: fee79ae3 bne a5,a4,3d4 <memmove+0x18>
+ src += n;
+ while(n-- > 0)
+ *--dst = *--src;
+ }
+ return vdst;
+}
+ 3e4: 6422 ld s0,8(sp)
+ 3e6: 0141 addi sp,sp,16
+ 3e8: 8082 ret
+ dst += n;
+ 3ea: 00c50733 add a4,a0,a2
+ src += n;
+ 3ee: 95b2 add a1,a1,a2
+ while(n-- > 0)
+ 3f0: fec05ae3 blez a2,3e4 <memmove+0x28>
+ 3f4: fff6079b addiw a5,a2,-1
+ 3f8: 1782 slli a5,a5,0x20
+ 3fa: 9381 srli a5,a5,0x20
+ 3fc: fff7c793 not a5,a5
+ 400: 97ba add a5,a5,a4
+ *--dst = *--src;
+ 402: 15fd addi a1,a1,-1
+ 404: 177d addi a4,a4,-1
+ 406: 0005c683 lbu a3,0(a1)
+ 40a: 00d70023 sb a3,0(a4)
+ while(n-- > 0)
+ 40e: fee79ae3 bne a5,a4,402 <memmove+0x46>
+ 412: bfc9 j 3e4 <memmove+0x28>
+
+0000000000000414 <memcmp>:
+
+int
+memcmp(const void *s1, const void *s2, uint n)
+{
+ 414: 1141 addi sp,sp,-16
+ 416: e422 sd s0,8(sp)
+ 418: 0800 addi s0,sp,16
+ const char *p1 = s1, *p2 = s2;
+ while (n-- > 0) {
+ 41a: ca05 beqz a2,44a <memcmp+0x36>
+ 41c: fff6069b addiw a3,a2,-1
+ 420: 1682 slli a3,a3,0x20
+ 422: 9281 srli a3,a3,0x20
+ 424: 0685 addi a3,a3,1
+ 426: 96aa add a3,a3,a0
+ if (*p1 != *p2) {
+ 428: 00054783 lbu a5,0(a0)
+ 42c: 0005c703 lbu a4,0(a1)
+ 430: 00e79863 bne a5,a4,440 <memcmp+0x2c>
+ return *p1 - *p2;
+ }
+ p1++;
+ 434: 0505 addi a0,a0,1
+ p2++;
+ 436: 0585 addi a1,a1,1
+ while (n-- > 0) {
+ 438: fed518e3 bne a0,a3,428 <memcmp+0x14>
+ }
+ return 0;
+ 43c: 4501 li a0,0
+ 43e: a019 j 444 <memcmp+0x30>
+ return *p1 - *p2;
+ 440: 40e7853b subw a0,a5,a4
+}
+ 444: 6422 ld s0,8(sp)
+ 446: 0141 addi sp,sp,16
+ 448: 8082 ret
+ return 0;
+ 44a: 4501 li a0,0
+ 44c: bfe5 j 444 <memcmp+0x30>
+
+000000000000044e <memcpy>:
+
+void *
+memcpy(void *dst, const void *src, uint n)
+{
+ 44e: 1141 addi sp,sp,-16
+ 450: e406 sd ra,8(sp)
+ 452: e022 sd s0,0(sp)
+ 454: 0800 addi s0,sp,16
+ return memmove(dst, src, n);
+ 456: 00000097 auipc ra,0x0
+ 45a: f66080e7 jalr -154(ra) # 3bc <memmove>
+}
+ 45e: 60a2 ld ra,8(sp)
+ 460: 6402 ld s0,0(sp)
+ 462: 0141 addi sp,sp,16
+ 464: 8082 ret
+
+0000000000000466 <fork>:
+# generated by usys.pl - do not edit
+#include "kernel/include/sysnum.h"
+.global fork
+fork:
+ li a7, SYS_fork
+ 466: 4885 li a7,1
+ ecall
+ 468: 00000073 ecall
+ ret
+ 46c: 8082 ret
+
+000000000000046e <exit>:
+.global exit
+exit:
+ li a7, SYS_exit
+ 46e: 05d00893 li a7,93
+ ecall
+ 472: 00000073 ecall
+ ret
+ 476: 8082 ret
+
+0000000000000478 <wait>:
+.global wait
+wait:
+ li a7, SYS_wait
+ 478: 488d li a7,3
+ ecall
+ 47a: 00000073 ecall
+ ret
+ 47e: 8082 ret
+
+0000000000000480 <pipe>:
+.global pipe
+pipe:
+ li a7, SYS_pipe
+ 480: 03b00893 li a7,59
+ ecall
+ 484: 00000073 ecall
+ ret
+ 488: 8082 ret
+
+000000000000048a <read>:
+.global read
+read:
+ li a7, SYS_read
+ 48a: 03f00893 li a7,63
+ ecall
+ 48e: 00000073 ecall
+ ret
+ 492: 8082 ret
+
+0000000000000494 <write>:
+.global write
+write:
+ li a7, SYS_write
+ 494: 04000893 li a7,64
+ ecall
+ 498: 00000073 ecall
+ ret
+ 49c: 8082 ret
+
+000000000000049e <close>:
+.global close
+close:
+ li a7, SYS_close
+ 49e: 03900893 li a7,57
+ ecall
+ 4a2: 00000073 ecall
+ ret
+ 4a6: 8082 ret
+
+00000000000004a8 <kill>:
+.global kill
+kill:
+ li a7, SYS_kill
+ 4a8: 4899 li a7,6
+ ecall
+ 4aa: 00000073 ecall
+ ret
+ 4ae: 8082 ret
+
+00000000000004b0 <exec>:
+.global exec
+exec:
+ li a7, SYS_exec
+ 4b0: 0dd00893 li a7,221
+ ecall
+ 4b4: 00000073 ecall
+ ret
+ 4b8: 8082 ret
+
+00000000000004ba <open>:
+.global open
+open:
+ li a7, SYS_open
+ 4ba: 03800893 li a7,56
+ ecall
+ 4be: 00000073 ecall
+ ret
+ 4c2: 8082 ret
+
+00000000000004c4 <fstat>:
+.global fstat
+fstat:
+ li a7, SYS_fstat
+ 4c4: 05000893 li a7,80
+ ecall
+ 4c8: 00000073 ecall
+ ret
+ 4cc: 8082 ret
+
+00000000000004ce <mkdir>:
+.global mkdir
+mkdir:
+ li a7, SYS_mkdir
+ 4ce: 02200893 li a7,34
+ ecall
+ 4d2: 00000073 ecall
+ ret
+ 4d6: 8082 ret
+
+00000000000004d8 <chdir>:
+.global chdir
+chdir:
+ li a7, SYS_chdir
+ 4d8: 03100893 li a7,49
+ ecall
+ 4dc: 00000073 ecall
+ ret
+ 4e0: 8082 ret
+
+00000000000004e2 <dup>:
+.global dup
+dup:
+ li a7, SYS_dup
+ 4e2: 48dd li a7,23
+ ecall
+ 4e4: 00000073 ecall
+ ret
+ 4e8: 8082 ret
+
+00000000000004ea <getpid>:
+.global getpid
+getpid:
+ li a7, SYS_getpid
+ 4ea: 0ac00893 li a7,172
+ ecall
+ 4ee: 00000073 ecall
+ ret
+ 4f2: 8082 ret
+
+00000000000004f4 <sbrk>:
+.global sbrk
+sbrk:
+ li a7, SYS_sbrk
+ 4f4: 48b1 li a7,12
+ ecall
+ 4f6: 00000073 ecall
+ ret
+ 4fa: 8082 ret
+
+00000000000004fc <sleep>:
+.global sleep
+sleep:
+ li a7, SYS_sleep
+ 4fc: 48b5 li a7,13
+ ecall
+ 4fe: 00000073 ecall
+ ret
+ 502: 8082 ret
+
+0000000000000504 <uptime>:
+.global uptime
+uptime:
+ li a7, SYS_uptime
+ 504: 48b9 li a7,14
+ ecall
+ 506: 00000073 ecall
+ ret
+ 50a: 8082 ret
+
+000000000000050c <test_proc>:
+.global test_proc
+test_proc:
+ li a7, SYS_test_proc
+ 50c: 48d9 li a7,22
+ ecall
+ 50e: 00000073 ecall
+ ret
+ 512: 8082 ret
+
+0000000000000514 <dev>:
+.global dev
+dev:
+ li a7, SYS_dev
+ 514: 03200893 li a7,50
+ ecall
+ 518: 00000073 ecall
+ ret
+ 51c: 8082 ret
+
+000000000000051e <readdir>:
+.global readdir
+readdir:
+ li a7, SYS_readdir
+ 51e: 48ed li a7,27
+ ecall
+ 520: 00000073 ecall
+ ret
+ 524: 8082 ret
+
+0000000000000526 <getcwd>:
+.global getcwd
+getcwd:
+ li a7, SYS_getcwd
+ 526: 48c5 li a7,17
+ ecall
+ 528: 00000073 ecall
+ ret
+ 52c: 8082 ret
+
+000000000000052e <remove>:
+.global remove
+remove:
+ li a7, SYS_remove
+ 52e: 07500893 li a7,117
+ ecall
+ 532: 00000073 ecall
+ ret
+ 536: 8082 ret
+
+0000000000000538 <trace>:
+.global trace
+trace:
+ li a7, SYS_trace
+ 538: 48c9 li a7,18
+ ecall
+ 53a: 00000073 ecall
+ ret
+ 53e: 8082 ret
+
+0000000000000540 <sysinfo>:
+.global sysinfo
+sysinfo:
+ li a7, SYS_sysinfo
+ 540: 48cd li a7,19
+ ecall
+ 542: 00000073 ecall
+ ret
+ 546: 8082 ret
+
+0000000000000548 <rename>:
+.global rename
+rename:
+ li a7, SYS_rename
+ 548: 48e9 li a7,26
+ ecall
+ 54a: 00000073 ecall
+ ret
+ 54e: 8082 ret
+
+0000000000000550 <shutdown>:
+.global shutdown
+shutdown:
+ li a7, SYS_shutdown
+ 550: 0d200893 li a7,210
+ ecall
+ 554: 00000073 ecall
+ ret
+ 558: 8082 ret
+
+000000000000055a <putc>:
+
+static char digits[] = "0123456789ABCDEF";
+
+static void
+putc(int fd, char c)
+{
+ 55a: 1101 addi sp,sp,-32
+ 55c: ec06 sd ra,24(sp)
+ 55e: e822 sd s0,16(sp)
+ 560: 1000 addi s0,sp,32
+ 562: feb407a3 sb a1,-17(s0)
+ write(fd, &c, 1);
+ 566: 4605 li a2,1
+ 568: fef40593 addi a1,s0,-17
+ 56c: 00000097 auipc ra,0x0
+ 570: f28080e7 jalr -216(ra) # 494 <write>
+}
+ 574: 60e2 ld ra,24(sp)
+ 576: 6442 ld s0,16(sp)
+ 578: 6105 addi sp,sp,32
+ 57a: 8082 ret
+
+000000000000057c <printint>:
+
+static void
+printint(int fd, int xx, int base, int sgn)
+{
+ 57c: 7139 addi sp,sp,-64
+ 57e: fc06 sd ra,56(sp)
+ 580: f822 sd s0,48(sp)
+ 582: f426 sd s1,40(sp)
+ 584: f04a sd s2,32(sp)
+ 586: ec4e sd s3,24(sp)
+ 588: 0080 addi s0,sp,64
+ 58a: 84aa mv s1,a0
+ char buf[16];
+ int i, neg;
+ uint x;
+
+ neg = 0;
+ if(sgn && xx < 0){
+ 58c: c299 beqz a3,592 <printint+0x16>
+ 58e: 0805c863 bltz a1,61e <printint+0xa2>
+ neg = 1;
+ x = -xx;
+ } else {
+ x = xx;
+ 592: 2581 sext.w a1,a1
+ neg = 0;
+ 594: 4881 li a7,0
+ }
+
+ i = 0;
+ 596: fc040993 addi s3,s0,-64
+ neg = 0;
+ 59a: 86ce mv a3,s3
+ i = 0;
+ 59c: 4701 li a4,0
+ do{
+ buf[i++] = digits[x % base];
+ 59e: 2601 sext.w a2,a2
+ 5a0: 00000517 auipc a0,0x0
+ 5a4: 4d850513 addi a0,a0,1240 # a78 <digits>
+ 5a8: 883a mv a6,a4
+ 5aa: 2705 addiw a4,a4,1
+ 5ac: 02c5f7bb remuw a5,a1,a2
+ 5b0: 1782 slli a5,a5,0x20
+ 5b2: 9381 srli a5,a5,0x20
+ 5b4: 97aa add a5,a5,a0
+ 5b6: 0007c783 lbu a5,0(a5)
+ 5ba: 00f68023 sb a5,0(a3)
+ }while((x /= base) != 0);
+ 5be: 0005879b sext.w a5,a1
+ 5c2: 02c5d5bb divuw a1,a1,a2
+ 5c6: 0685 addi a3,a3,1
+ 5c8: fec7f0e3 bgeu a5,a2,5a8 <printint+0x2c>
+ if(neg)
+ 5cc: 00088c63 beqz a7,5e4 <printint+0x68>
+ buf[i++] = '-';
+ 5d0: fd070793 addi a5,a4,-48
+ 5d4: 00878733 add a4,a5,s0
+ 5d8: 02d00793 li a5,45
+ 5dc: fef70823 sb a5,-16(a4)
+ 5e0: 0028071b addiw a4,a6,2
+
+ while(--i >= 0)
+ 5e4: 02e05663 blez a4,610 <printint+0x94>
+ 5e8: fc040913 addi s2,s0,-64
+ 5ec: 993a add s2,s2,a4
+ 5ee: 19fd addi s3,s3,-1
+ 5f0: 99ba add s3,s3,a4
+ 5f2: 377d addiw a4,a4,-1
+ 5f4: 1702 slli a4,a4,0x20
+ 5f6: 9301 srli a4,a4,0x20
+ 5f8: 40e989b3 sub s3,s3,a4
+ putc(fd, buf[i]);
+ 5fc: fff94583 lbu a1,-1(s2)
+ 600: 8526 mv a0,s1
+ 602: 00000097 auipc ra,0x0
+ 606: f58080e7 jalr -168(ra) # 55a <putc>
+ while(--i >= 0)
+ 60a: 197d addi s2,s2,-1
+ 60c: ff3918e3 bne s2,s3,5fc <printint+0x80>
+}
+ 610: 70e2 ld ra,56(sp)
+ 612: 7442 ld s0,48(sp)
+ 614: 74a2 ld s1,40(sp)
+ 616: 7902 ld s2,32(sp)
+ 618: 69e2 ld s3,24(sp)
+ 61a: 6121 addi sp,sp,64
+ 61c: 8082 ret
+ x = -xx;
+ 61e: 40b005bb negw a1,a1
+ neg = 1;
+ 622: 4885 li a7,1
+ x = -xx;
+ 624: bf8d j 596 <printint+0x1a>
+
+0000000000000626 <vprintf>:
+}
+
+// Print to the given fd. Only understands %d, %x, %p, %s.
+void
+vprintf(int fd, const char *fmt, va_list ap)
+{
+ 626: 7119 addi sp,sp,-128
+ 628: fc86 sd ra,120(sp)
+ 62a: f8a2 sd s0,112(sp)
+ 62c: f4a6 sd s1,104(sp)
+ 62e: f0ca sd s2,96(sp)
+ 630: ecce sd s3,88(sp)
+ 632: e8d2 sd s4,80(sp)
+ 634: e4d6 sd s5,72(sp)
+ 636: e0da sd s6,64(sp)
+ 638: fc5e sd s7,56(sp)
+ 63a: f862 sd s8,48(sp)
+ 63c: f466 sd s9,40(sp)
+ 63e: f06a sd s10,32(sp)
+ 640: ec6e sd s11,24(sp)
+ 642: 0100 addi s0,sp,128
+ char *s;
+ int c, i, state;
+
+ state = 0;
+ for(i = 0; fmt[i]; i++){
+ 644: 0005c903 lbu s2,0(a1)
+ 648: 18090f63 beqz s2,7e6 <vprintf+0x1c0>
+ 64c: 8aaa mv s5,a0
+ 64e: 8b32 mv s6,a2
+ 650: 00158493 addi s1,a1,1
+ state = 0;
+ 654: 4981 li s3,0
+ if(c == '%'){
+ state = '%';
+ } else {
+ putc(fd, c);
+ }
+ } else if(state == '%'){
+ 656: 02500a13 li s4,37
+ 65a: 4c55 li s8,21
+ 65c: 00000c97 auipc s9,0x0
+ 660: 3c4c8c93 addi s9,s9,964 # a20 <malloc+0x136>
+ printptr(fd, va_arg(ap, uint64));
+ } else if(c == 's'){
+ s = va_arg(ap, char*);
+ if(s == 0)
+ s = "(null)";
+ while(*s != 0){
+ 664: 02800d93 li s11,40
+ putc(fd, 'x');
+ 668: 4d41 li s10,16
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 66a: 00000b97 auipc s7,0x0
+ 66e: 40eb8b93 addi s7,s7,1038 # a78 <digits>
+ 672: a839 j 690 <vprintf+0x6a>
+ putc(fd, c);
+ 674: 85ca mv a1,s2
+ 676: 8556 mv a0,s5
+ 678: 00000097 auipc ra,0x0
+ 67c: ee2080e7 jalr -286(ra) # 55a <putc>
+ 680: a019 j 686 <vprintf+0x60>
+ } else if(state == '%'){
+ 682: 01498d63 beq s3,s4,69c <vprintf+0x76>
+ for(i = 0; fmt[i]; i++){
+ 686: 0485 addi s1,s1,1
+ 688: fff4c903 lbu s2,-1(s1)
+ 68c: 14090d63 beqz s2,7e6 <vprintf+0x1c0>
+ if(state == 0){
+ 690: fe0999e3 bnez s3,682 <vprintf+0x5c>
+ if(c == '%'){
+ 694: ff4910e3 bne s2,s4,674 <vprintf+0x4e>
+ state = '%';
+ 698: 89d2 mv s3,s4
+ 69a: b7f5 j 686 <vprintf+0x60>
+ if(c == 'd'){
+ 69c: 11490c63 beq s2,s4,7b4 <vprintf+0x18e>
+ 6a0: f9d9079b addiw a5,s2,-99
+ 6a4: 0ff7f793 zext.b a5,a5
+ 6a8: 10fc6e63 bltu s8,a5,7c4 <vprintf+0x19e>
+ 6ac: f9d9079b addiw a5,s2,-99
+ 6b0: 0ff7f713 zext.b a4,a5
+ 6b4: 10ec6863 bltu s8,a4,7c4 <vprintf+0x19e>
+ 6b8: 00271793 slli a5,a4,0x2
+ 6bc: 97e6 add a5,a5,s9
+ 6be: 439c lw a5,0(a5)
+ 6c0: 97e6 add a5,a5,s9
+ 6c2: 8782 jr a5
+ printint(fd, va_arg(ap, int), 10, 1);
+ 6c4: 008b0913 addi s2,s6,8
+ 6c8: 4685 li a3,1
+ 6ca: 4629 li a2,10
+ 6cc: 000b2583 lw a1,0(s6)
+ 6d0: 8556 mv a0,s5
+ 6d2: 00000097 auipc ra,0x0
+ 6d6: eaa080e7 jalr -342(ra) # 57c <printint>
+ 6da: 8b4a mv s6,s2
+ } else {
+ // Unknown % sequence. Print it to draw attention.
+ putc(fd, '%');
+ putc(fd, c);
+ }
+ state = 0;
+ 6dc: 4981 li s3,0
+ 6de: b765 j 686 <vprintf+0x60>
+ printint(fd, va_arg(ap, uint64), 10, 0);
+ 6e0: 008b0913 addi s2,s6,8
+ 6e4: 4681 li a3,0
+ 6e6: 4629 li a2,10
+ 6e8: 000b2583 lw a1,0(s6)
+ 6ec: 8556 mv a0,s5
+ 6ee: 00000097 auipc ra,0x0
+ 6f2: e8e080e7 jalr -370(ra) # 57c <printint>
+ 6f6: 8b4a mv s6,s2
+ state = 0;
+ 6f8: 4981 li s3,0
+ 6fa: b771 j 686 <vprintf+0x60>
+ printint(fd, va_arg(ap, int), 16, 0);
+ 6fc: 008b0913 addi s2,s6,8
+ 700: 4681 li a3,0
+ 702: 866a mv a2,s10
+ 704: 000b2583 lw a1,0(s6)
+ 708: 8556 mv a0,s5
+ 70a: 00000097 auipc ra,0x0
+ 70e: e72080e7 jalr -398(ra) # 57c <printint>
+ 712: 8b4a mv s6,s2
+ state = 0;
+ 714: 4981 li s3,0
+ 716: bf85 j 686 <vprintf+0x60>
+ printptr(fd, va_arg(ap, uint64));
+ 718: 008b0793 addi a5,s6,8
+ 71c: f8f43423 sd a5,-120(s0)
+ 720: 000b3983 ld s3,0(s6)
+ putc(fd, '0');
+ 724: 03000593 li a1,48
+ 728: 8556 mv a0,s5
+ 72a: 00000097 auipc ra,0x0
+ 72e: e30080e7 jalr -464(ra) # 55a <putc>
+ putc(fd, 'x');
+ 732: 07800593 li a1,120
+ 736: 8556 mv a0,s5
+ 738: 00000097 auipc ra,0x0
+ 73c: e22080e7 jalr -478(ra) # 55a <putc>
+ 740: 896a mv s2,s10
+ putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
+ 742: 03c9d793 srli a5,s3,0x3c
+ 746: 97de add a5,a5,s7
+ 748: 0007c583 lbu a1,0(a5)
+ 74c: 8556 mv a0,s5
+ 74e: 00000097 auipc ra,0x0
+ 752: e0c080e7 jalr -500(ra) # 55a <putc>
+ for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
+ 756: 0992 slli s3,s3,0x4
+ 758: 397d addiw s2,s2,-1
+ 75a: fe0914e3 bnez s2,742 <vprintf+0x11c>
+ printptr(fd, va_arg(ap, uint64));
+ 75e: f8843b03 ld s6,-120(s0)
+ state = 0;
+ 762: 4981 li s3,0
+ 764: b70d j 686 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 766: 008b0913 addi s2,s6,8
+ 76a: 000b3983 ld s3,0(s6)
+ if(s == 0)
+ 76e: 02098163 beqz s3,790 <vprintf+0x16a>
+ while(*s != 0){
+ 772: 0009c583 lbu a1,0(s3)
+ 776: c5ad beqz a1,7e0 <vprintf+0x1ba>
+ putc(fd, *s);
+ 778: 8556 mv a0,s5
+ 77a: 00000097 auipc ra,0x0
+ 77e: de0080e7 jalr -544(ra) # 55a <putc>
+ s++;
+ 782: 0985 addi s3,s3,1
+ while(*s != 0){
+ 784: 0009c583 lbu a1,0(s3)
+ 788: f9e5 bnez a1,778 <vprintf+0x152>
+ s = va_arg(ap, char*);
+ 78a: 8b4a mv s6,s2
+ state = 0;
+ 78c: 4981 li s3,0
+ 78e: bde5 j 686 <vprintf+0x60>
+ s = "(null)";
+ 790: 00000997 auipc s3,0x0
+ 794: 28898993 addi s3,s3,648 # a18 <malloc+0x12e>
+ while(*s != 0){
+ 798: 85ee mv a1,s11
+ 79a: bff9 j 778 <vprintf+0x152>
+ putc(fd, va_arg(ap, uint));
+ 79c: 008b0913 addi s2,s6,8
+ 7a0: 000b4583 lbu a1,0(s6)
+ 7a4: 8556 mv a0,s5
+ 7a6: 00000097 auipc ra,0x0
+ 7aa: db4080e7 jalr -588(ra) # 55a <putc>
+ 7ae: 8b4a mv s6,s2
+ state = 0;
+ 7b0: 4981 li s3,0
+ 7b2: bdd1 j 686 <vprintf+0x60>
+ putc(fd, c);
+ 7b4: 85d2 mv a1,s4
+ 7b6: 8556 mv a0,s5
+ 7b8: 00000097 auipc ra,0x0
+ 7bc: da2080e7 jalr -606(ra) # 55a <putc>
+ state = 0;
+ 7c0: 4981 li s3,0
+ 7c2: b5d1 j 686 <vprintf+0x60>
+ putc(fd, '%');
+ 7c4: 85d2 mv a1,s4
+ 7c6: 8556 mv a0,s5
+ 7c8: 00000097 auipc ra,0x0
+ 7cc: d92080e7 jalr -622(ra) # 55a <putc>
+ putc(fd, c);
+ 7d0: 85ca mv a1,s2
+ 7d2: 8556 mv a0,s5
+ 7d4: 00000097 auipc ra,0x0
+ 7d8: d86080e7 jalr -634(ra) # 55a <putc>
+ state = 0;
+ 7dc: 4981 li s3,0
+ 7de: b565 j 686 <vprintf+0x60>
+ s = va_arg(ap, char*);
+ 7e0: 8b4a mv s6,s2
+ state = 0;
+ 7e2: 4981 li s3,0
+ 7e4: b54d j 686 <vprintf+0x60>
+ }
+ }
+}
+ 7e6: 70e6 ld ra,120(sp)
+ 7e8: 7446 ld s0,112(sp)
+ 7ea: 74a6 ld s1,104(sp)
+ 7ec: 7906 ld s2,96(sp)
+ 7ee: 69e6 ld s3,88(sp)
+ 7f0: 6a46 ld s4,80(sp)
+ 7f2: 6aa6 ld s5,72(sp)
+ 7f4: 6b06 ld s6,64(sp)
+ 7f6: 7be2 ld s7,56(sp)
+ 7f8: 7c42 ld s8,48(sp)
+ 7fa: 7ca2 ld s9,40(sp)
+ 7fc: 7d02 ld s10,32(sp)
+ 7fe: 6de2 ld s11,24(sp)
+ 800: 6109 addi sp,sp,128
+ 802: 8082 ret
+
+0000000000000804 <fprintf>:
+
+void
+fprintf(int fd, const char *fmt, ...)
+{
+ 804: 715d addi sp,sp,-80
+ 806: ec06 sd ra,24(sp)
+ 808: e822 sd s0,16(sp)
+ 80a: 1000 addi s0,sp,32
+ 80c: e010 sd a2,0(s0)
+ 80e: e414 sd a3,8(s0)
+ 810: e818 sd a4,16(s0)
+ 812: ec1c sd a5,24(s0)
+ 814: 03043023 sd a6,32(s0)
+ 818: 03143423 sd a7,40(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 81c: 8622 mv a2,s0
+ 81e: fe843423 sd s0,-24(s0)
+ vprintf(fd, fmt, ap);
+ 822: 00000097 auipc ra,0x0
+ 826: e04080e7 jalr -508(ra) # 626 <vprintf>
+}
+ 82a: 60e2 ld ra,24(sp)
+ 82c: 6442 ld s0,16(sp)
+ 82e: 6161 addi sp,sp,80
+ 830: 8082 ret
+
+0000000000000832 <printf>:
+
+void
+printf(const char *fmt, ...)
+{
+ 832: 711d addi sp,sp,-96
+ 834: ec06 sd ra,24(sp)
+ 836: e822 sd s0,16(sp)
+ 838: 1000 addi s0,sp,32
+ 83a: e40c sd a1,8(s0)
+ 83c: e810 sd a2,16(s0)
+ 83e: ec14 sd a3,24(s0)
+ 840: f018 sd a4,32(s0)
+ 842: f41c sd a5,40(s0)
+ 844: 03043823 sd a6,48(s0)
+ 848: 03143c23 sd a7,56(s0)
+ va_list ap;
+
+ va_start(ap, fmt);
+ 84c: 00840613 addi a2,s0,8
+ 850: fec43423 sd a2,-24(s0)
+ vprintf(1, fmt, ap);
+ 854: 85aa mv a1,a0
+ 856: 4505 li a0,1
+ 858: 00000097 auipc ra,0x0
+ 85c: dce080e7 jalr -562(ra) # 626 <vprintf>
+}
+ 860: 60e2 ld ra,24(sp)
+ 862: 6442 ld s0,16(sp)
+ 864: 6125 addi sp,sp,96
+ 866: 8082 ret
+
+0000000000000868 <free>:
+static Header base;
+static Header *freep;
+
+void
+free(void *ap)
+{
+ 868: 1141 addi sp,sp,-16
+ 86a: e422 sd s0,8(sp)
+ 86c: 0800 addi s0,sp,16
+ Header *bp, *p;
+
+ bp = (Header*)ap - 1;
+ 86e: ff050693 addi a3,a0,-16
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 872: 00000797 auipc a5,0x0
+ 876: 21e7b783 ld a5,542(a5) # a90 <freep>
+ 87a: a02d j 8a4 <free+0x3c>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ break;
+ if(bp + bp->s.size == p->s.ptr){
+ bp->s.size += p->s.ptr->s.size;
+ 87c: 4618 lw a4,8(a2)
+ 87e: 9f2d addw a4,a4,a1
+ 880: fee52c23 sw a4,-8(a0)
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 884: 6398 ld a4,0(a5)
+ 886: 6310 ld a2,0(a4)
+ 888: a83d j 8c6 <free+0x5e>
+ } else
+ bp->s.ptr = p->s.ptr;
+ if(p + p->s.size == bp){
+ p->s.size += bp->s.size;
+ 88a: ff852703 lw a4,-8(a0)
+ 88e: 9f31 addw a4,a4,a2
+ 890: c798 sw a4,8(a5)
+ p->s.ptr = bp->s.ptr;
+ 892: ff053683 ld a3,-16(a0)
+ 896: a091 j 8da <free+0x72>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 898: 6398 ld a4,0(a5)
+ 89a: 00e7e463 bltu a5,a4,8a2 <free+0x3a>
+ 89e: 00e6ea63 bltu a3,a4,8b2 <free+0x4a>
+{
+ 8a2: 87ba mv a5,a4
+ for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+ 8a4: fed7fae3 bgeu a5,a3,898 <free+0x30>
+ 8a8: 6398 ld a4,0(a5)
+ 8aa: 00e6e463 bltu a3,a4,8b2 <free+0x4a>
+ if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+ 8ae: fee7eae3 bltu a5,a4,8a2 <free+0x3a>
+ if(bp + bp->s.size == p->s.ptr){
+ 8b2: ff852583 lw a1,-8(a0)
+ 8b6: 6390 ld a2,0(a5)
+ 8b8: 02059813 slli a6,a1,0x20
+ 8bc: 01c85713 srli a4,a6,0x1c
+ 8c0: 9736 add a4,a4,a3
+ 8c2: fae60de3 beq a2,a4,87c <free+0x14>
+ bp->s.ptr = p->s.ptr->s.ptr;
+ 8c6: fec53823 sd a2,-16(a0)
+ if(p + p->s.size == bp){
+ 8ca: 4790 lw a2,8(a5)
+ 8cc: 02061593 slli a1,a2,0x20
+ 8d0: 01c5d713 srli a4,a1,0x1c
+ 8d4: 973e add a4,a4,a5
+ 8d6: fae68ae3 beq a3,a4,88a <free+0x22>
+ p->s.ptr = bp->s.ptr;
+ 8da: e394 sd a3,0(a5)
+ } else
+ p->s.ptr = bp;
+ freep = p;
+ 8dc: 00000717 auipc a4,0x0
+ 8e0: 1af73a23 sd a5,436(a4) # a90 <freep>
+}
+ 8e4: 6422 ld s0,8(sp)
+ 8e6: 0141 addi sp,sp,16
+ 8e8: 8082 ret
+
+00000000000008ea <malloc>:
+ return freep;
+}
+
+void*
+malloc(uint nbytes)
+{
+ 8ea: 7139 addi sp,sp,-64
+ 8ec: fc06 sd ra,56(sp)
+ 8ee: f822 sd s0,48(sp)
+ 8f0: f426 sd s1,40(sp)
+ 8f2: f04a sd s2,32(sp)
+ 8f4: ec4e sd s3,24(sp)
+ 8f6: e852 sd s4,16(sp)
+ 8f8: e456 sd s5,8(sp)
+ 8fa: e05a sd s6,0(sp)
+ 8fc: 0080 addi s0,sp,64
+ Header *p, *prevp;
+ uint nunits;
+
+ nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
+ 8fe: 02051493 slli s1,a0,0x20
+ 902: 9081 srli s1,s1,0x20
+ 904: 04bd addi s1,s1,15
+ 906: 8091 srli s1,s1,0x4
+ 908: 00148a1b addiw s4,s1,1
+ 90c: 0485 addi s1,s1,1
+ if((prevp = freep) == 0){
+ 90e: 00000517 auipc a0,0x0
+ 912: 18253503 ld a0,386(a0) # a90 <freep>
+ 916: c515 beqz a0,942 <malloc+0x58>
+ base.s.ptr = freep = prevp = &base;
+ base.s.size = 0;
+ }
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 918: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 91a: 4798 lw a4,8(a5)
+ 91c: 04977163 bgeu a4,s1,95e <malloc+0x74>
+ 920: 89d2 mv s3,s4
+ 922: 000a071b sext.w a4,s4
+ 926: 6685 lui a3,0x1
+ 928: 00d77363 bgeu a4,a3,92e <malloc+0x44>
+ 92c: 6985 lui s3,0x1
+ 92e: 00098b1b sext.w s6,s3
+ p = sbrk(nu * sizeof(Header));
+ 932: 0049999b slliw s3,s3,0x4
+ p->s.size = nunits;
+ }
+ freep = prevp;
+ return (void*)(p + 1);
+ }
+ if(p == freep)
+ 936: 00000917 auipc s2,0x0
+ 93a: 15a90913 addi s2,s2,346 # a90 <freep>
+ if(p == (char*)-1)
+ 93e: 5afd li s5,-1
+ 940: a8a5 j 9b8 <malloc+0xce>
+ base.s.ptr = freep = prevp = &base;
+ 942: 00000797 auipc a5,0x0
+ 946: 14e78793 addi a5,a5,334 # a90 <freep>
+ 94a: 00000717 auipc a4,0x0
+ 94e: 14e70713 addi a4,a4,334 # a98 <base>
+ 952: e398 sd a4,0(a5)
+ 954: e798 sd a4,8(a5)
+ base.s.size = 0;
+ 956: 0007a823 sw zero,16(a5)
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 95a: 87ba mv a5,a4
+ 95c: b7d1 j 920 <malloc+0x36>
+ if(p->s.size == nunits)
+ 95e: 02e48c63 beq s1,a4,996 <malloc+0xac>
+ p->s.size -= nunits;
+ 962: 4147073b subw a4,a4,s4
+ 966: c798 sw a4,8(a5)
+ p += p->s.size;
+ 968: 02071693 slli a3,a4,0x20
+ 96c: 01c6d713 srli a4,a3,0x1c
+ 970: 97ba add a5,a5,a4
+ p->s.size = nunits;
+ 972: 0147a423 sw s4,8(a5)
+ freep = prevp;
+ 976: 00000717 auipc a4,0x0
+ 97a: 10a73d23 sd a0,282(a4) # a90 <freep>
+ return (void*)(p + 1);
+ 97e: 01078513 addi a0,a5,16
+ if((p = morecore(nunits)) == 0)
+ return 0;
+ }
+}
+ 982: 70e2 ld ra,56(sp)
+ 984: 7442 ld s0,48(sp)
+ 986: 74a2 ld s1,40(sp)
+ 988: 7902 ld s2,32(sp)
+ 98a: 69e2 ld s3,24(sp)
+ 98c: 6a42 ld s4,16(sp)
+ 98e: 6aa2 ld s5,8(sp)
+ 990: 6b02 ld s6,0(sp)
+ 992: 6121 addi sp,sp,64
+ 994: 8082 ret
+ prevp->s.ptr = p->s.ptr;
+ 996: 6398 ld a4,0(a5)
+ 998: e118 sd a4,0(a0)
+ 99a: bff1 j 976 <malloc+0x8c>
+ hp->s.size = nu;
+ 99c: 01652423 sw s6,8(a0)
+ free((void*)(hp + 1));
+ 9a0: 0541 addi a0,a0,16
+ 9a2: 00000097 auipc ra,0x0
+ 9a6: ec6080e7 jalr -314(ra) # 868 <free>
+ return freep;
+ 9aa: 00093503 ld a0,0(s2)
+ if((p = morecore(nunits)) == 0)
+ 9ae: d971 beqz a0,982 <malloc+0x98>
+ for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
+ 9b0: 611c ld a5,0(a0)
+ if(p->s.size >= nunits){
+ 9b2: 4798 lw a4,8(a5)
+ 9b4: fa9775e3 bgeu a4,s1,95e <malloc+0x74>
+ if(p == freep)
+ 9b8: 00093703 ld a4,0(s2)
+ 9bc: 853e mv a0,a5
+ 9be: fef719e3 bne a4,a5,9b0 <malloc+0xc6>
+ p = sbrk(nu * sizeof(Header));
+ 9c2: 854e mv a0,s3
+ 9c4: 00000097 auipc ra,0x0
+ 9c8: b30080e7 jalr -1232(ra) # 4f4 <sbrk>
+ if(p == (char*)-1)
+ 9cc: fd5518e3 bne a0,s5,99c <malloc+0xb2>
+ return 0;
+ 9d0: 4501 li a0,0
+ 9d2: bf45 j 982 <malloc+0x98>
diff --git a/xv6-user/xargs.c b/xv6-user/xargs.c
new file mode 100644
index 0000000000000000000000000000000000000000..4396b13b6ef8b6d3696a86fa2c1b2d7821f3e73e
--- /dev/null
+++ b/xv6-user/xargs.c
@@ -0,0 +1,62 @@
+#include "kernel/include/types.h"
+#include "kernel/include/param.h"
+#include "xv6-user/user.h"
+
+/**
+ * len: include the 0 in the end.
+ * return: the number of bytes that read successfully (0 in the end is not included)
+ */
+int readline(int fd, char *buf, int len)
+{
+ char *p = buf;
+ while (read(fd, p, 1) != 0 && p < buf + len) {
+ if (*p == '\n') {
+ if (p == buf) { // ignore empty line
+ continue;
+ }
+ *p = '\0';
+ break;
+ }
+ p++;
+ }
+ if (p == buf) {
+ return 0;
+ }
+ return p - buf;
+}
+
+int main(int argc, char *argv[])
+{
+ if (argc < 2) {
+ fprintf(2, "Usage: xargs COMMAND [INITIAL-ARGS]...\n");
+ exit(-1);
+ }
+ char *argvs[MAXARG];
+ char buf[128];
+ int i;
+ for (i = 1; i < argc; i++) {
+ argvs[i - 1] = argv[i]; // argvs[0] = COMMAND
+ }
+ i--;
+ if (readline(0, buf, 128) == 0) { // if there is no input
+ argvs[i] = 0;
+ if (fork() == 0) {
+ exec(argv[1], argvs);
+ printf("xargs: exec %s fail\n", argv[1]);
+ exit(0);
+ }
+ wait(0);
+ } else {
+ argvs[i] = buf;
+ argvs[i + 1] = 0;
+ do {
+ if (fork() == 0) {
+ exec(argv[1], argvs);
+ printf("xargs: exec %s fail\n", argv[1]);
+ exit(0);
+ }
+ wait(0);
+ } while (readline(0, buf, 128) != 0);
+ }
+ exit(0);
+}
diff --git a/xv6-user/xargs.d b/xv6-user/xargs.d
new file mode 100644
index 0000000000000000000000000000000000000000..0c873ade25280d22cf0ab20c05ae6745264fc749
--- /dev/null
+++ b/xv6-user/xargs.d
@@ -0,0 +1,3 @@
+xv6-user/xargs.o: xv6-user/xargs.c kernel/include/types.h \
+ kernel/include/param.h xv6-user/user.h kernel/include/stat.h \
+ kernel/include/fcntl.h
diff --git a/xv6-user/xargs.o b/xv6-user/xargs.o
new file mode 100644
index 0000000000000000000000000000000000000000..15d0853be426642397bdb55370ec4ccafa10fb63
Binary files /dev/null and b/xv6-user/xargs.o differ
diff --git a/xv6-user/xargs.sym b/xv6-user/xargs.sym
new file mode 100644
index 0000000000000000000000000000000000000000..1de8df8d1081f540e96015ae869c391ab07bc846
--- /dev/null
+++ b/xv6-user/xargs.sym
@@ -0,0 +1,77 @@
+0000000000000000 .text
+00000000000009d8 .rodata
+0000000000000a90 .bss
+0000000000000000 .comment
+0000000000000000 .riscv.attributes
+0000000000000000 .debug_aranges
+0000000000000000 .debug_info
+0000000000000000 .debug_abbrev
+0000000000000000 .debug_line
+0000000000000000 .debug_frame
+0000000000000000 .debug_str
+0000000000000000 .debug_line_str
+0000000000000000 .debug_loclists
+0000000000000000 .debug_rnglists
+0000000000000000 xargs.c
+0000000000000000 ulib.c
+0000000000000000 usys.o
+0000000000000000 printf.c
+000000000000055a putc
+000000000000057c printint
+0000000000000a78 digits
+0000000000000000 umalloc.c
+0000000000000a90 freep
+0000000000000a98 base
+00000000000001b6 strcpy
+0000000000000832 printf
+0000000000001289 __global_pointer$
+0000000000000514 dev
+00000000000003bc memmove
+0000000000000538 trace
+000000000000029c gets
+0000000000000a89 __SDATA_BEGIN__
+00000000000004ea getpid
+000000000000044e memcpy
+0000000000000000 readline
+00000000000008ea malloc
+000000000000052e remove
+00000000000004fc sleep
+0000000000000540 sysinfo
+000000000000051e readdir
+0000000000000480 pipe
+0000000000000548 rename
+0000000000000494 write
+00000000000004c4 fstat
+0000000000000804 fprintf
+00000000000004a8 kill
+00000000000001d2 strcat
+0000000000000626 vprintf
+00000000000004d8 chdir
+00000000000004b0 exec
+0000000000000478 wait
+000000000000048a read
+0000000000000414 memcmp
+0000000000000466 fork
+0000000000000aa8 __BSS_END__
+00000000000004f4 sbrk
+000000000000050c test_proc
+0000000000000504 uptime
+0000000000000a89 __bss_start
+0000000000000256 memset
+0000000000000068 main
+0000000000000200 strcmp
+0000000000000550 shutdown
+00000000000004e2 dup
+0000000000000526 getcwd
+0000000000000a89 __DATA_BEGIN__
+0000000000000316 stat
+0000000000000a89 _edata
+0000000000000aa8 _end
+000000000000046e exit
+000000000000035c atoi
+000000000000022c strlen
+00000000000004ba open
+0000000000000278 strchr
+00000000000004ce mkdir
+000000000000049e close
+0000000000000868 free
diff --git a/xv6-user/xargstest.sh b/xv6-user/xargstest.sh
new file mode 100644
index 0000000000000000000000000000000000000000..4362589c83455cc3e9e8e72dcbaacf7511e2cc16
--- /dev/null
+++ b/xv6-user/xargstest.sh
@@ -0,0 +1,6 @@
+mkdir a
+echo hello > a/b
+mkdir c
+echo hello > c/b
+echo hello > b
+find . b | xargs grep hello
diff --git a/xv6-user/xv6-riscv-license b/xv6-user/xv6-riscv-license
new file mode 100644
index 0000000000000000000000000000000000000000..bd4fb5bfcb80957d5c88e2b14a3df63d3510598c
--- /dev/null
+++ b/xv6-user/xv6-riscv-license
@@ -0,0 +1,23 @@
+The xv6 software is:
+
+Copyright (c) 2006-2019 Frans Kaashoek, Robert Morris, Russ Cox,
+ Massachusetts Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/xv6-user/zombie.c b/xv6-user/zombie.c
new file mode 100644
index 0000000000000000000000000000000000000000..abdb693613798ce0b53f87d4bdf00d224d7370f8
--- /dev/null
+++ b/xv6-user/zombie.c
@@ -0,0 +1,14 @@
+// Create a zombie process that
+// must be reparented at exit.
+
+#include "kernel/include/types.h"
+#include "kernel/include/stat.h"
+#include "xv6-user/user.h"
+
+int
+main(void)
+{
+ if(fork() > 0)
+ sleep(5); // Let child exit before parent.
+ exit(0);
+}